1 /* Support for the generic parts of most COFF variants, for BFD.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
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 hierachy 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
252 . {* Remembers the offset from the first symbol in the file for
253 . this symbol. Generated by coff_renumber_symbols. *}
254 .unsigned int offset;
256 . {* Should the value of this symbol be renumbered. Used for
257 . XCOFF C_BSTAT symbols. Set by coff_slurp_symbol_table. *}
258 .unsigned int fix_value : 1;
260 . {* Should the tag field of this symbol be renumbered.
261 . Created by coff_pointerize_aux. *}
262 .unsigned int fix_tag : 1;
264 . {* Should the endidx field of this symbol be renumbered.
265 . Created by coff_pointerize_aux. *}
266 .unsigned int fix_end : 1;
268 . {* Should the x_csect.x_scnlen field be renumbered.
269 . Created by coff_pointerize_aux. *}
270 .unsigned int fix_scnlen : 1;
272 . {* Fix up an XCOFF C_BINCL/C_EINCL symbol. The value is the
273 . index into the line number entries. Set by
274 . coff_slurp_symbol_table. *}
275 .unsigned int fix_line : 1;
277 . {* The container for the symbol structure as read and translated
281 . union internal_auxent auxent;
282 . struct internal_syment syment;
284 .} combined_entry_type;
287 .{* Each canonical asymbol really looks like this: *}
289 .typedef struct coff_symbol_struct
291 . {* The actual symbol which the rest of BFD works with *}
294 . {* A pointer to the hidden information for this symbol *}
295 .combined_entry_type *native;
297 . {* A pointer to the linenumber information for this symbol *}
298 .struct lineno_cache_entry *lineno;
300 . {* Have the line numbers been relocated yet ? *}
301 .boolean done_lineno;
309 #include "coffswap.h"
312 #define STRING_SIZE_SIZE (4)
314 static long sec_to_styp_flags PARAMS ((const char *, flagword));
315 static flagword styp_to_sec_flags
316 PARAMS ((bfd *, PTR, const char *, asection *));
317 static boolean coff_bad_format_hook PARAMS ((bfd *, PTR));
318 static void coff_set_custom_section_alignment
319 PARAMS ((bfd *, asection *, const struct coff_section_alignment_entry *,
320 const unsigned int));
321 static boolean coff_new_section_hook PARAMS ((bfd *, asection *));
322 static boolean coff_set_arch_mach_hook PARAMS ((bfd *, PTR));
323 static boolean coff_write_relocs PARAMS ((bfd *, int));
324 static boolean coff_set_flags
325 PARAMS ((bfd *, unsigned int *, unsigned short *));
326 static boolean coff_set_arch_mach
327 PARAMS ((bfd *, enum bfd_architecture, unsigned long));
328 static boolean coff_compute_section_file_positions PARAMS ((bfd *));
329 static boolean coff_write_object_contents PARAMS ((bfd *));
330 static boolean coff_set_section_contents
331 PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type));
332 static PTR buy_and_read PARAMS ((bfd *, file_ptr, int, size_t));
333 static boolean coff_slurp_line_table PARAMS ((bfd *, asection *));
334 static boolean coff_slurp_symbol_table PARAMS ((bfd *));
335 static enum coff_symbol_classification coff_classify_symbol
336 PARAMS ((bfd *, struct internal_syment *));
337 static boolean coff_slurp_reloc_table PARAMS ((bfd *, asection *, asymbol **));
338 static long coff_canonicalize_reloc
339 PARAMS ((bfd *, asection *, arelent **, asymbol **));
340 #ifndef coff_mkobject_hook
341 static PTR coff_mkobject_hook PARAMS ((bfd *, PTR, PTR));
344 static flagword handle_COMDAT PARAMS ((bfd *, flagword, PTR, const char *, asection *));
347 /* void warning(); */
349 /* Return a word with STYP_* (scnhdr.s_flags) flags set to represent
350 the incoming SEC_* flags. The inverse of this function is
351 styp_to_sec_flags(). NOTE: If you add to/change this routine, you
352 should probably mirror the changes in styp_to_sec_flags(). */
356 /* Macros for setting debugging flags. */
358 #define STYP_XCOFF_DEBUG STYP_DEBUG
360 #define STYP_XCOFF_DEBUG STYP_INFO
363 #ifdef COFF_ALIGN_IN_S_FLAGS
364 #define STYP_DEBUG_INFO STYP_DSECT
366 #define STYP_DEBUG_INFO STYP_INFO
370 sec_to_styp_flags (sec_name, sec_flags)
371 CONST char *sec_name;
376 if (!strcmp (sec_name, _TEXT))
378 styp_flags = STYP_TEXT;
380 else if (!strcmp (sec_name, _DATA))
382 styp_flags = STYP_DATA;
384 else if (!strcmp (sec_name, _BSS))
386 styp_flags = STYP_BSS;
389 else if (!strcmp (sec_name, _COMMENT))
391 styp_flags = STYP_INFO;
392 #endif /* _COMMENT */
395 else if (!strcmp (sec_name, _LIB))
397 styp_flags = STYP_LIB;
401 else if (!strcmp (sec_name, _LIT))
403 styp_flags = STYP_LIT;
406 else if (!strncmp (sec_name, ".debug", 6))
408 /* Handle the XCOFF debug section and DWARF2 debug sections. */
410 styp_flags = STYP_XCOFF_DEBUG;
412 styp_flags = STYP_DEBUG_INFO;
414 else if (!strncmp (sec_name, ".stab", 5))
416 styp_flags = STYP_DEBUG_INFO;
418 #ifdef COFF_LONG_SECTION_NAMES
419 else if (!strncmp (sec_name, ".gnu.linkonce.wi.", 17))
421 styp_flags = STYP_DEBUG_INFO;
425 else if (!strcmp (sec_name, _PAD))
427 styp_flags = STYP_PAD;
429 else if (!strcmp (sec_name, _LOADER))
431 styp_flags = STYP_LOADER;
434 /* Try and figure out what it should be */
435 else if (sec_flags & SEC_CODE)
437 styp_flags = STYP_TEXT;
439 else if (sec_flags & SEC_DATA)
441 styp_flags = STYP_DATA;
443 else if (sec_flags & SEC_READONLY)
445 #ifdef STYP_LIT /* 29k readonly text/data section */
446 styp_flags = STYP_LIT;
448 styp_flags = STYP_TEXT;
449 #endif /* STYP_LIT */
451 else if (sec_flags & SEC_LOAD)
453 styp_flags = STYP_TEXT;
455 else if (sec_flags & SEC_ALLOC)
457 styp_flags = STYP_BSS;
461 if (sec_flags & SEC_CLINK)
462 styp_flags |= STYP_CLINK;
466 if (sec_flags & SEC_BLOCK)
467 styp_flags |= STYP_BLOCK;
471 if ((sec_flags & (SEC_NEVER_LOAD | SEC_COFF_SHARED_LIBRARY)) != 0)
472 styp_flags |= STYP_NOLOAD;
478 #else /* COFF_WITH_PE */
480 /* The PE version; see above for the general comments. The non-PE
481 case seems to be more guessing, and breaks PE format; specifically,
482 .rdata is readonly, but it sure ain't text. Really, all this
483 should be set up properly in gas (or whatever assembler is in use),
484 and honor whatever objcopy/strip, etc. sent us as input. */
487 sec_to_styp_flags (sec_name, sec_flags)
488 const char *sec_name ATTRIBUTE_UNUSED;
493 /* caution: there are at least three groups of symbols that have
494 very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
495 SEC_* are the BFD internal flags, used for generic BFD
496 information. STYP_* are the COFF section flags which appear in
497 COFF files. IMAGE_SCN_* are the PE section flags which appear in
498 PE files. The STYP_* flags and the IMAGE_SCN_* flags overlap,
499 but there are more IMAGE_SCN_* flags. */
504 if ((sec_flags & SEC_CODE) != 0)
505 styp_flags |= IMAGE_SCN_CNT_CODE;
506 if ((sec_flags & SEC_DATA) != 0)
507 styp_flags |= IMAGE_SCN_CNT_INITIALIZED_DATA;
508 if ((sec_flags & SEC_ALLOC) != 0 && (sec_flags & SEC_LOAD) == 0)
509 styp_flags |= IMAGE_SCN_CNT_UNINITIALIZED_DATA; /* ==STYP_BSS */
511 /* skip CONSTRUCTOR */
514 if ((sec_flags & (SEC_NEVER_LOAD | SEC_COFF_SHARED_LIBRARY)) != 0)
515 styp_flags |= STYP_NOLOAD;
517 if ((sec_flags & SEC_IS_COMMON) != 0)
518 styp_flags |= IMAGE_SCN_LNK_COMDAT;
519 if ((sec_flags & SEC_DEBUGGING) != 0)
520 styp_flags |= IMAGE_SCN_MEM_DISCARDABLE;
521 if ((sec_flags & SEC_EXCLUDE) != 0)
522 styp_flags |= IMAGE_SCN_LNK_REMOVE;
523 if ((sec_flags & SEC_NEVER_LOAD) != 0)
524 styp_flags |= IMAGE_SCN_LNK_REMOVE;
527 if (sec_flags & SEC_LINK_ONCE)
528 styp_flags |= IMAGE_SCN_LNK_COMDAT;
529 /* skip LINK_DUPLICATES */
530 /* skip LINKER_CREATED */
532 /* For now, the read/write bits are mapped onto SEC_READONLY, even
533 though the semantics don't quite match. The bits from the input
534 are retained in pei_section_data(abfd, section)->pe_flags */
536 styp_flags |= IMAGE_SCN_MEM_READ; /* always readable. */
537 if ((sec_flags & SEC_READONLY) == 0)
538 styp_flags |= IMAGE_SCN_MEM_WRITE; /* Invert READONLY for write */
539 if (sec_flags & SEC_CODE)
540 styp_flags |= IMAGE_SCN_MEM_EXECUTE; /* CODE->EXECUTE */
541 if (sec_flags & SEC_SHARED)
542 styp_flags |= IMAGE_SCN_MEM_SHARED; /* Shared remains meaningful */
547 #endif /* COFF_WITH_PE */
549 /* Return a word with SEC_* flags set to represent the incoming STYP_*
550 flags (from scnhdr.s_flags). The inverse of this function is
551 sec_to_styp_flags(). NOTE: If you add to/change this routine, you
552 should probably mirror the changes in sec_to_styp_flags(). */
557 styp_to_sec_flags (abfd, hdr, name, section)
558 bfd *abfd ATTRIBUTE_UNUSED;
561 asection *section ATTRIBUTE_UNUSED;
563 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
564 long styp_flags = internal_s->s_flags;
565 flagword sec_flags = 0;
568 if (styp_flags & STYP_BLOCK)
569 sec_flags |= SEC_BLOCK;
573 if (styp_flags & STYP_CLINK)
574 sec_flags |= SEC_CLINK;
578 if (styp_flags & STYP_NOLOAD)
580 sec_flags |= SEC_NEVER_LOAD;
582 #endif /* STYP_NOLOAD */
584 /* For 386 COFF, at least, an unloadable text or data section is
585 actually a shared library section. */
586 if (styp_flags & STYP_TEXT)
588 if (sec_flags & SEC_NEVER_LOAD)
589 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
591 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
593 else if (styp_flags & STYP_DATA)
595 if (sec_flags & SEC_NEVER_LOAD)
596 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
598 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
600 else if (styp_flags & STYP_BSS)
602 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
603 if (sec_flags & SEC_NEVER_LOAD)
604 sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
607 sec_flags |= SEC_ALLOC;
609 else if (styp_flags & STYP_INFO)
611 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
612 defined. coff_compute_section_file_positions uses
613 COFF_PAGE_SIZE to ensure that the low order bits of the
614 section VMA and the file offset match. If we don't know
615 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
616 and demand page loading of the file will fail. */
617 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
618 sec_flags |= SEC_DEBUGGING;
621 else if (styp_flags & STYP_PAD)
625 else if (strcmp (name, _TEXT) == 0)
627 if (sec_flags & SEC_NEVER_LOAD)
628 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
630 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
632 else if (strcmp (name, _DATA) == 0)
634 if (sec_flags & SEC_NEVER_LOAD)
635 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
637 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
639 else if (strcmp (name, _BSS) == 0)
641 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
642 if (sec_flags & SEC_NEVER_LOAD)
643 sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
646 sec_flags |= SEC_ALLOC;
648 else if (strncmp (name, ".debug", 6) == 0
650 || strcmp (name, _COMMENT) == 0
652 #ifdef COFF_LONG_SECTION_NAMES
653 || strncmp (name, ".gnu.linkonce.wi.", 17) == 0
655 || strncmp (name, ".stab", 5) == 0)
657 #ifdef COFF_PAGE_SIZE
658 sec_flags |= SEC_DEBUGGING;
662 else if (strcmp (name, _LIB) == 0)
666 else if (strcmp (name, _LIT) == 0)
668 sec_flags = SEC_LOAD | SEC_ALLOC | SEC_READONLY;
673 sec_flags |= SEC_ALLOC | SEC_LOAD;
676 #ifdef STYP_LIT /* A29k readonly text/data section type */
677 if ((styp_flags & STYP_LIT) == STYP_LIT)
679 sec_flags = (SEC_LOAD | SEC_ALLOC | SEC_READONLY);
681 #endif /* STYP_LIT */
682 #ifdef STYP_OTHER_LOAD /* Other loaded sections */
683 if (styp_flags & STYP_OTHER_LOAD)
685 sec_flags = (SEC_LOAD | SEC_ALLOC);
687 #endif /* STYP_SDATA */
689 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
690 /* As a GNU extension, if the name begins with .gnu.linkonce, we
691 only link a single copy of the section. This is used to support
692 g++. g++ will emit each template expansion in its own section.
693 The symbols will be defined as weak, so that multiple definitions
694 are permitted. The GNU linker extension is to actually discard
695 all but one of the sections. */
696 if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
697 sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
703 #else /* COFF_WITH_PE */
706 handle_COMDAT (abfd, sec_flags, hdr, name, section)
713 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
714 bfd_byte *esymstart, *esym, *esymend;
716 char *target_name = NULL;
718 sec_flags |= SEC_LINK_ONCE;
720 /* Unfortunately, the PE format stores essential information in
721 the symbol table, of all places. We need to extract that
722 information now, so that objdump and the linker will know how
723 to handle the section without worrying about the symbols. We
724 can't call slurp_symtab, because the linker doesn't want the
727 /* COMDAT sections are special. The first symbol is the section
728 symbol, which tells what kind of COMDAT section it is. The
729 second symbol is the "comdat symbol" - the one with the
730 unique name. GNU uses the section symbol for the unique
731 name; MS uses ".text" for every comdat section. Sigh. - DJ */
733 /* This is not mirrored in sec_to_styp_flags(), but there
734 doesn't seem to be a need to, either, and it would at best be
737 if (! _bfd_coff_get_external_symbols (abfd))
740 esymstart = esym = (bfd_byte *) obj_coff_external_syms (abfd);
741 esymend = esym + obj_raw_syment_count (abfd) * bfd_coff_symesz (abfd);
743 while (esym < esymend)
745 struct internal_syment isym;
746 char buf[SYMNMLEN + 1];
749 bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &isym);
751 if (sizeof (internal_s->s_name) > SYMNMLEN)
753 /* This case implies that the matching
754 symbol name will be in the string table. */
758 if (isym.n_scnum == section->target_index)
760 /* According to the MSVC documentation, the first
761 TWO entries with the section # are both of
762 interest to us. The first one is the "section
763 symbol" (section name). The second is the comdat
764 symbol name. Here, we've found the first
765 qualifying entry; we distinguish it from the
766 second with a state flag.
768 In the case of gas-generated (at least until that
769 is fixed) .o files, it isn't necessarily the
770 second one. It may be some other later symbol.
772 Since gas also doesn't follow MS conventions and
773 emits the section similar to .text$<name>, where
774 <something> is the name we're looking for, we
775 distinguish the two as follows:
777 If the section name is simply a section name (no
778 $) we presume it's MS-generated, and look at
779 precisely the second symbol for the comdat name.
780 If the section name has a $, we assume it's
781 gas-generated, and look for <something> (whatever
782 follows the $) as the comdat symbol. */
784 /* All 3 branches use this */
785 symname = _bfd_coff_internal_syment_name (abfd, &isym, buf);
794 /* The first time we've seen the symbol. */
795 union internal_auxent aux;
799 /* If it isn't the stuff we're expecting, die;
800 The MS documentation is vague, but it
801 appears that the second entry serves BOTH
802 as the comdat symbol and the defining
803 symbol record (either C_STAT or C_EXT,
804 possibly with an aux entry with debug
805 information if it's a function.) It
806 appears the only way to find the second one
807 is to count. (On Intel, they appear to be
808 adjacent, but on Alpha, they have been
811 Here, we think we've found the first one,
812 but there's some checking we can do to be
815 if (! (isym.n_sclass == C_STAT
816 && isym.n_type == T_NULL
817 && isym.n_value == 0))
820 /* FIXME LATER: MSVC generates section names
821 like .text for comdats. Gas generates
822 names like .text$foo__Fv (in the case of a
823 function). See comment above for more. */
825 if (strcmp (name, symname) != 0)
828 /* This is the section symbol. */
829 bfd_coff_swap_aux_in (abfd, (PTR) (esym + bfd_coff_symesz (abfd)),
830 isym.n_type, isym.n_sclass,
831 0, isym.n_numaux, (PTR) &aux);
833 target_name = strchr (name, '$');
834 if (target_name != NULL)
842 /* FIXME: Microsoft uses NODUPLICATES and
843 ASSOCIATIVE, but gnu uses ANY and
844 SAME_SIZE. Unfortunately, gnu doesn't do
845 the comdat symbols right. So, until we can
846 fix it to do the right thing, we are
847 temporarily disabling comdats for the MS
848 types (they're used in DLLs and C++, but we
849 don't support *their* C++ libraries anyway
852 /* Cygwin does not follow the MS style, and
853 uses ANY and SAME_SIZE where NODUPLICATES
854 and ASSOCIATIVE should be used. For
855 Interix, we just do the right thing up
858 switch (aux.x_scn.x_comdat)
860 case IMAGE_COMDAT_SELECT_NODUPLICATES:
861 #ifdef STRICT_PE_FORMAT
862 sec_flags |= SEC_LINK_DUPLICATES_ONE_ONLY;
864 sec_flags &= ~SEC_LINK_ONCE;
868 case IMAGE_COMDAT_SELECT_ANY:
869 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
872 case IMAGE_COMDAT_SELECT_SAME_SIZE:
873 sec_flags |= SEC_LINK_DUPLICATES_SAME_SIZE;
876 case IMAGE_COMDAT_SELECT_EXACT_MATCH:
877 /* Not yet fully implemented ??? */
878 sec_flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS;
881 /* debug$S gets this case; other
884 /* There may be no symbol... we'll search
885 the whole table... Is this the right
886 place to play this game? Or should we do
887 it when reading it in. */
888 case IMAGE_COMDAT_SELECT_ASSOCIATIVE:
889 #ifdef STRICT_PE_FORMAT
890 /* FIXME: This is not currently implemented. */
891 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
893 sec_flags &= ~SEC_LINK_ONCE;
897 default: /* 0 means "no symbol" */
898 /* debug$F gets this case; other
900 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
907 /* Gas mode: the first matching on partial name. */
909 #ifndef TARGET_UNDERSCORE
910 #define TARGET_UNDERSCORE 0
912 /* Is this the name we're looking for? */
913 if (strcmp (target_name,
914 symname + (TARGET_UNDERSCORE ? 1 : 0)) != 0)
916 /* Not the name we're looking for */
917 esym += (isym.n_numaux + 1) * bfd_coff_symesz (abfd);
922 /* MSVC mode: the lexically second symbol (or
923 drop through from the above). */
927 /* This must the the second symbol with the
928 section #. It is the actual symbol name.
929 Intel puts the two adjacent, but Alpha (at
930 least) spreads them out. */
933 bfd_alloc (abfd, sizeof (struct bfd_comdat_info));
934 if (section->comdat == NULL)
937 section->comdat->symbol =
938 (esym - esymstart) / bfd_coff_symesz (abfd);
940 newname = bfd_alloc (abfd, strlen (symname) + 1);
944 strcpy (newname, symname);
945 section->comdat->name = newname;
952 esym += (isym.n_numaux + 1) * bfd_coff_symesz (abfd);
960 /* The PE version; see above for the general comments.
962 Since to set the SEC_LINK_ONCE and associated flags, we have to
963 look at the symbol table anyway, we return the symbol table index
964 of the symbol being used as the COMDAT symbol. This is admittedly
965 ugly, but there's really nowhere else that we have access to the
966 required information. FIXME: Is the COMDAT symbol index used for
967 any purpose other than objdump? */
970 styp_to_sec_flags (abfd, hdr, name, section)
976 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
977 long styp_flags = internal_s->s_flags;
980 /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
981 sec_flags = SEC_READONLY;
983 /* Process each flag bit in styp_flags in turn. */
986 long flag = styp_flags & - styp_flags;
987 char * unhandled = NULL;
989 styp_flags &= ~ flag;
991 /* We infer from the distinct read/write/execute bits the settings
992 of some of the bfd flags; the actual values, should we need them,
993 are also in pei_section_data (abfd, section)->pe_flags. */
998 unhandled = "STYP_DSECT";
1001 unhandled = "STYP_GROUP";
1004 unhandled = "STYP_COPY";
1007 unhandled = "STYP_OVER";
1009 #ifdef SEC_NEVER_LOAD
1011 sec_flags |= SEC_NEVER_LOAD;
1014 case IMAGE_SCN_MEM_READ:
1015 /* Ignored, assume it always to be true. */
1017 case IMAGE_SCN_TYPE_NO_PAD:
1020 case IMAGE_SCN_LNK_OTHER:
1021 unhandled = "IMAGE_SCN_LNK_OTHER";
1023 case IMAGE_SCN_MEM_NOT_CACHED:
1024 unhandled = "IMAGE_SCN_MEM_NOT_CACHED";
1026 case IMAGE_SCN_MEM_NOT_PAGED:
1027 unhandled = "IMAGE_SCN_MEM_NOT_PAGED";
1029 case IMAGE_SCN_MEM_EXECUTE:
1030 sec_flags |= SEC_CODE;
1032 case IMAGE_SCN_MEM_WRITE:
1033 sec_flags &= ~ SEC_READONLY;
1035 case IMAGE_SCN_MEM_DISCARDABLE:
1036 sec_flags |= SEC_DEBUGGING;
1038 case IMAGE_SCN_MEM_SHARED:
1039 sec_flags |= SEC_SHARED;
1041 case IMAGE_SCN_LNK_REMOVE:
1042 sec_flags |= SEC_EXCLUDE;
1044 case IMAGE_SCN_CNT_CODE:
1045 sec_flags |= SEC_CODE | SEC_ALLOC | SEC_LOAD;
1047 case IMAGE_SCN_CNT_INITIALIZED_DATA:
1048 sec_flags |= SEC_DATA | SEC_ALLOC | SEC_LOAD;
1050 case IMAGE_SCN_CNT_UNINITIALIZED_DATA:
1051 sec_flags |= SEC_ALLOC;
1053 case IMAGE_SCN_LNK_INFO:
1054 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
1055 defined. coff_compute_section_file_positions uses
1056 COFF_PAGE_SIZE to ensure that the low order bits of the
1057 section VMA and the file offset match. If we don't know
1058 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
1059 and demand page loading of the file will fail. */
1060 #ifdef COFF_PAGE_SIZE
1061 sec_flags |= SEC_DEBUGGING;
1064 case IMAGE_SCN_LNK_COMDAT:
1065 /* COMDAT gets very special treatment. */
1066 sec_flags = handle_COMDAT (abfd, sec_flags, hdr, name, section);
1069 /* Silently ignore for now. */
1073 /* If the section flag was not handled, report it here. This will allow
1074 users of the BFD library to report a problem but continue executing.
1075 Tools which need to be aware of these problems (such as the linker)
1076 can override the default bfd_error_handler to intercept these reports. */
1077 if (unhandled != NULL)
1078 (*_bfd_error_handler)
1079 (_("%s (%s): Section flag %s (0x%x) ignored"),
1080 bfd_get_filename (abfd), name, unhandled, flag);
1083 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1084 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1085 only link a single copy of the section. This is used to support
1086 g++. g++ will emit each template expansion in its own section.
1087 The symbols will be defined as weak, so that multiple definitions
1088 are permitted. The GNU linker extension is to actually discard
1089 all but one of the sections. */
1090 if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
1091 sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
1097 #endif /* COFF_WITH_PE */
1099 #define get_index(symbol) ((symbol)->udata.i)
1103 bfd_coff_backend_data
1107 .{* COFF symbol classifications. *}
1109 .enum coff_symbol_classification
1111 . {* Global symbol. *}
1112 . COFF_SYMBOL_GLOBAL,
1113 . {* Common symbol. *}
1114 . COFF_SYMBOL_COMMON,
1115 . {* Undefined symbol. *}
1116 . COFF_SYMBOL_UNDEFINED,
1117 . {* Local symbol. *}
1118 . COFF_SYMBOL_LOCAL,
1119 . {* PE section symbol. *}
1120 . COFF_SYMBOL_PE_SECTION
1123 Special entry points for gdb to swap in coff symbol table parts:
1126 . void (*_bfd_coff_swap_aux_in) PARAMS ((
1135 . void (*_bfd_coff_swap_sym_in) PARAMS ((
1140 . void (*_bfd_coff_swap_lineno_in) PARAMS ((
1146 Special entry points for gas to swap out coff parts:
1148 . unsigned int (*_bfd_coff_swap_aux_out) PARAMS ((
1157 . unsigned int (*_bfd_coff_swap_sym_out) PARAMS ((
1162 . unsigned int (*_bfd_coff_swap_lineno_out) PARAMS ((
1167 . unsigned int (*_bfd_coff_swap_reloc_out) PARAMS ((
1172 . unsigned int (*_bfd_coff_swap_filehdr_out) PARAMS ((
1177 . unsigned int (*_bfd_coff_swap_aouthdr_out) PARAMS ((
1182 . unsigned int (*_bfd_coff_swap_scnhdr_out) PARAMS ((
1188 Special entry points for generic COFF routines to call target
1189 dependent COFF routines:
1191 . unsigned int _bfd_filhsz;
1192 . unsigned int _bfd_aoutsz;
1193 . unsigned int _bfd_scnhsz;
1194 . unsigned int _bfd_symesz;
1195 . unsigned int _bfd_auxesz;
1196 . unsigned int _bfd_relsz;
1197 . unsigned int _bfd_linesz;
1198 . unsigned int _bfd_filnmlen;
1199 . boolean _bfd_coff_long_filenames;
1200 . boolean _bfd_coff_long_section_names;
1201 . unsigned int _bfd_coff_default_section_alignment_power;
1202 . boolean _bfd_coff_force_symnames_in_strings;
1203 . unsigned int _bfd_coff_debug_string_prefix_length;
1204 . void (*_bfd_coff_swap_filehdr_in) PARAMS ((
1208 . void (*_bfd_coff_swap_aouthdr_in) PARAMS ((
1212 . void (*_bfd_coff_swap_scnhdr_in) PARAMS ((
1216 . void (*_bfd_coff_swap_reloc_in) PARAMS ((
1220 . boolean (*_bfd_coff_bad_format_hook) PARAMS ((
1222 . PTR internal_filehdr));
1223 . boolean (*_bfd_coff_set_arch_mach_hook) PARAMS ((
1225 . PTR internal_filehdr));
1226 . PTR (*_bfd_coff_mkobject_hook) PARAMS ((
1228 . PTR internal_filehdr,
1229 . PTR internal_aouthdr));
1230 . flagword (*_bfd_styp_to_sec_flags_hook) PARAMS ((
1232 . PTR internal_scnhdr,
1234 . asection *section));
1235 . void (*_bfd_set_alignment_hook) PARAMS ((
1238 . PTR internal_scnhdr));
1239 . boolean (*_bfd_coff_slurp_symbol_table) PARAMS ((
1241 . boolean (*_bfd_coff_symname_in_debug) PARAMS ((
1243 . struct internal_syment *sym));
1244 . boolean (*_bfd_coff_pointerize_aux_hook) PARAMS ((
1246 . combined_entry_type *table_base,
1247 . combined_entry_type *symbol,
1248 . unsigned int indaux,
1249 . combined_entry_type *aux));
1250 . boolean (*_bfd_coff_print_aux) PARAMS ((
1253 . combined_entry_type *table_base,
1254 . combined_entry_type *symbol,
1255 . combined_entry_type *aux,
1256 . unsigned int indaux));
1257 . void (*_bfd_coff_reloc16_extra_cases) PARAMS ((
1259 . struct bfd_link_info *link_info,
1260 . struct bfd_link_order *link_order,
1263 . unsigned int *src_ptr,
1264 . unsigned int *dst_ptr));
1265 . int (*_bfd_coff_reloc16_estimate) PARAMS ((
1267 . asection *input_section,
1269 . unsigned int shrink,
1270 . struct bfd_link_info *link_info));
1271 . enum coff_symbol_classification (*_bfd_coff_classify_symbol) PARAMS ((
1273 . struct internal_syment *));
1274 . boolean (*_bfd_coff_compute_section_file_positions) PARAMS ((
1276 . boolean (*_bfd_coff_start_final_link) PARAMS ((
1278 . struct bfd_link_info *info));
1279 . boolean (*_bfd_coff_relocate_section) PARAMS ((
1281 . struct bfd_link_info *info,
1283 . asection *input_section,
1284 . bfd_byte *contents,
1285 . struct internal_reloc *relocs,
1286 . struct internal_syment *syms,
1287 . asection **sections));
1288 . reloc_howto_type *(*_bfd_coff_rtype_to_howto) PARAMS ((
1291 . struct internal_reloc *rel,
1292 . struct coff_link_hash_entry *h,
1293 . struct internal_syment *sym,
1294 . bfd_vma *addendp));
1295 . boolean (*_bfd_coff_adjust_symndx) PARAMS ((
1297 . struct bfd_link_info *info,
1300 . struct internal_reloc *reloc,
1301 . boolean *adjustedp));
1302 . boolean (*_bfd_coff_link_add_one_symbol) PARAMS ((
1303 . struct bfd_link_info *info,
1307 . asection *section,
1309 . const char *string,
1312 . struct bfd_link_hash_entry **hashp));
1314 . boolean (*_bfd_coff_link_output_has_begun) PARAMS ((
1316 . struct coff_final_link_info * pfinfo));
1317 . boolean (*_bfd_coff_final_link_postscript) PARAMS ((
1319 . struct coff_final_link_info * pfinfo));
1321 .} bfd_coff_backend_data;
1323 .#define coff_backend_info(abfd) ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1325 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1326 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1328 .#define bfd_coff_swap_sym_in(a,e,i) \
1329 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1331 .#define bfd_coff_swap_lineno_in(a,e,i) \
1332 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1334 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1335 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1337 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1338 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1340 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1341 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1343 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1344 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1346 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1347 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1349 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1350 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1352 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1353 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1355 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1356 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1357 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1358 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1359 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1360 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1361 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1362 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1363 .#define bfd_coff_long_filenames(abfd) (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1364 .#define bfd_coff_long_section_names(abfd) \
1365 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1366 .#define bfd_coff_default_section_alignment_power(abfd) \
1367 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1368 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1369 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1371 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1372 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1374 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1375 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1377 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1378 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1380 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1381 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1383 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1384 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1385 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1386 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook) (abfd, filehdr, aouthdr))
1388 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section)\
1389 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1390 . (abfd, scnhdr, name, section))
1392 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1393 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1395 .#define bfd_coff_slurp_symbol_table(abfd)\
1396 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1398 .#define bfd_coff_symname_in_debug(abfd, sym)\
1399 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1401 .#define bfd_coff_force_symnames_in_strings(abfd)\
1402 . (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
1404 .#define bfd_coff_debug_string_prefix_length(abfd)\
1405 . (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
1407 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1408 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1409 . (abfd, file, base, symbol, aux, indaux))
1411 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)\
1412 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1413 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1415 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1416 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1417 . (abfd, section, reloc, shrink, link_info))
1419 .#define bfd_coff_classify_symbol(abfd, sym)\
1420 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1423 .#define bfd_coff_compute_section_file_positions(abfd)\
1424 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1427 .#define bfd_coff_start_final_link(obfd, info)\
1428 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1430 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1431 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1432 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1433 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1434 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1435 . (abfd, sec, rel, h, sym, addendp))
1436 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1437 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1438 . (obfd, info, ibfd, sec, rel, adjustedp))
1439 .#define bfd_coff_link_add_one_symbol(info,abfd,name,flags,section,value,string,cp,coll,hashp)\
1440 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1441 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1443 .#define bfd_coff_link_output_has_begun(a,p) \
1444 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a,p))
1445 .#define bfd_coff_final_link_postscript(a,p) \
1446 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a,p))
1450 /* See whether the magic number matches. */
1453 coff_bad_format_hook (abfd, filehdr)
1454 bfd * abfd ATTRIBUTE_UNUSED;
1457 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1459 if (BADMAG (*internal_f))
1462 /* if the optional header is NULL or not the correct size then
1463 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1464 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1465 optional header is of a different size.
1467 But the mips keeps extra stuff in it's opthdr, so dont check
1471 #if defined(M88) || defined(I960)
1472 if (internal_f->f_opthdr != 0 && bfd_coff_aoutsz (abfd) != internal_f->f_opthdr)
1479 /* Check whether this section uses an alignment other than the
1483 coff_set_custom_section_alignment (abfd, section, alignment_table, table_size)
1484 bfd *abfd ATTRIBUTE_UNUSED;
1486 const struct coff_section_alignment_entry *alignment_table;
1487 const unsigned int table_size;
1489 const unsigned int default_alignment = COFF_DEFAULT_SECTION_ALIGNMENT_POWER;
1492 for (i = 0; i < table_size; ++i)
1494 const char *secname = bfd_get_section_name (abfd, section);
1495 if (alignment_table[i].comparison_length == (unsigned int) -1
1496 ? strcmp (alignment_table[i].name, secname) == 0
1497 : strncmp (alignment_table[i].name, secname,
1498 alignment_table[i].comparison_length) == 0)
1501 if (i >= table_size)
1504 if (alignment_table[i].default_alignment_min != COFF_ALIGNMENT_FIELD_EMPTY
1505 && default_alignment < alignment_table[i].default_alignment_min)
1508 if (alignment_table[i].default_alignment_max != COFF_ALIGNMENT_FIELD_EMPTY
1509 && default_alignment > alignment_table[i].default_alignment_max)
1512 section->alignment_power = alignment_table[i].alignment_power;
1515 /* Custom section alignment records. */
1517 static const struct coff_section_alignment_entry
1518 coff_section_alignment_table[] =
1520 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1521 COFF_SECTION_ALIGNMENT_ENTRIES,
1523 /* There must not be any gaps between .stabstr sections. */
1524 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1525 1, COFF_ALIGNMENT_FIELD_EMPTY, 0 },
1526 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1527 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1528 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 },
1529 /* Similarly for the .ctors and .dtors sections. */
1530 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1531 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 },
1532 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1533 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 }
1536 static const unsigned int coff_section_alignment_table_size =
1537 sizeof coff_section_alignment_table / sizeof coff_section_alignment_table[0];
1539 /* Initialize a section structure with information peculiar to this
1540 particular implementation of COFF. */
1543 coff_new_section_hook (abfd, section)
1547 combined_entry_type *native;
1549 section->alignment_power = COFF_DEFAULT_SECTION_ALIGNMENT_POWER;
1552 if (xcoff_data (abfd)->text_align_power != 0
1553 && strcmp (bfd_get_section_name (abfd, section), ".text") == 0)
1554 section->alignment_power = xcoff_data (abfd)->text_align_power;
1555 if (xcoff_data (abfd)->data_align_power != 0
1556 && strcmp (bfd_get_section_name (abfd, section), ".data") == 0)
1557 section->alignment_power = xcoff_data (abfd)->data_align_power;
1560 /* Allocate aux records for section symbols, to store size and
1563 @@ The 10 is a guess at a plausible maximum number of aux entries
1564 (but shouldn't be a constant). */
1565 native = ((combined_entry_type *)
1566 bfd_zalloc (abfd, sizeof (combined_entry_type) * 10));
1570 /* We don't need to set up n_name, n_value, or n_scnum in the native
1571 symbol information, since they'll be overriden by the BFD symbol
1572 anyhow. However, we do need to set the type and storage class,
1573 in case this symbol winds up getting written out. The value 0
1574 for n_numaux is already correct. */
1576 native->u.syment.n_type = T_NULL;
1577 native->u.syment.n_sclass = C_STAT;
1579 coffsymbol (section->symbol)->native = native;
1581 coff_set_custom_section_alignment (abfd, section,
1582 coff_section_alignment_table,
1583 coff_section_alignment_table_size);
1588 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1590 /* Set the alignment of a BFD section. */
1592 static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1595 coff_set_alignment_hook (abfd, section, scnhdr)
1596 bfd * abfd ATTRIBUTE_UNUSED;
1600 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1604 /* Extract ALIGN from 2**ALIGN stored in section header */
1605 for (i = 0; i < 32; i++)
1606 if ((1 << i) >= hdr->s_align)
1610 /* TI tools puts the alignment power in bits 8-11 */
1611 i = (hdr->s_flags >> 8) & 0xF ;
1613 #ifdef COFF_DECODE_ALIGNMENT
1614 i = COFF_DECODE_ALIGNMENT(hdr->s_flags);
1616 section->alignment_power = i;
1618 #ifdef coff_set_section_load_page
1619 coff_set_section_load_page (section, hdr->s_page);
1623 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1626 /* a couple of macros to help setting the alignment power field */
1627 #define ALIGN_SET(field,x,y) \
1628 if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x )\
1630 section->alignment_power = y;\
1633 #define ELIFALIGN_SET(field,x,y) \
1634 else if (( (field) & IMAGE_SCN_ALIGN_64BYTES) == x ) \
1636 section->alignment_power = y;\
1639 static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1642 coff_set_alignment_hook (abfd, section, scnhdr)
1643 bfd * abfd ATTRIBUTE_UNUSED;
1647 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1649 ALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_64BYTES, 6)
1650 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_32BYTES, 5)
1651 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_16BYTES, 4)
1652 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_8BYTES, 3)
1653 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_4BYTES, 2)
1654 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_2BYTES, 1)
1655 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_1BYTES, 0)
1657 /* In a PE image file, the s_paddr field holds the virtual size of a
1658 section, while the s_size field holds the raw size. We also keep
1659 the original section flag value, since not every bit can be
1660 mapped onto a generic BFD section bit. */
1661 if (coff_section_data (abfd, section) == NULL)
1663 section->used_by_bfd =
1664 (PTR) bfd_zalloc (abfd, sizeof (struct coff_section_tdata));
1665 if (section->used_by_bfd == NULL)
1667 /* FIXME: Return error. */
1671 if (pei_section_data (abfd, section) == NULL)
1673 coff_section_data (abfd, section)->tdata =
1674 (PTR) bfd_zalloc (abfd, sizeof (struct pei_section_tdata));
1675 if (coff_section_data (abfd, section)->tdata == NULL)
1677 /* FIXME: Return error. */
1681 pei_section_data (abfd, section)->virt_size = hdr->s_paddr;
1682 pei_section_data (abfd, section)->pe_flags = hdr->s_flags;
1684 section->lma = hdr->s_vaddr;
1686 /* check for extended relocs */
1687 if (hdr->s_flags & IMAGE_SCN_LNK_NRELOC_OVFL)
1689 struct external_reloc dst;
1690 struct internal_reloc n;
1691 int oldpos = bfd_tell (abfd);
1692 bfd_seek (abfd, hdr->s_relptr, 0);
1693 if (bfd_read ((PTR) & dst, 1, bfd_coff_relsz (abfd), abfd)
1694 != bfd_coff_relsz (abfd))
1697 coff_swap_reloc_in (abfd, &dst, &n);
1698 bfd_seek (abfd, oldpos, 0);
1699 section->reloc_count =
1700 hdr->s_nreloc = n.r_vaddr;
1704 #undef ELIFALIGN_SET
1706 #else /* ! COFF_WITH_PE */
1709 /* We grossly abuse this function to handle XCOFF overflow headers.
1710 When we see one, we correct the reloc and line number counts in the
1711 real header, and remove the section we just created. */
1713 static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1716 coff_set_alignment_hook (abfd, section, scnhdr)
1721 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1725 if ((hdr->s_flags & STYP_OVRFLO) == 0)
1728 real_sec = coff_section_from_bfd_index (abfd, hdr->s_nreloc);
1729 if (real_sec == NULL)
1732 real_sec->reloc_count = hdr->s_paddr;
1733 real_sec->lineno_count = hdr->s_vaddr;
1735 for (ps = &abfd->sections; *ps != NULL; ps = &(*ps)->next)
1740 --abfd->section_count;
1746 #else /* ! RS6000COFF_C */
1748 #define coff_set_alignment_hook \
1749 ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
1751 #endif /* ! RS6000COFF_C */
1752 #endif /* ! COFF_WITH_PE */
1753 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1755 #ifndef coff_mkobject
1757 static boolean coff_mkobject PARAMS ((bfd *));
1760 coff_mkobject (abfd)
1763 coff_data_type *coff;
1765 abfd->tdata.coff_obj_data = (struct coff_tdata *) bfd_zalloc (abfd, sizeof (coff_data_type));
1766 if (abfd->tdata.coff_obj_data == 0)
1768 coff = coff_data (abfd);
1769 coff->symbols = (coff_symbol_type *) NULL;
1770 coff->conversion_table = (unsigned int *) NULL;
1771 coff->raw_syments = (struct coff_ptr_struct *) NULL;
1772 coff->relocbase = 0;
1773 coff->local_toc_sym_map = 0;
1775 /* make_abs_section(abfd);*/
1781 /* Create the COFF backend specific information. */
1782 #ifndef coff_mkobject_hook
1784 coff_mkobject_hook (abfd, filehdr, aouthdr)
1787 PTR aouthdr ATTRIBUTE_UNUSED;
1789 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1790 coff_data_type *coff;
1792 if (coff_mkobject (abfd) == false)
1795 coff = coff_data (abfd);
1797 coff->sym_filepos = internal_f->f_symptr;
1799 /* These members communicate important constants about the symbol
1800 table to GDB's symbol-reading code. These `constants'
1801 unfortunately vary among coff implementations... */
1802 coff->local_n_btmask = N_BTMASK;
1803 coff->local_n_btshft = N_BTSHFT;
1804 coff->local_n_tmask = N_TMASK;
1805 coff->local_n_tshift = N_TSHIFT;
1806 coff->local_symesz = bfd_coff_symesz (abfd);
1807 coff->local_auxesz = bfd_coff_auxesz (abfd);
1808 coff->local_linesz = bfd_coff_linesz (abfd);
1810 coff->timestamp = internal_f->f_timdat;
1812 obj_raw_syment_count (abfd) =
1813 obj_conv_table_size (abfd) =
1814 internal_f->f_nsyms;
1817 if ((internal_f->f_flags & F_SHROBJ) != 0)
1818 abfd->flags |= DYNAMIC;
1819 if (aouthdr != NULL && internal_f->f_opthdr >= bfd_coff_aoutsz (abfd))
1821 struct internal_aouthdr *internal_a =
1822 (struct internal_aouthdr *) aouthdr;
1823 struct xcoff_tdata *xcoff;
1825 xcoff = xcoff_data (abfd);
1826 # ifdef U803XTOCMAGIC
1827 xcoff->xcoff64 = internal_f->f_magic == U803XTOCMAGIC;
1831 xcoff->full_aouthdr = true;
1832 xcoff->toc = internal_a->o_toc;
1833 xcoff->sntoc = internal_a->o_sntoc;
1834 xcoff->snentry = internal_a->o_snentry;
1835 xcoff->text_align_power = internal_a->o_algntext;
1836 xcoff->data_align_power = internal_a->o_algndata;
1837 xcoff->modtype = internal_a->o_modtype;
1838 xcoff->cputype = internal_a->o_cputype;
1839 xcoff->maxdata = internal_a->o_maxdata;
1840 xcoff->maxstack = internal_a->o_maxstack;
1845 /* Set the flags field from the COFF header read in */
1846 if (! _bfd_coff_arm_set_private_flags (abfd, internal_f->f_flags))
1851 /* FIXME: I'm not sure this is ever executed, since peicode.h
1852 defines coff_mkobject_hook. */
1853 if ((internal_f->f_flags & IMAGE_FILE_DEBUG_STRIPPED) == 0)
1854 abfd->flags |= HAS_DEBUG;
1861 /* Determine the machine architecture and type. FIXME: This is target
1862 dependent because the magic numbers are defined in the target
1863 dependent header files. But there is no particular need for this.
1864 If the magic numbers were moved to a separate file, this function
1865 would be target independent and would also be much more successful
1866 at linking together COFF files for different architectures. */
1869 coff_set_arch_mach_hook (abfd, filehdr)
1874 enum bfd_architecture arch;
1875 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1878 switch (internal_f->f_magic)
1882 arch = bfd_arch_powerpc;
1883 machine = 0; /* what does this mean? (krk) */
1889 case I386AIXMAGIC: /* Danbury PS/2 AIX C Compiler */
1890 case LYNXCOFFMAGIC: /* shadows the m68k Lynx number below, sigh */
1891 arch = bfd_arch_i386;
1897 arch = bfd_arch_ia64;
1901 #ifdef A29K_MAGIC_BIG
1902 case A29K_MAGIC_BIG:
1903 case A29K_MAGIC_LITTLE:
1904 arch = bfd_arch_a29k;
1912 arch = bfd_arch_arm;
1913 switch (internal_f->f_flags & F_ARM_ARCHITECTURE_MASK)
1915 case F_ARM_2: machine = bfd_mach_arm_2; break;
1916 case F_ARM_2a: machine = bfd_mach_arm_2a; break;
1917 case F_ARM_3: machine = bfd_mach_arm_3; break;
1919 case F_ARM_3M: machine = bfd_mach_arm_3M; break;
1920 case F_ARM_4: machine = bfd_mach_arm_4; break;
1921 case F_ARM_4T: machine = bfd_mach_arm_4T; break;
1922 case F_ARM_5: machine = bfd_mach_arm_5; break;
1929 #ifdef MC68KBCSMAGIC
1932 #ifdef APOLLOM68KMAGIC
1933 case APOLLOM68KMAGIC:
1935 #ifdef LYNXCOFFMAGIC
1938 arch = bfd_arch_m68k;
1939 machine = bfd_mach_m68020;
1946 arch = bfd_arch_m88k;
1952 arch = bfd_arch_z8k;
1953 switch (internal_f->f_flags & F_MACHMASK)
1956 machine = bfd_mach_z8001;
1959 machine = bfd_mach_z8002;
1968 arch = bfd_arch_i860;
1975 arch = bfd_arch_i960;
1976 switch (F_I960TYPE & internal_f->f_flags)
1980 machine = bfd_mach_i960_core;
1983 machine = bfd_mach_i960_kb_sb;
1986 machine = bfd_mach_i960_mc;
1989 machine = bfd_mach_i960_xa;
1992 machine = bfd_mach_i960_ca;
1995 machine = bfd_mach_i960_ka_sa;
1998 machine = bfd_mach_i960_jx;
2001 machine = bfd_mach_i960_hx;
2019 if (xcoff_data (abfd)->cputype != -1)
2020 cputype = xcoff_data (abfd)->cputype & 0xff;
2023 /* We did not get a value from the a.out header. If the
2024 file has not been stripped, we may be able to get the
2025 architecture information from the first symbol, if it
2026 is a .file symbol. */
2027 if (obj_raw_syment_count (abfd) == 0)
2032 struct internal_syment sym;
2034 buf = (bfd_byte *) bfd_malloc (bfd_coff_symesz (abfd));
2035 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
2036 || (bfd_read (buf, 1, bfd_coff_symesz (abfd), abfd)
2037 != bfd_coff_symesz (abfd)))
2042 bfd_coff_swap_sym_in (abfd, (PTR) buf, (PTR) &sym);
2043 if (sym.n_sclass == C_FILE)
2044 cputype = sym.n_type & 0xff;
2051 /* FIXME: We don't handle all cases here. */
2057 /* PowerPC Macs use the same magic numbers as RS/6000
2058 (because that's how they were bootstrapped originally),
2059 but they are always PowerPC architecture. */
2060 arch = bfd_arch_powerpc;
2061 machine = bfd_mach_ppc;
2064 arch = bfd_arch_powerpc;
2065 machine = bfd_mach_ppc_620;
2067 arch = bfd_arch_rs6000;
2068 machine = bfd_mach_rs6k;
2070 #endif /* POWERMAC */
2074 arch = bfd_arch_powerpc;
2075 machine = bfd_mach_ppc_601;
2077 case 2: /* 64 bit PowerPC */
2078 arch = bfd_arch_powerpc;
2079 machine = bfd_mach_ppc_620;
2082 arch = bfd_arch_powerpc;
2083 machine = bfd_mach_ppc;
2086 arch = bfd_arch_rs6000;
2087 machine = bfd_mach_rs6k;
2096 arch = bfd_arch_we32k;
2103 arch = bfd_arch_h8300;
2104 machine = bfd_mach_h8300;
2105 /* !! FIXME this probably isn't the right place for this */
2106 abfd->flags |= BFD_IS_RELAXABLE;
2112 arch = bfd_arch_h8300;
2113 machine = bfd_mach_h8300h;
2114 /* !! FIXME this probably isn't the right place for this */
2115 abfd->flags |= BFD_IS_RELAXABLE;
2121 arch = bfd_arch_h8300;
2122 machine = bfd_mach_h8300s;
2123 /* !! FIXME this probably isn't the right place for this */
2124 abfd->flags |= BFD_IS_RELAXABLE;
2128 #ifdef SH_ARCH_MAGIC_BIG
2129 case SH_ARCH_MAGIC_BIG:
2130 case SH_ARCH_MAGIC_LITTLE:
2132 case SH_ARCH_MAGIC_WINCE:
2139 #ifdef MIPS_ARCH_MAGIC_WINCE
2140 case MIPS_ARCH_MAGIC_WINCE:
2141 arch = bfd_arch_mips;
2148 arch = bfd_arch_h8500;
2155 #ifdef LYNXCOFFMAGIC
2158 arch = bfd_arch_sparc;
2165 arch = bfd_arch_tic30;
2170 #ifdef TICOFF_TARGET_ARCH
2171 /* this TI COFF section should be used by all new TI COFF v0 targets */
2173 arch = TICOFF_TARGET_ARCH;
2179 /* this TI COFF section should be used by all new TI COFF v1/2 targets */
2180 /* TI COFF1 and COFF2 use the target_id field to specify which arch */
2183 switch (internal_f->f_target_id)
2187 arch = TICOFF_TARGET_ARCH;
2191 arch = bfd_arch_obscure;
2192 (*_bfd_error_handler)
2193 (_("Unrecognized TI COFF target id '0x%x'"),
2194 internal_f->f_target_id);
2200 #ifdef TIC80_ARCH_MAGIC
2201 case TIC80_ARCH_MAGIC:
2202 arch = bfd_arch_tic80;
2208 arch = bfd_arch_mcore;
2211 default: /* Unreadable input file type */
2212 arch = bfd_arch_obscure;
2216 bfd_default_set_arch_mach (abfd, arch, machine);
2220 #ifdef SYMNAME_IN_DEBUG
2222 static boolean symname_in_debug_hook
2223 PARAMS ((bfd *, struct internal_syment *));
2226 symname_in_debug_hook (abfd, sym)
2227 bfd * abfd ATTRIBUTE_UNUSED;
2228 struct internal_syment *sym;
2230 return SYMNAME_IN_DEBUG (sym) ? true : false;
2235 #define symname_in_debug_hook \
2236 (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
2243 #define FORCE_SYMNAMES_IN_STRINGS
2246 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */
2248 static boolean coff_pointerize_aux_hook
2249 PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
2250 unsigned int, combined_entry_type *));
2254 coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux)
2255 bfd *abfd ATTRIBUTE_UNUSED;
2256 combined_entry_type *table_base;
2257 combined_entry_type *symbol;
2258 unsigned int indaux;
2259 combined_entry_type *aux;
2261 int class = symbol->u.syment.n_sclass;
2263 if ((class == C_EXT || class == C_HIDEXT)
2264 && indaux + 1 == symbol->u.syment.n_numaux)
2266 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD)
2268 aux->u.auxent.x_csect.x_scnlen.p =
2269 table_base + aux->u.auxent.x_csect.x_scnlen.l;
2270 aux->fix_scnlen = 1;
2273 /* Return true to indicate that the caller should not do any
2274 further work on this auxent. */
2278 /* Return false to indicate that this auxent should be handled by
2286 /* We don't want to pointerize bal entries. */
2288 static boolean coff_pointerize_aux_hook
2289 PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
2290 unsigned int, combined_entry_type *));
2294 coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux)
2295 bfd *abfd ATTRIBUTE_UNUSED;
2296 combined_entry_type *table_base ATTRIBUTE_UNUSED;
2297 combined_entry_type *symbol;
2298 unsigned int indaux;
2299 combined_entry_type *aux ATTRIBUTE_UNUSED;
2301 /* Return true if we don't want to pointerize this aux entry, which
2302 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
2304 && (symbol->u.syment.n_sclass == C_LEAFPROC
2305 || symbol->u.syment.n_sclass == C_LEAFSTAT
2306 || symbol->u.syment.n_sclass == C_LEAFEXT));
2311 #define coff_pointerize_aux_hook 0
2314 #endif /* ! RS6000COFF_C */
2316 /* Print an aux entry. This returns true if it has printed it. */
2318 static boolean coff_print_aux
2319 PARAMS ((bfd *, FILE *, combined_entry_type *, combined_entry_type *,
2320 combined_entry_type *, unsigned int));
2323 coff_print_aux (abfd, file, table_base, symbol, aux, indaux)
2324 bfd *abfd ATTRIBUTE_UNUSED;
2325 FILE *file ATTRIBUTE_UNUSED;
2326 combined_entry_type *table_base ATTRIBUTE_UNUSED;
2327 combined_entry_type *symbol ATTRIBUTE_UNUSED;
2328 combined_entry_type *aux ATTRIBUTE_UNUSED;
2329 unsigned int indaux ATTRIBUTE_UNUSED;
2332 if ((symbol->u.syment.n_sclass == C_EXT
2333 || symbol->u.syment.n_sclass == C_HIDEXT)
2334 && indaux + 1 == symbol->u.syment.n_numaux)
2336 /* This is a csect entry. */
2337 fprintf (file, "AUX ");
2338 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) != XTY_LD)
2340 BFD_ASSERT (! aux->fix_scnlen);
2341 fprintf (file, "val %5ld", aux->u.auxent.x_csect.x_scnlen.l);
2345 fprintf (file, "indx ");
2346 if (! aux->fix_scnlen)
2347 fprintf (file, "%4ld", aux->u.auxent.x_csect.x_scnlen.l);
2349 fprintf (file, "%4ld",
2350 (long) (aux->u.auxent.x_csect.x_scnlen.p - table_base));
2353 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2354 aux->u.auxent.x_csect.x_parmhash,
2355 (unsigned int) aux->u.auxent.x_csect.x_snhash,
2356 SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp),
2357 SMTYP_ALIGN (aux->u.auxent.x_csect.x_smtyp),
2358 (unsigned int) aux->u.auxent.x_csect.x_smclas,
2359 aux->u.auxent.x_csect.x_stab,
2360 (unsigned int) aux->u.auxent.x_csect.x_snstab);
2365 /* Return false to indicate that no special action was taken. */
2373 To write relocations, the back end steps though the
2374 canonical relocation table and create an
2375 @code{internal_reloc}. The symbol index to use is removed from
2376 the @code{offset} field in the symbol table supplied. The
2377 address comes directly from the sum of the section base
2378 address and the relocation offset; the type is dug directly
2379 from the howto field. Then the @code{internal_reloc} is
2380 swapped into the shape of an @code{external_reloc} and written
2387 static int compare_arelent_ptr PARAMS ((const PTR, const PTR));
2389 /* AUX's ld wants relocations to be sorted */
2391 compare_arelent_ptr (x, y)
2395 const arelent **a = (const arelent **) x;
2396 const arelent **b = (const arelent **) y;
2397 bfd_size_type aadr = (*a)->address;
2398 bfd_size_type badr = (*b)->address;
2400 return (aadr < badr ? -1 : badr < aadr ? 1 : 0);
2403 #endif /* TARG_AUX */
2406 coff_write_relocs (abfd, first_undef)
2412 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
2415 struct external_reloc dst;
2421 /* sort relocations before we write them out */
2422 p = (arelent **) bfd_malloc (s->reloc_count * sizeof (arelent *));
2423 if (p == NULL && s->reloc_count > 0)
2425 memcpy (p, s->orelocation, s->reloc_count * sizeof (arelent *));
2426 qsort (p, s->reloc_count, sizeof (arelent *), compare_arelent_ptr);
2429 if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0)
2433 if (s->reloc_count > 0xffff)
2435 /* encode real count here as first reloc */
2436 struct internal_reloc n;
2437 memset ((PTR) & n, 0, sizeof (n));
2438 /* add one to count *this* reloc (grr) */
2439 n.r_vaddr = s->reloc_count + 1;
2440 coff_swap_reloc_out (abfd, &n, &dst);
2441 if (bfd_write ((PTR) & dst, 1, bfd_coff_relsz (abfd), abfd)
2442 != bfd_coff_relsz (abfd))
2447 for (i = 0; i < s->reloc_count; i++)
2449 struct internal_reloc n;
2451 memset ((PTR) & n, 0, sizeof (n));
2453 /* Now we've renumbered the symbols we know where the
2454 undefined symbols live in the table. Check the reloc
2455 entries for symbols who's output bfd isn't the right one.
2456 This is because the symbol was undefined (which means
2457 that all the pointers are never made to point to the same
2458 place). This is a bad thing,'cause the symbols attached
2459 to the output bfd are indexed, so that the relocation
2460 entries know which symbol index they point to. So we
2461 have to look up the output symbol here. */
2463 if (q->sym_ptr_ptr[0]->the_bfd != abfd)
2466 const char *sname = q->sym_ptr_ptr[0]->name;
2467 asymbol **outsyms = abfd->outsymbols;
2468 for (i = first_undef; outsyms[i]; i++)
2470 const char *intable = outsyms[i]->name;
2471 if (strcmp (intable, sname) == 0) {
2472 /* got a hit, so repoint the reloc */
2473 q->sym_ptr_ptr = outsyms + i;
2479 n.r_vaddr = q->address + s->vma;
2482 /* The 29k const/consth reloc pair is a real kludge. The consth
2483 part doesn't have a symbol; it has an offset. So rebuilt
2485 if (q->howto->type == R_IHCONST)
2486 n.r_symndx = q->addend;
2491 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2492 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q,s))
2494 if (q->sym_ptr_ptr == bfd_abs_section_ptr->symbol_ptr_ptr)
2496 /* This is a relocation relative to the absolute symbol. */
2500 n.r_symndx = get_index ((*(q->sym_ptr_ptr)));
2501 /* Take notice if the symbol reloc points to a symbol
2502 we don't have in our symbol table. What should we
2504 if (n.r_symndx > obj_conv_table_size (abfd))
2509 #ifdef SWAP_OUT_RELOC_OFFSET
2510 n.r_offset = q->addend;
2514 /* Work out reloc type from what is required */
2515 SELECT_RELOC (n, q->howto);
2517 n.r_type = q->howto->type;
2519 coff_swap_reloc_out (abfd, &n, &dst);
2520 if (bfd_write ((PTR) & dst, 1, bfd_coff_relsz (abfd), abfd)
2521 != bfd_coff_relsz (abfd))
2534 /* Set flags and magic number of a coff file from architecture and machine
2535 type. Result is true if we can represent the arch&type, false if not. */
2538 coff_set_flags (abfd, magicp, flagsp)
2540 unsigned int *magicp ATTRIBUTE_UNUSED;
2541 unsigned short *flagsp ATTRIBUTE_UNUSED;
2543 switch (bfd_get_arch (abfd))
2548 switch (bfd_get_mach (abfd))
2550 case bfd_mach_z8001:
2553 case bfd_mach_z8002:
2567 *magicp = I960ROMAGIC;
2569 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
2570 I960RWMAGIC); FIXME???
2572 switch (bfd_get_mach (abfd))
2574 case bfd_mach_i960_core:
2577 case bfd_mach_i960_kb_sb:
2580 case bfd_mach_i960_mc:
2583 case bfd_mach_i960_xa:
2586 case bfd_mach_i960_ca:
2589 case bfd_mach_i960_ka_sa:
2592 case bfd_mach_i960_jx:
2595 case bfd_mach_i960_hx:
2608 case bfd_arch_tic30:
2609 *magicp = TIC30MAGIC;
2613 #ifdef TICOFF_DEFAULT_MAGIC
2614 case TICOFF_TARGET_ARCH:
2615 /* if there's no indication of which version we want, use the default */
2617 *magicp = TICOFF_DEFAULT_MAGIC;
2620 /* we may want to output in a different COFF version */
2621 switch (abfd->xvec->name[4])
2624 *magicp = TICOFF0MAGIC;
2627 *magicp = TICOFF1MAGIC;
2630 *magicp = TICOFF2MAGIC;
2639 #ifdef TIC80_ARCH_MAGIC
2640 case bfd_arch_tic80:
2641 *magicp = TIC80_ARCH_MAGIC;
2647 * magicp = ARMPEMAGIC;
2649 * magicp = ARMMAGIC;
2652 if (APCS_SET (abfd))
2654 if (APCS_26_FLAG (abfd))
2655 * flagsp |= F_APCS26;
2657 if (APCS_FLOAT_FLAG (abfd))
2658 * flagsp |= F_APCS_FLOAT;
2660 if (PIC_FLAG (abfd))
2663 if (INTERWORK_SET (abfd) && INTERWORK_FLAG (abfd))
2664 * flagsp |= F_INTERWORK;
2665 switch (bfd_get_mach (abfd))
2667 case bfd_mach_arm_2: * flagsp |= F_ARM_2; break;
2668 case bfd_mach_arm_2a: * flagsp |= F_ARM_2a; break;
2669 case bfd_mach_arm_3: * flagsp |= F_ARM_3; break;
2670 case bfd_mach_arm_3M: * flagsp |= F_ARM_3M; break;
2671 case bfd_mach_arm_4: * flagsp |= F_ARM_4; break;
2672 case bfd_mach_arm_4T: * flagsp |= F_ARM_4T; break;
2673 case bfd_mach_arm_5: * flagsp |= F_ARM_5; break;
2674 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5. */
2675 case bfd_mach_arm_5T: * flagsp |= F_ARM_5; break;
2676 case bfd_mach_arm_5TE: * flagsp |= F_ARM_5; break;
2677 case bfd_mach_arm_XScale: * flagsp |= F_ARM_5; break;
2682 case bfd_arch_powerpc:
2689 *magicp = I386MAGIC;
2691 /* Just overwrite the usual value if we're doing Lynx. */
2692 *magicp = LYNXCOFFMAGIC;
2699 *magicp = I860MAGIC;
2705 *magicp = IA64MAGIC;
2711 #ifdef APOLLOM68KMAGIC
2712 *magicp = APOLLO_COFF_VERSION_NUMBER;
2714 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2715 #ifdef NAMES_HAVE_UNDERSCORE
2716 *magicp = MC68KBCSMAGIC;
2718 *magicp = MC68MAGIC;
2722 /* Just overwrite the usual value if we're doing Lynx. */
2723 *magicp = LYNXCOFFMAGIC;
2731 *magicp = MC88OMAGIC;
2736 case bfd_arch_h8300:
2737 switch (bfd_get_mach (abfd))
2739 case bfd_mach_h8300:
2740 *magicp = H8300MAGIC;
2742 case bfd_mach_h8300h:
2743 *magicp = H8300HMAGIC;
2745 case bfd_mach_h8300s:
2746 *magicp = H8300SMAGIC;
2752 #ifdef SH_ARCH_MAGIC_BIG
2754 #ifdef COFF_IMAGE_WITH_PE
2755 *magicp = SH_ARCH_MAGIC_WINCE;
2757 if (bfd_big_endian (abfd))
2758 *magicp = SH_ARCH_MAGIC_BIG;
2760 *magicp = SH_ARCH_MAGIC_LITTLE;
2766 #ifdef MIPS_ARCH_MAGIC_WINCE
2768 *magicp = MIPS_ARCH_MAGIC_WINCE;
2774 case bfd_arch_sparc:
2775 *magicp = SPARCMAGIC;
2777 /* Just overwrite the usual value if we're doing Lynx. */
2778 *magicp = LYNXCOFFMAGIC;
2785 case bfd_arch_h8500:
2786 *magicp = H8500MAGIC;
2790 #ifdef A29K_MAGIC_BIG
2792 if (bfd_big_endian (abfd))
2793 *magicp = A29K_MAGIC_BIG;
2795 *magicp = A29K_MAGIC_LITTLE;
2801 case bfd_arch_we32k:
2802 *magicp = WE32KMAGIC;
2808 case bfd_arch_rs6000:
2810 case bfd_arch_powerpc:
2813 if (bfd_get_mach (abfd) == bfd_mach_ppc_620
2814 && !strncmp (abfd->xvec->name,"aix", 3))
2815 *magicp = U803XTOCMAGIC;
2818 *magicp = U802TOCMAGIC;
2825 case bfd_arch_mcore:
2826 * magicp = MCOREMAGIC;
2836 default: /* Unknown architecture. */
2837 /* Fall through to "return false" below, to avoid
2838 "statement never reached" errors on the one below. */
2846 coff_set_arch_mach (abfd, arch, machine)
2848 enum bfd_architecture arch;
2849 unsigned long machine;
2852 unsigned short dummy2;
2854 if (! bfd_default_set_arch_mach (abfd, arch, machine))
2857 if (arch != bfd_arch_unknown &&
2858 coff_set_flags (abfd, &dummy1, &dummy2) != true)
2859 return false; /* We can't represent this type */
2861 return true; /* We're easy ... */
2864 #ifdef COFF_IMAGE_WITH_PE
2866 /* This is used to sort sections by VMA, as required by PE image
2869 static int sort_by_secaddr PARAMS ((const PTR, const PTR));
2872 sort_by_secaddr (arg1, arg2)
2876 const asection *a = *(const asection **) arg1;
2877 const asection *b = *(const asection **) arg2;
2879 if (a->vma < b->vma)
2881 else if (a->vma > b->vma)
2887 #endif /* COFF_IMAGE_WITH_PE */
2889 /* Calculate the file position for each section. */
2892 #define ALIGN_SECTIONS_IN_FILE
2894 #if defined(TIC80COFF) || defined(TICOFF)
2895 #undef ALIGN_SECTIONS_IN_FILE
2899 coff_compute_section_file_positions (abfd)
2903 asection *previous = (asection *) NULL;
2904 file_ptr sofar = bfd_coff_filhsz (abfd);
2905 boolean align_adjust;
2906 #ifdef ALIGN_SECTIONS_IN_FILE
2911 /* On XCOFF, if we have symbols, set up the .debug section. */
2912 if (bfd_get_symcount (abfd) > 0)
2915 bfd_size_type i, symcount;
2919 symcount = bfd_get_symcount (abfd);
2920 for (symp = abfd->outsymbols, i = 0; i < symcount; symp++, i++)
2922 coff_symbol_type *cf;
2924 cf = coff_symbol_from (abfd, *symp);
2926 && cf->native != NULL
2927 && SYMNAME_IN_DEBUG (&cf->native->u.syment))
2931 len = strlen (bfd_asymbol_name (*symp));
2932 if (len > SYMNMLEN || bfd_coff_force_symnames_in_strings (abfd))
2933 sz += len + 1 + bfd_coff_debug_string_prefix_length (abfd);
2940 dsec = bfd_make_section_old_way (abfd, ".debug");
2943 dsec->_raw_size = sz;
2944 dsec->flags |= SEC_HAS_CONTENTS;
2949 #ifdef COFF_IMAGE_WITH_PE
2951 if (coff_data (abfd)->link_info)
2953 page_size = pe_data (abfd)->pe_opthdr.FileAlignment;
2956 page_size = PE_DEF_FILE_ALIGNMENT;
2958 #ifdef COFF_PAGE_SIZE
2959 int page_size = COFF_PAGE_SIZE;
2963 if (bfd_get_start_address (abfd))
2965 /* A start address may have been added to the original file. In this
2966 case it will need an optional header to record it. */
2967 abfd->flags |= EXEC_P;
2970 if (abfd->flags & EXEC_P)
2971 sofar += bfd_coff_aoutsz (abfd);
2973 else if (xcoff_data (abfd)->full_aouthdr)
2974 sofar += bfd_coff_aoutsz (abfd);
2976 sofar += SMALL_AOUTSZ;
2979 sofar += abfd->section_count * bfd_coff_scnhsz (abfd);
2982 /* XCOFF handles overflows in the reloc and line number count fields
2983 by allocating a new section header to hold the correct counts. */
2984 for (current = abfd->sections; current != NULL; current = current->next)
2985 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
2986 sofar += bfd_coff_scnhsz (abfd);
2989 #ifdef COFF_IMAGE_WITH_PE
2991 /* PE requires the sections to be in memory order when listed in
2992 the section headers. It also does not like empty loadable
2993 sections. The sections apparently do not have to be in the
2994 right order in the image file itself, but we do need to get the
2995 target_index values right. */
2998 asection **section_list;
3003 for (current = abfd->sections; current != NULL; current = current->next)
3006 /* We allocate an extra cell to simplify the final loop. */
3007 section_list = bfd_malloc (sizeof (struct asection *) * (count + 1));
3008 if (section_list == NULL)
3012 for (current = abfd->sections; current != NULL; current = current->next)
3014 section_list[i] = current;
3017 section_list[i] = NULL;
3019 qsort (section_list, count, sizeof (asection *), sort_by_secaddr);
3021 /* Rethread the linked list into sorted order; at the same time,
3022 assign target_index values. */
3024 abfd->sections = section_list[0];
3025 for (i = 0; i < count; i++)
3027 current = section_list[i];
3028 current->next = section_list[i + 1];
3030 /* Later, if the section has zero size, we'll be throwing it
3031 away, so we don't want to number it now. Note that having
3032 a zero size and having real contents are different
3033 concepts: .bss has no contents, but (usually) non-zero
3035 if (current->_raw_size == 0)
3037 /* Discard. However, it still might have (valid) symbols
3038 in it, so arbitrarily set it to section 1 (indexing is
3039 1-based here; usually .text). __end__ and other
3040 contents of .endsection really have this happen.
3041 FIXME: This seems somewhat dubious. */
3042 current->target_index = 1;
3045 current->target_index = target_index++;
3048 free (section_list);
3050 #else /* ! COFF_IMAGE_WITH_PE */
3052 /* Set the target_index field. */
3056 for (current = abfd->sections; current != NULL; current = current->next)
3057 current->target_index = target_index++;
3059 #endif /* ! COFF_IMAGE_WITH_PE */
3061 align_adjust = false;
3062 for (current = abfd->sections;
3063 current != (asection *) NULL;
3064 current = current->next)
3066 #ifdef COFF_IMAGE_WITH_PE
3067 /* With PE we have to pad each section to be a multiple of its
3068 page size too, and remember both sizes. */
3069 if (coff_section_data (abfd, current) == NULL)
3071 current->used_by_bfd =
3072 (PTR) bfd_zalloc (abfd, sizeof (struct coff_section_tdata));
3073 if (current->used_by_bfd == NULL)
3076 if (pei_section_data (abfd, current) == NULL)
3078 coff_section_data (abfd, current)->tdata =
3079 (PTR) bfd_zalloc (abfd, sizeof (struct pei_section_tdata));
3080 if (coff_section_data (abfd, current)->tdata == NULL)
3083 if (pei_section_data (abfd, current)->virt_size == 0)
3084 pei_section_data (abfd, current)->virt_size = current->_raw_size;
3087 /* Only deal with sections which have contents. */
3088 if (!(current->flags & SEC_HAS_CONTENTS))
3091 #ifdef COFF_IMAGE_WITH_PE
3092 /* Make sure we skip empty sections in a PE image. */
3093 if (current->_raw_size == 0)
3097 /* Align the sections in the file to the same boundary on
3098 which they are aligned in virtual memory. I960 doesn't
3099 do this (FIXME) so we can stay in sync with Intel. 960
3100 doesn't yet page from files... */
3101 #ifdef ALIGN_SECTIONS_IN_FILE
3102 if ((abfd->flags & EXEC_P) != 0)
3104 /* make sure this section is aligned on the right boundary - by
3105 padding the previous section up if necessary */
3108 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3109 if (previous != (asection *) NULL)
3111 previous->_raw_size += sofar - old_sofar;
3117 /* In demand paged files the low order bits of the file offset
3118 must match the low order bits of the virtual address. */
3119 #ifdef COFF_PAGE_SIZE
3120 if ((abfd->flags & D_PAGED) != 0
3121 && (current->flags & SEC_ALLOC) != 0)
3122 sofar += (current->vma - sofar) % page_size;
3124 current->filepos = sofar;
3126 #ifdef COFF_IMAGE_WITH_PE
3127 /* Set the padded size. */
3128 current->_raw_size = (current->_raw_size + page_size -1) & -page_size;
3131 sofar += current->_raw_size;
3133 #ifdef ALIGN_SECTIONS_IN_FILE
3134 /* make sure that this section is of the right size too */
3135 if ((abfd->flags & EXEC_P) == 0)
3137 bfd_size_type old_size;
3139 old_size = current->_raw_size;
3140 current->_raw_size = BFD_ALIGN (current->_raw_size,
3141 1 << current->alignment_power);
3142 align_adjust = current->_raw_size != old_size;
3143 sofar += current->_raw_size - old_size;
3148 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3149 align_adjust = sofar != old_sofar;
3150 current->_raw_size += sofar - old_sofar;
3154 #ifdef COFF_IMAGE_WITH_PE
3155 /* For PE we need to make sure we pad out to the aligned
3156 _raw_size, in case the caller only writes out data to the
3157 unaligned _raw_size. */
3158 if (pei_section_data (abfd, current)->virt_size < current->_raw_size)
3159 align_adjust = true;
3163 /* Force .lib sections to start at zero. The vma is then
3164 incremented in coff_set_section_contents. This is right for
3166 if (strcmp (current->name, _LIB) == 0)
3167 bfd_set_section_vma (abfd, current, 0);
3173 /* It is now safe to write to the output file. If we needed an
3174 alignment adjustment for the last section, then make sure that
3175 there is a byte at offset sofar. If there are no symbols and no
3176 relocs, then nothing follows the last section. If we don't force
3177 the last byte out, then the file may appear to be truncated. */
3183 if (bfd_seek (abfd, sofar - 1, SEEK_SET) != 0
3184 || bfd_write (&b, 1, 1, abfd) != 1)
3188 /* Make sure the relocations are aligned. We don't need to make
3189 sure that this byte exists, because it will only matter if there
3190 really are relocs. */
3191 sofar = BFD_ALIGN (sofar, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER);
3193 obj_relocbase (abfd) = sofar;
3194 abfd->output_has_begun = true;
3201 /* This can never work, because it is called too late--after the
3202 section positions have been set. I can't figure out what it is
3203 for, so I am going to disable it--Ian Taylor 20 March 1996. */
3205 /* If .file, .text, .data, .bss symbols are missing, add them. */
3206 /* @@ Should we only be adding missing symbols, or overriding the aux
3207 values for existing section symbols? */
3209 coff_add_missing_symbols (abfd)
3212 unsigned int nsyms = bfd_get_symcount (abfd);
3213 asymbol **sympp = abfd->outsymbols;
3216 int need_text = 1, need_data = 1, need_bss = 1, need_file = 1;
3218 for (i = 0; i < nsyms; i++)
3220 coff_symbol_type *csym = coff_symbol_from (abfd, sympp[i]);
3224 /* only do this if there is a coff representation of the input
3226 if (csym->native && csym->native->u.syment.n_sclass == C_FILE)
3231 name = csym->symbol.name;
3234 if (!strcmp (name, _TEXT))
3237 else if (!strcmp (name, ".wtext"))
3240 else if (!strcmp (name, _DATA))
3242 else if (!strcmp (name, _BSS))
3246 /* Now i == bfd_get_symcount (abfd). */
3247 /* @@ For now, don't deal with .file symbol. */
3250 if (!need_text && !need_data && !need_bss && !need_file)
3252 nsyms += need_text + need_data + need_bss + need_file;
3253 sympp2 = (asymbol **) bfd_alloc (abfd, nsyms * sizeof (asymbol *));
3256 memcpy (sympp2, sympp, i * sizeof (asymbol *));
3259 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
3263 sympp2[i++] = coff_section_symbol (abfd, _TEXT);
3265 sympp2[i++] = coff_section_symbol (abfd, _DATA);
3267 sympp2[i++] = coff_section_symbol (abfd, _BSS);
3268 BFD_ASSERT (i == nsyms);
3269 bfd_set_symtab (abfd, sympp2, nsyms);
3278 coff_write_object_contents (abfd)
3282 boolean hasrelocs = false;
3283 boolean haslinno = false;
3284 boolean hasdebug = false;
3286 file_ptr reloc_base;
3287 file_ptr lineno_base;
3289 unsigned long reloc_size = 0, reloc_count = 0;
3290 unsigned long lnno_size = 0;
3291 boolean long_section_names;
3292 asection *text_sec = NULL;
3293 asection *data_sec = NULL;
3294 asection *bss_sec = NULL;
3295 struct internal_filehdr internal_f;
3296 struct internal_aouthdr internal_a;
3297 #ifdef COFF_LONG_SECTION_NAMES
3298 size_t string_size = STRING_SIZE_SIZE;
3301 bfd_set_error (bfd_error_system_call);
3303 /* Make a pass through the symbol table to count line number entries and
3304 put them into the correct asections */
3306 lnno_size = coff_count_linenumbers (abfd) * bfd_coff_linesz (abfd);
3308 if (abfd->output_has_begun == false)
3310 if (! coff_compute_section_file_positions (abfd))
3314 reloc_base = obj_relocbase (abfd);
3316 /* Work out the size of the reloc and linno areas */
3318 for (current = abfd->sections; current != NULL; current =
3322 /* we store the actual reloc count in the first reloc's addr */
3323 if (current->reloc_count > 0xffff)
3326 reloc_count += current->reloc_count;
3329 reloc_size = reloc_count * bfd_coff_relsz (abfd);
3331 lineno_base = reloc_base + reloc_size;
3332 sym_base = lineno_base + lnno_size;
3334 /* Indicate in each section->line_filepos its actual file address */
3335 for (current = abfd->sections; current != NULL; current =
3338 if (current->lineno_count)
3340 current->line_filepos = lineno_base;
3341 current->moving_line_filepos = lineno_base;
3342 lineno_base += current->lineno_count * bfd_coff_linesz (abfd);
3346 current->line_filepos = 0;
3348 if (current->reloc_count)
3350 current->rel_filepos = reloc_base;
3351 reloc_base += current->reloc_count * bfd_coff_relsz (abfd);
3353 /* extra reloc to hold real count */
3354 if (current->reloc_count > 0xffff)
3355 reloc_base += bfd_coff_relsz (abfd);
3360 current->rel_filepos = 0;
3364 /* Write section headers to the file. */
3365 internal_f.f_nscns = 0;
3367 if ((abfd->flags & EXEC_P) != 0)
3368 scn_base = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
3371 scn_base = bfd_coff_filhsz (abfd);
3373 if (xcoff_data (abfd)->full_aouthdr)
3374 scn_base += bfd_coff_aoutsz (abfd);
3376 scn_base += SMALL_AOUTSZ;
3380 if (bfd_seek (abfd, scn_base, SEEK_SET) != 0)
3383 long_section_names = false;
3384 for (current = abfd->sections;
3386 current = current->next)
3388 struct internal_scnhdr section;
3389 boolean is_reloc_section = false;
3391 #ifdef COFF_IMAGE_WITH_PE
3392 if (strcmp (current->name, ".reloc") == 0)
3394 is_reloc_section = true;
3396 pe_data (abfd)->has_reloc_section = 1;
3400 internal_f.f_nscns++;
3402 strncpy (section.s_name, current->name, SCNNMLEN);
3404 #ifdef COFF_LONG_SECTION_NAMES
3405 /* Handle long section names as in PE. This must be compatible
3406 with the code in coff_write_symbols and _bfd_coff_final_link. */
3410 len = strlen (current->name);
3413 memset (section.s_name, 0, SCNNMLEN);
3414 sprintf (section.s_name, "/%lu", (unsigned long) string_size);
3415 string_size += len + 1;
3416 long_section_names = true;
3422 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3423 Ian Taylor <ian@cygnus.com>. */
3424 if (strcmp (current->name, _LIB) == 0)
3425 section.s_vaddr = 0;
3428 section.s_vaddr = current->vma;
3429 section.s_paddr = current->lma;
3430 section.s_size = current->_raw_size;
3431 #ifdef coff_get_section_load_page
3432 section.s_page = coff_get_section_load_page (current);
3436 section.s_paddr = 0;
3438 #ifdef COFF_IMAGE_WITH_PE
3439 /* Reminder: s_paddr holds the virtual size of the section. */
3440 if (coff_section_data (abfd, current) != NULL
3441 && pei_section_data (abfd, current) != NULL)
3442 section.s_paddr = pei_section_data (abfd, current)->virt_size;
3444 section.s_paddr = 0;
3448 If this section has no size or is unloadable then the scnptr
3451 if (current->_raw_size == 0 ||
3452 (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
3454 section.s_scnptr = 0;
3458 section.s_scnptr = current->filepos;
3460 section.s_relptr = current->rel_filepos;
3461 section.s_lnnoptr = current->line_filepos;
3462 section.s_nreloc = current->reloc_count;
3463 section.s_nlnno = current->lineno_count;
3464 #ifndef COFF_IMAGE_WITH_PE
3465 /* In PEI, relocs come in the .reloc section. */
3466 if (current->reloc_count != 0)
3469 if (current->lineno_count != 0)
3471 if ((current->flags & SEC_DEBUGGING) != 0
3472 && ! is_reloc_section)
3477 /* Indicate the use of an XCOFF overflow section header. */
3478 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3480 section.s_nreloc = 0xffff;
3481 section.s_nlnno = 0xffff;
3486 section.s_flags = sec_to_styp_flags (current->name, current->flags);
3488 if (!strcmp (current->name, _TEXT))
3492 else if (!strcmp (current->name, _DATA))
3496 else if (!strcmp (current->name, _BSS))
3502 section.s_align = (current->alignment_power
3503 ? 1 << current->alignment_power
3507 /* TI COFF puts the alignment power in bits 8-11 of the flags */
3508 section.s_flags |= (current->alignment_power & 0xF) << 8;
3510 #ifdef COFF_ENCODE_ALIGNMENT
3511 COFF_ENCODE_ALIGNMENT(section, current->alignment_power);
3514 #ifdef COFF_IMAGE_WITH_PE
3515 /* Suppress output of the sections if they are null. ld
3516 includes the bss and data sections even if there is no size
3517 assigned to them. NT loader doesn't like it if these section
3518 headers are included if the sections themselves are not
3519 needed. See also coff_compute_section_file_positions. */
3520 if (section.s_size == 0)
3521 internal_f.f_nscns--;
3526 if (coff_swap_scnhdr_out (abfd, §ion, &buff) == 0
3527 || bfd_write ((PTR) (&buff), 1, bfd_coff_scnhsz (abfd), abfd)
3528 != bfd_coff_scnhsz (abfd))
3533 /* PE stores COMDAT section information in the symbol table. If
3534 this section is supposed to have some COMDAT info, track down
3535 the symbol in the symbol table and modify it. */
3536 if ((current->flags & SEC_LINK_ONCE) != 0)
3538 unsigned int i, count;
3540 coff_symbol_type *csym = NULL;
3544 count = bfd_get_symcount (abfd);
3545 for (i = 0, psym = abfd->outsymbols; i < count; i++, psym++)
3547 if ((*psym)->section != current)
3550 /* Remember the location of the first symbol in this
3552 if (psymsec == NULL)
3555 /* See if this is the section symbol. */
3556 if (strcmp ((*psym)->name, current->name) == 0)
3558 csym = coff_symbol_from (abfd, *psym);
3560 || csym->native == NULL
3561 || csym->native->u.syment.n_numaux < 1
3562 || csym->native->u.syment.n_sclass != C_STAT
3563 || csym->native->u.syment.n_type != T_NULL)
3566 /* Here *PSYM is the section symbol for CURRENT. */
3573 Note that we might not if we're converting the file from
3574 some other object file format. */
3577 combined_entry_type *aux;
3579 /* We don't touch the x_checksum field. The
3580 x_associated field is not currently supported. */
3582 aux = csym->native + 1;
3583 switch (current->flags & SEC_LINK_DUPLICATES)
3585 case SEC_LINK_DUPLICATES_DISCARD:
3586 aux->u.auxent.x_scn.x_comdat = IMAGE_COMDAT_SELECT_ANY;
3589 case SEC_LINK_DUPLICATES_ONE_ONLY:
3590 aux->u.auxent.x_scn.x_comdat =
3591 IMAGE_COMDAT_SELECT_NODUPLICATES;
3594 case SEC_LINK_DUPLICATES_SAME_SIZE:
3595 aux->u.auxent.x_scn.x_comdat =
3596 IMAGE_COMDAT_SELECT_SAME_SIZE;
3599 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
3600 aux->u.auxent.x_scn.x_comdat =
3601 IMAGE_COMDAT_SELECT_EXACT_MATCH;
3605 /* The COMDAT symbol must be the first symbol from this
3606 section in the symbol table. In order to make this
3607 work, we move the COMDAT symbol before the first
3608 symbol we found in the search above. It's OK to
3609 rearrange the symbol table at this point, because
3610 coff_renumber_symbols is going to rearrange it
3611 further and fix up all the aux entries. */
3612 if (psym != psymsec)
3618 for (pcopy = psym; pcopy > psymsec; pcopy--)
3619 pcopy[0] = pcopy[-1];
3624 #endif /* COFF_WITH_PE */
3628 /* XCOFF handles overflows in the reloc and line number count fields
3629 by creating a new section header to hold the correct values. */
3630 for (current = abfd->sections; current != NULL; current = current->next)
3632 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3634 struct internal_scnhdr scnhdr;
3637 internal_f.f_nscns++;
3638 strncpy (&(scnhdr.s_name[0]), current->name, 8);
3639 scnhdr.s_paddr = current->reloc_count;
3640 scnhdr.s_vaddr = current->lineno_count;
3642 scnhdr.s_scnptr = 0;
3643 scnhdr.s_relptr = current->rel_filepos;
3644 scnhdr.s_lnnoptr = current->line_filepos;
3645 scnhdr.s_nreloc = current->target_index;
3646 scnhdr.s_nlnno = current->target_index;
3647 scnhdr.s_flags = STYP_OVRFLO;
3648 if (coff_swap_scnhdr_out (abfd, &scnhdr, &buff) == 0
3649 || bfd_write ((PTR) &buff, 1, bfd_coff_scnhsz (abfd), abfd)
3650 != bfd_coff_scnhsz (abfd))
3656 /* OK, now set up the filehdr... */
3658 /* Don't include the internal abs section in the section count */
3661 We will NOT put a fucking timestamp in the header here. Every time you
3662 put it back, I will come in and take it out again. I'm sorry. This
3663 field does not belong here. We fill it with a 0 so it compares the
3664 same but is not a reasonable time. -- gnu@cygnus.com
3666 internal_f.f_timdat = 0;
3668 internal_f.f_flags = 0;
3670 if (abfd->flags & EXEC_P)
3671 internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
3674 internal_f.f_opthdr = 0;
3676 if (xcoff_data (abfd)->full_aouthdr)
3677 internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
3679 internal_f.f_opthdr = SMALL_AOUTSZ;
3684 internal_f.f_flags |= F_RELFLG;
3686 internal_f.f_flags |= F_LNNO;
3687 if (abfd->flags & EXEC_P)
3688 internal_f.f_flags |= F_EXEC;
3689 #ifdef COFF_IMAGE_WITH_PE
3691 internal_f.f_flags |= IMAGE_FILE_DEBUG_STRIPPED;
3694 #ifndef COFF_WITH_PE
3695 if (bfd_little_endian (abfd))
3696 internal_f.f_flags |= F_AR32WR;
3698 internal_f.f_flags |= F_AR32W;
3702 /* target id is used in TI COFF v1 and later; COFF0 won't use this field,
3703 but it doesn't hurt to set it internally */
3704 internal_f.f_target_id = TI_TARGET_ID;
3706 #ifdef TIC80_TARGET_ID
3707 internal_f.f_target_id = TIC80_TARGET_ID;
3711 FIXME, should do something about the other byte orders and
3716 if ((abfd->flags & DYNAMIC) != 0)
3717 internal_f.f_flags |= F_SHROBJ;
3718 if (bfd_get_section_by_name (abfd, _LOADER) != NULL)
3719 internal_f.f_flags |= F_DYNLOAD;
3722 memset (&internal_a, 0, sizeof internal_a);
3724 /* Set up architecture-dependent stuff */
3727 unsigned int magic = 0;
3728 unsigned short flags = 0;
3729 coff_set_flags (abfd, &magic, &flags);
3730 internal_f.f_magic = magic;
3731 internal_f.f_flags |= flags;
3732 /* ...and the "opt"hdr... */
3735 #ifdef ULTRA3 /* NYU's machine */
3736 /* FIXME: This is a bogus check. I really want to see if there
3737 * is a .shbss or a .shdata section, if so then set the magic
3738 * number to indicate a shared data executable.
3740 if (internal_f.f_nscns >= 7)
3741 internal_a.magic = SHMAGIC; /* Shared magic */
3744 internal_a.magic = NMAGIC; /* Assume separate i/d */
3745 #define __A_MAGIC_SET__
3747 #ifdef TICOFF_AOUT_MAGIC
3748 internal_a.magic = TICOFF_AOUT_MAGIC;
3749 #define __A_MAGIC_SET__
3752 internal_a.magic = TIC80_ARCH_MAGIC;
3753 #define __A_MAGIC_SET__
3756 /* FIXME: What are the a.out magic numbers for the i860? */
3757 internal_a.magic = 0;
3758 #define __A_MAGIC_SET__
3761 internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
3762 #define __A_MAGIC_SET__
3765 #define __A_MAGIC_SET__
3766 internal_a.magic = PAGEMAGICBCS;
3770 #define __A_MAGIC_SET__
3771 internal_a.magic = APOLLO_COFF_VERSION_NUMBER;
3774 #if defined(M68) || defined(WE32K) || defined(M68K)
3775 #define __A_MAGIC_SET__
3777 internal_a.magic = LYNXCOFFMAGIC;
3779 #if defined(TARG_AUX)
3780 internal_a.magic = (abfd->flags & D_PAGED ? PAGEMAGICPEXECPAGED :
3781 abfd->flags & WP_TEXT ? PAGEMAGICPEXECSWAPPED :
3782 PAGEMAGICEXECSWAPPED);
3784 #if defined (PAGEMAGICPEXECPAGED)
3785 internal_a.magic = PAGEMAGICPEXECPAGED;
3787 #endif /* TARG_AUX */
3789 #endif /* M68 || WE32K || M68K */
3792 #define __A_MAGIC_SET__
3793 internal_a.magic = ZMAGIC;
3797 #define __A_MAGIC_SET__
3798 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
3801 #if defined MCORE_PE
3802 #define __A_MAGIC_SET__
3803 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
3807 #define __A_MAGIC_SET__
3809 internal_a.magic = LYNXCOFFMAGIC;
3811 internal_a.magic = ZMAGIC;
3816 #define __A_MAGIC_SET__
3817 internal_a.magic = ZMAGIC;
3821 #define __A_MAGIC_SET__
3823 internal_a.magic = LYNXCOFFMAGIC;
3828 #define __A_MAGIC_SET__
3829 internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC :
3830 (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC :
3831 RS6K_AOUTHDR_OMAGIC;
3834 #if defined(SH) && defined(COFF_WITH_PE)
3835 #define __A_MAGIC_SET__
3836 internal_a.magic = SH_PE_MAGIC;
3839 #if defined(MIPS) && defined(COFF_WITH_PE)
3840 #define __A_MAGIC_SET__
3841 internal_a.magic = MIPS_PE_MAGIC;
3844 #ifndef __A_MAGIC_SET__
3845 #include "Your aouthdr magic number is not being set!"
3847 #undef __A_MAGIC_SET__
3851 /* FIXME: Does anybody ever set this to another value? */
3852 internal_a.vstamp = 0;
3854 /* Now should write relocs, strings, syms */
3855 obj_sym_filepos (abfd) = sym_base;
3857 if (bfd_get_symcount (abfd) != 0)
3861 if (!coff_add_missing_symbols (abfd))
3864 if (!coff_renumber_symbols (abfd, &firstundef))
3866 coff_mangle_symbols (abfd);
3867 if (! coff_write_symbols (abfd))
3869 if (! coff_write_linenumbers (abfd))
3871 if (! coff_write_relocs (abfd, firstundef))
3874 #ifdef COFF_LONG_SECTION_NAMES
3875 else if (long_section_names && ! obj_coff_strings_written (abfd))
3877 /* If we have long section names we have to write out the string
3878 table even if there are no symbols. */
3879 if (! coff_write_symbols (abfd))
3883 #ifdef COFF_IMAGE_WITH_PE
3885 else if ((abfd->flags & EXEC_P) != 0)
3889 /* PowerPC PE appears to require that all executable files be
3890 rounded up to the page size. */
3893 BFD_ALIGN (sym_base, COFF_PAGE_SIZE) - 1,
3895 || bfd_write (&b, 1, 1, abfd) != 1)
3901 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
3902 backend linker, and obj_raw_syment_count is not valid until after
3903 coff_write_symbols is called. */
3904 if (obj_raw_syment_count (abfd) != 0)
3906 internal_f.f_symptr = sym_base;
3908 /* AIX appears to require that F_RELFLG not be set if there are
3909 local symbols but no relocations. */
3910 internal_f.f_flags &=~ F_RELFLG;
3915 if (long_section_names)
3916 internal_f.f_symptr = sym_base;
3918 internal_f.f_symptr = 0;
3919 internal_f.f_flags |= F_LSYMS;
3924 internal_a.tsize = bfd_get_section_size_before_reloc (text_sec);
3925 internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
3929 internal_a.dsize = bfd_get_section_size_before_reloc (data_sec);
3930 internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
3934 internal_a.bsize = bfd_get_section_size_before_reloc (bss_sec);
3935 if (internal_a.bsize && bss_sec->vma < internal_a.data_start)
3936 internal_a.data_start = bss_sec->vma;
3939 internal_a.entry = bfd_get_start_address (abfd);
3940 internal_f.f_nsyms = obj_raw_syment_count (abfd);
3943 if (xcoff_data (abfd)->full_aouthdr)
3946 asection *loader_sec;
3948 internal_a.vstamp = 1;
3950 internal_a.o_snentry = xcoff_data (abfd)->snentry;
3951 if (internal_a.o_snentry == 0)
3952 internal_a.entry = (bfd_vma) -1;
3954 if (text_sec != NULL)
3956 internal_a.o_sntext = text_sec->target_index;
3957 internal_a.o_algntext = bfd_get_section_alignment (abfd, text_sec);
3961 internal_a.o_sntext = 0;
3962 internal_a.o_algntext = 0;
3964 if (data_sec != NULL)
3966 internal_a.o_sndata = data_sec->target_index;
3967 internal_a.o_algndata = bfd_get_section_alignment (abfd, data_sec);
3971 internal_a.o_sndata = 0;
3972 internal_a.o_algndata = 0;
3974 loader_sec = bfd_get_section_by_name (abfd, ".loader");
3975 if (loader_sec != NULL)
3976 internal_a.o_snloader = loader_sec->target_index;
3978 internal_a.o_snloader = 0;
3979 if (bss_sec != NULL)
3980 internal_a.o_snbss = bss_sec->target_index;
3982 internal_a.o_snbss = 0;
3984 toc = xcoff_data (abfd)->toc;
3985 internal_a.o_toc = toc;
3986 internal_a.o_sntoc = xcoff_data (abfd)->sntoc;
3988 internal_a.o_modtype = xcoff_data (abfd)->modtype;
3989 if (xcoff_data (abfd)->cputype != -1)
3990 internal_a.o_cputype = xcoff_data (abfd)->cputype;
3993 switch (bfd_get_arch (abfd))
3995 case bfd_arch_rs6000:
3996 internal_a.o_cputype = 4;
3998 case bfd_arch_powerpc:
3999 if (bfd_get_mach (abfd) == 0)
4000 internal_a.o_cputype = 3;
4002 internal_a.o_cputype = 1;
4008 internal_a.o_maxstack = xcoff_data (abfd)->maxstack;
4009 internal_a.o_maxdata = xcoff_data (abfd)->maxdata;
4013 /* now write them */
4014 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
4019 bfd_size_type amount;
4021 buff = bfd_malloc (bfd_coff_filhsz (abfd));
4025 bfd_coff_swap_filehdr_out (abfd, (PTR) & internal_f, (PTR) buff);
4026 amount = bfd_write ((PTR) buff, 1, bfd_coff_filhsz (abfd), abfd);
4030 if (amount != bfd_coff_filhsz (abfd))
4034 if (abfd->flags & EXEC_P)
4036 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4037 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)) */
4039 bfd_size_type amount;
4041 buff = bfd_malloc (bfd_coff_aoutsz (abfd));
4045 coff_swap_aouthdr_out (abfd, (PTR) & internal_a, (PTR) buff);
4046 amount = bfd_write ((PTR) buff, 1, bfd_coff_aoutsz (abfd), abfd);
4050 if (amount != bfd_coff_aoutsz (abfd))
4059 /* XCOFF seems to always write at least a small a.out header. */
4060 coff_swap_aouthdr_out (abfd, (PTR) &internal_a, (PTR) &buff);
4061 if (xcoff_data (abfd)->full_aouthdr)
4062 size = bfd_coff_aoutsz (abfd);
4064 size = SMALL_AOUTSZ;
4065 if (bfd_write ((PTR) &buff, 1, size, abfd) != size)
4074 coff_set_section_contents (abfd, section, location, offset, count)
4079 bfd_size_type count;
4081 if (abfd->output_has_begun == false) /* set by bfd.c handler */
4083 if (! coff_compute_section_file_positions (abfd))
4087 #if defined(_LIB) && !defined(TARG_AUX)
4089 /* The physical address field of a .lib section is used to hold the
4090 number of shared libraries in the section. This code counts the
4091 number of sections being written, and increments the lma field
4094 I have found no documentation on the contents of this section.
4095 Experimentation indicates that the section contains zero or more
4096 records, each of which has the following structure:
4098 - a (four byte) word holding the length of this record, in words,
4099 - a word that always seems to be set to "2",
4100 - the path to a shared library, null-terminated and then padded
4101 to a whole word boundary.
4103 bfd_assert calls have been added to alert if an attempt is made
4104 to write a section which doesn't follow these assumptions. The
4105 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4106 <robertl@arnet.com> (Thanks!).
4108 Gvran Uddeborg <gvran@uddeborg.pp.se> */
4110 if (strcmp (section->name, _LIB) == 0)
4112 bfd_byte *rec, *recend;
4114 rec = (bfd_byte *) location;
4115 recend = rec + count;
4116 while (rec < recend)
4119 rec += bfd_get_32 (abfd, rec) * 4;
4122 BFD_ASSERT (rec == recend);
4127 /* Don't write out bss sections - one way to do this is to
4128 see if the filepos has not been set. */
4129 if (section->filepos == 0)
4132 if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) != 0)
4137 return (bfd_write (location, 1, count, abfd) == count) ? true : false;
4143 coff_close_and_cleanup (abfd)
4146 if (!bfd_read_p (abfd))
4147 switch (abfd->format)
4150 if (!_bfd_write_archive_contents (abfd))
4154 if (!coff_write_object_contents (abfd))
4158 bfd_set_error (bfd_error_invalid_operation);
4162 /* We depend on bfd_close to free all the memory on the objalloc. */
4169 buy_and_read (abfd, where, seek_direction, size)
4175 PTR area = (PTR) bfd_alloc (abfd, size);
4178 if (bfd_seek (abfd, where, seek_direction) != 0
4179 || bfd_read (area, 1, size, abfd) != size)
4182 } /* buy_and_read() */
4188 Creating the linenumber table is done by reading in the entire
4189 coff linenumber table, and creating another table for internal use.
4191 A coff linenumber table is structured so that each function
4192 is marked as having a line number of 0. Each line within the
4193 function is an offset from the first line in the function. The
4194 base of the line number information for the table is stored in
4195 the symbol associated with the function.
4197 Note: The PE format uses line number 0 for a flag indicating a
4200 The information is copied from the external to the internal
4201 table, and each symbol which marks a function is marked by
4204 How does this work ?
4209 coff_slurp_line_table (abfd, asect)
4213 LINENO *native_lineno;
4214 alent *lineno_cache;
4216 BFD_ASSERT (asect->lineno == (alent *) NULL);
4218 native_lineno = (LINENO *) buy_and_read (abfd,
4219 asect->line_filepos,
4221 (size_t) (bfd_coff_linesz (abfd) *
4222 asect->lineno_count));
4224 (alent *) bfd_alloc (abfd, (size_t) ((asect->lineno_count + 1) * sizeof (alent)));
4225 if (lineno_cache == NULL)
4229 unsigned int counter = 0;
4230 alent *cache_ptr = lineno_cache;
4231 LINENO *src = native_lineno;
4233 while (counter < asect->lineno_count)
4235 struct internal_lineno dst;
4236 bfd_coff_swap_lineno_in (abfd, src, &dst);
4237 cache_ptr->line_number = dst.l_lnno;
4239 if (cache_ptr->line_number == 0)
4243 coff_symbol_type *sym;
4246 symndx = dst.l_addr.l_symndx;
4248 || (unsigned long) symndx >= obj_raw_syment_count (abfd))
4250 (*_bfd_error_handler)
4251 (_("%s: warning: illegal symbol index %ld in line numbers"),
4252 bfd_get_filename (abfd), dst.l_addr.l_symndx);
4256 /* FIXME: We should not be casting between ints and
4257 pointers like this. */
4258 sym = ((coff_symbol_type *)
4259 ((symndx + obj_raw_syments (abfd))
4260 ->u.syment._n._n_n._n_zeroes));
4261 cache_ptr->u.sym = (asymbol *) sym;
4262 if (sym->lineno != NULL && ! warned)
4264 (*_bfd_error_handler)
4265 (_("%s: warning: duplicate line number information for `%s'"),
4266 bfd_get_filename (abfd),
4267 bfd_asymbol_name (&sym->symbol));
4269 sym->lineno = cache_ptr;
4273 cache_ptr->u.offset = dst.l_addr.l_paddr
4274 - bfd_section_vma (abfd, asect);
4275 } /* If no linenumber expect a symbol index */
4281 cache_ptr->line_number = 0;
4284 asect->lineno = lineno_cache;
4285 /* FIXME, free native_lineno here, or use alloca or something. */
4289 /* Slurp in the symbol table, converting it to generic form. Note
4290 that if coff_relocate_section is defined, the linker will read
4291 symbols via coff_link_add_symbols, rather than via this routine. */
4294 coff_slurp_symbol_table (abfd)
4297 combined_entry_type *native_symbols;
4298 coff_symbol_type *cached_area;
4299 unsigned int *table_ptr;
4301 unsigned int number_of_symbols = 0;
4303 if (obj_symbols (abfd))
4306 /* Read in the symbol table */
4307 if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL)
4312 /* Allocate enough room for all the symbols in cached form */
4313 cached_area = ((coff_symbol_type *)
4315 (obj_raw_syment_count (abfd)
4316 * sizeof (coff_symbol_type))));
4318 if (cached_area == NULL)
4320 table_ptr = ((unsigned int *)
4322 (obj_raw_syment_count (abfd)
4323 * sizeof (unsigned int))));
4325 if (table_ptr == NULL)
4329 coff_symbol_type *dst = cached_area;
4330 unsigned int last_native_index = obj_raw_syment_count (abfd);
4331 unsigned int this_index = 0;
4332 while (this_index < last_native_index)
4334 combined_entry_type *src = native_symbols + this_index;
4335 table_ptr[this_index] = number_of_symbols;
4336 dst->symbol.the_bfd = abfd;
4338 dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset);
4339 /* We use the native name field to point to the cached field. */
4340 src->u.syment._n._n_n._n_zeroes = (long) dst;
4341 dst->symbol.section = coff_section_from_bfd_index (abfd,
4342 src->u.syment.n_scnum);
4343 dst->symbol.flags = 0;
4344 dst->done_lineno = false;
4346 switch (src->u.syment.n_sclass)
4351 dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
4352 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
4353 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4355 /* Fall through to next case */
4363 case C_THUMBEXTFUNC:
4369 case C_SYSTEM: /* System Wide variable */
4372 /* In PE, 0x68 (104) denotes a section symbol */
4374 /* In PE, 0x69 (105) denotes a weak external symbol. */
4377 switch (coff_classify_symbol (abfd, &src->u.syment))
4379 case COFF_SYMBOL_GLOBAL:
4380 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
4381 #if defined COFF_WITH_PE
4382 /* PE sets the symbol to a value relative to the
4383 start of the section. */
4384 dst->symbol.value = src->u.syment.n_value;
4386 dst->symbol.value = (src->u.syment.n_value
4387 - dst->symbol.section->vma);
4389 if (ISFCN ((src->u.syment.n_type)))
4391 /* A function ext does not go at the end of a
4393 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4397 case COFF_SYMBOL_COMMON:
4398 dst->symbol.section = bfd_com_section_ptr;
4399 dst->symbol.value = src->u.syment.n_value;
4402 case COFF_SYMBOL_UNDEFINED:
4403 dst->symbol.section = bfd_und_section_ptr;
4404 dst->symbol.value = 0;
4407 case COFF_SYMBOL_PE_SECTION:
4408 dst->symbol.flags |= BSF_EXPORT | BSF_SECTION_SYM;
4409 dst->symbol.value = 0;
4412 case COFF_SYMBOL_LOCAL:
4413 dst->symbol.flags = BSF_LOCAL;
4414 #if defined COFF_WITH_PE
4415 /* PE sets the symbol to a value relative to the
4416 start of the section. */
4417 dst->symbol.value = src->u.syment.n_value;
4419 dst->symbol.value = (src->u.syment.n_value
4420 - dst->symbol.section->vma);
4422 if (ISFCN ((src->u.syment.n_type)))
4423 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4428 /* A symbol with a csect entry should not go at the end. */
4429 if (src->u.syment.n_numaux > 0)
4430 dst->symbol.flags |= BSF_NOT_AT_END;
4434 if (src->u.syment.n_sclass == C_NT_WEAK)
4435 dst->symbol.flags = BSF_WEAK;
4436 if (src->u.syment.n_sclass == C_SECTION
4437 && src->u.syment.n_scnum > 0)
4439 dst->symbol.flags = BSF_LOCAL;
4443 if (src->u.syment.n_sclass == C_WEAKEXT)
4444 dst->symbol.flags = BSF_WEAK;
4448 case C_STAT: /* static */
4450 case C_LEAFSTAT: /* static leaf procedure */
4453 case C_THUMBSTAT: /* Thumb static */
4454 case C_THUMBLABEL: /* Thumb label */
4455 case C_THUMBSTATFUNC:/* Thumb static function */
4457 case C_LABEL: /* label */
4458 if (src->u.syment.n_scnum == N_DEBUG)
4459 dst->symbol.flags = BSF_DEBUGGING;
4461 dst->symbol.flags = BSF_LOCAL;
4463 /* Base the value as an index from the base of the
4464 section, if there is one. */
4465 if (dst->symbol.section)
4467 #if defined COFF_WITH_PE
4468 /* PE sets the symbol to a value relative to the
4469 start of the section. */
4470 dst->symbol.value = src->u.syment.n_value;
4472 dst->symbol.value = (src->u.syment.n_value
4473 - dst->symbol.section->vma);
4477 dst->symbol.value = src->u.syment.n_value;
4480 case C_MOS: /* member of structure */
4481 case C_EOS: /* end of structure */
4482 #ifdef NOTDEF /* C_AUTOARG has the same value */
4484 case C_GLBLREG: /* A29k-specific storage class */
4487 case C_REGPARM: /* register parameter */
4488 case C_REG: /* register variable */
4489 /* C_AUTOARG conflictes with TI COFF C_UEXT */
4490 #if !defined (TIC80COFF) && !defined (TICOFF)
4492 case C_AUTOARG: /* 960-specific storage class */
4495 case C_TPDEF: /* type definition */
4497 case C_AUTO: /* automatic variable */
4498 case C_FIELD: /* bit field */
4499 case C_ENTAG: /* enumeration tag */
4500 case C_MOE: /* member of enumeration */
4501 case C_MOU: /* member of union */
4502 case C_UNTAG: /* union tag */
4503 dst->symbol.flags = BSF_DEBUGGING;
4504 dst->symbol.value = (src->u.syment.n_value);
4507 case C_FILE: /* file name */
4508 case C_STRTAG: /* structure tag */
4523 dst->symbol.flags = BSF_DEBUGGING;
4524 dst->symbol.value = (src->u.syment.n_value);
4528 case C_BINCL: /* beginning of include file */
4529 case C_EINCL: /* ending of include file */
4530 /* The value is actually a pointer into the line numbers
4531 of the file. We locate the line number entry, and
4532 set the section to the section which contains it, and
4533 the value to the index in that section. */
4537 dst->symbol.flags = BSF_DEBUGGING;
4538 for (sec = abfd->sections; sec != NULL; sec = sec->next)
4539 if (sec->line_filepos <= (file_ptr) src->u.syment.n_value
4540 && ((file_ptr) (sec->line_filepos
4541 + sec->lineno_count * bfd_coff_linesz (abfd))
4542 > (file_ptr) src->u.syment.n_value))
4545 dst->symbol.value = 0;
4548 dst->symbol.section = sec;
4549 dst->symbol.value = ((src->u.syment.n_value
4550 - sec->line_filepos)
4551 / bfd_coff_linesz (abfd));
4558 dst->symbol.flags = BSF_DEBUGGING;
4560 /* The value is actually a symbol index. Save a pointer
4561 to the symbol instead of the index. FIXME: This
4562 should use a union. */
4563 src->u.syment.n_value =
4564 (long) (native_symbols + src->u.syment.n_value);
4565 dst->symbol.value = src->u.syment.n_value;
4570 case C_BLOCK: /* ".bb" or ".eb" */
4571 case C_FCN: /* ".bf" or ".ef" (or PE ".lf") */
4572 case C_EFCN: /* physical end of function */
4573 #if defined COFF_WITH_PE
4574 /* PE sets the symbol to a value relative to the start
4576 dst->symbol.value = src->u.syment.n_value;
4577 if (strcmp (dst->symbol.name, ".bf") != 0)
4579 /* PE uses funny values for .ef and .lf; don't
4581 dst->symbol.flags = BSF_DEBUGGING;
4584 dst->symbol.flags = BSF_DEBUGGING | BSF_DEBUGGING_RELOC;
4586 /* Base the value as an index from the base of the
4588 dst->symbol.flags = BSF_LOCAL;
4589 dst->symbol.value = (src->u.syment.n_value
4590 - dst->symbol.section->vma);
4594 case C_STATLAB: /* Static load time label */
4595 dst->symbol.value = src->u.syment.n_value;
4596 dst->symbol.flags = BSF_GLOBAL;
4600 /* PE DLLs sometimes have zeroed out symbols for some
4601 reason. Just ignore them without a warning. */
4602 if (src->u.syment.n_type == 0
4603 && src->u.syment.n_value == 0
4604 && src->u.syment.n_scnum == 0)
4607 case C_EXTDEF: /* external definition */
4608 case C_ULABEL: /* undefined label */
4609 case C_USTATIC: /* undefined static */
4610 #ifndef COFF_WITH_PE
4611 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4612 class to represent a section symbol */
4613 case C_LINE: /* line # reformatted as symbol table entry */
4614 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4615 case C_ALIAS: /* duplicate tag */
4617 /* New storage classes for TI COFF */
4618 #if defined(TIC80COFF) || defined(TICOFF)
4619 case C_UEXT: /* Tentative external definition */
4621 case C_EXTLAB: /* External load time label */
4622 case C_HIDDEN: /* ext symbol in dmert public lib */
4624 (*_bfd_error_handler)
4625 (_("%s: Unrecognized storage class %d for %s symbol `%s'"),
4626 bfd_get_filename (abfd), src->u.syment.n_sclass,
4627 dst->symbol.section->name, dst->symbol.name);
4628 dst->symbol.flags = BSF_DEBUGGING;
4629 dst->symbol.value = (src->u.syment.n_value);
4633 /* BFD_ASSERT(dst->symbol.flags != 0);*/
4637 dst->symbol.udata.i = 0;
4638 dst->lineno = (alent *) NULL;
4639 this_index += (src->u.syment.n_numaux) + 1;
4641 number_of_symbols++;
4642 } /* walk the native symtab */
4643 } /* bfdize the native symtab */
4645 obj_symbols (abfd) = cached_area;
4646 obj_raw_syments (abfd) = native_symbols;
4648 bfd_get_symcount (abfd) = number_of_symbols;
4649 obj_convert (abfd) = table_ptr;
4650 /* Slurp the line tables for each section too */
4656 coff_slurp_line_table (abfd, p);
4661 } /* coff_slurp_symbol_table() */
4663 /* Classify a COFF symbol. A couple of targets have globally visible
4664 symbols which are not class C_EXT, and this handles those. It also
4665 recognizes some special PE cases. */
4667 static enum coff_symbol_classification
4668 coff_classify_symbol (abfd, syment)
4670 struct internal_syment *syment;
4672 /* FIXME: This partially duplicates the switch in
4673 coff_slurp_symbol_table. */
4674 switch (syment->n_sclass)
4683 case C_THUMBEXTFUNC:
4691 if (syment->n_scnum == 0)
4693 if (syment->n_value == 0)
4694 return COFF_SYMBOL_UNDEFINED;
4696 return COFF_SYMBOL_COMMON;
4698 return COFF_SYMBOL_GLOBAL;
4705 if (syment->n_sclass == C_STAT)
4707 if (syment->n_scnum == 0)
4709 /* The Microsoft compiler sometimes generates these if a
4710 small static function is inlined every time it is used.
4711 The function is discarded, but the symbol table entry
4713 return COFF_SYMBOL_LOCAL;
4716 #ifdef STRICT_PE_FORMAT
4717 /* This is correct for Microsoft generated objects, but it
4718 breaks gas generated objects. */
4720 if (syment->n_value == 0)
4723 char buf[SYMNMLEN + 1];
4725 sec = coff_section_from_bfd_index (abfd, syment->n_scnum);
4727 && (strcmp (bfd_get_section_name (abfd, sec),
4728 _bfd_coff_internal_syment_name (abfd, syment, buf))
4730 return COFF_SYMBOL_PE_SECTION;
4734 return COFF_SYMBOL_LOCAL;
4737 if (syment->n_sclass == C_SECTION)
4739 /* In some cases in a DLL generated by the Microsoft linker, the
4740 n_value field will contain garbage. FIXME: This should
4741 probably be handled by the swapping function instead. */
4742 syment->n_value = 0;
4743 if (syment->n_scnum == 0)
4744 return COFF_SYMBOL_UNDEFINED;
4745 return COFF_SYMBOL_PE_SECTION;
4747 #endif /* COFF_WITH_PE */
4749 /* If it is not a global symbol, we presume it is a local symbol. */
4751 if (syment->n_scnum == 0)
4753 char buf[SYMNMLEN + 1];
4755 (*_bfd_error_handler)
4756 (_("warning: %s: local symbol `%s' has no section"),
4757 bfd_get_filename (abfd),
4758 _bfd_coff_internal_syment_name (abfd, syment, buf));
4761 return COFF_SYMBOL_LOCAL;
4768 Coff relocations are easily transformed into the internal BFD form
4771 Reading a coff relocation table is done in the following stages:
4773 o Read the entire coff relocation table into memory.
4775 o Process each relocation in turn; first swap it from the
4776 external to the internal form.
4778 o Turn the symbol referenced in the relocation's symbol index
4779 into a pointer into the canonical symbol table.
4780 This table is the same as the one returned by a call to
4781 @code{bfd_canonicalize_symtab}. The back end will call that
4782 routine and save the result if a canonicalization hasn't been done.
4784 o The reloc index is turned into a pointer to a howto
4785 structure, in a back end specific way. For instance, the 386
4786 and 960 use the @code{r_type} to directly produce an index
4787 into a howto table vector; the 88k subtracts a number from the
4788 @code{r_type} field and creates an addend field.
4793 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
4795 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \
4796 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
4797 coffsym = (obj_symbols (abfd) \
4798 + (cache_ptr->sym_ptr_ptr - symbols)); \
4800 coffsym = coff_symbol_from (abfd, ptr); \
4801 if (coffsym != (coff_symbol_type *) NULL \
4802 && coffsym->native->u.syment.n_scnum == 0) \
4803 cache_ptr->addend = 0; \
4804 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
4805 && ptr->section != (asection *) NULL) \
4806 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
4808 cache_ptr->addend = 0; \
4813 coff_slurp_reloc_table (abfd, asect, symbols)
4818 RELOC *native_relocs;
4819 arelent *reloc_cache;
4824 if (asect->relocation)
4826 if (asect->reloc_count == 0)
4828 if (asect->flags & SEC_CONSTRUCTOR)
4830 if (!coff_slurp_symbol_table (abfd))
4833 (RELOC *) buy_and_read (abfd,
4836 (size_t) (bfd_coff_relsz (abfd) *
4837 asect->reloc_count));
4838 reloc_cache = (arelent *)
4839 bfd_alloc (abfd, (size_t) (asect->reloc_count * sizeof (arelent)));
4841 if (reloc_cache == NULL)
4844 for (idx = 0; idx < asect->reloc_count; idx++)
4846 struct internal_reloc dst;
4847 struct external_reloc *src;
4848 #ifndef RELOC_PROCESSING
4852 cache_ptr = reloc_cache + idx;
4853 src = native_relocs + idx;
4855 coff_swap_reloc_in (abfd, src, &dst);
4857 #ifdef RELOC_PROCESSING
4858 RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
4860 cache_ptr->address = dst.r_vaddr;
4862 if (dst.r_symndx != -1)
4864 if (dst.r_symndx < 0 || dst.r_symndx >= obj_conv_table_size (abfd))
4866 (*_bfd_error_handler)
4867 (_("%s: warning: illegal symbol index %ld in relocs"),
4868 bfd_get_filename (abfd), dst.r_symndx);
4869 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
4874 cache_ptr->sym_ptr_ptr = (symbols
4875 + obj_convert (abfd)[dst.r_symndx]);
4876 ptr = *(cache_ptr->sym_ptr_ptr);
4881 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
4885 /* The symbols definitions that we have read in have been
4886 relocated as if their sections started at 0. But the offsets
4887 refering to the symbols in the raw data have not been
4888 modified, so we have to have a negative addend to compensate.
4890 Note that symbols which used to be common must be left alone */
4892 /* Calculate any reloc addend by looking at the symbol */
4893 CALC_ADDEND (abfd, ptr, dst, cache_ptr);
4895 cache_ptr->address -= asect->vma;
4896 /* !! cache_ptr->section = (asection *) NULL;*/
4898 /* Fill in the cache_ptr->howto field from dst.r_type */
4899 RTYPE2HOWTO (cache_ptr, &dst);
4900 #endif /* RELOC_PROCESSING */
4902 if (cache_ptr->howto == NULL)
4904 (*_bfd_error_handler)
4905 (_("%s: illegal relocation type %d at address 0x%lx"),
4906 bfd_get_filename (abfd), dst.r_type, (long) dst.r_vaddr);
4907 bfd_set_error (bfd_error_bad_value);
4912 asect->relocation = reloc_cache;
4916 #ifndef coff_rtype_to_howto
4919 /* Get the howto structure for a reloc. This is only used if the file
4920 including this one defines coff_relocate_section to be
4921 _bfd_coff_generic_relocate_section, so it is OK if it does not
4922 always work. It is the responsibility of the including file to
4923 make sure it is reasonable if it is needed. */
4925 static reloc_howto_type *coff_rtype_to_howto
4926 PARAMS ((bfd *, asection *, struct internal_reloc *,
4927 struct coff_link_hash_entry *, struct internal_syment *,
4931 static reloc_howto_type *
4932 coff_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
4933 bfd *abfd ATTRIBUTE_UNUSED;
4934 asection *sec ATTRIBUTE_UNUSED;
4935 struct internal_reloc *rel;
4936 struct coff_link_hash_entry *h ATTRIBUTE_UNUSED;
4937 struct internal_syment *sym ATTRIBUTE_UNUSED;
4938 bfd_vma *addendp ATTRIBUTE_UNUSED;
4942 RTYPE2HOWTO (&genrel, rel);
4943 return genrel.howto;
4946 #else /* ! defined (RTYPE2HOWTO) */
4948 #define coff_rtype_to_howto NULL
4950 #endif /* ! defined (RTYPE2HOWTO) */
4951 #endif /* ! defined (coff_rtype_to_howto) */
4953 /* This is stupid. This function should be a boolean predicate. */
4955 coff_canonicalize_reloc (abfd, section, relptr, symbols)
4961 arelent *tblptr = section->relocation;
4962 unsigned int count = 0;
4964 if (section->flags & SEC_CONSTRUCTOR)
4966 /* this section has relocs made up by us, they are not in the
4967 file, so take them out of their chain and place them into
4968 the data area provided */
4969 arelent_chain *chain = section->constructor_chain;
4970 for (count = 0; count < section->reloc_count; count++)
4972 *relptr++ = &chain->relent;
4973 chain = chain->next;
4979 if (! coff_slurp_reloc_table (abfd, section, symbols))
4982 tblptr = section->relocation;
4984 for (; count++ < section->reloc_count;)
4985 *relptr++ = tblptr++;
4988 return section->reloc_count;
4993 coff_sym_filepos (abfd)
4996 return obj_sym_filepos (abfd);
5000 #ifndef coff_reloc16_estimate
5001 #define coff_reloc16_estimate dummy_reloc16_estimate
5003 static int dummy_reloc16_estimate
5004 PARAMS ((bfd *, asection *, arelent *, unsigned int,
5005 struct bfd_link_info *));
5008 dummy_reloc16_estimate (abfd, input_section, reloc, shrink, link_info)
5009 bfd *abfd ATTRIBUTE_UNUSED;
5010 asection *input_section ATTRIBUTE_UNUSED;
5011 arelent *reloc ATTRIBUTE_UNUSED;
5012 unsigned int shrink ATTRIBUTE_UNUSED;
5013 struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
5021 #ifndef coff_reloc16_extra_cases
5023 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
5025 /* This works even if abort is not declared in any header file. */
5027 static void dummy_reloc16_extra_cases
5028 PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
5029 bfd_byte *, unsigned int *, unsigned int *));
5032 dummy_reloc16_extra_cases (abfd, link_info, link_order, reloc, data, src_ptr,
5034 bfd *abfd ATTRIBUTE_UNUSED;
5035 struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
5036 struct bfd_link_order *link_order ATTRIBUTE_UNUSED;
5037 arelent *reloc ATTRIBUTE_UNUSED;
5038 bfd_byte *data ATTRIBUTE_UNUSED;
5039 unsigned int *src_ptr ATTRIBUTE_UNUSED;
5040 unsigned int *dst_ptr ATTRIBUTE_UNUSED;
5046 /* If coff_relocate_section is defined, we can use the optimized COFF
5047 backend linker. Otherwise we must continue to use the old linker. */
5048 #ifdef coff_relocate_section
5049 #ifndef coff_bfd_link_hash_table_create
5050 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5052 #ifndef coff_bfd_link_add_symbols
5053 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5055 #ifndef coff_bfd_final_link
5056 #define coff_bfd_final_link _bfd_coff_final_link
5058 #else /* ! defined (coff_relocate_section) */
5059 #define coff_relocate_section NULL
5060 #ifndef coff_bfd_link_hash_table_create
5061 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5063 #ifndef coff_bfd_link_add_symbols
5064 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5066 #define coff_bfd_final_link _bfd_generic_final_link
5067 #endif /* ! defined (coff_relocate_section) */
5069 #define coff_bfd_link_split_section _bfd_generic_link_split_section
5071 #ifndef coff_start_final_link
5072 #define coff_start_final_link NULL
5075 #ifndef coff_adjust_symndx
5076 #define coff_adjust_symndx NULL
5079 #ifndef coff_link_add_one_symbol
5080 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5083 #ifndef coff_link_output_has_begun
5085 static boolean coff_link_output_has_begun
5086 PARAMS ((bfd *, struct coff_final_link_info *));
5089 coff_link_output_has_begun (abfd, info)
5091 struct coff_final_link_info * info ATTRIBUTE_UNUSED;
5093 return abfd->output_has_begun;
5097 #ifndef coff_final_link_postscript
5099 static boolean coff_final_link_postscript
5100 PARAMS ((bfd *, struct coff_final_link_info *));
5103 coff_final_link_postscript (abfd, pfinfo)
5104 bfd * abfd ATTRIBUTE_UNUSED;
5105 struct coff_final_link_info * pfinfo ATTRIBUTE_UNUSED;
5111 #ifndef coff_SWAP_aux_in
5112 #define coff_SWAP_aux_in coff_swap_aux_in
5114 #ifndef coff_SWAP_sym_in
5115 #define coff_SWAP_sym_in coff_swap_sym_in
5117 #ifndef coff_SWAP_lineno_in
5118 #define coff_SWAP_lineno_in coff_swap_lineno_in
5120 #ifndef coff_SWAP_aux_out
5121 #define coff_SWAP_aux_out coff_swap_aux_out
5123 #ifndef coff_SWAP_sym_out
5124 #define coff_SWAP_sym_out coff_swap_sym_out
5126 #ifndef coff_SWAP_lineno_out
5127 #define coff_SWAP_lineno_out coff_swap_lineno_out
5129 #ifndef coff_SWAP_reloc_out
5130 #define coff_SWAP_reloc_out coff_swap_reloc_out
5132 #ifndef coff_SWAP_filehdr_out
5133 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5135 #ifndef coff_SWAP_aouthdr_out
5136 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5138 #ifndef coff_SWAP_scnhdr_out
5139 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5141 #ifndef coff_SWAP_reloc_in
5142 #define coff_SWAP_reloc_in coff_swap_reloc_in
5144 #ifndef coff_SWAP_filehdr_in
5145 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5147 #ifndef coff_SWAP_aouthdr_in
5148 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5150 #ifndef coff_SWAP_scnhdr_in
5151 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5154 static const bfd_coff_backend_data bfd_coff_std_swap_table =
5156 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5157 coff_SWAP_aux_out, coff_SWAP_sym_out,
5158 coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5159 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5160 coff_SWAP_scnhdr_out,
5161 FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
5162 #ifdef COFF_LONG_FILENAMES
5167 #ifdef COFF_LONG_SECTION_NAMES
5172 COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5173 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5178 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5183 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5184 coff_SWAP_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook,
5185 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5186 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5187 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5188 coff_classify_symbol, coff_compute_section_file_positions,
5189 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5190 coff_adjust_symndx, coff_link_add_one_symbol,
5191 coff_link_output_has_begun, coff_final_link_postscript
5194 #ifndef coff_close_and_cleanup
5195 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
5198 #ifndef coff_bfd_free_cached_info
5199 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
5202 #ifndef coff_get_section_contents
5203 #define coff_get_section_contents _bfd_generic_get_section_contents
5206 #ifndef coff_bfd_copy_private_symbol_data
5207 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5210 #ifndef coff_bfd_copy_private_section_data
5211 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5214 #ifndef coff_bfd_copy_private_bfd_data
5215 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5218 #ifndef coff_bfd_merge_private_bfd_data
5219 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5222 #ifndef coff_bfd_set_private_flags
5223 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5226 #ifndef coff_bfd_print_private_bfd_data
5227 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5230 #ifndef coff_bfd_is_local_label_name
5231 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5234 #ifndef coff_read_minisymbols
5235 #define coff_read_minisymbols _bfd_generic_read_minisymbols
5238 #ifndef coff_minisymbol_to_symbol
5239 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5242 /* The reloc lookup routine must be supplied by each individual COFF
5244 #ifndef coff_bfd_reloc_type_lookup
5245 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5248 #ifndef coff_bfd_get_relocated_section_contents
5249 #define coff_bfd_get_relocated_section_contents \
5250 bfd_generic_get_relocated_section_contents
5253 #ifndef coff_bfd_relax_section
5254 #define coff_bfd_relax_section bfd_generic_relax_section
5257 #ifndef coff_bfd_gc_sections
5258 #define coff_bfd_gc_sections bfd_generic_gc_sections
5261 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
5262 const bfd_target VAR = \
5265 bfd_target_coff_flavour, \
5266 BFD_ENDIAN_BIG, /* data byte order is big */ \
5267 BFD_ENDIAN_BIG, /* header byte order is big */ \
5268 /* object flags */ \
5269 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5270 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5271 /* section flags */ \
5272 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5273 UNDER, /* leading symbol underscore */ \
5274 '/', /* ar_pad_char */ \
5275 15, /* ar_max_namelen */ \
5277 /* Data conversion functions. */ \
5278 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5279 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5280 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5282 /* Header conversion functions. */ \
5283 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5284 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5285 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5287 /* bfd_check_format */ \
5288 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5289 _bfd_dummy_target }, \
5290 /* bfd_set_format */ \
5291 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5292 /* bfd_write_contents */ \
5293 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5296 BFD_JUMP_TABLE_GENERIC (coff), \
5297 BFD_JUMP_TABLE_COPY (coff), \
5298 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5299 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5300 BFD_JUMP_TABLE_SYMBOLS (coff), \
5301 BFD_JUMP_TABLE_RELOCS (coff), \
5302 BFD_JUMP_TABLE_WRITE (coff), \
5303 BFD_JUMP_TABLE_LINK (coff), \
5304 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5311 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
5312 const bfd_target VAR = \
5315 bfd_target_coff_flavour, \
5316 BFD_ENDIAN_LITTLE, /* data byte order is little */ \
5317 BFD_ENDIAN_LITTLE, /* header byte order is little */ \
5318 /* object flags */ \
5319 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5320 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5321 /* section flags */ \
5322 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5323 UNDER, /* leading symbol underscore */ \
5324 '/', /* ar_pad_char */ \
5325 15, /* ar_max_namelen */ \
5327 /* Data conversion functions. */ \
5328 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5329 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5330 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5331 /* Header conversion functions. */ \
5332 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5333 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5334 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5335 /* bfd_check_format */ \
5336 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5337 _bfd_dummy_target }, \
5338 /* bfd_set_format */ \
5339 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5340 /* bfd_write_contents */ \
5341 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5344 BFD_JUMP_TABLE_GENERIC (coff), \
5345 BFD_JUMP_TABLE_COPY (coff), \
5346 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5347 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5348 BFD_JUMP_TABLE_SYMBOLS (coff), \
5349 BFD_JUMP_TABLE_RELOCS (coff), \
5350 BFD_JUMP_TABLE_WRITE (coff), \
5351 BFD_JUMP_TABLE_LINK (coff), \
5352 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \