1 /* Support for the generic parts of most COFF variants, for BFD.
2 Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 98, 1999
3 Free Software Foundation, Inc.
4 Written by Cygnus Support.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
23 Most of this hacked by Steve Chamberlain,
31 BFD supports a number of different flavours of coff format.
32 The major differences between formats are the sizes and
33 alignments of fields in structures on disk, and the occasional
36 Coff in all its varieties is implemented with a few common
37 files and a number of implementation specific files. For
38 example, The 88k bcs coff format is implemented in the file
39 @file{coff-m88k.c}. This file @code{#include}s
40 @file{coff/m88k.h} which defines the external structure of the
41 coff format for the 88k, and @file{coff/internal.h} which
42 defines the internal structure. @file{coff-m88k.c} also
43 defines the relocations used by the 88k format
46 The Intel i960 processor version of coff is implemented in
47 @file{coff-i960.c}. This file has the same structure as
48 @file{coff-m88k.c}, except that it includes @file{coff/i960.h}
49 rather than @file{coff-m88k.h}.
52 Porting to a new version of coff
54 The recommended method is to select from the existing
55 implementations the version of coff which is most like the one
56 you want to use. For example, we'll say that i386 coff is
57 the one you select, and that your coff flavour is called foo.
58 Copy @file{i386coff.c} to @file{foocoff.c}, copy
59 @file{../include/coff/i386.h} to @file{../include/coff/foo.h},
60 and add the lines to @file{targets.c} and @file{Makefile.in}
61 so that your new back end is used. Alter the shapes of the
62 structures in @file{../include/coff/foo.h} so that they match
63 what you need. You will probably also have to add
64 @code{#ifdef}s to the code in @file{coff/internal.h} and
65 @file{coffcode.h} if your version of coff is too wild.
67 You can verify that your new BFD backend works quite simply by
68 building @file{objdump} from the @file{binutils} directory,
69 and making sure that its version of what's going on and your
70 host system's idea (assuming it has the pretty standard coff
71 dump utility, usually called @code{att-dump} or just
72 @code{dump}) are the same. Then clean up your code, and send
73 what you've done to Cygnus. Then your stuff will be in the
74 next release, and you won't have to keep integrating it.
77 How the coff backend works
82 The Coff backend is split into generic routines that are
83 applicable to any Coff target and routines that are specific
84 to a particular target. The target-specific routines are
85 further split into ones which are basically the same for all
86 Coff targets except that they use the external symbol format
87 or use different values for certain constants.
89 The generic routines are in @file{coffgen.c}. These routines
90 work for any Coff target. They use some hooks into the target
91 specific code; the hooks are in a @code{bfd_coff_backend_data}
92 structure, one of which exists for each target.
94 The essentially similar target-specific routines are in
95 @file{coffcode.h}. This header file includes executable C code.
96 The various Coff targets first include the appropriate Coff
97 header file, make any special defines that are needed, and
98 then include @file{coffcode.h}.
100 Some of the Coff targets then also have additional routines in
101 the target source file itself.
103 For example, @file{coff-i960.c} includes
104 @file{coff/internal.h} and @file{coff/i960.h}. It then
105 defines a few constants, such as @code{I960}, and includes
106 @file{coffcode.h}. Since the i960 has complex relocation
107 types, @file{coff-i960.c} also includes some code to
108 manipulate the i960 relocs. This code is not in
109 @file{coffcode.h} because it would not be used by any other
115 Each flavour of coff supported in BFD has its own header file
116 describing the external layout of the structures. There is also
117 an internal description of the coff layout, in
118 @file{coff/internal.h}. A major function of the
119 coff backend is swapping the bytes and twiddling the bits to
120 translate the external form of the structures into the normal
121 internal form. This is all performed in the
122 @code{bfd_swap}_@i{thing}_@i{direction} routines. Some
123 elements are different sizes between different versions of
124 coff; it is the duty of the coff version specific include file
125 to override the definitions of various packing routines in
126 @file{coffcode.h}. E.g., the size of line number entry in coff is
127 sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
128 @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
129 correct one. No doubt, some day someone will find a version of
130 coff which has a varying field size not catered to at the
131 moment. To port BFD, that person will have to add more @code{#defines}.
132 Three of the bit twiddling routines are exported to
133 @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
134 and @code{coff_swap_lineno_in}. @code{GDB} reads the symbol
135 table on its own, but uses BFD to fix things up. More of the
136 bit twiddlers are exported for @code{gas};
137 @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
138 @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
139 @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
140 @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
141 of all the symbol table and reloc drudgery itself, thereby
142 saving the internal BFD overhead, but uses BFD to swap things
143 on the way out, making cross ports much safer. Doing so also
144 allows BFD (and thus the linker) to use the same header files
145 as @code{gas}, which makes one avenue to disaster disappear.
150 The simple canonical form for symbols used by BFD is not rich
151 enough to keep all the information available in a coff symbol
152 table. The back end gets around this problem by keeping the original
153 symbol table around, "behind the scenes".
155 When a symbol table is requested (through a call to
156 @code{bfd_canonicalize_symtab}), a request gets through to
157 @code{coff_get_normalized_symtab}. This reads the symbol table from
158 the coff file and swaps all the structures inside into the
159 internal form. It also fixes up all the pointers in the table
160 (represented in the file by offsets from the first symbol in
161 the table) into physical pointers to elements in the new
162 internal table. This involves some work since the meanings of
163 fields change depending upon context: a field that is a
164 pointer to another structure in the symbol table at one moment
165 may be the size in bytes of a structure at the next. Another
166 pass is made over the table. All symbols which mark file names
167 (<<C_FILE>> symbols) are modified so that the internal
168 string points to the value in the auxent (the real filename)
169 rather than the normal text associated with the symbol
172 At this time the symbol names are moved around. Coff stores
173 all symbols less than nine characters long physically
174 within the symbol table; longer strings are kept at the end of
175 the file in the string table. This pass moves all strings
176 into memory and replaces them with pointers to the strings.
179 The symbol table is massaged once again, this time to create
180 the canonical table used by the BFD application. Each symbol
181 is inspected in turn, and a decision made (using the
182 @code{sclass} field) about the various flags to set in the
183 @code{asymbol}. @xref{Symbols}. The generated canonical table
184 shares strings with the hidden internal symbol table.
186 Any linenumbers are read from the coff file too, and attached
187 to the symbols which own the functions the linenumbers belong to.
192 Writing a symbol to a coff file which didn't come from a coff
193 file will lose any debugging information. The @code{asymbol}
194 structure remembers the BFD from which the symbol was taken, and on
195 output the back end makes sure that the same destination target as
196 source target is present.
198 When the symbols have come from a coff file then all the
199 debugging information is preserved.
201 Symbol tables are provided for writing to the back end in a
202 vector of pointers to pointers. This allows applications like
203 the linker to accumulate and output large symbol tables
204 without having to do too much byte copying.
206 This function runs through the provided symbol table and
207 patches each symbol marked as a file place holder
208 (@code{C_FILE}) to point to the next file place holder in the
209 list. It also marks each @code{offset} field in the list with
210 the offset from the first symbol of the current symbol.
212 Another function of this procedure is to turn the canonical
213 value form of BFD into the form used by coff. Internally, BFD
214 expects symbol values to be offsets from a section base; so a
215 symbol physically at 0x120, but in a section starting at
216 0x100, would have the value 0x20. Coff expects symbols to
217 contain their final value, so symbols have their values
218 changed at this point to reflect their sum with their owning
219 section. This transformation uses the
220 <<output_section>> field of the @code{asymbol}'s
221 @code{asection} @xref{Sections}.
223 o <<coff_mangle_symbols>>
225 This routine runs though the provided symbol table and uses
226 the offsets generated by the previous pass and the pointers
227 generated when the symbol table was read in to create the
228 structured hierachy required by coff. It changes each pointer
229 to a symbol into the index into the symbol table of the asymbol.
231 o <<coff_write_symbols>>
233 This routine runs through the symbol table and patches up the
234 symbols from their internal form into the coff way, calls the
235 bit twiddlers, and writes out the table to the file.
244 The hidden information for an <<asymbol>> is described in a
245 <<combined_entry_type>>:
249 .typedef struct coff_ptr_struct
252 . {* Remembers the offset from the first symbol in the file for
253 . this symbol. Generated by coff_renumber_symbols. *}
254 .unsigned int offset;
256 . {* Should the value of this symbol be renumbered. Used for
257 . XCOFF C_BSTAT symbols. Set by coff_slurp_symbol_table. *}
258 .unsigned int fix_value : 1;
260 . {* Should the tag field of this symbol be renumbered.
261 . Created by coff_pointerize_aux. *}
262 .unsigned int fix_tag : 1;
264 . {* Should the endidx field of this symbol be renumbered.
265 . Created by coff_pointerize_aux. *}
266 .unsigned int fix_end : 1;
268 . {* Should the x_csect.x_scnlen field be renumbered.
269 . Created by coff_pointerize_aux. *}
270 .unsigned int fix_scnlen : 1;
272 . {* Fix up an XCOFF C_BINCL/C_EINCL symbol. The value is the
273 . index into the line number entries. Set by
274 . coff_slurp_symbol_table. *}
275 .unsigned int fix_line : 1;
277 . {* The container for the symbol structure as read and translated
281 . union internal_auxent auxent;
282 . struct internal_syment syment;
284 .} combined_entry_type;
287 .{* Each canonical asymbol really looks like this: *}
289 .typedef struct coff_symbol_struct
291 . {* The actual symbol which the rest of BFD works with *}
294 . {* A pointer to the hidden information for this symbol *}
295 .combined_entry_type *native;
297 . {* A pointer to the linenumber information for this symbol *}
298 .struct lineno_cache_entry *lineno;
300 . {* Have the line numbers been relocated yet ? *}
301 .boolean done_lineno;
310 #include "coffswap.h"
313 #define STRING_SIZE_SIZE (4)
315 static long sec_to_styp_flags
PARAMS ((const char *, flagword
));
316 static flagword styp_to_sec_flags
317 PARAMS ((bfd
*, PTR
, const char *, asection
*));
318 static boolean coff_bad_format_hook
PARAMS ((bfd
*, PTR
));
319 static void coff_set_custom_section_alignment
320 PARAMS ((bfd
*, asection
*, const struct coff_section_alignment_entry
*,
321 const unsigned int));
322 static boolean coff_new_section_hook
PARAMS ((bfd
*, asection
*));
323 static boolean coff_set_arch_mach_hook
PARAMS ((bfd
*, PTR
));
324 static boolean coff_write_relocs
PARAMS ((bfd
*, int));
325 static boolean coff_set_flags
326 PARAMS ((bfd
*, unsigned int *, unsigned short *));
327 static boolean coff_set_arch_mach
328 PARAMS ((bfd
*, enum bfd_architecture
, unsigned long));
329 static boolean coff_compute_section_file_positions
PARAMS ((bfd
*));
330 static boolean coff_write_object_contents
PARAMS ((bfd
*));
331 static boolean coff_set_section_contents
332 PARAMS ((bfd
*, asection
*, PTR
, file_ptr
, bfd_size_type
));
333 static PTR buy_and_read
PARAMS ((bfd
*, file_ptr
, int, size_t));
334 static boolean coff_slurp_line_table
PARAMS ((bfd
*, asection
*));
335 static boolean coff_slurp_symbol_table
PARAMS ((bfd
*));
336 static enum coff_symbol_classification coff_classify_symbol
337 PARAMS ((bfd
*, struct internal_syment
*));
338 static boolean coff_slurp_reloc_table
PARAMS ((bfd
*, asection
*, asymbol
**));
339 static long coff_canonicalize_reloc
340 PARAMS ((bfd
*, asection
*, arelent
**, asymbol
**));
341 #ifndef coff_mkobject_hook
342 static PTR coff_mkobject_hook
PARAMS ((bfd
*, PTR
, PTR
));
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(). */
355 sec_to_styp_flags (sec_name
, sec_flags
)
356 CONST
char *sec_name
;
361 if (!strcmp (sec_name
, _TEXT
))
363 styp_flags
= STYP_TEXT
;
365 else if (!strcmp (sec_name
, _DATA
))
367 styp_flags
= STYP_DATA
;
369 else if (!strcmp (sec_name
, _BSS
))
371 styp_flags
= STYP_BSS
;
374 else if (!strcmp (sec_name
, _COMMENT
))
376 styp_flags
= STYP_INFO
;
377 #endif /* _COMMENT */
380 else if (!strcmp (sec_name
, _LIB
))
382 styp_flags
= STYP_LIB
;
386 else if (!strcmp (sec_name
, _LIT
))
388 styp_flags
= STYP_LIT
;
391 else if (!strcmp (sec_name
, ".debug"))
394 styp_flags
= STYP_DEBUG
;
396 styp_flags
= STYP_INFO
;
399 else if (!strncmp (sec_name
, ".stab", 5))
401 styp_flags
= STYP_INFO
;
404 else if (!strcmp (sec_name
, _PAD
))
406 styp_flags
= STYP_PAD
;
408 else if (!strcmp (sec_name
, _LOADER
))
410 styp_flags
= STYP_LOADER
;
413 /* Try and figure out what it should be */
414 else if (sec_flags
& SEC_CODE
)
416 styp_flags
= STYP_TEXT
;
418 else if (sec_flags
& SEC_DATA
)
420 styp_flags
= STYP_DATA
;
422 else if (sec_flags
& SEC_READONLY
)
424 #ifdef STYP_LIT /* 29k readonly text/data section */
425 styp_flags
= STYP_LIT
;
427 styp_flags
= STYP_TEXT
;
428 #endif /* STYP_LIT */
430 else if (sec_flags
& SEC_LOAD
)
432 styp_flags
= STYP_TEXT
;
434 else if (sec_flags
& SEC_ALLOC
)
436 styp_flags
= STYP_BSS
;
440 if ((sec_flags
& (SEC_NEVER_LOAD
| SEC_COFF_SHARED_LIBRARY
)) != 0)
441 styp_flags
|= STYP_NOLOAD
;
447 #else /* COFF_WITH_PE */
449 /* The PE version; see above for the general comments. The non-PE
450 case seems to be more guessing, and breaks PE format; specifically,
451 .rdata is readonly, but it sure ain't text. Really, all this
452 should be set up properly in gas (or whatever assembler is in use),
453 and honor whatever objcopy/strip, etc. sent us as input. */
456 sec_to_styp_flags (sec_name
, sec_flags
)
457 const char *sec_name ATTRIBUTE_UNUSED
;
462 /* caution: there are at least three groups of symbols that have
463 very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
464 SEC_* are the BFD internal flags, used for generic BFD
465 information. STYP_* are the COFF section flags which appear in
466 COFF files. IMAGE_SCN_* are the PE section flags which appear in
467 PE files. The STYP_* flags and the IMAGE_SCN_* flags overlap,
468 but there are more IMAGE_SCN_* flags. */
473 if ((sec_flags
& SEC_CODE
) != 0)
474 styp_flags
|= IMAGE_SCN_CNT_CODE
;
475 if ((sec_flags
& SEC_DATA
) != 0)
476 styp_flags
|= IMAGE_SCN_CNT_INITIALIZED_DATA
;
477 if ((sec_flags
& SEC_ALLOC
) != 0 && (sec_flags
& SEC_LOAD
) == 0)
478 styp_flags
|= IMAGE_SCN_CNT_UNINITIALIZED_DATA
; /* ==STYP_BSS */
480 /* skip CONSTRUCTOR */
483 if ((sec_flags
& (SEC_NEVER_LOAD
| SEC_COFF_SHARED_LIBRARY
)) != 0)
484 styp_flags
|= STYP_NOLOAD
;
486 if ((sec_flags
& SEC_IS_COMMON
) != 0)
487 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
488 if ((sec_flags
& SEC_DEBUGGING
) != 0)
489 styp_flags
|= IMAGE_SCN_MEM_DISCARDABLE
;
490 if ((sec_flags
& SEC_EXCLUDE
) != 0)
491 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
492 if ((sec_flags
& SEC_NEVER_LOAD
) != 0)
493 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
496 if (sec_flags
& SEC_LINK_ONCE
)
497 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
498 /* skip LINK_DUPLICATES */
499 /* skip LINKER_CREATED */
501 /* For now, the read/write bits are mapped onto SEC_READONLY, even
502 though the semantics don't quite match. The bits from the input
503 are retained in pei_section_data(abfd, section)->pe_flags */
505 styp_flags
|= IMAGE_SCN_MEM_READ
; /* always readable. */
506 if ((sec_flags
& SEC_READONLY
) == 0)
507 styp_flags
|= IMAGE_SCN_MEM_WRITE
; /* Invert READONLY for write */
508 if (sec_flags
& SEC_CODE
)
509 styp_flags
|= IMAGE_SCN_MEM_EXECUTE
; /* CODE->EXECUTE */
510 if (sec_flags
& SEC_SHARED
)
511 styp_flags
|= IMAGE_SCN_MEM_SHARED
; /* Shared remains meaningful */
516 #endif /* COFF_WITH_PE */
518 /* Return a word with SEC_* flags set to represent the incoming STYP_*
519 flags (from scnhdr.s_flags). The inverse of this function is
520 sec_to_styp_flags(). NOTE: If you add to/change this routine, you
521 should probably mirror the changes in sec_to_styp_flags(). */
526 styp_to_sec_flags (abfd
, hdr
, name
, section
)
527 bfd
*abfd ATTRIBUTE_UNUSED
;
530 asection
*section ATTRIBUTE_UNUSED
;
532 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
533 long styp_flags
= internal_s
->s_flags
;
534 flagword sec_flags
= 0;
537 if (styp_flags
& STYP_NOLOAD
)
539 sec_flags
|= SEC_NEVER_LOAD
;
541 #endif /* STYP_NOLOAD */
543 /* For 386 COFF, at least, an unloadable text or data section is
544 actually a shared library section. */
545 if (styp_flags
& STYP_TEXT
)
547 if (sec_flags
& SEC_NEVER_LOAD
)
548 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
550 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
552 else if (styp_flags
& STYP_DATA
)
554 if (sec_flags
& SEC_NEVER_LOAD
)
555 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
557 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
559 else if (styp_flags
& STYP_BSS
)
561 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
562 if (sec_flags
& SEC_NEVER_LOAD
)
563 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
566 sec_flags
|= SEC_ALLOC
;
568 else if (styp_flags
& STYP_INFO
)
570 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
571 defined. coff_compute_section_file_positions uses
572 COFF_PAGE_SIZE to ensure that the low order bits of the
573 section VMA and the file offset match. If we don't know
574 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
575 and demand page loading of the file will fail. */
576 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
577 sec_flags
|= SEC_DEBUGGING
;
580 else if (styp_flags
& STYP_PAD
)
584 else if (strcmp (name
, _TEXT
) == 0)
586 if (sec_flags
& SEC_NEVER_LOAD
)
587 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
589 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
591 else if (strcmp (name
, _DATA
) == 0)
593 if (sec_flags
& SEC_NEVER_LOAD
)
594 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
596 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
598 else if (strcmp (name
, _BSS
) == 0)
600 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
601 if (sec_flags
& SEC_NEVER_LOAD
)
602 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
605 sec_flags
|= SEC_ALLOC
;
607 else if (strcmp (name
, ".debug") == 0
609 || strcmp (name
, _COMMENT
) == 0
611 || strncmp (name
, ".stab", 5) == 0)
613 #ifdef COFF_PAGE_SIZE
614 sec_flags
|= SEC_DEBUGGING
;
618 else if (strcmp (name
, _LIB
) == 0)
622 else if (strcmp (name
, _LIT
) == 0)
624 sec_flags
= SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
629 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
632 #ifdef STYP_LIT /* A29k readonly text/data section type */
633 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
635 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
637 #endif /* STYP_LIT */
638 #ifdef STYP_OTHER_LOAD /* Other loaded sections */
639 if (styp_flags
& STYP_OTHER_LOAD
)
641 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
643 #endif /* STYP_SDATA */
645 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
646 /* As a GNU extension, if the name begins with .gnu.linkonce, we
647 only link a single copy of the section. This is used to support
648 g++. g++ will emit each template expansion in its own section.
649 The symbols will be defined as weak, so that multiple definitions
650 are permitted. The GNU linker extension is to actually discard
651 all but one of the sections. */
652 if (strncmp (name
, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
653 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
659 #else /* COFF_WITH_PE */
661 /* The PE version; see above for the general comments.
663 Since to set the SEC_LINK_ONCE and associated flags, we have to
664 look at the symbol table anyway, we return the symbol table index
665 of the symbol being used as the COMDAT symbol. This is admittedly
666 ugly, but there's really nowhere else that we have access to the
667 required information. FIXME: Is the COMDAT symbol index used for
668 any purpose other than objdump? */
671 styp_to_sec_flags (abfd
, hdr
, name
, section
)
672 bfd
*abfd ATTRIBUTE_UNUSED
;
677 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
678 long styp_flags
= internal_s
->s_flags
;
679 flagword sec_flags
= 0;
681 if (styp_flags
& STYP_DSECT
)
682 abort (); /* Don't know what to do */
683 #ifdef SEC_NEVER_LOAD
684 if (styp_flags
& STYP_NOLOAD
)
685 sec_flags
|= SEC_NEVER_LOAD
;
687 if (styp_flags
& STYP_GROUP
)
688 abort (); /* Don't know what to do */
689 /* skip IMAGE_SCN_TYPE_NO_PAD */
690 if (styp_flags
& STYP_COPY
)
691 abort (); /* Don't know what to do */
692 if (styp_flags
& IMAGE_SCN_CNT_CODE
)
693 sec_flags
|= SEC_CODE
| SEC_ALLOC
| SEC_LOAD
;
694 if (styp_flags
& IMAGE_SCN_CNT_INITIALIZED_DATA
)
695 sec_flags
|= SEC_DATA
| SEC_ALLOC
| SEC_LOAD
;
696 if (styp_flags
& IMAGE_SCN_CNT_UNINITIALIZED_DATA
)
697 sec_flags
|= SEC_ALLOC
;
698 if (styp_flags
& IMAGE_SCN_LNK_OTHER
)
699 abort (); /* Don't know what to do */
700 if (styp_flags
& IMAGE_SCN_LNK_INFO
)
702 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
703 defined. coff_compute_section_file_positions uses
704 COFF_PAGE_SIZE to ensure that the low order bits of the
705 section VMA and the file offset match. If we don't know
706 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
707 and demand page loading of the file will fail. */
708 #ifdef COFF_PAGE_SIZE
709 sec_flags
|= SEC_DEBUGGING
;
712 if (styp_flags
& STYP_OVER
)
713 abort (); /* Don't know what to do */
714 if (styp_flags
& IMAGE_SCN_LNK_REMOVE
)
715 sec_flags
|= SEC_EXCLUDE
;
717 if (styp_flags
& IMAGE_SCN_MEM_SHARED
)
718 sec_flags
|= SEC_SHARED
;
719 /* COMDAT: see below */
720 if (styp_flags
& IMAGE_SCN_MEM_DISCARDABLE
)
721 sec_flags
|= SEC_DEBUGGING
;
722 if (styp_flags
& IMAGE_SCN_MEM_NOT_CACHED
)
723 abort ();/* Don't know what to do */
724 if (styp_flags
& IMAGE_SCN_MEM_NOT_PAGED
)
725 abort (); /* Don't know what to do */
727 /* We infer from the distinct read/write/execute bits the settings
728 of some of the bfd flags; the actual values, should we need them,
729 are also in pei_section_data (abfd, section)->pe_flags. */
731 if (styp_flags
& IMAGE_SCN_MEM_EXECUTE
)
732 sec_flags
|= SEC_CODE
; /* Probably redundant */
733 /* IMAGE_SCN_MEM_READ is simply ignored, assuming it always to be true. */
734 if ((styp_flags
& IMAGE_SCN_MEM_WRITE
) == 0)
735 sec_flags
|= SEC_READONLY
;
737 /* COMDAT gets very special treatment. */
738 if (styp_flags
& IMAGE_SCN_LNK_COMDAT
)
740 sec_flags
|= SEC_LINK_ONCE
;
742 /* Unfortunately, the PE format stores essential information in
743 the symbol table, of all places. We need to extract that
744 information now, so that objdump and the linker will know how
745 to handle the section without worrying about the symbols. We
746 can't call slurp_symtab, because the linker doesn't want the
749 /* COMDAT sections are special. The first symbol is the section
750 symbol, which tells what kind of COMDAT section it is. The
751 second symbol is the "comdat symbol" - the one with the
752 unique name. GNU uses the section symbol for the unique
753 name; MS uses ".text" for every comdat section. Sigh. - DJ */
755 /* This is not mirrored in sec_to_styp_flags(), but there
756 doesn't seem to be a need to, either, and it would at best be
759 if (_bfd_coff_get_external_symbols (abfd
))
761 bfd_byte
*esymstart
, *esym
, *esymend
;
765 esymstart
= esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
766 esymend
= esym
+ obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
768 while (esym
< esymend
)
770 struct internal_syment isym
;
771 char buf
[SYMNMLEN
+ 1];
774 bfd_coff_swap_sym_in (abfd
, (PTR
) esym
, (PTR
) &isym
);
776 if (sizeof (internal_s
->s_name
) > SYMNMLEN
)
778 /* This case implies that the matching symbol name
779 will be in the string table. */
783 if (isym
.n_scnum
== section
->target_index
)
785 /* According to the MSVC documentation, the first
786 TWO entries with the section # are both of
787 interest to us. The first one is the "section
788 symbol" (section name). The second is the comdat
789 symbol name. Here, we've found the first
790 qualifying entry; we distinguish it from the
791 second with a state flag.
793 In the case of gas-generated (at least until that
794 is fixed) .o files, it isn't necessarily the
795 second one. It may be some other later symbol.
797 Since gas also doesn't follow MS conventions and
798 emits the section similar to .text$<name>, where
799 <something> is the name we're looking for, we
800 distinguish the two as follows:
802 If the section name is simply a section name (no
803 $) we presume it's MS-generated, and look at
804 precisely the second symbol for the comdat name.
805 If the section name has a $, we assume it's
806 gas-generated, and look for <something> (whatever
807 follows the $) as the comdat symbol. */
809 /* All 3 branches use this */
810 symname
= _bfd_coff_internal_syment_name (abfd
, &isym
, buf
);
819 /* The first time we've seen the symbol. */
820 union internal_auxent aux
;
824 /* If it isn't the stuff we're expecting, die;
825 The MS documentation is vague, but it
826 appears that the second entry serves BOTH
827 as the comdat symbol and the defining
828 symbol record (either C_STAT or C_EXT,
829 possibly with an aux entry with debug
830 information if it's a function.) It
831 appears the only way to find the second one
832 is to count. (On Intel, they appear to be
833 adjacent, but on Alpha, they have been
836 Here, we think we've found the first one,
837 but there's some checking we can do to be
840 if (! (isym
.n_sclass
== C_STAT
841 && isym
.n_type
== T_NULL
842 && isym
.n_value
== 0))
845 /* FIXME LATER: MSVC generates section names
846 like .text for comdats. Gas generates
847 names like .text$foo__Fv (in the case of a
848 function). See comment above for more. */
850 if (strcmp (name
, symname
) != 0)
853 /* This is the section symbol. */
855 bfd_coff_swap_aux_in (abfd
, (PTR
) (esym
+ bfd_coff_symesz (abfd
)),
856 isym
.n_type
, isym
.n_sclass
,
857 0, isym
.n_numaux
, (PTR
) &aux
);
859 target_name
= strchr (name
, '$');
860 if (target_name
!= NULL
)
868 /* FIXME: Microsoft uses NODUPLICATES and
869 ASSOCIATIVE, but gnu uses ANY and
870 SAME_SIZE. Unfortunately, gnu doesn't do
871 the comdat symbols right. So, until we can
872 fix it to do the right thing, we are
873 temporarily disabling comdats for the MS
874 types (they're used in DLLs and C++, but we
875 don't support *their* C++ libraries anyway
878 /* Cygwin does not follow the MS style, and
879 uses ANY and SAME_SIZE where NODUPLICATES
880 and ASSOCIATIVE should be used. For
881 Interix, we just do the right thing up
884 switch (aux
.x_scn
.x_comdat
)
886 case IMAGE_COMDAT_SELECT_NODUPLICATES
:
887 #ifdef STRICT_PE_FORMAT
888 sec_flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
890 sec_flags
&= ~SEC_LINK_ONCE
;
894 case IMAGE_COMDAT_SELECT_ANY
:
895 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
898 case IMAGE_COMDAT_SELECT_SAME_SIZE
:
899 sec_flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
902 case IMAGE_COMDAT_SELECT_EXACT_MATCH
:
903 /* Not yet fully implemented ??? */
904 sec_flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
907 /* debug$S gets this case; other
910 /* There may be no symbol... we'll search
911 the whole table... Is this the right
912 place to play this game? Or should we do
913 it when reading it in. */
914 case IMAGE_COMDAT_SELECT_ASSOCIATIVE
:
915 #ifdef STRICT_PE_FORMAT
916 /* FIXME: This is not currently implemented. */
917 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
919 sec_flags
&= ~SEC_LINK_ONCE
;
923 default: /* 0 means "no symbol" */
924 /* debug$F gets this case; other
926 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
933 /* Gas mode: the first matching on partial name. */
935 #ifndef TARGET_UNDERSCORE
936 #define TARGET_UNDERSCORE 0
938 /* Is this the name we're looking for? */
939 if (strcmp (target_name
,
940 symname
+ (TARGET_UNDERSCORE
? 1 : 0)) != 0)
942 /* Not the name we're looking for */
943 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
948 /* MSVC mode: the lexically second symbol (or
949 drop through from the above). */
953 /* This must the the second symbol with the
954 section #. It is the actual symbol name.
955 Intel puts the two adjacent, but Alpha (at
956 least) spreads them out. */
959 bfd_alloc (abfd
, sizeof (struct bfd_comdat_info
));
960 if (section
->comdat
== NULL
)
962 section
->comdat
->symbol
=
963 (esym
- esymstart
) / bfd_coff_symesz (abfd
);
965 newname
= bfd_alloc (abfd
, strlen (symname
) + 1);
969 strcpy (newname
, symname
);
970 section
->comdat
->name
= newname
;
978 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
984 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
985 /* As a GNU extension, if the name begins with .gnu.linkonce, we
986 only link a single copy of the section. This is used to support
987 g++. g++ will emit each template expansion in its own section.
988 The symbols will be defined as weak, so that multiple definitions
989 are permitted. The GNU linker extension is to actually discard
990 all but one of the sections. */
991 if (strncmp (name
, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
992 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
998 #endif /* COFF_WITH_PE */
1000 #define get_index(symbol) ((symbol)->udata.i)
1004 bfd_coff_backend_data
1008 .{* COFF symbol classifications. *}
1010 .enum coff_symbol_classification
1012 . {* Global symbol. *}
1013 . COFF_SYMBOL_GLOBAL,
1014 . {* Common symbol. *}
1015 . COFF_SYMBOL_COMMON,
1016 . {* Undefined symbol. *}
1017 . COFF_SYMBOL_UNDEFINED,
1018 . {* Local symbol. *}
1019 . COFF_SYMBOL_LOCAL,
1020 . {* PE section symbol. *}
1021 . COFF_SYMBOL_PE_SECTION
1024 Special entry points for gdb to swap in coff symbol table parts:
1027 . void (*_bfd_coff_swap_aux_in) PARAMS ((
1036 . void (*_bfd_coff_swap_sym_in) PARAMS ((
1041 . void (*_bfd_coff_swap_lineno_in) PARAMS ((
1047 Special entry points for gas to swap out coff parts:
1049 . unsigned int (*_bfd_coff_swap_aux_out) PARAMS ((
1058 . unsigned int (*_bfd_coff_swap_sym_out) PARAMS ((
1063 . unsigned int (*_bfd_coff_swap_lineno_out) PARAMS ((
1068 . unsigned int (*_bfd_coff_swap_reloc_out) PARAMS ((
1073 . unsigned int (*_bfd_coff_swap_filehdr_out) PARAMS ((
1078 . unsigned int (*_bfd_coff_swap_aouthdr_out) PARAMS ((
1083 . unsigned int (*_bfd_coff_swap_scnhdr_out) PARAMS ((
1089 Special entry points for generic COFF routines to call target
1090 dependent COFF routines:
1092 . unsigned int _bfd_filhsz;
1093 . unsigned int _bfd_aoutsz;
1094 . unsigned int _bfd_scnhsz;
1095 . unsigned int _bfd_symesz;
1096 . unsigned int _bfd_auxesz;
1097 . unsigned int _bfd_relsz;
1098 . unsigned int _bfd_linesz;
1099 . unsigned int _bfd_filnmlen;
1100 . boolean _bfd_coff_long_filenames;
1101 . boolean _bfd_coff_long_section_names;
1102 . unsigned int _bfd_coff_default_section_alignment_power;
1103 . void (*_bfd_coff_swap_filehdr_in) PARAMS ((
1107 . void (*_bfd_coff_swap_aouthdr_in) PARAMS ((
1111 . void (*_bfd_coff_swap_scnhdr_in) PARAMS ((
1115 . void (*_bfd_coff_swap_reloc_in) PARAMS ((
1119 . boolean (*_bfd_coff_bad_format_hook) PARAMS ((
1121 . PTR internal_filehdr));
1122 . boolean (*_bfd_coff_set_arch_mach_hook) PARAMS ((
1124 . PTR internal_filehdr));
1125 . PTR (*_bfd_coff_mkobject_hook) PARAMS ((
1127 . PTR internal_filehdr,
1128 . PTR internal_aouthdr));
1129 . flagword (*_bfd_styp_to_sec_flags_hook) PARAMS ((
1131 . PTR internal_scnhdr,
1133 . asection *section));
1134 . void (*_bfd_set_alignment_hook) PARAMS ((
1137 . PTR internal_scnhdr));
1138 . boolean (*_bfd_coff_slurp_symbol_table) PARAMS ((
1140 . boolean (*_bfd_coff_symname_in_debug) PARAMS ((
1142 . struct internal_syment *sym));
1143 . boolean (*_bfd_coff_pointerize_aux_hook) PARAMS ((
1145 . combined_entry_type *table_base,
1146 . combined_entry_type *symbol,
1147 . unsigned int indaux,
1148 . combined_entry_type *aux));
1149 . boolean (*_bfd_coff_print_aux) PARAMS ((
1152 . combined_entry_type *table_base,
1153 . combined_entry_type *symbol,
1154 . combined_entry_type *aux,
1155 . unsigned int indaux));
1156 . void (*_bfd_coff_reloc16_extra_cases) PARAMS ((
1158 . struct bfd_link_info *link_info,
1159 . struct bfd_link_order *link_order,
1162 . unsigned int *src_ptr,
1163 . unsigned int *dst_ptr));
1164 . int (*_bfd_coff_reloc16_estimate) PARAMS ((
1166 . asection *input_section,
1168 . unsigned int shrink,
1169 . struct bfd_link_info *link_info));
1170 . enum coff_symbol_classification (*_bfd_coff_classify_symbol) PARAMS ((
1172 . struct internal_syment *));
1173 . boolean (*_bfd_coff_compute_section_file_positions) PARAMS ((
1175 . boolean (*_bfd_coff_start_final_link) PARAMS ((
1177 . struct bfd_link_info *info));
1178 . boolean (*_bfd_coff_relocate_section) PARAMS ((
1180 . struct bfd_link_info *info,
1182 . asection *input_section,
1183 . bfd_byte *contents,
1184 . struct internal_reloc *relocs,
1185 . struct internal_syment *syms,
1186 . asection **sections));
1187 . reloc_howto_type *(*_bfd_coff_rtype_to_howto) PARAMS ((
1190 . struct internal_reloc *rel,
1191 . struct coff_link_hash_entry *h,
1192 . struct internal_syment *sym,
1193 . bfd_vma *addendp));
1194 . boolean (*_bfd_coff_adjust_symndx) PARAMS ((
1196 . struct bfd_link_info *info,
1199 . struct internal_reloc *reloc,
1200 . boolean *adjustedp));
1201 . boolean (*_bfd_coff_link_add_one_symbol) PARAMS ((
1202 . struct bfd_link_info *info,
1206 . asection *section,
1208 . const char *string,
1211 . struct bfd_link_hash_entry **hashp));
1213 . boolean (*_bfd_coff_link_output_has_begun) PARAMS ((
1215 . struct coff_final_link_info * pfinfo));
1216 . boolean (*_bfd_coff_final_link_postscript) PARAMS ((
1218 . struct coff_final_link_info * pfinfo));
1220 .} bfd_coff_backend_data;
1222 .#define coff_backend_info(abfd) ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1224 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1225 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1227 .#define bfd_coff_swap_sym_in(a,e,i) \
1228 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1230 .#define bfd_coff_swap_lineno_in(a,e,i) \
1231 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1233 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1234 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1236 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1237 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1239 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1240 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1242 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1243 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1245 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1246 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1248 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1249 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1251 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1252 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1254 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1255 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1256 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1257 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1258 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1259 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1260 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1261 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1262 .#define bfd_coff_long_filenames(abfd) (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1263 .#define bfd_coff_long_section_names(abfd) \
1264 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1265 .#define bfd_coff_default_section_alignment_power(abfd) \
1266 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1267 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1268 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1270 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1271 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1273 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1274 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1276 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1277 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1279 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1280 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1282 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1283 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1284 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1285 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook) (abfd, filehdr, aouthdr))
1287 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section)\
1288 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1289 . (abfd, scnhdr, name, section))
1291 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1292 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1294 .#define bfd_coff_slurp_symbol_table(abfd)\
1295 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1297 .#define bfd_coff_symname_in_debug(abfd, sym)\
1298 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1300 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1301 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1302 . (abfd, file, base, symbol, aux, indaux))
1304 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)\
1305 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1306 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1308 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1309 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1310 . (abfd, section, reloc, shrink, link_info))
1312 .#define bfd_coff_classify_symbol(abfd, sym)\
1313 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1316 .#define bfd_coff_compute_section_file_positions(abfd)\
1317 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1320 .#define bfd_coff_start_final_link(obfd, info)\
1321 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1323 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1324 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1325 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1326 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1327 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1328 . (abfd, sec, rel, h, sym, addendp))
1329 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1330 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1331 . (obfd, info, ibfd, sec, rel, adjustedp))
1332 .#define bfd_coff_link_add_one_symbol(info,abfd,name,flags,section,value,string,cp,coll,hashp)\
1333 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1334 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1336 .#define bfd_coff_link_output_has_begun(a,p) \
1337 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a,p))
1338 .#define bfd_coff_final_link_postscript(a,p) \
1339 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a,p))
1343 /* See whether the magic number matches. */
1346 coff_bad_format_hook (abfd
, filehdr
)
1347 bfd
* abfd ATTRIBUTE_UNUSED
;
1350 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1352 if (BADMAG (*internal_f
))
1355 /* if the optional header is NULL or not the correct size then
1356 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1357 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1358 optional header is of a different size.
1360 But the mips keeps extra stuff in it's opthdr, so dont check
1364 #if defined(M88) || defined(I960)
1365 if (internal_f
->f_opthdr
!= 0 && bfd_coff_aoutsz (abfd
) != internal_f
->f_opthdr
)
1372 /* Check whether this section uses an alignment other than the
1376 coff_set_custom_section_alignment (abfd
, section
, alignment_table
, table_size
)
1377 bfd
*abfd ATTRIBUTE_UNUSED
;
1379 const struct coff_section_alignment_entry
*alignment_table
;
1380 const unsigned int table_size
;
1382 const unsigned int default_alignment
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1385 for (i
= 0; i
< table_size
; ++i
)
1387 const char *secname
= bfd_get_section_name (abfd
, section
);
1388 if (alignment_table
[i
].comparison_length
== (unsigned int) -1
1389 ? strcmp (alignment_table
[i
].name
, secname
) == 0
1390 : strncmp (alignment_table
[i
].name
, secname
,
1391 alignment_table
[i
].comparison_length
) == 0)
1394 if (i
>= table_size
)
1397 if (alignment_table
[i
].default_alignment_min
!= COFF_ALIGNMENT_FIELD_EMPTY
1398 && default_alignment
< alignment_table
[i
].default_alignment_min
)
1401 if (alignment_table
[i
].default_alignment_max
!= COFF_ALIGNMENT_FIELD_EMPTY
1402 && default_alignment
> alignment_table
[i
].default_alignment_max
)
1405 section
->alignment_power
= alignment_table
[i
].alignment_power
;
1408 /* Custom section alignment records. */
1410 static const struct coff_section_alignment_entry
1411 coff_section_alignment_table
[] =
1413 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1414 COFF_SECTION_ALIGNMENT_ENTRIES
,
1416 /* There must not be any gaps between .stabstr sections. */
1417 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1418 1, COFF_ALIGNMENT_FIELD_EMPTY
, 0 },
1419 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1420 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1421 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1422 /* Similarly for the .ctors and .dtors sections. */
1423 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1424 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1425 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1426 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 }
1429 static const unsigned int coff_section_alignment_table_size
=
1430 sizeof coff_section_alignment_table
/ sizeof coff_section_alignment_table
[0];
1432 /* Initialize a section structure with information peculiar to this
1433 particular implementation of COFF. */
1436 coff_new_section_hook (abfd
, section
)
1440 combined_entry_type
*native
;
1442 section
->alignment_power
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1445 if (xcoff_data (abfd
)->text_align_power
!= 0
1446 && strcmp (bfd_get_section_name (abfd
, section
), ".text") == 0)
1447 section
->alignment_power
= xcoff_data (abfd
)->text_align_power
;
1448 if (xcoff_data (abfd
)->data_align_power
!= 0
1449 && strcmp (bfd_get_section_name (abfd
, section
), ".data") == 0)
1450 section
->alignment_power
= xcoff_data (abfd
)->data_align_power
;
1453 /* Allocate aux records for section symbols, to store size and
1456 @@ The 10 is a guess at a plausible maximum number of aux entries
1457 (but shouldn't be a constant). */
1458 native
= ((combined_entry_type
*)
1459 bfd_zalloc (abfd
, sizeof (combined_entry_type
) * 10));
1463 /* We don't need to set up n_name, n_value, or n_scnum in the native
1464 symbol information, since they'll be overriden by the BFD symbol
1465 anyhow. However, we do need to set the type and storage class,
1466 in case this symbol winds up getting written out. The value 0
1467 for n_numaux is already correct. */
1469 native
->u
.syment
.n_type
= T_NULL
;
1470 native
->u
.syment
.n_sclass
= C_STAT
;
1472 coffsymbol (section
->symbol
)->native
= native
;
1474 coff_set_custom_section_alignment (abfd
, section
,
1475 coff_section_alignment_table
,
1476 coff_section_alignment_table_size
);
1481 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1483 /* Set the alignment of a BFD section. */
1485 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1488 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1489 bfd
* abfd ATTRIBUTE_UNUSED
;
1493 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1497 /* Extract ALIGN from 2**ALIGN stored in section header */
1498 for (i
= 0; i
< 32; i
++)
1499 if ((1 << i
) >= hdr
->s_align
)
1503 /* TI tools hijack bits 8-11 for the alignment */
1504 i
= (hdr
->s_flags
>> 8) & 0xF ;
1506 section
->alignment_power
= i
;
1509 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1512 /* a couple of macros to help setting the alignment power field */
1513 #define ALIGN_SET(field,x,y) \
1514 if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x )\
1516 section->alignment_power = y;\
1519 #define ELIFALIGN_SET(field,x,y) \
1520 else if (( (field) & IMAGE_SCN_ALIGN_64BYTES) == x ) \
1522 section->alignment_power = y;\
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
;
1535 ALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_64BYTES
, 6)
1536 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_32BYTES
, 5)
1537 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_16BYTES
, 4)
1538 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_8BYTES
, 3)
1539 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_4BYTES
, 2)
1540 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_2BYTES
, 1)
1541 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_1BYTES
, 0)
1543 /* In a PE image file, the s_paddr field holds the virtual size of a
1544 section, while the s_size field holds the raw size. We also keep
1545 the original section flag value, since not every bit can be
1546 mapped onto a generic BFD section bit. */
1547 if (coff_section_data (abfd
, section
) == NULL
)
1549 section
->used_by_bfd
=
1550 (PTR
) bfd_zalloc (abfd
, sizeof (struct coff_section_tdata
));
1551 if (section
->used_by_bfd
== NULL
)
1553 /* FIXME: Return error. */
1557 if (pei_section_data (abfd
, section
) == NULL
)
1559 coff_section_data (abfd
, section
)->tdata
=
1560 (PTR
) bfd_zalloc (abfd
, sizeof (struct pei_section_tdata
));
1561 if (coff_section_data (abfd
, section
)->tdata
== NULL
)
1563 /* FIXME: Return error. */
1567 pei_section_data (abfd
, section
)->virt_size
= hdr
->s_paddr
;
1568 pei_section_data (abfd
, section
)->pe_flags
= hdr
->s_flags
;
1570 section
->lma
= hdr
->s_vaddr
;
1573 #undef ELIFALIGN_SET
1575 #else /* ! COFF_WITH_PE */
1578 /* We grossly abuse this function to handle XCOFF overflow headers.
1579 When we see one, we correct the reloc and line number counts in the
1580 real header, and remove the section we just created. */
1582 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1585 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1590 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1594 if ((hdr
->s_flags
& STYP_OVRFLO
) == 0)
1597 real_sec
= coff_section_from_bfd_index (abfd
, hdr
->s_nreloc
);
1598 if (real_sec
== NULL
)
1601 real_sec
->reloc_count
= hdr
->s_paddr
;
1602 real_sec
->lineno_count
= hdr
->s_vaddr
;
1604 for (ps
= &abfd
->sections
; *ps
!= NULL
; ps
= &(*ps
)->next
)
1609 --abfd
->section_count
;
1615 #else /* ! RS6000COFF_C */
1617 #define coff_set_alignment_hook \
1618 ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
1620 #endif /* ! RS6000COFF_C */
1621 #endif /* ! COFF_WITH_PE */
1622 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1624 #ifndef coff_mkobject
1626 static boolean coff_mkobject
PARAMS ((bfd
*));
1629 coff_mkobject (abfd
)
1632 coff_data_type
*coff
;
1634 abfd
->tdata
.coff_obj_data
= (struct coff_tdata
*) bfd_zalloc (abfd
, sizeof (coff_data_type
));
1635 if (abfd
->tdata
.coff_obj_data
== 0)
1637 coff
= coff_data (abfd
);
1638 coff
->symbols
= (coff_symbol_type
*) NULL
;
1639 coff
->conversion_table
= (unsigned int *) NULL
;
1640 coff
->raw_syments
= (struct coff_ptr_struct
*) NULL
;
1641 coff
->relocbase
= 0;
1642 coff
->local_toc_sym_map
= 0;
1644 /* make_abs_section(abfd);*/
1650 /* Create the COFF backend specific information. */
1651 #ifndef coff_mkobject_hook
1653 coff_mkobject_hook (abfd
, filehdr
, aouthdr
)
1656 PTR aouthdr ATTRIBUTE_UNUSED
;
1658 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1659 coff_data_type
*coff
;
1661 if (coff_mkobject (abfd
) == false)
1664 coff
= coff_data (abfd
);
1666 coff
->sym_filepos
= internal_f
->f_symptr
;
1668 /* These members communicate important constants about the symbol
1669 table to GDB's symbol-reading code. These `constants'
1670 unfortunately vary among coff implementations... */
1671 coff
->local_n_btmask
= N_BTMASK
;
1672 coff
->local_n_btshft
= N_BTSHFT
;
1673 coff
->local_n_tmask
= N_TMASK
;
1674 coff
->local_n_tshift
= N_TSHIFT
;
1675 coff
->local_symesz
= bfd_coff_symesz (abfd
);
1676 coff
->local_auxesz
= bfd_coff_auxesz (abfd
);
1677 coff
->local_linesz
= bfd_coff_linesz (abfd
);
1679 coff
->timestamp
= internal_f
->f_timdat
;
1681 obj_raw_syment_count (abfd
) =
1682 obj_conv_table_size (abfd
) =
1683 internal_f
->f_nsyms
;
1686 if ((internal_f
->f_flags
& F_SHROBJ
) != 0)
1687 abfd
->flags
|= DYNAMIC
;
1688 if (aouthdr
!= NULL
&& internal_f
->f_opthdr
>= bfd_coff_aoutsz (abfd
))
1690 struct internal_aouthdr
*internal_a
=
1691 (struct internal_aouthdr
*) aouthdr
;
1692 struct xcoff_tdata
*xcoff
;
1694 xcoff
= xcoff_data (abfd
);
1695 xcoff
->full_aouthdr
= true;
1696 xcoff
->toc
= internal_a
->o_toc
;
1697 xcoff
->sntoc
= internal_a
->o_sntoc
;
1698 xcoff
->snentry
= internal_a
->o_snentry
;
1699 xcoff
->text_align_power
= internal_a
->o_algntext
;
1700 xcoff
->data_align_power
= internal_a
->o_algndata
;
1701 xcoff
->modtype
= internal_a
->o_modtype
;
1702 xcoff
->cputype
= internal_a
->o_cputype
;
1703 xcoff
->maxdata
= internal_a
->o_maxdata
;
1704 xcoff
->maxstack
= internal_a
->o_maxstack
;
1709 /* Set the flags field from the COFF header read in */
1710 if (! _bfd_coff_arm_set_private_flags (abfd
, internal_f
->f_flags
))
1715 /* FIXME: I'm not sure this is ever executed, since peicode.h
1716 defines coff_mkobject_hook. */
1717 if ((internal_f
->f_flags
& IMAGE_FILE_DEBUG_STRIPPED
) == 0)
1718 abfd
->flags
|= HAS_DEBUG
;
1725 /* Determine the machine architecture and type. FIXME: This is target
1726 dependent because the magic numbers are defined in the target
1727 dependent header files. But there is no particular need for this.
1728 If the magic numbers were moved to a separate file, this function
1729 would be target independent and would also be much more successful
1730 at linking together COFF files for different architectures. */
1733 coff_set_arch_mach_hook (abfd
, filehdr
)
1738 enum bfd_architecture arch
;
1739 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1742 switch (internal_f
->f_magic
)
1746 arch
= bfd_arch_powerpc
;
1747 machine
= 0; /* what does this mean? (krk) */
1753 case I386AIXMAGIC
: /* Danbury PS/2 AIX C Compiler */
1754 case LYNXCOFFMAGIC
: /* shadows the m68k Lynx number below, sigh */
1755 arch
= bfd_arch_i386
;
1759 #ifdef A29K_MAGIC_BIG
1760 case A29K_MAGIC_BIG
:
1761 case A29K_MAGIC_LITTLE
:
1762 arch
= bfd_arch_a29k
;
1768 arch
= bfd_arch_arm
;
1769 switch (internal_f
->f_flags
& F_ARM_ARCHITECTURE_MASK
)
1771 case F_ARM_2
: machine
= bfd_mach_arm_2
; break;
1772 case F_ARM_2a
: machine
= bfd_mach_arm_2a
; break;
1773 case F_ARM_3
: machine
= bfd_mach_arm_3
; break;
1775 case F_ARM_3M
: machine
= bfd_mach_arm_3M
; break;
1776 case F_ARM_4
: machine
= bfd_mach_arm_4
; break;
1777 case F_ARM_4T
: machine
= bfd_mach_arm_4T
; break;
1778 case F_ARM_5
: machine
= bfd_mach_arm_5
; break;
1785 #ifdef MC68KBCSMAGIC
1788 #ifdef APOLLOM68KMAGIC
1789 case APOLLOM68KMAGIC
:
1791 #ifdef LYNXCOFFMAGIC
1794 arch
= bfd_arch_m68k
;
1795 machine
= bfd_mach_m68020
;
1802 arch
= bfd_arch_m88k
;
1808 arch
= bfd_arch_z8k
;
1809 switch (internal_f
->f_flags
& F_MACHMASK
)
1812 machine
= bfd_mach_z8001
;
1815 machine
= bfd_mach_z8002
;
1824 arch
= bfd_arch_i860
;
1831 arch
= bfd_arch_i960
;
1832 switch (F_I960TYPE
& internal_f
->f_flags
)
1836 machine
= bfd_mach_i960_core
;
1839 machine
= bfd_mach_i960_kb_sb
;
1842 machine
= bfd_mach_i960_mc
;
1845 machine
= bfd_mach_i960_xa
;
1848 machine
= bfd_mach_i960_ca
;
1851 machine
= bfd_mach_i960_ka_sa
;
1854 machine
= bfd_mach_i960_jx
;
1857 machine
= bfd_mach_i960_hx
;
1871 if (xcoff_data (abfd
)->cputype
!= -1)
1872 cputype
= xcoff_data (abfd
)->cputype
& 0xff;
1875 /* We did not get a value from the a.out header. If the
1876 file has not been stripped, we may be able to get the
1877 architecture information from the first symbol, if it
1878 is a .file symbol. */
1879 if (obj_raw_syment_count (abfd
) == 0)
1884 struct internal_syment sym
;
1886 buf
= (bfd_byte
*) bfd_malloc (bfd_coff_symesz (abfd
));
1887 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
1888 || (bfd_read (buf
, 1, bfd_coff_symesz (abfd
), abfd
)
1889 != bfd_coff_symesz (abfd
)))
1894 coff_swap_sym_in (abfd
, (PTR
) buf
, (PTR
) &sym
);
1895 if (sym
.n_sclass
== C_FILE
)
1896 cputype
= sym
.n_type
& 0xff;
1903 /* FIXME: We don't handle all cases here. */
1909 /* PowerPC Macs use the same magic numbers as RS/6000
1910 (because that's how they were bootstrapped originally),
1911 but they are always PowerPC architecture. */
1912 arch
= bfd_arch_powerpc
;
1915 arch
= bfd_arch_rs6000
;
1917 #endif /* POWERMAC */
1921 arch
= bfd_arch_powerpc
;
1924 case 2: /* 64 bit PowerPC */
1925 arch
= bfd_arch_powerpc
;
1929 arch
= bfd_arch_powerpc
;
1933 arch
= bfd_arch_rs6000
;
1943 arch
= bfd_arch_we32k
;
1950 arch
= bfd_arch_h8300
;
1951 machine
= bfd_mach_h8300
;
1952 /* !! FIXME this probably isn't the right place for this */
1953 abfd
->flags
|= BFD_IS_RELAXABLE
;
1959 arch
= bfd_arch_h8300
;
1960 machine
= bfd_mach_h8300h
;
1961 /* !! FIXME this probably isn't the right place for this */
1962 abfd
->flags
|= BFD_IS_RELAXABLE
;
1968 arch
= bfd_arch_h8300
;
1969 machine
= bfd_mach_h8300s
;
1970 /* !! FIXME this probably isn't the right place for this */
1971 abfd
->flags
|= BFD_IS_RELAXABLE
;
1975 #ifdef SH_ARCH_MAGIC_BIG
1976 case SH_ARCH_MAGIC_BIG
:
1977 case SH_ARCH_MAGIC_LITTLE
:
1985 arch
= bfd_arch_h8500
;
1992 #ifdef LYNXCOFFMAGIC
1995 arch
= bfd_arch_sparc
;
2002 arch
= bfd_arch_tic30
;
2006 #ifdef TIC80_ARCH_MAGIC
2007 case TIC80_ARCH_MAGIC
:
2008 arch
= bfd_arch_tic80
;
2014 arch
= bfd_arch_mcore
;
2017 default: /* Unreadable input file type */
2018 arch
= bfd_arch_obscure
;
2022 bfd_default_set_arch_mach (abfd
, arch
, machine
);
2026 #ifdef SYMNAME_IN_DEBUG
2028 static boolean symname_in_debug_hook
2029 PARAMS ((bfd
*, struct internal_syment
*));
2032 symname_in_debug_hook (abfd
, sym
)
2033 bfd
* abfd ATTRIBUTE_UNUSED
;
2034 struct internal_syment
*sym
;
2036 return SYMNAME_IN_DEBUG (sym
) ? true : false;
2041 #define symname_in_debug_hook \
2042 (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
2048 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */
2050 static boolean coff_pointerize_aux_hook
2051 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
2052 unsigned int, combined_entry_type
*));
2056 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
2057 bfd
*abfd ATTRIBUTE_UNUSED
;
2058 combined_entry_type
*table_base
;
2059 combined_entry_type
*symbol
;
2060 unsigned int indaux
;
2061 combined_entry_type
*aux
;
2063 int class = symbol
->u
.syment
.n_sclass
;
2065 if ((class == C_EXT
|| class == C_HIDEXT
)
2066 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2068 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) == XTY_LD
)
2070 aux
->u
.auxent
.x_csect
.x_scnlen
.p
=
2071 table_base
+ aux
->u
.auxent
.x_csect
.x_scnlen
.l
;
2072 aux
->fix_scnlen
= 1;
2075 /* Return true to indicate that the caller should not do any
2076 further work on this auxent. */
2080 /* Return false to indicate that this auxent should be handled by
2088 /* We don't want to pointerize bal entries. */
2090 static boolean coff_pointerize_aux_hook
2091 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
2092 unsigned int, combined_entry_type
*));
2096 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
2097 bfd
*abfd ATTRIBUTE_UNUSED
;
2098 combined_entry_type
*table_base ATTRIBUTE_UNUSED
;
2099 combined_entry_type
*symbol
;
2100 unsigned int indaux
;
2101 combined_entry_type
*aux ATTRIBUTE_UNUSED
;
2103 /* Return true if we don't want to pointerize this aux entry, which
2104 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
2106 && (symbol
->u
.syment
.n_sclass
== C_LEAFPROC
2107 || symbol
->u
.syment
.n_sclass
== C_LEAFSTAT
2108 || symbol
->u
.syment
.n_sclass
== C_LEAFEXT
));
2113 #define coff_pointerize_aux_hook 0
2116 #endif /* ! RS6000COFF_C */
2118 /* Print an aux entry. This returns true if it has printed it. */
2120 static boolean coff_print_aux
2121 PARAMS ((bfd
*, FILE *, combined_entry_type
*, combined_entry_type
*,
2122 combined_entry_type
*, unsigned int));
2125 coff_print_aux (abfd
, file
, table_base
, symbol
, aux
, indaux
)
2126 bfd
*abfd ATTRIBUTE_UNUSED
;
2127 FILE *file ATTRIBUTE_UNUSED
;
2128 combined_entry_type
*table_base ATTRIBUTE_UNUSED
;
2129 combined_entry_type
*symbol ATTRIBUTE_UNUSED
;
2130 combined_entry_type
*aux ATTRIBUTE_UNUSED
;
2131 unsigned int indaux ATTRIBUTE_UNUSED
;
2134 if ((symbol
->u
.syment
.n_sclass
== C_EXT
2135 || symbol
->u
.syment
.n_sclass
== C_HIDEXT
)
2136 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2138 /* This is a csect entry. */
2139 fprintf (file
, "AUX ");
2140 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) != XTY_LD
)
2142 BFD_ASSERT (! aux
->fix_scnlen
);
2143 fprintf (file
, "val %5ld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2147 fprintf (file
, "indx ");
2148 if (! aux
->fix_scnlen
)
2149 fprintf (file
, "%4ld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2151 fprintf (file
, "%4ld",
2152 (long) (aux
->u
.auxent
.x_csect
.x_scnlen
.p
- table_base
));
2155 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2156 aux
->u
.auxent
.x_csect
.x_parmhash
,
2157 (unsigned int) aux
->u
.auxent
.x_csect
.x_snhash
,
2158 SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
),
2159 SMTYP_ALIGN (aux
->u
.auxent
.x_csect
.x_smtyp
),
2160 (unsigned int) aux
->u
.auxent
.x_csect
.x_smclas
,
2161 aux
->u
.auxent
.x_csect
.x_stab
,
2162 (unsigned int) aux
->u
.auxent
.x_csect
.x_snstab
);
2167 /* Return false to indicate that no special action was taken. */
2175 To write relocations, the back end steps though the
2176 canonical relocation table and create an
2177 @code{internal_reloc}. The symbol index to use is removed from
2178 the @code{offset} field in the symbol table supplied. The
2179 address comes directly from the sum of the section base
2180 address and the relocation offset; the type is dug directly
2181 from the howto field. Then the @code{internal_reloc} is
2182 swapped into the shape of an @code{external_reloc} and written
2189 static int compare_arelent_ptr
PARAMS ((const PTR
, const PTR
));
2191 /* AUX's ld wants relocations to be sorted */
2193 compare_arelent_ptr (x
, y
)
2197 const arelent
**a
= (const arelent
**) x
;
2198 const arelent
**b
= (const arelent
**) y
;
2199 bfd_size_type aadr
= (*a
)->address
;
2200 bfd_size_type badr
= (*b
)->address
;
2202 return (aadr
< badr
? -1 : badr
< aadr
? 1 : 0);
2205 #endif /* TARG_AUX */
2208 coff_write_relocs (abfd
, first_undef
)
2214 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
2217 struct external_reloc dst
;
2223 /* sort relocations before we write them out */
2224 p
= (arelent
**) bfd_malloc (s
->reloc_count
* sizeof (arelent
*));
2225 if (p
== NULL
&& s
->reloc_count
> 0)
2227 memcpy (p
, s
->orelocation
, s
->reloc_count
* sizeof (arelent
*));
2228 qsort (p
, s
->reloc_count
, sizeof (arelent
*), compare_arelent_ptr
);
2231 if (bfd_seek (abfd
, s
->rel_filepos
, SEEK_SET
) != 0)
2233 for (i
= 0; i
< s
->reloc_count
; i
++)
2235 struct internal_reloc n
;
2237 memset ((PTR
) & n
, 0, sizeof (n
));
2239 /* Now we've renumbered the symbols we know where the
2240 undefined symbols live in the table. Check the reloc
2241 entries for symbols who's output bfd isn't the right one.
2242 This is because the symbol was undefined (which means
2243 that all the pointers are never made to point to the same
2244 place). This is a bad thing,'cause the symbols attached
2245 to the output bfd are indexed, so that the relocation
2246 entries know which symbol index they point to. So we
2247 have to look up the output symbol here. */
2249 if (q
->sym_ptr_ptr
[0]->the_bfd
!= abfd
)
2252 const char *sname
= q
->sym_ptr_ptr
[0]->name
;
2253 asymbol
**outsyms
= abfd
->outsymbols
;
2254 for (i
= first_undef
; outsyms
[i
]; i
++)
2256 const char *intable
= outsyms
[i
]->name
;
2257 if (strcmp (intable
, sname
) == 0) {
2258 /* got a hit, so repoint the reloc */
2259 q
->sym_ptr_ptr
= outsyms
+ i
;
2265 n
.r_vaddr
= q
->address
+ s
->vma
;
2268 /* The 29k const/consth reloc pair is a real kludge. The consth
2269 part doesn't have a symbol; it has an offset. So rebuilt
2271 if (q
->howto
->type
== R_IHCONST
)
2272 n
.r_symndx
= q
->addend
;
2277 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2278 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q
,s
))
2280 if (q
->sym_ptr_ptr
== bfd_abs_section_ptr
->symbol_ptr_ptr
)
2282 /* This is a relocation relative to the absolute symbol. */
2286 n
.r_symndx
= get_index ((*(q
->sym_ptr_ptr
)));
2287 /* Take notice if the symbol reloc points to a symbol
2288 we don't have in our symbol table. What should we
2290 if (n
.r_symndx
> obj_conv_table_size (abfd
))
2295 #ifdef SWAP_OUT_RELOC_OFFSET
2296 n
.r_offset
= q
->addend
;
2300 /* Work out reloc type from what is required */
2301 SELECT_RELOC (n
, q
->howto
);
2303 n
.r_type
= q
->howto
->type
;
2305 coff_swap_reloc_out (abfd
, &n
, &dst
);
2306 if (bfd_write ((PTR
) & dst
, 1, bfd_coff_relsz (abfd
), abfd
)
2307 != bfd_coff_relsz (abfd
))
2320 /* Set flags and magic number of a coff file from architecture and machine
2321 type. Result is true if we can represent the arch&type, false if not. */
2324 coff_set_flags (abfd
, magicp
, flagsp
)
2326 unsigned int *magicp ATTRIBUTE_UNUSED
;
2327 unsigned short *flagsp ATTRIBUTE_UNUSED
;
2329 switch (bfd_get_arch (abfd
))
2334 switch (bfd_get_mach (abfd
))
2336 case bfd_mach_z8001
:
2339 case bfd_mach_z8002
:
2353 *magicp
= I960ROMAGIC
;
2355 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
2356 I960RWMAGIC); FIXME???
2358 switch (bfd_get_mach (abfd
))
2360 case bfd_mach_i960_core
:
2363 case bfd_mach_i960_kb_sb
:
2366 case bfd_mach_i960_mc
:
2369 case bfd_mach_i960_xa
:
2372 case bfd_mach_i960_ca
:
2375 case bfd_mach_i960_ka_sa
:
2378 case bfd_mach_i960_jx
:
2381 case bfd_mach_i960_hx
:
2394 case bfd_arch_tic30
:
2395 *magicp
= TIC30MAGIC
;
2398 #ifdef TIC80_ARCH_MAGIC
2399 case bfd_arch_tic80
:
2400 *magicp
= TIC80_ARCH_MAGIC
;
2405 * magicp
= ARMMAGIC
;
2407 if (APCS_SET (abfd
))
2409 if (APCS_26_FLAG (abfd
))
2410 * flagsp
|= F_APCS26
;
2412 if (APCS_FLOAT_FLAG (abfd
))
2413 * flagsp
|= F_APCS_FLOAT
;
2415 if (PIC_FLAG (abfd
))
2418 if (INTERWORK_SET (abfd
) && INTERWORK_FLAG (abfd
))
2419 * flagsp
|= F_INTERWORK
;
2420 switch (bfd_get_mach (abfd
))
2422 case bfd_mach_arm_2
: * flagsp
|= F_ARM_2
; break;
2423 case bfd_mach_arm_2a
: * flagsp
|= F_ARM_2a
; break;
2424 case bfd_mach_arm_3
: * flagsp
|= F_ARM_3
; break;
2425 case bfd_mach_arm_3M
: * flagsp
|= F_ARM_3M
; break;
2426 case bfd_mach_arm_4
: * flagsp
|= F_ARM_4
; break;
2427 case bfd_mach_arm_4T
: * flagsp
|= F_ARM_4T
; break;
2428 case bfd_mach_arm_5
: * flagsp
|= F_ARM_5
; break;
2429 case bfd_mach_arm_5T
: * flagsp
|= F_ARM_5
; break; /* XXX - we do not have an F_ARM_5T */
2434 case bfd_arch_powerpc
:
2441 *magicp
= I386MAGIC
;
2443 /* Just overwrite the usual value if we're doing Lynx. */
2444 *magicp
= LYNXCOFFMAGIC
;
2451 *magicp
= I860MAGIC
;
2457 #ifdef APOLLOM68KMAGIC
2458 *magicp
= APOLLO_COFF_VERSION_NUMBER
;
2460 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2461 #ifdef NAMES_HAVE_UNDERSCORE
2462 *magicp
= MC68KBCSMAGIC
;
2464 *magicp
= MC68MAGIC
;
2468 /* Just overwrite the usual value if we're doing Lynx. */
2469 *magicp
= LYNXCOFFMAGIC
;
2477 *magicp
= MC88OMAGIC
;
2482 case bfd_arch_h8300
:
2483 switch (bfd_get_mach (abfd
))
2485 case bfd_mach_h8300
:
2486 *magicp
= H8300MAGIC
;
2488 case bfd_mach_h8300h
:
2489 *magicp
= H8300HMAGIC
;
2491 case bfd_mach_h8300s
:
2492 *magicp
= H8300SMAGIC
;
2498 #ifdef SH_ARCH_MAGIC_BIG
2500 if (bfd_big_endian (abfd
))
2501 *magicp
= SH_ARCH_MAGIC_BIG
;
2503 *magicp
= SH_ARCH_MAGIC_LITTLE
;
2509 case bfd_arch_sparc
:
2510 *magicp
= SPARCMAGIC
;
2512 /* Just overwrite the usual value if we're doing Lynx. */
2513 *magicp
= LYNXCOFFMAGIC
;
2520 case bfd_arch_h8500
:
2521 *magicp
= H8500MAGIC
;
2525 #ifdef A29K_MAGIC_BIG
2527 if (bfd_big_endian (abfd
))
2528 *magicp
= A29K_MAGIC_BIG
;
2530 *magicp
= A29K_MAGIC_LITTLE
;
2536 case bfd_arch_we32k
:
2537 *magicp
= WE32KMAGIC
;
2543 case bfd_arch_rs6000
:
2545 case bfd_arch_powerpc
:
2547 *magicp
= U802TOCMAGIC
;
2553 case bfd_arch_mcore
:
2554 * magicp
= MCOREMAGIC
;
2558 default: /* Unknown architecture */
2559 /* return false; -- fall through to "return false" below, to avoid
2560 "statement never reached" errors on the one below. */
2569 coff_set_arch_mach (abfd
, arch
, machine
)
2571 enum bfd_architecture arch
;
2572 unsigned long machine
;
2575 unsigned short dummy2
;
2577 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
2580 if (arch
!= bfd_arch_unknown
&&
2581 coff_set_flags (abfd
, &dummy1
, &dummy2
) != true)
2582 return false; /* We can't represent this type */
2584 return true; /* We're easy ... */
2587 #ifdef COFF_IMAGE_WITH_PE
2589 /* This is used to sort sections by VMA, as required by PE image
2592 static int sort_by_secaddr
PARAMS ((const PTR
, const PTR
));
2595 sort_by_secaddr (arg1
, arg2
)
2599 const asection
*a
= *(const asection
**) arg1
;
2600 const asection
*b
= *(const asection
**) arg2
;
2602 if (a
->vma
< b
->vma
)
2604 else if (a
->vma
> b
->vma
)
2610 #endif /* COFF_IMAGE_WITH_PE */
2612 /* Calculate the file position for each section. */
2615 #define ALIGN_SECTIONS_IN_FILE
2618 #undef ALIGN_SECTIONS_IN_FILE
2622 coff_compute_section_file_positions (abfd
)
2626 asection
*previous
= (asection
*) NULL
;
2627 file_ptr sofar
= bfd_coff_filhsz (abfd
);
2628 boolean align_adjust
;
2629 #ifdef ALIGN_SECTIONS_IN_FILE
2634 /* On XCOFF, if we have symbols, set up the .debug section. */
2635 if (bfd_get_symcount (abfd
) > 0)
2638 bfd_size_type i
, symcount
;
2642 symcount
= bfd_get_symcount (abfd
);
2643 for (symp
= abfd
->outsymbols
, i
= 0; i
< symcount
; symp
++, i
++)
2645 coff_symbol_type
*cf
;
2647 cf
= coff_symbol_from (abfd
, *symp
);
2649 && cf
->native
!= NULL
2650 && SYMNAME_IN_DEBUG (&cf
->native
->u
.syment
))
2654 len
= strlen (bfd_asymbol_name (*symp
));
2663 dsec
= bfd_make_section_old_way (abfd
, ".debug");
2666 dsec
->_raw_size
= sz
;
2667 dsec
->flags
|= SEC_HAS_CONTENTS
;
2672 #ifdef COFF_IMAGE_WITH_PE
2674 if (coff_data (abfd
)->link_info
)
2676 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
2679 page_size
= PE_DEF_FILE_ALIGNMENT
;
2681 #ifdef COFF_PAGE_SIZE
2682 int page_size
= COFF_PAGE_SIZE
;
2686 if (bfd_get_start_address (abfd
))
2688 /* A start address may have been added to the original file. In this
2689 case it will need an optional header to record it. */
2690 abfd
->flags
|= EXEC_P
;
2693 if (abfd
->flags
& EXEC_P
)
2694 sofar
+= bfd_coff_aoutsz (abfd
);
2696 else if (xcoff_data (abfd
)->full_aouthdr
)
2697 sofar
+= bfd_coff_aoutsz (abfd
);
2699 sofar
+= SMALL_AOUTSZ
;
2702 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
2705 /* XCOFF handles overflows in the reloc and line number count fields
2706 by allocating a new section header to hold the correct counts. */
2707 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2708 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
2709 sofar
+= bfd_coff_scnhsz (abfd
);
2712 #ifdef COFF_IMAGE_WITH_PE
2714 /* PE requires the sections to be in memory order when listed in
2715 the section headers. It also does not like empty loadable
2716 sections. The sections apparently do not have to be in the
2717 right order in the image file itself, but we do need to get the
2718 target_index values right. */
2721 asection
**section_list
;
2726 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2729 /* We allocate an extra cell to simplify the final loop. */
2730 section_list
= bfd_malloc (sizeof (struct asection
*) * (count
+ 1));
2731 if (section_list
== NULL
)
2735 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2737 section_list
[i
] = current
;
2740 section_list
[i
] = NULL
;
2742 qsort (section_list
, count
, sizeof (asection
*), sort_by_secaddr
);
2744 /* Rethread the linked list into sorted order; at the same time,
2745 assign target_index values. */
2747 abfd
->sections
= section_list
[0];
2748 for (i
= 0; i
< count
; i
++)
2750 current
= section_list
[i
];
2751 current
->next
= section_list
[i
+ 1];
2753 /* Later, if the section has zero size, we'll be throwing it
2754 away, so we don't want to number it now. Note that having
2755 a zero size and having real contents are different
2756 concepts: .bss has no contents, but (usually) non-zero
2758 if (current
->_raw_size
== 0)
2760 /* Discard. However, it still might have (valid) symbols
2761 in it, so arbitrarily set it to section 1 (indexing is
2762 1-based here; usually .text). __end__ and other
2763 contents of .endsection really have this happen.
2764 FIXME: This seems somewhat dubious. */
2765 current
->target_index
= 1;
2768 current
->target_index
= target_index
++;
2771 bfd_free (section_list
);
2773 #else /* ! COFF_IMAGE_WITH_PE */
2775 /* Set the target_index field. */
2779 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2780 current
->target_index
= target_index
++;
2782 #endif /* ! COFF_IMAGE_WITH_PE */
2784 align_adjust
= false;
2785 for (current
= abfd
->sections
;
2786 current
!= (asection
*) NULL
;
2787 current
= current
->next
)
2789 #ifdef COFF_IMAGE_WITH_PE
2790 /* With PE we have to pad each section to be a multiple of its
2791 page size too, and remember both sizes. */
2792 if (coff_section_data (abfd
, current
) == NULL
)
2794 current
->used_by_bfd
=
2795 (PTR
) bfd_zalloc (abfd
, sizeof (struct coff_section_tdata
));
2796 if (current
->used_by_bfd
== NULL
)
2799 if (pei_section_data (abfd
, current
) == NULL
)
2801 coff_section_data (abfd
, current
)->tdata
=
2802 (PTR
) bfd_zalloc (abfd
, sizeof (struct pei_section_tdata
));
2803 if (coff_section_data (abfd
, current
)->tdata
== NULL
)
2806 if (pei_section_data (abfd
, current
)->virt_size
== 0)
2807 pei_section_data (abfd
, current
)->virt_size
= current
->_raw_size
;
2810 /* Only deal with sections which have contents. */
2811 if (!(current
->flags
& SEC_HAS_CONTENTS
))
2814 #ifdef COFF_IMAGE_WITH_PE
2815 /* Make sure we skip empty sections in a PE image. */
2816 if (current
->_raw_size
== 0)
2820 /* Align the sections in the file to the same boundary on
2821 which they are aligned in virtual memory. I960 doesn't
2822 do this (FIXME) so we can stay in sync with Intel. 960
2823 doesn't yet page from files... */
2824 #ifdef ALIGN_SECTIONS_IN_FILE
2825 if ((abfd
->flags
& EXEC_P
) != 0)
2827 /* make sure this section is aligned on the right boundary - by
2828 padding the previous section up if necessary */
2831 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
2832 if (previous
!= (asection
*) NULL
)
2834 previous
->_raw_size
+= sofar
- old_sofar
;
2840 /* In demand paged files the low order bits of the file offset
2841 must match the low order bits of the virtual address. */
2842 #ifdef COFF_PAGE_SIZE
2843 if ((abfd
->flags
& D_PAGED
) != 0
2844 && (current
->flags
& SEC_ALLOC
) != 0)
2845 sofar
+= (current
->vma
- sofar
) % page_size
;
2847 current
->filepos
= sofar
;
2849 #ifdef COFF_IMAGE_WITH_PE
2850 /* Set the padded size. */
2851 current
->_raw_size
= (current
->_raw_size
+ page_size
-1) & -page_size
;
2854 sofar
+= current
->_raw_size
;
2856 #ifdef ALIGN_SECTIONS_IN_FILE
2857 /* make sure that this section is of the right size too */
2858 if ((abfd
->flags
& EXEC_P
) == 0)
2860 bfd_size_type old_size
;
2862 old_size
= current
->_raw_size
;
2863 current
->_raw_size
= BFD_ALIGN (current
->_raw_size
,
2864 1 << current
->alignment_power
);
2865 align_adjust
= current
->_raw_size
!= old_size
;
2866 sofar
+= current
->_raw_size
- old_size
;
2871 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
2872 align_adjust
= sofar
!= old_sofar
;
2873 current
->_raw_size
+= sofar
- old_sofar
;
2877 #ifdef COFF_IMAGE_WITH_PE
2878 /* For PE we need to make sure we pad out to the aligned
2879 _raw_size, in case the caller only writes out data to the
2880 unaligned _raw_size. */
2881 if (pei_section_data (abfd
, current
)->virt_size
< current
->_raw_size
)
2882 align_adjust
= true;
2886 /* Force .lib sections to start at zero. The vma is then
2887 incremented in coff_set_section_contents. This is right for
2889 if (strcmp (current
->name
, _LIB
) == 0)
2890 bfd_set_section_vma (abfd
, current
, 0);
2896 /* It is now safe to write to the output file. If we needed an
2897 alignment adjustment for the last section, then make sure that
2898 there is a byte at offset sofar. If there are no symbols and no
2899 relocs, then nothing follows the last section. If we don't force
2900 the last byte out, then the file may appear to be truncated. */
2906 if (bfd_seek (abfd
, sofar
- 1, SEEK_SET
) != 0
2907 || bfd_write (&b
, 1, 1, abfd
) != 1)
2911 /* Make sure the relocations are aligned. We don't need to make
2912 sure that this byte exists, because it will only matter if there
2913 really are relocs. */
2914 sofar
= BFD_ALIGN (sofar
, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER
);
2916 obj_relocbase (abfd
) = sofar
;
2917 abfd
->output_has_begun
= true;
2924 /* This can never work, because it is called too late--after the
2925 section positions have been set. I can't figure out what it is
2926 for, so I am going to disable it--Ian Taylor 20 March 1996. */
2928 /* If .file, .text, .data, .bss symbols are missing, add them. */
2929 /* @@ Should we only be adding missing symbols, or overriding the aux
2930 values for existing section symbols? */
2932 coff_add_missing_symbols (abfd
)
2935 unsigned int nsyms
= bfd_get_symcount (abfd
);
2936 asymbol
**sympp
= abfd
->outsymbols
;
2939 int need_text
= 1, need_data
= 1, need_bss
= 1, need_file
= 1;
2941 for (i
= 0; i
< nsyms
; i
++)
2943 coff_symbol_type
*csym
= coff_symbol_from (abfd
, sympp
[i
]);
2947 /* only do this if there is a coff representation of the input
2949 if (csym
->native
&& csym
->native
->u
.syment
.n_sclass
== C_FILE
)
2954 name
= csym
->symbol
.name
;
2957 if (!strcmp (name
, _TEXT
))
2960 else if (!strcmp (name
, ".wtext"))
2963 else if (!strcmp (name
, _DATA
))
2965 else if (!strcmp (name
, _BSS
))
2969 /* Now i == bfd_get_symcount (abfd). */
2970 /* @@ For now, don't deal with .file symbol. */
2973 if (!need_text
&& !need_data
&& !need_bss
&& !need_file
)
2975 nsyms
+= need_text
+ need_data
+ need_bss
+ need_file
;
2976 sympp2
= (asymbol
**) bfd_alloc (abfd
, nsyms
* sizeof (asymbol
*));
2979 memcpy (sympp2
, sympp
, i
* sizeof (asymbol
*));
2982 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
2986 sympp2
[i
++] = coff_section_symbol (abfd
, _TEXT
);
2988 sympp2
[i
++] = coff_section_symbol (abfd
, _DATA
);
2990 sympp2
[i
++] = coff_section_symbol (abfd
, _BSS
);
2991 BFD_ASSERT (i
== nsyms
);
2992 bfd_set_symtab (abfd
, sympp2
, nsyms
);
3001 coff_write_object_contents (abfd
)
3005 boolean hasrelocs
= false;
3006 boolean haslinno
= false;
3007 boolean hasdebug
= false;
3009 file_ptr reloc_base
;
3010 file_ptr lineno_base
;
3012 unsigned long reloc_size
= 0;
3013 unsigned long lnno_size
= 0;
3014 boolean long_section_names
;
3015 asection
*text_sec
= NULL
;
3016 asection
*data_sec
= NULL
;
3017 asection
*bss_sec
= NULL
;
3018 struct internal_filehdr internal_f
;
3019 struct internal_aouthdr internal_a
;
3020 #ifdef COFF_LONG_SECTION_NAMES
3021 size_t string_size
= STRING_SIZE_SIZE
;
3024 bfd_set_error (bfd_error_system_call
);
3026 /* Make a pass through the symbol table to count line number entries and
3027 put them into the correct asections */
3029 lnno_size
= coff_count_linenumbers (abfd
) * bfd_coff_linesz (abfd
);
3031 if (abfd
->output_has_begun
== false)
3033 if (! coff_compute_section_file_positions (abfd
))
3037 reloc_base
= obj_relocbase (abfd
);
3039 /* Work out the size of the reloc and linno areas */
3041 for (current
= abfd
->sections
; current
!= NULL
; current
=
3043 reloc_size
+= current
->reloc_count
* bfd_coff_relsz (abfd
);
3045 lineno_base
= reloc_base
+ reloc_size
;
3046 sym_base
= lineno_base
+ lnno_size
;
3048 /* Indicate in each section->line_filepos its actual file address */
3049 for (current
= abfd
->sections
; current
!= NULL
; current
=
3052 if (current
->lineno_count
)
3054 current
->line_filepos
= lineno_base
;
3055 current
->moving_line_filepos
= lineno_base
;
3056 lineno_base
+= current
->lineno_count
* bfd_coff_linesz (abfd
);
3060 current
->line_filepos
= 0;
3062 if (current
->reloc_count
)
3064 current
->rel_filepos
= reloc_base
;
3065 reloc_base
+= current
->reloc_count
* bfd_coff_relsz (abfd
);
3069 current
->rel_filepos
= 0;
3073 /* Write section headers to the file. */
3074 internal_f
.f_nscns
= 0;
3076 if ((abfd
->flags
& EXEC_P
) != 0)
3077 scn_base
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
3080 scn_base
= bfd_coff_filhsz (abfd
);
3082 if (xcoff_data (abfd
)->full_aouthdr
)
3083 scn_base
+= bfd_coff_aoutsz (abfd
);
3085 scn_base
+= SMALL_AOUTSZ
;
3089 if (bfd_seek (abfd
, scn_base
, SEEK_SET
) != 0)
3092 long_section_names
= false;
3093 for (current
= abfd
->sections
;
3095 current
= current
->next
)
3097 struct internal_scnhdr section
;
3098 boolean is_reloc_section
= false;
3100 #ifdef COFF_IMAGE_WITH_PE
3101 if (strcmp (current
->name
, ".reloc") == 0)
3103 is_reloc_section
= true;
3105 pe_data (abfd
)->has_reloc_section
= 1;
3109 internal_f
.f_nscns
++;
3111 strncpy (section
.s_name
, current
->name
, SCNNMLEN
);
3113 #ifdef COFF_LONG_SECTION_NAMES
3114 /* Handle long section names as in PE. This must be compatible
3115 with the code in coff_write_symbols and _bfd_coff_final_link. */
3119 len
= strlen (current
->name
);
3122 memset (section
.s_name
, 0, SCNNMLEN
);
3123 sprintf (section
.s_name
, "/%lu", (unsigned long) string_size
);
3124 string_size
+= len
+ 1;
3125 long_section_names
= true;
3131 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3132 Ian Taylor <ian@cygnus.com>. */
3133 if (strcmp (current
->name
, _LIB
) == 0)
3134 section
.s_vaddr
= 0;
3137 section
.s_vaddr
= current
->vma
;
3138 section
.s_paddr
= current
->lma
;
3139 section
.s_size
= current
->_raw_size
;
3142 section
.s_paddr
= 0;
3144 #ifdef COFF_IMAGE_WITH_PE
3145 /* Reminder: s_paddr holds the virtual size of the section. */
3146 if (coff_section_data (abfd
, current
) != NULL
3147 && pei_section_data (abfd
, current
) != NULL
)
3148 section
.s_paddr
= pei_section_data (abfd
, current
)->virt_size
;
3150 section
.s_paddr
= 0;
3154 If this section has no size or is unloadable then the scnptr
3157 if (current
->_raw_size
== 0 ||
3158 (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3160 section
.s_scnptr
= 0;
3164 section
.s_scnptr
= current
->filepos
;
3166 section
.s_relptr
= current
->rel_filepos
;
3167 section
.s_lnnoptr
= current
->line_filepos
;
3168 section
.s_nreloc
= current
->reloc_count
;
3169 section
.s_nlnno
= current
->lineno_count
;
3170 #ifndef COFF_IMAGE_WITH_PE
3171 /* In PEI, relocs come in the .reloc section. */
3172 if (current
->reloc_count
!= 0)
3175 if (current
->lineno_count
!= 0)
3177 if ((current
->flags
& SEC_DEBUGGING
) != 0
3178 && ! is_reloc_section
)
3182 /* Indicate the use of an XCOFF overflow section header. */
3183 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3185 section
.s_nreloc
= 0xffff;
3186 section
.s_nlnno
= 0xffff;
3190 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
3192 if (!strcmp (current
->name
, _TEXT
))
3196 else if (!strcmp (current
->name
, _DATA
))
3200 else if (!strcmp (current
->name
, _BSS
))
3206 section
.s_align
= (current
->alignment_power
3207 ? 1 << current
->alignment_power
3211 section
.s_flags
|= (current
->alignment_power
& 0xF) << 8;
3215 #ifdef COFF_IMAGE_WITH_PE
3216 /* Suppress output of the sections if they are null. ld
3217 includes the bss and data sections even if there is no size
3218 assigned to them. NT loader doesn't like it if these section
3219 headers are included if the sections themselves are not
3220 needed. See also coff_compute_section_file_positions. */
3221 if (section
.s_size
== 0)
3222 internal_f
.f_nscns
--;
3227 if (coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
3228 || bfd_write ((PTR
) (&buff
), 1, bfd_coff_scnhsz (abfd
), abfd
)
3229 != bfd_coff_scnhsz (abfd
))
3234 /* PE stores COMDAT section information in the symbol table. If
3235 this section is supposed to have some COMDAT info, track down
3236 the symbol in the symbol table and modify it. */
3237 if ((current
->flags
& SEC_LINK_ONCE
) != 0)
3239 unsigned int i
, count
;
3241 coff_symbol_type
*csym
= NULL
;
3245 count
= bfd_get_symcount (abfd
);
3246 for (i
= 0, psym
= abfd
->outsymbols
; i
< count
; i
++, psym
++)
3248 if ((*psym
)->section
!= current
)
3251 /* Remember the location of the first symbol in this
3253 if (psymsec
== NULL
)
3256 /* See if this is the section symbol. */
3257 if (strcmp ((*psym
)->name
, current
->name
) == 0)
3259 csym
= coff_symbol_from (abfd
, *psym
);
3261 || csym
->native
== NULL
3262 || csym
->native
->u
.syment
.n_numaux
< 1
3263 || csym
->native
->u
.syment
.n_sclass
!= C_STAT
3264 || csym
->native
->u
.syment
.n_type
!= T_NULL
)
3267 /* Here *PSYM is the section symbol for CURRENT. */
3274 Note that we might not if we're converting the file from
3275 some other object file format. */
3278 combined_entry_type
*aux
;
3280 /* We don't touch the x_checksum field. The
3281 x_associated field is not currently supported. */
3283 aux
= csym
->native
+ 1;
3284 switch (current
->flags
& SEC_LINK_DUPLICATES
)
3286 case SEC_LINK_DUPLICATES_DISCARD
:
3287 aux
->u
.auxent
.x_scn
.x_comdat
= IMAGE_COMDAT_SELECT_ANY
;
3290 case SEC_LINK_DUPLICATES_ONE_ONLY
:
3291 aux
->u
.auxent
.x_scn
.x_comdat
=
3292 IMAGE_COMDAT_SELECT_NODUPLICATES
;
3295 case SEC_LINK_DUPLICATES_SAME_SIZE
:
3296 aux
->u
.auxent
.x_scn
.x_comdat
=
3297 IMAGE_COMDAT_SELECT_SAME_SIZE
;
3300 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
3301 aux
->u
.auxent
.x_scn
.x_comdat
=
3302 IMAGE_COMDAT_SELECT_EXACT_MATCH
;
3306 /* The COMDAT symbol must be the first symbol from this
3307 section in the symbol table. In order to make this
3308 work, we move the COMDAT symbol before the first
3309 symbol we found in the search above. It's OK to
3310 rearrange the symbol table at this point, because
3311 coff_renumber_symbols is going to rearrange it
3312 further and fix up all the aux entries. */
3313 if (psym
!= psymsec
)
3319 for (pcopy
= psym
; pcopy
> psymsec
; pcopy
--)
3320 pcopy
[0] = pcopy
[-1];
3325 #endif /* COFF_WITH_PE */
3329 /* XCOFF handles overflows in the reloc and line number count fields
3330 by creating a new section header to hold the correct values. */
3331 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3333 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3335 struct internal_scnhdr scnhdr
;
3338 internal_f
.f_nscns
++;
3339 strncpy (&(scnhdr
.s_name
[0]), current
->name
, 8);
3340 scnhdr
.s_paddr
= current
->reloc_count
;
3341 scnhdr
.s_vaddr
= current
->lineno_count
;
3343 scnhdr
.s_scnptr
= 0;
3344 scnhdr
.s_relptr
= current
->rel_filepos
;
3345 scnhdr
.s_lnnoptr
= current
->line_filepos
;
3346 scnhdr
.s_nreloc
= current
->target_index
;
3347 scnhdr
.s_nlnno
= current
->target_index
;
3348 scnhdr
.s_flags
= STYP_OVRFLO
;
3349 if (coff_swap_scnhdr_out (abfd
, &scnhdr
, &buff
) == 0
3350 || bfd_write ((PTR
) &buff
, 1, bfd_coff_scnhsz (abfd
), abfd
)
3351 != bfd_coff_scnhsz (abfd
))
3357 /* OK, now set up the filehdr... */
3359 /* Don't include the internal abs section in the section count */
3362 We will NOT put a fucking timestamp in the header here. Every time you
3363 put it back, I will come in and take it out again. I'm sorry. This
3364 field does not belong here. We fill it with a 0 so it compares the
3365 same but is not a reasonable time. -- gnu@cygnus.com
3367 internal_f
.f_timdat
= 0;
3369 internal_f
.f_flags
= 0;
3371 if (abfd
->flags
& EXEC_P
)
3372 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3375 internal_f
.f_opthdr
= 0;
3377 if (xcoff_data (abfd
)->full_aouthdr
)
3378 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3380 internal_f
.f_opthdr
= SMALL_AOUTSZ
;
3385 internal_f
.f_flags
|= F_RELFLG
;
3387 internal_f
.f_flags
|= F_LNNO
;
3388 if (abfd
->flags
& EXEC_P
)
3389 internal_f
.f_flags
|= F_EXEC
;
3390 #ifdef COFF_IMAGE_WITH_PE
3392 internal_f
.f_flags
|= IMAGE_FILE_DEBUG_STRIPPED
;
3395 #ifndef COFF_WITH_PE
3396 if (bfd_little_endian (abfd
))
3397 internal_f
.f_flags
|= F_AR32WR
;
3399 internal_f
.f_flags
|= F_AR32W
;
3402 #ifdef TIC80_TARGET_ID
3403 internal_f
.f_target_id
= TIC80_TARGET_ID
;
3407 FIXME, should do something about the other byte orders and
3412 if ((abfd
->flags
& DYNAMIC
) != 0)
3413 internal_f
.f_flags
|= F_SHROBJ
;
3414 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
3415 internal_f
.f_flags
|= F_DYNLOAD
;
3418 memset (&internal_a
, 0, sizeof internal_a
);
3420 /* Set up architecture-dependent stuff */
3423 unsigned int magic
= 0;
3424 unsigned short flags
= 0;
3425 coff_set_flags (abfd
, &magic
, &flags
);
3426 internal_f
.f_magic
= magic
;
3427 internal_f
.f_flags
|= flags
;
3428 /* ...and the "opt"hdr... */
3431 #ifdef ULTRA3 /* NYU's machine */
3432 /* FIXME: This is a bogus check. I really want to see if there
3433 * is a .shbss or a .shdata section, if so then set the magic
3434 * number to indicate a shared data executable.
3436 if (internal_f
.f_nscns
>= 7)
3437 internal_a
.magic
= SHMAGIC
; /* Shared magic */
3440 internal_a
.magic
= NMAGIC
; /* Assume separate i/d */
3441 #define __A_MAGIC_SET__
3444 internal_a
.magic
= TIC80_ARCH_MAGIC
;
3445 #define __A_MAGIC_SET__
3448 /* FIXME: What are the a.out magic numbers for the i860? */
3449 internal_a
.magic
= 0;
3450 #define __A_MAGIC_SET__
3453 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
3454 #define __A_MAGIC_SET__
3457 #define __A_MAGIC_SET__
3458 internal_a
.magic
= PAGEMAGICBCS
;
3462 #define __A_MAGIC_SET__
3463 internal_a
.magic
= APOLLO_COFF_VERSION_NUMBER
;
3466 #if defined(M68) || defined(WE32K) || defined(M68K)
3467 #define __A_MAGIC_SET__
3469 internal_a
.magic
= LYNXCOFFMAGIC
;
3471 #if defined(TARG_AUX)
3472 internal_a
.magic
= (abfd
->flags
& D_PAGED
? PAGEMAGICPEXECPAGED
:
3473 abfd
->flags
& WP_TEXT
? PAGEMAGICPEXECSWAPPED
:
3474 PAGEMAGICEXECSWAPPED
);
3476 #if defined (PAGEMAGICPEXECPAGED)
3477 internal_a
.magic
= PAGEMAGICPEXECPAGED
;
3479 #endif /* TARG_AUX */
3481 #endif /* M68 || WE32K || M68K */
3484 #define __A_MAGIC_SET__
3485 internal_a
.magic
= ZMAGIC
;
3489 #define __A_MAGIC_SET__
3490 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3493 #if defined MCORE_PE
3494 #define __A_MAGIC_SET__
3495 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3499 #define __A_MAGIC_SET__
3501 internal_a
.magic
= LYNXCOFFMAGIC
;
3503 internal_a
.magic
= ZMAGIC
;
3508 #define __A_MAGIC_SET__
3510 internal_a
.magic
= LYNXCOFFMAGIC
;
3515 #define __A_MAGIC_SET__
3516 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
3517 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
3518 RS6K_AOUTHDR_OMAGIC
;
3521 #ifndef __A_MAGIC_SET__
3522 #include "Your aouthdr magic number is not being set!"
3524 #undef __A_MAGIC_SET__
3528 /* FIXME: Does anybody ever set this to another value? */
3529 internal_a
.vstamp
= 0;
3531 /* Now should write relocs, strings, syms */
3532 obj_sym_filepos (abfd
) = sym_base
;
3534 if (bfd_get_symcount (abfd
) != 0)
3538 if (!coff_add_missing_symbols (abfd
))
3541 if (!coff_renumber_symbols (abfd
, &firstundef
))
3543 coff_mangle_symbols (abfd
);
3544 if (! coff_write_symbols (abfd
))
3546 if (! coff_write_linenumbers (abfd
))
3548 if (! coff_write_relocs (abfd
, firstundef
))
3551 #ifdef COFF_LONG_SECTION_NAMES
3552 else if (long_section_names
)
3554 /* If we have long section names we have to write out the string
3555 table even if there are no symbols. */
3556 if (! coff_write_symbols (abfd
))
3560 #ifdef COFF_IMAGE_WITH_PE
3562 else if ((abfd
->flags
& EXEC_P
) != 0)
3566 /* PowerPC PE appears to require that all executable files be
3567 rounded up to the page size. */
3570 BFD_ALIGN (sym_base
, COFF_PAGE_SIZE
) - 1,
3572 || bfd_write (&b
, 1, 1, abfd
) != 1)
3578 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
3579 backend linker, and obj_raw_syment_count is not valid until after
3580 coff_write_symbols is called. */
3581 if (obj_raw_syment_count (abfd
) != 0)
3583 internal_f
.f_symptr
= sym_base
;
3585 /* AIX appears to require that F_RELFLG not be set if there are
3586 local symbols but no relocations. */
3587 internal_f
.f_flags
&=~ F_RELFLG
;
3592 if (long_section_names
)
3593 internal_f
.f_symptr
= sym_base
;
3595 internal_f
.f_symptr
= 0;
3596 internal_f
.f_flags
|= F_LSYMS
;
3601 internal_a
.tsize
= bfd_get_section_size_before_reloc (text_sec
);
3602 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
3606 internal_a
.dsize
= bfd_get_section_size_before_reloc (data_sec
);
3607 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
3611 internal_a
.bsize
= bfd_get_section_size_before_reloc (bss_sec
);
3612 if (internal_a
.bsize
&& bss_sec
->vma
< internal_a
.data_start
)
3613 internal_a
.data_start
= bss_sec
->vma
;
3616 internal_a
.entry
= bfd_get_start_address (abfd
);
3617 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
3620 if (xcoff_data (abfd
)->full_aouthdr
)
3623 asection
*loader_sec
;
3625 internal_a
.vstamp
= 1;
3627 internal_a
.o_snentry
= xcoff_data (abfd
)->snentry
;
3628 if (internal_a
.o_snentry
== 0)
3629 internal_a
.entry
= (bfd_vma
) -1;
3631 if (text_sec
!= NULL
)
3633 internal_a
.o_sntext
= text_sec
->target_index
;
3634 internal_a
.o_algntext
= bfd_get_section_alignment (abfd
, text_sec
);
3638 internal_a
.o_sntext
= 0;
3639 internal_a
.o_algntext
= 0;
3641 if (data_sec
!= NULL
)
3643 internal_a
.o_sndata
= data_sec
->target_index
;
3644 internal_a
.o_algndata
= bfd_get_section_alignment (abfd
, data_sec
);
3648 internal_a
.o_sndata
= 0;
3649 internal_a
.o_algndata
= 0;
3651 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
3652 if (loader_sec
!= NULL
)
3653 internal_a
.o_snloader
= loader_sec
->target_index
;
3655 internal_a
.o_snloader
= 0;
3656 if (bss_sec
!= NULL
)
3657 internal_a
.o_snbss
= bss_sec
->target_index
;
3659 internal_a
.o_snbss
= 0;
3661 toc
= xcoff_data (abfd
)->toc
;
3662 internal_a
.o_toc
= toc
;
3663 internal_a
.o_sntoc
= xcoff_data (abfd
)->sntoc
;
3665 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
3666 if (xcoff_data (abfd
)->cputype
!= -1)
3667 internal_a
.o_cputype
= xcoff_data (abfd
)->cputype
;
3670 switch (bfd_get_arch (abfd
))
3672 case bfd_arch_rs6000
:
3673 internal_a
.o_cputype
= 4;
3675 case bfd_arch_powerpc
:
3676 if (bfd_get_mach (abfd
) == 0)
3677 internal_a
.o_cputype
= 3;
3679 internal_a
.o_cputype
= 1;
3685 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
3686 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
3690 /* now write them */
3691 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
3696 bfd_size_type amount
;
3698 buff
= bfd_malloc (bfd_coff_filhsz (abfd
));
3702 coff_swap_filehdr_out (abfd
, (PTR
) & internal_f
, (PTR
) buff
);
3703 amount
= bfd_write ((PTR
) buff
, 1, bfd_coff_filhsz (abfd
), abfd
);
3707 if (amount
!= bfd_coff_filhsz (abfd
))
3711 if (abfd
->flags
& EXEC_P
)
3713 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
3714 include/coff/pe.h sets AOUTSZ == sizeof(PEAOUTHDR)) */
3716 bfd_size_type amount
;
3718 buff
= bfd_malloc (bfd_coff_aoutsz (abfd
));
3722 coff_swap_aouthdr_out (abfd
, (PTR
) & internal_a
, (PTR
) buff
);
3723 amount
= bfd_write ((PTR
) buff
, 1, bfd_coff_aoutsz (abfd
), abfd
);
3727 if (amount
!= bfd_coff_aoutsz (abfd
))
3736 /* XCOFF seems to always write at least a small a.out header. */
3737 coff_swap_aouthdr_out (abfd
, (PTR
) &internal_a
, (PTR
) &buff
);
3738 if (xcoff_data (abfd
)->full_aouthdr
)
3739 size
= bfd_coff_aoutsz (abfd
);
3741 size
= SMALL_AOUTSZ
;
3742 if (bfd_write ((PTR
) &buff
, 1, size
, abfd
) != size
)
3751 coff_set_section_contents (abfd
, section
, location
, offset
, count
)
3756 bfd_size_type count
;
3758 if (abfd
->output_has_begun
== false) /* set by bfd.c handler */
3760 if (! coff_compute_section_file_positions (abfd
))
3764 #if defined(_LIB) && !defined(TARG_AUX)
3766 /* The physical address field of a .lib section is used to hold the
3767 number of shared libraries in the section. This code counts the
3768 number of sections being written, and increments the lma field
3771 I have found no documentation on the contents of this section.
3772 Experimentation indicates that the section contains zero or more
3773 records, each of which has the following structure:
3775 - a (four byte) word holding the length of this record, in words,
3776 - a word that always seems to be set to "2",
3777 - the path to a shared library, null-terminated and then padded
3778 to a whole word boundary.
3780 bfd_assert calls have been added to alert if an attempt is made
3781 to write a section which doesn't follow these assumptions. The
3782 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
3783 <robertl@arnet.com> (Thanks!).
3785 Gvran Uddeborg <gvran@uddeborg.pp.se> */
3787 if (strcmp (section
->name
, _LIB
) == 0)
3789 bfd_byte
*rec
, *recend
;
3791 rec
= (bfd_byte
*) location
;
3792 recend
= rec
+ count
;
3793 while (rec
< recend
)
3796 rec
+= bfd_get_32 (abfd
, rec
) * 4;
3799 BFD_ASSERT (rec
== recend
);
3804 /* Don't write out bss sections - one way to do this is to
3805 see if the filepos has not been set. */
3806 if (section
->filepos
== 0)
3809 if (bfd_seek (abfd
, (file_ptr
) (section
->filepos
+ offset
), SEEK_SET
) != 0)
3814 return (bfd_write (location
, 1, count
, abfd
) == count
) ? true : false;
3820 coff_close_and_cleanup (abfd
)
3823 if (!bfd_read_p (abfd
))
3824 switch (abfd
->format
)
3827 if (!_bfd_write_archive_contents (abfd
))
3831 if (!coff_write_object_contents (abfd
))
3835 bfd_set_error (bfd_error_invalid_operation
);
3839 /* We depend on bfd_close to free all the memory on the objalloc. */
3846 buy_and_read (abfd
, where
, seek_direction
, size
)
3852 PTR area
= (PTR
) bfd_alloc (abfd
, size
);
3855 if (bfd_seek (abfd
, where
, seek_direction
) != 0
3856 || bfd_read (area
, 1, size
, abfd
) != size
)
3859 } /* buy_and_read() */
3865 Creating the linenumber table is done by reading in the entire
3866 coff linenumber table, and creating another table for internal use.
3868 A coff linenumber table is structured so that each function
3869 is marked as having a line number of 0. Each line within the
3870 function is an offset from the first line in the function. The
3871 base of the line number information for the table is stored in
3872 the symbol associated with the function.
3874 Note: The PE format uses line number 0 for a flag indicating a
3877 The information is copied from the external to the internal
3878 table, and each symbol which marks a function is marked by
3881 How does this work ?
3886 coff_slurp_line_table (abfd
, asect
)
3890 LINENO
*native_lineno
;
3891 alent
*lineno_cache
;
3893 BFD_ASSERT (asect
->lineno
== (alent
*) NULL
);
3895 native_lineno
= (LINENO
*) buy_and_read (abfd
,
3896 asect
->line_filepos
,
3898 (size_t) (bfd_coff_linesz (abfd
) *
3899 asect
->lineno_count
));
3901 (alent
*) bfd_alloc (abfd
, (size_t) ((asect
->lineno_count
+ 1) * sizeof (alent
)));
3902 if (lineno_cache
== NULL
)
3906 unsigned int counter
= 0;
3907 alent
*cache_ptr
= lineno_cache
;
3908 LINENO
*src
= native_lineno
;
3910 while (counter
< asect
->lineno_count
)
3912 struct internal_lineno dst
;
3913 coff_swap_lineno_in (abfd
, src
, &dst
);
3914 cache_ptr
->line_number
= dst
.l_lnno
;
3916 if (cache_ptr
->line_number
== 0)
3920 coff_symbol_type
*sym
;
3923 symndx
= dst
.l_addr
.l_symndx
;
3925 || (unsigned long) symndx
>= obj_raw_syment_count (abfd
))
3927 (*_bfd_error_handler
)
3928 (_("%s: warning: illegal symbol index %ld in line numbers"),
3929 bfd_get_filename (abfd
), dst
.l_addr
.l_symndx
);
3933 /* FIXME: We should not be casting between ints and
3934 pointers like this. */
3935 sym
= ((coff_symbol_type
*)
3936 ((symndx
+ obj_raw_syments (abfd
))
3937 ->u
.syment
._n
._n_n
._n_zeroes
));
3938 cache_ptr
->u
.sym
= (asymbol
*) sym
;
3939 if (sym
->lineno
!= NULL
&& ! warned
)
3941 (*_bfd_error_handler
)
3942 (_("%s: warning: duplicate line number information for `%s'"),
3943 bfd_get_filename (abfd
),
3944 bfd_asymbol_name (&sym
->symbol
));
3946 sym
->lineno
= cache_ptr
;
3950 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
3951 - bfd_section_vma (abfd
, asect
);
3952 } /* If no linenumber expect a symbol index */
3958 cache_ptr
->line_number
= 0;
3961 asect
->lineno
= lineno_cache
;
3962 /* FIXME, free native_lineno here, or use alloca or something. */
3966 /* Slurp in the symbol table, converting it to generic form. Note
3967 that if coff_relocate_section is defined, the linker will read
3968 symbols via coff_link_add_symbols, rather than via this routine. */
3971 coff_slurp_symbol_table (abfd
)
3974 combined_entry_type
*native_symbols
;
3975 coff_symbol_type
*cached_area
;
3976 unsigned int *table_ptr
;
3978 unsigned int number_of_symbols
= 0;
3980 if (obj_symbols (abfd
))
3983 /* Read in the symbol table */
3984 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
3989 /* Allocate enough room for all the symbols in cached form */
3990 cached_area
= ((coff_symbol_type
*)
3992 (obj_raw_syment_count (abfd
)
3993 * sizeof (coff_symbol_type
))));
3995 if (cached_area
== NULL
)
3997 table_ptr
= ((unsigned int *)
3999 (obj_raw_syment_count (abfd
)
4000 * sizeof (unsigned int))));
4002 if (table_ptr
== NULL
)
4006 coff_symbol_type
*dst
= cached_area
;
4007 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
4008 unsigned int this_index
= 0;
4009 while (this_index
< last_native_index
)
4011 combined_entry_type
*src
= native_symbols
+ this_index
;
4012 table_ptr
[this_index
] = number_of_symbols
;
4013 dst
->symbol
.the_bfd
= abfd
;
4015 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
4016 /* We use the native name field to point to the cached field. */
4017 src
->u
.syment
._n
._n_n
._n_zeroes
= (long) dst
;
4018 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
4019 src
->u
.syment
.n_scnum
);
4020 dst
->symbol
.flags
= 0;
4021 dst
->done_lineno
= false;
4023 switch (src
->u
.syment
.n_sclass
)
4028 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
4029 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4030 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4032 /* Fall through to next case */
4040 case C_THUMBEXTFUNC
:
4046 case C_SYSTEM
: /* System Wide variable */
4049 /* In PE, 0x68 (104) denotes a section symbol */
4051 /* In PE, 0x69 (105) denotes a weak external symbol. */
4054 switch (coff_classify_symbol (abfd
, &src
->u
.syment
))
4056 case COFF_SYMBOL_GLOBAL
:
4057 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4058 #if defined COFF_WITH_PE
4059 /* PE sets the symbol to a value relative to the
4060 start of the section. */
4061 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4063 dst
->symbol
.value
= (src
->u
.syment
.n_value
4064 - dst
->symbol
.section
->vma
);
4066 if (ISFCN ((src
->u
.syment
.n_type
)))
4068 /* A function ext does not go at the end of a
4070 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4074 case COFF_SYMBOL_COMMON
:
4075 dst
->symbol
.section
= bfd_com_section_ptr
;
4076 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4079 case COFF_SYMBOL_UNDEFINED
:
4080 dst
->symbol
.section
= bfd_und_section_ptr
;
4081 dst
->symbol
.value
= 0;
4084 case COFF_SYMBOL_PE_SECTION
:
4085 dst
->symbol
.flags
|= BSF_EXPORT
| BSF_SECTION_SYM
;
4086 dst
->symbol
.value
= 0;
4089 case COFF_SYMBOL_LOCAL
:
4090 dst
->symbol
.flags
= BSF_LOCAL
;
4091 #if defined COFF_WITH_PE
4092 /* PE sets the symbol to a value relative to the
4093 start of the section. */
4094 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4096 dst
->symbol
.value
= (src
->u
.syment
.n_value
4097 - dst
->symbol
.section
->vma
);
4099 if (ISFCN ((src
->u
.syment
.n_type
)))
4100 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4105 /* A symbol with a csect entry should not go at the end. */
4106 if (src
->u
.syment
.n_numaux
> 0)
4107 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
4111 if (src
->u
.syment
.n_sclass
== C_NT_WEAK
)
4112 dst
->symbol
.flags
= BSF_WEAK
;
4113 if (src
->u
.syment
.n_sclass
== C_SECTION
4114 && src
->u
.syment
.n_scnum
> 0)
4116 dst
->symbol
.flags
= BSF_LOCAL
;
4120 if (src
->u
.syment
.n_sclass
== C_WEAKEXT
)
4121 dst
->symbol
.flags
= BSF_WEAK
;
4125 case C_STAT
: /* static */
4127 case C_LEAFSTAT
: /* static leaf procedure */
4130 case C_THUMBSTAT
: /* Thumb static */
4131 case C_THUMBLABEL
: /* Thumb label */
4132 case C_THUMBSTATFUNC
:/* Thumb static function */
4134 case C_LABEL
: /* label */
4135 if (src
->u
.syment
.n_scnum
== N_DEBUG
)
4136 dst
->symbol
.flags
= BSF_DEBUGGING
;
4138 dst
->symbol
.flags
= BSF_LOCAL
;
4140 /* Base the value as an index from the base of the
4141 section, if there is one. */
4142 if (dst
->symbol
.section
)
4144 #if defined COFF_WITH_PE
4145 /* PE sets the symbol to a value relative to the
4146 start of the section. */
4147 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4149 dst
->symbol
.value
= (src
->u
.syment
.n_value
4150 - dst
->symbol
.section
->vma
);
4154 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4157 case C_MOS
: /* member of structure */
4158 case C_EOS
: /* end of structure */
4159 #ifdef NOTDEF /* C_AUTOARG has the same value */
4161 case C_GLBLREG
: /* A29k-specific storage class */
4164 case C_REGPARM
: /* register parameter */
4165 case C_REG
: /* register variable */
4168 case C_AUTOARG
: /* 960-specific storage class */
4171 case C_TPDEF
: /* type definition */
4173 case C_AUTO
: /* automatic variable */
4174 case C_FIELD
: /* bit field */
4175 case C_ENTAG
: /* enumeration tag */
4176 case C_MOE
: /* member of enumeration */
4177 case C_MOU
: /* member of union */
4178 case C_UNTAG
: /* union tag */
4179 dst
->symbol
.flags
= BSF_DEBUGGING
;
4180 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4183 case C_FILE
: /* file name */
4184 case C_STRTAG
: /* structure tag */
4199 dst
->symbol
.flags
= BSF_DEBUGGING
;
4200 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4204 case C_BINCL
: /* beginning of include file */
4205 case C_EINCL
: /* ending of include file */
4206 /* The value is actually a pointer into the line numbers
4207 of the file. We locate the line number entry, and
4208 set the section to the section which contains it, and
4209 the value to the index in that section. */
4213 dst
->symbol
.flags
= BSF_DEBUGGING
;
4214 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4215 if (sec
->line_filepos
<= (file_ptr
) src
->u
.syment
.n_value
4216 && ((file_ptr
) (sec
->line_filepos
4217 + sec
->lineno_count
* bfd_coff_linesz (abfd
))
4218 > (file_ptr
) src
->u
.syment
.n_value
))
4221 dst
->symbol
.value
= 0;
4224 dst
->symbol
.section
= sec
;
4225 dst
->symbol
.value
= ((src
->u
.syment
.n_value
4226 - sec
->line_filepos
)
4227 / bfd_coff_linesz (abfd
));
4234 dst
->symbol
.flags
= BSF_DEBUGGING
;
4236 /* The value is actually a symbol index. Save a pointer
4237 to the symbol instead of the index. FIXME: This
4238 should use a union. */
4239 src
->u
.syment
.n_value
=
4240 (long) (native_symbols
+ src
->u
.syment
.n_value
);
4241 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4246 case C_BLOCK
: /* ".bb" or ".eb" */
4247 case C_FCN
: /* ".bf" or ".ef" (or PE ".lf") */
4248 case C_EFCN
: /* physical end of function */
4249 #if defined COFF_WITH_PE
4250 /* PE sets the symbol to a value relative to the start
4252 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4253 if (strcmp (dst
->symbol
.name
, ".bf") != 0)
4255 /* PE uses funny values for .ef and .lf; don't
4257 dst
->symbol
.flags
= BSF_DEBUGGING
;
4260 dst
->symbol
.flags
= BSF_DEBUGGING
| BSF_DEBUGGING_RELOC
;
4262 /* Base the value as an index from the base of the
4264 dst
->symbol
.flags
= BSF_LOCAL
;
4265 dst
->symbol
.value
= (src
->u
.syment
.n_value
4266 - dst
->symbol
.section
->vma
);
4271 /* PE DLLs sometimes have zeroed out symbols for some
4272 reason. Just ignore them without a warning. */
4273 if (src
->u
.syment
.n_type
== 0
4274 && src
->u
.syment
.n_value
== 0
4275 && src
->u
.syment
.n_scnum
== 0)
4278 case C_EXTDEF
: /* external definition */
4279 case C_ULABEL
: /* undefined label */
4280 case C_USTATIC
: /* undefined static */
4281 #ifndef COFF_WITH_PE
4282 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4283 class to represent a section symbol */
4284 case C_LINE
: /* line # reformatted as symbol table entry */
4285 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4286 case C_ALIAS
: /* duplicate tag */
4288 /* New storage classes for TIc80 */
4290 case C_UEXT
: /* Tentative external definition */
4292 case C_STATLAB
: /* Static load time label */
4293 case C_EXTLAB
: /* External load time label */
4294 case C_HIDDEN
: /* ext symbol in dmert public lib */
4296 (*_bfd_error_handler
)
4297 (_("%s: Unrecognized storage class %d for %s symbol `%s'"),
4298 bfd_get_filename (abfd
), src
->u
.syment
.n_sclass
,
4299 dst
->symbol
.section
->name
, dst
->symbol
.name
);
4300 dst
->symbol
.flags
= BSF_DEBUGGING
;
4301 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4305 /* BFD_ASSERT(dst->symbol.flags != 0);*/
4309 dst
->symbol
.udata
.i
= 0;
4310 dst
->lineno
= (alent
*) NULL
;
4311 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
4313 number_of_symbols
++;
4314 } /* walk the native symtab */
4315 } /* bfdize the native symtab */
4317 obj_symbols (abfd
) = cached_area
;
4318 obj_raw_syments (abfd
) = native_symbols
;
4320 bfd_get_symcount (abfd
) = number_of_symbols
;
4321 obj_convert (abfd
) = table_ptr
;
4322 /* Slurp the line tables for each section too */
4328 coff_slurp_line_table (abfd
, p
);
4333 } /* coff_slurp_symbol_table() */
4335 /* Classify a COFF symbol. A couple of targets have globally visible
4336 symbols which are not class C_EXT, and this handles those. It also
4337 recognizes some special PE cases. */
4339 static enum coff_symbol_classification
4340 coff_classify_symbol (abfd
, syment
)
4342 struct internal_syment
*syment
;
4344 /* FIXME: This partially duplicates the switch in
4345 coff_slurp_symbol_table. */
4346 switch (syment
->n_sclass
)
4355 case C_THUMBEXTFUNC
:
4363 if (syment
->n_scnum
== 0)
4365 if (syment
->n_value
== 0)
4366 return COFF_SYMBOL_UNDEFINED
;
4368 return COFF_SYMBOL_COMMON
;
4370 return COFF_SYMBOL_GLOBAL
;
4377 if (syment
->n_sclass
== C_STAT
)
4379 if (syment
->n_scnum
== 0)
4381 /* The Microsoft compiler sometimes generates these if a
4382 small static function is inlined every time it is used.
4383 The function is discarded, but the symbol table entry
4385 return COFF_SYMBOL_LOCAL
;
4388 #ifdef STRICT_PE_FORMAT
4389 /* This is correct for Microsoft generated objects, but it
4390 breaks gas generated objects. */
4392 if (syment
->n_value
== 0)
4395 char buf
[SYMNMLEN
+ 1];
4397 sec
= coff_section_from_bfd_index (abfd
, syment
->n_scnum
);
4399 && (strcmp (bfd_get_section_name (abfd
, sec
),
4400 _bfd_coff_internal_syment_name (abfd
, syment
, buf
))
4402 return COFF_SYMBOL_PE_SECTION
;
4406 return COFF_SYMBOL_LOCAL
;
4409 if (syment
->n_sclass
== C_SECTION
)
4411 /* In some cases in a DLL generated by the Microsoft linker, the
4412 n_value field will contain garbage. FIXME: This should
4413 probably be handled by the swapping function instead. */
4414 syment
->n_value
= 0;
4415 if (syment
->n_scnum
== 0)
4416 return COFF_SYMBOL_UNDEFINED
;
4417 return COFF_SYMBOL_PE_SECTION
;
4419 #endif /* COFF_WITH_PE */
4421 /* If it is not a global symbol, we presume it is a local symbol. */
4423 if (syment
->n_scnum
== 0)
4425 char buf
[SYMNMLEN
+ 1];
4427 (*_bfd_error_handler
)
4428 (_("warning: %s: local symbol `%s' has no section"),
4429 bfd_get_filename (abfd
),
4430 _bfd_coff_internal_syment_name (abfd
, syment
, buf
));
4433 return COFF_SYMBOL_LOCAL
;
4440 Coff relocations are easily transformed into the internal BFD form
4443 Reading a coff relocation table is done in the following stages:
4445 o Read the entire coff relocation table into memory.
4447 o Process each relocation in turn; first swap it from the
4448 external to the internal form.
4450 o Turn the symbol referenced in the relocation's symbol index
4451 into a pointer into the canonical symbol table.
4452 This table is the same as the one returned by a call to
4453 @code{bfd_canonicalize_symtab}. The back end will call that
4454 routine and save the result if a canonicalization hasn't been done.
4456 o The reloc index is turned into a pointer to a howto
4457 structure, in a back end specific way. For instance, the 386
4458 and 960 use the @code{r_type} to directly produce an index
4459 into a howto table vector; the 88k subtracts a number from the
4460 @code{r_type} field and creates an addend field.
4466 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
4468 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \
4469 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
4470 coffsym = (obj_symbols (abfd) \
4471 + (cache_ptr->sym_ptr_ptr - symbols)); \
4473 coffsym = coff_symbol_from (abfd, ptr); \
4474 if (coffsym != (coff_symbol_type *) NULL \
4475 && coffsym->native->u.syment.n_scnum == 0) \
4476 cache_ptr->addend = 0; \
4477 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
4478 && ptr->section != (asection *) NULL) \
4479 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
4481 cache_ptr->addend = 0; \
4486 coff_slurp_reloc_table (abfd
, asect
, symbols
)
4491 RELOC
*native_relocs
;
4492 arelent
*reloc_cache
;
4497 if (asect
->relocation
)
4499 if (asect
->reloc_count
== 0)
4501 if (asect
->flags
& SEC_CONSTRUCTOR
)
4503 if (!coff_slurp_symbol_table (abfd
))
4506 (RELOC
*) buy_and_read (abfd
,
4509 (size_t) (bfd_coff_relsz (abfd
) *
4510 asect
->reloc_count
));
4511 reloc_cache
= (arelent
*)
4512 bfd_alloc (abfd
, (size_t) (asect
->reloc_count
* sizeof (arelent
)));
4514 if (reloc_cache
== NULL
)
4518 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
4520 struct internal_reloc dst
;
4521 struct external_reloc
*src
;
4522 #ifndef RELOC_PROCESSING
4526 cache_ptr
= reloc_cache
+ idx
;
4527 src
= native_relocs
+ idx
;
4529 coff_swap_reloc_in (abfd
, src
, &dst
);
4531 #ifdef RELOC_PROCESSING
4532 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
4534 cache_ptr
->address
= dst
.r_vaddr
;
4536 if (dst
.r_symndx
!= -1)
4538 if (dst
.r_symndx
< 0 || dst
.r_symndx
>= obj_conv_table_size (abfd
))
4540 (*_bfd_error_handler
)
4541 (_("%s: warning: illegal symbol index %ld in relocs"),
4542 bfd_get_filename (abfd
), dst
.r_symndx
);
4543 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
4548 cache_ptr
->sym_ptr_ptr
= (symbols
4549 + obj_convert (abfd
)[dst
.r_symndx
]);
4550 ptr
= *(cache_ptr
->sym_ptr_ptr
);
4555 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
4559 /* The symbols definitions that we have read in have been
4560 relocated as if their sections started at 0. But the offsets
4561 refering to the symbols in the raw data have not been
4562 modified, so we have to have a negative addend to compensate.
4564 Note that symbols which used to be common must be left alone */
4566 /* Calculate any reloc addend by looking at the symbol */
4567 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
4569 cache_ptr
->address
-= asect
->vma
;
4570 /* !! cache_ptr->section = (asection *) NULL;*/
4572 /* Fill in the cache_ptr->howto field from dst.r_type */
4573 RTYPE2HOWTO (cache_ptr
, &dst
);
4574 #endif /* RELOC_PROCESSING */
4576 if (cache_ptr
->howto
== NULL
)
4578 (*_bfd_error_handler
)
4579 (_("%s: illegal relocation type %d at address 0x%lx"),
4580 bfd_get_filename (abfd
), dst
.r_type
, (long) dst
.r_vaddr
);
4581 bfd_set_error (bfd_error_bad_value
);
4586 asect
->relocation
= reloc_cache
;
4590 #ifndef coff_rtype_to_howto
4593 /* Get the howto structure for a reloc. This is only used if the file
4594 including this one defines coff_relocate_section to be
4595 _bfd_coff_generic_relocate_section, so it is OK if it does not
4596 always work. It is the responsibility of the including file to
4597 make sure it is reasonable if it is needed. */
4599 static reloc_howto_type
*coff_rtype_to_howto
4600 PARAMS ((bfd
*, asection
*, struct internal_reloc
*,
4601 struct coff_link_hash_entry
*, struct internal_syment
*,
4605 static reloc_howto_type
*
4606 coff_rtype_to_howto (abfd
, sec
, rel
, h
, sym
, addendp
)
4607 bfd
*abfd ATTRIBUTE_UNUSED
;
4608 asection
*sec ATTRIBUTE_UNUSED
;
4609 struct internal_reloc
*rel
;
4610 struct coff_link_hash_entry
*h ATTRIBUTE_UNUSED
;
4611 struct internal_syment
*sym ATTRIBUTE_UNUSED
;
4612 bfd_vma
*addendp ATTRIBUTE_UNUSED
;
4616 RTYPE2HOWTO (&genrel
, rel
);
4617 return genrel
.howto
;
4620 #else /* ! defined (RTYPE2HOWTO) */
4622 #define coff_rtype_to_howto NULL
4624 #endif /* ! defined (RTYPE2HOWTO) */
4625 #endif /* ! defined (coff_rtype_to_howto) */
4627 /* This is stupid. This function should be a boolean predicate. */
4629 coff_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
4635 arelent
*tblptr
= section
->relocation
;
4636 unsigned int count
= 0;
4639 if (section
->flags
& SEC_CONSTRUCTOR
)
4641 /* this section has relocs made up by us, they are not in the
4642 file, so take them out of their chain and place them into
4643 the data area provided */
4644 arelent_chain
*chain
= section
->constructor_chain
;
4645 for (count
= 0; count
< section
->reloc_count
; count
++)
4647 *relptr
++ = &chain
->relent
;
4648 chain
= chain
->next
;
4654 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
4657 tblptr
= section
->relocation
;
4659 for (; count
++ < section
->reloc_count
;)
4660 *relptr
++ = tblptr
++;
4665 return section
->reloc_count
;
4670 coff_sym_filepos (abfd
)
4673 return obj_sym_filepos (abfd
);
4677 #ifndef coff_reloc16_estimate
4678 #define coff_reloc16_estimate dummy_reloc16_estimate
4680 static int dummy_reloc16_estimate
4681 PARAMS ((bfd
*, asection
*, arelent
*, unsigned int,
4682 struct bfd_link_info
*));
4685 dummy_reloc16_estimate (abfd
, input_section
, reloc
, shrink
, link_info
)
4686 bfd
*abfd ATTRIBUTE_UNUSED
;
4687 asection
*input_section ATTRIBUTE_UNUSED
;
4688 arelent
*reloc ATTRIBUTE_UNUSED
;
4689 unsigned int shrink ATTRIBUTE_UNUSED
;
4690 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
4698 #ifndef coff_reloc16_extra_cases
4700 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
4702 /* This works even if abort is not declared in any header file. */
4704 static void dummy_reloc16_extra_cases
4705 PARAMS ((bfd
*, struct bfd_link_info
*, struct bfd_link_order
*, arelent
*,
4706 bfd_byte
*, unsigned int *, unsigned int *));
4709 dummy_reloc16_extra_cases (abfd
, link_info
, link_order
, reloc
, data
, src_ptr
,
4711 bfd
*abfd ATTRIBUTE_UNUSED
;
4712 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
4713 struct bfd_link_order
*link_order ATTRIBUTE_UNUSED
;
4714 arelent
*reloc ATTRIBUTE_UNUSED
;
4715 bfd_byte
*data ATTRIBUTE_UNUSED
;
4716 unsigned int *src_ptr ATTRIBUTE_UNUSED
;
4717 unsigned int *dst_ptr ATTRIBUTE_UNUSED
;
4723 /* If coff_relocate_section is defined, we can use the optimized COFF
4724 backend linker. Otherwise we must continue to use the old linker. */
4725 #ifdef coff_relocate_section
4726 #ifndef coff_bfd_link_hash_table_create
4727 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
4729 #ifndef coff_bfd_link_add_symbols
4730 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
4732 #ifndef coff_bfd_final_link
4733 #define coff_bfd_final_link _bfd_coff_final_link
4735 #else /* ! defined (coff_relocate_section) */
4736 #define coff_relocate_section NULL
4737 #ifndef coff_bfd_link_hash_table_create
4738 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
4740 #ifndef coff_bfd_link_add_symbols
4741 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
4743 #define coff_bfd_final_link _bfd_generic_final_link
4744 #endif /* ! defined (coff_relocate_section) */
4746 #define coff_bfd_link_split_section _bfd_generic_link_split_section
4748 #ifndef coff_start_final_link
4749 #define coff_start_final_link NULL
4752 #ifndef coff_adjust_symndx
4753 #define coff_adjust_symndx NULL
4756 #ifndef coff_link_add_one_symbol
4757 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
4760 #ifndef coff_link_output_has_begun
4762 static boolean coff_link_output_has_begun
4763 PARAMS ((bfd
*, struct coff_final_link_info
*));
4766 coff_link_output_has_begun (abfd
, info
)
4768 struct coff_final_link_info
* info ATTRIBUTE_UNUSED
;
4770 return abfd
->output_has_begun
;
4774 #ifndef coff_final_link_postscript
4776 static boolean coff_final_link_postscript
4777 PARAMS ((bfd
*, struct coff_final_link_info
*));
4780 coff_final_link_postscript (abfd
, pfinfo
)
4781 bfd
* abfd ATTRIBUTE_UNUSED
;
4782 struct coff_final_link_info
* pfinfo ATTRIBUTE_UNUSED
;
4788 #ifndef coff_SWAP_aux_in
4789 #define coff_SWAP_aux_in coff_swap_aux_in
4791 #ifndef coff_SWAP_sym_in
4792 #define coff_SWAP_sym_in coff_swap_sym_in
4794 #ifndef coff_SWAP_lineno_in
4795 #define coff_SWAP_lineno_in coff_swap_lineno_in
4797 #ifndef coff_SWAP_aux_out
4798 #define coff_SWAP_aux_out coff_swap_aux_out
4800 #ifndef coff_SWAP_sym_out
4801 #define coff_SWAP_sym_out coff_swap_sym_out
4803 #ifndef coff_SWAP_lineno_out
4804 #define coff_SWAP_lineno_out coff_swap_lineno_out
4806 #ifndef coff_SWAP_reloc_out
4807 #define coff_SWAP_reloc_out coff_swap_reloc_out
4809 #ifndef coff_SWAP_filehdr_out
4810 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
4812 #ifndef coff_SWAP_aouthdr_out
4813 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
4815 #ifndef coff_SWAP_scnhdr_out
4816 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
4818 #ifndef coff_SWAP_reloc_in
4819 #define coff_SWAP_reloc_in coff_swap_reloc_in
4821 #ifndef coff_SWAP_filehdr_in
4822 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
4824 #ifndef coff_SWAP_aouthdr_in
4825 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
4827 #ifndef coff_SWAP_scnhdr_in
4828 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
4831 static const bfd_coff_backend_data bfd_coff_std_swap_table
=
4833 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
4834 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
4835 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
4836 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
4837 coff_SWAP_scnhdr_out
,
4838 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
4839 #ifdef COFF_LONG_FILENAMES
4844 #ifdef COFF_LONG_SECTION_NAMES
4849 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
4850 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
4851 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
4852 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
4853 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
4854 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
4855 coff_classify_symbol
, coff_compute_section_file_positions
,
4856 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
4857 coff_adjust_symndx
, coff_link_add_one_symbol
,
4858 coff_link_output_has_begun
, coff_final_link_postscript
4861 #ifndef coff_close_and_cleanup
4862 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
4865 #ifndef coff_bfd_free_cached_info
4866 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
4869 #ifndef coff_get_section_contents
4870 #define coff_get_section_contents _bfd_generic_get_section_contents
4873 #ifndef coff_bfd_copy_private_symbol_data
4874 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
4877 #ifndef coff_bfd_copy_private_section_data
4878 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
4881 #ifndef coff_bfd_copy_private_bfd_data
4882 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
4885 #ifndef coff_bfd_merge_private_bfd_data
4886 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
4889 #ifndef coff_bfd_set_private_flags
4890 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
4893 #ifndef coff_bfd_print_private_bfd_data
4894 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
4897 #ifndef coff_bfd_is_local_label_name
4898 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
4901 #ifndef coff_read_minisymbols
4902 #define coff_read_minisymbols _bfd_generic_read_minisymbols
4905 #ifndef coff_minisymbol_to_symbol
4906 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
4909 /* The reloc lookup routine must be supplied by each individual COFF
4911 #ifndef coff_bfd_reloc_type_lookup
4912 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
4915 #ifndef coff_bfd_get_relocated_section_contents
4916 #define coff_bfd_get_relocated_section_contents \
4917 bfd_generic_get_relocated_section_contents
4920 #ifndef coff_bfd_relax_section
4921 #define coff_bfd_relax_section bfd_generic_relax_section
4924 #ifndef coff_bfd_gc_sections
4925 #define coff_bfd_gc_sections bfd_generic_gc_sections
4928 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
4929 const bfd_target VAR = \
4932 bfd_target_coff_flavour, \
4933 BFD_ENDIAN_BIG, /* data byte order is big */ \
4934 BFD_ENDIAN_BIG, /* header byte order is big */ \
4935 /* object flags */ \
4936 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
4937 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
4938 /* section flags */ \
4939 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
4940 UNDER, /* leading symbol underscore */ \
4941 '/', /* ar_pad_char */ \
4942 15, /* ar_max_namelen */ \
4944 /* Data conversion functions. */ \
4945 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
4946 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
4947 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
4949 /* Header conversion functions. */ \
4950 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
4951 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
4952 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
4954 /* bfd_check_format */ \
4955 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
4956 _bfd_dummy_target }, \
4957 /* bfd_set_format */ \
4958 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
4959 /* bfd_write_contents */ \
4960 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
4963 BFD_JUMP_TABLE_GENERIC (coff), \
4964 BFD_JUMP_TABLE_COPY (coff), \
4965 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
4966 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
4967 BFD_JUMP_TABLE_SYMBOLS (coff), \
4968 BFD_JUMP_TABLE_RELOCS (coff), \
4969 BFD_JUMP_TABLE_WRITE (coff), \
4970 BFD_JUMP_TABLE_LINK (coff), \
4971 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
4978 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
4979 const bfd_target VAR = \
4982 bfd_target_coff_flavour, \
4983 BFD_ENDIAN_LITTLE, /* data byte order is little */ \
4984 BFD_ENDIAN_LITTLE, /* header byte order is little */ \
4985 /* object flags */ \
4986 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
4987 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
4988 /* section flags */ \
4989 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
4990 UNDER, /* leading symbol underscore */ \
4991 '/', /* ar_pad_char */ \
4992 15, /* ar_max_namelen */ \
4994 /* Data conversion functions. */ \
4995 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
4996 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
4997 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
4998 /* Header conversion functions. */ \
4999 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5000 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5001 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5002 /* bfd_check_format */ \
5003 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5004 _bfd_dummy_target }, \
5005 /* bfd_set_format */ \
5006 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5007 /* bfd_write_contents */ \
5008 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5011 BFD_JUMP_TABLE_GENERIC (coff), \
5012 BFD_JUMP_TABLE_COPY (coff), \
5013 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5014 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5015 BFD_JUMP_TABLE_SYMBOLS (coff), \
5016 BFD_JUMP_TABLE_RELOCS (coff), \
5017 BFD_JUMP_TABLE_WRITE (coff), \
5018 BFD_JUMP_TABLE_LINK (coff), \
5019 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \