1 /* Support for the generic parts of most COFF variants, for BFD.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004
4 Free Software Foundation, Inc.
5 Written by Cygnus Support.
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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
24 Most of this hacked by Steve Chamberlain,
32 BFD supports a number of different flavours of coff format.
33 The major differences between formats are the sizes and
34 alignments of fields in structures on disk, and the occasional
37 Coff in all its varieties is implemented with a few common
38 files and a number of implementation specific files. For
39 example, The 88k bcs coff format is implemented in the file
40 @file{coff-m88k.c}. This file @code{#include}s
41 @file{coff/m88k.h} which defines the external structure of the
42 coff format for the 88k, and @file{coff/internal.h} which
43 defines the internal structure. @file{coff-m88k.c} also
44 defines the relocations used by the 88k format
47 The Intel i960 processor version of coff is implemented in
48 @file{coff-i960.c}. This file has the same structure as
49 @file{coff-m88k.c}, except that it includes @file{coff/i960.h}
50 rather than @file{coff-m88k.h}.
53 Porting to a new version of coff
55 The recommended method is to select from the existing
56 implementations the version of coff which is most like the one
57 you want to use. For example, we'll say that i386 coff is
58 the one you select, and that your coff flavour is called foo.
59 Copy @file{i386coff.c} to @file{foocoff.c}, copy
60 @file{../include/coff/i386.h} to @file{../include/coff/foo.h},
61 and add the lines to @file{targets.c} and @file{Makefile.in}
62 so that your new back end is used. Alter the shapes of the
63 structures in @file{../include/coff/foo.h} so that they match
64 what you need. You will probably also have to add
65 @code{#ifdef}s to the code in @file{coff/internal.h} and
66 @file{coffcode.h} if your version of coff is too wild.
68 You can verify that your new BFD backend works quite simply by
69 building @file{objdump} from the @file{binutils} directory,
70 and making sure that its version of what's going on and your
71 host system's idea (assuming it has the pretty standard coff
72 dump utility, usually called @code{att-dump} or just
73 @code{dump}) are the same. Then clean up your code, and send
74 what you've done to Cygnus. Then your stuff will be in the
75 next release, and you won't have to keep integrating it.
78 How the coff backend works
83 The Coff backend is split into generic routines that are
84 applicable to any Coff target and routines that are specific
85 to a particular target. The target-specific routines are
86 further split into ones which are basically the same for all
87 Coff targets except that they use the external symbol format
88 or use different values for certain constants.
90 The generic routines are in @file{coffgen.c}. These routines
91 work for any Coff target. They use some hooks into the target
92 specific code; the hooks are in a @code{bfd_coff_backend_data}
93 structure, one of which exists for each target.
95 The essentially similar target-specific routines are in
96 @file{coffcode.h}. This header file includes executable C code.
97 The various Coff targets first include the appropriate Coff
98 header file, make any special defines that are needed, and
99 then include @file{coffcode.h}.
101 Some of the Coff targets then also have additional routines in
102 the target source file itself.
104 For example, @file{coff-i960.c} includes
105 @file{coff/internal.h} and @file{coff/i960.h}. It then
106 defines a few constants, such as @code{I960}, and includes
107 @file{coffcode.h}. Since the i960 has complex relocation
108 types, @file{coff-i960.c} also includes some code to
109 manipulate the i960 relocs. This code is not in
110 @file{coffcode.h} because it would not be used by any other
116 Each flavour of coff supported in BFD has its own header file
117 describing the external layout of the structures. There is also
118 an internal description of the coff layout, in
119 @file{coff/internal.h}. A major function of the
120 coff backend is swapping the bytes and twiddling the bits to
121 translate the external form of the structures into the normal
122 internal form. This is all performed in the
123 @code{bfd_swap}_@i{thing}_@i{direction} routines. Some
124 elements are different sizes between different versions of
125 coff; it is the duty of the coff version specific include file
126 to override the definitions of various packing routines in
127 @file{coffcode.h}. E.g., the size of line number entry in coff is
128 sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
129 @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
130 correct one. No doubt, some day someone will find a version of
131 coff which has a varying field size not catered to at the
132 moment. To port BFD, that person will have to add more @code{#defines}.
133 Three of the bit twiddling routines are exported to
134 @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
135 and @code{coff_swap_lineno_in}. @code{GDB} reads the symbol
136 table on its own, but uses BFD to fix things up. More of the
137 bit twiddlers are exported for @code{gas};
138 @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
139 @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
140 @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
141 @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
142 of all the symbol table and reloc drudgery itself, thereby
143 saving the internal BFD overhead, but uses BFD to swap things
144 on the way out, making cross ports much safer. Doing so also
145 allows BFD (and thus the linker) to use the same header files
146 as @code{gas}, which makes one avenue to disaster disappear.
151 The simple canonical form for symbols used by BFD is not rich
152 enough to keep all the information available in a coff symbol
153 table. The back end gets around this problem by keeping the original
154 symbol table around, "behind the scenes".
156 When a symbol table is requested (through a call to
157 @code{bfd_canonicalize_symtab}), a request gets through to
158 @code{coff_get_normalized_symtab}. This reads the symbol table from
159 the coff file and swaps all the structures inside into the
160 internal form. It also fixes up all the pointers in the table
161 (represented in the file by offsets from the first symbol in
162 the table) into physical pointers to elements in the new
163 internal table. This involves some work since the meanings of
164 fields change depending upon context: a field that is a
165 pointer to another structure in the symbol table at one moment
166 may be the size in bytes of a structure at the next. Another
167 pass is made over the table. All symbols which mark file names
168 (<<C_FILE>> symbols) are modified so that the internal
169 string points to the value in the auxent (the real filename)
170 rather than the normal text associated with the symbol
173 At this time the symbol names are moved around. Coff stores
174 all symbols less than nine characters long physically
175 within the symbol table; longer strings are kept at the end of
176 the file in the string table. This pass moves all strings
177 into memory and replaces them with pointers to the strings.
179 The symbol table is massaged once again, this time to create
180 the canonical table used by the BFD application. Each symbol
181 is inspected in turn, and a decision made (using the
182 @code{sclass} field) about the various flags to set in the
183 @code{asymbol}. @xref{Symbols}. The generated canonical table
184 shares strings with the hidden internal symbol table.
186 Any linenumbers are read from the coff file too, and attached
187 to the symbols which own the functions the linenumbers belong to.
192 Writing a symbol to a coff file which didn't come from a coff
193 file will lose any debugging information. The @code{asymbol}
194 structure remembers the BFD from which the symbol was taken, and on
195 output the back end makes sure that the same destination target as
196 source target is present.
198 When the symbols have come from a coff file then all the
199 debugging information is preserved.
201 Symbol tables are provided for writing to the back end in a
202 vector of pointers to pointers. This allows applications like
203 the linker to accumulate and output large symbol tables
204 without having to do too much byte copying.
206 This function runs through the provided symbol table and
207 patches each symbol marked as a file place holder
208 (@code{C_FILE}) to point to the next file place holder in the
209 list. It also marks each @code{offset} field in the list with
210 the offset from the first symbol of the current symbol.
212 Another function of this procedure is to turn the canonical
213 value form of BFD into the form used by coff. Internally, BFD
214 expects symbol values to be offsets from a section base; so a
215 symbol physically at 0x120, but in a section starting at
216 0x100, would have the value 0x20. Coff expects symbols to
217 contain their final value, so symbols have their values
218 changed at this point to reflect their sum with their owning
219 section. This transformation uses the
220 <<output_section>> field of the @code{asymbol}'s
221 @code{asection} @xref{Sections}.
223 o <<coff_mangle_symbols>>
225 This routine runs though the provided symbol table and uses
226 the offsets generated by the previous pass and the pointers
227 generated when the symbol table was read in to create the
228 structured hierarchy required by coff. It changes each pointer
229 to a symbol into the index into the symbol table of the asymbol.
231 o <<coff_write_symbols>>
233 This routine runs through the symbol table and patches up the
234 symbols from their internal form into the coff way, calls the
235 bit twiddlers, and writes out the table to the file.
244 The hidden information for an <<asymbol>> is described in a
245 <<combined_entry_type>>:
249 .typedef struct coff_ptr_struct
251 . {* Remembers the offset from the first symbol in the file for
252 . this symbol. Generated by coff_renumber_symbols. *}
253 . unsigned int offset;
255 . {* Should the value of this symbol be renumbered. Used for
256 . XCOFF C_BSTAT symbols. Set by coff_slurp_symbol_table. *}
257 . unsigned int fix_value : 1;
259 . {* Should the tag field of this symbol be renumbered.
260 . Created by coff_pointerize_aux. *}
261 . unsigned int fix_tag : 1;
263 . {* Should the endidx field of this symbol be renumbered.
264 . Created by coff_pointerize_aux. *}
265 . unsigned int fix_end : 1;
267 . {* Should the x_csect.x_scnlen field be renumbered.
268 . Created by coff_pointerize_aux. *}
269 . unsigned int fix_scnlen : 1;
271 . {* Fix up an XCOFF C_BINCL/C_EINCL symbol. The value is the
272 . index into the line number entries. Set by coff_slurp_symbol_table. *}
273 . unsigned int fix_line : 1;
275 . {* The container for the symbol structure as read and translated
279 . union internal_auxent auxent;
280 . struct internal_syment syment;
282 .} combined_entry_type;
285 .{* Each canonical asymbol really looks like this: *}
287 .typedef struct coff_symbol_struct
289 . {* The actual symbol which the rest of BFD works with *}
292 . {* A pointer to the hidden information for this symbol *}
293 . combined_entry_type *native;
295 . {* A pointer to the linenumber information for this symbol *}
296 . struct lineno_cache_entry *lineno;
298 . {* Have the line numbers been relocated yet ? *}
299 . bfd_boolean done_lineno;
307 #include "coffswap.h"
310 #define STRING_SIZE_SIZE (4)
312 #define DOT_DEBUG ".debug"
313 #define GNU_LINKONCE_WI ".gnu.linkonce.wi."
315 static long sec_to_styp_flags
316 PARAMS ((const char *, flagword));
317 static bfd_boolean styp_to_sec_flags
318 PARAMS ((bfd *, PTR, const char *, asection *, flagword *));
319 static bfd_boolean coff_bad_format_hook
320 PARAMS ((bfd *, PTR));
321 static void coff_set_custom_section_alignment
322 PARAMS ((bfd *, asection *, const struct coff_section_alignment_entry *,
323 const unsigned int));
324 static bfd_boolean coff_new_section_hook
325 PARAMS ((bfd *, asection *));
326 static bfd_boolean coff_set_arch_mach_hook
327 PARAMS ((bfd *, PTR));
328 static bfd_boolean coff_write_relocs
329 PARAMS ((bfd *, int));
330 static bfd_boolean coff_set_flags
331 PARAMS ((bfd *, unsigned int *, unsigned short *));
332 static bfd_boolean coff_set_arch_mach
333 PARAMS ((bfd *, enum bfd_architecture, unsigned long)) ATTRIBUTE_UNUSED;
334 static bfd_boolean coff_compute_section_file_positions
336 static bfd_boolean coff_write_object_contents
337 PARAMS ((bfd *)) ATTRIBUTE_UNUSED;
338 static bfd_boolean coff_set_section_contents
339 PARAMS ((bfd *, asection *, const PTR, file_ptr, bfd_size_type));
340 static PTR buy_and_read
341 PARAMS ((bfd *, file_ptr, bfd_size_type));
342 static bfd_boolean coff_slurp_line_table
343 PARAMS ((bfd *, asection *));
344 static bfd_boolean coff_slurp_symbol_table
346 static enum coff_symbol_classification coff_classify_symbol
347 PARAMS ((bfd *, struct internal_syment *));
348 static bfd_boolean coff_slurp_reloc_table
349 PARAMS ((bfd *, asection *, asymbol **));
350 static long coff_canonicalize_reloc
351 PARAMS ((bfd *, asection *, arelent **, asymbol **));
352 #ifndef coff_mkobject_hook
353 static PTR coff_mkobject_hook
354 PARAMS ((bfd *, PTR, PTR));
357 static flagword handle_COMDAT
358 PARAMS ((bfd *, flagword, PTR, const char *, asection *));
360 #ifdef COFF_IMAGE_WITH_PE
361 static bfd_boolean coff_read_word
362 PARAMS ((bfd *, unsigned int *));
363 static unsigned int coff_compute_checksum
365 static bfd_boolean coff_apply_checksum
369 static bfd_boolean ticoff0_bad_format_hook
370 PARAMS ((bfd *, PTR ));
371 static bfd_boolean ticoff1_bad_format_hook
372 PARAMS ((bfd *, PTR ));
375 /* void warning(); */
377 /* Return a word with STYP_* (scnhdr.s_flags) flags set to represent
378 the incoming SEC_* flags. The inverse of this function is
379 styp_to_sec_flags(). NOTE: If you add to/change this routine, you
380 should probably mirror the changes in styp_to_sec_flags(). */
384 /* Macros for setting debugging flags. */
386 #define STYP_XCOFF_DEBUG STYP_DEBUG
388 #define STYP_XCOFF_DEBUG STYP_INFO
391 #ifdef COFF_ALIGN_IN_S_FLAGS
392 #define STYP_DEBUG_INFO STYP_DSECT
394 #define STYP_DEBUG_INFO STYP_INFO
398 sec_to_styp_flags (sec_name, sec_flags)
399 const char *sec_name;
404 if (!strcmp (sec_name, _TEXT))
406 styp_flags = STYP_TEXT;
408 else if (!strcmp (sec_name, _DATA))
410 styp_flags = STYP_DATA;
412 else if (!strcmp (sec_name, _BSS))
414 styp_flags = STYP_BSS;
417 else if (!strcmp (sec_name, _COMMENT))
419 styp_flags = STYP_INFO;
420 #endif /* _COMMENT */
423 else if (!strcmp (sec_name, _LIB))
425 styp_flags = STYP_LIB;
429 else if (!strcmp (sec_name, _LIT))
431 styp_flags = STYP_LIT;
434 else if (!strncmp (sec_name, DOT_DEBUG, sizeof (DOT_DEBUG) - 1))
436 /* Handle the XCOFF debug section and DWARF2 debug sections. */
438 styp_flags = STYP_XCOFF_DEBUG;
440 styp_flags = STYP_DEBUG_INFO;
442 else if (!strncmp (sec_name, ".stab", 5))
444 styp_flags = STYP_DEBUG_INFO;
446 #ifdef COFF_LONG_SECTION_NAMES
447 else if (!strncmp (sec_name, GNU_LINKONCE_WI, sizeof (GNU_LINKONCE_WI) - 1))
449 styp_flags = STYP_DEBUG_INFO;
453 else if (!strcmp (sec_name, _PAD))
455 styp_flags = STYP_PAD;
457 else if (!strcmp (sec_name, _LOADER))
459 styp_flags = STYP_LOADER;
461 else if (!strcmp (sec_name, _EXCEPT))
463 styp_flags = STYP_EXCEPT;
465 else if (!strcmp (sec_name, _TYPCHK))
467 styp_flags = STYP_TYPCHK;
470 /* Try and figure out what it should be */
471 else if (sec_flags & SEC_CODE)
473 styp_flags = STYP_TEXT;
475 else if (sec_flags & SEC_DATA)
477 styp_flags = STYP_DATA;
479 else if (sec_flags & SEC_READONLY)
481 #ifdef STYP_LIT /* 29k readonly text/data section */
482 styp_flags = STYP_LIT;
484 styp_flags = STYP_TEXT;
485 #endif /* STYP_LIT */
487 else if (sec_flags & SEC_LOAD)
489 styp_flags = STYP_TEXT;
491 else if (sec_flags & SEC_ALLOC)
493 styp_flags = STYP_BSS;
497 if (sec_flags & SEC_CLINK)
498 styp_flags |= STYP_CLINK;
502 if (sec_flags & SEC_BLOCK)
503 styp_flags |= STYP_BLOCK;
507 if ((sec_flags & (SEC_NEVER_LOAD | SEC_COFF_SHARED_LIBRARY)) != 0)
508 styp_flags |= STYP_NOLOAD;
514 #else /* COFF_WITH_PE */
516 /* The PE version; see above for the general comments. The non-PE
517 case seems to be more guessing, and breaks PE format; specifically,
518 .rdata is readonly, but it sure ain't text. Really, all this
519 should be set up properly in gas (or whatever assembler is in use),
520 and honor whatever objcopy/strip, etc. sent us as input. */
523 sec_to_styp_flags (sec_name, sec_flags)
524 const char *sec_name;
529 /* caution: there are at least three groups of symbols that have
530 very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
531 SEC_* are the BFD internal flags, used for generic BFD
532 information. STYP_* are the COFF section flags which appear in
533 COFF files. IMAGE_SCN_* are the PE section flags which appear in
534 PE files. The STYP_* flags and the IMAGE_SCN_* flags overlap,
535 but there are more IMAGE_SCN_* flags. */
537 /* FIXME: There is no gas syntax to specify the debug section flag. */
538 if (strncmp (sec_name, DOT_DEBUG, sizeof (DOT_DEBUG) - 1) == 0
539 || strncmp (sec_name, GNU_LINKONCE_WI, sizeof (GNU_LINKONCE_WI) - 1) == 0)
540 sec_flags = SEC_READONLY | SEC_DEBUGGING;
545 if ((sec_flags & SEC_CODE) != 0)
546 styp_flags |= IMAGE_SCN_CNT_CODE;
547 if ((sec_flags & SEC_DATA) != 0)
548 styp_flags |= IMAGE_SCN_CNT_INITIALIZED_DATA;
549 if ((sec_flags & SEC_ALLOC) != 0 && (sec_flags & SEC_LOAD) == 0)
550 styp_flags |= IMAGE_SCN_CNT_UNINITIALIZED_DATA; /* ==STYP_BSS */
552 /* skip constRUCTOR */
555 if ((sec_flags & (SEC_NEVER_LOAD | SEC_COFF_SHARED_LIBRARY)) != 0)
556 styp_flags |= STYP_NOLOAD;
558 if ((sec_flags & SEC_IS_COMMON) != 0)
559 styp_flags |= IMAGE_SCN_LNK_COMDAT;
560 if ((sec_flags & SEC_DEBUGGING) != 0)
561 styp_flags |= IMAGE_SCN_MEM_DISCARDABLE;
562 if ((sec_flags & SEC_EXCLUDE) != 0)
563 styp_flags |= IMAGE_SCN_LNK_REMOVE;
564 if ((sec_flags & SEC_NEVER_LOAD) != 0)
565 styp_flags |= IMAGE_SCN_LNK_REMOVE;
568 if (sec_flags & SEC_LINK_ONCE)
569 styp_flags |= IMAGE_SCN_LNK_COMDAT;
570 /* skip LINK_DUPLICATES */
571 /* skip LINKER_CREATED */
573 /* For now, the read/write bits are mapped onto SEC_READONLY, even
574 though the semantics don't quite match. The bits from the input
575 are retained in pei_section_data(abfd, section)->pe_flags. */
577 styp_flags |= IMAGE_SCN_MEM_READ; /* Always readable. */
578 if ((sec_flags & SEC_READONLY) == 0)
579 styp_flags |= IMAGE_SCN_MEM_WRITE; /* Invert READONLY for write. */
580 if (sec_flags & SEC_CODE)
581 styp_flags |= IMAGE_SCN_MEM_EXECUTE; /* CODE->EXECUTE. */
582 if (sec_flags & SEC_SHARED)
583 styp_flags |= IMAGE_SCN_MEM_SHARED; /* Shared remains meaningful. */
588 #endif /* COFF_WITH_PE */
590 /* Return a word with SEC_* flags set to represent the incoming STYP_*
591 flags (from scnhdr.s_flags). The inverse of this function is
592 sec_to_styp_flags(). NOTE: If you add to/change this routine, you
593 should probably mirror the changes in sec_to_styp_flags(). */
598 styp_to_sec_flags (abfd, hdr, name, section, flags_ptr)
599 bfd *abfd ATTRIBUTE_UNUSED;
602 asection *section ATTRIBUTE_UNUSED;
605 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
606 long styp_flags = internal_s->s_flags;
607 flagword sec_flags = 0;
610 if (styp_flags & STYP_BLOCK)
611 sec_flags |= SEC_BLOCK;
615 if (styp_flags & STYP_CLINK)
616 sec_flags |= SEC_CLINK;
620 if (styp_flags & STYP_NOLOAD)
621 sec_flags |= SEC_NEVER_LOAD;
622 #endif /* STYP_NOLOAD */
624 /* For 386 COFF, at least, an unloadable text or data section is
625 actually a shared library section. */
626 if (styp_flags & STYP_TEXT)
628 if (sec_flags & SEC_NEVER_LOAD)
629 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
631 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
633 else if (styp_flags & STYP_DATA)
635 if (sec_flags & SEC_NEVER_LOAD)
636 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
638 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
640 else if (styp_flags & STYP_BSS)
642 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
643 if (sec_flags & SEC_NEVER_LOAD)
644 sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
647 sec_flags |= SEC_ALLOC;
649 else if (styp_flags & STYP_INFO)
651 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
652 defined. coff_compute_section_file_positions uses
653 COFF_PAGE_SIZE to ensure that the low order bits of the
654 section VMA and the file offset match. If we don't know
655 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
656 and demand page loading of the file will fail. */
657 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
658 sec_flags |= SEC_DEBUGGING;
661 else if (styp_flags & STYP_PAD)
663 else if (strcmp (name, _TEXT) == 0)
665 if (sec_flags & SEC_NEVER_LOAD)
666 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
668 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
670 else if (strcmp (name, _DATA) == 0)
672 if (sec_flags & SEC_NEVER_LOAD)
673 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
675 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
677 else if (strcmp (name, _BSS) == 0)
679 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
680 if (sec_flags & SEC_NEVER_LOAD)
681 sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
684 sec_flags |= SEC_ALLOC;
686 else if (strncmp (name, DOT_DEBUG, sizeof (DOT_DEBUG) - 1) == 0
688 || strcmp (name, _COMMENT) == 0
690 #ifdef COFF_LONG_SECTION_NAMES
691 || strncmp (name, GNU_LINKONCE_WI, sizeof (GNU_LINKONCE_WI) - 1) == 0
693 || strncmp (name, ".stab", 5) == 0)
695 #ifdef COFF_PAGE_SIZE
696 sec_flags |= SEC_DEBUGGING;
700 else if (strcmp (name, _LIB) == 0)
704 else if (strcmp (name, _LIT) == 0)
705 sec_flags = SEC_LOAD | SEC_ALLOC | SEC_READONLY;
708 sec_flags |= SEC_ALLOC | SEC_LOAD;
710 #ifdef STYP_LIT /* A29k readonly text/data section type. */
711 if ((styp_flags & STYP_LIT) == STYP_LIT)
712 sec_flags = (SEC_LOAD | SEC_ALLOC | SEC_READONLY);
713 #endif /* STYP_LIT */
715 #ifdef STYP_OTHER_LOAD /* Other loaded sections. */
716 if (styp_flags & STYP_OTHER_LOAD)
717 sec_flags = (SEC_LOAD | SEC_ALLOC);
718 #endif /* STYP_SDATA */
720 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
721 /* As a GNU extension, if the name begins with .gnu.linkonce, we
722 only link a single copy of the section. This is used to support
723 g++. g++ will emit each template expansion in its own section.
724 The symbols will be defined as weak, so that multiple definitions
725 are permitted. The GNU linker extension is to actually discard
726 all but one of the sections. */
727 if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
728 sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
731 if (flags_ptr == NULL)
734 * flags_ptr = sec_flags;
738 #else /* COFF_WITH_PE */
741 handle_COMDAT (abfd, sec_flags, hdr, name, section)
748 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
749 bfd_byte *esymstart, *esym, *esymend;
751 char *target_name = NULL;
753 sec_flags |= SEC_LINK_ONCE;
755 /* Unfortunately, the PE format stores essential information in
756 the symbol table, of all places. We need to extract that
757 information now, so that objdump and the linker will know how
758 to handle the section without worrying about the symbols. We
759 can't call slurp_symtab, because the linker doesn't want the
762 /* COMDAT sections are special. The first symbol is the section
763 symbol, which tells what kind of COMDAT section it is. The
764 second symbol is the "comdat symbol" - the one with the
765 unique name. GNU uses the section symbol for the unique
766 name; MS uses ".text" for every comdat section. Sigh. - DJ */
768 /* This is not mirrored in sec_to_styp_flags(), but there
769 doesn't seem to be a need to, either, and it would at best be
772 if (! _bfd_coff_get_external_symbols (abfd))
775 esymstart = esym = (bfd_byte *) obj_coff_external_syms (abfd);
776 esymend = esym + obj_raw_syment_count (abfd) * bfd_coff_symesz (abfd);
778 while (esym < esymend)
780 struct internal_syment isym;
781 char buf[SYMNMLEN + 1];
784 bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &isym);
786 if (sizeof (internal_s->s_name) > SYMNMLEN)
788 /* This case implies that the matching
789 symbol name will be in the string table. */
793 if (isym.n_scnum == section->target_index)
795 /* According to the MSVC documentation, the first
796 TWO entries with the section # are both of
797 interest to us. The first one is the "section
798 symbol" (section name). The second is the comdat
799 symbol name. Here, we've found the first
800 qualifying entry; we distinguish it from the
801 second with a state flag.
803 In the case of gas-generated (at least until that
804 is fixed) .o files, it isn't necessarily the
805 second one. It may be some other later symbol.
807 Since gas also doesn't follow MS conventions and
808 emits the section similar to .text$<name>, where
809 <something> is the name we're looking for, we
810 distinguish the two as follows:
812 If the section name is simply a section name (no
813 $) we presume it's MS-generated, and look at
814 precisely the second symbol for the comdat name.
815 If the section name has a $, we assume it's
816 gas-generated, and look for <something> (whatever
817 follows the $) as the comdat symbol. */
819 /* All 3 branches use this. */
820 symname = _bfd_coff_internal_syment_name (abfd, &isym, buf);
829 /* The first time we've seen the symbol. */
830 union internal_auxent aux;
834 /* If it isn't the stuff we're expecting, die;
835 The MS documentation is vague, but it
836 appears that the second entry serves BOTH
837 as the comdat symbol and the defining
838 symbol record (either C_STAT or C_EXT,
839 possibly with an aux entry with debug
840 information if it's a function.) It
841 appears the only way to find the second one
842 is to count. (On Intel, they appear to be
843 adjacent, but on Alpha, they have been
846 Here, we think we've found the first one,
847 but there's some checking we can do to be
850 if (! (isym.n_sclass == C_STAT
851 && isym.n_type == T_NULL
852 && isym.n_value == 0))
855 /* FIXME LATER: MSVC generates section names
856 like .text for comdats. Gas generates
857 names like .text$foo__Fv (in the case of a
858 function). See comment above for more. */
860 if (strcmp (name, symname) != 0)
863 /* This is the section symbol. */
864 bfd_coff_swap_aux_in (abfd, (PTR) (esym + bfd_coff_symesz (abfd)),
865 isym.n_type, isym.n_sclass,
866 0, isym.n_numaux, (PTR) &aux);
868 target_name = strchr (name, '$');
869 if (target_name != NULL)
877 /* FIXME: Microsoft uses NODUPLICATES and
878 ASSOCIATIVE, but gnu uses ANY and
879 SAME_SIZE. Unfortunately, gnu doesn't do
880 the comdat symbols right. So, until we can
881 fix it to do the right thing, we are
882 temporarily disabling comdats for the MS
883 types (they're used in DLLs and C++, but we
884 don't support *their* C++ libraries anyway
887 /* Cygwin does not follow the MS style, and
888 uses ANY and SAME_SIZE where NODUPLICATES
889 and ASSOCIATIVE should be used. For
890 Interix, we just do the right thing up
893 switch (aux.x_scn.x_comdat)
895 case IMAGE_COMDAT_SELECT_NODUPLICATES:
896 #ifdef STRICT_PE_FORMAT
897 sec_flags |= SEC_LINK_DUPLICATES_ONE_ONLY;
899 sec_flags &= ~SEC_LINK_ONCE;
903 case IMAGE_COMDAT_SELECT_ANY:
904 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
907 case IMAGE_COMDAT_SELECT_SAME_SIZE:
908 sec_flags |= SEC_LINK_DUPLICATES_SAME_SIZE;
911 case IMAGE_COMDAT_SELECT_EXACT_MATCH:
912 /* Not yet fully implemented ??? */
913 sec_flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS;
916 /* debug$S gets this case; other
919 /* There may be no symbol... we'll search
920 the whole table... Is this the right
921 place to play this game? Or should we do
922 it when reading it in. */
923 case IMAGE_COMDAT_SELECT_ASSOCIATIVE:
924 #ifdef STRICT_PE_FORMAT
925 /* FIXME: This is not currently implemented. */
926 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
928 sec_flags &= ~SEC_LINK_ONCE;
932 default: /* 0 means "no symbol" */
933 /* debug$F gets this case; other
935 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
942 /* Gas mode: the first matching on partial name. */
944 #ifndef TARGET_UNDERSCORE
945 #define TARGET_UNDERSCORE 0
947 /* Is this the name we're looking for ? */
948 if (strcmp (target_name,
949 symname + (TARGET_UNDERSCORE ? 1 : 0)) != 0)
951 /* Not the name we're looking for */
952 esym += (isym.n_numaux + 1) * bfd_coff_symesz (abfd);
957 /* MSVC mode: the lexically second symbol (or
958 drop through from the above). */
963 /* This must the second symbol with the
964 section #. It is the actual symbol name.
965 Intel puts the two adjacent, but Alpha (at
966 least) spreads them out. */
968 amt = sizeof (struct bfd_comdat_info);
969 section->comdat = bfd_alloc (abfd, amt);
970 if (section->comdat == NULL)
973 section->comdat->symbol =
974 (esym - esymstart) / bfd_coff_symesz (abfd);
976 amt = strlen (symname) + 1;
977 newname = bfd_alloc (abfd, amt);
981 strcpy (newname, symname);
982 section->comdat->name = newname;
989 esym += (isym.n_numaux + 1) * bfd_coff_symesz (abfd);
997 /* The PE version; see above for the general comments.
999 Since to set the SEC_LINK_ONCE and associated flags, we have to
1000 look at the symbol table anyway, we return the symbol table index
1001 of the symbol being used as the COMDAT symbol. This is admittedly
1002 ugly, but there's really nowhere else that we have access to the
1003 required information. FIXME: Is the COMDAT symbol index used for
1004 any purpose other than objdump? */
1007 styp_to_sec_flags (abfd, hdr, name, section, flags_ptr)
1012 flagword *flags_ptr;
1014 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
1015 long styp_flags = internal_s->s_flags;
1017 bfd_boolean result = TRUE;
1019 /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
1020 sec_flags = SEC_READONLY;
1022 /* Process each flag bit in styp_flags in turn. */
1025 long flag = styp_flags & - styp_flags;
1026 char * unhandled = NULL;
1028 styp_flags &= ~ flag;
1030 /* We infer from the distinct read/write/execute bits the settings
1031 of some of the bfd flags; the actual values, should we need them,
1032 are also in pei_section_data (abfd, section)->pe_flags. */
1037 unhandled = "STYP_DSECT";
1040 unhandled = "STYP_GROUP";
1043 unhandled = "STYP_COPY";
1046 unhandled = "STYP_OVER";
1048 #ifdef SEC_NEVER_LOAD
1050 sec_flags |= SEC_NEVER_LOAD;
1053 case IMAGE_SCN_MEM_READ:
1054 /* Ignored, assume it always to be true. */
1056 case IMAGE_SCN_TYPE_NO_PAD:
1059 case IMAGE_SCN_LNK_OTHER:
1060 unhandled = "IMAGE_SCN_LNK_OTHER";
1062 case IMAGE_SCN_MEM_NOT_CACHED:
1063 unhandled = "IMAGE_SCN_MEM_NOT_CACHED";
1065 case IMAGE_SCN_MEM_NOT_PAGED:
1066 unhandled = "IMAGE_SCN_MEM_NOT_PAGED";
1068 case IMAGE_SCN_MEM_EXECUTE:
1069 sec_flags |= SEC_CODE;
1071 case IMAGE_SCN_MEM_WRITE:
1072 sec_flags &= ~ SEC_READONLY;
1074 case IMAGE_SCN_MEM_DISCARDABLE:
1075 /* The MS PE spec sets the DISCARDABLE flag on .reloc sections
1076 but we do not want them to be labelled as debug section, since
1077 then strip would remove them. */
1078 if (strncmp (name, ".reloc", sizeof ".reloc" - 1) != 0)
1079 sec_flags |= SEC_DEBUGGING;
1081 case IMAGE_SCN_MEM_SHARED:
1082 sec_flags |= SEC_SHARED;
1084 case IMAGE_SCN_LNK_REMOVE:
1085 sec_flags |= SEC_EXCLUDE;
1087 case IMAGE_SCN_CNT_CODE:
1088 sec_flags |= SEC_CODE | SEC_ALLOC | SEC_LOAD;
1090 case IMAGE_SCN_CNT_INITIALIZED_DATA:
1091 sec_flags |= SEC_DATA | SEC_ALLOC | SEC_LOAD;
1093 case IMAGE_SCN_CNT_UNINITIALIZED_DATA:
1094 sec_flags |= SEC_ALLOC;
1096 case IMAGE_SCN_LNK_INFO:
1097 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
1098 defined. coff_compute_section_file_positions uses
1099 COFF_PAGE_SIZE to ensure that the low order bits of the
1100 section VMA and the file offset match. If we don't know
1101 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
1102 and demand page loading of the file will fail. */
1103 #ifdef COFF_PAGE_SIZE
1104 sec_flags |= SEC_DEBUGGING;
1107 case IMAGE_SCN_LNK_COMDAT:
1108 /* COMDAT gets very special treatment. */
1109 sec_flags = handle_COMDAT (abfd, sec_flags, hdr, name, section);
1112 /* Silently ignore for now. */
1116 /* If the section flag was not handled, report it here. */
1117 if (unhandled != NULL)
1119 (*_bfd_error_handler)
1120 (_("%s (%s): Section flag %s (0x%x) ignored"),
1121 bfd_archive_filename (abfd), name, unhandled, flag);
1126 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1127 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1128 only link a single copy of the section. This is used to support
1129 g++. g++ will emit each template expansion in its own section.
1130 The symbols will be defined as weak, so that multiple definitions
1131 are permitted. The GNU linker extension is to actually discard
1132 all but one of the sections. */
1133 if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
1134 sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
1138 * flags_ptr = sec_flags;
1143 #endif /* COFF_WITH_PE */
1145 #define get_index(symbol) ((symbol)->udata.i)
1149 bfd_coff_backend_data
1153 .{* COFF symbol classifications. *}
1155 .enum coff_symbol_classification
1157 . {* Global symbol. *}
1158 . COFF_SYMBOL_GLOBAL,
1159 . {* Common symbol. *}
1160 . COFF_SYMBOL_COMMON,
1161 . {* Undefined symbol. *}
1162 . COFF_SYMBOL_UNDEFINED,
1163 . {* Local symbol. *}
1164 . COFF_SYMBOL_LOCAL,
1165 . {* PE section symbol. *}
1166 . COFF_SYMBOL_PE_SECTION
1169 Special entry points for gdb to swap in coff symbol table parts:
1172 . void (*_bfd_coff_swap_aux_in)
1173 . PARAMS ((bfd *, PTR, int, int, int, int, PTR));
1175 . void (*_bfd_coff_swap_sym_in)
1176 . PARAMS ((bfd *, PTR, PTR));
1178 . void (*_bfd_coff_swap_lineno_in)
1179 . PARAMS ((bfd *, PTR, PTR));
1181 . unsigned int (*_bfd_coff_swap_aux_out)
1182 . PARAMS ((bfd *, PTR, int, int, int, int, PTR));
1184 . unsigned int (*_bfd_coff_swap_sym_out)
1185 . PARAMS ((bfd *, PTR, PTR));
1187 . unsigned int (*_bfd_coff_swap_lineno_out)
1188 . PARAMS ((bfd *, PTR, PTR));
1190 . unsigned int (*_bfd_coff_swap_reloc_out)
1191 . PARAMS ((bfd *, PTR, PTR));
1193 . unsigned int (*_bfd_coff_swap_filehdr_out)
1194 . PARAMS ((bfd *, PTR, PTR));
1196 . unsigned int (*_bfd_coff_swap_aouthdr_out)
1197 . PARAMS ((bfd *, PTR, PTR));
1199 . unsigned int (*_bfd_coff_swap_scnhdr_out)
1200 . PARAMS ((bfd *, PTR, PTR));
1202 . unsigned int _bfd_filhsz;
1203 . unsigned int _bfd_aoutsz;
1204 . unsigned int _bfd_scnhsz;
1205 . unsigned int _bfd_symesz;
1206 . unsigned int _bfd_auxesz;
1207 . unsigned int _bfd_relsz;
1208 . unsigned int _bfd_linesz;
1209 . unsigned int _bfd_filnmlen;
1210 . bfd_boolean _bfd_coff_long_filenames;
1211 . bfd_boolean _bfd_coff_long_section_names;
1212 . unsigned int _bfd_coff_default_section_alignment_power;
1213 . bfd_boolean _bfd_coff_force_symnames_in_strings;
1214 . unsigned int _bfd_coff_debug_string_prefix_length;
1216 . void (*_bfd_coff_swap_filehdr_in)
1217 . PARAMS ((bfd *, PTR, PTR));
1219 . void (*_bfd_coff_swap_aouthdr_in)
1220 . PARAMS ((bfd *, PTR, PTR));
1222 . void (*_bfd_coff_swap_scnhdr_in)
1223 . PARAMS ((bfd *, PTR, PTR));
1225 . void (*_bfd_coff_swap_reloc_in)
1226 . PARAMS ((bfd *abfd, PTR, PTR));
1228 . bfd_boolean (*_bfd_coff_bad_format_hook)
1229 . PARAMS ((bfd *, PTR));
1231 . bfd_boolean (*_bfd_coff_set_arch_mach_hook)
1232 . PARAMS ((bfd *, PTR));
1234 . PTR (*_bfd_coff_mkobject_hook)
1235 . PARAMS ((bfd *, PTR, PTR));
1237 . bfd_boolean (*_bfd_styp_to_sec_flags_hook)
1238 . PARAMS ((bfd *, PTR, const char *, asection *, flagword *));
1240 . void (*_bfd_set_alignment_hook)
1241 . PARAMS ((bfd *, asection *, PTR));
1243 . bfd_boolean (*_bfd_coff_slurp_symbol_table)
1246 . bfd_boolean (*_bfd_coff_symname_in_debug)
1247 . PARAMS ((bfd *, struct internal_syment *));
1249 . bfd_boolean (*_bfd_coff_pointerize_aux_hook)
1250 . PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
1251 . unsigned int, combined_entry_type *));
1253 . bfd_boolean (*_bfd_coff_print_aux)
1254 . PARAMS ((bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1255 . combined_entry_type *, unsigned int));
1257 . void (*_bfd_coff_reloc16_extra_cases)
1258 . PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
1259 . bfd_byte *, unsigned int *, unsigned int *));
1261 . int (*_bfd_coff_reloc16_estimate)
1262 . PARAMS ((bfd *, asection *, arelent *, unsigned int,
1263 . struct bfd_link_info *));
1265 . enum coff_symbol_classification (*_bfd_coff_classify_symbol)
1266 . PARAMS ((bfd *, struct internal_syment *));
1268 . bfd_boolean (*_bfd_coff_compute_section_file_positions)
1271 . bfd_boolean (*_bfd_coff_start_final_link)
1272 . PARAMS ((bfd *, struct bfd_link_info *));
1274 . bfd_boolean (*_bfd_coff_relocate_section)
1275 . PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
1276 . struct internal_reloc *, struct internal_syment *, asection **));
1278 . reloc_howto_type *(*_bfd_coff_rtype_to_howto)
1279 . PARAMS ((bfd *, asection *, struct internal_reloc *,
1280 . struct coff_link_hash_entry *, struct internal_syment *,
1283 . bfd_boolean (*_bfd_coff_adjust_symndx)
1284 . PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *,
1285 . struct internal_reloc *, bfd_boolean *));
1287 . bfd_boolean (*_bfd_coff_link_add_one_symbol)
1288 . PARAMS ((struct bfd_link_info *, bfd *, const char *, flagword,
1289 . asection *, bfd_vma, const char *, bfd_boolean, bfd_boolean,
1290 . struct bfd_link_hash_entry **));
1292 . bfd_boolean (*_bfd_coff_link_output_has_begun)
1293 . PARAMS ((bfd *, struct coff_final_link_info *));
1295 . bfd_boolean (*_bfd_coff_final_link_postscript)
1296 . PARAMS ((bfd *, struct coff_final_link_info *));
1298 .} bfd_coff_backend_data;
1300 .#define coff_backend_info(abfd) \
1301 . ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1303 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1304 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1306 .#define bfd_coff_swap_sym_in(a,e,i) \
1307 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1309 .#define bfd_coff_swap_lineno_in(a,e,i) \
1310 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1312 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1313 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1315 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1316 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1318 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1319 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1321 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1322 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1324 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1325 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1327 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1328 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1330 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1331 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1333 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1334 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1335 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1336 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1337 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1338 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1339 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1340 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1341 .#define bfd_coff_long_filenames(abfd) \
1342 . (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1343 .#define bfd_coff_long_section_names(abfd) \
1344 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1345 .#define bfd_coff_default_section_alignment_power(abfd) \
1346 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1347 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1348 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1350 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1351 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1353 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1354 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1356 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1357 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1359 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1360 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1362 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1363 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1364 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1365 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook)\
1366 . (abfd, filehdr, aouthdr))
1368 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\
1369 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1370 . (abfd, scnhdr, name, section, flags_ptr))
1372 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1373 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1375 .#define bfd_coff_slurp_symbol_table(abfd)\
1376 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1378 .#define bfd_coff_symname_in_debug(abfd, sym)\
1379 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1381 .#define bfd_coff_force_symnames_in_strings(abfd)\
1382 . (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
1384 .#define bfd_coff_debug_string_prefix_length(abfd)\
1385 . (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
1387 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1388 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1389 . (abfd, file, base, symbol, aux, indaux))
1391 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order,\
1392 . reloc, data, src_ptr, dst_ptr)\
1393 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1394 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1396 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1397 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1398 . (abfd, section, reloc, shrink, link_info))
1400 .#define bfd_coff_classify_symbol(abfd, sym)\
1401 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1404 .#define bfd_coff_compute_section_file_positions(abfd)\
1405 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1408 .#define bfd_coff_start_final_link(obfd, info)\
1409 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1411 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1412 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1413 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1414 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1415 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1416 . (abfd, sec, rel, h, sym, addendp))
1417 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1418 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1419 . (obfd, info, ibfd, sec, rel, adjustedp))
1420 .#define bfd_coff_link_add_one_symbol(info, abfd, name, flags, section,\
1421 . value, string, cp, coll, hashp)\
1422 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1423 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1425 .#define bfd_coff_link_output_has_begun(a,p) \
1426 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a,p))
1427 .#define bfd_coff_final_link_postscript(a,p) \
1428 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a,p))
1432 /* See whether the magic number matches. */
1435 coff_bad_format_hook (abfd, filehdr)
1436 bfd * abfd ATTRIBUTE_UNUSED;
1439 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1441 if (BADMAG (*internal_f))
1444 /* If the optional header is NULL or not the correct size then
1445 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1446 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1447 optional header is of a different size.
1449 But the mips keeps extra stuff in it's opthdr, so dont check
1452 #if defined(M88) || defined(I960)
1453 if (internal_f->f_opthdr != 0 && bfd_coff_aoutsz (abfd) != internal_f->f_opthdr)
1462 ticoff0_bad_format_hook (abfd, filehdr)
1463 bfd *abfd ATTRIBUTE_UNUSED;
1466 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1468 if (COFF0_BADMAG (*internal_f))
1477 ticoff1_bad_format_hook (abfd, filehdr)
1478 bfd *abfd ATTRIBUTE_UNUSED;
1481 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1483 if (COFF1_BADMAG (*internal_f))
1490 /* Check whether this section uses an alignment other than the
1494 coff_set_custom_section_alignment (abfd, section, alignment_table, table_size)
1495 bfd *abfd ATTRIBUTE_UNUSED;
1497 const struct coff_section_alignment_entry *alignment_table;
1498 const unsigned int table_size;
1500 const unsigned int default_alignment = COFF_DEFAULT_SECTION_ALIGNMENT_POWER;
1503 for (i = 0; i < table_size; ++i)
1505 const char *secname = bfd_get_section_name (abfd, section);
1507 if (alignment_table[i].comparison_length == (unsigned int) -1
1508 ? strcmp (alignment_table[i].name, secname) == 0
1509 : strncmp (alignment_table[i].name, secname,
1510 alignment_table[i].comparison_length) == 0)
1513 if (i >= table_size)
1516 if (alignment_table[i].default_alignment_min != COFF_ALIGNMENT_FIELD_EMPTY
1517 && default_alignment < alignment_table[i].default_alignment_min)
1520 if (alignment_table[i].default_alignment_max != COFF_ALIGNMENT_FIELD_EMPTY
1521 #if COFF_DEFAULT_SECTION_ALIGNMENT_POWER != 0
1522 && default_alignment > alignment_table[i].default_alignment_max
1527 section->alignment_power = alignment_table[i].alignment_power;
1530 /* Custom section alignment records. */
1532 static const struct coff_section_alignment_entry
1533 coff_section_alignment_table[] =
1535 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1536 COFF_SECTION_ALIGNMENT_ENTRIES,
1538 /* There must not be any gaps between .stabstr sections. */
1539 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1540 1, COFF_ALIGNMENT_FIELD_EMPTY, 0 },
1541 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1542 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1543 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 },
1544 /* Similarly for the .ctors and .dtors sections. */
1545 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1546 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 },
1547 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1548 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 }
1551 static const unsigned int coff_section_alignment_table_size =
1552 sizeof coff_section_alignment_table / sizeof coff_section_alignment_table[0];
1554 /* Initialize a section structure with information peculiar to this
1555 particular implementation of COFF. */
1558 coff_new_section_hook (abfd, section)
1562 combined_entry_type *native;
1565 section->alignment_power = COFF_DEFAULT_SECTION_ALIGNMENT_POWER;
1568 if (bfd_xcoff_text_align_power (abfd) != 0
1569 && strcmp (bfd_get_section_name (abfd, section), ".text") == 0)
1570 section->alignment_power = bfd_xcoff_text_align_power (abfd);
1571 if (bfd_xcoff_data_align_power (abfd) != 0
1572 && strcmp (bfd_get_section_name (abfd, section), ".data") == 0)
1573 section->alignment_power = bfd_xcoff_data_align_power (abfd);
1576 /* Allocate aux records for section symbols, to store size and
1579 @@ The 10 is a guess at a plausible maximum number of aux entries
1580 (but shouldn't be a constant). */
1581 amt = sizeof (combined_entry_type) * 10;
1582 native = (combined_entry_type *) bfd_zalloc (abfd, amt);
1586 /* We don't need to set up n_name, n_value, or n_scnum in the native
1587 symbol information, since they'll be overridden by the BFD symbol
1588 anyhow. However, we do need to set the type and storage class,
1589 in case this symbol winds up getting written out. The value 0
1590 for n_numaux is already correct. */
1592 native->u.syment.n_type = T_NULL;
1593 native->u.syment.n_sclass = C_STAT;
1595 coffsymbol (section->symbol)->native = native;
1597 coff_set_custom_section_alignment (abfd, section,
1598 coff_section_alignment_table,
1599 coff_section_alignment_table_size);
1604 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1606 /* Set the alignment of a BFD section. */
1608 static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1611 coff_set_alignment_hook (abfd, section, scnhdr)
1612 bfd * abfd ATTRIBUTE_UNUSED;
1616 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1620 /* Extract ALIGN from 2**ALIGN stored in section header. */
1621 for (i = 0; i < 32; i++)
1622 if ((1 << i) >= hdr->s_align)
1626 /* TI tools puts the alignment power in bits 8-11. */
1627 i = (hdr->s_flags >> 8) & 0xF ;
1629 #ifdef COFF_DECODE_ALIGNMENT
1630 i = COFF_DECODE_ALIGNMENT(hdr->s_flags);
1632 section->alignment_power = i;
1634 #ifdef coff_set_section_load_page
1635 coff_set_section_load_page (section, hdr->s_page);
1639 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1642 /* A couple of macros to help setting the alignment power field. */
1643 #define ALIGN_SET(field,x,y) \
1644 if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x )\
1646 section->alignment_power = y;\
1649 #define ELIFALIGN_SET(field,x,y) \
1650 else if (( (field) & IMAGE_SCN_ALIGN_64BYTES) == x ) \
1652 section->alignment_power = y;\
1655 static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1658 coff_set_alignment_hook (abfd, section, scnhdr)
1659 bfd * abfd ATTRIBUTE_UNUSED;
1663 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1666 ALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_64BYTES, 6)
1667 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_32BYTES, 5)
1668 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_16BYTES, 4)
1669 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_8BYTES, 3)
1670 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_4BYTES, 2)
1671 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_2BYTES, 1)
1672 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_1BYTES, 0)
1674 /* In a PE image file, the s_paddr field holds the virtual size of a
1675 section, while the s_size field holds the raw size. We also keep
1676 the original section flag value, since not every bit can be
1677 mapped onto a generic BFD section bit. */
1678 if (coff_section_data (abfd, section) == NULL)
1680 amt = sizeof (struct coff_section_tdata);
1681 section->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
1682 if (section->used_by_bfd == NULL)
1684 /* FIXME: Return error. */
1688 if (pei_section_data (abfd, section) == NULL)
1690 amt = sizeof (struct pei_section_tdata);
1691 coff_section_data (abfd, section)->tdata = (PTR) bfd_zalloc (abfd, amt);
1692 if (coff_section_data (abfd, section)->tdata == NULL)
1694 /* FIXME: Return error. */
1698 pei_section_data (abfd, section)->virt_size = hdr->s_paddr;
1699 pei_section_data (abfd, section)->pe_flags = hdr->s_flags;
1701 section->lma = hdr->s_vaddr;
1703 /* Check for extended relocs. */
1704 if (hdr->s_flags & IMAGE_SCN_LNK_NRELOC_OVFL)
1706 struct external_reloc dst;
1707 struct internal_reloc n;
1708 file_ptr oldpos = bfd_tell (abfd);
1709 bfd_size_type relsz = bfd_coff_relsz (abfd);
1711 bfd_seek (abfd, (file_ptr) hdr->s_relptr, 0);
1712 if (bfd_bread ((PTR) &dst, relsz, abfd) != relsz)
1715 coff_swap_reloc_in (abfd, &dst, &n);
1716 bfd_seek (abfd, oldpos, 0);
1717 section->reloc_count = hdr->s_nreloc = n.r_vaddr - 1;
1718 section->rel_filepos += relsz;
1720 else if (hdr->s_nreloc == 0xffff)
1721 (*_bfd_error_handler)
1722 ("%s: warning: claims to have 0xffff relocs, without overflow",
1723 bfd_get_filename (abfd));
1726 #undef ELIFALIGN_SET
1728 #else /* ! COFF_WITH_PE */
1731 /* We grossly abuse this function to handle XCOFF overflow headers.
1732 When we see one, we correct the reloc and line number counts in the
1733 real header, and remove the section we just created. */
1735 static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1738 coff_set_alignment_hook (abfd, section, scnhdr)
1743 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1747 if ((hdr->s_flags & STYP_OVRFLO) == 0)
1750 real_sec = coff_section_from_bfd_index (abfd, (int) hdr->s_nreloc);
1751 if (real_sec == NULL)
1754 real_sec->reloc_count = hdr->s_paddr;
1755 real_sec->lineno_count = hdr->s_vaddr;
1757 for (ps = &abfd->sections; *ps != NULL; ps = &(*ps)->next)
1761 bfd_section_list_remove (abfd, ps);
1762 --abfd->section_count;
1768 #else /* ! RS6000COFF_C */
1770 #define coff_set_alignment_hook \
1771 ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
1773 #endif /* ! RS6000COFF_C */
1774 #endif /* ! COFF_WITH_PE */
1775 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1777 #ifndef coff_mkobject
1779 static bfd_boolean coff_mkobject PARAMS ((bfd *));
1782 coff_mkobject (abfd)
1785 coff_data_type *coff;
1786 bfd_size_type amt = sizeof (coff_data_type);
1788 abfd->tdata.coff_obj_data = (struct coff_tdata *) bfd_zalloc (abfd, amt);
1789 if (abfd->tdata.coff_obj_data == 0)
1791 coff = coff_data (abfd);
1792 coff->symbols = (coff_symbol_type *) NULL;
1793 coff->conversion_table = (unsigned int *) NULL;
1794 coff->raw_syments = (struct coff_ptr_struct *) NULL;
1795 coff->relocbase = 0;
1796 coff->local_toc_sym_map = 0;
1798 /* make_abs_section(abfd);*/
1804 /* Create the COFF backend specific information. */
1806 #ifndef coff_mkobject_hook
1808 coff_mkobject_hook (abfd, filehdr, aouthdr)
1811 PTR aouthdr ATTRIBUTE_UNUSED;
1813 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1814 coff_data_type *coff;
1816 if (! coff_mkobject (abfd))
1819 coff = coff_data (abfd);
1821 coff->sym_filepos = internal_f->f_symptr;
1823 /* These members communicate important constants about the symbol
1824 table to GDB's symbol-reading code. These `constants'
1825 unfortunately vary among coff implementations... */
1826 coff->local_n_btmask = N_BTMASK;
1827 coff->local_n_btshft = N_BTSHFT;
1828 coff->local_n_tmask = N_TMASK;
1829 coff->local_n_tshift = N_TSHIFT;
1830 coff->local_symesz = bfd_coff_symesz (abfd);
1831 coff->local_auxesz = bfd_coff_auxesz (abfd);
1832 coff->local_linesz = bfd_coff_linesz (abfd);
1834 coff->timestamp = internal_f->f_timdat;
1836 obj_raw_syment_count (abfd) =
1837 obj_conv_table_size (abfd) =
1838 internal_f->f_nsyms;
1841 if ((internal_f->f_flags & F_SHROBJ) != 0)
1842 abfd->flags |= DYNAMIC;
1843 if (aouthdr != NULL && internal_f->f_opthdr >= bfd_coff_aoutsz (abfd))
1845 struct internal_aouthdr *internal_a =
1846 (struct internal_aouthdr *) aouthdr;
1847 struct xcoff_tdata *xcoff;
1849 xcoff = xcoff_data (abfd);
1850 # ifdef U803XTOCMAGIC
1851 xcoff->xcoff64 = internal_f->f_magic == U803XTOCMAGIC;
1855 xcoff->full_aouthdr = TRUE;
1856 xcoff->toc = internal_a->o_toc;
1857 xcoff->sntoc = internal_a->o_sntoc;
1858 xcoff->snentry = internal_a->o_snentry;
1859 bfd_xcoff_text_align_power (abfd) = internal_a->o_algntext;
1860 bfd_xcoff_data_align_power (abfd) = internal_a->o_algndata;
1861 xcoff->modtype = internal_a->o_modtype;
1862 xcoff->cputype = internal_a->o_cputype;
1863 xcoff->maxdata = internal_a->o_maxdata;
1864 xcoff->maxstack = internal_a->o_maxstack;
1869 /* Set the flags field from the COFF header read in. */
1870 if (! _bfd_coff_arm_set_private_flags (abfd, internal_f->f_flags))
1875 /* FIXME: I'm not sure this is ever executed, since peicode.h
1876 defines coff_mkobject_hook. */
1877 if ((internal_f->f_flags & IMAGE_FILE_DEBUG_STRIPPED) == 0)
1878 abfd->flags |= HAS_DEBUG;
1885 /* Determine the machine architecture and type. FIXME: This is target
1886 dependent because the magic numbers are defined in the target
1887 dependent header files. But there is no particular need for this.
1888 If the magic numbers were moved to a separate file, this function
1889 would be target independent and would also be much more successful
1890 at linking together COFF files for different architectures. */
1893 coff_set_arch_mach_hook (abfd, filehdr)
1897 unsigned long machine;
1898 enum bfd_architecture arch;
1899 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1901 /* Zero selects the default machine for an arch. */
1903 switch (internal_f->f_magic)
1905 #ifdef OR32_MAGIC_BIG
1906 case OR32_MAGIC_BIG:
1907 case OR32_MAGIC_LITTLE:
1908 arch = bfd_arch_or32;
1913 arch = bfd_arch_powerpc;
1919 case I386AIXMAGIC: /* Danbury PS/2 AIX C Compiler */
1920 case LYNXCOFFMAGIC: /* shadows the m68k Lynx number below, sigh */
1921 arch = bfd_arch_i386;
1926 arch = bfd_arch_ia64;
1929 #ifdef A29K_MAGIC_BIG
1930 case A29K_MAGIC_BIG:
1931 case A29K_MAGIC_LITTLE:
1932 arch = bfd_arch_a29k;
1939 arch = bfd_arch_arm;
1940 machine = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION);
1941 if (machine == bfd_mach_arm_unknown)
1943 switch (internal_f->f_flags & F_ARM_ARCHITECTURE_MASK)
1945 case F_ARM_2: machine = bfd_mach_arm_2; break;
1946 case F_ARM_2a: machine = bfd_mach_arm_2a; break;
1947 case F_ARM_3: machine = bfd_mach_arm_3; break;
1949 case F_ARM_3M: machine = bfd_mach_arm_3M; break;
1950 case F_ARM_4: machine = bfd_mach_arm_4; break;
1951 case F_ARM_4T: machine = bfd_mach_arm_4T; break;
1952 /* The COFF header does not have enough bits available
1953 to cover all the different ARM architectures. So
1954 we interpret F_ARM_5, the highest flag value to mean
1955 "the highest ARM architecture known to BFD" which is
1956 currently the XScale. */
1957 case F_ARM_5: machine = bfd_mach_arm_XScale; break;
1965 #ifdef MC68KBCSMAGIC
1968 #ifdef APOLLOM68KMAGIC
1969 case APOLLOM68KMAGIC:
1971 #ifdef LYNXCOFFMAGIC
1974 arch = bfd_arch_m68k;
1975 machine = bfd_mach_m68020;
1982 arch = bfd_arch_m88k;
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_byte *) 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, (PTR) buf, (PTR) &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
2268 static bfd_boolean symname_in_debug_hook
2269 PARAMS ((bfd *, struct internal_syment *));
2272 symname_in_debug_hook (abfd, sym)
2273 bfd * abfd ATTRIBUTE_UNUSED;
2274 struct internal_syment *sym;
2276 return SYMNAME_IN_DEBUG (sym) != 0;
2281 #define symname_in_debug_hook \
2282 (bfd_boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
2289 #define FORCE_SYMNAMES_IN_STRINGS
2292 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */
2294 static bfd_boolean coff_pointerize_aux_hook
2295 PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
2296 unsigned int, combined_entry_type *));
2299 coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux)
2300 bfd *abfd ATTRIBUTE_UNUSED;
2301 combined_entry_type *table_base;
2302 combined_entry_type *symbol;
2303 unsigned int indaux;
2304 combined_entry_type *aux;
2306 int class = symbol->u.syment.n_sclass;
2308 if ((class == C_EXT || class == C_HIDEXT)
2309 && indaux + 1 == symbol->u.syment.n_numaux)
2311 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD)
2313 aux->u.auxent.x_csect.x_scnlen.p =
2314 table_base + aux->u.auxent.x_csect.x_scnlen.l;
2315 aux->fix_scnlen = 1;
2318 /* Return TRUE to indicate that the caller should not do any
2319 further work on this auxent. */
2323 /* Return FALSE to indicate that this auxent should be handled by
2331 /* We don't want to pointerize bal entries. */
2333 static bfd_boolean coff_pointerize_aux_hook
2334 PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
2335 unsigned int, combined_entry_type *));
2338 coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux)
2339 bfd *abfd ATTRIBUTE_UNUSED;
2340 combined_entry_type *table_base ATTRIBUTE_UNUSED;
2341 combined_entry_type *symbol;
2342 unsigned int indaux;
2343 combined_entry_type *aux ATTRIBUTE_UNUSED;
2345 /* Return TRUE if we don't want to pointerize this aux entry, which
2346 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
2348 && (symbol->u.syment.n_sclass == C_LEAFPROC
2349 || symbol->u.syment.n_sclass == C_LEAFSTAT
2350 || symbol->u.syment.n_sclass == C_LEAFEXT));
2355 #define coff_pointerize_aux_hook 0
2358 #endif /* ! RS6000COFF_C */
2360 /* Print an aux entry. This returns TRUE if it has printed it. */
2362 static bfd_boolean coff_print_aux
2363 PARAMS ((bfd *, FILE *, combined_entry_type *, combined_entry_type *,
2364 combined_entry_type *, unsigned int));
2367 coff_print_aux (abfd, file, table_base, symbol, aux, indaux)
2368 bfd *abfd ATTRIBUTE_UNUSED;
2369 FILE *file ATTRIBUTE_UNUSED;
2370 combined_entry_type *table_base ATTRIBUTE_UNUSED;
2371 combined_entry_type *symbol ATTRIBUTE_UNUSED;
2372 combined_entry_type *aux ATTRIBUTE_UNUSED;
2373 unsigned int indaux ATTRIBUTE_UNUSED;
2376 if ((symbol->u.syment.n_sclass == C_EXT
2377 || symbol->u.syment.n_sclass == C_HIDEXT)
2378 && indaux + 1 == symbol->u.syment.n_numaux)
2380 /* This is a csect entry. */
2381 fprintf (file, "AUX ");
2382 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) != XTY_LD)
2384 BFD_ASSERT (! aux->fix_scnlen);
2386 fprintf (file, "val %5lld", aux->u.auxent.x_csect.x_scnlen.l);
2388 fprintf (file, "val %5ld", (long) aux->u.auxent.x_csect.x_scnlen.l);
2393 fprintf (file, "indx ");
2394 if (! aux->fix_scnlen)
2396 fprintf (file, "%4lld", aux->u.auxent.x_csect.x_scnlen.l);
2398 fprintf (file, "%4ld", (long) aux->u.auxent.x_csect.x_scnlen.l);
2401 fprintf (file, "%4ld",
2402 (long) (aux->u.auxent.x_csect.x_scnlen.p - table_base));
2405 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2406 aux->u.auxent.x_csect.x_parmhash,
2407 (unsigned int) aux->u.auxent.x_csect.x_snhash,
2408 SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp),
2409 SMTYP_ALIGN (aux->u.auxent.x_csect.x_smtyp),
2410 (unsigned int) aux->u.auxent.x_csect.x_smclas,
2411 aux->u.auxent.x_csect.x_stab,
2412 (unsigned int) aux->u.auxent.x_csect.x_snstab);
2417 /* Return FALSE to indicate that no special action was taken. */
2425 To write relocations, the back end steps though the
2426 canonical relocation table and create an
2427 @code{internal_reloc}. The symbol index to use is removed from
2428 the @code{offset} field in the symbol table supplied. The
2429 address comes directly from the sum of the section base
2430 address and the relocation offset; the type is dug directly
2431 from the howto field. Then the @code{internal_reloc} is
2432 swapped into the shape of an @code{external_reloc} and written
2439 static int compare_arelent_ptr PARAMS ((const PTR, const PTR));
2441 /* AUX's ld wants relocations to be sorted. */
2443 compare_arelent_ptr (x, y)
2447 const arelent **a = (const arelent **) x;
2448 const arelent **b = (const arelent **) y;
2449 bfd_size_type aadr = (*a)->address;
2450 bfd_size_type badr = (*b)->address;
2452 return (aadr < badr ? -1 : badr < aadr ? 1 : 0);
2455 #endif /* TARG_AUX */
2458 coff_write_relocs (abfd, first_undef)
2464 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
2467 struct external_reloc dst;
2474 /* Sort relocations before we write them out. */
2477 amt = s->reloc_count;
2478 amt *= sizeof (arelent *);
2479 p = (arelent **) bfd_malloc (amt);
2480 if (p == NULL && s->reloc_count > 0)
2482 memcpy (p, s->orelocation, (size_t) amt);
2483 qsort (p, s->reloc_count, sizeof (arelent *), compare_arelent_ptr);
2487 if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0)
2491 if (obj_pe (abfd) && s->reloc_count >= 0xffff)
2493 /* Encode real count here as first reloc. */
2494 struct internal_reloc n;
2496 memset ((PTR) & n, 0, sizeof (n));
2497 /* Add one to count *this* reloc (grr). */
2498 n.r_vaddr = s->reloc_count + 1;
2499 coff_swap_reloc_out (abfd, &n, &dst);
2500 if (bfd_bwrite ((PTR) & dst, (bfd_size_type) bfd_coff_relsz (abfd),
2501 abfd) != bfd_coff_relsz (abfd))
2506 for (i = 0; i < s->reloc_count; i++)
2508 struct internal_reloc n;
2511 memset ((PTR) & n, 0, sizeof (n));
2513 /* Now we've renumbered the symbols we know where the
2514 undefined symbols live in the table. Check the reloc
2515 entries for symbols who's output bfd isn't the right one.
2516 This is because the symbol was undefined (which means
2517 that all the pointers are never made to point to the same
2518 place). This is a bad thing,'cause the symbols attached
2519 to the output bfd are indexed, so that the relocation
2520 entries know which symbol index they point to. So we
2521 have to look up the output symbol here. */
2523 if (q->sym_ptr_ptr[0]->the_bfd != abfd)
2526 const char *sname = q->sym_ptr_ptr[0]->name;
2527 asymbol **outsyms = abfd->outsymbols;
2529 for (j = first_undef; outsyms[j]; j++)
2531 const char *intable = outsyms[j]->name;
2533 if (strcmp (intable, sname) == 0) {
2534 /* Got a hit, so repoint the reloc. */
2535 q->sym_ptr_ptr = outsyms + j;
2541 n.r_vaddr = q->address + s->vma;
2544 /* The 29k const/consth reloc pair is a real kludge. The consth
2545 part doesn't have a symbol; it has an offset. So rebuilt
2547 if (q->howto->type == R_IHCONST)
2548 n.r_symndx = q->addend;
2553 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2554 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q,s))
2556 if ((*q->sym_ptr_ptr)->section == bfd_abs_section_ptr
2557 && ((*q->sym_ptr_ptr)->flags & BSF_SECTION_SYM) != 0)
2559 /* This is a relocation relative to the absolute symbol. */
2563 n.r_symndx = get_index ((*(q->sym_ptr_ptr)));
2564 /* Take notice if the symbol reloc points to a symbol
2565 we don't have in our symbol table. What should we
2567 if (n.r_symndx > obj_conv_table_size (abfd))
2572 #ifdef SWAP_OUT_RELOC_OFFSET
2573 n.r_offset = q->addend;
2577 /* Work out reloc type from what is required. */
2578 SELECT_RELOC (n, q->howto);
2580 n.r_type = q->howto->type;
2582 coff_swap_reloc_out (abfd, &n, &dst);
2584 if (bfd_bwrite ((PTR) & dst, (bfd_size_type) bfd_coff_relsz (abfd),
2585 abfd) != bfd_coff_relsz (abfd))
2598 /* Set flags and magic number of a coff file from architecture and machine
2599 type. Result is TRUE if we can represent the arch&type, FALSE if not. */
2602 coff_set_flags (abfd, magicp, flagsp)
2604 unsigned int *magicp ATTRIBUTE_UNUSED;
2605 unsigned short *flagsp ATTRIBUTE_UNUSED;
2607 switch (bfd_get_arch (abfd))
2612 switch (bfd_get_mach (abfd))
2614 case bfd_mach_z8001:
2617 case bfd_mach_z8002:
2631 *magicp = I960ROMAGIC;
2633 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
2634 I960RWMAGIC); FIXME???
2636 switch (bfd_get_mach (abfd))
2638 case bfd_mach_i960_core:
2641 case bfd_mach_i960_kb_sb:
2644 case bfd_mach_i960_mc:
2647 case bfd_mach_i960_xa:
2650 case bfd_mach_i960_ca:
2653 case bfd_mach_i960_ka_sa:
2656 case bfd_mach_i960_jx:
2659 case bfd_mach_i960_hx:
2672 case bfd_arch_tic30:
2673 *magicp = TIC30MAGIC;
2677 #ifdef TICOFF_DEFAULT_MAGIC
2678 case TICOFF_TARGET_ARCH:
2679 /* If there's no indication of which version we want, use the default. */
2681 *magicp = TICOFF_DEFAULT_MAGIC;
2684 /* We may want to output in a different COFF version. */
2685 switch (abfd->xvec->name[4])
2688 *magicp = TICOFF0MAGIC;
2691 *magicp = TICOFF1MAGIC;
2694 *magicp = TICOFF2MAGIC;
2700 TICOFF_TARGET_MACHINE_SET (flagsp, bfd_get_mach (abfd));
2704 #ifdef TIC80_ARCH_MAGIC
2705 case bfd_arch_tic80:
2706 *magicp = TIC80_ARCH_MAGIC;
2712 * magicp = ARMPEMAGIC;
2714 * magicp = ARMMAGIC;
2717 if (APCS_SET (abfd))
2719 if (APCS_26_FLAG (abfd))
2720 * flagsp |= F_APCS26;
2722 if (APCS_FLOAT_FLAG (abfd))
2723 * flagsp |= F_APCS_FLOAT;
2725 if (PIC_FLAG (abfd))
2728 if (INTERWORK_SET (abfd) && INTERWORK_FLAG (abfd))
2729 * flagsp |= F_INTERWORK;
2730 switch (bfd_get_mach (abfd))
2732 case bfd_mach_arm_2: * flagsp |= F_ARM_2; break;
2733 case bfd_mach_arm_2a: * flagsp |= F_ARM_2a; break;
2734 case bfd_mach_arm_3: * flagsp |= F_ARM_3; break;
2735 case bfd_mach_arm_3M: * flagsp |= F_ARM_3M; break;
2736 case bfd_mach_arm_4: * flagsp |= F_ARM_4; break;
2737 case bfd_mach_arm_4T: * flagsp |= F_ARM_4T; break;
2738 case bfd_mach_arm_5: * flagsp |= F_ARM_5; break;
2739 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5.
2740 See also the comment in coff_set_arch_mach_hook(). */
2741 case bfd_mach_arm_5T: * flagsp |= F_ARM_5; break;
2742 case bfd_mach_arm_5TE: * flagsp |= F_ARM_5; break;
2743 case bfd_mach_arm_XScale: * flagsp |= F_ARM_5; break;
2748 case bfd_arch_powerpc:
2755 *magicp = I386MAGIC;
2757 /* Just overwrite the usual value if we're doing Lynx. */
2758 *magicp = LYNXCOFFMAGIC;
2765 *magicp = I860MAGIC;
2771 *magicp = IA64MAGIC;
2777 #ifdef APOLLOM68KMAGIC
2778 *magicp = APOLLO_COFF_VERSION_NUMBER;
2780 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2781 #ifdef NAMES_HAVE_UNDERSCORE
2782 *magicp = MC68KBCSMAGIC;
2784 *magicp = MC68MAGIC;
2788 /* Just overwrite the usual value if we're doing Lynx. */
2789 *magicp = LYNXCOFFMAGIC;
2797 *magicp = MC88OMAGIC;
2802 case bfd_arch_h8300:
2803 switch (bfd_get_mach (abfd))
2805 case bfd_mach_h8300:
2806 *magicp = H8300MAGIC;
2808 case bfd_mach_h8300h:
2809 *magicp = H8300HMAGIC;
2811 case bfd_mach_h8300s:
2812 *magicp = H8300SMAGIC;
2814 case bfd_mach_h8300hn:
2815 *magicp = H8300HNMAGIC;
2817 case bfd_mach_h8300sn:
2818 *magicp = H8300SNMAGIC;
2824 #ifdef SH_ARCH_MAGIC_BIG
2826 #ifdef COFF_IMAGE_WITH_PE
2827 *magicp = SH_ARCH_MAGIC_WINCE;
2829 if (bfd_big_endian (abfd))
2830 *magicp = SH_ARCH_MAGIC_BIG;
2832 *magicp = SH_ARCH_MAGIC_LITTLE;
2838 #ifdef MIPS_ARCH_MAGIC_WINCE
2840 *magicp = MIPS_ARCH_MAGIC_WINCE;
2846 case bfd_arch_sparc:
2847 *magicp = SPARCMAGIC;
2849 /* Just overwrite the usual value if we're doing Lynx. */
2850 *magicp = LYNXCOFFMAGIC;
2857 case bfd_arch_h8500:
2858 *magicp = H8500MAGIC;
2862 #ifdef A29K_MAGIC_BIG
2864 if (bfd_big_endian (abfd))
2865 *magicp = A29K_MAGIC_BIG;
2867 *magicp = A29K_MAGIC_LITTLE;
2873 case bfd_arch_we32k:
2874 *magicp = WE32KMAGIC;
2880 case bfd_arch_rs6000:
2882 case bfd_arch_powerpc:
2884 BFD_ASSERT (bfd_get_flavour (abfd) == bfd_target_xcoff_flavour);
2885 *magicp = bfd_xcoff_magic_number (abfd);
2891 case bfd_arch_mcore:
2892 * magicp = MCOREMAGIC;
2902 #ifdef OR32_MAGIC_BIG
2904 if (bfd_big_endian (abfd))
2905 * magicp = OR32_MAGIC_BIG;
2907 * magicp = OR32_MAGIC_LITTLE;
2911 default: /* Unknown architecture. */
2912 /* Fall through to "return FALSE" below, to avoid
2913 "statement never reached" errors on the one below. */
2921 coff_set_arch_mach (abfd, arch, machine)
2923 enum bfd_architecture arch;
2924 unsigned long machine;
2927 unsigned short dummy2;
2929 if (! bfd_default_set_arch_mach (abfd, arch, machine))
2932 if (arch != bfd_arch_unknown
2933 && ! coff_set_flags (abfd, &dummy1, &dummy2))
2934 return FALSE; /* We can't represent this type */
2936 return TRUE; /* We're easy ... */
2939 #ifdef COFF_IMAGE_WITH_PE
2941 /* This is used to sort sections by VMA, as required by PE image
2944 static int sort_by_secaddr PARAMS ((const PTR, const PTR));
2947 sort_by_secaddr (arg1, arg2)
2951 const asection *a = *(const asection **) arg1;
2952 const asection *b = *(const asection **) arg2;
2954 if (a->vma < b->vma)
2956 else if (a->vma > b->vma)
2962 #endif /* COFF_IMAGE_WITH_PE */
2964 /* Calculate the file position for each section. */
2967 #define ALIGN_SECTIONS_IN_FILE
2969 #if defined(TIC80COFF) || defined(TICOFF)
2970 #undef ALIGN_SECTIONS_IN_FILE
2974 coff_compute_section_file_positions (abfd)
2978 asection *previous = (asection *) NULL;
2979 file_ptr sofar = bfd_coff_filhsz (abfd);
2980 bfd_boolean align_adjust;
2981 #ifdef ALIGN_SECTIONS_IN_FILE
2986 /* On XCOFF, if we have symbols, set up the .debug section. */
2987 if (bfd_get_symcount (abfd) > 0)
2990 bfd_size_type i, symcount;
2994 symcount = bfd_get_symcount (abfd);
2995 for (symp = abfd->outsymbols, i = 0; i < symcount; symp++, i++)
2997 coff_symbol_type *cf;
2999 cf = coff_symbol_from (abfd, *symp);
3001 && cf->native != NULL
3002 && SYMNAME_IN_DEBUG (&cf->native->u.syment))
3006 len = strlen (bfd_asymbol_name (*symp));
3007 if (len > SYMNMLEN || bfd_coff_force_symnames_in_strings (abfd))
3008 sz += len + 1 + bfd_coff_debug_string_prefix_length (abfd);
3015 dsec = bfd_make_section_old_way (abfd, DOT_DEBUG);
3018 dsec->_raw_size = sz;
3019 dsec->flags |= SEC_HAS_CONTENTS;
3024 #ifdef COFF_IMAGE_WITH_PE
3026 if (coff_data (abfd)->link_info)
3028 page_size = pe_data (abfd)->pe_opthdr.FileAlignment;
3030 /* If no file alignment has been set, default to one.
3031 This repairs 'ld -r' for arm-wince-pe target. */
3036 page_size = PE_DEF_FILE_ALIGNMENT;
3038 #ifdef COFF_PAGE_SIZE
3039 int page_size = COFF_PAGE_SIZE;
3043 if (bfd_get_start_address (abfd))
3045 /* A start address may have been added to the original file. In this
3046 case it will need an optional header to record it. */
3047 abfd->flags |= EXEC_P;
3050 if (abfd->flags & EXEC_P)
3051 sofar += bfd_coff_aoutsz (abfd);
3053 else if (xcoff_data (abfd)->full_aouthdr)
3054 sofar += bfd_coff_aoutsz (abfd);
3056 sofar += SMALL_AOUTSZ;
3059 sofar += abfd->section_count * bfd_coff_scnhsz (abfd);
3062 /* XCOFF handles overflows in the reloc and line number count fields
3063 by allocating a new section header to hold the correct counts. */
3064 for (current = abfd->sections; current != NULL; current = current->next)
3065 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3066 sofar += bfd_coff_scnhsz (abfd);
3069 #ifdef COFF_IMAGE_WITH_PE
3071 /* PE requires the sections to be in memory order when listed in
3072 the section headers. It also does not like empty loadable
3073 sections. The sections apparently do not have to be in the
3074 right order in the image file itself, but we do need to get the
3075 target_index values right. */
3078 asection **section_list;
3084 for (current = abfd->sections; current != NULL; current = current->next)
3087 /* We allocate an extra cell to simplify the final loop. */
3088 amt = sizeof (struct asection *) * (count + 1);
3089 section_list = bfd_malloc (amt);
3090 if (section_list == NULL)
3094 for (current = abfd->sections; current != NULL; current = current->next)
3096 section_list[i] = current;
3099 section_list[i] = NULL;
3101 qsort (section_list, count, sizeof (asection *), sort_by_secaddr);
3103 /* Rethread the linked list into sorted order; at the same time,
3104 assign target_index values. */
3106 abfd->sections = section_list[0];
3107 for (i = 0; i < count; i++)
3109 current = section_list[i];
3110 current->next = section_list[i + 1];
3112 /* Later, if the section has zero size, we'll be throwing it
3113 away, so we don't want to number it now. Note that having
3114 a zero size and having real contents are different
3115 concepts: .bss has no contents, but (usually) non-zero
3117 if (current->_raw_size == 0)
3119 /* Discard. However, it still might have (valid) symbols
3120 in it, so arbitrarily set it to section 1 (indexing is
3121 1-based here; usually .text). __end__ and other
3122 contents of .endsection really have this happen.
3123 FIXME: This seems somewhat dubious. */
3124 current->target_index = 1;
3127 current->target_index = target_index++;
3129 abfd->section_tail = ¤t->next;
3131 free (section_list);
3133 #else /* ! COFF_IMAGE_WITH_PE */
3135 /* Set the target_index field. */
3139 for (current = abfd->sections; current != NULL; current = current->next)
3140 current->target_index = target_index++;
3142 #endif /* ! COFF_IMAGE_WITH_PE */
3144 align_adjust = FALSE;
3145 for (current = abfd->sections;
3146 current != (asection *) NULL;
3147 current = current->next)
3149 #ifdef COFF_IMAGE_WITH_PE
3150 /* With PE we have to pad each section to be a multiple of its
3151 page size too, and remember both sizes. */
3152 if (coff_section_data (abfd, current) == NULL)
3154 bfd_size_type amt = sizeof (struct coff_section_tdata);
3155 current->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
3156 if (current->used_by_bfd == NULL)
3159 if (pei_section_data (abfd, current) == NULL)
3161 bfd_size_type amt = sizeof (struct pei_section_tdata);
3162 coff_section_data (abfd, current)->tdata
3163 = (PTR) bfd_zalloc (abfd, amt);
3164 if (coff_section_data (abfd, current)->tdata == NULL)
3167 if (pei_section_data (abfd, current)->virt_size == 0)
3168 pei_section_data (abfd, current)->virt_size = current->_raw_size;
3171 /* Only deal with sections which have contents. */
3172 if (!(current->flags & SEC_HAS_CONTENTS))
3175 #ifdef COFF_IMAGE_WITH_PE
3176 /* Make sure we skip empty sections in a PE image. */
3177 if (current->_raw_size == 0)
3181 /* Align the sections in the file to the same boundary on
3182 which they are aligned in virtual memory. I960 doesn't
3183 do this (FIXME) so we can stay in sync with Intel. 960
3184 doesn't yet page from files... */
3185 #ifdef ALIGN_SECTIONS_IN_FILE
3186 if ((abfd->flags & EXEC_P) != 0)
3188 /* Make sure this section is aligned on the right boundary - by
3189 padding the previous section up if necessary. */
3193 /* AIX loader checks the text section alignment of (vma - filepos)
3194 So even though the filepos may be aligned wrt the o_algntext, for
3195 AIX executables, this check fails. This shows up when a native
3196 AIX executable is stripped with gnu strip because the default vma
3197 of native is 0x10000150 but default for gnu is 0x10000140. Gnu
3198 stripped gnu excutable passes this check because the filepos is
3199 0x0140. This problem also show up with 64 bit shared objects. The
3200 data section must also be aligned. */
3201 if (!strcmp (current->name, _TEXT)
3202 || !strcmp (current->name, _DATA))
3207 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3209 align = 1 << current->alignment_power;
3210 pad = abs (current->vma - sofar) % align;
3221 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3224 if (previous != (asection *) NULL)
3225 previous->_raw_size += sofar - old_sofar;
3230 /* In demand paged files the low order bits of the file offset
3231 must match the low order bits of the virtual address. */
3232 #ifdef COFF_PAGE_SIZE
3233 if ((abfd->flags & D_PAGED) != 0
3234 && (current->flags & SEC_ALLOC) != 0)
3235 sofar += (current->vma - sofar) % page_size;
3237 current->filepos = sofar;
3239 #ifdef COFF_IMAGE_WITH_PE
3240 /* Set the padded size. */
3241 current->_raw_size = (current->_raw_size + page_size -1) & -page_size;
3244 sofar += current->_raw_size;
3246 #ifdef ALIGN_SECTIONS_IN_FILE
3247 /* Make sure that this section is of the right size too. */
3248 if ((abfd->flags & EXEC_P) == 0)
3250 bfd_size_type old_size;
3252 old_size = current->_raw_size;
3253 current->_raw_size = BFD_ALIGN (current->_raw_size,
3254 1 << current->alignment_power);
3255 align_adjust = current->_raw_size != old_size;
3256 sofar += current->_raw_size - old_size;
3261 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3262 align_adjust = sofar != old_sofar;
3263 current->_raw_size += sofar - old_sofar;
3267 #ifdef COFF_IMAGE_WITH_PE
3268 /* For PE we need to make sure we pad out to the aligned
3269 _raw_size, in case the caller only writes out data to the
3270 unaligned _raw_size. */
3271 if (pei_section_data (abfd, current)->virt_size < current->_raw_size)
3272 align_adjust = TRUE;
3276 /* Force .lib sections to start at zero. The vma is then
3277 incremented in coff_set_section_contents. This is right for
3279 if (strcmp (current->name, _LIB) == 0)
3280 bfd_set_section_vma (abfd, current, 0);
3286 /* It is now safe to write to the output file. If we needed an
3287 alignment adjustment for the last section, then make sure that
3288 there is a byte at offset sofar. If there are no symbols and no
3289 relocs, then nothing follows the last section. If we don't force
3290 the last byte out, then the file may appear to be truncated. */
3296 if (bfd_seek (abfd, sofar - 1, SEEK_SET) != 0
3297 || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
3301 /* Make sure the relocations are aligned. We don't need to make
3302 sure that this byte exists, because it will only matter if there
3303 really are relocs. */
3304 sofar = BFD_ALIGN (sofar, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER);
3306 obj_relocbase (abfd) = sofar;
3307 abfd->output_has_begun = TRUE;
3314 /* This can never work, because it is called too late--after the
3315 section positions have been set. I can't figure out what it is
3316 for, so I am going to disable it--Ian Taylor 20 March 1996. */
3318 /* If .file, .text, .data, .bss symbols are missing, add them. */
3319 /* @@ Should we only be adding missing symbols, or overriding the aux
3320 values for existing section symbols? */
3322 coff_add_missing_symbols (abfd)
3325 unsigned int nsyms = bfd_get_symcount (abfd);
3326 asymbol **sympp = abfd->outsymbols;
3329 int need_text = 1, need_data = 1, need_bss = 1, need_file = 1;
3332 for (i = 0; i < nsyms; i++)
3334 coff_symbol_type *csym = coff_symbol_from (abfd, sympp[i]);
3339 /* Only do this if there is a coff representation of the input
3341 if (csym->native && csym->native->u.syment.n_sclass == C_FILE)
3346 name = csym->symbol.name;
3349 if (!strcmp (name, _TEXT))
3352 else if (!strcmp (name, ".wtext"))
3355 else if (!strcmp (name, _DATA))
3357 else if (!strcmp (name, _BSS))
3361 /* Now i == bfd_get_symcount (abfd). */
3362 /* @@ For now, don't deal with .file symbol. */
3365 if (!need_text && !need_data && !need_bss && !need_file)
3367 nsyms += need_text + need_data + need_bss + need_file;
3369 amt *= sizeof (asymbol *);
3370 sympp2 = (asymbol **) bfd_alloc (abfd, amt);
3373 memcpy (sympp2, sympp, i * sizeof (asymbol *));
3376 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
3380 sympp2[i++] = coff_section_symbol (abfd, _TEXT);
3382 sympp2[i++] = coff_section_symbol (abfd, _DATA);
3384 sympp2[i++] = coff_section_symbol (abfd, _BSS);
3385 BFD_ASSERT (i == nsyms);
3386 bfd_set_symtab (abfd, sympp2, nsyms);
3392 #ifdef COFF_IMAGE_WITH_PE
3394 static unsigned int pelength;
3395 static unsigned int peheader;
3398 coff_read_word (abfd, value)
3400 unsigned int *value;
3405 status = bfd_bread (b, (bfd_size_type) 2, abfd);
3413 *value = (unsigned int) b[0];
3415 *value = (unsigned int) (b[0] + (b[1] << 8));
3417 pelength += (unsigned int) status;
3423 coff_compute_checksum (abfd)
3426 bfd_boolean more_data;
3433 filepos = (file_ptr) 0;
3437 if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
3440 more_data = coff_read_word (abfd, &value);
3442 total = 0xffff & (total + (total >> 0x10));
3447 return (0xffff & (total + (total >> 0x10)));
3451 coff_apply_checksum (abfd)
3454 unsigned int computed;
3455 unsigned int checksum = 0;
3457 if (bfd_seek (abfd, 0x3c, SEEK_SET) != 0)
3460 if (!coff_read_word (abfd, &peheader))
3463 if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0)
3467 bfd_bwrite (&checksum, (bfd_size_type) 4, abfd);
3469 if (bfd_seek (abfd, peheader, SEEK_SET) != 0)
3472 computed = coff_compute_checksum (abfd);
3474 checksum = computed + pelength;
3476 if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0)
3479 bfd_bwrite (&checksum, (bfd_size_type) 4, abfd);
3484 #endif /* COFF_IMAGE_WITH_PE */
3489 coff_write_object_contents (abfd)
3493 bfd_boolean hasrelocs = FALSE;
3494 bfd_boolean haslinno = FALSE;
3495 bfd_boolean hasdebug = FALSE;
3497 file_ptr reloc_base;
3498 file_ptr lineno_base;
3500 unsigned long reloc_size = 0, reloc_count = 0;
3501 unsigned long lnno_size = 0;
3502 bfd_boolean long_section_names;
3503 asection *text_sec = NULL;
3504 asection *data_sec = NULL;
3505 asection *bss_sec = NULL;
3506 struct internal_filehdr internal_f;
3507 struct internal_aouthdr internal_a;
3508 #ifdef COFF_LONG_SECTION_NAMES
3509 size_t string_size = STRING_SIZE_SIZE;
3512 bfd_set_error (bfd_error_system_call);
3514 /* Make a pass through the symbol table to count line number entries and
3515 put them into the correct asections. */
3517 lnno_size = coff_count_linenumbers (abfd) * bfd_coff_linesz (abfd);
3519 if (! abfd->output_has_begun)
3521 if (! coff_compute_section_file_positions (abfd))
3525 reloc_base = obj_relocbase (abfd);
3527 /* Work out the size of the reloc and linno areas. */
3529 for (current = abfd->sections; current != NULL; current =
3533 /* We store the actual reloc count in the first reloc's addr. */
3534 if (obj_pe (abfd) && current->reloc_count >= 0xffff)
3537 reloc_count += current->reloc_count;
3540 reloc_size = reloc_count * bfd_coff_relsz (abfd);
3542 lineno_base = reloc_base + reloc_size;
3543 sym_base = lineno_base + lnno_size;
3545 /* Indicate in each section->line_filepos its actual file address. */
3546 for (current = abfd->sections; current != NULL; current =
3549 if (current->lineno_count)
3551 current->line_filepos = lineno_base;
3552 current->moving_line_filepos = lineno_base;
3553 lineno_base += current->lineno_count * bfd_coff_linesz (abfd);
3557 current->line_filepos = 0;
3559 if (current->reloc_count)
3561 current->rel_filepos = reloc_base;
3562 reloc_base += current->reloc_count * bfd_coff_relsz (abfd);
3564 /* Extra reloc to hold real count. */
3565 if (obj_pe (abfd) && current->reloc_count >= 0xffff)
3566 reloc_base += bfd_coff_relsz (abfd);
3571 current->rel_filepos = 0;
3575 /* Write section headers to the file. */
3576 internal_f.f_nscns = 0;
3578 if ((abfd->flags & EXEC_P) != 0)
3579 scn_base = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
3582 scn_base = bfd_coff_filhsz (abfd);
3585 if (xcoff_data (abfd)->full_aouthdr)
3586 scn_base += bfd_coff_aoutsz (abfd);
3588 scn_base += SMALL_AOUTSZ;
3593 if (bfd_seek (abfd, scn_base, SEEK_SET) != 0)
3596 long_section_names = FALSE;
3597 for (current = abfd->sections;
3599 current = current->next)
3601 struct internal_scnhdr section;
3602 bfd_boolean is_reloc_section = FALSE;
3604 #ifdef COFF_IMAGE_WITH_PE
3605 if (strcmp (current->name, ".reloc") == 0)
3607 is_reloc_section = TRUE;
3609 pe_data (abfd)->has_reloc_section = 1;
3613 internal_f.f_nscns++;
3615 strncpy (section.s_name, current->name, SCNNMLEN);
3617 #ifdef COFF_LONG_SECTION_NAMES
3618 /* Handle long section names as in PE. This must be compatible
3619 with the code in coff_write_symbols and _bfd_coff_final_link. */
3623 len = strlen (current->name);
3626 memset (section.s_name, 0, SCNNMLEN);
3627 sprintf (section.s_name, "/%lu", (unsigned long) string_size);
3628 string_size += len + 1;
3629 long_section_names = TRUE;
3635 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3636 Ian Taylor <ian@cygnus.com>. */
3637 if (strcmp (current->name, _LIB) == 0)
3638 section.s_vaddr = 0;
3641 section.s_vaddr = current->vma;
3642 section.s_paddr = current->lma;
3643 section.s_size = current->_raw_size;
3644 #ifdef coff_get_section_load_page
3645 section.s_page = coff_get_section_load_page (current);
3649 section.s_paddr = 0;
3651 #ifdef COFF_IMAGE_WITH_PE
3652 /* Reminder: s_paddr holds the virtual size of the section. */
3653 if (coff_section_data (abfd, current) != NULL
3654 && pei_section_data (abfd, current) != NULL)
3655 section.s_paddr = pei_section_data (abfd, current)->virt_size;
3657 section.s_paddr = 0;
3660 /* If this section has no size or is unloadable then the scnptr
3662 if (current->_raw_size == 0 ||
3663 (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
3664 section.s_scnptr = 0;
3666 section.s_scnptr = current->filepos;
3668 section.s_relptr = current->rel_filepos;
3669 section.s_lnnoptr = current->line_filepos;
3670 section.s_nreloc = current->reloc_count;
3671 section.s_nlnno = current->lineno_count;
3672 #ifndef COFF_IMAGE_WITH_PE
3673 /* In PEI, relocs come in the .reloc section. */
3674 if (current->reloc_count != 0)
3677 if (current->lineno_count != 0)
3679 if ((current->flags & SEC_DEBUGGING) != 0
3680 && ! is_reloc_section)
3685 /* Indicate the use of an XCOFF overflow section header. */
3686 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3688 section.s_nreloc = 0xffff;
3689 section.s_nlnno = 0xffff;
3694 section.s_flags = sec_to_styp_flags (current->name, current->flags);
3696 if (!strcmp (current->name, _TEXT))
3698 else if (!strcmp (current->name, _DATA))
3700 else if (!strcmp (current->name, _BSS))
3704 section.s_align = (current->alignment_power
3705 ? 1 << current->alignment_power
3709 /* TI COFF puts the alignment power in bits 8-11 of the flags. */
3710 section.s_flags |= (current->alignment_power & 0xF) << 8;
3712 #ifdef COFF_ENCODE_ALIGNMENT
3713 COFF_ENCODE_ALIGNMENT(section, current->alignment_power);
3716 #ifdef COFF_IMAGE_WITH_PE
3717 /* Suppress output of the sections if they are null. ld
3718 includes the bss and data sections even if there is no size
3719 assigned to them. NT loader doesn't like it if these section
3720 headers are included if the sections themselves are not
3721 needed. See also coff_compute_section_file_positions. */
3722 if (section.s_size == 0)
3723 internal_f.f_nscns--;
3728 bfd_size_type amt = bfd_coff_scnhsz (abfd);
3730 if (coff_swap_scnhdr_out (abfd, §ion, &buff) == 0
3731 || bfd_bwrite ((PTR) &buff, amt, abfd) != amt)
3736 /* PE stores COMDAT section information in the symbol table. If
3737 this section is supposed to have some COMDAT info, track down
3738 the symbol in the symbol table and modify it. */
3739 if ((current->flags & SEC_LINK_ONCE) != 0)
3741 unsigned int i, count;
3743 coff_symbol_type *csym = NULL;
3747 count = bfd_get_symcount (abfd);
3748 for (i = 0, psym = abfd->outsymbols; i < count; i++, psym++)
3750 if ((*psym)->section != current)
3753 /* Remember the location of the first symbol in this
3755 if (psymsec == NULL)
3758 /* See if this is the section symbol. */
3759 if (strcmp ((*psym)->name, current->name) == 0)
3761 csym = coff_symbol_from (abfd, *psym);
3763 || csym->native == NULL
3764 || csym->native->u.syment.n_numaux < 1
3765 || csym->native->u.syment.n_sclass != C_STAT
3766 || csym->native->u.syment.n_type != T_NULL)
3769 /* Here *PSYM is the section symbol for CURRENT. */
3776 Note that we might not if we're converting the file from
3777 some other object file format. */
3780 combined_entry_type *aux;
3782 /* We don't touch the x_checksum field. The
3783 x_associated field is not currently supported. */
3785 aux = csym->native + 1;
3786 switch (current->flags & SEC_LINK_DUPLICATES)
3788 case SEC_LINK_DUPLICATES_DISCARD:
3789 aux->u.auxent.x_scn.x_comdat = IMAGE_COMDAT_SELECT_ANY;
3792 case SEC_LINK_DUPLICATES_ONE_ONLY:
3793 aux->u.auxent.x_scn.x_comdat =
3794 IMAGE_COMDAT_SELECT_NODUPLICATES;
3797 case SEC_LINK_DUPLICATES_SAME_SIZE:
3798 aux->u.auxent.x_scn.x_comdat =
3799 IMAGE_COMDAT_SELECT_SAME_SIZE;
3802 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
3803 aux->u.auxent.x_scn.x_comdat =
3804 IMAGE_COMDAT_SELECT_EXACT_MATCH;
3808 /* The COMDAT symbol must be the first symbol from this
3809 section in the symbol table. In order to make this
3810 work, we move the COMDAT symbol before the first
3811 symbol we found in the search above. It's OK to
3812 rearrange the symbol table at this point, because
3813 coff_renumber_symbols is going to rearrange it
3814 further and fix up all the aux entries. */
3815 if (psym != psymsec)
3821 for (pcopy = psym; pcopy > psymsec; pcopy--)
3822 pcopy[0] = pcopy[-1];
3827 #endif /* COFF_WITH_PE */
3832 /* XCOFF handles overflows in the reloc and line number count fields
3833 by creating a new section header to hold the correct values. */
3834 for (current = abfd->sections; current != NULL; current = current->next)
3836 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3838 struct internal_scnhdr scnhdr;
3842 internal_f.f_nscns++;
3843 strncpy (&(scnhdr.s_name[0]), current->name, 8);
3844 scnhdr.s_paddr = current->reloc_count;
3845 scnhdr.s_vaddr = current->lineno_count;
3847 scnhdr.s_scnptr = 0;
3848 scnhdr.s_relptr = current->rel_filepos;
3849 scnhdr.s_lnnoptr = current->line_filepos;
3850 scnhdr.s_nreloc = current->target_index;
3851 scnhdr.s_nlnno = current->target_index;
3852 scnhdr.s_flags = STYP_OVRFLO;
3853 amt = bfd_coff_scnhsz (abfd);
3854 if (coff_swap_scnhdr_out (abfd, &scnhdr, &buff) == 0
3855 || bfd_bwrite ((PTR) &buff, amt, abfd) != amt)
3862 /* OK, now set up the filehdr... */
3864 /* Don't include the internal abs section in the section count */
3866 /* We will NOT put a fucking timestamp in the header here. Every time you
3867 put it back, I will come in and take it out again. I'm sorry. This
3868 field does not belong here. We fill it with a 0 so it compares the
3869 same but is not a reasonable time. -- gnu@cygnus.com */
3870 internal_f.f_timdat = 0;
3871 internal_f.f_flags = 0;
3873 if (abfd->flags & EXEC_P)
3874 internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
3877 internal_f.f_opthdr = 0;
3880 if (xcoff_data (abfd)->full_aouthdr)
3881 internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
3883 internal_f.f_opthdr = SMALL_AOUTSZ;
3889 internal_f.f_flags |= F_RELFLG;
3891 internal_f.f_flags |= F_LNNO;
3892 if (abfd->flags & EXEC_P)
3893 internal_f.f_flags |= F_EXEC;
3894 #ifdef COFF_IMAGE_WITH_PE
3896 internal_f.f_flags |= IMAGE_FILE_DEBUG_STRIPPED;
3900 internal_f.f_flags |= IMAGE_FILE_32BIT_MACHINE;
3902 if (bfd_little_endian (abfd))
3903 internal_f.f_flags |= F_AR32WR;
3905 internal_f.f_flags |= F_AR32W;
3909 /* Target id is used in TI COFF v1 and later; COFF0 won't use this field,
3910 but it doesn't hurt to set it internally. */
3911 internal_f.f_target_id = TI_TARGET_ID;
3913 #ifdef TIC80_TARGET_ID
3914 internal_f.f_target_id = TIC80_TARGET_ID;
3917 /* FIXME, should do something about the other byte orders and
3921 if ((abfd->flags & DYNAMIC) != 0)
3922 internal_f.f_flags |= F_SHROBJ;
3923 if (bfd_get_section_by_name (abfd, _LOADER) != NULL)
3924 internal_f.f_flags |= F_DYNLOAD;
3927 memset (&internal_a, 0, sizeof internal_a);
3929 /* Set up architecture-dependent stuff. */
3931 unsigned int magic = 0;
3932 unsigned short flags = 0;
3934 coff_set_flags (abfd, &magic, &flags);
3935 internal_f.f_magic = magic;
3936 internal_f.f_flags |= flags;
3937 /* ...and the "opt"hdr... */
3940 #ifdef ULTRA3 /* NYU's machine */
3941 /* FIXME: This is a bogus check. I really want to see if there
3942 is a .shbss or a .shdata section, if so then set the magic
3943 number to indicate a shared data executable. */
3944 if (internal_f.f_nscns >= 7)
3945 internal_a.magic = SHMAGIC; /* Shared magic. */
3948 internal_a.magic = NMAGIC; /* Assume separate i/d. */
3949 #define __A_MAGIC_SET__
3951 #ifdef TICOFF_AOUT_MAGIC
3952 internal_a.magic = TICOFF_AOUT_MAGIC;
3953 #define __A_MAGIC_SET__
3956 internal_a.magic = TIC80_ARCH_MAGIC;
3957 #define __A_MAGIC_SET__
3960 /* FIXME: What are the a.out magic numbers for the i860? */
3961 internal_a.magic = 0;
3962 #define __A_MAGIC_SET__
3965 internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
3966 #define __A_MAGIC_SET__
3969 #define __A_MAGIC_SET__
3970 internal_a.magic = PAGEMAGICBCS;
3974 #define __A_MAGIC_SET__
3975 internal_a.magic = APOLLO_COFF_VERSION_NUMBER;
3978 #if defined(M68) || defined(WE32K) || defined(M68K)
3979 #define __A_MAGIC_SET__
3981 internal_a.magic = LYNXCOFFMAGIC;
3983 #if defined(TARG_AUX)
3984 internal_a.magic = (abfd->flags & D_PAGED ? PAGEMAGICPEXECPAGED :
3985 abfd->flags & WP_TEXT ? PAGEMAGICPEXECSWAPPED :
3986 PAGEMAGICEXECSWAPPED);
3988 #if defined (PAGEMAGICPEXECPAGED)
3989 internal_a.magic = PAGEMAGICPEXECPAGED;
3991 #endif /* TARG_AUX */
3993 #endif /* M68 || WE32K || M68K */
3996 #define __A_MAGIC_SET__
3997 internal_a.magic = ZMAGIC;
4001 #define __A_MAGIC_SET__
4002 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
4005 #if defined MCORE_PE
4006 #define __A_MAGIC_SET__
4007 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
4011 #define __A_MAGIC_SET__
4013 internal_a.magic = LYNXCOFFMAGIC;
4015 internal_a.magic = ZMAGIC;
4020 #define __A_MAGIC_SET__
4021 internal_a.magic = ZMAGIC;
4025 #define __A_MAGIC_SET__
4027 internal_a.magic = LYNXCOFFMAGIC;
4032 #define __A_MAGIC_SET__
4033 internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC :
4034 (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC :
4035 RS6K_AOUTHDR_OMAGIC;
4038 #if defined(SH) && defined(COFF_WITH_PE)
4039 #define __A_MAGIC_SET__
4040 internal_a.magic = SH_PE_MAGIC;
4043 #if defined(MIPS) && defined(COFF_WITH_PE)
4044 #define __A_MAGIC_SET__
4045 internal_a.magic = MIPS_PE_MAGIC;
4049 #define __A_MAGIC_SET__
4050 internal_a.magic = NMAGIC; /* Assume separate i/d. */
4053 #ifndef __A_MAGIC_SET__
4054 #include "Your aouthdr magic number is not being set!"
4056 #undef __A_MAGIC_SET__
4060 /* FIXME: Does anybody ever set this to another value? */
4061 internal_a.vstamp = 0;
4063 /* Now should write relocs, strings, syms. */
4064 obj_sym_filepos (abfd) = sym_base;
4066 if (bfd_get_symcount (abfd) != 0)
4070 if (!coff_add_missing_symbols (abfd))
4073 if (!coff_renumber_symbols (abfd, &firstundef))
4075 coff_mangle_symbols (abfd);
4076 if (! coff_write_symbols (abfd))
4078 if (! coff_write_linenumbers (abfd))
4080 if (! coff_write_relocs (abfd, firstundef))
4083 #ifdef COFF_LONG_SECTION_NAMES
4084 else if (long_section_names && ! obj_coff_strings_written (abfd))
4086 /* If we have long section names we have to write out the string
4087 table even if there are no symbols. */
4088 if (! coff_write_symbols (abfd))
4092 #ifdef COFF_IMAGE_WITH_PE
4094 else if ((abfd->flags & EXEC_P) != 0)
4098 /* PowerPC PE appears to require that all executable files be
4099 rounded up to the page size. */
4102 (file_ptr) BFD_ALIGN (sym_base, COFF_PAGE_SIZE) - 1,
4104 || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
4110 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
4111 backend linker, and obj_raw_syment_count is not valid until after
4112 coff_write_symbols is called. */
4113 if (obj_raw_syment_count (abfd) != 0)
4115 internal_f.f_symptr = sym_base;
4117 /* AIX appears to require that F_RELFLG not be set if there are
4118 local symbols but no relocations. */
4119 internal_f.f_flags &=~ F_RELFLG;
4124 if (long_section_names)
4125 internal_f.f_symptr = sym_base;
4127 internal_f.f_symptr = 0;
4128 internal_f.f_flags |= F_LSYMS;
4133 internal_a.tsize = bfd_get_section_size_before_reloc (text_sec);
4134 internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
4138 internal_a.dsize = bfd_get_section_size_before_reloc (data_sec);
4139 internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
4143 internal_a.bsize = bfd_get_section_size_before_reloc (bss_sec);
4144 if (internal_a.bsize && bss_sec->vma < internal_a.data_start)
4145 internal_a.data_start = bss_sec->vma;
4148 internal_a.entry = bfd_get_start_address (abfd);
4149 internal_f.f_nsyms = obj_raw_syment_count (abfd);
4152 if (xcoff_data (abfd)->full_aouthdr)
4155 asection *loader_sec;
4157 internal_a.vstamp = 1;
4159 internal_a.o_snentry = xcoff_data (abfd)->snentry;
4160 if (internal_a.o_snentry == 0)
4161 internal_a.entry = (bfd_vma) -1;
4163 if (text_sec != NULL)
4165 internal_a.o_sntext = text_sec->target_index;
4166 internal_a.o_algntext = bfd_get_section_alignment (abfd, text_sec);
4170 internal_a.o_sntext = 0;
4171 internal_a.o_algntext = 0;
4173 if (data_sec != NULL)
4175 internal_a.o_sndata = data_sec->target_index;
4176 internal_a.o_algndata = bfd_get_section_alignment (abfd, data_sec);
4180 internal_a.o_sndata = 0;
4181 internal_a.o_algndata = 0;
4183 loader_sec = bfd_get_section_by_name (abfd, ".loader");
4184 if (loader_sec != NULL)
4185 internal_a.o_snloader = loader_sec->target_index;
4187 internal_a.o_snloader = 0;
4188 if (bss_sec != NULL)
4189 internal_a.o_snbss = bss_sec->target_index;
4191 internal_a.o_snbss = 0;
4193 toc = xcoff_data (abfd)->toc;
4194 internal_a.o_toc = toc;
4195 internal_a.o_sntoc = xcoff_data (abfd)->sntoc;
4197 internal_a.o_modtype = xcoff_data (abfd)->modtype;
4198 if (xcoff_data (abfd)->cputype != -1)
4199 internal_a.o_cputype = xcoff_data (abfd)->cputype;
4202 switch (bfd_get_arch (abfd))
4204 case bfd_arch_rs6000:
4205 internal_a.o_cputype = 4;
4207 case bfd_arch_powerpc:
4208 if (bfd_get_mach (abfd) == bfd_mach_ppc)
4209 internal_a.o_cputype = 3;
4211 internal_a.o_cputype = 1;
4217 internal_a.o_maxstack = xcoff_data (abfd)->maxstack;
4218 internal_a.o_maxdata = xcoff_data (abfd)->maxdata;
4222 /* now write them */
4223 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
4228 bfd_size_type amount = bfd_coff_filhsz (abfd);
4230 buff = bfd_malloc (amount);
4234 bfd_coff_swap_filehdr_out (abfd, (PTR) &internal_f, (PTR) buff);
4235 amount = bfd_bwrite ((PTR) buff, amount, abfd);
4239 if (amount != bfd_coff_filhsz (abfd))
4243 if (abfd->flags & EXEC_P)
4245 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4246 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)). */
4248 bfd_size_type amount = bfd_coff_aoutsz (abfd);
4250 buff = bfd_malloc (amount);
4254 coff_swap_aouthdr_out (abfd, (PTR) &internal_a, (PTR) buff);
4255 amount = bfd_bwrite ((PTR) buff, amount, abfd);
4259 if (amount != bfd_coff_aoutsz (abfd))
4262 #ifdef COFF_IMAGE_WITH_PE
4263 if (! coff_apply_checksum (abfd))
4273 /* XCOFF seems to always write at least a small a.out header. */
4274 coff_swap_aouthdr_out (abfd, (PTR) &internal_a, (PTR) &buff);
4275 if (xcoff_data (abfd)->full_aouthdr)
4276 size = bfd_coff_aoutsz (abfd);
4278 size = SMALL_AOUTSZ;
4279 if (bfd_bwrite ((PTR) &buff, (bfd_size_type) size, abfd) != size)
4288 coff_set_section_contents (abfd, section, location, offset, count)
4293 bfd_size_type count;
4295 if (! abfd->output_has_begun) /* Set by bfd.c handler. */
4297 if (! coff_compute_section_file_positions (abfd))
4301 #if defined(_LIB) && !defined(TARG_AUX)
4303 /* The physical address field of a .lib section is used to hold the
4304 number of shared libraries in the section. This code counts the
4305 number of sections being written, and increments the lma field
4308 I have found no documentation on the contents of this section.
4309 Experimentation indicates that the section contains zero or more
4310 records, each of which has the following structure:
4312 - a (four byte) word holding the length of this record, in words,
4313 - a word that always seems to be set to "2",
4314 - the path to a shared library, null-terminated and then padded
4315 to a whole word boundary.
4317 bfd_assert calls have been added to alert if an attempt is made
4318 to write a section which doesn't follow these assumptions. The
4319 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4320 <robertl@arnet.com> (Thanks!).
4322 Gvran Uddeborg <gvran@uddeborg.pp.se>. */
4324 if (strcmp (section->name, _LIB) == 0)
4326 bfd_byte *rec, *recend;
4328 rec = (bfd_byte *) location;
4329 recend = rec + count;
4330 while (rec < recend)
4333 rec += bfd_get_32 (abfd, rec) * 4;
4336 BFD_ASSERT (rec == recend);
4341 /* Don't write out bss sections - one way to do this is to
4342 see if the filepos has not been set. */
4343 if (section->filepos == 0)
4346 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0)
4352 return bfd_bwrite (location, count, abfd) == count;
4356 coff_close_and_cleanup (abfd)
4359 if (!bfd_read_p (abfd))
4360 switch (abfd->format)
4363 if (!_bfd_write_archive_contents (abfd))
4367 if (!coff_write_object_contents (abfd))
4371 bfd_set_error (bfd_error_invalid_operation);
4375 /* We depend on bfd_close to free all the memory on the objalloc. */
4382 buy_and_read (abfd, where, size)
4387 PTR area = (PTR) bfd_alloc (abfd, size);
4390 if (bfd_seek (abfd, where, SEEK_SET) != 0
4391 || bfd_bread (area, size, abfd) != size)
4394 } /* buy_and_read() */
4400 Creating the linenumber table is done by reading in the entire
4401 coff linenumber table, and creating another table for internal use.
4403 A coff linenumber table is structured so that each function
4404 is marked as having a line number of 0. Each line within the
4405 function is an offset from the first line in the function. The
4406 base of the line number information for the table is stored in
4407 the symbol associated with the function.
4409 Note: The PE format uses line number 0 for a flag indicating a
4412 The information is copied from the external to the internal
4413 table, and each symbol which marks a function is marked by
4416 How does this work ?
4421 coff_slurp_line_table (abfd, asect)
4425 LINENO *native_lineno;
4426 alent *lineno_cache;
4429 BFD_ASSERT (asect->lineno == (alent *) NULL);
4431 amt = (bfd_size_type) bfd_coff_linesz (abfd) * asect->lineno_count;
4432 native_lineno = (LINENO *) buy_and_read (abfd, asect->line_filepos, amt);
4433 if (native_lineno == NULL)
4435 (*_bfd_error_handler)
4436 (_("%s: warning: line number table read failed"),
4437 bfd_archive_filename (abfd));
4440 amt = ((bfd_size_type) asect->lineno_count + 1) * sizeof (alent);
4441 lineno_cache = (alent *) bfd_alloc (abfd, amt);
4442 if (lineno_cache == NULL)
4446 unsigned int counter = 0;
4447 alent *cache_ptr = lineno_cache;
4448 LINENO *src = native_lineno;
4450 while (counter < asect->lineno_count)
4452 struct internal_lineno dst;
4454 bfd_coff_swap_lineno_in (abfd, src, &dst);
4455 cache_ptr->line_number = dst.l_lnno;
4457 if (cache_ptr->line_number == 0)
4460 bfd_signed_vma symndx;
4461 coff_symbol_type *sym;
4464 symndx = dst.l_addr.l_symndx;
4466 || (bfd_vma) symndx >= obj_raw_syment_count (abfd))
4468 (*_bfd_error_handler)
4469 (_("%s: warning: illegal symbol index %ld in line numbers"),
4470 bfd_archive_filename (abfd), dst.l_addr.l_symndx);
4474 /* FIXME: We should not be casting between ints and
4475 pointers like this. */
4476 sym = ((coff_symbol_type *)
4477 ((symndx + obj_raw_syments (abfd))
4478 ->u.syment._n._n_n._n_zeroes));
4479 cache_ptr->u.sym = (asymbol *) sym;
4480 if (sym->lineno != NULL && ! warned)
4482 (*_bfd_error_handler)
4483 (_("%s: warning: duplicate line number information for `%s'"),
4484 bfd_archive_filename (abfd),
4485 bfd_asymbol_name (&sym->symbol));
4487 sym->lineno = cache_ptr;
4491 cache_ptr->u.offset = dst.l_addr.l_paddr
4492 - bfd_section_vma (abfd, asect);
4493 } /* If no linenumber expect a symbol index */
4499 cache_ptr->line_number = 0;
4502 asect->lineno = lineno_cache;
4503 /* FIXME, free native_lineno here, or use alloca or something. */
4507 /* Slurp in the symbol table, converting it to generic form. Note
4508 that if coff_relocate_section is defined, the linker will read
4509 symbols via coff_link_add_symbols, rather than via this routine. */
4512 coff_slurp_symbol_table (abfd)
4515 combined_entry_type *native_symbols;
4516 coff_symbol_type *cached_area;
4517 unsigned int *table_ptr;
4519 unsigned int number_of_symbols = 0;
4521 if (obj_symbols (abfd))
4524 /* Read in the symbol table. */
4525 if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL)
4528 /* Allocate enough room for all the symbols in cached form. */
4529 amt = obj_raw_syment_count (abfd);
4530 amt *= sizeof (coff_symbol_type);
4531 cached_area = (coff_symbol_type *) bfd_alloc (abfd, amt);
4532 if (cached_area == NULL)
4535 amt = obj_raw_syment_count (abfd);
4536 amt *= sizeof (unsigned int);
4537 table_ptr = (unsigned int *) bfd_alloc (abfd, amt);
4539 if (table_ptr == NULL)
4543 coff_symbol_type *dst = cached_area;
4544 unsigned int last_native_index = obj_raw_syment_count (abfd);
4545 unsigned int this_index = 0;
4547 while (this_index < last_native_index)
4549 combined_entry_type *src = native_symbols + this_index;
4550 table_ptr[this_index] = number_of_symbols;
4551 dst->symbol.the_bfd = abfd;
4553 dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset);
4554 /* We use the native name field to point to the cached field. */
4555 src->u.syment._n._n_n._n_zeroes = (long) dst;
4556 dst->symbol.section = coff_section_from_bfd_index (abfd,
4557 src->u.syment.n_scnum);
4558 dst->symbol.flags = 0;
4559 dst->done_lineno = FALSE;
4561 switch (src->u.syment.n_sclass)
4566 dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
4567 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
4568 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4570 /* Fall through to next case. */
4577 case C_THUMBEXTFUNC:
4583 case C_SYSTEM: /* System Wide variable. */
4586 /* In PE, 0x68 (104) denotes a section symbol. */
4588 /* In PE, 0x69 (105) denotes a weak external symbol. */
4591 switch (coff_classify_symbol (abfd, &src->u.syment))
4593 case COFF_SYMBOL_GLOBAL:
4594 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
4595 #if defined COFF_WITH_PE
4596 /* PE sets the symbol to a value relative to the
4597 start of the section. */
4598 dst->symbol.value = src->u.syment.n_value;
4600 dst->symbol.value = (src->u.syment.n_value
4601 - dst->symbol.section->vma);
4603 if (ISFCN ((src->u.syment.n_type)))
4605 /* A function ext does not go at the end of a
4607 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4611 case COFF_SYMBOL_COMMON:
4612 dst->symbol.section = bfd_com_section_ptr;
4613 dst->symbol.value = src->u.syment.n_value;
4616 case COFF_SYMBOL_UNDEFINED:
4617 dst->symbol.section = bfd_und_section_ptr;
4618 dst->symbol.value = 0;
4621 case COFF_SYMBOL_PE_SECTION:
4622 dst->symbol.flags |= BSF_EXPORT | BSF_SECTION_SYM;
4623 dst->symbol.value = 0;
4626 case COFF_SYMBOL_LOCAL:
4627 dst->symbol.flags = BSF_LOCAL;
4628 #if defined COFF_WITH_PE
4629 /* PE sets the symbol to a value relative to the
4630 start of the section. */
4631 dst->symbol.value = src->u.syment.n_value;
4633 dst->symbol.value = (src->u.syment.n_value
4634 - dst->symbol.section->vma);
4636 if (ISFCN ((src->u.syment.n_type)))
4637 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4642 /* A symbol with a csect entry should not go at the end. */
4643 if (src->u.syment.n_numaux > 0)
4644 dst->symbol.flags |= BSF_NOT_AT_END;
4648 if (src->u.syment.n_sclass == C_NT_WEAK)
4649 dst->symbol.flags |= BSF_WEAK;
4651 if (src->u.syment.n_sclass == C_SECTION
4652 && src->u.syment.n_scnum > 0)
4653 dst->symbol.flags = BSF_LOCAL;
4655 if (src->u.syment.n_sclass == C_WEAKEXT)
4656 dst->symbol.flags |= BSF_WEAK;
4660 case C_STAT: /* Static. */
4662 case C_LEAFSTAT: /* Static leaf procedure. */
4665 case C_THUMBSTAT: /* Thumb static. */
4666 case C_THUMBLABEL: /* Thumb label. */
4667 case C_THUMBSTATFUNC:/* Thumb static function. */
4669 case C_LABEL: /* Label. */
4670 if (src->u.syment.n_scnum == N_DEBUG)
4671 dst->symbol.flags = BSF_DEBUGGING;
4673 dst->symbol.flags = BSF_LOCAL;
4675 /* Base the value as an index from the base of the
4676 section, if there is one. */
4677 if (dst->symbol.section)
4679 #if defined COFF_WITH_PE
4680 /* PE sets the symbol to a value relative to the
4681 start of the section. */
4682 dst->symbol.value = src->u.syment.n_value;
4684 dst->symbol.value = (src->u.syment.n_value
4685 - dst->symbol.section->vma);
4689 dst->symbol.value = src->u.syment.n_value;
4692 case C_MOS: /* Member of structure. */
4693 case C_EOS: /* End of structure. */
4694 #ifdef NOTDEF /* C_AUTOARG has the same value. */
4696 case C_GLBLREG: /* A29k-specific storage class. */
4699 case C_REGPARM: /* Register parameter. */
4700 case C_REG: /* register variable. */
4701 /* C_AUTOARG conflicts with TI COFF C_UEXT. */
4702 #if !defined (TIC80COFF) && !defined (TICOFF)
4704 case C_AUTOARG: /* 960-specific storage class. */
4707 case C_TPDEF: /* Type definition. */
4709 case C_AUTO: /* Automatic variable. */
4710 case C_FIELD: /* Bit field. */
4711 case C_ENTAG: /* Enumeration tag. */
4712 case C_MOE: /* Member of enumeration. */
4713 case C_MOU: /* Member of union. */
4714 case C_UNTAG: /* Union tag. */
4715 dst->symbol.flags = BSF_DEBUGGING;
4716 dst->symbol.value = (src->u.syment.n_value);
4719 case C_FILE: /* File name. */
4720 case C_STRTAG: /* Structure tag. */
4737 dst->symbol.flags = BSF_DEBUGGING;
4738 dst->symbol.value = (src->u.syment.n_value);
4742 case C_BINCL: /* Beginning of include file. */
4743 case C_EINCL: /* Ending of include file. */
4744 /* The value is actually a pointer into the line numbers
4745 of the file. We locate the line number entry, and
4746 set the section to the section which contains it, and
4747 the value to the index in that section. */
4751 dst->symbol.flags = BSF_DEBUGGING;
4752 for (sec = abfd->sections; sec != NULL; sec = sec->next)
4753 if (sec->line_filepos <= (file_ptr) src->u.syment.n_value
4754 && ((file_ptr) (sec->line_filepos
4755 + sec->lineno_count * bfd_coff_linesz (abfd))
4756 > (file_ptr) src->u.syment.n_value))
4759 dst->symbol.value = 0;
4762 dst->symbol.section = sec;
4763 dst->symbol.value = ((src->u.syment.n_value
4764 - sec->line_filepos)
4765 / bfd_coff_linesz (abfd));
4772 dst->symbol.flags = BSF_DEBUGGING;
4774 /* The value is actually a symbol index. Save a pointer
4775 to the symbol instead of the index. FIXME: This
4776 should use a union. */
4777 src->u.syment.n_value =
4778 (long) (native_symbols + src->u.syment.n_value);
4779 dst->symbol.value = src->u.syment.n_value;
4784 case C_BLOCK: /* ".bb" or ".eb". */
4785 case C_FCN: /* ".bf" or ".ef" (or PE ".lf"). */
4786 case C_EFCN: /* Physical end of function. */
4787 #if defined COFF_WITH_PE
4788 /* PE sets the symbol to a value relative to the start
4790 dst->symbol.value = src->u.syment.n_value;
4791 if (strcmp (dst->symbol.name, ".bf") != 0)
4793 /* PE uses funny values for .ef and .lf; don't
4795 dst->symbol.flags = BSF_DEBUGGING;
4798 dst->symbol.flags = BSF_DEBUGGING | BSF_DEBUGGING_RELOC;
4800 /* Base the value as an index from the base of the
4802 dst->symbol.flags = BSF_LOCAL;
4803 dst->symbol.value = (src->u.syment.n_value
4804 - dst->symbol.section->vma);
4808 case C_STATLAB: /* Static load time label. */
4809 dst->symbol.value = src->u.syment.n_value;
4810 dst->symbol.flags = BSF_GLOBAL;
4814 /* PE DLLs sometimes have zeroed out symbols for some
4815 reason. Just ignore them without a warning. */
4816 if (src->u.syment.n_type == 0
4817 && src->u.syment.n_value == 0
4818 && src->u.syment.n_scnum == 0)
4821 case C_EXTDEF: /* External definition. */
4822 case C_ULABEL: /* Undefined label. */
4823 case C_USTATIC: /* Undefined static. */
4824 #ifndef COFF_WITH_PE
4825 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4826 class to represent a section symbol. */
4827 case C_LINE: /* line # reformatted as symbol table entry. */
4828 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4829 case C_ALIAS: /* Duplicate tag. */
4831 /* New storage classes for TI COFF. */
4832 #if defined(TIC80COFF) || defined(TICOFF)
4833 case C_UEXT: /* Tentative external definition. */
4835 case C_EXTLAB: /* External load time label. */
4836 case C_HIDDEN: /* Ext symbol in dmert public lib. */
4838 (*_bfd_error_handler)
4839 (_("%s: Unrecognized storage class %d for %s symbol `%s'"),
4840 bfd_archive_filename (abfd), src->u.syment.n_sclass,
4841 dst->symbol.section->name, dst->symbol.name);
4842 dst->symbol.flags = BSF_DEBUGGING;
4843 dst->symbol.value = (src->u.syment.n_value);
4847 /* BFD_ASSERT(dst->symbol.flags != 0);*/
4851 dst->symbol.udata.i = 0;
4852 dst->lineno = (alent *) NULL;
4853 this_index += (src->u.syment.n_numaux) + 1;
4855 number_of_symbols++;
4859 obj_symbols (abfd) = cached_area;
4860 obj_raw_syments (abfd) = native_symbols;
4862 bfd_get_symcount (abfd) = number_of_symbols;
4863 obj_convert (abfd) = table_ptr;
4864 /* Slurp the line tables for each section too. */
4871 coff_slurp_line_table (abfd, p);
4877 } /* coff_slurp_symbol_table() */
4879 /* Classify a COFF symbol. A couple of targets have globally visible
4880 symbols which are not class C_EXT, and this handles those. It also
4881 recognizes some special PE cases. */
4883 static enum coff_symbol_classification
4884 coff_classify_symbol (abfd, syment)
4886 struct internal_syment *syment;
4888 /* FIXME: This partially duplicates the switch in
4889 coff_slurp_symbol_table. */
4890 switch (syment->n_sclass)
4899 case C_THUMBEXTFUNC:
4907 if (syment->n_scnum == 0)
4909 if (syment->n_value == 0)
4910 return COFF_SYMBOL_UNDEFINED;
4912 return COFF_SYMBOL_COMMON;
4914 return COFF_SYMBOL_GLOBAL;
4921 if (syment->n_sclass == C_STAT)
4923 if (syment->n_scnum == 0)
4925 /* The Microsoft compiler sometimes generates these if a
4926 small static function is inlined every time it is used.
4927 The function is discarded, but the symbol table entry
4929 return COFF_SYMBOL_LOCAL;
4932 #ifdef STRICT_PE_FORMAT
4933 /* This is correct for Microsoft generated objects, but it
4934 breaks gas generated objects. */
4936 if (syment->n_value == 0)
4939 char buf[SYMNMLEN + 1];
4941 sec = coff_section_from_bfd_index (abfd, syment->n_scnum);
4943 && (strcmp (bfd_get_section_name (abfd, sec),
4944 _bfd_coff_internal_syment_name (abfd, syment, buf))
4946 return COFF_SYMBOL_PE_SECTION;
4950 return COFF_SYMBOL_LOCAL;
4953 if (syment->n_sclass == C_SECTION)
4955 /* In some cases in a DLL generated by the Microsoft linker, the
4956 n_value field will contain garbage. FIXME: This should
4957 probably be handled by the swapping function instead. */
4958 syment->n_value = 0;
4959 if (syment->n_scnum == 0)
4960 return COFF_SYMBOL_UNDEFINED;
4961 return COFF_SYMBOL_PE_SECTION;
4963 #endif /* COFF_WITH_PE */
4965 /* If it is not a global symbol, we presume it is a local symbol. */
4967 if (syment->n_scnum == 0)
4969 char buf[SYMNMLEN + 1];
4971 (*_bfd_error_handler)
4972 (_("warning: %s: local symbol `%s' has no section"),
4973 bfd_archive_filename (abfd),
4974 _bfd_coff_internal_syment_name (abfd, syment, buf));
4977 return COFF_SYMBOL_LOCAL;
4984 Coff relocations are easily transformed into the internal BFD form
4987 Reading a coff relocation table is done in the following stages:
4989 o Read the entire coff relocation table into memory.
4991 o Process each relocation in turn; first swap it from the
4992 external to the internal form.
4994 o Turn the symbol referenced in the relocation's symbol index
4995 into a pointer into the canonical symbol table.
4996 This table is the same as the one returned by a call to
4997 @code{bfd_canonicalize_symtab}. The back end will call that
4998 routine and save the result if a canonicalization hasn't been done.
5000 o The reloc index is turned into a pointer to a howto
5001 structure, in a back end specific way. For instance, the 386
5002 and 960 use the @code{r_type} to directly produce an index
5003 into a howto table vector; the 88k subtracts a number from the
5004 @code{r_type} field and creates an addend field.
5009 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
5011 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \
5012 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
5013 coffsym = (obj_symbols (abfd) \
5014 + (cache_ptr->sym_ptr_ptr - symbols)); \
5016 coffsym = coff_symbol_from (abfd, ptr); \
5017 if (coffsym != (coff_symbol_type *) NULL \
5018 && coffsym->native->u.syment.n_scnum == 0) \
5019 cache_ptr->addend = 0; \
5020 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
5021 && ptr->section != (asection *) NULL) \
5022 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
5024 cache_ptr->addend = 0; \
5029 coff_slurp_reloc_table (abfd, asect, symbols)
5034 RELOC *native_relocs;
5035 arelent *reloc_cache;
5040 if (asect->relocation)
5042 if (asect->reloc_count == 0)
5044 if (asect->flags & SEC_CONSTRUCTOR)
5046 if (!coff_slurp_symbol_table (abfd))
5048 amt = (bfd_size_type) bfd_coff_relsz (abfd) * asect->reloc_count;
5049 native_relocs = (RELOC *) buy_and_read (abfd, asect->rel_filepos, amt);
5050 amt = (bfd_size_type) asect->reloc_count * sizeof (arelent);
5051 reloc_cache = (arelent *) bfd_alloc (abfd, amt);
5053 if (reloc_cache == NULL)
5056 for (idx = 0; idx < asect->reloc_count; idx++)
5058 struct internal_reloc dst;
5059 struct external_reloc *src;
5060 #ifndef RELOC_PROCESSING
5064 cache_ptr = reloc_cache + idx;
5065 src = native_relocs + idx;
5067 coff_swap_reloc_in (abfd, src, &dst);
5069 #ifdef RELOC_PROCESSING
5070 RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
5072 cache_ptr->address = dst.r_vaddr;
5074 if (dst.r_symndx != -1)
5076 if (dst.r_symndx < 0 || dst.r_symndx >= obj_conv_table_size (abfd))
5078 (*_bfd_error_handler)
5079 (_("%s: warning: illegal symbol index %ld in relocs"),
5080 bfd_archive_filename (abfd), dst.r_symndx);
5081 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
5086 cache_ptr->sym_ptr_ptr = (symbols
5087 + obj_convert (abfd)[dst.r_symndx]);
5088 ptr = *(cache_ptr->sym_ptr_ptr);
5093 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
5097 /* The symbols definitions that we have read in have been
5098 relocated as if their sections started at 0. But the offsets
5099 refering to the symbols in the raw data have not been
5100 modified, so we have to have a negative addend to compensate.
5102 Note that symbols which used to be common must be left alone. */
5104 /* Calculate any reloc addend by looking at the symbol. */
5105 CALC_ADDEND (abfd, ptr, dst, cache_ptr);
5107 cache_ptr->address -= asect->vma;
5108 /* !! cache_ptr->section = (asection *) NULL;*/
5110 /* Fill in the cache_ptr->howto field from dst.r_type. */
5111 RTYPE2HOWTO (cache_ptr, &dst);
5112 #endif /* RELOC_PROCESSING */
5114 if (cache_ptr->howto == NULL)
5116 (*_bfd_error_handler)
5117 (_("%s: illegal relocation type %d at address 0x%lx"),
5118 bfd_archive_filename (abfd), dst.r_type, (long) dst.r_vaddr);
5119 bfd_set_error (bfd_error_bad_value);
5124 asect->relocation = reloc_cache;
5128 #ifndef coff_rtype_to_howto
5131 /* Get the howto structure for a reloc. This is only used if the file
5132 including this one defines coff_relocate_section to be
5133 _bfd_coff_generic_relocate_section, so it is OK if it does not
5134 always work. It is the responsibility of the including file to
5135 make sure it is reasonable if it is needed. */
5137 static reloc_howto_type *coff_rtype_to_howto
5138 PARAMS ((bfd *, asection *, struct internal_reloc *,
5139 struct coff_link_hash_entry *, struct internal_syment *,
5142 static reloc_howto_type *
5143 coff_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
5144 bfd *abfd ATTRIBUTE_UNUSED;
5145 asection *sec ATTRIBUTE_UNUSED;
5146 struct internal_reloc *rel;
5147 struct coff_link_hash_entry *h ATTRIBUTE_UNUSED;
5148 struct internal_syment *sym ATTRIBUTE_UNUSED;
5149 bfd_vma *addendp ATTRIBUTE_UNUSED;
5153 RTYPE2HOWTO (&genrel, rel);
5154 return genrel.howto;
5157 #else /* ! defined (RTYPE2HOWTO) */
5159 #define coff_rtype_to_howto NULL
5161 #endif /* ! defined (RTYPE2HOWTO) */
5162 #endif /* ! defined (coff_rtype_to_howto) */
5164 /* This is stupid. This function should be a boolean predicate. */
5166 coff_canonicalize_reloc (abfd, section, relptr, symbols)
5172 arelent *tblptr = section->relocation;
5173 unsigned int count = 0;
5175 if (section->flags & SEC_CONSTRUCTOR)
5177 /* This section has relocs made up by us, they are not in the
5178 file, so take them out of their chain and place them into
5179 the data area provided. */
5180 arelent_chain *chain = section->constructor_chain;
5182 for (count = 0; count < section->reloc_count; count++)
5184 *relptr++ = &chain->relent;
5185 chain = chain->next;
5190 if (! coff_slurp_reloc_table (abfd, section, symbols))
5193 tblptr = section->relocation;
5195 for (; count++ < section->reloc_count;)
5196 *relptr++ = tblptr++;
5199 return section->reloc_count;
5204 coff_sym_filepos (abfd)
5207 return obj_sym_filepos (abfd);
5211 #ifndef coff_reloc16_estimate
5212 #define coff_reloc16_estimate dummy_reloc16_estimate
5214 static int dummy_reloc16_estimate
5215 PARAMS ((bfd *, asection *, arelent *, unsigned int,
5216 struct bfd_link_info *));
5219 dummy_reloc16_estimate (abfd, input_section, reloc, shrink, link_info)
5220 bfd *abfd ATTRIBUTE_UNUSED;
5221 asection *input_section ATTRIBUTE_UNUSED;
5222 arelent *reloc ATTRIBUTE_UNUSED;
5223 unsigned int shrink ATTRIBUTE_UNUSED;
5224 struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
5232 #ifndef coff_reloc16_extra_cases
5234 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
5236 /* This works even if abort is not declared in any header file. */
5238 static void dummy_reloc16_extra_cases
5239 PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
5240 bfd_byte *, unsigned int *, unsigned int *));
5243 dummy_reloc16_extra_cases (abfd, link_info, link_order, reloc, data, src_ptr,
5245 bfd *abfd ATTRIBUTE_UNUSED;
5246 struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
5247 struct bfd_link_order *link_order ATTRIBUTE_UNUSED;
5248 arelent *reloc ATTRIBUTE_UNUSED;
5249 bfd_byte *data ATTRIBUTE_UNUSED;
5250 unsigned int *src_ptr ATTRIBUTE_UNUSED;
5251 unsigned int *dst_ptr ATTRIBUTE_UNUSED;
5257 #ifndef coff_bfd_link_hash_table_free
5258 #define coff_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
5261 /* If coff_relocate_section is defined, we can use the optimized COFF
5262 backend linker. Otherwise we must continue to use the old linker. */
5263 #ifdef coff_relocate_section
5264 #ifndef coff_bfd_link_hash_table_create
5265 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5267 #ifndef coff_bfd_link_add_symbols
5268 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5270 #ifndef coff_bfd_final_link
5271 #define coff_bfd_final_link _bfd_coff_final_link
5273 #else /* ! defined (coff_relocate_section) */
5274 #define coff_relocate_section NULL
5275 #ifndef coff_bfd_link_hash_table_create
5276 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5278 #ifndef coff_bfd_link_add_symbols
5279 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5281 #define coff_bfd_final_link _bfd_generic_final_link
5282 #endif /* ! defined (coff_relocate_section) */
5284 #define coff_bfd_link_just_syms _bfd_generic_link_just_syms
5285 #define coff_bfd_link_split_section _bfd_generic_link_split_section
5287 #ifndef coff_start_final_link
5288 #define coff_start_final_link NULL
5291 #ifndef coff_adjust_symndx
5292 #define coff_adjust_symndx NULL
5295 #ifndef coff_link_add_one_symbol
5296 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5299 #ifndef coff_link_output_has_begun
5301 static bfd_boolean coff_link_output_has_begun
5302 PARAMS ((bfd *, struct coff_final_link_info *));
5305 coff_link_output_has_begun (abfd, info)
5307 struct coff_final_link_info * info ATTRIBUTE_UNUSED;
5309 return abfd->output_has_begun;
5313 #ifndef coff_final_link_postscript
5315 static bfd_boolean coff_final_link_postscript
5316 PARAMS ((bfd *, struct coff_final_link_info *));
5319 coff_final_link_postscript (abfd, pfinfo)
5320 bfd * abfd ATTRIBUTE_UNUSED;
5321 struct coff_final_link_info * pfinfo ATTRIBUTE_UNUSED;
5327 #ifndef coff_SWAP_aux_in
5328 #define coff_SWAP_aux_in coff_swap_aux_in
5330 #ifndef coff_SWAP_sym_in
5331 #define coff_SWAP_sym_in coff_swap_sym_in
5333 #ifndef coff_SWAP_lineno_in
5334 #define coff_SWAP_lineno_in coff_swap_lineno_in
5336 #ifndef coff_SWAP_aux_out
5337 #define coff_SWAP_aux_out coff_swap_aux_out
5339 #ifndef coff_SWAP_sym_out
5340 #define coff_SWAP_sym_out coff_swap_sym_out
5342 #ifndef coff_SWAP_lineno_out
5343 #define coff_SWAP_lineno_out coff_swap_lineno_out
5345 #ifndef coff_SWAP_reloc_out
5346 #define coff_SWAP_reloc_out coff_swap_reloc_out
5348 #ifndef coff_SWAP_filehdr_out
5349 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5351 #ifndef coff_SWAP_aouthdr_out
5352 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5354 #ifndef coff_SWAP_scnhdr_out
5355 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5357 #ifndef coff_SWAP_reloc_in
5358 #define coff_SWAP_reloc_in coff_swap_reloc_in
5360 #ifndef coff_SWAP_filehdr_in
5361 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5363 #ifndef coff_SWAP_aouthdr_in
5364 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5366 #ifndef coff_SWAP_scnhdr_in
5367 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5370 static const bfd_coff_backend_data bfd_coff_std_swap_table =
5372 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5373 coff_SWAP_aux_out, coff_SWAP_sym_out,
5374 coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5375 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5376 coff_SWAP_scnhdr_out,
5377 FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
5378 #ifdef COFF_LONG_FILENAMES
5383 #ifdef COFF_LONG_SECTION_NAMES
5388 COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5389 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5394 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5399 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5400 coff_SWAP_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook,
5401 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5402 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5403 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5404 coff_classify_symbol, coff_compute_section_file_positions,
5405 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5406 coff_adjust_symndx, coff_link_add_one_symbol,
5407 coff_link_output_has_begun, coff_final_link_postscript
5411 /* COFF0 differs in file/section header size and relocation entry size. */
5412 static const bfd_coff_backend_data ticoff0_swap_table =
5414 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5415 coff_SWAP_aux_out, coff_SWAP_sym_out,
5416 coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5417 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5418 coff_SWAP_scnhdr_out,
5419 FILHSZ_V0, AOUTSZ, SCNHSZ_V01, SYMESZ, AUXESZ, RELSZ_V0, LINESZ, FILNMLEN,
5420 #ifdef COFF_LONG_FILENAMES
5425 #ifdef COFF_LONG_SECTION_NAMES
5430 COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5431 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5436 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5441 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5442 coff_SWAP_reloc_in, ticoff0_bad_format_hook, coff_set_arch_mach_hook,
5443 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5444 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5445 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5446 coff_classify_symbol, coff_compute_section_file_positions,
5447 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5448 coff_adjust_symndx, coff_link_add_one_symbol,
5449 coff_link_output_has_begun, coff_final_link_postscript
5454 /* COFF1 differs in section header size. */
5455 static const bfd_coff_backend_data ticoff1_swap_table =
5457 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5458 coff_SWAP_aux_out, coff_SWAP_sym_out,
5459 coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5460 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5461 coff_SWAP_scnhdr_out,
5462 FILHSZ, AOUTSZ, SCNHSZ_V01, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
5463 #ifdef COFF_LONG_FILENAMES
5468 #ifdef COFF_LONG_SECTION_NAMES
5473 COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5474 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5479 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5484 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5485 coff_SWAP_reloc_in, ticoff1_bad_format_hook, coff_set_arch_mach_hook,
5486 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5487 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5488 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5489 coff_classify_symbol, coff_compute_section_file_positions,
5490 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5491 coff_adjust_symndx, coff_link_add_one_symbol,
5492 coff_link_output_has_begun, coff_final_link_postscript
5496 #ifndef coff_close_and_cleanup
5497 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
5500 #ifndef coff_bfd_free_cached_info
5501 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
5504 #ifndef coff_get_section_contents
5505 #define coff_get_section_contents _bfd_generic_get_section_contents
5508 #ifndef coff_bfd_copy_private_symbol_data
5509 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5512 #ifndef coff_bfd_copy_private_section_data
5513 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5516 #ifndef coff_bfd_copy_private_bfd_data
5517 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5520 #ifndef coff_bfd_merge_private_bfd_data
5521 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5524 #ifndef coff_bfd_set_private_flags
5525 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5528 #ifndef coff_bfd_print_private_bfd_data
5529 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5532 #ifndef coff_bfd_is_local_label_name
5533 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5536 #ifndef coff_read_minisymbols
5537 #define coff_read_minisymbols _bfd_generic_read_minisymbols
5540 #ifndef coff_minisymbol_to_symbol
5541 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5544 /* The reloc lookup routine must be supplied by each individual COFF
5546 #ifndef coff_bfd_reloc_type_lookup
5547 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5550 #ifndef coff_bfd_get_relocated_section_contents
5551 #define coff_bfd_get_relocated_section_contents \
5552 bfd_generic_get_relocated_section_contents
5555 #ifndef coff_bfd_relax_section
5556 #define coff_bfd_relax_section bfd_generic_relax_section
5559 #ifndef coff_bfd_gc_sections
5560 #define coff_bfd_gc_sections bfd_generic_gc_sections
5563 #ifndef coff_bfd_merge_sections
5564 #define coff_bfd_merge_sections bfd_generic_merge_sections
5567 #ifndef coff_bfd_discard_group
5568 #define coff_bfd_discard_group bfd_generic_discard_group
5571 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5572 const bfd_target VAR = \
5575 bfd_target_coff_flavour, \
5576 BFD_ENDIAN_BIG, /* data byte order is big */ \
5577 BFD_ENDIAN_BIG, /* header byte order is big */ \
5578 /* object flags */ \
5579 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5580 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5581 /* section flags */ \
5582 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5583 UNDER, /* leading symbol underscore */ \
5584 '/', /* ar_pad_char */ \
5585 15, /* ar_max_namelen */ \
5587 /* Data conversion functions. */ \
5588 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5589 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5590 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5592 /* Header conversion functions. */ \
5593 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5594 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5595 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5597 /* bfd_check_format */ \
5598 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5599 _bfd_dummy_target }, \
5600 /* bfd_set_format */ \
5601 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5602 /* bfd_write_contents */ \
5603 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5606 BFD_JUMP_TABLE_GENERIC (coff), \
5607 BFD_JUMP_TABLE_COPY (coff), \
5608 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5609 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5610 BFD_JUMP_TABLE_SYMBOLS (coff), \
5611 BFD_JUMP_TABLE_RELOCS (coff), \
5612 BFD_JUMP_TABLE_WRITE (coff), \
5613 BFD_JUMP_TABLE_LINK (coff), \
5614 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5621 #define CREATE_BIGHDR_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5622 const bfd_target VAR = \
5625 bfd_target_coff_flavour, \
5626 BFD_ENDIAN_LITTLE, /* data byte order is little */ \
5627 BFD_ENDIAN_BIG, /* header byte order is big */ \
5628 /* object flags */ \
5629 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5630 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5631 /* section flags */ \
5632 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5633 UNDER, /* leading symbol underscore */ \
5634 '/', /* ar_pad_char */ \
5635 15, /* ar_max_namelen */ \
5637 /* Data conversion functions. */ \
5638 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5639 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5640 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5642 /* Header conversion functions. */ \
5643 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5644 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5645 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5647 /* bfd_check_format */ \
5648 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5649 _bfd_dummy_target }, \
5650 /* bfd_set_format */ \
5651 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5652 /* bfd_write_contents */ \
5653 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5656 BFD_JUMP_TABLE_GENERIC (coff), \
5657 BFD_JUMP_TABLE_COPY (coff), \
5658 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5659 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5660 BFD_JUMP_TABLE_SYMBOLS (coff), \
5661 BFD_JUMP_TABLE_RELOCS (coff), \
5662 BFD_JUMP_TABLE_WRITE (coff), \
5663 BFD_JUMP_TABLE_LINK (coff), \
5664 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5671 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5672 const bfd_target VAR = \
5675 bfd_target_coff_flavour, \
5676 BFD_ENDIAN_LITTLE, /* data byte order is little */ \
5677 BFD_ENDIAN_LITTLE, /* header byte order is little */ \
5678 /* object flags */ \
5679 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5680 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5681 /* section flags */ \
5682 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5683 UNDER, /* leading symbol underscore */ \
5684 '/', /* ar_pad_char */ \
5685 15, /* ar_max_namelen */ \
5687 /* Data conversion functions. */ \
5688 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5689 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5690 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5691 /* Header conversion functions. */ \
5692 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5693 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5694 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5695 /* bfd_check_format */ \
5696 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5697 _bfd_dummy_target }, \
5698 /* bfd_set_format */ \
5699 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5700 /* bfd_write_contents */ \
5701 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5704 BFD_JUMP_TABLE_GENERIC (coff), \
5705 BFD_JUMP_TABLE_COPY (coff), \
5706 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5707 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5708 BFD_JUMP_TABLE_SYMBOLS (coff), \
5709 BFD_JUMP_TABLE_RELOCS (coff), \
5710 BFD_JUMP_TABLE_WRITE (coff), \
5711 BFD_JUMP_TABLE_LINK (coff), \
5712 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \