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
;
763 esymstart
= esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
764 esymend
= esym
+ obj_raw_syment_count (abfd
) * SYMESZ
;
766 while (esym
< esymend
)
768 struct internal_syment isym
;
769 char buf
[SYMNMLEN
+ 1];
772 bfd_coff_swap_sym_in (abfd
, (PTR
) esym
, (PTR
) &isym
);
774 if (sizeof (internal_s
->s_name
) > SYMNMLEN
)
776 /* This case implies that the matching symbol name
777 will be in the string table. */
781 /* The MS documentation is vague, but it appears to
782 require that n_sclass be C_STAT for both entries;
783 However, the Alpha compiler uses C_EXT for the one
784 with the "real" name, at least for string-pooled
786 if (isym
.n_scnum
== section
->target_index
787 && (isym
.n_sclass
== C_STAT
|| isym
.n_sclass
== C_EXT
)
788 && isym
.n_type
== T_NULL
789 && isym
.n_value
== 0)
791 /* The first TWO entries with the section # are both
792 of interest to us. The first one is the "section
793 symbol" (section name). The second is the comdat
794 symbol name. 'value' must be zero for it to
795 apply. Here, we've found a qualifying entry; we
796 distinguish the first from the second by numaux
797 (which should be 0 for the second). FIXME: We
798 should use the first one first rather than
799 counting on numaux. */
800 if (isym
.n_numaux
== 1)
802 union internal_auxent aux
;
804 symname
= _bfd_coff_internal_syment_name (abfd
, &isym
,
809 if (strcmp (name
, symname
) != 0)
812 /* This is the section symbol. */
814 bfd_coff_swap_aux_in (abfd
, (PTR
) (esym
+ SYMESZ
),
815 isym
.n_type
, isym
.n_sclass
,
816 0, isym
.n_numaux
, (PTR
) &aux
);
818 /* FIXME: Microsoft uses NODUPLICATES and
819 ASSOCIATIVE, but gnu uses ANY and SAME_SIZE.
820 Unfortunately, gnu doesn't do the comdat
821 symbols right. So, until we can fix it to do
822 the right thing, we are temporarily disabling
823 comdats for the MS types (they're used in
824 DLLs and C++, but we don't support *their*
825 C++ libraries anyway - DJ. */
827 switch (aux
.x_scn
.x_comdat
)
829 case IMAGE_COMDAT_SELECT_NODUPLICATES
:
830 /* FIXME: This is bogus. It breaks cross-compilers. */
832 sec_flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
834 sec_flags
&= ~SEC_LINK_ONCE
;
838 case IMAGE_COMDAT_SELECT_ANY
:
839 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
842 case IMAGE_COMDAT_SELECT_SAME_SIZE
:
843 sec_flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
846 case IMAGE_COMDAT_SELECT_EXACT_MATCH
:
847 /* Not yet fully implemented in the linker. */
848 sec_flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
851 case IMAGE_COMDAT_SELECT_ASSOCIATIVE
:
852 /* FIXME: This is bogus. It breaks cross-compilers. */
854 /* FIXME: This is not currently implemented. */
855 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
857 sec_flags
&= ~SEC_LINK_ONCE
;
862 /* FIXME: Shouldn't this be at least a
864 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
872 /* This should be the the second symbol with the
873 section #. It is the actual symbol name.
874 Intel puts the two adjacent, but Alpha (at
875 least) spreads them out. */
878 bfd_alloc (abfd
, sizeof (struct bfd_comdat_info
));
879 if (section
->comdat
== NULL
)
881 section
->comdat
->symbol
= (esym
- esymstart
) / SYMESZ
;
882 symname
= _bfd_coff_internal_syment_name (abfd
, &isym
,
887 newname
= bfd_alloc (abfd
, strlen (symname
) + 1);
890 strcpy (newname
, symname
);
891 section
->comdat
->name
= newname
;
897 esym
+= (isym
.n_numaux
+ 1) * SYMESZ
;
902 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
903 /* As a GNU extension, if the name begins with .gnu.linkonce, we
904 only link a single copy of the section. This is used to support
905 g++. g++ will emit each template expansion in its own section.
906 The symbols will be defined as weak, so that multiple definitions
907 are permitted. The GNU linker extension is to actually discard
908 all but one of the sections. */
909 if (strncmp (name
, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
910 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
916 #endif /* COFF_WITH_PE */
918 #define get_index(symbol) ((symbol)->udata.i)
922 bfd_coff_backend_data
926 .{* COFF symbol classifications. *}
928 .enum coff_symbol_classification
930 . {* Global symbol. *}
931 . COFF_SYMBOL_GLOBAL,
932 . {* Common symbol. *}
933 . COFF_SYMBOL_COMMON,
934 . {* Undefined symbol. *}
935 . COFF_SYMBOL_UNDEFINED,
936 . {* Local symbol. *}
938 . {* PE section symbol. *}
939 . COFF_SYMBOL_PE_SECTION
942 Special entry points for gdb to swap in coff symbol table parts:
945 . void (*_bfd_coff_swap_aux_in) PARAMS ((
954 . void (*_bfd_coff_swap_sym_in) PARAMS ((
959 . void (*_bfd_coff_swap_lineno_in) PARAMS ((
965 Special entry points for gas to swap out coff parts:
967 . unsigned int (*_bfd_coff_swap_aux_out) PARAMS ((
976 . unsigned int (*_bfd_coff_swap_sym_out) PARAMS ((
981 . unsigned int (*_bfd_coff_swap_lineno_out) PARAMS ((
986 . unsigned int (*_bfd_coff_swap_reloc_out) PARAMS ((
991 . unsigned int (*_bfd_coff_swap_filehdr_out) PARAMS ((
996 . unsigned int (*_bfd_coff_swap_aouthdr_out) PARAMS ((
1001 . unsigned int (*_bfd_coff_swap_scnhdr_out) PARAMS ((
1007 Special entry points for generic COFF routines to call target
1008 dependent COFF routines:
1010 . unsigned int _bfd_filhsz;
1011 . unsigned int _bfd_aoutsz;
1012 . unsigned int _bfd_scnhsz;
1013 . unsigned int _bfd_symesz;
1014 . unsigned int _bfd_auxesz;
1015 . unsigned int _bfd_relsz;
1016 . unsigned int _bfd_linesz;
1017 . unsigned int _bfd_filnmlen;
1018 . boolean _bfd_coff_long_filenames;
1019 . boolean _bfd_coff_long_section_names;
1020 . unsigned int _bfd_coff_default_section_alignment_power;
1021 . void (*_bfd_coff_swap_filehdr_in) PARAMS ((
1025 . void (*_bfd_coff_swap_aouthdr_in) PARAMS ((
1029 . void (*_bfd_coff_swap_scnhdr_in) PARAMS ((
1033 . void (*_bfd_coff_swap_reloc_in) PARAMS ((
1037 . boolean (*_bfd_coff_bad_format_hook) PARAMS ((
1039 . PTR internal_filehdr));
1040 . boolean (*_bfd_coff_set_arch_mach_hook) PARAMS ((
1042 . PTR internal_filehdr));
1043 . PTR (*_bfd_coff_mkobject_hook) PARAMS ((
1045 . PTR internal_filehdr,
1046 . PTR internal_aouthdr));
1047 . flagword (*_bfd_styp_to_sec_flags_hook) PARAMS ((
1049 . PTR internal_scnhdr,
1051 . asection *section));
1052 . void (*_bfd_set_alignment_hook) PARAMS ((
1055 . PTR internal_scnhdr));
1056 . boolean (*_bfd_coff_slurp_symbol_table) PARAMS ((
1058 . boolean (*_bfd_coff_symname_in_debug) PARAMS ((
1060 . struct internal_syment *sym));
1061 . boolean (*_bfd_coff_pointerize_aux_hook) PARAMS ((
1063 . combined_entry_type *table_base,
1064 . combined_entry_type *symbol,
1065 . unsigned int indaux,
1066 . combined_entry_type *aux));
1067 . boolean (*_bfd_coff_print_aux) PARAMS ((
1070 . combined_entry_type *table_base,
1071 . combined_entry_type *symbol,
1072 . combined_entry_type *aux,
1073 . unsigned int indaux));
1074 . void (*_bfd_coff_reloc16_extra_cases) PARAMS ((
1076 . struct bfd_link_info *link_info,
1077 . struct bfd_link_order *link_order,
1080 . unsigned int *src_ptr,
1081 . unsigned int *dst_ptr));
1082 . int (*_bfd_coff_reloc16_estimate) PARAMS ((
1084 . asection *input_section,
1086 . unsigned int shrink,
1087 . struct bfd_link_info *link_info));
1088 . enum coff_symbol_classification (*_bfd_coff_classify_symbol) PARAMS ((
1090 . struct internal_syment *));
1091 . boolean (*_bfd_coff_compute_section_file_positions) PARAMS ((
1093 . boolean (*_bfd_coff_start_final_link) PARAMS ((
1095 . struct bfd_link_info *info));
1096 . boolean (*_bfd_coff_relocate_section) PARAMS ((
1098 . struct bfd_link_info *info,
1100 . asection *input_section,
1101 . bfd_byte *contents,
1102 . struct internal_reloc *relocs,
1103 . struct internal_syment *syms,
1104 . asection **sections));
1105 . reloc_howto_type *(*_bfd_coff_rtype_to_howto) PARAMS ((
1108 . struct internal_reloc *rel,
1109 . struct coff_link_hash_entry *h,
1110 . struct internal_syment *sym,
1111 . bfd_vma *addendp));
1112 . boolean (*_bfd_coff_adjust_symndx) PARAMS ((
1114 . struct bfd_link_info *info,
1117 . struct internal_reloc *reloc,
1118 . boolean *adjustedp));
1119 . boolean (*_bfd_coff_link_add_one_symbol) PARAMS ((
1120 . struct bfd_link_info *info,
1124 . asection *section,
1126 . const char *string,
1129 . struct bfd_link_hash_entry **hashp));
1131 . boolean (*_bfd_coff_link_output_has_begun) PARAMS ((
1133 . struct coff_final_link_info * pfinfo));
1134 . boolean (*_bfd_coff_final_link_postscript) PARAMS ((
1136 . struct coff_final_link_info * pfinfo));
1138 .} bfd_coff_backend_data;
1140 .#define coff_backend_info(abfd) ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1142 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1143 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1145 .#define bfd_coff_swap_sym_in(a,e,i) \
1146 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1148 .#define bfd_coff_swap_lineno_in(a,e,i) \
1149 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1151 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1152 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1154 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1155 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1157 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1158 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1160 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1161 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1163 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1164 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1166 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1167 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1169 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1170 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1172 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1173 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1174 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1175 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1176 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1177 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1178 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1179 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1180 .#define bfd_coff_long_filenames(abfd) (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1181 .#define bfd_coff_long_section_names(abfd) \
1182 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1183 .#define bfd_coff_default_section_alignment_power(abfd) \
1184 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1185 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1186 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1188 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1189 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1191 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1192 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1194 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1195 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1197 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1198 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1200 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1201 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1202 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1203 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook) (abfd, filehdr, aouthdr))
1205 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section)\
1206 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1207 . (abfd, scnhdr, name, section))
1209 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1210 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1212 .#define bfd_coff_slurp_symbol_table(abfd)\
1213 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1215 .#define bfd_coff_symname_in_debug(abfd, sym)\
1216 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1218 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1219 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1220 . (abfd, file, base, symbol, aux, indaux))
1222 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)\
1223 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1224 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1226 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1227 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1228 . (abfd, section, reloc, shrink, link_info))
1230 .#define bfd_coff_classify_symbol(abfd, sym)\
1231 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1234 .#define bfd_coff_compute_section_file_positions(abfd)\
1235 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1238 .#define bfd_coff_start_final_link(obfd, info)\
1239 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1241 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1242 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1243 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1244 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1245 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1246 . (abfd, sec, rel, h, sym, addendp))
1247 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1248 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1249 . (obfd, info, ibfd, sec, rel, adjustedp))
1250 .#define bfd_coff_link_add_one_symbol(info,abfd,name,flags,section,value,string,cp,coll,hashp)\
1251 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1252 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1254 .#define bfd_coff_link_output_has_begun(a,p) \
1255 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a,p))
1256 .#define bfd_coff_final_link_postscript(a,p) \
1257 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a,p))
1261 /* See whether the magic number matches. */
1264 coff_bad_format_hook (abfd
, filehdr
)
1265 bfd
* abfd ATTRIBUTE_UNUSED
;
1268 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1270 if (BADMAG (*internal_f
))
1273 /* if the optional header is NULL or not the correct size then
1274 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1275 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1276 optional header is of a different size.
1278 But the mips keeps extra stuff in it's opthdr, so dont check
1282 #if defined(M88) || defined(I960)
1283 if (internal_f
->f_opthdr
!= 0 && AOUTSZ
!= internal_f
->f_opthdr
)
1290 /* Check whether this section uses an alignment other than the
1294 coff_set_custom_section_alignment (abfd
, section
, alignment_table
, table_size
)
1295 bfd
*abfd ATTRIBUTE_UNUSED
;
1297 const struct coff_section_alignment_entry
*alignment_table
;
1298 const unsigned int table_size
;
1300 const unsigned int default_alignment
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1303 for (i
= 0; i
< table_size
; ++i
)
1305 const char *secname
= bfd_get_section_name (abfd
, section
);
1306 if (alignment_table
[i
].comparison_length
== (unsigned int) -1
1307 ? strcmp (alignment_table
[i
].name
, secname
) == 0
1308 : strncmp (alignment_table
[i
].name
, secname
,
1309 alignment_table
[i
].comparison_length
) == 0)
1312 if (i
>= table_size
)
1315 if (alignment_table
[i
].default_alignment_min
!= COFF_ALIGNMENT_FIELD_EMPTY
1316 && default_alignment
< alignment_table
[i
].default_alignment_min
)
1319 if (alignment_table
[i
].default_alignment_max
!= COFF_ALIGNMENT_FIELD_EMPTY
1320 && default_alignment
> alignment_table
[i
].default_alignment_max
)
1323 section
->alignment_power
= alignment_table
[i
].alignment_power
;
1326 /* Custom section alignment records. */
1328 static const struct coff_section_alignment_entry
1329 coff_section_alignment_table
[] =
1331 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1332 COFF_SECTION_ALIGNMENT_ENTRIES
,
1334 /* There must not be any gaps between .stabstr sections. */
1335 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1336 1, COFF_ALIGNMENT_FIELD_EMPTY
, 0 },
1337 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1338 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1339 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1340 /* Similarly for the .ctors and .dtors sections. */
1341 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1342 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1343 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1344 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 }
1347 static const unsigned int coff_section_alignment_table_size
=
1348 sizeof coff_section_alignment_table
/ sizeof coff_section_alignment_table
[0];
1350 /* Initialize a section structure with information peculiar to this
1351 particular implementation of COFF. */
1354 coff_new_section_hook (abfd
, section
)
1358 combined_entry_type
*native
;
1360 section
->alignment_power
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1363 if (xcoff_data (abfd
)->text_align_power
!= 0
1364 && strcmp (bfd_get_section_name (abfd
, section
), ".text") == 0)
1365 section
->alignment_power
= xcoff_data (abfd
)->text_align_power
;
1366 if (xcoff_data (abfd
)->data_align_power
!= 0
1367 && strcmp (bfd_get_section_name (abfd
, section
), ".data") == 0)
1368 section
->alignment_power
= xcoff_data (abfd
)->data_align_power
;
1371 /* Allocate aux records for section symbols, to store size and
1374 @@ The 10 is a guess at a plausible maximum number of aux entries
1375 (but shouldn't be a constant). */
1376 native
= ((combined_entry_type
*)
1377 bfd_zalloc (abfd
, sizeof (combined_entry_type
) * 10));
1381 /* We don't need to set up n_name, n_value, or n_scnum in the native
1382 symbol information, since they'll be overriden by the BFD symbol
1383 anyhow. However, we do need to set the type and storage class,
1384 in case this symbol winds up getting written out. The value 0
1385 for n_numaux is already correct. */
1387 native
->u
.syment
.n_type
= T_NULL
;
1388 native
->u
.syment
.n_sclass
= C_STAT
;
1390 coffsymbol (section
->symbol
)->native
= native
;
1392 coff_set_custom_section_alignment (abfd
, section
,
1393 coff_section_alignment_table
,
1394 coff_section_alignment_table_size
);
1399 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1401 /* Set the alignment of a BFD section. */
1403 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1406 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1407 bfd
* abfd ATTRIBUTE_UNUSED
;
1411 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1415 /* Extract ALIGN from 2**ALIGN stored in section header */
1416 for (i
= 0; i
< 32; i
++)
1417 if ((1 << i
) >= hdr
->s_align
)
1421 /* TI tools hijack bits 8-11 for the alignment */
1422 i
= (hdr
->s_flags
>> 8) & 0xF ;
1424 section
->alignment_power
= i
;
1427 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1430 /* a couple of macros to help setting the alignment power field */
1431 #define ALIGN_SET(field,x,y) \
1432 if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x )\
1434 section->alignment_power = y;\
1437 #define ELIFALIGN_SET(field,x,y) \
1438 else if (( (field) & IMAGE_SCN_ALIGN_64BYTES) == x ) \
1440 section->alignment_power = y;\
1443 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1446 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1447 bfd
* abfd ATTRIBUTE_UNUSED
;
1451 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1453 ALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_64BYTES
, 6)
1454 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_32BYTES
, 5)
1455 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_16BYTES
, 4)
1456 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_8BYTES
, 3)
1457 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_4BYTES
, 2)
1458 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_2BYTES
, 1)
1459 ELIFALIGN_SET (hdr
->s_flags
, IMAGE_SCN_ALIGN_1BYTES
, 0)
1461 #ifdef POWERPC_LE_PE
1462 if (strcmp (section
->name
, ".idata$2") == 0)
1464 section
->alignment_power
= 0;
1466 else if (strcmp (section
->name
, ".idata$3") == 0)
1468 section
->alignment_power
= 0;
1470 else if (strcmp (section
->name
, ".idata$4") == 0)
1472 section
->alignment_power
= 2;
1474 else if (strcmp (section
->name
, ".idata$5") == 0)
1476 section
->alignment_power
= 2;
1478 else if (strcmp (section
->name
, ".idata$6") == 0)
1480 section
->alignment_power
= 1;
1482 else if (strcmp (section
->name
, ".reloc") == 0)
1484 section
->alignment_power
= 1;
1486 else if (strncmp (section
->name
, ".stab", 5) == 0)
1488 section
->alignment_power
= 2;
1492 /* In a PE image file, the s_paddr field holds the virtual size of a
1493 section, while the s_size field holds the raw size. We also keep
1494 the original section flag value, since not every bit can be
1495 mapped onto a generic BFD section bit. */
1496 if (coff_section_data (abfd
, section
) == NULL
)
1498 section
->used_by_bfd
=
1499 (PTR
) bfd_zalloc (abfd
, sizeof (struct coff_section_tdata
));
1500 if (section
->used_by_bfd
== NULL
)
1502 /* FIXME: Return error. */
1506 if (pei_section_data (abfd
, section
) == NULL
)
1508 coff_section_data (abfd
, section
)->tdata
=
1509 (PTR
) bfd_zalloc (abfd
, sizeof (struct pei_section_tdata
));
1510 if (coff_section_data (abfd
, section
)->tdata
== NULL
)
1512 /* FIXME: Return error. */
1516 pei_section_data (abfd
, section
)->virt_size
= hdr
->s_paddr
;
1517 pei_section_data (abfd
, section
)->pe_flags
= hdr
->s_flags
;
1519 section
->lma
= hdr
->s_vaddr
;
1522 #undef ELIFALIGN_SET
1524 #else /* ! COFF_WITH_PE */
1527 /* We grossly abuse this function to handle XCOFF overflow headers.
1528 When we see one, we correct the reloc and line number counts in the
1529 real header, and remove the section we just created. */
1531 static void coff_set_alignment_hook
PARAMS ((bfd
*, asection
*, PTR
));
1534 coff_set_alignment_hook (abfd
, section
, scnhdr
)
1539 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1543 if ((hdr
->s_flags
& STYP_OVRFLO
) == 0)
1546 real_sec
= coff_section_from_bfd_index (abfd
, hdr
->s_nreloc
);
1547 if (real_sec
== NULL
)
1550 real_sec
->reloc_count
= hdr
->s_paddr
;
1551 real_sec
->lineno_count
= hdr
->s_vaddr
;
1553 for (ps
= &abfd
->sections
; *ps
!= NULL
; ps
= &(*ps
)->next
)
1558 --abfd
->section_count
;
1564 #else /* ! RS6000COFF_C */
1566 #define coff_set_alignment_hook \
1567 ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
1569 #endif /* ! RS6000COFF_C */
1570 #endif /* ! COFF_WITH_PE */
1571 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1573 #ifndef coff_mkobject
1575 static boolean coff_mkobject
PARAMS ((bfd
*));
1578 coff_mkobject (abfd
)
1581 coff_data_type
*coff
;
1583 abfd
->tdata
.coff_obj_data
= (struct coff_tdata
*) bfd_zalloc (abfd
, sizeof (coff_data_type
));
1584 if (abfd
->tdata
.coff_obj_data
== 0)
1586 coff
= coff_data (abfd
);
1587 coff
->symbols
= (coff_symbol_type
*) NULL
;
1588 coff
->conversion_table
= (unsigned int *) NULL
;
1589 coff
->raw_syments
= (struct coff_ptr_struct
*) NULL
;
1590 coff
->relocbase
= 0;
1591 coff
->local_toc_sym_map
= 0;
1593 /* make_abs_section(abfd);*/
1599 /* Create the COFF backend specific information. */
1600 #ifndef coff_mkobject_hook
1602 coff_mkobject_hook (abfd
, filehdr
, aouthdr
)
1605 PTR aouthdr ATTRIBUTE_UNUSED
;
1607 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1608 coff_data_type
*coff
;
1610 if (coff_mkobject (abfd
) == false)
1613 coff
= coff_data (abfd
);
1615 coff
->sym_filepos
= internal_f
->f_symptr
;
1617 /* These members communicate important constants about the symbol
1618 table to GDB's symbol-reading code. These `constants'
1619 unfortunately vary among coff implementations... */
1620 coff
->local_n_btmask
= N_BTMASK
;
1621 coff
->local_n_btshft
= N_BTSHFT
;
1622 coff
->local_n_tmask
= N_TMASK
;
1623 coff
->local_n_tshift
= N_TSHIFT
;
1624 coff
->local_symesz
= SYMESZ
;
1625 coff
->local_auxesz
= AUXESZ
;
1626 coff
->local_linesz
= LINESZ
;
1628 obj_raw_syment_count (abfd
) =
1629 obj_conv_table_size (abfd
) =
1630 internal_f
->f_nsyms
;
1633 if ((internal_f
->f_flags
& F_SHROBJ
) != 0)
1634 abfd
->flags
|= DYNAMIC
;
1635 if (aouthdr
!= NULL
&& internal_f
->f_opthdr
>= AOUTSZ
)
1637 struct internal_aouthdr
*internal_a
=
1638 (struct internal_aouthdr
*) aouthdr
;
1639 struct xcoff_tdata
*xcoff
;
1641 xcoff
= xcoff_data (abfd
);
1642 xcoff
->full_aouthdr
= true;
1643 xcoff
->toc
= internal_a
->o_toc
;
1644 xcoff
->sntoc
= internal_a
->o_sntoc
;
1645 xcoff
->snentry
= internal_a
->o_snentry
;
1646 xcoff
->text_align_power
= internal_a
->o_algntext
;
1647 xcoff
->data_align_power
= internal_a
->o_algndata
;
1648 xcoff
->modtype
= internal_a
->o_modtype
;
1649 xcoff
->cputype
= internal_a
->o_cputype
;
1650 xcoff
->maxdata
= internal_a
->o_maxdata
;
1651 xcoff
->maxstack
= internal_a
->o_maxstack
;
1656 /* Set the flags field from the COFF header read in */
1657 if (! _bfd_coff_arm_set_private_flags (abfd
, internal_f
->f_flags
))
1665 /* Determine the machine architecture and type. FIXME: This is target
1666 dependent because the magic numbers are defined in the target
1667 dependent header files. But there is no particular need for this.
1668 If the magic numbers were moved to a separate file, this function
1669 would be target independent and would also be much more successful
1670 at linking together COFF files for different architectures. */
1673 coff_set_arch_mach_hook (abfd
, filehdr
)
1678 enum bfd_architecture arch
;
1679 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1682 switch (internal_f
->f_magic
)
1686 arch
= bfd_arch_powerpc
;
1687 machine
= 0; /* what does this mean? (krk) */
1693 case I386AIXMAGIC
: /* Danbury PS/2 AIX C Compiler */
1694 case LYNXCOFFMAGIC
: /* shadows the m68k Lynx number below, sigh */
1695 arch
= bfd_arch_i386
;
1699 #ifdef A29K_MAGIC_BIG
1700 case A29K_MAGIC_BIG
:
1701 case A29K_MAGIC_LITTLE
:
1702 arch
= bfd_arch_a29k
;
1708 arch
= bfd_arch_arm
;
1709 switch (internal_f
->f_flags
& F_ARM_ARCHITECTURE_MASK
)
1711 case F_ARM_2
: machine
= bfd_mach_arm_2
; break;
1712 case F_ARM_2a
: machine
= bfd_mach_arm_2a
; break;
1713 case F_ARM_3
: machine
= bfd_mach_arm_3
; break;
1715 case F_ARM_3M
: machine
= bfd_mach_arm_3M
; break;
1716 case F_ARM_4
: machine
= bfd_mach_arm_4
; break;
1717 case F_ARM_4T
: machine
= bfd_mach_arm_4T
; break;
1718 case F_ARM_5
: machine
= bfd_mach_arm_5
; break;
1725 #ifdef MC68KBCSMAGIC
1728 #ifdef APOLLOM68KMAGIC
1729 case APOLLOM68KMAGIC
:
1731 #ifdef LYNXCOFFMAGIC
1734 arch
= bfd_arch_m68k
;
1735 machine
= bfd_mach_m68020
;
1742 arch
= bfd_arch_m88k
;
1748 arch
= bfd_arch_z8k
;
1749 switch (internal_f
->f_flags
& F_MACHMASK
)
1752 machine
= bfd_mach_z8001
;
1755 machine
= bfd_mach_z8002
;
1764 arch
= bfd_arch_i860
;
1771 arch
= bfd_arch_i960
;
1772 switch (F_I960TYPE
& internal_f
->f_flags
)
1776 machine
= bfd_mach_i960_core
;
1779 machine
= bfd_mach_i960_kb_sb
;
1782 machine
= bfd_mach_i960_mc
;
1785 machine
= bfd_mach_i960_xa
;
1788 machine
= bfd_mach_i960_ca
;
1791 machine
= bfd_mach_i960_ka_sa
;
1794 machine
= bfd_mach_i960_jx
;
1797 machine
= bfd_mach_i960_hx
;
1811 if (xcoff_data (abfd
)->cputype
!= -1)
1812 cputype
= xcoff_data (abfd
)->cputype
& 0xff;
1815 /* We did not get a value from the a.out header. If the
1816 file has not been stripped, we may be able to get the
1817 architecture information from the first symbol, if it
1818 is a .file symbol. */
1819 if (obj_raw_syment_count (abfd
) == 0)
1823 bfd_byte buf
[SYMESZ
];
1824 struct internal_syment sym
;
1826 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
1827 || bfd_read (buf
, 1, SYMESZ
, abfd
) != SYMESZ
)
1829 coff_swap_sym_in (abfd
, (PTR
) buf
, (PTR
) &sym
);
1830 if (sym
.n_sclass
== C_FILE
)
1831 cputype
= sym
.n_type
& 0xff;
1837 /* FIXME: We don't handle all cases here. */
1843 /* PowerPC Macs use the same magic numbers as RS/6000
1844 (because that's how they were bootstrapped originally),
1845 but they are always PowerPC architecture. */
1846 arch
= bfd_arch_powerpc
;
1849 arch
= bfd_arch_rs6000
;
1851 #endif /* POWERMAC */
1855 arch
= bfd_arch_powerpc
;
1858 case 2: /* 64 bit PowerPC */
1859 arch
= bfd_arch_powerpc
;
1863 arch
= bfd_arch_powerpc
;
1867 arch
= bfd_arch_rs6000
;
1877 arch
= bfd_arch_we32k
;
1884 arch
= bfd_arch_h8300
;
1885 machine
= bfd_mach_h8300
;
1886 /* !! FIXME this probably isn't the right place for this */
1887 abfd
->flags
|= BFD_IS_RELAXABLE
;
1893 arch
= bfd_arch_h8300
;
1894 machine
= bfd_mach_h8300h
;
1895 /* !! FIXME this probably isn't the right place for this */
1896 abfd
->flags
|= BFD_IS_RELAXABLE
;
1902 arch
= bfd_arch_h8300
;
1903 machine
= bfd_mach_h8300s
;
1904 /* !! FIXME this probably isn't the right place for this */
1905 abfd
->flags
|= BFD_IS_RELAXABLE
;
1909 #ifdef SH_ARCH_MAGIC_BIG
1910 case SH_ARCH_MAGIC_BIG
:
1911 case SH_ARCH_MAGIC_LITTLE
:
1919 arch
= bfd_arch_h8500
;
1926 #ifdef LYNXCOFFMAGIC
1929 arch
= bfd_arch_sparc
;
1936 arch
= bfd_arch_tic30
;
1940 #ifdef TIC80_ARCH_MAGIC
1941 case TIC80_ARCH_MAGIC
:
1942 arch
= bfd_arch_tic80
;
1948 arch
= bfd_arch_mcore
;
1951 default: /* Unreadable input file type */
1952 arch
= bfd_arch_obscure
;
1956 bfd_default_set_arch_mach (abfd
, arch
, machine
);
1960 #ifdef SYMNAME_IN_DEBUG
1962 static boolean symname_in_debug_hook
1963 PARAMS ((bfd
*, struct internal_syment
*));
1966 symname_in_debug_hook (abfd
, sym
)
1967 bfd
* abfd ATTRIBUTE_UNUSED
;
1968 struct internal_syment
*sym
;
1970 return SYMNAME_IN_DEBUG (sym
) ? true : false;
1975 #define symname_in_debug_hook \
1976 (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
1982 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */
1984 static boolean coff_pointerize_aux_hook
1985 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
1986 unsigned int, combined_entry_type
*));
1990 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
1991 bfd
*abfd ATTRIBUTE_UNUSED
;
1992 combined_entry_type
*table_base
;
1993 combined_entry_type
*symbol
;
1994 unsigned int indaux
;
1995 combined_entry_type
*aux
;
1997 int class = symbol
->u
.syment
.n_sclass
;
1999 if ((class == C_EXT
|| class == C_HIDEXT
)
2000 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2002 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) == XTY_LD
)
2004 aux
->u
.auxent
.x_csect
.x_scnlen
.p
=
2005 table_base
+ aux
->u
.auxent
.x_csect
.x_scnlen
.l
;
2006 aux
->fix_scnlen
= 1;
2009 /* Return true to indicate that the caller should not do any
2010 further work on this auxent. */
2014 /* Return false to indicate that this auxent should be handled by
2022 /* We don't want to pointerize bal entries. */
2024 static boolean coff_pointerize_aux_hook
2025 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
2026 unsigned int, combined_entry_type
*));
2030 coff_pointerize_aux_hook (abfd
, table_base
, symbol
, indaux
, aux
)
2031 bfd
*abfd ATTRIBUTE_UNUSED
;
2032 combined_entry_type
*table_base ATTRIBUTE_UNUSED
;
2033 combined_entry_type
*symbol
;
2034 unsigned int indaux
;
2035 combined_entry_type
*aux ATTRIBUTE_UNUSED
;
2037 /* Return true if we don't want to pointerize this aux entry, which
2038 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
2040 && (symbol
->u
.syment
.n_sclass
== C_LEAFPROC
2041 || symbol
->u
.syment
.n_sclass
== C_LEAFSTAT
2042 || symbol
->u
.syment
.n_sclass
== C_LEAFEXT
));
2047 #define coff_pointerize_aux_hook 0
2050 #endif /* ! RS6000COFF_C */
2052 /* Print an aux entry. This returns true if it has printed it. */
2054 static boolean coff_print_aux
2055 PARAMS ((bfd
*, FILE *, combined_entry_type
*, combined_entry_type
*,
2056 combined_entry_type
*, unsigned int));
2059 coff_print_aux (abfd
, file
, table_base
, symbol
, aux
, indaux
)
2060 bfd
*abfd ATTRIBUTE_UNUSED
;
2061 FILE *file ATTRIBUTE_UNUSED
;
2062 combined_entry_type
*table_base ATTRIBUTE_UNUSED
;
2063 combined_entry_type
*symbol ATTRIBUTE_UNUSED
;
2064 combined_entry_type
*aux ATTRIBUTE_UNUSED
;
2065 unsigned int indaux ATTRIBUTE_UNUSED
;
2068 if ((symbol
->u
.syment
.n_sclass
== C_EXT
2069 || symbol
->u
.syment
.n_sclass
== C_HIDEXT
)
2070 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2072 /* This is a csect entry. */
2073 fprintf (file
, "AUX ");
2074 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) != XTY_LD
)
2076 BFD_ASSERT (! aux
->fix_scnlen
);
2077 fprintf (file
, "val %5ld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2081 fprintf (file
, "indx ");
2082 if (! aux
->fix_scnlen
)
2083 fprintf (file
, "%4ld", aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2085 fprintf (file
, "%4ld",
2086 (long) (aux
->u
.auxent
.x_csect
.x_scnlen
.p
- table_base
));
2089 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2090 aux
->u
.auxent
.x_csect
.x_parmhash
,
2091 (unsigned int) aux
->u
.auxent
.x_csect
.x_snhash
,
2092 SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
),
2093 SMTYP_ALIGN (aux
->u
.auxent
.x_csect
.x_smtyp
),
2094 (unsigned int) aux
->u
.auxent
.x_csect
.x_smclas
,
2095 aux
->u
.auxent
.x_csect
.x_stab
,
2096 (unsigned int) aux
->u
.auxent
.x_csect
.x_snstab
);
2101 /* Return false to indicate that no special action was taken. */
2109 To write relocations, the back end steps though the
2110 canonical relocation table and create an
2111 @code{internal_reloc}. The symbol index to use is removed from
2112 the @code{offset} field in the symbol table supplied. The
2113 address comes directly from the sum of the section base
2114 address and the relocation offset; the type is dug directly
2115 from the howto field. Then the @code{internal_reloc} is
2116 swapped into the shape of an @code{external_reloc} and written
2123 static int compare_arelent_ptr
PARAMS ((const PTR
, const PTR
));
2125 /* AUX's ld wants relocations to be sorted */
2127 compare_arelent_ptr (x
, y
)
2131 const arelent
**a
= (const arelent
**) x
;
2132 const arelent
**b
= (const arelent
**) y
;
2133 bfd_size_type aadr
= (*a
)->address
;
2134 bfd_size_type badr
= (*b
)->address
;
2136 return (aadr
< badr
? -1 : badr
< aadr
? 1 : 0);
2139 #endif /* TARG_AUX */
2142 coff_write_relocs (abfd
, first_undef
)
2148 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
2151 struct external_reloc dst
;
2157 /* sort relocations before we write them out */
2158 p
= (arelent
**) bfd_malloc (s
->reloc_count
* sizeof (arelent
*));
2159 if (p
== NULL
&& s
->reloc_count
> 0)
2161 memcpy (p
, s
->orelocation
, s
->reloc_count
* sizeof (arelent
*));
2162 qsort (p
, s
->reloc_count
, sizeof (arelent
*), compare_arelent_ptr
);
2165 if (bfd_seek (abfd
, s
->rel_filepos
, SEEK_SET
) != 0)
2167 for (i
= 0; i
< s
->reloc_count
; i
++)
2169 struct internal_reloc n
;
2171 memset ((PTR
) & n
, 0, sizeof (n
));
2173 /* Now we've renumbered the symbols we know where the
2174 undefined symbols live in the table. Check the reloc
2175 entries for symbols who's output bfd isn't the right one.
2176 This is because the symbol was undefined (which means
2177 that all the pointers are never made to point to the same
2178 place). This is a bad thing,'cause the symbols attached
2179 to the output bfd are indexed, so that the relocation
2180 entries know which symbol index they point to. So we
2181 have to look up the output symbol here. */
2183 if (q
->sym_ptr_ptr
[0]->the_bfd
!= abfd
)
2186 const char *sname
= q
->sym_ptr_ptr
[0]->name
;
2187 asymbol
**outsyms
= abfd
->outsymbols
;
2188 for (i
= first_undef
; outsyms
[i
]; i
++)
2190 const char *intable
= outsyms
[i
]->name
;
2191 if (strcmp (intable
, sname
) == 0) {
2192 /* got a hit, so repoint the reloc */
2193 q
->sym_ptr_ptr
= outsyms
+ i
;
2199 n
.r_vaddr
= q
->address
+ s
->vma
;
2202 /* The 29k const/consth reloc pair is a real kludge. The consth
2203 part doesn't have a symbol; it has an offset. So rebuilt
2205 if (q
->howto
->type
== R_IHCONST
)
2206 n
.r_symndx
= q
->addend
;
2211 if (q
->sym_ptr_ptr
== bfd_abs_section_ptr
->symbol_ptr_ptr
)
2212 /* This is a relocation relative to the absolute symbol. */
2216 n
.r_symndx
= get_index ((*(q
->sym_ptr_ptr
)));
2217 /* Take notice if the symbol reloc points to a symbol
2218 we don't have in our symbol table. What should we
2220 if (n
.r_symndx
> obj_conv_table_size (abfd
))
2225 #ifdef SWAP_OUT_RELOC_OFFSET
2226 n
.r_offset
= q
->addend
;
2230 /* Work out reloc type from what is required */
2231 SELECT_RELOC (n
, q
->howto
);
2233 n
.r_type
= q
->howto
->type
;
2235 coff_swap_reloc_out (abfd
, &n
, &dst
);
2236 if (bfd_write ((PTR
) & dst
, 1, RELSZ
, abfd
) != RELSZ
)
2249 /* Set flags and magic number of a coff file from architecture and machine
2250 type. Result is true if we can represent the arch&type, false if not. */
2253 coff_set_flags (abfd
, magicp
, flagsp
)
2255 unsigned int *magicp ATTRIBUTE_UNUSED
;
2256 unsigned short *flagsp ATTRIBUTE_UNUSED
;
2258 switch (bfd_get_arch (abfd
))
2263 switch (bfd_get_mach (abfd
))
2265 case bfd_mach_z8001
:
2268 case bfd_mach_z8002
:
2282 *magicp
= I960ROMAGIC
;
2284 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
2285 I960RWMAGIC); FIXME???
2287 switch (bfd_get_mach (abfd
))
2289 case bfd_mach_i960_core
:
2292 case bfd_mach_i960_kb_sb
:
2295 case bfd_mach_i960_mc
:
2298 case bfd_mach_i960_xa
:
2301 case bfd_mach_i960_ca
:
2304 case bfd_mach_i960_ka_sa
:
2307 case bfd_mach_i960_jx
:
2310 case bfd_mach_i960_hx
:
2323 case bfd_arch_tic30
:
2324 *magicp
= TIC30MAGIC
;
2327 #ifdef TIC80_ARCH_MAGIC
2328 case bfd_arch_tic80
:
2329 *magicp
= TIC80_ARCH_MAGIC
;
2334 * magicp
= ARMMAGIC
;
2336 if (APCS_SET (abfd
))
2338 if (APCS_26_FLAG (abfd
))
2339 * flagsp
|= F_APCS26
;
2341 if (APCS_FLOAT_FLAG (abfd
))
2342 * flagsp
|= F_APCS_FLOAT
;
2344 if (PIC_FLAG (abfd
))
2347 if (INTERWORK_SET (abfd
) && INTERWORK_FLAG (abfd
))
2348 * flagsp
|= F_INTERWORK
;
2349 switch (bfd_get_mach (abfd
))
2351 case bfd_mach_arm_2
: * flagsp
|= F_ARM_2
; break;
2352 case bfd_mach_arm_2a
: * flagsp
|= F_ARM_2a
; break;
2353 case bfd_mach_arm_3
: * flagsp
|= F_ARM_3
; break;
2354 case bfd_mach_arm_3M
: * flagsp
|= F_ARM_3M
; break;
2355 case bfd_mach_arm_4
: * flagsp
|= F_ARM_4
; break;
2356 case bfd_mach_arm_4T
: * flagsp
|= F_ARM_4T
; break;
2357 case bfd_mach_arm_5
: * flagsp
|= F_ARM_5
; break;
2358 case bfd_mach_arm_5T
: * flagsp
|= F_ARM_5
; break; /* XXX - we do not have an F_ARM_5T */
2363 case bfd_arch_powerpc
:
2370 *magicp
= I386MAGIC
;
2372 /* Just overwrite the usual value if we're doing Lynx. */
2373 *magicp
= LYNXCOFFMAGIC
;
2380 *magicp
= I860MAGIC
;
2386 #ifdef APOLLOM68KMAGIC
2387 *magicp
= APOLLO_COFF_VERSION_NUMBER
;
2389 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2390 #ifdef NAMES_HAVE_UNDERSCORE
2391 *magicp
= MC68KBCSMAGIC
;
2393 *magicp
= MC68MAGIC
;
2397 /* Just overwrite the usual value if we're doing Lynx. */
2398 *magicp
= LYNXCOFFMAGIC
;
2406 *magicp
= MC88OMAGIC
;
2411 case bfd_arch_h8300
:
2412 switch (bfd_get_mach (abfd
))
2414 case bfd_mach_h8300
:
2415 *magicp
= H8300MAGIC
;
2417 case bfd_mach_h8300h
:
2418 *magicp
= H8300HMAGIC
;
2420 case bfd_mach_h8300s
:
2421 *magicp
= H8300SMAGIC
;
2427 #ifdef SH_ARCH_MAGIC_BIG
2429 if (bfd_big_endian (abfd
))
2430 *magicp
= SH_ARCH_MAGIC_BIG
;
2432 *magicp
= SH_ARCH_MAGIC_LITTLE
;
2438 case bfd_arch_sparc
:
2439 *magicp
= SPARCMAGIC
;
2441 /* Just overwrite the usual value if we're doing Lynx. */
2442 *magicp
= LYNXCOFFMAGIC
;
2449 case bfd_arch_h8500
:
2450 *magicp
= H8500MAGIC
;
2454 #ifdef A29K_MAGIC_BIG
2456 if (bfd_big_endian (abfd
))
2457 *magicp
= A29K_MAGIC_BIG
;
2459 *magicp
= A29K_MAGIC_LITTLE
;
2465 case bfd_arch_we32k
:
2466 *magicp
= WE32KMAGIC
;
2472 case bfd_arch_rs6000
:
2474 case bfd_arch_powerpc
:
2476 *magicp
= U802TOCMAGIC
;
2482 case bfd_arch_mcore
:
2483 * magicp
= MCOREMAGIC
;
2487 default: /* Unknown architecture */
2488 /* return false; -- fall through to "return false" below, to avoid
2489 "statement never reached" errors on the one below. */
2498 coff_set_arch_mach (abfd
, arch
, machine
)
2500 enum bfd_architecture arch
;
2501 unsigned long machine
;
2504 unsigned short dummy2
;
2506 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
2509 if (arch
!= bfd_arch_unknown
&&
2510 coff_set_flags (abfd
, &dummy1
, &dummy2
) != true)
2511 return false; /* We can't represent this type */
2513 return true; /* We're easy ... */
2516 #ifdef COFF_IMAGE_WITH_PE
2518 /* This is used to sort sections by VMA, as required by PE image
2521 static int sort_by_secaddr
PARAMS ((const PTR
, const PTR
));
2524 sort_by_secaddr (arg1
, arg2
)
2528 const asection
*a
= *(const asection
**) arg1
;
2529 const asection
*b
= *(const asection
**) arg2
;
2531 if (a
->vma
< b
->vma
)
2533 else if (a
->vma
> b
->vma
)
2539 #endif /* COFF_IMAGE_WITH_PE */
2541 /* Calculate the file position for each section. */
2544 #define ALIGN_SECTIONS_IN_FILE
2547 #undef ALIGN_SECTIONS_IN_FILE
2551 coff_compute_section_file_positions (abfd
)
2555 asection
*previous
= (asection
*) NULL
;
2556 file_ptr sofar
= FILHSZ
;
2557 boolean align_adjust
;
2558 #ifdef ALIGN_SECTIONS_IN_FILE
2563 /* On XCOFF, if we have symbols, set up the .debug section. */
2564 if (bfd_get_symcount (abfd
) > 0)
2567 bfd_size_type i
, symcount
;
2571 symcount
= bfd_get_symcount (abfd
);
2572 for (symp
= abfd
->outsymbols
, i
= 0; i
< symcount
; symp
++, i
++)
2574 coff_symbol_type
*cf
;
2576 cf
= coff_symbol_from (abfd
, *symp
);
2578 && cf
->native
!= NULL
2579 && SYMNAME_IN_DEBUG (&cf
->native
->u
.syment
))
2583 len
= strlen (bfd_asymbol_name (*symp
));
2592 dsec
= bfd_make_section_old_way (abfd
, ".debug");
2595 dsec
->_raw_size
= sz
;
2596 dsec
->flags
|= SEC_HAS_CONTENTS
;
2601 #ifdef COFF_IMAGE_WITH_PE
2603 if (coff_data (abfd
)->link_info
)
2605 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
2608 page_size
= PE_DEF_FILE_ALIGNMENT
;
2610 #ifdef COFF_PAGE_SIZE
2611 int page_size
= COFF_PAGE_SIZE
;
2615 if (bfd_get_start_address (abfd
))
2617 /* A start address may have been added to the original file. In this
2618 case it will need an optional header to record it. */
2619 abfd
->flags
|= EXEC_P
;
2622 if (abfd
->flags
& EXEC_P
)
2625 else if (xcoff_data (abfd
)->full_aouthdr
)
2628 sofar
+= SMALL_AOUTSZ
;
2631 sofar
+= abfd
->section_count
* SCNHSZ
;
2634 /* XCOFF handles overflows in the reloc and line number count fields
2635 by allocating a new section header to hold the correct counts. */
2636 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2637 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
2641 #ifdef COFF_IMAGE_WITH_PE
2643 /* PE requires the sections to be in memory order when listed in
2644 the section headers. It also does not like empty loadable
2645 sections. The sections apparently do not have to be in the
2646 right order in the image file itself, but we do need to get the
2647 target_index values right. */
2650 asection
**section_list
;
2655 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2658 /* We allocate an extra cell to simplify the final loop. */
2659 section_list
= bfd_malloc (sizeof (struct asection
*) * (count
+ 1));
2660 if (section_list
== NULL
)
2664 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2666 section_list
[i
] = current
;
2669 section_list
[i
] = NULL
;
2671 qsort (section_list
, count
, sizeof (asection
*), sort_by_secaddr
);
2673 /* Rethread the linked list into sorted order; at the same time,
2674 assign target_index values. */
2676 abfd
->sections
= section_list
[0];
2677 for (i
= 0; i
< count
; i
++)
2679 current
= section_list
[i
];
2680 current
->next
= section_list
[i
+ 1];
2682 /* Later, if the section has zero size, we'll be throwing it
2683 away, so we don't want to number it now. Note that having
2684 a zero size and having real contents are different
2685 concepts: .bss has no contents, but (usually) non-zero
2687 if (current
->_raw_size
== 0)
2689 /* Discard. However, it still might have (valid) symbols
2690 in it, so arbitrarily set it to section 1 (indexing is
2691 1-based here; usually .text). __end__ and other
2692 contents of .endsection really have this happen.
2693 FIXME: This seems somewhat dubious. */
2694 current
->target_index
= 1;
2697 current
->target_index
= target_index
++;
2700 free (section_list
);
2702 #else /* ! COFF_IMAGE_WITH_PE */
2704 /* Set the target_index field. */
2708 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
2709 current
->target_index
= target_index
++;
2711 #endif /* ! COFF_IMAGE_WITH_PE */
2713 align_adjust
= false;
2714 for (current
= abfd
->sections
;
2715 current
!= (asection
*) NULL
;
2716 current
= current
->next
)
2718 #ifdef COFF_IMAGE_WITH_PE
2719 /* With PE we have to pad each section to be a multiple of its
2720 page size too, and remember both sizes. */
2721 if (coff_section_data (abfd
, current
) == NULL
)
2723 current
->used_by_bfd
=
2724 (PTR
) bfd_zalloc (abfd
, sizeof (struct coff_section_tdata
));
2725 if (current
->used_by_bfd
== NULL
)
2728 if (pei_section_data (abfd
, current
) == NULL
)
2730 coff_section_data (abfd
, current
)->tdata
=
2731 (PTR
) bfd_zalloc (abfd
, sizeof (struct pei_section_tdata
));
2732 if (coff_section_data (abfd
, current
)->tdata
== NULL
)
2735 if (pei_section_data (abfd
, current
)->virt_size
== 0)
2736 pei_section_data (abfd
, current
)->virt_size
= current
->_raw_size
;
2739 /* Only deal with sections which have contents. */
2740 if (!(current
->flags
& SEC_HAS_CONTENTS
))
2743 #ifdef COFF_IMAGE_WITH_PE
2744 /* Make sure we skip empty sections in a PE image. */
2745 if (current
->_raw_size
== 0)
2749 /* Align the sections in the file to the same boundary on
2750 which they are aligned in virtual memory. I960 doesn't
2751 do this (FIXME) so we can stay in sync with Intel. 960
2752 doesn't yet page from files... */
2753 #ifdef ALIGN_SECTIONS_IN_FILE
2754 if ((abfd
->flags
& EXEC_P
) != 0)
2756 /* make sure this section is aligned on the right boundary - by
2757 padding the previous section up if necessary */
2760 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
2761 if (previous
!= (asection
*) NULL
)
2763 previous
->_raw_size
+= sofar
- old_sofar
;
2769 /* In demand paged files the low order bits of the file offset
2770 must match the low order bits of the virtual address. */
2771 #ifdef COFF_PAGE_SIZE
2772 if ((abfd
->flags
& D_PAGED
) != 0
2773 && (current
->flags
& SEC_ALLOC
) != 0)
2774 sofar
+= (current
->vma
- sofar
) % page_size
;
2776 current
->filepos
= sofar
;
2778 #ifdef COFF_IMAGE_WITH_PE
2779 /* Set the padded size. */
2780 current
->_raw_size
= (current
->_raw_size
+ page_size
-1) & -page_size
;
2783 sofar
+= current
->_raw_size
;
2785 #ifdef ALIGN_SECTIONS_IN_FILE
2786 /* make sure that this section is of the right size too */
2787 if ((abfd
->flags
& EXEC_P
) == 0)
2789 bfd_size_type old_size
;
2791 old_size
= current
->_raw_size
;
2792 current
->_raw_size
= BFD_ALIGN (current
->_raw_size
,
2793 1 << current
->alignment_power
);
2794 align_adjust
= current
->_raw_size
!= old_size
;
2795 sofar
+= current
->_raw_size
- old_size
;
2800 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
2801 align_adjust
= sofar
!= old_sofar
;
2802 current
->_raw_size
+= sofar
- old_sofar
;
2806 #ifdef COFF_IMAGE_WITH_PE
2807 /* For PE we need to make sure we pad out to the aligned
2808 _raw_size, in case the caller only writes out data to the
2809 unaligned _raw_size. */
2810 if (pei_section_data (abfd
, current
)->virt_size
< current
->_raw_size
)
2811 align_adjust
= true;
2815 /* Force .lib sections to start at zero. The vma is then
2816 incremented in coff_set_section_contents. This is right for
2818 if (strcmp (current
->name
, _LIB
) == 0)
2819 bfd_set_section_vma (abfd
, current
, 0);
2825 /* It is now safe to write to the output file. If we needed an
2826 alignment adjustment for the last section, then make sure that
2827 there is a byte at offset sofar. If there are no symbols and no
2828 relocs, then nothing follows the last section. If we don't force
2829 the last byte out, then the file may appear to be truncated. */
2835 if (bfd_seek (abfd
, sofar
- 1, SEEK_SET
) != 0
2836 || bfd_write (&b
, 1, 1, abfd
) != 1)
2840 /* Make sure the relocations are aligned. We don't need to make
2841 sure that this byte exists, because it will only matter if there
2842 really are relocs. */
2843 sofar
= BFD_ALIGN (sofar
, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER
);
2845 obj_relocbase (abfd
) = sofar
;
2846 abfd
->output_has_begun
= true;
2853 /* This can never work, because it is called too late--after the
2854 section positions have been set. I can't figure out what it is
2855 for, so I am going to disable it--Ian Taylor 20 March 1996. */
2857 /* If .file, .text, .data, .bss symbols are missing, add them. */
2858 /* @@ Should we only be adding missing symbols, or overriding the aux
2859 values for existing section symbols? */
2861 coff_add_missing_symbols (abfd
)
2864 unsigned int nsyms
= bfd_get_symcount (abfd
);
2865 asymbol
**sympp
= abfd
->outsymbols
;
2868 int need_text
= 1, need_data
= 1, need_bss
= 1, need_file
= 1;
2870 for (i
= 0; i
< nsyms
; i
++)
2872 coff_symbol_type
*csym
= coff_symbol_from (abfd
, sympp
[i
]);
2876 /* only do this if there is a coff representation of the input
2878 if (csym
->native
&& csym
->native
->u
.syment
.n_sclass
== C_FILE
)
2883 name
= csym
->symbol
.name
;
2886 if (!strcmp (name
, _TEXT
))
2889 else if (!strcmp (name
, ".wtext"))
2892 else if (!strcmp (name
, _DATA
))
2894 else if (!strcmp (name
, _BSS
))
2898 /* Now i == bfd_get_symcount (abfd). */
2899 /* @@ For now, don't deal with .file symbol. */
2902 if (!need_text
&& !need_data
&& !need_bss
&& !need_file
)
2904 nsyms
+= need_text
+ need_data
+ need_bss
+ need_file
;
2905 sympp2
= (asymbol
**) bfd_alloc (abfd
, nsyms
* sizeof (asymbol
*));
2908 memcpy (sympp2
, sympp
, i
* sizeof (asymbol
*));
2911 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
2915 sympp2
[i
++] = coff_section_symbol (abfd
, _TEXT
);
2917 sympp2
[i
++] = coff_section_symbol (abfd
, _DATA
);
2919 sympp2
[i
++] = coff_section_symbol (abfd
, _BSS
);
2920 BFD_ASSERT (i
== nsyms
);
2921 bfd_set_symtab (abfd
, sympp2
, nsyms
);
2930 coff_write_object_contents (abfd
)
2934 boolean hasrelocs
= false;
2935 boolean haslinno
= false;
2937 file_ptr reloc_base
;
2938 file_ptr lineno_base
;
2940 unsigned long reloc_size
= 0;
2941 unsigned long lnno_size
= 0;
2942 boolean long_section_names
;
2943 asection
*text_sec
= NULL
;
2944 asection
*data_sec
= NULL
;
2945 asection
*bss_sec
= NULL
;
2946 struct internal_filehdr internal_f
;
2947 struct internal_aouthdr internal_a
;
2948 #ifdef COFF_LONG_SECTION_NAMES
2949 size_t string_size
= STRING_SIZE_SIZE
;
2952 bfd_set_error (bfd_error_system_call
);
2954 /* Make a pass through the symbol table to count line number entries and
2955 put them into the correct asections */
2957 lnno_size
= coff_count_linenumbers (abfd
) * LINESZ
;
2959 if (abfd
->output_has_begun
== false)
2961 if (! coff_compute_section_file_positions (abfd
))
2965 reloc_base
= obj_relocbase (abfd
);
2967 /* Work out the size of the reloc and linno areas */
2969 for (current
= abfd
->sections
; current
!= NULL
; current
=
2971 reloc_size
+= current
->reloc_count
* RELSZ
;
2973 lineno_base
= reloc_base
+ reloc_size
;
2974 sym_base
= lineno_base
+ lnno_size
;
2976 /* Indicate in each section->line_filepos its actual file address */
2977 for (current
= abfd
->sections
; current
!= NULL
; current
=
2980 if (current
->lineno_count
)
2982 current
->line_filepos
= lineno_base
;
2983 current
->moving_line_filepos
= lineno_base
;
2984 lineno_base
+= current
->lineno_count
* LINESZ
;
2988 current
->line_filepos
= 0;
2990 if (current
->reloc_count
)
2992 current
->rel_filepos
= reloc_base
;
2993 reloc_base
+= current
->reloc_count
* RELSZ
;
2997 current
->rel_filepos
= 0;
3001 /* Write section headers to the file. */
3002 internal_f
.f_nscns
= 0;
3004 if ((abfd
->flags
& EXEC_P
) != 0)
3005 scn_base
= FILHSZ
+ AOUTSZ
;
3010 if (xcoff_data (abfd
)->full_aouthdr
)
3013 scn_base
+= SMALL_AOUTSZ
;
3017 if (bfd_seek (abfd
, scn_base
, SEEK_SET
) != 0)
3020 long_section_names
= false;
3021 for (current
= abfd
->sections
;
3023 current
= current
->next
)
3025 struct internal_scnhdr section
;
3028 /* If we've got a .reloc section, remember. */
3030 #ifdef COFF_IMAGE_WITH_PE
3031 if (strcmp (current
->name
, ".reloc") == 0)
3033 pe_data (abfd
)->has_reloc_section
= 1;
3038 internal_f
.f_nscns
++;
3040 strncpy (section
.s_name
, current
->name
, SCNNMLEN
);
3042 #ifdef COFF_LONG_SECTION_NAMES
3043 /* Handle long section names as in PE. This must be compatible
3044 with the code in coff_write_symbols and _bfd_coff_final_link. */
3048 len
= strlen (current
->name
);
3051 memset (section
.s_name
, 0, SCNNMLEN
);
3052 sprintf (section
.s_name
, "/%lu", (unsigned long) string_size
);
3053 string_size
+= len
+ 1;
3054 long_section_names
= true;
3060 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3061 Ian Taylor <ian@cygnus.com>. */
3062 if (strcmp (current
->name
, _LIB
) == 0)
3063 section
.s_vaddr
= 0;
3066 section
.s_vaddr
= current
->vma
;
3067 section
.s_paddr
= current
->lma
;
3068 section
.s_size
= current
->_raw_size
;
3071 section
.s_paddr
= 0;
3073 #ifdef COFF_IMAGE_WITH_PE
3074 /* Reminder: s_paddr holds the virtual size of the section. */
3075 if (coff_section_data (abfd
, current
) != NULL
3076 && pei_section_data (abfd
, current
) != NULL
)
3077 section
.s_paddr
= pei_section_data (abfd
, current
)->virt_size
;
3079 section
.s_paddr
= 0;
3083 If this section has no size or is unloadable then the scnptr
3086 if (current
->_raw_size
== 0 ||
3087 (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3089 section
.s_scnptr
= 0;
3093 section
.s_scnptr
= current
->filepos
;
3095 section
.s_relptr
= current
->rel_filepos
;
3096 section
.s_lnnoptr
= current
->line_filepos
;
3097 section
.s_nreloc
= current
->reloc_count
;
3098 section
.s_nlnno
= current
->lineno_count
;
3099 if (current
->reloc_count
!= 0)
3101 if (current
->lineno_count
!= 0)
3105 /* Indicate the use of an XCOFF overflow section header. */
3106 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3108 section
.s_nreloc
= 0xffff;
3109 section
.s_nlnno
= 0xffff;
3113 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
3115 if (!strcmp (current
->name
, _TEXT
))
3119 else if (!strcmp (current
->name
, _DATA
))
3123 else if (!strcmp (current
->name
, _BSS
))
3129 section
.s_align
= (current
->alignment_power
3130 ? 1 << current
->alignment_power
3134 section
.s_flags
|= (current
->alignment_power
& 0xF) << 8;
3138 #ifdef COFF_IMAGE_WITH_PE
3139 /* Suppress output of the sections if they are null. ld
3140 includes the bss and data sections even if there is no size
3141 assigned to them. NT loader doesn't like it if these section
3142 headers are included if the sections themselves are not
3143 needed. See also coff_compute_section_file_positions. */
3144 if (section
.s_size
== 0)
3145 internal_f
.f_nscns
--;
3150 if (coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
3151 || bfd_write ((PTR
) (&buff
), 1, SCNHSZ
, abfd
) != SCNHSZ
)
3156 /* PE stores COMDAT section information in the symbol table. If
3157 this section is supposed to have some COMDAT info, track down
3158 the symbol in the symbol table and modify it. */
3159 if ((current
->flags
& SEC_LINK_ONCE
) != 0)
3161 unsigned int i
, count
;
3163 coff_symbol_type
*csym
= NULL
;
3167 count
= bfd_get_symcount (abfd
);
3168 for (i
= 0, psym
= abfd
->outsymbols
; i
< count
; i
++, psym
++)
3170 if ((*psym
)->section
!= current
)
3173 /* Remember the location of the first symbol in this
3175 if (psymsec
== NULL
)
3178 /* See if this is the section symbol. */
3179 if (strcmp ((*psym
)->name
, current
->name
) == 0)
3181 csym
= coff_symbol_from (abfd
, *psym
);
3183 || csym
->native
== NULL
3184 || csym
->native
->u
.syment
.n_numaux
< 1
3185 || csym
->native
->u
.syment
.n_sclass
!= C_STAT
3186 || csym
->native
->u
.syment
.n_type
!= T_NULL
)
3189 /* Here *PSYM is the section symbol for CURRENT. */
3196 Note that we might not if we're converting the file from
3197 some other object file format. */
3200 combined_entry_type
*aux
;
3202 /* We don't touch the x_checksum field. The
3203 x_associated field is not currently supported. */
3205 aux
= csym
->native
+ 1;
3206 switch (current
->flags
& SEC_LINK_DUPLICATES
)
3208 case SEC_LINK_DUPLICATES_DISCARD
:
3209 aux
->u
.auxent
.x_scn
.x_comdat
= IMAGE_COMDAT_SELECT_ANY
;
3212 case SEC_LINK_DUPLICATES_ONE_ONLY
:
3213 aux
->u
.auxent
.x_scn
.x_comdat
=
3214 IMAGE_COMDAT_SELECT_NODUPLICATES
;
3217 case SEC_LINK_DUPLICATES_SAME_SIZE
:
3218 aux
->u
.auxent
.x_scn
.x_comdat
=
3219 IMAGE_COMDAT_SELECT_SAME_SIZE
;
3222 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
3223 aux
->u
.auxent
.x_scn
.x_comdat
=
3224 IMAGE_COMDAT_SELECT_EXACT_MATCH
;
3228 /* The COMDAT symbol must be the first symbol from this
3229 section in the symbol table. In order to make this
3230 work, we move the COMDAT symbol before the first
3231 symbol we found in the search above. It's OK to
3232 rearrange the symbol table at this point, because
3233 coff_renumber_symbols is going to rearrange it
3234 further and fix up all the aux entries. */
3235 if (psym
!= psymsec
)
3241 for (pcopy
= psym
; pcopy
> psymsec
; pcopy
--)
3242 pcopy
[0] = pcopy
[-1];
3247 #endif /* COFF_WITH_PE */
3251 /* XCOFF handles overflows in the reloc and line number count fields
3252 by creating a new section header to hold the correct values. */
3253 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3255 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3257 struct internal_scnhdr scnhdr
;
3260 internal_f
.f_nscns
++;
3261 strncpy (&(scnhdr
.s_name
[0]), current
->name
, 8);
3262 scnhdr
.s_paddr
= current
->reloc_count
;
3263 scnhdr
.s_vaddr
= current
->lineno_count
;
3265 scnhdr
.s_scnptr
= 0;
3266 scnhdr
.s_relptr
= current
->rel_filepos
;
3267 scnhdr
.s_lnnoptr
= current
->line_filepos
;
3268 scnhdr
.s_nreloc
= current
->target_index
;
3269 scnhdr
.s_nlnno
= current
->target_index
;
3270 scnhdr
.s_flags
= STYP_OVRFLO
;
3271 if (coff_swap_scnhdr_out (abfd
, &scnhdr
, &buff
) == 0
3272 || bfd_write ((PTR
) &buff
, 1, SCNHSZ
, abfd
) != SCNHSZ
)
3278 /* OK, now set up the filehdr... */
3280 /* Don't include the internal abs section in the section count */
3283 We will NOT put a fucking timestamp in the header here. Every time you
3284 put it back, I will come in and take it out again. I'm sorry. This
3285 field does not belong here. We fill it with a 0 so it compares the
3286 same but is not a reasonable time. -- gnu@cygnus.com
3288 internal_f
.f_timdat
= 0;
3290 internal_f
.f_flags
= 0;
3292 if (abfd
->flags
& EXEC_P
)
3293 internal_f
.f_opthdr
= AOUTSZ
;
3296 internal_f
.f_opthdr
= 0;
3298 if (xcoff_data (abfd
)->full_aouthdr
)
3299 internal_f
.f_opthdr
= AOUTSZ
;
3301 internal_f
.f_opthdr
= SMALL_AOUTSZ
;
3306 internal_f
.f_flags
|= F_RELFLG
;
3308 internal_f
.f_flags
|= F_LNNO
;
3309 if (abfd
->flags
& EXEC_P
)
3310 internal_f
.f_flags
|= F_EXEC
;
3312 #ifndef COFF_WITH_PE
3313 if (bfd_little_endian (abfd
))
3314 internal_f
.f_flags
|= F_AR32WR
;
3316 internal_f
.f_flags
|= F_AR32W
;
3319 #ifdef TIC80_TARGET_ID
3320 internal_f
.f_target_id
= TIC80_TARGET_ID
;
3324 FIXME, should do something about the other byte orders and
3329 if ((abfd
->flags
& DYNAMIC
) != 0)
3330 internal_f
.f_flags
|= F_SHROBJ
;
3331 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
3332 internal_f
.f_flags
|= F_DYNLOAD
;
3335 memset (&internal_a
, 0, sizeof internal_a
);
3337 /* Set up architecture-dependent stuff */
3340 unsigned int magic
= 0;
3341 unsigned short flags
= 0;
3342 coff_set_flags (abfd
, &magic
, &flags
);
3343 internal_f
.f_magic
= magic
;
3344 internal_f
.f_flags
|= flags
;
3345 /* ...and the "opt"hdr... */
3348 #ifdef ULTRA3 /* NYU's machine */
3349 /* FIXME: This is a bogus check. I really want to see if there
3350 * is a .shbss or a .shdata section, if so then set the magic
3351 * number to indicate a shared data executable.
3353 if (internal_f
.f_nscns
>= 7)
3354 internal_a
.magic
= SHMAGIC
; /* Shared magic */
3357 internal_a
.magic
= NMAGIC
; /* Assume separate i/d */
3358 #define __A_MAGIC_SET__
3361 internal_a
.magic
= TIC80_ARCH_MAGIC
;
3362 #define __A_MAGIC_SET__
3365 /* FIXME: What are the a.out magic numbers for the i860? */
3366 internal_a
.magic
= 0;
3367 #define __A_MAGIC_SET__
3370 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
3371 #define __A_MAGIC_SET__
3374 #define __A_MAGIC_SET__
3375 internal_a
.magic
= PAGEMAGICBCS
;
3379 #define __A_MAGIC_SET__
3380 internal_a
.magic
= APOLLO_COFF_VERSION_NUMBER
;
3383 #if defined(M68) || defined(WE32K) || defined(M68K)
3384 #define __A_MAGIC_SET__
3386 internal_a
.magic
= LYNXCOFFMAGIC
;
3388 #if defined(TARG_AUX)
3389 internal_a
.magic
= (abfd
->flags
& D_PAGED
? PAGEMAGICPEXECPAGED
:
3390 abfd
->flags
& WP_TEXT
? PAGEMAGICPEXECSWAPPED
:
3391 PAGEMAGICEXECSWAPPED
);
3393 #if defined (PAGEMAGICPEXECPAGED)
3394 internal_a
.magic
= PAGEMAGICPEXECPAGED
;
3396 #endif /* TARG_AUX */
3398 #endif /* M68 || WE32K || M68K */
3401 #define __A_MAGIC_SET__
3402 internal_a
.magic
= ZMAGIC
;
3406 #define __A_MAGIC_SET__
3407 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3410 #if defined MCORE_PE
3411 #define __A_MAGIC_SET__
3412 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
3416 #define __A_MAGIC_SET__
3418 internal_a
.magic
= LYNXCOFFMAGIC
;
3420 internal_a
.magic
= ZMAGIC
;
3425 #define __A_MAGIC_SET__
3427 internal_a
.magic
= LYNXCOFFMAGIC
;
3432 #define __A_MAGIC_SET__
3433 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
3434 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
3435 RS6K_AOUTHDR_OMAGIC
;
3438 #ifndef __A_MAGIC_SET__
3439 #include "Your aouthdr magic number is not being set!"
3441 #undef __A_MAGIC_SET__
3445 /* FIXME: Does anybody ever set this to another value? */
3446 internal_a
.vstamp
= 0;
3448 /* Now should write relocs, strings, syms */
3449 obj_sym_filepos (abfd
) = sym_base
;
3451 if (bfd_get_symcount (abfd
) != 0)
3455 if (!coff_add_missing_symbols (abfd
))
3458 if (!coff_renumber_symbols (abfd
, &firstundef
))
3460 coff_mangle_symbols (abfd
);
3461 if (! coff_write_symbols (abfd
))
3463 if (! coff_write_linenumbers (abfd
))
3465 if (! coff_write_relocs (abfd
, firstundef
))
3468 #ifdef COFF_LONG_SECTION_NAMES
3469 else if (long_section_names
)
3471 /* If we have long section names we have to write out the string
3472 table even if there are no symbols. */
3473 if (! coff_write_symbols (abfd
))
3477 #ifdef COFF_IMAGE_WITH_PE
3479 else if ((abfd
->flags
& EXEC_P
) != 0)
3483 /* PowerPC PE appears to require that all executable files be
3484 rounded up to the page size. */
3487 BFD_ALIGN (sym_base
, COFF_PAGE_SIZE
) - 1,
3489 || bfd_write (&b
, 1, 1, abfd
) != 1)
3495 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
3496 backend linker, and obj_raw_syment_count is not valid until after
3497 coff_write_symbols is called. */
3498 if (obj_raw_syment_count (abfd
) != 0)
3500 internal_f
.f_symptr
= sym_base
;
3502 /* AIX appears to require that F_RELFLG not be set if there are
3503 local symbols but no relocations. */
3504 internal_f
.f_flags
&=~ F_RELFLG
;
3509 if (long_section_names
)
3510 internal_f
.f_symptr
= sym_base
;
3512 internal_f
.f_symptr
= 0;
3513 internal_f
.f_flags
|= F_LSYMS
;
3518 internal_a
.tsize
= bfd_get_section_size_before_reloc (text_sec
);
3519 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
3523 internal_a
.dsize
= bfd_get_section_size_before_reloc (data_sec
);
3524 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
3528 internal_a
.bsize
= bfd_get_section_size_before_reloc (bss_sec
);
3529 if (internal_a
.bsize
&& bss_sec
->vma
< internal_a
.data_start
)
3530 internal_a
.data_start
= bss_sec
->vma
;
3533 internal_a
.entry
= bfd_get_start_address (abfd
);
3534 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
3537 if (xcoff_data (abfd
)->full_aouthdr
)
3540 asection
*loader_sec
;
3542 internal_a
.vstamp
= 1;
3544 internal_a
.o_snentry
= xcoff_data (abfd
)->snentry
;
3545 if (internal_a
.o_snentry
== 0)
3546 internal_a
.entry
= (bfd_vma
) -1;
3548 if (text_sec
!= NULL
)
3550 internal_a
.o_sntext
= text_sec
->target_index
;
3551 internal_a
.o_algntext
= bfd_get_section_alignment (abfd
, text_sec
);
3555 internal_a
.o_sntext
= 0;
3556 internal_a
.o_algntext
= 0;
3558 if (data_sec
!= NULL
)
3560 internal_a
.o_sndata
= data_sec
->target_index
;
3561 internal_a
.o_algndata
= bfd_get_section_alignment (abfd
, data_sec
);
3565 internal_a
.o_sndata
= 0;
3566 internal_a
.o_algndata
= 0;
3568 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
3569 if (loader_sec
!= NULL
)
3570 internal_a
.o_snloader
= loader_sec
->target_index
;
3572 internal_a
.o_snloader
= 0;
3573 if (bss_sec
!= NULL
)
3574 internal_a
.o_snbss
= bss_sec
->target_index
;
3576 internal_a
.o_snbss
= 0;
3578 toc
= xcoff_data (abfd
)->toc
;
3579 internal_a
.o_toc
= toc
;
3580 internal_a
.o_sntoc
= xcoff_data (abfd
)->sntoc
;
3582 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
3583 if (xcoff_data (abfd
)->cputype
!= -1)
3584 internal_a
.o_cputype
= xcoff_data (abfd
)->cputype
;
3587 switch (bfd_get_arch (abfd
))
3589 case bfd_arch_rs6000
:
3590 internal_a
.o_cputype
= 4;
3592 case bfd_arch_powerpc
:
3593 if (bfd_get_mach (abfd
) == 0)
3594 internal_a
.o_cputype
= 3;
3596 internal_a
.o_cputype
= 1;
3602 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
3603 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
3607 /* now write them */
3608 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
3612 coff_swap_filehdr_out (abfd
, (PTR
) & internal_f
, (PTR
) buff
);
3613 if (bfd_write ((PTR
) buff
, 1, FILHSZ
, abfd
) != FILHSZ
)
3616 if (abfd
->flags
& EXEC_P
)
3618 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
3619 include/coff/pe.h sets AOUTSZ == sizeof(PEAOUTHDR)) */
3621 coff_swap_aouthdr_out (abfd
, (PTR
) & internal_a
, (PTR
) buff
);
3622 if (bfd_write ((PTR
) buff
, 1, AOUTSZ
, abfd
) != AOUTSZ
)
3631 /* XCOFF seems to always write at least a small a.out header. */
3632 coff_swap_aouthdr_out (abfd
, (PTR
) &internal_a
, (PTR
) &buff
);
3633 if (xcoff_data (abfd
)->full_aouthdr
)
3636 size
= SMALL_AOUTSZ
;
3637 if (bfd_write ((PTR
) &buff
, 1, size
, abfd
) != size
)
3646 coff_set_section_contents (abfd
, section
, location
, offset
, count
)
3651 bfd_size_type count
;
3653 if (abfd
->output_has_begun
== false) /* set by bfd.c handler */
3655 if (! coff_compute_section_file_positions (abfd
))
3659 #if defined(_LIB) && !defined(TARG_AUX)
3661 /* The physical address field of a .lib section is used to hold the
3662 number of shared libraries in the section. This code counts the
3663 number of sections being written, and increments the lma field
3666 I have found no documentation on the contents of this section.
3667 Experimentation indicates that the section contains zero or more
3668 records, each of which has the following structure:
3670 - a (four byte) word holding the length of this record, in words,
3671 - a word that always seems to be set to "2",
3672 - the path to a shared library, null-terminated and then padded
3673 to a whole word boundary.
3675 bfd_assert calls have been added to alert if an attempt is made
3676 to write a section which doesn't follow these assumptions. The
3677 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
3678 <robertl@arnet.com> (Thanks!).
3680 Gvran Uddeborg <gvran@uddeborg.pp.se> */
3682 if (strcmp (section
->name
, _LIB
) == 0)
3684 bfd_byte
*rec
, *recend
;
3686 rec
= (bfd_byte
*) location
;
3687 recend
= rec
+ count
;
3688 while (rec
< recend
)
3691 rec
+= bfd_get_32 (abfd
, rec
) * 4;
3694 BFD_ASSERT (rec
== recend
);
3699 /* Don't write out bss sections - one way to do this is to
3700 see if the filepos has not been set. */
3701 if (section
->filepos
== 0)
3704 if (bfd_seek (abfd
, (file_ptr
) (section
->filepos
+ offset
), SEEK_SET
) != 0)
3709 return (bfd_write (location
, 1, count
, abfd
) == count
) ? true : false;
3715 coff_close_and_cleanup (abfd
)
3718 if (!bfd_read_p (abfd
))
3719 switch (abfd
->format
)
3722 if (!_bfd_write_archive_contents (abfd
))
3726 if (!coff_write_object_contents (abfd
))
3730 bfd_set_error (bfd_error_invalid_operation
);
3734 /* We depend on bfd_close to free all the memory on the objalloc. */
3741 buy_and_read (abfd
, where
, seek_direction
, size
)
3747 PTR area
= (PTR
) bfd_alloc (abfd
, size
);
3750 if (bfd_seek (abfd
, where
, seek_direction
) != 0
3751 || bfd_read (area
, 1, size
, abfd
) != size
)
3754 } /* buy_and_read() */
3760 Creating the linenumber table is done by reading in the entire
3761 coff linenumber table, and creating another table for internal use.
3763 A coff linenumber table is structured so that each function
3764 is marked as having a line number of 0. Each line within the
3765 function is an offset from the first line in the function. The
3766 base of the line number information for the table is stored in
3767 the symbol associated with the function.
3769 Note: The PE format uses line number 0 for a flag indicating a
3772 The information is copied from the external to the internal
3773 table, and each symbol which marks a function is marked by
3776 How does this work ?
3781 coff_slurp_line_table (abfd
, asect
)
3785 LINENO
*native_lineno
;
3786 alent
*lineno_cache
;
3788 BFD_ASSERT (asect
->lineno
== (alent
*) NULL
);
3790 native_lineno
= (LINENO
*) buy_and_read (abfd
,
3791 asect
->line_filepos
,
3794 asect
->lineno_count
));
3796 (alent
*) bfd_alloc (abfd
, (size_t) ((asect
->lineno_count
+ 1) * sizeof (alent
)));
3797 if (lineno_cache
== NULL
)
3801 unsigned int counter
= 0;
3802 alent
*cache_ptr
= lineno_cache
;
3803 LINENO
*src
= native_lineno
;
3805 while (counter
< asect
->lineno_count
)
3807 struct internal_lineno dst
;
3808 coff_swap_lineno_in (abfd
, src
, &dst
);
3809 cache_ptr
->line_number
= dst
.l_lnno
;
3811 if (cache_ptr
->line_number
== 0)
3815 coff_symbol_type
*sym
;
3818 symndx
= dst
.l_addr
.l_symndx
;
3820 || (unsigned long) symndx
>= obj_raw_syment_count (abfd
))
3822 (*_bfd_error_handler
)
3823 (_("%s: warning: illegal symbol index %ld in line numbers"),
3824 bfd_get_filename (abfd
), dst
.l_addr
.l_symndx
);
3828 /* FIXME: We should not be casting between ints and
3829 pointers like this. */
3830 sym
= ((coff_symbol_type
*)
3831 ((symndx
+ obj_raw_syments (abfd
))
3832 ->u
.syment
._n
._n_n
._n_zeroes
));
3833 cache_ptr
->u
.sym
= (asymbol
*) sym
;
3834 if (sym
->lineno
!= NULL
&& ! warned
)
3836 (*_bfd_error_handler
)
3837 (_("%s: warning: duplicate line number information for `%s'"),
3838 bfd_get_filename (abfd
),
3839 bfd_asymbol_name (&sym
->symbol
));
3841 sym
->lineno
= cache_ptr
;
3845 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
3846 - bfd_section_vma (abfd
, asect
);
3847 } /* If no linenumber expect a symbol index */
3853 cache_ptr
->line_number
= 0;
3856 asect
->lineno
= lineno_cache
;
3857 /* FIXME, free native_lineno here, or use alloca or something. */
3861 /* Slurp in the symbol table, converting it to generic form. Note
3862 that if coff_relocate_section is defined, the linker will read
3863 symbols via coff_link_add_symbols, rather than via this routine. */
3866 coff_slurp_symbol_table (abfd
)
3869 combined_entry_type
*native_symbols
;
3870 coff_symbol_type
*cached_area
;
3871 unsigned int *table_ptr
;
3873 unsigned int number_of_symbols
= 0;
3875 if (obj_symbols (abfd
))
3878 /* Read in the symbol table */
3879 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
3884 /* Allocate enough room for all the symbols in cached form */
3885 cached_area
= ((coff_symbol_type
*)
3887 (obj_raw_syment_count (abfd
)
3888 * sizeof (coff_symbol_type
))));
3890 if (cached_area
== NULL
)
3892 table_ptr
= ((unsigned int *)
3894 (obj_raw_syment_count (abfd
)
3895 * sizeof (unsigned int))));
3897 if (table_ptr
== NULL
)
3901 coff_symbol_type
*dst
= cached_area
;
3902 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
3903 unsigned int this_index
= 0;
3904 while (this_index
< last_native_index
)
3906 combined_entry_type
*src
= native_symbols
+ this_index
;
3907 table_ptr
[this_index
] = number_of_symbols
;
3908 dst
->symbol
.the_bfd
= abfd
;
3910 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
3911 /* We use the native name field to point to the cached field. */
3912 src
->u
.syment
._n
._n_n
._n_zeroes
= (long) dst
;
3913 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
3914 src
->u
.syment
.n_scnum
);
3915 dst
->symbol
.flags
= 0;
3916 dst
->done_lineno
= false;
3918 switch (src
->u
.syment
.n_sclass
)
3923 dst
->symbol
.value
= src
->u
.syment
.n_value
- dst
->symbol
.section
->vma
;
3924 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
3925 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
3927 /* Fall through to next case */
3935 case C_THUMBEXTFUNC
:
3941 case C_SYSTEM
: /* System Wide variable */
3944 /* In PE, 0x68 (104) denotes a section symbol */
3946 /* In PE, 0x69 (105) denotes a weak external symbol. */
3949 switch (coff_classify_symbol (abfd
, &src
->u
.syment
))
3951 case COFF_SYMBOL_GLOBAL
:
3952 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
3953 #if defined COFF_WITH_PE
3954 /* PE sets the symbol to a value relative to the
3955 start of the section. */
3956 dst
->symbol
.value
= src
->u
.syment
.n_value
;
3958 dst
->symbol
.value
= (src
->u
.syment
.n_value
3959 - dst
->symbol
.section
->vma
);
3961 if (ISFCN ((src
->u
.syment
.n_type
)))
3963 /* A function ext does not go at the end of a
3965 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
3969 case COFF_SYMBOL_COMMON
:
3970 dst
->symbol
.section
= bfd_com_section_ptr
;
3971 dst
->symbol
.value
= src
->u
.syment
.n_value
;
3974 case COFF_SYMBOL_UNDEFINED
:
3975 dst
->symbol
.section
= bfd_und_section_ptr
;
3976 dst
->symbol
.value
= 0;
3979 case COFF_SYMBOL_PE_SECTION
:
3980 dst
->symbol
.flags
|= BSF_EXPORT
| BSF_SECTION_SYM
;
3981 dst
->symbol
.value
= 0;
3984 case COFF_SYMBOL_LOCAL
:
3985 dst
->symbol
.flags
= BSF_LOCAL
;
3986 #if defined COFF_WITH_PE
3987 /* PE sets the symbol to a value relative to the
3988 start of the section. */
3989 dst
->symbol
.value
= src
->u
.syment
.n_value
;
3991 dst
->symbol
.value
= (src
->u
.syment
.n_value
3992 - dst
->symbol
.section
->vma
);
3994 if (ISFCN ((src
->u
.syment
.n_type
)))
3995 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4000 /* A symbol with a csect entry should not go at the end. */
4001 if (src
->u
.syment
.n_numaux
> 0)
4002 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
4006 if (src
->u
.syment
.n_sclass
== C_NT_WEAK
)
4007 dst
->symbol
.flags
= BSF_WEAK
;
4008 if (src
->u
.syment
.n_sclass
== C_SECTION
4009 && src
->u
.syment
.n_scnum
> 0)
4011 dst
->symbol
.flags
= BSF_LOCAL
;
4015 if (src
->u
.syment
.n_sclass
== C_WEAKEXT
)
4016 dst
->symbol
.flags
= BSF_WEAK
;
4020 case C_STAT
: /* static */
4022 case C_LEAFSTAT
: /* static leaf procedure */
4025 case C_THUMBSTAT
: /* Thumb static */
4026 case C_THUMBLABEL
: /* Thumb label */
4027 case C_THUMBSTATFUNC
:/* Thumb static function */
4029 case C_LABEL
: /* label */
4030 if (src
->u
.syment
.n_scnum
== N_DEBUG
)
4031 dst
->symbol
.flags
= BSF_DEBUGGING
;
4033 dst
->symbol
.flags
= BSF_LOCAL
;
4035 /* Base the value as an index from the base of the
4036 section, if there is one. */
4037 if (dst
->symbol
.section
)
4039 #if defined COFF_WITH_PE
4040 /* PE sets the symbol to a value relative to the
4041 start of the section. */
4042 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4044 dst
->symbol
.value
= (src
->u
.syment
.n_value
4045 - dst
->symbol
.section
->vma
);
4049 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4052 case C_MOS
: /* member of structure */
4053 case C_EOS
: /* end of structure */
4054 #ifdef NOTDEF /* C_AUTOARG has the same value */
4056 case C_GLBLREG
: /* A29k-specific storage class */
4059 case C_REGPARM
: /* register parameter */
4060 case C_REG
: /* register variable */
4063 case C_AUTOARG
: /* 960-specific storage class */
4066 case C_TPDEF
: /* type definition */
4068 case C_AUTO
: /* automatic variable */
4069 case C_FIELD
: /* bit field */
4070 case C_ENTAG
: /* enumeration tag */
4071 case C_MOE
: /* member of enumeration */
4072 case C_MOU
: /* member of union */
4073 case C_UNTAG
: /* union tag */
4074 dst
->symbol
.flags
= BSF_DEBUGGING
;
4075 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4078 case C_FILE
: /* file name */
4079 case C_STRTAG
: /* structure tag */
4094 dst
->symbol
.flags
= BSF_DEBUGGING
;
4095 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4099 case C_BINCL
: /* beginning of include file */
4100 case C_EINCL
: /* ending of include file */
4101 /* The value is actually a pointer into the line numbers
4102 of the file. We locate the line number entry, and
4103 set the section to the section which contains it, and
4104 the value to the index in that section. */
4108 dst
->symbol
.flags
= BSF_DEBUGGING
;
4109 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4110 if (sec
->line_filepos
<= (file_ptr
) src
->u
.syment
.n_value
4111 && ((file_ptr
) (sec
->line_filepos
4112 + sec
->lineno_count
* LINESZ
)
4113 > (file_ptr
) src
->u
.syment
.n_value
))
4116 dst
->symbol
.value
= 0;
4119 dst
->symbol
.section
= sec
;
4120 dst
->symbol
.value
= ((src
->u
.syment
.n_value
4121 - sec
->line_filepos
)
4129 dst
->symbol
.flags
= BSF_DEBUGGING
;
4131 /* The value is actually a symbol index. Save a pointer
4132 to the symbol instead of the index. FIXME: This
4133 should use a union. */
4134 src
->u
.syment
.n_value
=
4135 (long) (native_symbols
+ src
->u
.syment
.n_value
);
4136 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4141 case C_BLOCK
: /* ".bb" or ".eb" */
4142 case C_FCN
: /* ".bf" or ".ef" (or PE ".lf") */
4143 case C_EFCN
: /* physical end of function */
4144 #if defined COFF_WITH_PE
4145 /* PE sets the symbol to a value relative to the start
4147 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4148 if (strcmp (dst
->symbol
.name
, ".bf") != 0)
4150 /* PE uses funny values for .ef and .lf; don't
4152 dst
->symbol
.flags
= BSF_DEBUGGING
;
4155 dst
->symbol
.flags
= BSF_DEBUGGING
| BSF_DEBUGGING_RELOC
;
4157 /* Base the value as an index from the base of the
4159 dst
->symbol
.flags
= BSF_LOCAL
;
4160 dst
->symbol
.value
= (src
->u
.syment
.n_value
4161 - dst
->symbol
.section
->vma
);
4166 /* PE DLLs sometimes have zeroed out symbols for some
4167 reason. Just ignore them without a warning. */
4168 if (src
->u
.syment
.n_type
== 0
4169 && src
->u
.syment
.n_value
== 0
4170 && src
->u
.syment
.n_scnum
== 0)
4173 case C_EXTDEF
: /* external definition */
4174 case C_ULABEL
: /* undefined label */
4175 case C_USTATIC
: /* undefined static */
4176 #ifndef COFF_WITH_PE
4177 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4178 class to represent a section symbol */
4179 case C_LINE
: /* line # reformatted as symbol table entry */
4180 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4181 case C_ALIAS
: /* duplicate tag */
4183 /* New storage classes for TIc80 */
4185 case C_UEXT
: /* Tentative external definition */
4187 case C_STATLAB
: /* Static load time label */
4188 case C_EXTLAB
: /* External load time label */
4189 case C_HIDDEN
: /* ext symbol in dmert public lib */
4191 (*_bfd_error_handler
)
4192 (_("%s: Unrecognized storage class %d for %s symbol `%s'"),
4193 bfd_get_filename (abfd
), src
->u
.syment
.n_sclass
,
4194 dst
->symbol
.section
->name
, dst
->symbol
.name
);
4195 dst
->symbol
.flags
= BSF_DEBUGGING
;
4196 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4200 /* BFD_ASSERT(dst->symbol.flags != 0);*/
4204 dst
->symbol
.udata
.i
= 0;
4205 dst
->lineno
= (alent
*) NULL
;
4206 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
4208 number_of_symbols
++;
4209 } /* walk the native symtab */
4210 } /* bfdize the native symtab */
4212 obj_symbols (abfd
) = cached_area
;
4213 obj_raw_syments (abfd
) = native_symbols
;
4215 bfd_get_symcount (abfd
) = number_of_symbols
;
4216 obj_convert (abfd
) = table_ptr
;
4217 /* Slurp the line tables for each section too */
4223 coff_slurp_line_table (abfd
, p
);
4228 } /* coff_slurp_symbol_table() */
4230 /* Classify a COFF symbol. A couple of targets have globally visible
4231 symbols which are not class C_EXT, and this handles those. It also
4232 recognizes some special PE cases. */
4234 static enum coff_symbol_classification
4235 coff_classify_symbol (abfd
, syment
)
4237 struct internal_syment
*syment
;
4239 /* FIXME: This partially duplicates the switch in
4240 coff_slurp_symbol_table. */
4241 switch (syment
->n_sclass
)
4250 case C_THUMBEXTFUNC
:
4258 if (syment
->n_scnum
== 0)
4260 if (syment
->n_value
== 0)
4261 return COFF_SYMBOL_UNDEFINED
;
4263 return COFF_SYMBOL_COMMON
;
4265 return COFF_SYMBOL_GLOBAL
;
4272 if (syment
->n_sclass
== C_STAT
)
4274 if (syment
->n_scnum
== 0)
4276 /* The Microsoft compiler sometimes generates these if a
4277 small static function is inlined every time it is used.
4278 The function is discarded, but the symbol table entry
4280 return COFF_SYMBOL_LOCAL
;
4284 /* This is correct for Microsoft generated objects, but it
4285 breaks gas generated objects. */
4287 if (syment
->n_value
== 0)
4290 char buf
[SYMNMLEN
+ 1];
4292 sec
= coff_section_from_bfd_index (abfd
, syment
->n_scnum
);
4294 && (strcmp (bfd_get_section_name (abfd
, sec
),
4295 _bfd_coff_internal_syment_name (abfd
, syment
, buf
))
4297 return COFF_SYMBOL_PE_SECTION
;
4301 return COFF_SYMBOL_LOCAL
;
4304 if (syment
->n_sclass
== C_SECTION
)
4306 /* In some cases in a DLL generated by the Microsoft linker, the
4307 n_value field will contain garbage. FIXME: This should
4308 probably be handled by the swapping function instead. */
4309 syment
->n_value
= 0;
4310 if (syment
->n_scnum
== 0)
4311 return COFF_SYMBOL_UNDEFINED
;
4312 return COFF_SYMBOL_PE_SECTION
;
4314 #endif /* COFF_WITH_PE */
4316 /* If it is not a global symbol, we presume it is a local symbol. */
4318 if (syment
->n_scnum
== 0)
4320 char buf
[SYMNMLEN
+ 1];
4322 (*_bfd_error_handler
)
4323 (_("warning: %s: local symbol `%s' has no section"),
4324 bfd_get_filename (abfd
),
4325 _bfd_coff_internal_syment_name (abfd
, syment
, buf
));
4328 return COFF_SYMBOL_LOCAL
;
4335 Coff relocations are easily transformed into the internal BFD form
4338 Reading a coff relocation table is done in the following stages:
4340 o Read the entire coff relocation table into memory.
4342 o Process each relocation in turn; first swap it from the
4343 external to the internal form.
4345 o Turn the symbol referenced in the relocation's symbol index
4346 into a pointer into the canonical symbol table.
4347 This table is the same as the one returned by a call to
4348 @code{bfd_canonicalize_symtab}. The back end will call that
4349 routine and save the result if a canonicalization hasn't been done.
4351 o The reloc index is turned into a pointer to a howto
4352 structure, in a back end specific way. For instance, the 386
4353 and 960 use the @code{r_type} to directly produce an index
4354 into a howto table vector; the 88k subtracts a number from the
4355 @code{r_type} field and creates an addend field.
4361 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
4363 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \
4364 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
4365 coffsym = (obj_symbols (abfd) \
4366 + (cache_ptr->sym_ptr_ptr - symbols)); \
4368 coffsym = coff_symbol_from (abfd, ptr); \
4369 if (coffsym != (coff_symbol_type *) NULL \
4370 && coffsym->native->u.syment.n_scnum == 0) \
4371 cache_ptr->addend = 0; \
4372 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
4373 && ptr->section != (asection *) NULL) \
4374 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
4376 cache_ptr->addend = 0; \
4381 coff_slurp_reloc_table (abfd
, asect
, symbols
)
4386 RELOC
*native_relocs
;
4387 arelent
*reloc_cache
;
4392 if (asect
->relocation
)
4394 if (asect
->reloc_count
== 0)
4396 if (asect
->flags
& SEC_CONSTRUCTOR
)
4398 if (!coff_slurp_symbol_table (abfd
))
4401 (RELOC
*) buy_and_read (abfd
,
4405 asect
->reloc_count
));
4406 reloc_cache
= (arelent
*)
4407 bfd_alloc (abfd
, (size_t) (asect
->reloc_count
* sizeof (arelent
)));
4409 if (reloc_cache
== NULL
)
4413 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
4415 struct internal_reloc dst
;
4416 struct external_reloc
*src
;
4417 #ifndef RELOC_PROCESSING
4421 cache_ptr
= reloc_cache
+ idx
;
4422 src
= native_relocs
+ idx
;
4424 coff_swap_reloc_in (abfd
, src
, &dst
);
4426 #ifdef RELOC_PROCESSING
4427 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
4429 cache_ptr
->address
= dst
.r_vaddr
;
4431 if (dst
.r_symndx
!= -1)
4433 if (dst
.r_symndx
< 0 || dst
.r_symndx
>= obj_conv_table_size (abfd
))
4435 (*_bfd_error_handler
)
4436 (_("%s: warning: illegal symbol index %ld in relocs"),
4437 bfd_get_filename (abfd
), dst
.r_symndx
);
4438 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
4443 cache_ptr
->sym_ptr_ptr
= (symbols
4444 + obj_convert (abfd
)[dst
.r_symndx
]);
4445 ptr
= *(cache_ptr
->sym_ptr_ptr
);
4450 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
4454 /* The symbols definitions that we have read in have been
4455 relocated as if their sections started at 0. But the offsets
4456 refering to the symbols in the raw data have not been
4457 modified, so we have to have a negative addend to compensate.
4459 Note that symbols which used to be common must be left alone */
4461 /* Calculate any reloc addend by looking at the symbol */
4462 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
4464 cache_ptr
->address
-= asect
->vma
;
4465 /* !! cache_ptr->section = (asection *) NULL;*/
4467 /* Fill in the cache_ptr->howto field from dst.r_type */
4468 RTYPE2HOWTO (cache_ptr
, &dst
);
4469 #endif /* RELOC_PROCESSING */
4471 if (cache_ptr
->howto
== NULL
)
4473 (*_bfd_error_handler
)
4474 (_("%s: illegal relocation type %d at address 0x%lx"),
4475 bfd_get_filename (abfd
), dst
.r_type
, (long) dst
.r_vaddr
);
4476 bfd_set_error (bfd_error_bad_value
);
4481 asect
->relocation
= reloc_cache
;
4485 #ifndef coff_rtype_to_howto
4488 /* Get the howto structure for a reloc. This is only used if the file
4489 including this one defines coff_relocate_section to be
4490 _bfd_coff_generic_relocate_section, so it is OK if it does not
4491 always work. It is the responsibility of the including file to
4492 make sure it is reasonable if it is needed. */
4494 static reloc_howto_type
*coff_rtype_to_howto
4495 PARAMS ((bfd
*, asection
*, struct internal_reloc
*,
4496 struct coff_link_hash_entry
*, struct internal_syment
*,
4500 static reloc_howto_type
*
4501 coff_rtype_to_howto (abfd
, sec
, rel
, h
, sym
, addendp
)
4502 bfd
*abfd ATTRIBUTE_UNUSED
;
4503 asection
*sec ATTRIBUTE_UNUSED
;
4504 struct internal_reloc
*rel
;
4505 struct coff_link_hash_entry
*h ATTRIBUTE_UNUSED
;
4506 struct internal_syment
*sym ATTRIBUTE_UNUSED
;
4507 bfd_vma
*addendp ATTRIBUTE_UNUSED
;
4511 RTYPE2HOWTO (&genrel
, rel
);
4512 return genrel
.howto
;
4515 #else /* ! defined (RTYPE2HOWTO) */
4517 #define coff_rtype_to_howto NULL
4519 #endif /* ! defined (RTYPE2HOWTO) */
4520 #endif /* ! defined (coff_rtype_to_howto) */
4522 /* This is stupid. This function should be a boolean predicate. */
4524 coff_canonicalize_reloc (abfd
, section
, relptr
, symbols
)
4530 arelent
*tblptr
= section
->relocation
;
4531 unsigned int count
= 0;
4534 if (section
->flags
& SEC_CONSTRUCTOR
)
4536 /* this section has relocs made up by us, they are not in the
4537 file, so take them out of their chain and place them into
4538 the data area provided */
4539 arelent_chain
*chain
= section
->constructor_chain
;
4540 for (count
= 0; count
< section
->reloc_count
; count
++)
4542 *relptr
++ = &chain
->relent
;
4543 chain
= chain
->next
;
4549 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
4552 tblptr
= section
->relocation
;
4554 for (; count
++ < section
->reloc_count
;)
4555 *relptr
++ = tblptr
++;
4560 return section
->reloc_count
;
4565 coff_sym_filepos (abfd
)
4568 return obj_sym_filepos (abfd
);
4572 #ifndef coff_reloc16_estimate
4573 #define coff_reloc16_estimate dummy_reloc16_estimate
4575 static int dummy_reloc16_estimate
4576 PARAMS ((bfd
*, asection
*, arelent
*, unsigned int,
4577 struct bfd_link_info
*));
4580 dummy_reloc16_estimate (abfd
, input_section
, reloc
, shrink
, link_info
)
4581 bfd
*abfd ATTRIBUTE_UNUSED
;
4582 asection
*input_section ATTRIBUTE_UNUSED
;
4583 arelent
*reloc ATTRIBUTE_UNUSED
;
4584 unsigned int shrink ATTRIBUTE_UNUSED
;
4585 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
4593 #ifndef coff_reloc16_extra_cases
4595 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
4597 /* This works even if abort is not declared in any header file. */
4599 static void dummy_reloc16_extra_cases
4600 PARAMS ((bfd
*, struct bfd_link_info
*, struct bfd_link_order
*, arelent
*,
4601 bfd_byte
*, unsigned int *, unsigned int *));
4604 dummy_reloc16_extra_cases (abfd
, link_info
, link_order
, reloc
, data
, src_ptr
,
4606 bfd
*abfd ATTRIBUTE_UNUSED
;
4607 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
;
4608 struct bfd_link_order
*link_order ATTRIBUTE_UNUSED
;
4609 arelent
*reloc ATTRIBUTE_UNUSED
;
4610 bfd_byte
*data ATTRIBUTE_UNUSED
;
4611 unsigned int *src_ptr ATTRIBUTE_UNUSED
;
4612 unsigned int *dst_ptr ATTRIBUTE_UNUSED
;
4618 /* If coff_relocate_section is defined, we can use the optimized COFF
4619 backend linker. Otherwise we must continue to use the old linker. */
4620 #ifdef coff_relocate_section
4621 #ifndef coff_bfd_link_hash_table_create
4622 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
4624 #ifndef coff_bfd_link_add_symbols
4625 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
4627 #ifndef coff_bfd_final_link
4628 #define coff_bfd_final_link _bfd_coff_final_link
4630 #else /* ! defined (coff_relocate_section) */
4631 #define coff_relocate_section NULL
4632 #ifndef coff_bfd_link_hash_table_create
4633 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
4635 #ifndef coff_bfd_link_add_symbols
4636 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
4638 #define coff_bfd_final_link _bfd_generic_final_link
4639 #endif /* ! defined (coff_relocate_section) */
4641 #define coff_bfd_link_split_section _bfd_generic_link_split_section
4643 #ifndef coff_start_final_link
4644 #define coff_start_final_link NULL
4647 #ifndef coff_adjust_symndx
4648 #define coff_adjust_symndx NULL
4651 #ifndef coff_link_add_one_symbol
4652 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
4655 #ifndef coff_link_output_has_begun
4657 static boolean coff_link_output_has_begun
4658 PARAMS ((bfd
*, struct coff_final_link_info
*));
4661 coff_link_output_has_begun (abfd
, info
)
4663 struct coff_final_link_info
* info ATTRIBUTE_UNUSED
;
4665 return abfd
->output_has_begun
;
4669 #ifndef coff_final_link_postscript
4671 static boolean coff_final_link_postscript
4672 PARAMS ((bfd
*, struct coff_final_link_info
*));
4675 coff_final_link_postscript (abfd
, pfinfo
)
4676 bfd
* abfd ATTRIBUTE_UNUSED
;
4677 struct coff_final_link_info
* pfinfo ATTRIBUTE_UNUSED
;
4683 #ifndef coff_SWAP_aux_in
4684 #define coff_SWAP_aux_in coff_swap_aux_in
4686 #ifndef coff_SWAP_sym_in
4687 #define coff_SWAP_sym_in coff_swap_sym_in
4689 #ifndef coff_SWAP_lineno_in
4690 #define coff_SWAP_lineno_in coff_swap_lineno_in
4692 #ifndef coff_SWAP_aux_out
4693 #define coff_SWAP_aux_out coff_swap_aux_out
4695 #ifndef coff_SWAP_sym_out
4696 #define coff_SWAP_sym_out coff_swap_sym_out
4698 #ifndef coff_SWAP_lineno_out
4699 #define coff_SWAP_lineno_out coff_swap_lineno_out
4701 #ifndef coff_SWAP_reloc_out
4702 #define coff_SWAP_reloc_out coff_swap_reloc_out
4704 #ifndef coff_SWAP_filehdr_out
4705 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
4707 #ifndef coff_SWAP_aouthdr_out
4708 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
4710 #ifndef coff_SWAP_scnhdr_out
4711 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
4713 #ifndef coff_SWAP_reloc_in
4714 #define coff_SWAP_reloc_in coff_swap_reloc_in
4716 #ifndef coff_SWAP_filehdr_in
4717 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
4719 #ifndef coff_SWAP_aouthdr_in
4720 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
4722 #ifndef coff_SWAP_scnhdr_in
4723 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
4726 static const bfd_coff_backend_data bfd_coff_std_swap_table
=
4728 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
4729 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
4730 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
4731 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
4732 coff_SWAP_scnhdr_out
,
4733 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
4734 #ifdef COFF_LONG_FILENAMES
4739 #ifdef COFF_LONG_SECTION_NAMES
4744 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
4745 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
4746 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
4747 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
4748 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
4749 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
4750 coff_classify_symbol
, coff_compute_section_file_positions
,
4751 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
4752 coff_adjust_symndx
, coff_link_add_one_symbol
,
4753 coff_link_output_has_begun
, coff_final_link_postscript
4756 #ifndef coff_close_and_cleanup
4757 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
4760 #ifndef coff_bfd_free_cached_info
4761 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
4764 #ifndef coff_get_section_contents
4765 #define coff_get_section_contents _bfd_generic_get_section_contents
4768 #ifndef coff_bfd_copy_private_symbol_data
4769 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
4772 #ifndef coff_bfd_copy_private_section_data
4773 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
4776 #ifndef coff_bfd_copy_private_bfd_data
4777 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
4780 #ifndef coff_bfd_merge_private_bfd_data
4781 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
4784 #ifndef coff_bfd_set_private_flags
4785 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
4788 #ifndef coff_bfd_print_private_bfd_data
4789 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
4792 #ifndef coff_bfd_is_local_label_name
4793 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
4796 #ifndef coff_read_minisymbols
4797 #define coff_read_minisymbols _bfd_generic_read_minisymbols
4800 #ifndef coff_minisymbol_to_symbol
4801 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
4804 /* The reloc lookup routine must be supplied by each individual COFF
4806 #ifndef coff_bfd_reloc_type_lookup
4807 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
4810 #ifndef coff_bfd_get_relocated_section_contents
4811 #define coff_bfd_get_relocated_section_contents \
4812 bfd_generic_get_relocated_section_contents
4815 #ifndef coff_bfd_relax_section
4816 #define coff_bfd_relax_section bfd_generic_relax_section
4819 #ifndef coff_bfd_gc_sections
4820 #define coff_bfd_gc_sections bfd_generic_gc_sections
4823 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
4824 const bfd_target VAR = \
4827 bfd_target_coff_flavour, \
4828 BFD_ENDIAN_BIG, /* data byte order is big */ \
4829 BFD_ENDIAN_BIG, /* header byte order is big */ \
4830 /* object flags */ \
4831 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
4832 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
4833 /* section flags */ \
4834 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
4835 UNDER, /* leading symbol underscore */ \
4836 '/', /* ar_pad_char */ \
4837 15, /* ar_max_namelen */ \
4839 /* Data conversion functions. */ \
4840 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
4841 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
4842 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
4844 /* Header conversion functions. */ \
4845 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
4846 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
4847 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
4849 /* bfd_check_format */ \
4850 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
4851 _bfd_dummy_target }, \
4852 /* bfd_set_format */ \
4853 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
4854 /* bfd_write_contents */ \
4855 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
4858 BFD_JUMP_TABLE_GENERIC (coff), \
4859 BFD_JUMP_TABLE_COPY (coff), \
4860 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
4861 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
4862 BFD_JUMP_TABLE_SYMBOLS (coff), \
4863 BFD_JUMP_TABLE_RELOCS (coff), \
4864 BFD_JUMP_TABLE_WRITE (coff), \
4865 BFD_JUMP_TABLE_LINK (coff), \
4866 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
4873 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
4874 const bfd_target VAR = \
4877 bfd_target_coff_flavour, \
4878 BFD_ENDIAN_LITTLE, /* data byte order is little */ \
4879 BFD_ENDIAN_LITTLE, /* header byte order is little */ \
4880 /* object flags */ \
4881 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
4882 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
4883 /* section flags */ \
4884 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
4885 UNDER, /* leading symbol underscore */ \
4886 '/', /* ar_pad_char */ \
4887 15, /* ar_max_namelen */ \
4889 /* Data conversion functions. */ \
4890 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
4891 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
4892 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
4893 /* Header conversion functions. */ \
4894 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
4895 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
4896 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
4897 /* bfd_check_format */ \
4898 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
4899 _bfd_dummy_target }, \
4900 /* bfd_set_format */ \
4901 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
4902 /* bfd_write_contents */ \
4903 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
4906 BFD_JUMP_TABLE_GENERIC (coff), \
4907 BFD_JUMP_TABLE_COPY (coff), \
4908 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
4909 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
4910 BFD_JUMP_TABLE_SYMBOLS (coff), \
4911 BFD_JUMP_TABLE_RELOCS (coff), \
4912 BFD_JUMP_TABLE_WRITE (coff), \
4913 BFD_JUMP_TABLE_LINK (coff), \
4914 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \