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
251 . {* Remembers the offset from the first symbol in the file for
252 . this symbol. Generated by coff_renumber_symbols. *}
253 . unsigned int offset;
255 . {* Should the value of this symbol be renumbered. Used for
256 . XCOFF C_BSTAT symbols. Set by coff_slurp_symbol_table. *}
257 . unsigned int fix_value : 1;
259 . {* Should the tag field of this symbol be renumbered.
260 . Created by coff_pointerize_aux. *}
261 . unsigned int fix_tag : 1;
263 . {* Should the endidx field of this symbol be renumbered.
264 . Created by coff_pointerize_aux. *}
265 . unsigned int fix_end : 1;
267 . {* Should the x_csect.x_scnlen field be renumbered.
268 . Created by coff_pointerize_aux. *}
269 . unsigned int fix_scnlen : 1;
271 . {* Fix up an XCOFF C_BINCL/C_EINCL symbol. The value is the
272 . index into the line number entries. Set by coff_slurp_symbol_table. *}
273 . unsigned int fix_line : 1;
275 . {* The container for the symbol structure as read and translated
279 . union internal_auxent auxent;
280 . struct internal_syment syment;
282 .} combined_entry_type;
285 .{* Each canonical asymbol really looks like this: *}
287 .typedef struct coff_symbol_struct
289 . {* The actual symbol which the rest of BFD works with *}
292 . {* A pointer to the hidden information for this symbol *}
293 . combined_entry_type *native;
295 . {* A pointer to the linenumber information for this symbol *}
296 . struct lineno_cache_entry *lineno;
298 . {* Have the line numbers been relocated yet ? *}
299 . boolean done_lineno;
307 #include "coffswap.h"
310 #define STRING_SIZE_SIZE (4)
312 static long sec_to_styp_flags PARAMS ((const char *, flagword));
313 static boolean styp_to_sec_flags
314 PARAMS ((bfd *, PTR, const char *, asection *, flagword *));
315 static boolean coff_bad_format_hook PARAMS ((bfd *, PTR));
316 static void coff_set_custom_section_alignment
317 PARAMS ((bfd *, asection *, const struct coff_section_alignment_entry *,
318 const unsigned int));
319 static boolean coff_new_section_hook PARAMS ((bfd *, asection *));
320 static boolean coff_set_arch_mach_hook PARAMS ((bfd *, PTR));
321 static boolean coff_write_relocs PARAMS ((bfd *, int));
322 static boolean coff_set_flags
323 PARAMS ((bfd *, unsigned int *, unsigned short *));
324 static boolean coff_set_arch_mach
325 PARAMS ((bfd *, enum bfd_architecture, unsigned long)) ATTRIBUTE_UNUSED;
326 static boolean coff_compute_section_file_positions PARAMS ((bfd *));
327 static boolean coff_write_object_contents PARAMS ((bfd *)) ATTRIBUTE_UNUSED;
328 static boolean coff_set_section_contents
329 PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type));
330 static PTR buy_and_read PARAMS ((bfd *, file_ptr, bfd_size_type));
331 static boolean coff_slurp_line_table PARAMS ((bfd *, asection *));
332 static boolean coff_slurp_symbol_table PARAMS ((bfd *));
333 static enum coff_symbol_classification coff_classify_symbol
334 PARAMS ((bfd *, struct internal_syment *));
335 static boolean coff_slurp_reloc_table PARAMS ((bfd *, asection *, asymbol **));
336 static long coff_canonicalize_reloc
337 PARAMS ((bfd *, asection *, arelent **, asymbol **));
338 #ifndef coff_mkobject_hook
339 static PTR coff_mkobject_hook PARAMS ((bfd *, PTR, PTR));
342 static flagword handle_COMDAT PARAMS ((bfd *, flagword, PTR, const char *, asection *));
345 /* void warning(); */
347 /* Return a word with STYP_* (scnhdr.s_flags) flags set to represent
348 the incoming SEC_* flags. The inverse of this function is
349 styp_to_sec_flags(). NOTE: If you add to/change this routine, you
350 should probably mirror the changes in styp_to_sec_flags(). */
354 /* Macros for setting debugging flags. */
356 #define STYP_XCOFF_DEBUG STYP_DEBUG
358 #define STYP_XCOFF_DEBUG STYP_INFO
361 #ifdef COFF_ALIGN_IN_S_FLAGS
362 #define STYP_DEBUG_INFO STYP_DSECT
364 #define STYP_DEBUG_INFO STYP_INFO
368 sec_to_styp_flags (sec_name, sec_flags)
369 const char *sec_name;
374 if (!strcmp (sec_name, _TEXT))
376 styp_flags = STYP_TEXT;
378 else if (!strcmp (sec_name, _DATA))
380 styp_flags = STYP_DATA;
382 else if (!strcmp (sec_name, _BSS))
384 styp_flags = STYP_BSS;
387 else if (!strcmp (sec_name, _COMMENT))
389 styp_flags = STYP_INFO;
390 #endif /* _COMMENT */
393 else if (!strcmp (sec_name, _LIB))
395 styp_flags = STYP_LIB;
399 else if (!strcmp (sec_name, _LIT))
401 styp_flags = STYP_LIT;
404 else if (!strncmp (sec_name, ".debug", 6))
406 /* Handle the XCOFF debug section and DWARF2 debug sections. */
408 styp_flags = STYP_XCOFF_DEBUG;
410 styp_flags = STYP_DEBUG_INFO;
412 else if (!strncmp (sec_name, ".stab", 5))
414 styp_flags = STYP_DEBUG_INFO;
416 #ifdef COFF_LONG_SECTION_NAMES
417 else if (!strncmp (sec_name, ".gnu.linkonce.wi.", 17))
419 styp_flags = STYP_DEBUG_INFO;
423 else if (!strcmp (sec_name, _PAD))
425 styp_flags = STYP_PAD;
427 else if (!strcmp (sec_name, _LOADER))
429 styp_flags = STYP_LOADER;
432 /* Try and figure out what it should be */
433 else if (sec_flags & SEC_CODE)
435 styp_flags = STYP_TEXT;
437 else if (sec_flags & SEC_DATA)
439 styp_flags = STYP_DATA;
441 else if (sec_flags & SEC_READONLY)
443 #ifdef STYP_LIT /* 29k readonly text/data section */
444 styp_flags = STYP_LIT;
446 styp_flags = STYP_TEXT;
447 #endif /* STYP_LIT */
449 else if (sec_flags & SEC_LOAD)
451 styp_flags = STYP_TEXT;
453 else if (sec_flags & SEC_ALLOC)
455 styp_flags = STYP_BSS;
459 if (sec_flags & SEC_CLINK)
460 styp_flags |= STYP_CLINK;
464 if (sec_flags & SEC_BLOCK)
465 styp_flags |= STYP_BLOCK;
469 if ((sec_flags & (SEC_NEVER_LOAD | SEC_COFF_SHARED_LIBRARY)) != 0)
470 styp_flags |= STYP_NOLOAD;
476 #else /* COFF_WITH_PE */
478 /* The PE version; see above for the general comments. The non-PE
479 case seems to be more guessing, and breaks PE format; specifically,
480 .rdata is readonly, but it sure ain't text. Really, all this
481 should be set up properly in gas (or whatever assembler is in use),
482 and honor whatever objcopy/strip, etc. sent us as input. */
485 sec_to_styp_flags (sec_name, sec_flags)
486 const char *sec_name ATTRIBUTE_UNUSED;
491 /* caution: there are at least three groups of symbols that have
492 very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
493 SEC_* are the BFD internal flags, used for generic BFD
494 information. STYP_* are the COFF section flags which appear in
495 COFF files. IMAGE_SCN_* are the PE section flags which appear in
496 PE files. The STYP_* flags and the IMAGE_SCN_* flags overlap,
497 but there are more IMAGE_SCN_* flags. */
502 if ((sec_flags & SEC_CODE) != 0)
503 styp_flags |= IMAGE_SCN_CNT_CODE;
504 if ((sec_flags & SEC_DATA) != 0)
505 styp_flags |= IMAGE_SCN_CNT_INITIALIZED_DATA;
506 if ((sec_flags & SEC_ALLOC) != 0 && (sec_flags & SEC_LOAD) == 0)
507 styp_flags |= IMAGE_SCN_CNT_UNINITIALIZED_DATA; /* ==STYP_BSS */
509 /* skip constRUCTOR */
512 if ((sec_flags & (SEC_NEVER_LOAD | SEC_COFF_SHARED_LIBRARY)) != 0)
513 styp_flags |= STYP_NOLOAD;
515 if ((sec_flags & SEC_IS_COMMON) != 0)
516 styp_flags |= IMAGE_SCN_LNK_COMDAT;
517 if ((sec_flags & SEC_DEBUGGING) != 0)
518 styp_flags |= IMAGE_SCN_MEM_DISCARDABLE;
519 if ((sec_flags & SEC_EXCLUDE) != 0)
520 styp_flags |= IMAGE_SCN_LNK_REMOVE;
521 if ((sec_flags & SEC_NEVER_LOAD) != 0)
522 styp_flags |= IMAGE_SCN_LNK_REMOVE;
525 if (sec_flags & SEC_LINK_ONCE)
526 styp_flags |= IMAGE_SCN_LNK_COMDAT;
527 /* skip LINK_DUPLICATES */
528 /* skip LINKER_CREATED */
530 /* For now, the read/write bits are mapped onto SEC_READONLY, even
531 though the semantics don't quite match. The bits from the input
532 are retained in pei_section_data(abfd, section)->pe_flags */
534 styp_flags |= IMAGE_SCN_MEM_READ; /* always readable. */
535 if ((sec_flags & SEC_READONLY) == 0)
536 styp_flags |= IMAGE_SCN_MEM_WRITE; /* Invert READONLY for write */
537 if (sec_flags & SEC_CODE)
538 styp_flags |= IMAGE_SCN_MEM_EXECUTE; /* CODE->EXECUTE */
539 if (sec_flags & SEC_SHARED)
540 styp_flags |= IMAGE_SCN_MEM_SHARED; /* Shared remains meaningful */
545 #endif /* COFF_WITH_PE */
547 /* Return a word with SEC_* flags set to represent the incoming STYP_*
548 flags (from scnhdr.s_flags). The inverse of this function is
549 sec_to_styp_flags(). NOTE: If you add to/change this routine, you
550 should probably mirror the changes in sec_to_styp_flags(). */
555 styp_to_sec_flags (abfd, hdr, name, section, flags_ptr)
556 bfd *abfd ATTRIBUTE_UNUSED;
559 asection *section ATTRIBUTE_UNUSED;
562 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
563 long styp_flags = internal_s->s_flags;
564 flagword sec_flags = 0;
567 if (styp_flags & STYP_BLOCK)
568 sec_flags |= SEC_BLOCK;
572 if (styp_flags & STYP_CLINK)
573 sec_flags |= SEC_CLINK;
577 if (styp_flags & STYP_NOLOAD)
578 sec_flags |= SEC_NEVER_LOAD;
579 #endif /* STYP_NOLOAD */
581 /* For 386 COFF, at least, an unloadable text or data section is
582 actually a shared library section. */
583 if (styp_flags & STYP_TEXT)
585 if (sec_flags & SEC_NEVER_LOAD)
586 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
588 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
590 else if (styp_flags & STYP_DATA)
592 if (sec_flags & SEC_NEVER_LOAD)
593 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
595 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
597 else if (styp_flags & STYP_BSS)
599 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
600 if (sec_flags & SEC_NEVER_LOAD)
601 sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
604 sec_flags |= SEC_ALLOC;
606 else if (styp_flags & STYP_INFO)
608 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
609 defined. coff_compute_section_file_positions uses
610 COFF_PAGE_SIZE to ensure that the low order bits of the
611 section VMA and the file offset match. If we don't know
612 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
613 and demand page loading of the file will fail. */
614 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
615 sec_flags |= SEC_DEBUGGING;
618 else if (styp_flags & STYP_PAD)
620 else if (strcmp (name, _TEXT) == 0)
622 if (sec_flags & SEC_NEVER_LOAD)
623 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
625 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
627 else if (strcmp (name, _DATA) == 0)
629 if (sec_flags & SEC_NEVER_LOAD)
630 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
632 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
634 else if (strcmp (name, _BSS) == 0)
636 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
637 if (sec_flags & SEC_NEVER_LOAD)
638 sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
641 sec_flags |= SEC_ALLOC;
643 else if (strncmp (name, ".debug", 6) == 0
645 || strcmp (name, _COMMENT) == 0
647 #ifdef COFF_LONG_SECTION_NAMES
648 || strncmp (name, ".gnu.linkonce.wi.", 17) == 0
650 || strncmp (name, ".stab", 5) == 0)
652 #ifdef COFF_PAGE_SIZE
653 sec_flags |= SEC_DEBUGGING;
657 else if (strcmp (name, _LIB) == 0)
661 else if (strcmp (name, _LIT) == 0)
662 sec_flags = SEC_LOAD | SEC_ALLOC | SEC_READONLY;
665 sec_flags |= SEC_ALLOC | SEC_LOAD;
667 #ifdef STYP_LIT /* A29k readonly text/data section type */
668 if ((styp_flags & STYP_LIT) == STYP_LIT)
669 sec_flags = (SEC_LOAD | SEC_ALLOC | SEC_READONLY);
670 #endif /* STYP_LIT */
672 #ifdef STYP_OTHER_LOAD /* Other loaded sections */
673 if (styp_flags & STYP_OTHER_LOAD)
674 sec_flags = (SEC_LOAD | SEC_ALLOC);
675 #endif /* STYP_SDATA */
677 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
678 /* As a GNU extension, if the name begins with .gnu.linkonce, we
679 only link a single copy of the section. This is used to support
680 g++. g++ will emit each template expansion in its own section.
681 The symbols will be defined as weak, so that multiple definitions
682 are permitted. The GNU linker extension is to actually discard
683 all but one of the sections. */
684 if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
685 sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
688 if (flags_ptr == NULL)
691 * flags_ptr = sec_flags;
695 #else /* COFF_WITH_PE */
698 handle_COMDAT (abfd, sec_flags, hdr, name, section)
705 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
706 bfd_byte *esymstart, *esym, *esymend;
708 char *target_name = NULL;
710 sec_flags |= SEC_LINK_ONCE;
712 /* Unfortunately, the PE format stores essential information in
713 the symbol table, of all places. We need to extract that
714 information now, so that objdump and the linker will know how
715 to handle the section without worrying about the symbols. We
716 can't call slurp_symtab, because the linker doesn't want the
719 /* COMDAT sections are special. The first symbol is the section
720 symbol, which tells what kind of COMDAT section it is. The
721 second symbol is the "comdat symbol" - the one with the
722 unique name. GNU uses the section symbol for the unique
723 name; MS uses ".text" for every comdat section. Sigh. - DJ */
725 /* This is not mirrored in sec_to_styp_flags(), but there
726 doesn't seem to be a need to, either, and it would at best be
729 if (! _bfd_coff_get_external_symbols (abfd))
732 esymstart = esym = (bfd_byte *) obj_coff_external_syms (abfd);
733 esymend = esym + obj_raw_syment_count (abfd) * bfd_coff_symesz (abfd);
735 while (esym < esymend)
737 struct internal_syment isym;
738 char buf[SYMNMLEN + 1];
741 bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &isym);
743 if (sizeof (internal_s->s_name) > SYMNMLEN)
745 /* This case implies that the matching
746 symbol name will be in the string table. */
750 if (isym.n_scnum == section->target_index)
752 /* According to the MSVC documentation, the first
753 TWO entries with the section # are both of
754 interest to us. The first one is the "section
755 symbol" (section name). The second is the comdat
756 symbol name. Here, we've found the first
757 qualifying entry; we distinguish it from the
758 second with a state flag.
760 In the case of gas-generated (at least until that
761 is fixed) .o files, it isn't necessarily the
762 second one. It may be some other later symbol.
764 Since gas also doesn't follow MS conventions and
765 emits the section similar to .text$<name>, where
766 <something> is the name we're looking for, we
767 distinguish the two as follows:
769 If the section name is simply a section name (no
770 $) we presume it's MS-generated, and look at
771 precisely the second symbol for the comdat name.
772 If the section name has a $, we assume it's
773 gas-generated, and look for <something> (whatever
774 follows the $) as the comdat symbol. */
776 /* All 3 branches use this */
777 symname = _bfd_coff_internal_syment_name (abfd, &isym, buf);
786 /* The first time we've seen the symbol. */
787 union internal_auxent aux;
791 /* If it isn't the stuff we're expecting, die;
792 The MS documentation is vague, but it
793 appears that the second entry serves BOTH
794 as the comdat symbol and the defining
795 symbol record (either C_STAT or C_EXT,
796 possibly with an aux entry with debug
797 information if it's a function.) It
798 appears the only way to find the second one
799 is to count. (On Intel, they appear to be
800 adjacent, but on Alpha, they have been
803 Here, we think we've found the first one,
804 but there's some checking we can do to be
807 if (! (isym.n_sclass == C_STAT
808 && isym.n_type == T_NULL
809 && isym.n_value == 0))
812 /* FIXME LATER: MSVC generates section names
813 like .text for comdats. Gas generates
814 names like .text$foo__Fv (in the case of a
815 function). See comment above for more. */
817 if (strcmp (name, symname) != 0)
820 /* This is the section symbol. */
821 bfd_coff_swap_aux_in (abfd, (PTR) (esym + bfd_coff_symesz (abfd)),
822 isym.n_type, isym.n_sclass,
823 0, isym.n_numaux, (PTR) &aux);
825 target_name = strchr (name, '$');
826 if (target_name != NULL)
834 /* FIXME: Microsoft uses NODUPLICATES and
835 ASSOCIATIVE, but gnu uses ANY and
836 SAME_SIZE. Unfortunately, gnu doesn't do
837 the comdat symbols right. So, until we can
838 fix it to do the right thing, we are
839 temporarily disabling comdats for the MS
840 types (they're used in DLLs and C++, but we
841 don't support *their* C++ libraries anyway
844 /* Cygwin does not follow the MS style, and
845 uses ANY and SAME_SIZE where NODUPLICATES
846 and ASSOCIATIVE should be used. For
847 Interix, we just do the right thing up
850 switch (aux.x_scn.x_comdat)
852 case IMAGE_COMDAT_SELECT_NODUPLICATES:
853 #ifdef STRICT_PE_FORMAT
854 sec_flags |= SEC_LINK_DUPLICATES_ONE_ONLY;
856 sec_flags &= ~SEC_LINK_ONCE;
860 case IMAGE_COMDAT_SELECT_ANY:
861 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
864 case IMAGE_COMDAT_SELECT_SAME_SIZE:
865 sec_flags |= SEC_LINK_DUPLICATES_SAME_SIZE;
868 case IMAGE_COMDAT_SELECT_EXACT_MATCH:
869 /* Not yet fully implemented ??? */
870 sec_flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS;
873 /* debug$S gets this case; other
876 /* There may be no symbol... we'll search
877 the whole table... Is this the right
878 place to play this game? Or should we do
879 it when reading it in. */
880 case IMAGE_COMDAT_SELECT_ASSOCIATIVE:
881 #ifdef STRICT_PE_FORMAT
882 /* FIXME: This is not currently implemented. */
883 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
885 sec_flags &= ~SEC_LINK_ONCE;
889 default: /* 0 means "no symbol" */
890 /* debug$F gets this case; other
892 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
899 /* Gas mode: the first matching on partial name. */
901 #ifndef TARGET_UNDERSCORE
902 #define TARGET_UNDERSCORE 0
904 /* Is this the name we're looking for? */
905 if (strcmp (target_name,
906 symname + (TARGET_UNDERSCORE ? 1 : 0)) != 0)
908 /* Not the name we're looking for */
909 esym += (isym.n_numaux + 1) * bfd_coff_symesz (abfd);
914 /* MSVC mode: the lexically second symbol (or
915 drop through from the above). */
920 /* This must the the second symbol with the
921 section #. It is the actual symbol name.
922 Intel puts the two adjacent, but Alpha (at
923 least) spreads them out. */
925 amt = sizeof (struct bfd_comdat_info);
926 section->comdat = bfd_alloc (abfd, amt);
927 if (section->comdat == NULL)
930 section->comdat->symbol =
931 (esym - esymstart) / bfd_coff_symesz (abfd);
933 amt = strlen (symname) + 1;
934 newname = bfd_alloc (abfd, amt);
938 strcpy (newname, symname);
939 section->comdat->name = newname;
946 esym += (isym.n_numaux + 1) * bfd_coff_symesz (abfd);
954 /* The PE version; see above for the general comments.
956 Since to set the SEC_LINK_ONCE and associated flags, we have to
957 look at the symbol table anyway, we return the symbol table index
958 of the symbol being used as the COMDAT symbol. This is admittedly
959 ugly, but there's really nowhere else that we have access to the
960 required information. FIXME: Is the COMDAT symbol index used for
961 any purpose other than objdump? */
964 styp_to_sec_flags (abfd, hdr, name, section, flags_ptr)
971 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
972 long styp_flags = internal_s->s_flags;
974 boolean result = true;
976 /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
977 sec_flags = SEC_READONLY;
979 /* Process each flag bit in styp_flags in turn. */
982 long flag = styp_flags & - styp_flags;
983 char * unhandled = NULL;
985 styp_flags &= ~ flag;
987 /* We infer from the distinct read/write/execute bits the settings
988 of some of the bfd flags; the actual values, should we need them,
989 are also in pei_section_data (abfd, section)->pe_flags. */
994 unhandled = "STYP_DSECT";
997 unhandled = "STYP_GROUP";
1000 unhandled = "STYP_COPY";
1003 unhandled = "STYP_OVER";
1005 #ifdef SEC_NEVER_LOAD
1007 sec_flags |= SEC_NEVER_LOAD;
1010 case IMAGE_SCN_MEM_READ:
1011 /* Ignored, assume it always to be true. */
1013 case IMAGE_SCN_TYPE_NO_PAD:
1016 case IMAGE_SCN_LNK_OTHER:
1017 unhandled = "IMAGE_SCN_LNK_OTHER";
1019 case IMAGE_SCN_MEM_NOT_CACHED:
1020 unhandled = "IMAGE_SCN_MEM_NOT_CACHED";
1022 case IMAGE_SCN_MEM_NOT_PAGED:
1023 unhandled = "IMAGE_SCN_MEM_NOT_PAGED";
1025 case IMAGE_SCN_MEM_EXECUTE:
1026 sec_flags |= SEC_CODE;
1028 case IMAGE_SCN_MEM_WRITE:
1029 sec_flags &= ~ SEC_READONLY;
1031 case IMAGE_SCN_MEM_DISCARDABLE:
1032 sec_flags |= SEC_DEBUGGING;
1034 case IMAGE_SCN_MEM_SHARED:
1035 sec_flags |= SEC_SHARED;
1037 case IMAGE_SCN_LNK_REMOVE:
1038 sec_flags |= SEC_EXCLUDE;
1040 case IMAGE_SCN_CNT_CODE:
1041 sec_flags |= SEC_CODE | SEC_ALLOC | SEC_LOAD;
1043 case IMAGE_SCN_CNT_INITIALIZED_DATA:
1044 sec_flags |= SEC_DATA | SEC_ALLOC | SEC_LOAD;
1046 case IMAGE_SCN_CNT_UNINITIALIZED_DATA:
1047 sec_flags |= SEC_ALLOC;
1049 case IMAGE_SCN_LNK_INFO:
1050 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
1051 defined. coff_compute_section_file_positions uses
1052 COFF_PAGE_SIZE to ensure that the low order bits of the
1053 section VMA and the file offset match. If we don't know
1054 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
1055 and demand page loading of the file will fail. */
1056 #ifdef COFF_PAGE_SIZE
1057 sec_flags |= SEC_DEBUGGING;
1060 case IMAGE_SCN_LNK_COMDAT:
1061 /* COMDAT gets very special treatment. */
1062 sec_flags = handle_COMDAT (abfd, sec_flags, hdr, name, section);
1065 /* Silently ignore for now. */
1069 /* If the section flag was not handled, report it here. */
1070 if (unhandled != NULL)
1072 (*_bfd_error_handler)
1073 (_("%s (%s): Section flag %s (0x%x) ignored"),
1074 bfd_get_filename (abfd), name, unhandled, flag);
1079 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1080 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1081 only link a single copy of the section. This is used to support
1082 g++. g++ will emit each template expansion in its own section.
1083 The symbols will be defined as weak, so that multiple definitions
1084 are permitted. The GNU linker extension is to actually discard
1085 all but one of the sections. */
1086 if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
1087 sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
1091 * flags_ptr = sec_flags;
1096 #endif /* COFF_WITH_PE */
1098 #define get_index(symbol) ((symbol)->udata.i)
1102 bfd_coff_backend_data
1106 .{* COFF symbol classifications. *}
1108 .enum coff_symbol_classification
1110 . {* Global symbol. *}
1111 . COFF_SYMBOL_GLOBAL,
1112 . {* Common symbol. *}
1113 . COFF_SYMBOL_COMMON,
1114 . {* Undefined symbol. *}
1115 . COFF_SYMBOL_UNDEFINED,
1116 . {* Local symbol. *}
1117 . COFF_SYMBOL_LOCAL,
1118 . {* PE section symbol. *}
1119 . COFF_SYMBOL_PE_SECTION
1122 Special entry points for gdb to swap in coff symbol table parts:
1125 . void (*_bfd_coff_swap_aux_in)
1126 . PARAMS ((bfd *, PTR, int, int, int, int, PTR));
1128 . void (*_bfd_coff_swap_sym_in)
1129 . PARAMS ((bfd *, PTR, PTR));
1131 . void (*_bfd_coff_swap_lineno_in)
1132 . PARAMS ((bfd *, PTR, PTR));
1134 . unsigned int (*_bfd_coff_swap_aux_out)
1135 . PARAMS ((bfd *, PTR, int, int, int, int, PTR));
1137 . unsigned int (*_bfd_coff_swap_sym_out)
1138 . PARAMS ((bfd *, PTR, PTR));
1140 . unsigned int (*_bfd_coff_swap_lineno_out)
1141 . PARAMS ((bfd *, PTR, PTR));
1143 . unsigned int (*_bfd_coff_swap_reloc_out)
1144 . PARAMS ((bfd *, PTR, PTR));
1146 . unsigned int (*_bfd_coff_swap_filehdr_out)
1147 . PARAMS ((bfd *, PTR, PTR));
1149 . unsigned int (*_bfd_coff_swap_aouthdr_out)
1150 . PARAMS ((bfd *, PTR, PTR));
1152 . unsigned int (*_bfd_coff_swap_scnhdr_out)
1153 . PARAMS ((bfd *, PTR, PTR));
1155 . unsigned int _bfd_filhsz;
1156 . unsigned int _bfd_aoutsz;
1157 . unsigned int _bfd_scnhsz;
1158 . unsigned int _bfd_symesz;
1159 . unsigned int _bfd_auxesz;
1160 . unsigned int _bfd_relsz;
1161 . unsigned int _bfd_linesz;
1162 . unsigned int _bfd_filnmlen;
1163 . boolean _bfd_coff_long_filenames;
1164 . boolean _bfd_coff_long_section_names;
1165 . unsigned int _bfd_coff_default_section_alignment_power;
1166 . boolean _bfd_coff_force_symnames_in_strings;
1167 . unsigned int _bfd_coff_debug_string_prefix_length;
1169 . void (*_bfd_coff_swap_filehdr_in)
1170 . PARAMS ((bfd *, PTR, PTR));
1172 . void (*_bfd_coff_swap_aouthdr_in)
1173 . PARAMS ((bfd *, PTR, PTR));
1175 . void (*_bfd_coff_swap_scnhdr_in)
1176 . PARAMS ((bfd *, PTR, PTR));
1178 . void (*_bfd_coff_swap_reloc_in)
1179 . PARAMS ((bfd *abfd, PTR, PTR));
1181 . boolean (*_bfd_coff_bad_format_hook)
1182 . PARAMS ((bfd *, PTR));
1184 . boolean (*_bfd_coff_set_arch_mach_hook)
1185 . PARAMS ((bfd *, PTR));
1187 . PTR (*_bfd_coff_mkobject_hook)
1188 . PARAMS ((bfd *, PTR, PTR));
1190 . boolean (*_bfd_styp_to_sec_flags_hook)
1191 . PARAMS ((bfd *, PTR, const char *, asection *, flagword *));
1193 . void (*_bfd_set_alignment_hook)
1194 . PARAMS ((bfd *, asection *, PTR));
1196 . boolean (*_bfd_coff_slurp_symbol_table)
1199 . boolean (*_bfd_coff_symname_in_debug)
1200 . PARAMS ((bfd *, struct internal_syment *));
1202 . boolean (*_bfd_coff_pointerize_aux_hook)
1203 . PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
1204 . unsigned int, combined_entry_type *));
1206 . boolean (*_bfd_coff_print_aux)
1207 . PARAMS ((bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1208 . combined_entry_type *, unsigned int));
1210 . void (*_bfd_coff_reloc16_extra_cases)
1211 . PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
1212 . bfd_byte *, unsigned int *, unsigned int *));
1214 . int (*_bfd_coff_reloc16_estimate)
1215 . PARAMS ((bfd *, asection *, arelent *, unsigned int,
1216 . struct bfd_link_info *));
1218 . enum coff_symbol_classification (*_bfd_coff_classify_symbol)
1219 . PARAMS ((bfd *, struct internal_syment *));
1221 . boolean (*_bfd_coff_compute_section_file_positions)
1224 . boolean (*_bfd_coff_start_final_link)
1225 . PARAMS ((bfd *, struct bfd_link_info *));
1227 . boolean (*_bfd_coff_relocate_section)
1228 . PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
1229 . struct internal_reloc *, struct internal_syment *, asection **));
1231 . reloc_howto_type *(*_bfd_coff_rtype_to_howto)
1232 . PARAMS ((bfd *, asection *, struct internal_reloc *,
1233 . struct coff_link_hash_entry *, struct internal_syment *,
1236 . boolean (*_bfd_coff_adjust_symndx)\
1237 . PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *,
1238 . struct internal_reloc *, boolean *));
1240 . boolean (*_bfd_coff_link_add_one_symbol)
1241 . PARAMS ((struct bfd_link_info *, bfd *, const char *, flagword,
1242 . asection *, bfd_vma, const char *, boolean, boolean,
1243 . struct bfd_link_hash_entry **));
1245 . boolean (*_bfd_coff_link_output_has_begun)
1246 . PARAMS ((bfd *, struct coff_final_link_info *));
1248 . boolean (*_bfd_coff_final_link_postscript)
1249 . PARAMS ((bfd *, struct coff_final_link_info *));
1251 .} bfd_coff_backend_data;
1253 .#define coff_backend_info(abfd) \
1254 . ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1256 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1257 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1259 .#define bfd_coff_swap_sym_in(a,e,i) \
1260 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1262 .#define bfd_coff_swap_lineno_in(a,e,i) \
1263 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1265 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1266 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1268 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1269 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1271 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1272 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1274 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1275 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1277 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1278 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1280 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1281 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1283 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1284 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1286 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1287 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1288 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1289 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1290 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1291 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1292 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1293 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1294 .#define bfd_coff_long_filenames(abfd) \
1295 . (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1296 .#define bfd_coff_long_section_names(abfd) \
1297 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1298 .#define bfd_coff_default_section_alignment_power(abfd) \
1299 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1300 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1301 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1303 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1304 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1306 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1307 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1309 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1310 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1312 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1313 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1315 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1316 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1317 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1318 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook) (abfd, filehdr, aouthdr))
1320 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\
1321 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1322 . (abfd, scnhdr, name, section, flags_ptr))
1324 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1325 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1327 .#define bfd_coff_slurp_symbol_table(abfd)\
1328 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1330 .#define bfd_coff_symname_in_debug(abfd, sym)\
1331 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1333 .#define bfd_coff_force_symnames_in_strings(abfd)\
1334 . (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
1336 .#define bfd_coff_debug_string_prefix_length(abfd)\
1337 . (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
1339 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1340 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1341 . (abfd, file, base, symbol, aux, indaux))
1343 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)\
1344 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1345 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1347 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1348 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1349 . (abfd, section, reloc, shrink, link_info))
1351 .#define bfd_coff_classify_symbol(abfd, sym)\
1352 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1355 .#define bfd_coff_compute_section_file_positions(abfd)\
1356 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1359 .#define bfd_coff_start_final_link(obfd, info)\
1360 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1362 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1363 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1364 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1365 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1366 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1367 . (abfd, sec, rel, h, sym, addendp))
1368 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1369 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1370 . (obfd, info, ibfd, sec, rel, adjustedp))
1371 .#define bfd_coff_link_add_one_symbol(info,abfd,name,flags,section,value,string,cp,coll,hashp)\
1372 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1373 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1375 .#define bfd_coff_link_output_has_begun(a,p) \
1376 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a,p))
1377 .#define bfd_coff_final_link_postscript(a,p) \
1378 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a,p))
1382 /* See whether the magic number matches. */
1385 coff_bad_format_hook (abfd, filehdr)
1386 bfd * abfd ATTRIBUTE_UNUSED;
1389 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1391 if (BADMAG (*internal_f))
1394 /* if the optional header is NULL or not the correct size then
1395 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1396 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1397 optional header is of a different size.
1399 But the mips keeps extra stuff in it's opthdr, so dont check
1403 #if defined(M88) || defined(I960)
1404 if (internal_f->f_opthdr != 0 && bfd_coff_aoutsz (abfd) != internal_f->f_opthdr)
1411 /* Check whether this section uses an alignment other than the
1415 coff_set_custom_section_alignment (abfd, section, alignment_table, table_size)
1416 bfd *abfd ATTRIBUTE_UNUSED;
1418 const struct coff_section_alignment_entry *alignment_table;
1419 const unsigned int table_size;
1421 const unsigned int default_alignment = COFF_DEFAULT_SECTION_ALIGNMENT_POWER;
1424 for (i = 0; i < table_size; ++i)
1426 const char *secname = bfd_get_section_name (abfd, section);
1427 if (alignment_table[i].comparison_length == (unsigned int) -1
1428 ? strcmp (alignment_table[i].name, secname) == 0
1429 : strncmp (alignment_table[i].name, secname,
1430 alignment_table[i].comparison_length) == 0)
1433 if (i >= table_size)
1436 if (alignment_table[i].default_alignment_min != COFF_ALIGNMENT_FIELD_EMPTY
1437 && default_alignment < alignment_table[i].default_alignment_min)
1440 if (alignment_table[i].default_alignment_max != COFF_ALIGNMENT_FIELD_EMPTY
1441 && default_alignment > alignment_table[i].default_alignment_max)
1444 section->alignment_power = alignment_table[i].alignment_power;
1447 /* Custom section alignment records. */
1449 static const struct coff_section_alignment_entry
1450 coff_section_alignment_table[] =
1452 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1453 COFF_SECTION_ALIGNMENT_ENTRIES,
1455 /* There must not be any gaps between .stabstr sections. */
1456 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1457 1, COFF_ALIGNMENT_FIELD_EMPTY, 0 },
1458 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1459 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1460 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 },
1461 /* Similarly for the .ctors and .dtors sections. */
1462 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1463 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 },
1464 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1465 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 }
1468 static const unsigned int coff_section_alignment_table_size =
1469 sizeof coff_section_alignment_table / sizeof coff_section_alignment_table[0];
1471 /* Initialize a section structure with information peculiar to this
1472 particular implementation of COFF. */
1475 coff_new_section_hook (abfd, section)
1479 combined_entry_type *native;
1482 section->alignment_power = COFF_DEFAULT_SECTION_ALIGNMENT_POWER;
1485 if (xcoff_data (abfd)->text_align_power != 0
1486 && strcmp (bfd_get_section_name (abfd, section), ".text") == 0)
1487 section->alignment_power = xcoff_data (abfd)->text_align_power;
1488 if (xcoff_data (abfd)->data_align_power != 0
1489 && strcmp (bfd_get_section_name (abfd, section), ".data") == 0)
1490 section->alignment_power = xcoff_data (abfd)->data_align_power;
1493 /* Allocate aux records for section symbols, to store size and
1496 @@ The 10 is a guess at a plausible maximum number of aux entries
1497 (but shouldn't be a constant). */
1498 amt = sizeof (combined_entry_type) * 10;
1499 native = (combined_entry_type *) bfd_zalloc (abfd, amt);
1503 /* We don't need to set up n_name, n_value, or n_scnum in the native
1504 symbol information, since they'll be overriden by the BFD symbol
1505 anyhow. However, we do need to set the type and storage class,
1506 in case this symbol winds up getting written out. The value 0
1507 for n_numaux is already correct. */
1509 native->u.syment.n_type = T_NULL;
1510 native->u.syment.n_sclass = C_STAT;
1512 coffsymbol (section->symbol)->native = native;
1514 coff_set_custom_section_alignment (abfd, section,
1515 coff_section_alignment_table,
1516 coff_section_alignment_table_size);
1521 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1523 /* Set the alignment of a BFD section. */
1525 static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1528 coff_set_alignment_hook (abfd, section, scnhdr)
1529 bfd * abfd ATTRIBUTE_UNUSED;
1533 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1537 /* Extract ALIGN from 2**ALIGN stored in section header */
1538 for (i = 0; i < 32; i++)
1539 if ((1 << i) >= hdr->s_align)
1543 /* TI tools puts the alignment power in bits 8-11 */
1544 i = (hdr->s_flags >> 8) & 0xF ;
1546 #ifdef COFF_DECODE_ALIGNMENT
1547 i = COFF_DECODE_ALIGNMENT(hdr->s_flags);
1549 section->alignment_power = i;
1551 #ifdef coff_set_section_load_page
1552 coff_set_section_load_page (section, hdr->s_page);
1556 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1559 /* a couple of macros to help setting the alignment power field */
1560 #define ALIGN_SET(field,x,y) \
1561 if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x )\
1563 section->alignment_power = y;\
1566 #define ELIFALIGN_SET(field,x,y) \
1567 else if (( (field) & IMAGE_SCN_ALIGN_64BYTES) == x ) \
1569 section->alignment_power = y;\
1572 static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1575 coff_set_alignment_hook (abfd, section, scnhdr)
1576 bfd * abfd ATTRIBUTE_UNUSED;
1580 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1583 ALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_64BYTES, 6)
1584 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_32BYTES, 5)
1585 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_16BYTES, 4)
1586 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_8BYTES, 3)
1587 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_4BYTES, 2)
1588 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_2BYTES, 1)
1589 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_1BYTES, 0)
1591 /* In a PE image file, the s_paddr field holds the virtual size of a
1592 section, while the s_size field holds the raw size. We also keep
1593 the original section flag value, since not every bit can be
1594 mapped onto a generic BFD section bit. */
1595 if (coff_section_data (abfd, section) == NULL)
1597 amt = sizeof (struct coff_section_tdata);
1598 section->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
1599 if (section->used_by_bfd == NULL)
1601 /* FIXME: Return error. */
1605 if (pei_section_data (abfd, section) == NULL)
1607 amt = sizeof (struct pei_section_tdata);
1608 coff_section_data (abfd, section)->tdata = (PTR) bfd_zalloc (abfd, amt);
1609 if (coff_section_data (abfd, section)->tdata == NULL)
1611 /* FIXME: Return error. */
1615 pei_section_data (abfd, section)->virt_size = hdr->s_paddr;
1616 pei_section_data (abfd, section)->pe_flags = hdr->s_flags;
1618 section->lma = hdr->s_vaddr;
1620 /* check for extended relocs */
1621 if (hdr->s_flags & IMAGE_SCN_LNK_NRELOC_OVFL)
1623 struct external_reloc dst;
1624 struct internal_reloc n;
1625 file_ptr oldpos = bfd_tell (abfd);
1626 bfd_seek (abfd, (file_ptr) hdr->s_relptr, 0);
1627 if (bfd_bread ((PTR) &dst, (bfd_size_type) bfd_coff_relsz (abfd), abfd)
1628 != bfd_coff_relsz (abfd))
1631 coff_swap_reloc_in (abfd, &dst, &n);
1632 bfd_seek (abfd, oldpos, 0);
1633 section->reloc_count = hdr->s_nreloc = n.r_vaddr;
1637 #undef ELIFALIGN_SET
1639 #else /* ! COFF_WITH_PE */
1642 /* We grossly abuse this function to handle XCOFF overflow headers.
1643 When we see one, we correct the reloc and line number counts in the
1644 real header, and remove the section we just created. */
1646 static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1649 coff_set_alignment_hook (abfd, section, scnhdr)
1654 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1658 if ((hdr->s_flags & STYP_OVRFLO) == 0)
1661 real_sec = coff_section_from_bfd_index (abfd, (int) hdr->s_nreloc);
1662 if (real_sec == NULL)
1665 real_sec->reloc_count = hdr->s_paddr;
1666 real_sec->lineno_count = hdr->s_vaddr;
1668 for (ps = &abfd->sections; *ps != NULL; ps = &(*ps)->next)
1673 --abfd->section_count;
1679 #else /* ! RS6000COFF_C */
1681 #define coff_set_alignment_hook \
1682 ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
1684 #endif /* ! RS6000COFF_C */
1685 #endif /* ! COFF_WITH_PE */
1686 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1688 #ifndef coff_mkobject
1690 static boolean coff_mkobject PARAMS ((bfd *));
1693 coff_mkobject (abfd)
1696 coff_data_type *coff;
1697 bfd_size_type amt = sizeof (coff_data_type);
1699 abfd->tdata.coff_obj_data = (struct coff_tdata *) bfd_zalloc (abfd, amt);
1700 if (abfd->tdata.coff_obj_data == 0)
1702 coff = coff_data (abfd);
1703 coff->symbols = (coff_symbol_type *) NULL;
1704 coff->conversion_table = (unsigned int *) NULL;
1705 coff->raw_syments = (struct coff_ptr_struct *) NULL;
1706 coff->relocbase = 0;
1707 coff->local_toc_sym_map = 0;
1709 /* make_abs_section(abfd);*/
1715 /* Create the COFF backend specific information. */
1716 #ifndef coff_mkobject_hook
1718 coff_mkobject_hook (abfd, filehdr, aouthdr)
1721 PTR aouthdr ATTRIBUTE_UNUSED;
1723 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1724 coff_data_type *coff;
1726 if (coff_mkobject (abfd) == false)
1729 coff = coff_data (abfd);
1731 coff->sym_filepos = internal_f->f_symptr;
1733 /* These members communicate important constants about the symbol
1734 table to GDB's symbol-reading code. These `constants'
1735 unfortunately vary among coff implementations... */
1736 coff->local_n_btmask = N_BTMASK;
1737 coff->local_n_btshft = N_BTSHFT;
1738 coff->local_n_tmask = N_TMASK;
1739 coff->local_n_tshift = N_TSHIFT;
1740 coff->local_symesz = bfd_coff_symesz (abfd);
1741 coff->local_auxesz = bfd_coff_auxesz (abfd);
1742 coff->local_linesz = bfd_coff_linesz (abfd);
1744 coff->timestamp = internal_f->f_timdat;
1746 obj_raw_syment_count (abfd) =
1747 obj_conv_table_size (abfd) =
1748 internal_f->f_nsyms;
1751 if ((internal_f->f_flags & F_SHROBJ) != 0)
1752 abfd->flags |= DYNAMIC;
1753 if (aouthdr != NULL && internal_f->f_opthdr >= bfd_coff_aoutsz (abfd))
1755 struct internal_aouthdr *internal_a =
1756 (struct internal_aouthdr *) aouthdr;
1757 struct xcoff_tdata *xcoff;
1759 xcoff = xcoff_data (abfd);
1760 # ifdef U803XTOCMAGIC
1761 xcoff->xcoff64 = internal_f->f_magic == U803XTOCMAGIC;
1765 xcoff->full_aouthdr = true;
1766 xcoff->toc = internal_a->o_toc;
1767 xcoff->sntoc = internal_a->o_sntoc;
1768 xcoff->snentry = internal_a->o_snentry;
1769 xcoff->text_align_power = internal_a->o_algntext;
1770 xcoff->data_align_power = internal_a->o_algndata;
1771 xcoff->modtype = internal_a->o_modtype;
1772 xcoff->cputype = internal_a->o_cputype;
1773 xcoff->maxdata = internal_a->o_maxdata;
1774 xcoff->maxstack = internal_a->o_maxstack;
1779 /* Set the flags field from the COFF header read in */
1780 if (! _bfd_coff_arm_set_private_flags (abfd, internal_f->f_flags))
1785 /* FIXME: I'm not sure this is ever executed, since peicode.h
1786 defines coff_mkobject_hook. */
1787 if ((internal_f->f_flags & IMAGE_FILE_DEBUG_STRIPPED) == 0)
1788 abfd->flags |= HAS_DEBUG;
1795 /* Determine the machine architecture and type. FIXME: This is target
1796 dependent because the magic numbers are defined in the target
1797 dependent header files. But there is no particular need for this.
1798 If the magic numbers were moved to a separate file, this function
1799 would be target independent and would also be much more successful
1800 at linking together COFF files for different architectures. */
1803 coff_set_arch_mach_hook (abfd, filehdr)
1807 unsigned long machine;
1808 enum bfd_architecture arch;
1809 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1812 switch (internal_f->f_magic)
1816 arch = bfd_arch_powerpc;
1817 machine = 0; /* what does this mean? (krk) */
1823 case I386AIXMAGIC: /* Danbury PS/2 AIX C Compiler */
1824 case LYNXCOFFMAGIC: /* shadows the m68k Lynx number below, sigh */
1825 arch = bfd_arch_i386;
1831 arch = bfd_arch_ia64;
1835 #ifdef A29K_MAGIC_BIG
1836 case A29K_MAGIC_BIG:
1837 case A29K_MAGIC_LITTLE:
1838 arch = bfd_arch_a29k;
1846 arch = bfd_arch_arm;
1847 switch (internal_f->f_flags & F_ARM_ARCHITECTURE_MASK)
1849 case F_ARM_2: machine = bfd_mach_arm_2; break;
1850 case F_ARM_2a: machine = bfd_mach_arm_2a; break;
1851 case F_ARM_3: machine = bfd_mach_arm_3; break;
1853 case F_ARM_3M: machine = bfd_mach_arm_3M; break;
1854 case F_ARM_4: machine = bfd_mach_arm_4; break;
1855 case F_ARM_4T: machine = bfd_mach_arm_4T; break;
1856 case F_ARM_5: machine = bfd_mach_arm_5; break;
1863 #ifdef MC68KBCSMAGIC
1866 #ifdef APOLLOM68KMAGIC
1867 case APOLLOM68KMAGIC:
1869 #ifdef LYNXCOFFMAGIC
1872 arch = bfd_arch_m68k;
1873 machine = bfd_mach_m68020;
1880 arch = bfd_arch_m88k;
1886 arch = bfd_arch_z8k;
1887 switch (internal_f->f_flags & F_MACHMASK)
1890 machine = bfd_mach_z8001;
1893 machine = bfd_mach_z8002;
1902 arch = bfd_arch_i860;
1909 arch = bfd_arch_i960;
1910 switch (F_I960TYPE & internal_f->f_flags)
1914 machine = bfd_mach_i960_core;
1917 machine = bfd_mach_i960_kb_sb;
1920 machine = bfd_mach_i960_mc;
1923 machine = bfd_mach_i960_xa;
1926 machine = bfd_mach_i960_ca;
1929 machine = bfd_mach_i960_ka_sa;
1932 machine = bfd_mach_i960_jx;
1935 machine = bfd_mach_i960_hx;
1953 if (xcoff_data (abfd)->cputype != -1)
1954 cputype = xcoff_data (abfd)->cputype & 0xff;
1957 /* We did not get a value from the a.out header. If the
1958 file has not been stripped, we may be able to get the
1959 architecture information from the first symbol, if it
1960 is a .file symbol. */
1961 if (obj_raw_syment_count (abfd) == 0)
1966 struct internal_syment sym;
1967 bfd_size_type amt = bfd_coff_symesz (abfd);
1969 buf = (bfd_byte *) bfd_malloc (amt);
1970 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
1971 || bfd_bread (buf, amt, abfd) != amt)
1976 bfd_coff_swap_sym_in (abfd, (PTR) buf, (PTR) &sym);
1977 if (sym.n_sclass == C_FILE)
1978 cputype = sym.n_type & 0xff;
1985 /* FIXME: We don't handle all cases here. */
1990 arch = bfd_xcoff_architecture (abfd);
1991 machine = bfd_xcoff_machine (abfd);
1995 arch = bfd_arch_powerpc;
1996 machine = bfd_mach_ppc_601;
1998 case 2: /* 64 bit PowerPC */
1999 arch = bfd_arch_powerpc;
2000 machine = bfd_mach_ppc_620;
2003 arch = bfd_arch_powerpc;
2004 machine = bfd_mach_ppc;
2007 arch = bfd_arch_rs6000;
2008 machine = bfd_mach_rs6k;
2017 arch = bfd_arch_we32k;
2024 arch = bfd_arch_h8300;
2025 machine = bfd_mach_h8300;
2026 /* !! FIXME this probably isn't the right place for this */
2027 abfd->flags |= BFD_IS_RELAXABLE;
2033 arch = bfd_arch_h8300;
2034 machine = bfd_mach_h8300h;
2035 /* !! FIXME this probably isn't the right place for this */
2036 abfd->flags |= BFD_IS_RELAXABLE;
2042 arch = bfd_arch_h8300;
2043 machine = bfd_mach_h8300s;
2044 /* !! FIXME this probably isn't the right place for this */
2045 abfd->flags |= BFD_IS_RELAXABLE;
2049 #ifdef SH_ARCH_MAGIC_BIG
2050 case SH_ARCH_MAGIC_BIG:
2051 case SH_ARCH_MAGIC_LITTLE:
2053 case SH_ARCH_MAGIC_WINCE:
2060 #ifdef MIPS_ARCH_MAGIC_WINCE
2061 case MIPS_ARCH_MAGIC_WINCE:
2062 arch = bfd_arch_mips;
2069 arch = bfd_arch_h8500;
2076 #ifdef LYNXCOFFMAGIC
2079 arch = bfd_arch_sparc;
2086 arch = bfd_arch_tic30;
2091 #ifdef TICOFF_TARGET_ARCH
2092 /* this TI COFF section should be used by all new TI COFF v0 targets */
2094 arch = TICOFF_TARGET_ARCH;
2100 /* this TI COFF section should be used by all new TI COFF v1/2 targets */
2101 /* TI COFF1 and COFF2 use the target_id field to specify which arch */
2104 switch (internal_f->f_target_id)
2108 arch = TICOFF_TARGET_ARCH;
2112 arch = bfd_arch_obscure;
2113 (*_bfd_error_handler)
2114 (_("Unrecognized TI COFF target id '0x%x'"),
2115 internal_f->f_target_id);
2121 #ifdef TIC80_ARCH_MAGIC
2122 case TIC80_ARCH_MAGIC:
2123 arch = bfd_arch_tic80;
2129 arch = bfd_arch_mcore;
2132 default: /* Unreadable input file type */
2133 arch = bfd_arch_obscure;
2137 bfd_default_set_arch_mach (abfd, arch, machine);
2141 #ifdef SYMNAME_IN_DEBUG
2143 static boolean symname_in_debug_hook
2144 PARAMS ((bfd *, struct internal_syment *));
2147 symname_in_debug_hook (abfd, sym)
2148 bfd * abfd ATTRIBUTE_UNUSED;
2149 struct internal_syment *sym;
2151 return SYMNAME_IN_DEBUG (sym) ? true : false;
2156 #define symname_in_debug_hook \
2157 (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
2164 #define FORCE_SYMNAMES_IN_STRINGS
2167 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */
2169 static boolean coff_pointerize_aux_hook
2170 PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
2171 unsigned int, combined_entry_type *));
2175 coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux)
2176 bfd *abfd ATTRIBUTE_UNUSED;
2177 combined_entry_type *table_base;
2178 combined_entry_type *symbol;
2179 unsigned int indaux;
2180 combined_entry_type *aux;
2182 int class = symbol->u.syment.n_sclass;
2184 if ((class == C_EXT || class == C_HIDEXT)
2185 && indaux + 1 == symbol->u.syment.n_numaux)
2187 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD)
2189 aux->u.auxent.x_csect.x_scnlen.p =
2190 table_base + aux->u.auxent.x_csect.x_scnlen.l;
2191 aux->fix_scnlen = 1;
2194 /* Return true to indicate that the caller should not do any
2195 further work on this auxent. */
2199 /* Return false to indicate that this auxent should be handled by
2207 /* We don't want to pointerize bal entries. */
2209 static boolean coff_pointerize_aux_hook
2210 PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
2211 unsigned int, combined_entry_type *));
2215 coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux)
2216 bfd *abfd ATTRIBUTE_UNUSED;
2217 combined_entry_type *table_base ATTRIBUTE_UNUSED;
2218 combined_entry_type *symbol;
2219 unsigned int indaux;
2220 combined_entry_type *aux ATTRIBUTE_UNUSED;
2222 /* Return true if we don't want to pointerize this aux entry, which
2223 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
2225 && (symbol->u.syment.n_sclass == C_LEAFPROC
2226 || symbol->u.syment.n_sclass == C_LEAFSTAT
2227 || symbol->u.syment.n_sclass == C_LEAFEXT));
2232 #define coff_pointerize_aux_hook 0
2235 #endif /* ! RS6000COFF_C */
2237 /* Print an aux entry. This returns true if it has printed it. */
2239 static boolean coff_print_aux
2240 PARAMS ((bfd *, FILE *, combined_entry_type *, combined_entry_type *,
2241 combined_entry_type *, unsigned int));
2244 coff_print_aux (abfd, file, table_base, symbol, aux, indaux)
2245 bfd *abfd ATTRIBUTE_UNUSED;
2246 FILE *file ATTRIBUTE_UNUSED;
2247 combined_entry_type *table_base ATTRIBUTE_UNUSED;
2248 combined_entry_type *symbol ATTRIBUTE_UNUSED;
2249 combined_entry_type *aux ATTRIBUTE_UNUSED;
2250 unsigned int indaux ATTRIBUTE_UNUSED;
2253 if ((symbol->u.syment.n_sclass == C_EXT
2254 || symbol->u.syment.n_sclass == C_HIDEXT)
2255 && indaux + 1 == symbol->u.syment.n_numaux)
2257 /* This is a csect entry. */
2258 fprintf (file, "AUX ");
2259 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) != XTY_LD)
2261 BFD_ASSERT (! aux->fix_scnlen);
2263 fprintf (file, "val %5lld", aux->u.auxent.x_csect.x_scnlen.l);
2265 fprintf (file, "val %5ld", (long) aux->u.auxent.x_csect.x_scnlen.l);
2270 fprintf (file, "indx ");
2271 if (! aux->fix_scnlen)
2273 fprintf (file, "%4lld", aux->u.auxent.x_csect.x_scnlen.l);
2275 fprintf (file, "%4ld", (long) aux->u.auxent.x_csect.x_scnlen.l);
2278 fprintf (file, "%4ld",
2279 (long) (aux->u.auxent.x_csect.x_scnlen.p - table_base));
2282 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2283 aux->u.auxent.x_csect.x_parmhash,
2284 (unsigned int) aux->u.auxent.x_csect.x_snhash,
2285 SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp),
2286 SMTYP_ALIGN (aux->u.auxent.x_csect.x_smtyp),
2287 (unsigned int) aux->u.auxent.x_csect.x_smclas,
2288 aux->u.auxent.x_csect.x_stab,
2289 (unsigned int) aux->u.auxent.x_csect.x_snstab);
2294 /* Return false to indicate that no special action was taken. */
2302 To write relocations, the back end steps though the
2303 canonical relocation table and create an
2304 @code{internal_reloc}. The symbol index to use is removed from
2305 the @code{offset} field in the symbol table supplied. The
2306 address comes directly from the sum of the section base
2307 address and the relocation offset; the type is dug directly
2308 from the howto field. Then the @code{internal_reloc} is
2309 swapped into the shape of an @code{external_reloc} and written
2316 static int compare_arelent_ptr PARAMS ((const PTR, const PTR));
2318 /* AUX's ld wants relocations to be sorted */
2320 compare_arelent_ptr (x, y)
2324 const arelent **a = (const arelent **) x;
2325 const arelent **b = (const arelent **) y;
2326 bfd_size_type aadr = (*a)->address;
2327 bfd_size_type badr = (*b)->address;
2329 return (aadr < badr ? -1 : badr < aadr ? 1 : 0);
2332 #endif /* TARG_AUX */
2335 coff_write_relocs (abfd, first_undef)
2341 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
2344 struct external_reloc dst;
2351 /* sort relocations before we write them out */
2354 amt = s->reloc_count;
2355 amt *= sizeof (arelent *);
2356 p = (arelent **) bfd_malloc (amt);
2357 if (p == NULL && s->reloc_count > 0)
2359 memcpy (p, s->orelocation, (size_t) amt);
2360 qsort (p, s->reloc_count, sizeof (arelent *), compare_arelent_ptr);
2364 if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0)
2368 if (s->reloc_count > 0xffff)
2370 /* encode real count here as first reloc */
2371 struct internal_reloc n;
2372 memset ((PTR) & n, 0, sizeof (n));
2373 /* add one to count *this* reloc (grr) */
2374 n.r_vaddr = s->reloc_count + 1;
2375 coff_swap_reloc_out (abfd, &n, &dst);
2376 if (bfd_bwrite ((PTR) & dst, (bfd_size_type) bfd_coff_relsz (abfd),
2377 abfd) != bfd_coff_relsz (abfd))
2382 for (i = 0; i < s->reloc_count; i++)
2384 struct internal_reloc n;
2386 memset ((PTR) & n, 0, sizeof (n));
2388 /* Now we've renumbered the symbols we know where the
2389 undefined symbols live in the table. Check the reloc
2390 entries for symbols who's output bfd isn't the right one.
2391 This is because the symbol was undefined (which means
2392 that all the pointers are never made to point to the same
2393 place). This is a bad thing,'cause the symbols attached
2394 to the output bfd are indexed, so that the relocation
2395 entries know which symbol index they point to. So we
2396 have to look up the output symbol here. */
2398 if (q->sym_ptr_ptr[0]->the_bfd != abfd)
2401 const char *sname = q->sym_ptr_ptr[0]->name;
2402 asymbol **outsyms = abfd->outsymbols;
2403 for (j = first_undef; outsyms[j]; j++)
2405 const char *intable = outsyms[j]->name;
2406 if (strcmp (intable, sname) == 0) {
2407 /* got a hit, so repoint the reloc */
2408 q->sym_ptr_ptr = outsyms + j;
2414 n.r_vaddr = q->address + s->vma;
2417 /* The 29k const/consth reloc pair is a real kludge. The consth
2418 part doesn't have a symbol; it has an offset. So rebuilt
2420 if (q->howto->type == R_IHCONST)
2421 n.r_symndx = q->addend;
2426 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2427 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q,s))
2429 if (q->sym_ptr_ptr == bfd_abs_section_ptr->symbol_ptr_ptr)
2431 /* This is a relocation relative to the absolute symbol. */
2435 n.r_symndx = get_index ((*(q->sym_ptr_ptr)));
2436 /* Take notice if the symbol reloc points to a symbol
2437 we don't have in our symbol table. What should we
2439 if (n.r_symndx > obj_conv_table_size (abfd))
2444 #ifdef SWAP_OUT_RELOC_OFFSET
2445 n.r_offset = q->addend;
2449 /* Work out reloc type from what is required */
2450 SELECT_RELOC (n, q->howto);
2452 n.r_type = q->howto->type;
2454 coff_swap_reloc_out (abfd, &n, &dst);
2455 if (bfd_bwrite ((PTR) & dst, (bfd_size_type) bfd_coff_relsz (abfd),
2456 abfd) != bfd_coff_relsz (abfd))
2469 /* Set flags and magic number of a coff file from architecture and machine
2470 type. Result is true if we can represent the arch&type, false if not. */
2473 coff_set_flags (abfd, magicp, flagsp)
2475 unsigned int *magicp ATTRIBUTE_UNUSED;
2476 unsigned short *flagsp ATTRIBUTE_UNUSED;
2478 switch (bfd_get_arch (abfd))
2483 switch (bfd_get_mach (abfd))
2485 case bfd_mach_z8001:
2488 case bfd_mach_z8002:
2502 *magicp = I960ROMAGIC;
2504 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
2505 I960RWMAGIC); FIXME???
2507 switch (bfd_get_mach (abfd))
2509 case bfd_mach_i960_core:
2512 case bfd_mach_i960_kb_sb:
2515 case bfd_mach_i960_mc:
2518 case bfd_mach_i960_xa:
2521 case bfd_mach_i960_ca:
2524 case bfd_mach_i960_ka_sa:
2527 case bfd_mach_i960_jx:
2530 case bfd_mach_i960_hx:
2543 case bfd_arch_tic30:
2544 *magicp = TIC30MAGIC;
2548 #ifdef TICOFF_DEFAULT_MAGIC
2549 case TICOFF_TARGET_ARCH:
2550 /* if there's no indication of which version we want, use the default */
2552 *magicp = TICOFF_DEFAULT_MAGIC;
2555 /* we may want to output in a different COFF version */
2556 switch (abfd->xvec->name[4])
2559 *magicp = TICOFF0MAGIC;
2562 *magicp = TICOFF1MAGIC;
2565 *magicp = TICOFF2MAGIC;
2574 #ifdef TIC80_ARCH_MAGIC
2575 case bfd_arch_tic80:
2576 *magicp = TIC80_ARCH_MAGIC;
2582 * magicp = ARMPEMAGIC;
2584 * magicp = ARMMAGIC;
2587 if (APCS_SET (abfd))
2589 if (APCS_26_FLAG (abfd))
2590 * flagsp |= F_APCS26;
2592 if (APCS_FLOAT_FLAG (abfd))
2593 * flagsp |= F_APCS_FLOAT;
2595 if (PIC_FLAG (abfd))
2598 if (INTERWORK_SET (abfd) && INTERWORK_FLAG (abfd))
2599 * flagsp |= F_INTERWORK;
2600 switch (bfd_get_mach (abfd))
2602 case bfd_mach_arm_2: * flagsp |= F_ARM_2; break;
2603 case bfd_mach_arm_2a: * flagsp |= F_ARM_2a; break;
2604 case bfd_mach_arm_3: * flagsp |= F_ARM_3; break;
2605 case bfd_mach_arm_3M: * flagsp |= F_ARM_3M; break;
2606 case bfd_mach_arm_4: * flagsp |= F_ARM_4; break;
2607 case bfd_mach_arm_4T: * flagsp |= F_ARM_4T; break;
2608 case bfd_mach_arm_5: * flagsp |= F_ARM_5; break;
2609 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5. */
2610 case bfd_mach_arm_5T: * flagsp |= F_ARM_5; break;
2611 case bfd_mach_arm_5TE: * flagsp |= F_ARM_5; break;
2612 case bfd_mach_arm_XScale: * flagsp |= F_ARM_5; break;
2617 case bfd_arch_powerpc:
2624 *magicp = I386MAGIC;
2626 /* Just overwrite the usual value if we're doing Lynx. */
2627 *magicp = LYNXCOFFMAGIC;
2634 *magicp = I860MAGIC;
2640 *magicp = IA64MAGIC;
2646 #ifdef APOLLOM68KMAGIC
2647 *magicp = APOLLO_COFF_VERSION_NUMBER;
2649 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2650 #ifdef NAMES_HAVE_UNDERSCORE
2651 *magicp = MC68KBCSMAGIC;
2653 *magicp = MC68MAGIC;
2657 /* Just overwrite the usual value if we're doing Lynx. */
2658 *magicp = LYNXCOFFMAGIC;
2666 *magicp = MC88OMAGIC;
2671 case bfd_arch_h8300:
2672 switch (bfd_get_mach (abfd))
2674 case bfd_mach_h8300:
2675 *magicp = H8300MAGIC;
2677 case bfd_mach_h8300h:
2678 *magicp = H8300HMAGIC;
2680 case bfd_mach_h8300s:
2681 *magicp = H8300SMAGIC;
2687 #ifdef SH_ARCH_MAGIC_BIG
2689 #ifdef COFF_IMAGE_WITH_PE
2690 *magicp = SH_ARCH_MAGIC_WINCE;
2692 if (bfd_big_endian (abfd))
2693 *magicp = SH_ARCH_MAGIC_BIG;
2695 *magicp = SH_ARCH_MAGIC_LITTLE;
2701 #ifdef MIPS_ARCH_MAGIC_WINCE
2703 *magicp = MIPS_ARCH_MAGIC_WINCE;
2709 case bfd_arch_sparc:
2710 *magicp = SPARCMAGIC;
2712 /* Just overwrite the usual value if we're doing Lynx. */
2713 *magicp = LYNXCOFFMAGIC;
2720 case bfd_arch_h8500:
2721 *magicp = H8500MAGIC;
2725 #ifdef A29K_MAGIC_BIG
2727 if (bfd_big_endian (abfd))
2728 *magicp = A29K_MAGIC_BIG;
2730 *magicp = A29K_MAGIC_LITTLE;
2736 case bfd_arch_we32k:
2737 *magicp = WE32KMAGIC;
2743 case bfd_arch_rs6000:
2745 case bfd_arch_powerpc:
2748 if (bfd_get_mach (abfd) == bfd_mach_ppc_620
2749 && !strncmp (abfd->xvec->name,"aix", 3))
2750 *magicp = U803XTOCMAGIC;
2753 *magicp = U802TOCMAGIC;
2760 case bfd_arch_mcore:
2761 * magicp = MCOREMAGIC;
2771 default: /* Unknown architecture. */
2772 /* Fall through to "return false" below, to avoid
2773 "statement never reached" errors on the one below. */
2781 coff_set_arch_mach (abfd, arch, machine)
2783 enum bfd_architecture arch;
2784 unsigned long machine;
2787 unsigned short dummy2;
2789 if (! bfd_default_set_arch_mach (abfd, arch, machine))
2792 if (arch != bfd_arch_unknown &&
2793 coff_set_flags (abfd, &dummy1, &dummy2) != true)
2794 return false; /* We can't represent this type */
2796 return true; /* We're easy ... */
2799 #ifdef COFF_IMAGE_WITH_PE
2801 /* This is used to sort sections by VMA, as required by PE image
2804 static int sort_by_secaddr PARAMS ((const PTR, const PTR));
2807 sort_by_secaddr (arg1, arg2)
2811 const asection *a = *(const asection **) arg1;
2812 const asection *b = *(const asection **) arg2;
2814 if (a->vma < b->vma)
2816 else if (a->vma > b->vma)
2822 #endif /* COFF_IMAGE_WITH_PE */
2824 /* Calculate the file position for each section. */
2827 #define ALIGN_SECTIONS_IN_FILE
2829 #if defined(TIC80COFF) || defined(TICOFF)
2830 #undef ALIGN_SECTIONS_IN_FILE
2834 coff_compute_section_file_positions (abfd)
2838 asection *previous = (asection *) NULL;
2839 file_ptr sofar = bfd_coff_filhsz (abfd);
2840 boolean align_adjust;
2841 #ifdef ALIGN_SECTIONS_IN_FILE
2846 /* On XCOFF, if we have symbols, set up the .debug section. */
2847 if (bfd_get_symcount (abfd) > 0)
2850 bfd_size_type i, symcount;
2854 symcount = bfd_get_symcount (abfd);
2855 for (symp = abfd->outsymbols, i = 0; i < symcount; symp++, i++)
2857 coff_symbol_type *cf;
2859 cf = coff_symbol_from (abfd, *symp);
2861 && cf->native != NULL
2862 && SYMNAME_IN_DEBUG (&cf->native->u.syment))
2866 len = strlen (bfd_asymbol_name (*symp));
2867 if (len > SYMNMLEN || bfd_coff_force_symnames_in_strings (abfd))
2868 sz += len + 1 + bfd_coff_debug_string_prefix_length (abfd);
2875 dsec = bfd_make_section_old_way (abfd, ".debug");
2878 dsec->_raw_size = sz;
2879 dsec->flags |= SEC_HAS_CONTENTS;
2884 #ifdef COFF_IMAGE_WITH_PE
2886 if (coff_data (abfd)->link_info)
2888 page_size = pe_data (abfd)->pe_opthdr.FileAlignment;
2891 page_size = PE_DEF_FILE_ALIGNMENT;
2893 #ifdef COFF_PAGE_SIZE
2894 int page_size = COFF_PAGE_SIZE;
2898 if (bfd_get_start_address (abfd))
2900 /* A start address may have been added to the original file. In this
2901 case it will need an optional header to record it. */
2902 abfd->flags |= EXEC_P;
2905 if (abfd->flags & EXEC_P)
2906 sofar += bfd_coff_aoutsz (abfd);
2908 else if (xcoff_data (abfd)->full_aouthdr)
2909 sofar += bfd_coff_aoutsz (abfd);
2911 sofar += SMALL_AOUTSZ;
2914 sofar += abfd->section_count * bfd_coff_scnhsz (abfd);
2917 /* XCOFF handles overflows in the reloc and line number count fields
2918 by allocating a new section header to hold the correct counts. */
2919 for (current = abfd->sections; current != NULL; current = current->next)
2920 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
2921 sofar += bfd_coff_scnhsz (abfd);
2924 #ifdef COFF_IMAGE_WITH_PE
2926 /* PE requires the sections to be in memory order when listed in
2927 the section headers. It also does not like empty loadable
2928 sections. The sections apparently do not have to be in the
2929 right order in the image file itself, but we do need to get the
2930 target_index values right. */
2933 asection **section_list;
2939 for (current = abfd->sections; current != NULL; current = current->next)
2942 /* We allocate an extra cell to simplify the final loop. */
2943 amt = sizeof (struct asection *) * (count + 1);
2944 section_list = bfd_malloc (amt);
2945 if (section_list == NULL)
2949 for (current = abfd->sections; current != NULL; current = current->next)
2951 section_list[i] = current;
2954 section_list[i] = NULL;
2956 qsort (section_list, count, sizeof (asection *), sort_by_secaddr);
2958 /* Rethread the linked list into sorted order; at the same time,
2959 assign target_index values. */
2961 abfd->sections = section_list[0];
2962 for (i = 0; i < count; i++)
2964 current = section_list[i];
2965 current->next = section_list[i + 1];
2967 /* Later, if the section has zero size, we'll be throwing it
2968 away, so we don't want to number it now. Note that having
2969 a zero size and having real contents are different
2970 concepts: .bss has no contents, but (usually) non-zero
2972 if (current->_raw_size == 0)
2974 /* Discard. However, it still might have (valid) symbols
2975 in it, so arbitrarily set it to section 1 (indexing is
2976 1-based here; usually .text). __end__ and other
2977 contents of .endsection really have this happen.
2978 FIXME: This seems somewhat dubious. */
2979 current->target_index = 1;
2982 current->target_index = target_index++;
2985 free (section_list);
2987 #else /* ! COFF_IMAGE_WITH_PE */
2989 /* Set the target_index field. */
2993 for (current = abfd->sections; current != NULL; current = current->next)
2994 current->target_index = target_index++;
2996 #endif /* ! COFF_IMAGE_WITH_PE */
2998 align_adjust = false;
2999 for (current = abfd->sections;
3000 current != (asection *) NULL;
3001 current = current->next)
3003 #ifdef COFF_IMAGE_WITH_PE
3004 /* With PE we have to pad each section to be a multiple of its
3005 page size too, and remember both sizes. */
3006 if (coff_section_data (abfd, current) == NULL)
3008 bfd_size_type amt = sizeof (struct coff_section_tdata);
3009 current->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
3010 if (current->used_by_bfd == NULL)
3013 if (pei_section_data (abfd, current) == NULL)
3015 bfd_size_type amt = sizeof (struct pei_section_tdata);
3016 coff_section_data (abfd, current)->tdata
3017 = (PTR) bfd_zalloc (abfd, amt);
3018 if (coff_section_data (abfd, current)->tdata == NULL)
3021 if (pei_section_data (abfd, current)->virt_size == 0)
3022 pei_section_data (abfd, current)->virt_size = current->_raw_size;
3025 /* Only deal with sections which have contents. */
3026 if (!(current->flags & SEC_HAS_CONTENTS))
3029 #ifdef COFF_IMAGE_WITH_PE
3030 /* Make sure we skip empty sections in a PE image. */
3031 if (current->_raw_size == 0)
3035 /* Align the sections in the file to the same boundary on
3036 which they are aligned in virtual memory. I960 doesn't
3037 do this (FIXME) so we can stay in sync with Intel. 960
3038 doesn't yet page from files... */
3039 #ifdef ALIGN_SECTIONS_IN_FILE
3040 if ((abfd->flags & EXEC_P) != 0)
3042 /* make sure this section is aligned on the right boundary - by
3043 padding the previous section up if necessary */
3046 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3047 if (previous != (asection *) NULL)
3049 previous->_raw_size += sofar - old_sofar;
3055 /* In demand paged files the low order bits of the file offset
3056 must match the low order bits of the virtual address. */
3057 #ifdef COFF_PAGE_SIZE
3058 if ((abfd->flags & D_PAGED) != 0
3059 && (current->flags & SEC_ALLOC) != 0)
3060 sofar += (current->vma - sofar) % page_size;
3062 current->filepos = sofar;
3064 #ifdef COFF_IMAGE_WITH_PE
3065 /* Set the padded size. */
3066 current->_raw_size = (current->_raw_size + page_size -1) & -page_size;
3069 sofar += current->_raw_size;
3071 #ifdef ALIGN_SECTIONS_IN_FILE
3072 /* make sure that this section is of the right size too */
3073 if ((abfd->flags & EXEC_P) == 0)
3075 bfd_size_type old_size;
3077 old_size = current->_raw_size;
3078 current->_raw_size = BFD_ALIGN (current->_raw_size,
3079 1 << current->alignment_power);
3080 align_adjust = current->_raw_size != old_size;
3081 sofar += current->_raw_size - old_size;
3086 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3087 align_adjust = sofar != old_sofar;
3088 current->_raw_size += sofar - old_sofar;
3092 #ifdef COFF_IMAGE_WITH_PE
3093 /* For PE we need to make sure we pad out to the aligned
3094 _raw_size, in case the caller only writes out data to the
3095 unaligned _raw_size. */
3096 if (pei_section_data (abfd, current)->virt_size < current->_raw_size)
3097 align_adjust = true;
3101 /* Force .lib sections to start at zero. The vma is then
3102 incremented in coff_set_section_contents. This is right for
3104 if (strcmp (current->name, _LIB) == 0)
3105 bfd_set_section_vma (abfd, current, 0);
3111 /* It is now safe to write to the output file. If we needed an
3112 alignment adjustment for the last section, then make sure that
3113 there is a byte at offset sofar. If there are no symbols and no
3114 relocs, then nothing follows the last section. If we don't force
3115 the last byte out, then the file may appear to be truncated. */
3121 if (bfd_seek (abfd, sofar - 1, SEEK_SET) != 0
3122 || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
3126 /* Make sure the relocations are aligned. We don't need to make
3127 sure that this byte exists, because it will only matter if there
3128 really are relocs. */
3129 sofar = BFD_ALIGN (sofar, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER);
3131 obj_relocbase (abfd) = sofar;
3132 abfd->output_has_begun = true;
3139 /* This can never work, because it is called too late--after the
3140 section positions have been set. I can't figure out what it is
3141 for, so I am going to disable it--Ian Taylor 20 March 1996. */
3143 /* If .file, .text, .data, .bss symbols are missing, add them. */
3144 /* @@ Should we only be adding missing symbols, or overriding the aux
3145 values for existing section symbols? */
3147 coff_add_missing_symbols (abfd)
3150 unsigned int nsyms = bfd_get_symcount (abfd);
3151 asymbol **sympp = abfd->outsymbols;
3154 int need_text = 1, need_data = 1, need_bss = 1, need_file = 1;
3157 for (i = 0; i < nsyms; i++)
3159 coff_symbol_type *csym = coff_symbol_from (abfd, sympp[i]);
3163 /* only do this if there is a coff representation of the input
3165 if (csym->native && csym->native->u.syment.n_sclass == C_FILE)
3170 name = csym->symbol.name;
3173 if (!strcmp (name, _TEXT))
3176 else if (!strcmp (name, ".wtext"))
3179 else if (!strcmp (name, _DATA))
3181 else if (!strcmp (name, _BSS))
3185 /* Now i == bfd_get_symcount (abfd). */
3186 /* @@ For now, don't deal with .file symbol. */
3189 if (!need_text && !need_data && !need_bss && !need_file)
3191 nsyms += need_text + need_data + need_bss + need_file;
3193 amt *= sizeof (asymbol *);
3194 sympp2 = (asymbol **) bfd_alloc (abfd, amt);
3197 memcpy (sympp2, sympp, i * sizeof (asymbol *));
3200 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
3204 sympp2[i++] = coff_section_symbol (abfd, _TEXT);
3206 sympp2[i++] = coff_section_symbol (abfd, _DATA);
3208 sympp2[i++] = coff_section_symbol (abfd, _BSS);
3209 BFD_ASSERT (i == nsyms);
3210 bfd_set_symtab (abfd, sympp2, nsyms);
3219 coff_write_object_contents (abfd)
3223 boolean hasrelocs = false;
3224 boolean haslinno = false;
3225 boolean hasdebug = false;
3227 file_ptr reloc_base;
3228 file_ptr lineno_base;
3230 unsigned long reloc_size = 0, reloc_count = 0;
3231 unsigned long lnno_size = 0;
3232 boolean long_section_names;
3233 asection *text_sec = NULL;
3234 asection *data_sec = NULL;
3235 asection *bss_sec = NULL;
3236 struct internal_filehdr internal_f;
3237 struct internal_aouthdr internal_a;
3238 #ifdef COFF_LONG_SECTION_NAMES
3239 size_t string_size = STRING_SIZE_SIZE;
3242 bfd_set_error (bfd_error_system_call);
3244 /* Make a pass through the symbol table to count line number entries and
3245 put them into the correct asections */
3247 lnno_size = coff_count_linenumbers (abfd) * bfd_coff_linesz (abfd);
3249 if (abfd->output_has_begun == false)
3251 if (! coff_compute_section_file_positions (abfd))
3255 reloc_base = obj_relocbase (abfd);
3257 /* Work out the size of the reloc and linno areas */
3259 for (current = abfd->sections; current != NULL; current =
3263 /* we store the actual reloc count in the first reloc's addr */
3264 if (current->reloc_count > 0xffff)
3267 reloc_count += current->reloc_count;
3270 reloc_size = reloc_count * bfd_coff_relsz (abfd);
3272 lineno_base = reloc_base + reloc_size;
3273 sym_base = lineno_base + lnno_size;
3275 /* Indicate in each section->line_filepos its actual file address */
3276 for (current = abfd->sections; current != NULL; current =
3279 if (current->lineno_count)
3281 current->line_filepos = lineno_base;
3282 current->moving_line_filepos = lineno_base;
3283 lineno_base += current->lineno_count * bfd_coff_linesz (abfd);
3287 current->line_filepos = 0;
3289 if (current->reloc_count)
3291 current->rel_filepos = reloc_base;
3292 reloc_base += current->reloc_count * bfd_coff_relsz (abfd);
3294 /* extra reloc to hold real count */
3295 if (current->reloc_count > 0xffff)
3296 reloc_base += bfd_coff_relsz (abfd);
3301 current->rel_filepos = 0;
3305 /* Write section headers to the file. */
3306 internal_f.f_nscns = 0;
3308 if ((abfd->flags & EXEC_P) != 0)
3309 scn_base = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
3312 scn_base = bfd_coff_filhsz (abfd);
3315 if (xcoff_data (abfd)->full_aouthdr)
3316 scn_base += bfd_coff_aoutsz (abfd);
3318 scn_base += SMALL_AOUTSZ;
3323 if (bfd_seek (abfd, scn_base, SEEK_SET) != 0)
3326 long_section_names = false;
3327 for (current = abfd->sections;
3329 current = current->next)
3331 struct internal_scnhdr section;
3332 boolean is_reloc_section = false;
3334 #ifdef COFF_IMAGE_WITH_PE
3335 if (strcmp (current->name, ".reloc") == 0)
3337 is_reloc_section = true;
3339 pe_data (abfd)->has_reloc_section = 1;
3343 internal_f.f_nscns++;
3345 strncpy (section.s_name, current->name, SCNNMLEN);
3347 #ifdef COFF_LONG_SECTION_NAMES
3348 /* Handle long section names as in PE. This must be compatible
3349 with the code in coff_write_symbols and _bfd_coff_final_link. */
3353 len = strlen (current->name);
3356 memset (section.s_name, 0, SCNNMLEN);
3357 sprintf (section.s_name, "/%lu", (unsigned long) string_size);
3358 string_size += len + 1;
3359 long_section_names = true;
3365 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3366 Ian Taylor <ian@cygnus.com>. */
3367 if (strcmp (current->name, _LIB) == 0)
3368 section.s_vaddr = 0;
3371 section.s_vaddr = current->vma;
3372 section.s_paddr = current->lma;
3373 section.s_size = current->_raw_size;
3374 #ifdef coff_get_section_load_page
3375 section.s_page = coff_get_section_load_page (current);
3379 section.s_paddr = 0;
3381 #ifdef COFF_IMAGE_WITH_PE
3382 /* Reminder: s_paddr holds the virtual size of the section. */
3383 if (coff_section_data (abfd, current) != NULL
3384 && pei_section_data (abfd, current) != NULL)
3385 section.s_paddr = pei_section_data (abfd, current)->virt_size;
3387 section.s_paddr = 0;
3391 If this section has no size or is unloadable then the scnptr
3394 if (current->_raw_size == 0 ||
3395 (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
3397 section.s_scnptr = 0;
3401 section.s_scnptr = current->filepos;
3403 section.s_relptr = current->rel_filepos;
3404 section.s_lnnoptr = current->line_filepos;
3405 section.s_nreloc = current->reloc_count;
3406 section.s_nlnno = current->lineno_count;
3407 #ifndef COFF_IMAGE_WITH_PE
3408 /* In PEI, relocs come in the .reloc section. */
3409 if (current->reloc_count != 0)
3412 if (current->lineno_count != 0)
3414 if ((current->flags & SEC_DEBUGGING) != 0
3415 && ! is_reloc_section)
3420 /* Indicate the use of an XCOFF overflow section header. */
3421 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3423 section.s_nreloc = 0xffff;
3424 section.s_nlnno = 0xffff;
3429 section.s_flags = sec_to_styp_flags (current->name, current->flags);
3431 if (!strcmp (current->name, _TEXT))
3435 else if (!strcmp (current->name, _DATA))
3439 else if (!strcmp (current->name, _BSS))
3445 section.s_align = (current->alignment_power
3446 ? 1 << current->alignment_power
3450 /* TI COFF puts the alignment power in bits 8-11 of the flags */
3451 section.s_flags |= (current->alignment_power & 0xF) << 8;
3453 #ifdef COFF_ENCODE_ALIGNMENT
3454 COFF_ENCODE_ALIGNMENT(section, current->alignment_power);
3457 #ifdef COFF_IMAGE_WITH_PE
3458 /* Suppress output of the sections if they are null. ld
3459 includes the bss and data sections even if there is no size
3460 assigned to them. NT loader doesn't like it if these section
3461 headers are included if the sections themselves are not
3462 needed. See also coff_compute_section_file_positions. */
3463 if (section.s_size == 0)
3464 internal_f.f_nscns--;
3469 bfd_size_type amt = bfd_coff_scnhsz (abfd);
3471 if (coff_swap_scnhdr_out (abfd, §ion, &buff) == 0
3472 || bfd_bwrite ((PTR) &buff, amt, abfd) != amt)
3477 /* PE stores COMDAT section information in the symbol table. If
3478 this section is supposed to have some COMDAT info, track down
3479 the symbol in the symbol table and modify it. */
3480 if ((current->flags & SEC_LINK_ONCE) != 0)
3482 unsigned int i, count;
3484 coff_symbol_type *csym = NULL;
3488 count = bfd_get_symcount (abfd);
3489 for (i = 0, psym = abfd->outsymbols; i < count; i++, psym++)
3491 if ((*psym)->section != current)
3494 /* Remember the location of the first symbol in this
3496 if (psymsec == NULL)
3499 /* See if this is the section symbol. */
3500 if (strcmp ((*psym)->name, current->name) == 0)
3502 csym = coff_symbol_from (abfd, *psym);
3504 || csym->native == NULL
3505 || csym->native->u.syment.n_numaux < 1
3506 || csym->native->u.syment.n_sclass != C_STAT
3507 || csym->native->u.syment.n_type != T_NULL)
3510 /* Here *PSYM is the section symbol for CURRENT. */
3517 Note that we might not if we're converting the file from
3518 some other object file format. */
3521 combined_entry_type *aux;
3523 /* We don't touch the x_checksum field. The
3524 x_associated field is not currently supported. */
3526 aux = csym->native + 1;
3527 switch (current->flags & SEC_LINK_DUPLICATES)
3529 case SEC_LINK_DUPLICATES_DISCARD:
3530 aux->u.auxent.x_scn.x_comdat = IMAGE_COMDAT_SELECT_ANY;
3533 case SEC_LINK_DUPLICATES_ONE_ONLY:
3534 aux->u.auxent.x_scn.x_comdat =
3535 IMAGE_COMDAT_SELECT_NODUPLICATES;
3538 case SEC_LINK_DUPLICATES_SAME_SIZE:
3539 aux->u.auxent.x_scn.x_comdat =
3540 IMAGE_COMDAT_SELECT_SAME_SIZE;
3543 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
3544 aux->u.auxent.x_scn.x_comdat =
3545 IMAGE_COMDAT_SELECT_EXACT_MATCH;
3549 /* The COMDAT symbol must be the first symbol from this
3550 section in the symbol table. In order to make this
3551 work, we move the COMDAT symbol before the first
3552 symbol we found in the search above. It's OK to
3553 rearrange the symbol table at this point, because
3554 coff_renumber_symbols is going to rearrange it
3555 further and fix up all the aux entries. */
3556 if (psym != psymsec)
3562 for (pcopy = psym; pcopy > psymsec; pcopy--)
3563 pcopy[0] = pcopy[-1];
3568 #endif /* COFF_WITH_PE */
3573 /* XCOFF handles overflows in the reloc and line number count fields
3574 by creating a new section header to hold the correct values. */
3575 for (current = abfd->sections; current != NULL; current = current->next)
3577 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3579 struct internal_scnhdr scnhdr;
3583 internal_f.f_nscns++;
3584 strncpy (&(scnhdr.s_name[0]), current->name, 8);
3585 scnhdr.s_paddr = current->reloc_count;
3586 scnhdr.s_vaddr = current->lineno_count;
3588 scnhdr.s_scnptr = 0;
3589 scnhdr.s_relptr = current->rel_filepos;
3590 scnhdr.s_lnnoptr = current->line_filepos;
3591 scnhdr.s_nreloc = current->target_index;
3592 scnhdr.s_nlnno = current->target_index;
3593 scnhdr.s_flags = STYP_OVRFLO;
3594 amt = bfd_coff_scnhsz (abfd);
3595 if (coff_swap_scnhdr_out (abfd, &scnhdr, &buff) == 0
3596 || bfd_bwrite ((PTR) &buff, amt, abfd) != amt)
3603 /* OK, now set up the filehdr... */
3605 /* Don't include the internal abs section in the section count */
3608 We will NOT put a fucking timestamp in the header here. Every time you
3609 put it back, I will come in and take it out again. I'm sorry. This
3610 field does not belong here. We fill it with a 0 so it compares the
3611 same but is not a reasonable time. -- gnu@cygnus.com
3613 internal_f.f_timdat = 0;
3615 internal_f.f_flags = 0;
3617 if (abfd->flags & EXEC_P)
3618 internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
3621 internal_f.f_opthdr = 0;
3624 if (xcoff_data (abfd)->full_aouthdr)
3625 internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
3627 internal_f.f_opthdr = SMALL_AOUTSZ;
3633 internal_f.f_flags |= F_RELFLG;
3635 internal_f.f_flags |= F_LNNO;
3636 if (abfd->flags & EXEC_P)
3637 internal_f.f_flags |= F_EXEC;
3638 #ifdef COFF_IMAGE_WITH_PE
3640 internal_f.f_flags |= IMAGE_FILE_DEBUG_STRIPPED;
3643 #ifndef COFF_WITH_PE
3644 if (bfd_little_endian (abfd))
3645 internal_f.f_flags |= F_AR32WR;
3647 internal_f.f_flags |= F_AR32W;
3651 /* target id is used in TI COFF v1 and later; COFF0 won't use this field,
3652 but it doesn't hurt to set it internally */
3653 internal_f.f_target_id = TI_TARGET_ID;
3655 #ifdef TIC80_TARGET_ID
3656 internal_f.f_target_id = TIC80_TARGET_ID;
3660 FIXME, should do something about the other byte orders and
3665 if ((abfd->flags & DYNAMIC) != 0)
3666 internal_f.f_flags |= F_SHROBJ;
3667 if (bfd_get_section_by_name (abfd, _LOADER) != NULL)
3668 internal_f.f_flags |= F_DYNLOAD;
3671 memset (&internal_a, 0, sizeof internal_a);
3673 /* Set up architecture-dependent stuff */
3676 unsigned int magic = 0;
3677 unsigned short flags = 0;
3678 coff_set_flags (abfd, &magic, &flags);
3679 internal_f.f_magic = magic;
3680 internal_f.f_flags |= flags;
3681 /* ...and the "opt"hdr... */
3684 #ifdef ULTRA3 /* NYU's machine */
3685 /* FIXME: This is a bogus check. I really want to see if there
3686 * is a .shbss or a .shdata section, if so then set the magic
3687 * number to indicate a shared data executable.
3689 if (internal_f.f_nscns >= 7)
3690 internal_a.magic = SHMAGIC; /* Shared magic */
3693 internal_a.magic = NMAGIC; /* Assume separate i/d */
3694 #define __A_MAGIC_SET__
3696 #ifdef TICOFF_AOUT_MAGIC
3697 internal_a.magic = TICOFF_AOUT_MAGIC;
3698 #define __A_MAGIC_SET__
3701 internal_a.magic = TIC80_ARCH_MAGIC;
3702 #define __A_MAGIC_SET__
3705 /* FIXME: What are the a.out magic numbers for the i860? */
3706 internal_a.magic = 0;
3707 #define __A_MAGIC_SET__
3710 internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
3711 #define __A_MAGIC_SET__
3714 #define __A_MAGIC_SET__
3715 internal_a.magic = PAGEMAGICBCS;
3719 #define __A_MAGIC_SET__
3720 internal_a.magic = APOLLO_COFF_VERSION_NUMBER;
3723 #if defined(M68) || defined(WE32K) || defined(M68K)
3724 #define __A_MAGIC_SET__
3726 internal_a.magic = LYNXCOFFMAGIC;
3728 #if defined(TARG_AUX)
3729 internal_a.magic = (abfd->flags & D_PAGED ? PAGEMAGICPEXECPAGED :
3730 abfd->flags & WP_TEXT ? PAGEMAGICPEXECSWAPPED :
3731 PAGEMAGICEXECSWAPPED);
3733 #if defined (PAGEMAGICPEXECPAGED)
3734 internal_a.magic = PAGEMAGICPEXECPAGED;
3736 #endif /* TARG_AUX */
3738 #endif /* M68 || WE32K || M68K */
3741 #define __A_MAGIC_SET__
3742 internal_a.magic = ZMAGIC;
3746 #define __A_MAGIC_SET__
3747 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
3750 #if defined MCORE_PE
3751 #define __A_MAGIC_SET__
3752 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
3756 #define __A_MAGIC_SET__
3758 internal_a.magic = LYNXCOFFMAGIC;
3760 internal_a.magic = ZMAGIC;
3765 #define __A_MAGIC_SET__
3766 internal_a.magic = ZMAGIC;
3770 #define __A_MAGIC_SET__
3772 internal_a.magic = LYNXCOFFMAGIC;
3777 #define __A_MAGIC_SET__
3778 internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC :
3779 (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC :
3780 RS6K_AOUTHDR_OMAGIC;
3783 #if defined(SH) && defined(COFF_WITH_PE)
3784 #define __A_MAGIC_SET__
3785 internal_a.magic = SH_PE_MAGIC;
3788 #if defined(MIPS) && defined(COFF_WITH_PE)
3789 #define __A_MAGIC_SET__
3790 internal_a.magic = MIPS_PE_MAGIC;
3793 #ifndef __A_MAGIC_SET__
3794 #include "Your aouthdr magic number is not being set!"
3796 #undef __A_MAGIC_SET__
3800 /* FIXME: Does anybody ever set this to another value? */
3801 internal_a.vstamp = 0;
3803 /* Now should write relocs, strings, syms */
3804 obj_sym_filepos (abfd) = sym_base;
3806 if (bfd_get_symcount (abfd) != 0)
3810 if (!coff_add_missing_symbols (abfd))
3813 if (!coff_renumber_symbols (abfd, &firstundef))
3815 coff_mangle_symbols (abfd);
3816 if (! coff_write_symbols (abfd))
3818 if (! coff_write_linenumbers (abfd))
3820 if (! coff_write_relocs (abfd, firstundef))
3823 #ifdef COFF_LONG_SECTION_NAMES
3824 else if (long_section_names && ! obj_coff_strings_written (abfd))
3826 /* If we have long section names we have to write out the string
3827 table even if there are no symbols. */
3828 if (! coff_write_symbols (abfd))
3832 #ifdef COFF_IMAGE_WITH_PE
3834 else if ((abfd->flags & EXEC_P) != 0)
3838 /* PowerPC PE appears to require that all executable files be
3839 rounded up to the page size. */
3842 (file_ptr) BFD_ALIGN (sym_base, COFF_PAGE_SIZE) - 1,
3844 || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
3850 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
3851 backend linker, and obj_raw_syment_count is not valid until after
3852 coff_write_symbols is called. */
3853 if (obj_raw_syment_count (abfd) != 0)
3855 internal_f.f_symptr = sym_base;
3857 /* AIX appears to require that F_RELFLG not be set if there are
3858 local symbols but no relocations. */
3859 internal_f.f_flags &=~ F_RELFLG;
3864 if (long_section_names)
3865 internal_f.f_symptr = sym_base;
3867 internal_f.f_symptr = 0;
3868 internal_f.f_flags |= F_LSYMS;
3873 internal_a.tsize = bfd_get_section_size_before_reloc (text_sec);
3874 internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
3878 internal_a.dsize = bfd_get_section_size_before_reloc (data_sec);
3879 internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
3883 internal_a.bsize = bfd_get_section_size_before_reloc (bss_sec);
3884 if (internal_a.bsize && bss_sec->vma < internal_a.data_start)
3885 internal_a.data_start = bss_sec->vma;
3888 internal_a.entry = bfd_get_start_address (abfd);
3889 internal_f.f_nsyms = obj_raw_syment_count (abfd);
3892 if (xcoff_data (abfd)->full_aouthdr)
3895 asection *loader_sec;
3897 internal_a.vstamp = 1;
3899 internal_a.o_snentry = xcoff_data (abfd)->snentry;
3900 if (internal_a.o_snentry == 0)
3901 internal_a.entry = (bfd_vma) -1;
3903 if (text_sec != NULL)
3905 internal_a.o_sntext = text_sec->target_index;
3906 internal_a.o_algntext = bfd_get_section_alignment (abfd, text_sec);
3910 internal_a.o_sntext = 0;
3911 internal_a.o_algntext = 0;
3913 if (data_sec != NULL)
3915 internal_a.o_sndata = data_sec->target_index;
3916 internal_a.o_algndata = bfd_get_section_alignment (abfd, data_sec);
3920 internal_a.o_sndata = 0;
3921 internal_a.o_algndata = 0;
3923 loader_sec = bfd_get_section_by_name (abfd, ".loader");
3924 if (loader_sec != NULL)
3925 internal_a.o_snloader = loader_sec->target_index;
3927 internal_a.o_snloader = 0;
3928 if (bss_sec != NULL)
3929 internal_a.o_snbss = bss_sec->target_index;
3931 internal_a.o_snbss = 0;
3933 toc = xcoff_data (abfd)->toc;
3934 internal_a.o_toc = toc;
3935 internal_a.o_sntoc = xcoff_data (abfd)->sntoc;
3937 internal_a.o_modtype = xcoff_data (abfd)->modtype;
3938 if (xcoff_data (abfd)->cputype != -1)
3939 internal_a.o_cputype = xcoff_data (abfd)->cputype;
3942 switch (bfd_get_arch (abfd))
3944 case bfd_arch_rs6000:
3945 internal_a.o_cputype = 4;
3947 case bfd_arch_powerpc:
3948 if (bfd_get_mach (abfd) == 0)
3949 internal_a.o_cputype = 3;
3951 internal_a.o_cputype = 1;
3957 internal_a.o_maxstack = xcoff_data (abfd)->maxstack;
3958 internal_a.o_maxdata = xcoff_data (abfd)->maxdata;
3962 /* now write them */
3963 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
3968 bfd_size_type amount = bfd_coff_filhsz (abfd);
3970 buff = bfd_malloc (amount);
3974 bfd_coff_swap_filehdr_out (abfd, (PTR) &internal_f, (PTR) buff);
3975 amount = bfd_bwrite ((PTR) buff, amount, abfd);
3979 if (amount != bfd_coff_filhsz (abfd))
3983 if (abfd->flags & EXEC_P)
3985 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
3986 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)) */
3988 bfd_size_type amount = bfd_coff_aoutsz (abfd);
3990 buff = bfd_malloc (amount);
3994 coff_swap_aouthdr_out (abfd, (PTR) &internal_a, (PTR) buff);
3995 amount = bfd_bwrite ((PTR) buff, amount, abfd);
3999 if (amount != bfd_coff_aoutsz (abfd))
4008 /* XCOFF seems to always write at least a small a.out header. */
4009 coff_swap_aouthdr_out (abfd, (PTR) &internal_a, (PTR) &buff);
4010 if (xcoff_data (abfd)->full_aouthdr)
4011 size = bfd_coff_aoutsz (abfd);
4013 size = SMALL_AOUTSZ;
4014 if (bfd_bwrite ((PTR) &buff, (bfd_size_type) size, abfd) != size)
4023 coff_set_section_contents (abfd, section, location, offset, count)
4028 bfd_size_type count;
4030 if (abfd->output_has_begun == false) /* set by bfd.c handler */
4032 if (! coff_compute_section_file_positions (abfd))
4036 #if defined(_LIB) && !defined(TARG_AUX)
4038 /* The physical address field of a .lib section is used to hold the
4039 number of shared libraries in the section. This code counts the
4040 number of sections being written, and increments the lma field
4043 I have found no documentation on the contents of this section.
4044 Experimentation indicates that the section contains zero or more
4045 records, each of which has the following structure:
4047 - a (four byte) word holding the length of this record, in words,
4048 - a word that always seems to be set to "2",
4049 - the path to a shared library, null-terminated and then padded
4050 to a whole word boundary.
4052 bfd_assert calls have been added to alert if an attempt is made
4053 to write a section which doesn't follow these assumptions. The
4054 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4055 <robertl@arnet.com> (Thanks!).
4057 Gvran Uddeborg <gvran@uddeborg.pp.se> */
4059 if (strcmp (section->name, _LIB) == 0)
4061 bfd_byte *rec, *recend;
4063 rec = (bfd_byte *) location;
4064 recend = rec + count;
4065 while (rec < recend)
4068 rec += bfd_get_32 (abfd, rec) * 4;
4071 BFD_ASSERT (rec == recend);
4076 /* Don't write out bss sections - one way to do this is to
4077 see if the filepos has not been set. */
4078 if (section->filepos == 0)
4081 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0)
4087 return bfd_bwrite (location, count, abfd) == count;
4091 coff_close_and_cleanup (abfd)
4094 if (!bfd_read_p (abfd))
4095 switch (abfd->format)
4098 if (!_bfd_write_archive_contents (abfd))
4102 if (!coff_write_object_contents (abfd))
4106 bfd_set_error (bfd_error_invalid_operation);
4110 /* We depend on bfd_close to free all the memory on the objalloc. */
4117 buy_and_read (abfd, where, size)
4122 PTR area = (PTR) bfd_alloc (abfd, size);
4125 if (bfd_seek (abfd, where, SEEK_SET) != 0
4126 || bfd_bread (area, size, abfd) != size)
4129 } /* buy_and_read() */
4135 Creating the linenumber table is done by reading in the entire
4136 coff linenumber table, and creating another table for internal use.
4138 A coff linenumber table is structured so that each function
4139 is marked as having a line number of 0. Each line within the
4140 function is an offset from the first line in the function. The
4141 base of the line number information for the table is stored in
4142 the symbol associated with the function.
4144 Note: The PE format uses line number 0 for a flag indicating a
4147 The information is copied from the external to the internal
4148 table, and each symbol which marks a function is marked by
4151 How does this work ?
4156 coff_slurp_line_table (abfd, asect)
4160 LINENO *native_lineno;
4161 alent *lineno_cache;
4164 BFD_ASSERT (asect->lineno == (alent *) NULL);
4166 amt = (bfd_size_type) bfd_coff_linesz (abfd) * asect->lineno_count;
4167 native_lineno = (LINENO *) buy_and_read (abfd, asect->line_filepos, amt);
4168 amt = ((bfd_size_type) asect->lineno_count + 1) * sizeof (alent);
4169 lineno_cache = (alent *) bfd_alloc (abfd, amt);
4170 if (lineno_cache == NULL)
4174 unsigned int counter = 0;
4175 alent *cache_ptr = lineno_cache;
4176 LINENO *src = native_lineno;
4178 while (counter < asect->lineno_count)
4180 struct internal_lineno dst;
4181 bfd_coff_swap_lineno_in (abfd, src, &dst);
4182 cache_ptr->line_number = dst.l_lnno;
4184 if (cache_ptr->line_number == 0)
4187 bfd_signed_vma symndx;
4188 coff_symbol_type *sym;
4191 symndx = dst.l_addr.l_symndx;
4193 || (bfd_vma) symndx >= obj_raw_syment_count (abfd))
4195 (*_bfd_error_handler)
4196 (_("%s: warning: illegal symbol index %ld in line numbers"),
4197 bfd_get_filename (abfd), dst.l_addr.l_symndx);
4201 /* FIXME: We should not be casting between ints and
4202 pointers like this. */
4203 sym = ((coff_symbol_type *)
4204 ((symndx + obj_raw_syments (abfd))
4205 ->u.syment._n._n_n._n_zeroes));
4206 cache_ptr->u.sym = (asymbol *) sym;
4207 if (sym->lineno != NULL && ! warned)
4209 (*_bfd_error_handler)
4210 (_("%s: warning: duplicate line number information for `%s'"),
4211 bfd_get_filename (abfd),
4212 bfd_asymbol_name (&sym->symbol));
4214 sym->lineno = cache_ptr;
4218 cache_ptr->u.offset = dst.l_addr.l_paddr
4219 - bfd_section_vma (abfd, asect);
4220 } /* If no linenumber expect a symbol index */
4226 cache_ptr->line_number = 0;
4229 asect->lineno = lineno_cache;
4230 /* FIXME, free native_lineno here, or use alloca or something. */
4234 /* Slurp in the symbol table, converting it to generic form. Note
4235 that if coff_relocate_section is defined, the linker will read
4236 symbols via coff_link_add_symbols, rather than via this routine. */
4239 coff_slurp_symbol_table (abfd)
4242 combined_entry_type *native_symbols;
4243 coff_symbol_type *cached_area;
4244 unsigned int *table_ptr;
4247 unsigned int number_of_symbols = 0;
4249 if (obj_symbols (abfd))
4252 /* Read in the symbol table */
4253 if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL)
4258 /* Allocate enough room for all the symbols in cached form */
4259 amt = obj_raw_syment_count (abfd);
4260 amt *= sizeof (coff_symbol_type);
4261 cached_area = (coff_symbol_type *) bfd_alloc (abfd, amt);
4262 if (cached_area == NULL)
4265 amt = obj_raw_syment_count (abfd);
4266 amt *= sizeof (unsigned int);
4267 table_ptr = (unsigned int *) bfd_alloc (abfd, amt);
4269 if (table_ptr == NULL)
4273 coff_symbol_type *dst = cached_area;
4274 unsigned int last_native_index = obj_raw_syment_count (abfd);
4275 unsigned int this_index = 0;
4276 while (this_index < last_native_index)
4278 combined_entry_type *src = native_symbols + this_index;
4279 table_ptr[this_index] = number_of_symbols;
4280 dst->symbol.the_bfd = abfd;
4282 dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset);
4283 /* We use the native name field to point to the cached field. */
4284 src->u.syment._n._n_n._n_zeroes = (long) dst;
4285 dst->symbol.section = coff_section_from_bfd_index (abfd,
4286 src->u.syment.n_scnum);
4287 dst->symbol.flags = 0;
4288 dst->done_lineno = false;
4290 switch (src->u.syment.n_sclass)
4295 dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
4296 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
4297 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4299 /* Fall through to next case */
4307 case C_THUMBEXTFUNC:
4313 case C_SYSTEM: /* System Wide variable */
4316 /* In PE, 0x68 (104) denotes a section symbol */
4318 /* In PE, 0x69 (105) denotes a weak external symbol. */
4321 switch (coff_classify_symbol (abfd, &src->u.syment))
4323 case COFF_SYMBOL_GLOBAL:
4324 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
4325 #if defined COFF_WITH_PE
4326 /* PE sets the symbol to a value relative to the
4327 start of the section. */
4328 dst->symbol.value = src->u.syment.n_value;
4330 dst->symbol.value = (src->u.syment.n_value
4331 - dst->symbol.section->vma);
4333 if (ISFCN ((src->u.syment.n_type)))
4335 /* A function ext does not go at the end of a
4337 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4341 case COFF_SYMBOL_COMMON:
4342 dst->symbol.section = bfd_com_section_ptr;
4343 dst->symbol.value = src->u.syment.n_value;
4346 case COFF_SYMBOL_UNDEFINED:
4347 dst->symbol.section = bfd_und_section_ptr;
4348 dst->symbol.value = 0;
4351 case COFF_SYMBOL_PE_SECTION:
4352 dst->symbol.flags |= BSF_EXPORT | BSF_SECTION_SYM;
4353 dst->symbol.value = 0;
4356 case COFF_SYMBOL_LOCAL:
4357 dst->symbol.flags = BSF_LOCAL;
4358 #if defined COFF_WITH_PE
4359 /* PE sets the symbol to a value relative to the
4360 start of the section. */
4361 dst->symbol.value = src->u.syment.n_value;
4363 dst->symbol.value = (src->u.syment.n_value
4364 - dst->symbol.section->vma);
4366 if (ISFCN ((src->u.syment.n_type)))
4367 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4372 /* A symbol with a csect entry should not go at the end. */
4373 if (src->u.syment.n_numaux > 0)
4374 dst->symbol.flags |= BSF_NOT_AT_END;
4378 if (src->u.syment.n_sclass == C_NT_WEAK)
4379 dst->symbol.flags = BSF_WEAK;
4380 if (src->u.syment.n_sclass == C_SECTION
4381 && src->u.syment.n_scnum > 0)
4383 dst->symbol.flags = BSF_LOCAL;
4387 if (src->u.syment.n_sclass == C_WEAKEXT)
4388 dst->symbol.flags = BSF_WEAK;
4392 case C_STAT: /* static */
4394 case C_LEAFSTAT: /* static leaf procedure */
4397 case C_THUMBSTAT: /* Thumb static */
4398 case C_THUMBLABEL: /* Thumb label */
4399 case C_THUMBSTATFUNC:/* Thumb static function */
4401 case C_LABEL: /* label */
4402 if (src->u.syment.n_scnum == N_DEBUG)
4403 dst->symbol.flags = BSF_DEBUGGING;
4405 dst->symbol.flags = BSF_LOCAL;
4407 /* Base the value as an index from the base of the
4408 section, if there is one. */
4409 if (dst->symbol.section)
4411 #if defined COFF_WITH_PE
4412 /* PE sets the symbol to a value relative to the
4413 start of the section. */
4414 dst->symbol.value = src->u.syment.n_value;
4416 dst->symbol.value = (src->u.syment.n_value
4417 - dst->symbol.section->vma);
4421 dst->symbol.value = src->u.syment.n_value;
4424 case C_MOS: /* member of structure */
4425 case C_EOS: /* end of structure */
4426 #ifdef NOTDEF /* C_AUTOARG has the same value */
4428 case C_GLBLREG: /* A29k-specific storage class */
4431 case C_REGPARM: /* register parameter */
4432 case C_REG: /* register variable */
4433 /* C_AUTOARG conflictes with TI COFF C_UEXT */
4434 #if !defined (TIC80COFF) && !defined (TICOFF)
4436 case C_AUTOARG: /* 960-specific storage class */
4439 case C_TPDEF: /* type definition */
4441 case C_AUTO: /* automatic variable */
4442 case C_FIELD: /* bit field */
4443 case C_ENTAG: /* enumeration tag */
4444 case C_MOE: /* member of enumeration */
4445 case C_MOU: /* member of union */
4446 case C_UNTAG: /* union tag */
4447 dst->symbol.flags = BSF_DEBUGGING;
4448 dst->symbol.value = (src->u.syment.n_value);
4451 case C_FILE: /* file name */
4452 case C_STRTAG: /* structure tag */
4467 dst->symbol.flags = BSF_DEBUGGING;
4468 dst->symbol.value = (src->u.syment.n_value);
4472 case C_BINCL: /* beginning of include file */
4473 case C_EINCL: /* ending of include file */
4474 /* The value is actually a pointer into the line numbers
4475 of the file. We locate the line number entry, and
4476 set the section to the section which contains it, and
4477 the value to the index in that section. */
4481 dst->symbol.flags = BSF_DEBUGGING;
4482 for (sec = abfd->sections; sec != NULL; sec = sec->next)
4483 if (sec->line_filepos <= (file_ptr) src->u.syment.n_value
4484 && ((file_ptr) (sec->line_filepos
4485 + sec->lineno_count * bfd_coff_linesz (abfd))
4486 > (file_ptr) src->u.syment.n_value))
4489 dst->symbol.value = 0;
4492 dst->symbol.section = sec;
4493 dst->symbol.value = ((src->u.syment.n_value
4494 - sec->line_filepos)
4495 / bfd_coff_linesz (abfd));
4502 dst->symbol.flags = BSF_DEBUGGING;
4504 /* The value is actually a symbol index. Save a pointer
4505 to the symbol instead of the index. FIXME: This
4506 should use a union. */
4507 src->u.syment.n_value =
4508 (long) (native_symbols + src->u.syment.n_value);
4509 dst->symbol.value = src->u.syment.n_value;
4514 case C_BLOCK: /* ".bb" or ".eb" */
4515 case C_FCN: /* ".bf" or ".ef" (or PE ".lf") */
4516 case C_EFCN: /* physical end of function */
4517 #if defined COFF_WITH_PE
4518 /* PE sets the symbol to a value relative to the start
4520 dst->symbol.value = src->u.syment.n_value;
4521 if (strcmp (dst->symbol.name, ".bf") != 0)
4523 /* PE uses funny values for .ef and .lf; don't
4525 dst->symbol.flags = BSF_DEBUGGING;
4528 dst->symbol.flags = BSF_DEBUGGING | BSF_DEBUGGING_RELOC;
4530 /* Base the value as an index from the base of the
4532 dst->symbol.flags = BSF_LOCAL;
4533 dst->symbol.value = (src->u.syment.n_value
4534 - dst->symbol.section->vma);
4538 case C_STATLAB: /* Static load time label */
4539 dst->symbol.value = src->u.syment.n_value;
4540 dst->symbol.flags = BSF_GLOBAL;
4544 /* PE DLLs sometimes have zeroed out symbols for some
4545 reason. Just ignore them without a warning. */
4546 if (src->u.syment.n_type == 0
4547 && src->u.syment.n_value == 0
4548 && src->u.syment.n_scnum == 0)
4551 case C_EXTDEF: /* external definition */
4552 case C_ULABEL: /* undefined label */
4553 case C_USTATIC: /* undefined static */
4554 #ifndef COFF_WITH_PE
4555 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4556 class to represent a section symbol */
4557 case C_LINE: /* line # reformatted as symbol table entry */
4558 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4559 case C_ALIAS: /* duplicate tag */
4561 /* New storage classes for TI COFF */
4562 #if defined(TIC80COFF) || defined(TICOFF)
4563 case C_UEXT: /* Tentative external definition */
4565 case C_EXTLAB: /* External load time label */
4566 case C_HIDDEN: /* ext symbol in dmert public lib */
4568 (*_bfd_error_handler)
4569 (_("%s: Unrecognized storage class %d for %s symbol `%s'"),
4570 bfd_get_filename (abfd), src->u.syment.n_sclass,
4571 dst->symbol.section->name, dst->symbol.name);
4572 dst->symbol.flags = BSF_DEBUGGING;
4573 dst->symbol.value = (src->u.syment.n_value);
4577 /* BFD_ASSERT(dst->symbol.flags != 0);*/
4581 dst->symbol.udata.i = 0;
4582 dst->lineno = (alent *) NULL;
4583 this_index += (src->u.syment.n_numaux) + 1;
4585 number_of_symbols++;
4586 } /* walk the native symtab */
4587 } /* bfdize the native symtab */
4589 obj_symbols (abfd) = cached_area;
4590 obj_raw_syments (abfd) = native_symbols;
4592 bfd_get_symcount (abfd) = number_of_symbols;
4593 obj_convert (abfd) = table_ptr;
4594 /* Slurp the line tables for each section too */
4600 coff_slurp_line_table (abfd, p);
4605 } /* coff_slurp_symbol_table() */
4607 /* Classify a COFF symbol. A couple of targets have globally visible
4608 symbols which are not class C_EXT, and this handles those. It also
4609 recognizes some special PE cases. */
4611 static enum coff_symbol_classification
4612 coff_classify_symbol (abfd, syment)
4614 struct internal_syment *syment;
4616 /* FIXME: This partially duplicates the switch in
4617 coff_slurp_symbol_table. */
4618 switch (syment->n_sclass)
4627 case C_THUMBEXTFUNC:
4635 if (syment->n_scnum == 0)
4637 if (syment->n_value == 0)
4638 return COFF_SYMBOL_UNDEFINED;
4640 return COFF_SYMBOL_COMMON;
4642 return COFF_SYMBOL_GLOBAL;
4649 if (syment->n_sclass == C_STAT)
4651 if (syment->n_scnum == 0)
4653 /* The Microsoft compiler sometimes generates these if a
4654 small static function is inlined every time it is used.
4655 The function is discarded, but the symbol table entry
4657 return COFF_SYMBOL_LOCAL;
4660 #ifdef STRICT_PE_FORMAT
4661 /* This is correct for Microsoft generated objects, but it
4662 breaks gas generated objects. */
4664 if (syment->n_value == 0)
4667 char buf[SYMNMLEN + 1];
4669 sec = coff_section_from_bfd_index (abfd, syment->n_scnum);
4671 && (strcmp (bfd_get_section_name (abfd, sec),
4672 _bfd_coff_internal_syment_name (abfd, syment, buf))
4674 return COFF_SYMBOL_PE_SECTION;
4678 return COFF_SYMBOL_LOCAL;
4681 if (syment->n_sclass == C_SECTION)
4683 /* In some cases in a DLL generated by the Microsoft linker, the
4684 n_value field will contain garbage. FIXME: This should
4685 probably be handled by the swapping function instead. */
4686 syment->n_value = 0;
4687 if (syment->n_scnum == 0)
4688 return COFF_SYMBOL_UNDEFINED;
4689 return COFF_SYMBOL_PE_SECTION;
4691 #endif /* COFF_WITH_PE */
4693 /* If it is not a global symbol, we presume it is a local symbol. */
4695 if (syment->n_scnum == 0)
4697 char buf[SYMNMLEN + 1];
4699 (*_bfd_error_handler)
4700 (_("warning: %s: local symbol `%s' has no section"),
4701 bfd_get_filename (abfd),
4702 _bfd_coff_internal_syment_name (abfd, syment, buf));
4705 return COFF_SYMBOL_LOCAL;
4712 Coff relocations are easily transformed into the internal BFD form
4715 Reading a coff relocation table is done in the following stages:
4717 o Read the entire coff relocation table into memory.
4719 o Process each relocation in turn; first swap it from the
4720 external to the internal form.
4722 o Turn the symbol referenced in the relocation's symbol index
4723 into a pointer into the canonical symbol table.
4724 This table is the same as the one returned by a call to
4725 @code{bfd_canonicalize_symtab}. The back end will call that
4726 routine and save the result if a canonicalization hasn't been done.
4728 o The reloc index is turned into a pointer to a howto
4729 structure, in a back end specific way. For instance, the 386
4730 and 960 use the @code{r_type} to directly produce an index
4731 into a howto table vector; the 88k subtracts a number from the
4732 @code{r_type} field and creates an addend field.
4737 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
4739 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \
4740 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
4741 coffsym = (obj_symbols (abfd) \
4742 + (cache_ptr->sym_ptr_ptr - symbols)); \
4744 coffsym = coff_symbol_from (abfd, ptr); \
4745 if (coffsym != (coff_symbol_type *) NULL \
4746 && coffsym->native->u.syment.n_scnum == 0) \
4747 cache_ptr->addend = 0; \
4748 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
4749 && ptr->section != (asection *) NULL) \
4750 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
4752 cache_ptr->addend = 0; \
4757 coff_slurp_reloc_table (abfd, asect, symbols)
4762 RELOC *native_relocs;
4763 arelent *reloc_cache;
4768 if (asect->relocation)
4770 if (asect->reloc_count == 0)
4772 if (asect->flags & SEC_CONSTRUCTOR)
4774 if (!coff_slurp_symbol_table (abfd))
4776 amt = (bfd_size_type) bfd_coff_relsz (abfd) * asect->reloc_count;
4777 native_relocs = (RELOC *) buy_and_read (abfd, asect->rel_filepos, amt);
4778 amt = (bfd_size_type) asect->reloc_count * sizeof (arelent);
4779 reloc_cache = (arelent *) bfd_alloc (abfd, amt);
4781 if (reloc_cache == NULL)
4784 for (idx = 0; idx < asect->reloc_count; idx++)
4786 struct internal_reloc dst;
4787 struct external_reloc *src;
4788 #ifndef RELOC_PROCESSING
4792 cache_ptr = reloc_cache + idx;
4793 src = native_relocs + idx;
4795 coff_swap_reloc_in (abfd, src, &dst);
4797 #ifdef RELOC_PROCESSING
4798 RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
4800 cache_ptr->address = dst.r_vaddr;
4802 if (dst.r_symndx != -1)
4804 if (dst.r_symndx < 0 || dst.r_symndx >= obj_conv_table_size (abfd))
4806 (*_bfd_error_handler)
4807 (_("%s: warning: illegal symbol index %ld in relocs"),
4808 bfd_get_filename (abfd), dst.r_symndx);
4809 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
4814 cache_ptr->sym_ptr_ptr = (symbols
4815 + obj_convert (abfd)[dst.r_symndx]);
4816 ptr = *(cache_ptr->sym_ptr_ptr);
4821 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
4825 /* The symbols definitions that we have read in have been
4826 relocated as if their sections started at 0. But the offsets
4827 refering to the symbols in the raw data have not been
4828 modified, so we have to have a negative addend to compensate.
4830 Note that symbols which used to be common must be left alone */
4832 /* Calculate any reloc addend by looking at the symbol */
4833 CALC_ADDEND (abfd, ptr, dst, cache_ptr);
4835 cache_ptr->address -= asect->vma;
4836 /* !! cache_ptr->section = (asection *) NULL;*/
4838 /* Fill in the cache_ptr->howto field from dst.r_type */
4839 RTYPE2HOWTO (cache_ptr, &dst);
4840 #endif /* RELOC_PROCESSING */
4842 if (cache_ptr->howto == NULL)
4844 (*_bfd_error_handler)
4845 (_("%s: illegal relocation type %d at address 0x%lx"),
4846 bfd_get_filename (abfd), dst.r_type, (long) dst.r_vaddr);
4847 bfd_set_error (bfd_error_bad_value);
4852 asect->relocation = reloc_cache;
4856 #ifndef coff_rtype_to_howto
4859 /* Get the howto structure for a reloc. This is only used if the file
4860 including this one defines coff_relocate_section to be
4861 _bfd_coff_generic_relocate_section, so it is OK if it does not
4862 always work. It is the responsibility of the including file to
4863 make sure it is reasonable if it is needed. */
4865 static reloc_howto_type *coff_rtype_to_howto
4866 PARAMS ((bfd *, asection *, struct internal_reloc *,
4867 struct coff_link_hash_entry *, struct internal_syment *,
4871 static reloc_howto_type *
4872 coff_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
4873 bfd *abfd ATTRIBUTE_UNUSED;
4874 asection *sec ATTRIBUTE_UNUSED;
4875 struct internal_reloc *rel;
4876 struct coff_link_hash_entry *h ATTRIBUTE_UNUSED;
4877 struct internal_syment *sym ATTRIBUTE_UNUSED;
4878 bfd_vma *addendp ATTRIBUTE_UNUSED;
4882 RTYPE2HOWTO (&genrel, rel);
4883 return genrel.howto;
4886 #else /* ! defined (RTYPE2HOWTO) */
4888 #define coff_rtype_to_howto NULL
4890 #endif /* ! defined (RTYPE2HOWTO) */
4891 #endif /* ! defined (coff_rtype_to_howto) */
4893 /* This is stupid. This function should be a boolean predicate. */
4895 coff_canonicalize_reloc (abfd, section, relptr, symbols)
4901 arelent *tblptr = section->relocation;
4902 unsigned int count = 0;
4904 if (section->flags & SEC_CONSTRUCTOR)
4906 /* this section has relocs made up by us, they are not in the
4907 file, so take them out of their chain and place them into
4908 the data area provided */
4909 arelent_chain *chain = section->constructor_chain;
4910 for (count = 0; count < section->reloc_count; count++)
4912 *relptr++ = &chain->relent;
4913 chain = chain->next;
4919 if (! coff_slurp_reloc_table (abfd, section, symbols))
4922 tblptr = section->relocation;
4924 for (; count++ < section->reloc_count;)
4925 *relptr++ = tblptr++;
4928 return section->reloc_count;
4933 coff_sym_filepos (abfd)
4936 return obj_sym_filepos (abfd);
4940 #ifndef coff_reloc16_estimate
4941 #define coff_reloc16_estimate dummy_reloc16_estimate
4943 static int dummy_reloc16_estimate
4944 PARAMS ((bfd *, asection *, arelent *, unsigned int,
4945 struct bfd_link_info *));
4948 dummy_reloc16_estimate (abfd, input_section, reloc, shrink, link_info)
4949 bfd *abfd ATTRIBUTE_UNUSED;
4950 asection *input_section ATTRIBUTE_UNUSED;
4951 arelent *reloc ATTRIBUTE_UNUSED;
4952 unsigned int shrink ATTRIBUTE_UNUSED;
4953 struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
4961 #ifndef coff_reloc16_extra_cases
4963 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
4965 /* This works even if abort is not declared in any header file. */
4967 static void dummy_reloc16_extra_cases
4968 PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
4969 bfd_byte *, unsigned int *, unsigned int *));
4972 dummy_reloc16_extra_cases (abfd, link_info, link_order, reloc, data, src_ptr,
4974 bfd *abfd ATTRIBUTE_UNUSED;
4975 struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
4976 struct bfd_link_order *link_order ATTRIBUTE_UNUSED;
4977 arelent *reloc ATTRIBUTE_UNUSED;
4978 bfd_byte *data ATTRIBUTE_UNUSED;
4979 unsigned int *src_ptr ATTRIBUTE_UNUSED;
4980 unsigned int *dst_ptr ATTRIBUTE_UNUSED;
4986 /* If coff_relocate_section is defined, we can use the optimized COFF
4987 backend linker. Otherwise we must continue to use the old linker. */
4988 #ifdef coff_relocate_section
4989 #ifndef coff_bfd_link_hash_table_create
4990 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
4992 #ifndef coff_bfd_link_add_symbols
4993 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
4995 #ifndef coff_bfd_final_link
4996 #define coff_bfd_final_link _bfd_coff_final_link
4998 #else /* ! defined (coff_relocate_section) */
4999 #define coff_relocate_section NULL
5000 #ifndef coff_bfd_link_hash_table_create
5001 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5003 #ifndef coff_bfd_link_add_symbols
5004 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5006 #define coff_bfd_final_link _bfd_generic_final_link
5007 #endif /* ! defined (coff_relocate_section) */
5009 #define coff_bfd_link_split_section _bfd_generic_link_split_section
5011 #ifndef coff_start_final_link
5012 #define coff_start_final_link NULL
5015 #ifndef coff_adjust_symndx
5016 #define coff_adjust_symndx NULL
5019 #ifndef coff_link_add_one_symbol
5020 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5023 #ifndef coff_link_output_has_begun
5025 static boolean coff_link_output_has_begun
5026 PARAMS ((bfd *, struct coff_final_link_info *));
5029 coff_link_output_has_begun (abfd, info)
5031 struct coff_final_link_info * info ATTRIBUTE_UNUSED;
5033 return abfd->output_has_begun;
5037 #ifndef coff_final_link_postscript
5039 static boolean coff_final_link_postscript
5040 PARAMS ((bfd *, struct coff_final_link_info *));
5043 coff_final_link_postscript (abfd, pfinfo)
5044 bfd * abfd ATTRIBUTE_UNUSED;
5045 struct coff_final_link_info * pfinfo ATTRIBUTE_UNUSED;
5051 #ifndef coff_SWAP_aux_in
5052 #define coff_SWAP_aux_in coff_swap_aux_in
5054 #ifndef coff_SWAP_sym_in
5055 #define coff_SWAP_sym_in coff_swap_sym_in
5057 #ifndef coff_SWAP_lineno_in
5058 #define coff_SWAP_lineno_in coff_swap_lineno_in
5060 #ifndef coff_SWAP_aux_out
5061 #define coff_SWAP_aux_out coff_swap_aux_out
5063 #ifndef coff_SWAP_sym_out
5064 #define coff_SWAP_sym_out coff_swap_sym_out
5066 #ifndef coff_SWAP_lineno_out
5067 #define coff_SWAP_lineno_out coff_swap_lineno_out
5069 #ifndef coff_SWAP_reloc_out
5070 #define coff_SWAP_reloc_out coff_swap_reloc_out
5072 #ifndef coff_SWAP_filehdr_out
5073 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5075 #ifndef coff_SWAP_aouthdr_out
5076 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5078 #ifndef coff_SWAP_scnhdr_out
5079 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5081 #ifndef coff_SWAP_reloc_in
5082 #define coff_SWAP_reloc_in coff_swap_reloc_in
5084 #ifndef coff_SWAP_filehdr_in
5085 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5087 #ifndef coff_SWAP_aouthdr_in
5088 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5090 #ifndef coff_SWAP_scnhdr_in
5091 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5094 static const bfd_coff_backend_data bfd_coff_std_swap_table =
5096 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5097 coff_SWAP_aux_out, coff_SWAP_sym_out,
5098 coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5099 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5100 coff_SWAP_scnhdr_out,
5101 FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
5102 #ifdef COFF_LONG_FILENAMES
5107 #ifdef COFF_LONG_SECTION_NAMES
5112 COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5113 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5118 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5123 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5124 coff_SWAP_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook,
5125 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5126 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5127 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5128 coff_classify_symbol, coff_compute_section_file_positions,
5129 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5130 coff_adjust_symndx, coff_link_add_one_symbol,
5131 coff_link_output_has_begun, coff_final_link_postscript
5134 #ifndef coff_close_and_cleanup
5135 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
5138 #ifndef coff_bfd_free_cached_info
5139 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
5142 #ifndef coff_get_section_contents
5143 #define coff_get_section_contents _bfd_generic_get_section_contents
5146 #ifndef coff_bfd_copy_private_symbol_data
5147 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5150 #ifndef coff_bfd_copy_private_section_data
5151 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5154 #ifndef coff_bfd_copy_private_bfd_data
5155 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5158 #ifndef coff_bfd_merge_private_bfd_data
5159 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5162 #ifndef coff_bfd_set_private_flags
5163 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5166 #ifndef coff_bfd_print_private_bfd_data
5167 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5170 #ifndef coff_bfd_is_local_label_name
5171 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5174 #ifndef coff_read_minisymbols
5175 #define coff_read_minisymbols _bfd_generic_read_minisymbols
5178 #ifndef coff_minisymbol_to_symbol
5179 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5182 /* The reloc lookup routine must be supplied by each individual COFF
5184 #ifndef coff_bfd_reloc_type_lookup
5185 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5188 #ifndef coff_bfd_get_relocated_section_contents
5189 #define coff_bfd_get_relocated_section_contents \
5190 bfd_generic_get_relocated_section_contents
5193 #ifndef coff_bfd_relax_section
5194 #define coff_bfd_relax_section bfd_generic_relax_section
5197 #ifndef coff_bfd_gc_sections
5198 #define coff_bfd_gc_sections bfd_generic_gc_sections
5201 #ifndef coff_bfd_merge_sections
5202 #define coff_bfd_merge_sections bfd_generic_merge_sections
5205 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
5206 const bfd_target VAR = \
5209 bfd_target_coff_flavour, \
5210 BFD_ENDIAN_BIG, /* data byte order is big */ \
5211 BFD_ENDIAN_BIG, /* header byte order is big */ \
5212 /* object flags */ \
5213 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5214 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5215 /* section flags */ \
5216 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5217 UNDER, /* leading symbol underscore */ \
5218 '/', /* ar_pad_char */ \
5219 15, /* ar_max_namelen */ \
5221 /* Data conversion functions. */ \
5222 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5223 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5224 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5226 /* Header conversion functions. */ \
5227 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5228 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5229 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5231 /* bfd_check_format */ \
5232 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5233 _bfd_dummy_target }, \
5234 /* bfd_set_format */ \
5235 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5236 /* bfd_write_contents */ \
5237 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5240 BFD_JUMP_TABLE_GENERIC (coff), \
5241 BFD_JUMP_TABLE_COPY (coff), \
5242 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5243 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5244 BFD_JUMP_TABLE_SYMBOLS (coff), \
5245 BFD_JUMP_TABLE_RELOCS (coff), \
5246 BFD_JUMP_TABLE_WRITE (coff), \
5247 BFD_JUMP_TABLE_LINK (coff), \
5248 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5255 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
5256 const bfd_target VAR = \
5259 bfd_target_coff_flavour, \
5260 BFD_ENDIAN_LITTLE, /* data byte order is little */ \
5261 BFD_ENDIAN_LITTLE, /* header byte order is little */ \
5262 /* object flags */ \
5263 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5264 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5265 /* section flags */ \
5266 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5267 UNDER, /* leading symbol underscore */ \
5268 '/', /* ar_pad_char */ \
5269 15, /* ar_max_namelen */ \
5271 /* Data conversion functions. */ \
5272 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5273 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5274 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5275 /* Header conversion functions. */ \
5276 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5277 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5278 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5279 /* bfd_check_format */ \
5280 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5281 _bfd_dummy_target }, \
5282 /* bfd_set_format */ \
5283 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5284 /* bfd_write_contents */ \
5285 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5288 BFD_JUMP_TABLE_GENERIC (coff), \
5289 BFD_JUMP_TABLE_COPY (coff), \
5290 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5291 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5292 BFD_JUMP_TABLE_SYMBOLS (coff), \
5293 BFD_JUMP_TABLE_RELOCS (coff), \
5294 BFD_JUMP_TABLE_WRITE (coff), \
5295 BFD_JUMP_TABLE_LINK (coff), \
5296 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \