1 /* Support for the generic parts of most COFF variants, for BFD.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
5 Written by Cygnus Support.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
24 /* Most of this hacked by Steve Chamberlain,
30 BFD supports a number of different flavours of coff format.
31 The major differences between formats are the sizes and
32 alignments of fields in structures on disk, and the occasional
35 Coff in all its varieties is implemented with a few common
36 files and a number of implementation specific files. For
37 example, The 88k bcs coff format is implemented in the file
38 @file{coff-m88k.c}. This file @code{#include}s
39 @file{coff/m88k.h} which defines the external structure of the
40 coff format for the 88k, and @file{coff/internal.h} which
41 defines the internal structure. @file{coff-m88k.c} also
42 defines the relocations used by the 88k format
45 The Intel i960 processor version of coff is implemented in
46 @file{coff-i960.c}. This file has the same structure as
47 @file{coff-m88k.c}, except that it includes @file{coff/i960.h}
48 rather than @file{coff-m88k.h}.
51 Porting to a new version of coff
53 The recommended method is to select from the existing
54 implementations the version of coff which is most like the one
55 you want to use. For example, we'll say that i386 coff is
56 the one you select, and that your coff flavour is called foo.
57 Copy @file{i386coff.c} to @file{foocoff.c}, copy
58 @file{../include/coff/i386.h} to @file{../include/coff/foo.h},
59 and add the lines to @file{targets.c} and @file{Makefile.in}
60 so that your new back end is used. Alter the shapes of the
61 structures in @file{../include/coff/foo.h} so that they match
62 what you need. You will probably also have to add
63 @code{#ifdef}s to the code in @file{coff/internal.h} and
64 @file{coffcode.h} if your version of coff is too wild.
66 You can verify that your new BFD backend works quite simply by
67 building @file{objdump} from the @file{binutils} directory,
68 and making sure that its version of what's going on and your
69 host system's idea (assuming it has the pretty standard coff
70 dump utility, usually called @code{att-dump} or just
71 @code{dump}) are the same. Then clean up your code, and send
72 what you've done to Cygnus. Then your stuff will be in the
73 next release, and you won't have to keep integrating it.
76 How the coff backend works
81 The Coff backend is split into generic routines that are
82 applicable to any Coff target and routines that are specific
83 to a particular target. The target-specific routines are
84 further split into ones which are basically the same for all
85 Coff targets except that they use the external symbol format
86 or use different values for certain constants.
88 The generic routines are in @file{coffgen.c}. These routines
89 work for any Coff target. They use some hooks into the target
90 specific code; the hooks are in a @code{bfd_coff_backend_data}
91 structure, one of which exists for each target.
93 The essentially similar target-specific routines are in
94 @file{coffcode.h}. This header file includes executable C code.
95 The various Coff targets first include the appropriate Coff
96 header file, make any special defines that are needed, and
97 then include @file{coffcode.h}.
99 Some of the Coff targets then also have additional routines in
100 the target source file itself.
102 For example, @file{coff-i960.c} includes
103 @file{coff/internal.h} and @file{coff/i960.h}. It then
104 defines a few constants, such as @code{I960}, and includes
105 @file{coffcode.h}. Since the i960 has complex relocation
106 types, @file{coff-i960.c} also includes some code to
107 manipulate the i960 relocs. This code is not in
108 @file{coffcode.h} because it would not be used by any other
112 Coff long section names
114 In the standard Coff object format, section names are limited to
115 the eight bytes available in the @code{s_name} field of the
116 @code{SCNHDR} section header structure. The format requires the
117 field to be NUL-padded, but not necessarily NUL-terminated, so
118 the longest section names permitted are a full eight characters.
120 The Microsoft PE variants of the Coff object file format add
121 an extension to support the use of long section names. This
122 extension is defined in section 4 of the Microsoft PE/COFF
123 specification (rev 8.1). If a section name is too long to fit
124 into the section header's @code{s_name} field, it is instead
125 placed into the string table, and the @code{s_name} field is
126 filled with a slash ("/") followed by the ASCII decimal
127 representation of the offset of the full name relative to the
130 Note that this implies that the extension can only be used in object
131 files, as executables do not contain a string table. The standard
132 specifies that long section names from objects emitted into executable
133 images are to be truncated.
135 However, as a GNU extension, BFD can generate executable images
136 that contain a string table and long section names. This
137 would appear to be technically valid, as the standard only says
138 that Coff debugging information is deprecated, not forbidden,
139 and in practice it works, although some tools that parse PE files
140 expecting the MS standard format may become confused; @file{PEview} is
143 The functionality is supported in BFD by code implemented under
144 the control of the macro @code{COFF_LONG_SECTION_NAMES}. If not
145 defined, the format does not support long section names in any way.
146 If defined, it is used to initialise a flag,
147 @code{_bfd_coff_long_section_names}, and a hook function pointer,
148 @code{_bfd_coff_set_long_section_names}, in the Coff backend data
149 structure. The flag controls the generation of long section names
150 in output BFDs at runtime; if it is false, as it will be by default
151 when generating an executable image, long section names are truncated;
152 if true, the long section names extension is employed. The hook
153 points to a function that allows the value of the flag to be altered
154 at runtime, on formats that support long section names at all; on
155 other formats it points to a stub that returns an error indication.
157 With input BFDs, the flag is set according to whether any long section
158 names are detected while reading the section headers. For a completely
159 new BFD, the flag is set to the default for the target format. This
160 information can be used by a client of the BFD library when deciding
161 what output format to generate, and means that a BFD that is opened
162 for read and subsequently converted to a writeable BFD and modified
163 in-place will retain whatever format it had on input.
165 If @code{COFF_LONG_SECTION_NAMES} is simply defined (blank), or is
166 defined to the value "1", then long section names are enabled by
167 default; if it is defined to the value zero, they are disabled by
168 default (but still accepted in input BFDs). The header @file{coffcode.h}
169 defines a macro, @code{COFF_DEFAULT_LONG_SECTION_NAMES}, which is
170 used in the backends to initialise the backend data structure fields
171 appropriately; see the comments for further detail.
176 Each flavour of coff supported in BFD has its own header file
177 describing the external layout of the structures. There is also
178 an internal description of the coff layout, in
179 @file{coff/internal.h}. A major function of the
180 coff backend is swapping the bytes and twiddling the bits to
181 translate the external form of the structures into the normal
182 internal form. This is all performed in the
183 @code{bfd_swap}_@i{thing}_@i{direction} routines. Some
184 elements are different sizes between different versions of
185 coff; it is the duty of the coff version specific include file
186 to override the definitions of various packing routines in
187 @file{coffcode.h}. E.g., the size of line number entry in coff is
188 sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
189 @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
190 correct one. No doubt, some day someone will find a version of
191 coff which has a varying field size not catered to at the
192 moment. To port BFD, that person will have to add more @code{#defines}.
193 Three of the bit twiddling routines are exported to
194 @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
195 and @code{coff_swap_lineno_in}. @code{GDB} reads the symbol
196 table on its own, but uses BFD to fix things up. More of the
197 bit twiddlers are exported for @code{gas};
198 @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
199 @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
200 @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
201 @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
202 of all the symbol table and reloc drudgery itself, thereby
203 saving the internal BFD overhead, but uses BFD to swap things
204 on the way out, making cross ports much safer. Doing so also
205 allows BFD (and thus the linker) to use the same header files
206 as @code{gas}, which makes one avenue to disaster disappear.
211 The simple canonical form for symbols used by BFD is not rich
212 enough to keep all the information available in a coff symbol
213 table. The back end gets around this problem by keeping the original
214 symbol table around, "behind the scenes".
216 When a symbol table is requested (through a call to
217 @code{bfd_canonicalize_symtab}), a request gets through to
218 @code{coff_get_normalized_symtab}. This reads the symbol table from
219 the coff file and swaps all the structures inside into the
220 internal form. It also fixes up all the pointers in the table
221 (represented in the file by offsets from the first symbol in
222 the table) into physical pointers to elements in the new
223 internal table. This involves some work since the meanings of
224 fields change depending upon context: a field that is a
225 pointer to another structure in the symbol table at one moment
226 may be the size in bytes of a structure at the next. Another
227 pass is made over the table. All symbols which mark file names
228 (<<C_FILE>> symbols) are modified so that the internal
229 string points to the value in the auxent (the real filename)
230 rather than the normal text associated with the symbol
233 At this time the symbol names are moved around. Coff stores
234 all symbols less than nine characters long physically
235 within the symbol table; longer strings are kept at the end of
236 the file in the string table. This pass moves all strings
237 into memory and replaces them with pointers to the strings.
239 The symbol table is massaged once again, this time to create
240 the canonical table used by the BFD application. Each symbol
241 is inspected in turn, and a decision made (using the
242 @code{sclass} field) about the various flags to set in the
243 @code{asymbol}. @xref{Symbols}. The generated canonical table
244 shares strings with the hidden internal symbol table.
246 Any linenumbers are read from the coff file too, and attached
247 to the symbols which own the functions the linenumbers belong to.
252 Writing a symbol to a coff file which didn't come from a coff
253 file will lose any debugging information. The @code{asymbol}
254 structure remembers the BFD from which the symbol was taken, and on
255 output the back end makes sure that the same destination target as
256 source target is present.
258 When the symbols have come from a coff file then all the
259 debugging information is preserved.
261 Symbol tables are provided for writing to the back end in a
262 vector of pointers to pointers. This allows applications like
263 the linker to accumulate and output large symbol tables
264 without having to do too much byte copying.
266 This function runs through the provided symbol table and
267 patches each symbol marked as a file place holder
268 (@code{C_FILE}) to point to the next file place holder in the
269 list. It also marks each @code{offset} field in the list with
270 the offset from the first symbol of the current symbol.
272 Another function of this procedure is to turn the canonical
273 value form of BFD into the form used by coff. Internally, BFD
274 expects symbol values to be offsets from a section base; so a
275 symbol physically at 0x120, but in a section starting at
276 0x100, would have the value 0x20. Coff expects symbols to
277 contain their final value, so symbols have their values
278 changed at this point to reflect their sum with their owning
279 section. This transformation uses the
280 <<output_section>> field of the @code{asymbol}'s
281 @code{asection} @xref{Sections}.
283 o <<coff_mangle_symbols>>
285 This routine runs though the provided symbol table and uses
286 the offsets generated by the previous pass and the pointers
287 generated when the symbol table was read in to create the
288 structured hierarchy required by coff. It changes each pointer
289 to a symbol into the index into the symbol table of the asymbol.
291 o <<coff_write_symbols>>
293 This routine runs through the symbol table and patches up the
294 symbols from their internal form into the coff way, calls the
295 bit twiddlers, and writes out the table to the file.
304 The hidden information for an <<asymbol>> is described in a
305 <<combined_entry_type>>:
309 .typedef struct coff_ptr_struct
311 . {* Remembers the offset from the first symbol in the file for
312 . this symbol. Generated by coff_renumber_symbols. *}
313 . unsigned int offset;
315 . {* Should the value of this symbol be renumbered. Used for
316 . XCOFF C_BSTAT symbols. Set by coff_slurp_symbol_table. *}
317 . unsigned int fix_value : 1;
319 . {* Should the tag field of this symbol be renumbered.
320 . Created by coff_pointerize_aux. *}
321 . unsigned int fix_tag : 1;
323 . {* Should the endidx field of this symbol be renumbered.
324 . Created by coff_pointerize_aux. *}
325 . unsigned int fix_end : 1;
327 . {* Should the x_csect.x_scnlen field be renumbered.
328 . Created by coff_pointerize_aux. *}
329 . unsigned int fix_scnlen : 1;
331 . {* Fix up an XCOFF C_BINCL/C_EINCL symbol. The value is the
332 . index into the line number entries. Set by coff_slurp_symbol_table. *}
333 . unsigned int fix_line : 1;
335 . {* The container for the symbol structure as read and translated
339 . union internal_auxent auxent;
340 . struct internal_syment syment;
342 .} combined_entry_type;
345 .{* Each canonical asymbol really looks like this: *}
347 .typedef struct coff_symbol_struct
349 . {* The actual symbol which the rest of BFD works with *}
352 . {* A pointer to the hidden information for this symbol *}
353 . combined_entry_type *native;
355 . {* A pointer to the linenumber information for this symbol *}
356 . struct lineno_cache_entry *lineno;
358 . {* Have the line numbers been relocated yet ? *}
359 . bfd_boolean done_lineno;
364 #include "libiberty.h"
369 #include "coffswap.h"
372 #define STRING_SIZE_SIZE 4
374 #define DOT_DEBUG ".debug"
375 #define GNU_LINKONCE_WI ".gnu.linkonce.wi."
376 #define GNU_LINKONCE_WT ".gnu.linkonce.wt."
377 #define DOT_RELOC ".reloc"
379 #if defined (COFF_LONG_SECTION_NAMES)
380 /* Needed to expand the inputs to BLANKOR1TOODD. */
381 #define COFFLONGSECTIONCATHELPER(x,y) x ## y
382 /* If the input macro Y is blank or '1', return an odd number; if it is
383 '0', return an even number. Result undefined in all other cases. */
384 #define BLANKOR1TOODD(y) COFFLONGSECTIONCATHELPER(1,y)
385 /* Defined to numerical 0 or 1 according to whether generation of long
386 section names is disabled or enabled by default. */
387 #define COFF_ENABLE_LONG_SECTION_NAMES (BLANKOR1TOODD(COFF_LONG_SECTION_NAMES) & 1)
388 /* Where long section names are supported, we allow them to be enabled
389 and disabled at runtime, so select an appropriate hook function for
390 _bfd_coff_set_long_section_names. */
391 #define COFF_LONG_SECTION_NAMES_SETTER bfd_coff_set_long_section_names_allowed
392 #else /* !defined (COFF_LONG_SECTION_NAMES) */
393 /* If long section names are not supported, this stub disallows any
394 attempt to enable them at run-time. */
395 #define COFF_LONG_SECTION_NAMES_SETTER bfd_coff_set_long_section_names_disallowed
396 #endif /* defined (COFF_LONG_SECTION_NAMES) */
398 /* Define a macro that can be used to initialise both the fields relating
399 to long section names in the backend data struct simultaneously. */
400 #if COFF_ENABLE_LONG_SECTION_NAMES
401 #define COFF_DEFAULT_LONG_SECTION_NAMES (TRUE), COFF_LONG_SECTION_NAMES_SETTER
402 #else /* !COFF_ENABLE_LONG_SECTION_NAMES */
403 #define COFF_DEFAULT_LONG_SECTION_NAMES (FALSE), COFF_LONG_SECTION_NAMES_SETTER
404 #endif /* COFF_ENABLE_LONG_SECTION_NAMES */
406 #if defined (COFF_LONG_SECTION_NAMES)
407 static bfd_boolean bfd_coff_set_long_section_names_allowed
409 #else /* !defined (COFF_LONG_SECTION_NAMES) */
410 static bfd_boolean bfd_coff_set_long_section_names_disallowed
412 #endif /* defined (COFF_LONG_SECTION_NAMES) */
413 static long sec_to_styp_flags
414 (const char *, flagword
);
415 static bfd_boolean styp_to_sec_flags
416 (bfd
*, void *, const char *, asection
*, flagword
*);
417 static bfd_boolean coff_bad_format_hook
419 static void coff_set_custom_section_alignment
420 (bfd
*, asection
*, const struct coff_section_alignment_entry
*,
422 static bfd_boolean coff_new_section_hook
424 static bfd_boolean coff_set_arch_mach_hook
426 static bfd_boolean coff_write_relocs
428 static bfd_boolean coff_set_flags
429 (bfd
*, unsigned int *, unsigned short *);
430 static bfd_boolean coff_set_arch_mach
431 (bfd
*, enum bfd_architecture
, unsigned long) ATTRIBUTE_UNUSED
;
432 static bfd_boolean coff_compute_section_file_positions
434 static bfd_boolean coff_write_object_contents
435 (bfd
*) ATTRIBUTE_UNUSED
;
436 static bfd_boolean coff_set_section_contents
437 (bfd
*, asection
*, const void *, file_ptr
, bfd_size_type
);
438 static void * buy_and_read
439 (bfd
*, file_ptr
, bfd_size_type
);
440 static bfd_boolean coff_slurp_line_table
442 static bfd_boolean coff_slurp_symbol_table
444 static enum coff_symbol_classification coff_classify_symbol
445 (bfd
*, struct internal_syment
*);
446 static bfd_boolean coff_slurp_reloc_table
447 (bfd
*, asection
*, asymbol
**);
448 static long coff_canonicalize_reloc
449 (bfd
*, asection
*, arelent
**, asymbol
**);
450 #ifndef coff_mkobject_hook
451 static void * coff_mkobject_hook
452 (bfd
*, void *, void *);
455 static flagword handle_COMDAT
456 (bfd
*, flagword
, void *, const char *, asection
*);
458 #ifdef COFF_IMAGE_WITH_PE
459 static bfd_boolean coff_read_word
460 (bfd
*, unsigned int *);
461 static unsigned int coff_compute_checksum
463 static bfd_boolean coff_apply_checksum
467 static bfd_boolean ticoff0_bad_format_hook
469 static bfd_boolean ticoff1_bad_format_hook
473 /* void warning(); */
475 #if defined (COFF_LONG_SECTION_NAMES)
477 bfd_coff_set_long_section_names_allowed (bfd
*abfd
, int enable
)
479 coff_backend_info (abfd
)->_bfd_coff_long_section_names
= enable
;
482 #else /* !defined (COFF_LONG_SECTION_NAMES) */
484 bfd_coff_set_long_section_names_disallowed (bfd
*abfd
, int enable
)
490 #endif /* defined (COFF_LONG_SECTION_NAMES) */
492 /* Return a word with STYP_* (scnhdr.s_flags) flags set to represent
493 the incoming SEC_* flags. The inverse of this function is
494 styp_to_sec_flags(). NOTE: If you add to/change this routine, you
495 should probably mirror the changes in styp_to_sec_flags(). */
499 /* Macros for setting debugging flags. */
502 #define STYP_XCOFF_DEBUG STYP_DEBUG
504 #define STYP_XCOFF_DEBUG STYP_INFO
507 #ifdef COFF_ALIGN_IN_S_FLAGS
508 #define STYP_DEBUG_INFO STYP_DSECT
510 #define STYP_DEBUG_INFO STYP_INFO
514 sec_to_styp_flags (const char *sec_name
, flagword sec_flags
)
518 if (!strcmp (sec_name
, _TEXT
))
520 styp_flags
= STYP_TEXT
;
522 else if (!strcmp (sec_name
, _DATA
))
524 styp_flags
= STYP_DATA
;
526 else if (!strcmp (sec_name
, _BSS
))
528 styp_flags
= STYP_BSS
;
531 else if (!strcmp (sec_name
, _COMMENT
))
533 styp_flags
= STYP_INFO
;
534 #endif /* _COMMENT */
537 else if (!strcmp (sec_name
, _LIB
))
539 styp_flags
= STYP_LIB
;
543 else if (!strcmp (sec_name
, _LIT
))
545 styp_flags
= STYP_LIT
;
548 else if (CONST_STRNEQ (sec_name
, DOT_DEBUG
))
550 /* Handle the XCOFF debug section and DWARF2 debug sections. */
552 styp_flags
= STYP_XCOFF_DEBUG
;
554 styp_flags
= STYP_DEBUG_INFO
;
556 else if (CONST_STRNEQ (sec_name
, ".stab"))
558 styp_flags
= STYP_DEBUG_INFO
;
560 #ifdef COFF_LONG_SECTION_NAMES
561 else if (CONST_STRNEQ (sec_name
, GNU_LINKONCE_WI
)
562 || CONST_STRNEQ (sec_name
, GNU_LINKONCE_WT
))
564 styp_flags
= STYP_DEBUG_INFO
;
568 else if (!strcmp (sec_name
, _PAD
))
570 styp_flags
= STYP_PAD
;
572 else if (!strcmp (sec_name
, _LOADER
))
574 styp_flags
= STYP_LOADER
;
576 else if (!strcmp (sec_name
, _EXCEPT
))
578 styp_flags
= STYP_EXCEPT
;
580 else if (!strcmp (sec_name
, _TYPCHK
))
582 styp_flags
= STYP_TYPCHK
;
585 /* Try and figure out what it should be */
586 else if (sec_flags
& SEC_CODE
)
588 styp_flags
= STYP_TEXT
;
590 else if (sec_flags
& SEC_DATA
)
592 styp_flags
= STYP_DATA
;
594 else if (sec_flags
& SEC_READONLY
)
596 #ifdef STYP_LIT /* 29k readonly text/data section */
597 styp_flags
= STYP_LIT
;
599 styp_flags
= STYP_TEXT
;
600 #endif /* STYP_LIT */
602 else if (sec_flags
& SEC_LOAD
)
604 styp_flags
= STYP_TEXT
;
606 else if (sec_flags
& SEC_ALLOC
)
608 styp_flags
= STYP_BSS
;
612 if (sec_flags
& SEC_TIC54X_CLINK
)
613 styp_flags
|= STYP_CLINK
;
617 if (sec_flags
& SEC_TIC54X_BLOCK
)
618 styp_flags
|= STYP_BLOCK
;
622 if ((sec_flags
& (SEC_NEVER_LOAD
| SEC_COFF_SHARED_LIBRARY
)) != 0)
623 styp_flags
|= STYP_NOLOAD
;
629 #else /* COFF_WITH_PE */
631 /* The PE version; see above for the general comments. The non-PE
632 case seems to be more guessing, and breaks PE format; specifically,
633 .rdata is readonly, but it sure ain't text. Really, all this
634 should be set up properly in gas (or whatever assembler is in use),
635 and honor whatever objcopy/strip, etc. sent us as input. */
638 sec_to_styp_flags (const char *sec_name
, flagword sec_flags
)
641 bfd_boolean is_dbg
= FALSE
;
643 if (CONST_STRNEQ (sec_name
, DOT_DEBUG
)
644 #ifdef COFF_LONG_SECTION_NAMES
645 || CONST_STRNEQ (sec_name
, GNU_LINKONCE_WI
)
646 || CONST_STRNEQ (sec_name
, GNU_LINKONCE_WT
)
648 || CONST_STRNEQ (sec_name
, ".stab"))
651 /* caution: there are at least three groups of symbols that have
652 very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
653 SEC_* are the BFD internal flags, used for generic BFD
654 information. STYP_* are the COFF section flags which appear in
655 COFF files. IMAGE_SCN_* are the PE section flags which appear in
656 PE files. The STYP_* flags and the IMAGE_SCN_* flags overlap,
657 but there are more IMAGE_SCN_* flags. */
659 /* FIXME: There is no gas syntax to specify the debug section flag. */
661 sec_flags
= SEC_DEBUGGING
| SEC_READONLY
;
666 if ((sec_flags
& SEC_CODE
) != 0)
667 styp_flags
|= IMAGE_SCN_CNT_CODE
;
668 if ((sec_flags
& (SEC_DATA
| SEC_DEBUGGING
)) != 0)
669 styp_flags
|= IMAGE_SCN_CNT_INITIALIZED_DATA
;
670 if ((sec_flags
& SEC_ALLOC
) != 0 && (sec_flags
& SEC_LOAD
) == 0)
671 styp_flags
|= IMAGE_SCN_CNT_UNINITIALIZED_DATA
; /* ==STYP_BSS */
673 /* skip constRUCTOR */
675 if ((sec_flags
& SEC_IS_COMMON
) != 0)
676 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
677 if ((sec_flags
& SEC_DEBUGGING
) != 0)
678 styp_flags
|= IMAGE_SCN_MEM_DISCARDABLE
;
679 if ((sec_flags
& SEC_EXCLUDE
) != 0 && !is_dbg
)
680 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
681 if ((sec_flags
& SEC_NEVER_LOAD
) != 0 && !is_dbg
)
682 styp_flags
|= IMAGE_SCN_LNK_REMOVE
;
685 if (sec_flags
& SEC_LINK_ONCE
)
686 styp_flags
|= IMAGE_SCN_LNK_COMDAT
;
687 /* skip LINK_DUPLICATES */
688 /* skip LINKER_CREATED */
690 if ((sec_flags
& SEC_COFF_NOREAD
) == 0)
691 styp_flags
|= IMAGE_SCN_MEM_READ
; /* Invert NOREAD for read. */
692 if ((sec_flags
& SEC_READONLY
) == 0)
693 styp_flags
|= IMAGE_SCN_MEM_WRITE
; /* Invert READONLY for write. */
694 if (sec_flags
& SEC_CODE
)
695 styp_flags
|= IMAGE_SCN_MEM_EXECUTE
; /* CODE->EXECUTE. */
696 if (sec_flags
& SEC_COFF_SHARED
)
697 styp_flags
|= IMAGE_SCN_MEM_SHARED
; /* Shared remains meaningful. */
702 #endif /* COFF_WITH_PE */
704 /* Return a word with SEC_* flags set to represent the incoming STYP_*
705 flags (from scnhdr.s_flags). The inverse of this function is
706 sec_to_styp_flags(). NOTE: If you add to/change this routine, you
707 should probably mirror the changes in sec_to_styp_flags(). */
712 styp_to_sec_flags (bfd
*abfd ATTRIBUTE_UNUSED
,
715 asection
*section ATTRIBUTE_UNUSED
,
718 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
719 long styp_flags
= internal_s
->s_flags
;
720 flagword sec_flags
= 0;
723 if (styp_flags
& STYP_BLOCK
)
724 sec_flags
|= SEC_TIC54X_BLOCK
;
728 if (styp_flags
& STYP_CLINK
)
729 sec_flags
|= SEC_TIC54X_CLINK
;
733 if (styp_flags
& STYP_NOLOAD
)
734 sec_flags
|= SEC_NEVER_LOAD
;
735 #endif /* STYP_NOLOAD */
737 /* For 386 COFF, at least, an unloadable text or data section is
738 actually a shared library section. */
739 if (styp_flags
& STYP_TEXT
)
741 if (sec_flags
& SEC_NEVER_LOAD
)
742 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
744 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
746 else if (styp_flags
& STYP_DATA
)
748 if (sec_flags
& SEC_NEVER_LOAD
)
749 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
751 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
753 else if (styp_flags
& STYP_BSS
)
755 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
756 if (sec_flags
& SEC_NEVER_LOAD
)
757 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
760 sec_flags
|= SEC_ALLOC
;
762 else if (styp_flags
& STYP_INFO
)
764 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
765 defined. coff_compute_section_file_positions uses
766 COFF_PAGE_SIZE to ensure that the low order bits of the
767 section VMA and the file offset match. If we don't know
768 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
769 and demand page loading of the file will fail. */
770 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
771 sec_flags
|= SEC_DEBUGGING
;
774 else if (styp_flags
& STYP_PAD
)
776 else if (strcmp (name
, _TEXT
) == 0)
778 if (sec_flags
& SEC_NEVER_LOAD
)
779 sec_flags
|= SEC_CODE
| SEC_COFF_SHARED_LIBRARY
;
781 sec_flags
|= SEC_CODE
| SEC_LOAD
| SEC_ALLOC
;
783 else if (strcmp (name
, _DATA
) == 0)
785 if (sec_flags
& SEC_NEVER_LOAD
)
786 sec_flags
|= SEC_DATA
| SEC_COFF_SHARED_LIBRARY
;
788 sec_flags
|= SEC_DATA
| SEC_LOAD
| SEC_ALLOC
;
790 else if (strcmp (name
, _BSS
) == 0)
792 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
793 if (sec_flags
& SEC_NEVER_LOAD
)
794 sec_flags
|= SEC_ALLOC
| SEC_COFF_SHARED_LIBRARY
;
797 sec_flags
|= SEC_ALLOC
;
799 else if (CONST_STRNEQ (name
, DOT_DEBUG
)
801 || strcmp (name
, _COMMENT
) == 0
803 #ifdef COFF_LONG_SECTION_NAMES
804 || CONST_STRNEQ (name
, GNU_LINKONCE_WI
)
805 || CONST_STRNEQ (name
, GNU_LINKONCE_WT
)
807 || CONST_STRNEQ (name
, ".stab"))
809 #ifdef COFF_PAGE_SIZE
810 sec_flags
|= SEC_DEBUGGING
;
814 else if (strcmp (name
, _LIB
) == 0)
818 else if (strcmp (name
, _LIT
) == 0)
819 sec_flags
= SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
;
822 sec_flags
|= SEC_ALLOC
| SEC_LOAD
;
824 #ifdef STYP_LIT /* A29k readonly text/data section type. */
825 if ((styp_flags
& STYP_LIT
) == STYP_LIT
)
826 sec_flags
= (SEC_LOAD
| SEC_ALLOC
| SEC_READONLY
);
827 #endif /* STYP_LIT */
829 #ifdef STYP_OTHER_LOAD /* Other loaded sections. */
830 if (styp_flags
& STYP_OTHER_LOAD
)
831 sec_flags
= (SEC_LOAD
| SEC_ALLOC
);
832 #endif /* STYP_SDATA */
834 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
835 /* As a GNU extension, if the name begins with .gnu.linkonce, we
836 only link a single copy of the section. This is used to support
837 g++. g++ will emit each template expansion in its own section.
838 The symbols will be defined as weak, so that multiple definitions
839 are permitted. The GNU linker extension is to actually discard
840 all but one of the sections. */
841 if (CONST_STRNEQ (name
, ".gnu.linkonce"))
842 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
845 if (flags_ptr
== NULL
)
848 * flags_ptr
= sec_flags
;
852 #else /* COFF_WITH_PE */
855 handle_COMDAT (bfd
* abfd
,
861 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
862 bfd_byte
*esymstart
, *esym
, *esymend
;
864 char *target_name
= NULL
;
866 sec_flags
|= SEC_LINK_ONCE
;
868 /* Unfortunately, the PE format stores essential information in
869 the symbol table, of all places. We need to extract that
870 information now, so that objdump and the linker will know how
871 to handle the section without worrying about the symbols. We
872 can't call slurp_symtab, because the linker doesn't want the
875 /* COMDAT sections are special. The first symbol is the section
876 symbol, which tells what kind of COMDAT section it is. The
877 second symbol is the "comdat symbol" - the one with the
878 unique name. GNU uses the section symbol for the unique
879 name; MS uses ".text" for every comdat section. Sigh. - DJ */
881 /* This is not mirrored in sec_to_styp_flags(), but there
882 doesn't seem to be a need to, either, and it would at best be
885 if (! _bfd_coff_get_external_symbols (abfd
))
888 esymstart
= esym
= (bfd_byte
*) obj_coff_external_syms (abfd
);
889 esymend
= esym
+ obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
891 while (esym
< esymend
)
893 struct internal_syment isym
;
894 char buf
[SYMNMLEN
+ 1];
897 bfd_coff_swap_sym_in (abfd
, esym
, & isym
);
899 if (sizeof (internal_s
->s_name
) > SYMNMLEN
)
901 /* This case implies that the matching
902 symbol name will be in the string table. */
906 if (isym
.n_scnum
== section
->target_index
)
908 /* According to the MSVC documentation, the first
909 TWO entries with the section # are both of
910 interest to us. The first one is the "section
911 symbol" (section name). The second is the comdat
912 symbol name. Here, we've found the first
913 qualifying entry; we distinguish it from the
914 second with a state flag.
916 In the case of gas-generated (at least until that
917 is fixed) .o files, it isn't necessarily the
918 second one. It may be some other later symbol.
920 Since gas also doesn't follow MS conventions and
921 emits the section similar to .text$<name>, where
922 <something> is the name we're looking for, we
923 distinguish the two as follows:
925 If the section name is simply a section name (no
926 $) we presume it's MS-generated, and look at
927 precisely the second symbol for the comdat name.
928 If the section name has a $, we assume it's
929 gas-generated, and look for <something> (whatever
930 follows the $) as the comdat symbol. */
932 /* All 3 branches use this. */
933 symname
= _bfd_coff_internal_syment_name (abfd
, &isym
, buf
);
942 /* The first time we've seen the symbol. */
943 union internal_auxent aux
;
945 /* If it isn't the stuff we're expecting, die;
946 The MS documentation is vague, but it
947 appears that the second entry serves BOTH
948 as the comdat symbol and the defining
949 symbol record (either C_STAT or C_EXT,
950 possibly with an aux entry with debug
951 information if it's a function.) It
952 appears the only way to find the second one
953 is to count. (On Intel, they appear to be
954 adjacent, but on Alpha, they have been
957 Here, we think we've found the first one,
958 but there's some checking we can do to be
961 if (! ((isym
.n_sclass
== C_STAT
962 || isym
.n_sclass
== C_EXT
)
963 && BTYPE (isym
.n_type
) == T_NULL
964 && isym
.n_value
== 0))
967 /* FIXME LATER: MSVC generates section names
968 like .text for comdats. Gas generates
969 names like .text$foo__Fv (in the case of a
970 function). See comment above for more. */
972 if (isym
.n_sclass
== C_STAT
&& strcmp (name
, symname
) != 0)
973 _bfd_error_handler (_("%B: warning: COMDAT symbol '%s' does not match section name '%s'"),
974 abfd
, symname
, name
);
978 /* This is the section symbol. */
979 bfd_coff_swap_aux_in (abfd
, (esym
+ bfd_coff_symesz (abfd
)),
980 isym
.n_type
, isym
.n_sclass
,
981 0, isym
.n_numaux
, & aux
);
983 target_name
= strchr (name
, '$');
984 if (target_name
!= NULL
)
992 /* FIXME: Microsoft uses NODUPLICATES and
993 ASSOCIATIVE, but gnu uses ANY and
994 SAME_SIZE. Unfortunately, gnu doesn't do
995 the comdat symbols right. So, until we can
996 fix it to do the right thing, we are
997 temporarily disabling comdats for the MS
998 types (they're used in DLLs and C++, but we
999 don't support *their* C++ libraries anyway
1002 /* Cygwin does not follow the MS style, and
1003 uses ANY and SAME_SIZE where NODUPLICATES
1004 and ASSOCIATIVE should be used. For
1005 Interix, we just do the right thing up
1008 switch (aux
.x_scn
.x_comdat
)
1010 case IMAGE_COMDAT_SELECT_NODUPLICATES
:
1011 #ifdef STRICT_PE_FORMAT
1012 sec_flags
|= SEC_LINK_DUPLICATES_ONE_ONLY
;
1014 sec_flags
&= ~SEC_LINK_ONCE
;
1018 case IMAGE_COMDAT_SELECT_ANY
:
1019 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1022 case IMAGE_COMDAT_SELECT_SAME_SIZE
:
1023 sec_flags
|= SEC_LINK_DUPLICATES_SAME_SIZE
;
1026 case IMAGE_COMDAT_SELECT_EXACT_MATCH
:
1027 /* Not yet fully implemented ??? */
1028 sec_flags
|= SEC_LINK_DUPLICATES_SAME_CONTENTS
;
1031 /* debug$S gets this case; other
1034 /* There may be no symbol... we'll search
1035 the whole table... Is this the right
1036 place to play this game? Or should we do
1037 it when reading it in. */
1038 case IMAGE_COMDAT_SELECT_ASSOCIATIVE
:
1039 #ifdef STRICT_PE_FORMAT
1040 /* FIXME: This is not currently implemented. */
1041 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1043 sec_flags
&= ~SEC_LINK_ONCE
;
1047 default: /* 0 means "no symbol" */
1048 /* debug$F gets this case; other
1050 sec_flags
|= SEC_LINK_DUPLICATES_DISCARD
;
1057 /* Gas mode: the first matching on partial name. */
1059 #ifndef TARGET_UNDERSCORE
1060 #define TARGET_UNDERSCORE 0
1062 /* Is this the name we're looking for ? */
1063 if (strcmp (target_name
,
1064 symname
+ (TARGET_UNDERSCORE
? 1 : 0)) != 0)
1066 /* Not the name we're looking for */
1067 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
1072 /* MSVC mode: the lexically second symbol (or
1073 drop through from the above). */
1078 /* This must the second symbol with the
1079 section #. It is the actual symbol name.
1080 Intel puts the two adjacent, but Alpha (at
1081 least) spreads them out. */
1083 amt
= sizeof (struct coff_comdat_info
);
1084 coff_section_data (abfd
, section
)->comdat
1085 = (struct coff_comdat_info
*) bfd_alloc (abfd
, amt
);
1086 if (coff_section_data (abfd
, section
)->comdat
== NULL
)
1089 coff_section_data (abfd
, section
)->comdat
->symbol
=
1090 (esym
- esymstart
) / bfd_coff_symesz (abfd
);
1092 amt
= strlen (symname
) + 1;
1093 newname
= (char *) bfd_alloc (abfd
, amt
);
1094 if (newname
== NULL
)
1097 strcpy (newname
, symname
);
1098 coff_section_data (abfd
, section
)->comdat
->name
1106 esym
+= (isym
.n_numaux
+ 1) * bfd_coff_symesz (abfd
);
1114 /* The PE version; see above for the general comments.
1116 Since to set the SEC_LINK_ONCE and associated flags, we have to
1117 look at the symbol table anyway, we return the symbol table index
1118 of the symbol being used as the COMDAT symbol. This is admittedly
1119 ugly, but there's really nowhere else that we have access to the
1120 required information. FIXME: Is the COMDAT symbol index used for
1121 any purpose other than objdump? */
1124 styp_to_sec_flags (bfd
*abfd
,
1128 flagword
*flags_ptr
)
1130 struct internal_scnhdr
*internal_s
= (struct internal_scnhdr
*) hdr
;
1131 long styp_flags
= internal_s
->s_flags
;
1133 bfd_boolean result
= TRUE
;
1134 bfd_boolean is_dbg
= FALSE
;
1136 if (CONST_STRNEQ (name
, DOT_DEBUG
)
1137 #ifdef COFF_LONG_SECTION_NAMES
1138 || CONST_STRNEQ (name
, GNU_LINKONCE_WI
)
1139 || CONST_STRNEQ (name
, GNU_LINKONCE_WT
)
1141 || CONST_STRNEQ (name
, ".stab"))
1143 /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
1144 sec_flags
= SEC_READONLY
;
1146 /* If section disallows read, then set the NOREAD flag. */
1147 if ((styp_flags
& IMAGE_SCN_MEM_READ
) == 0)
1148 sec_flags
|= SEC_COFF_NOREAD
;
1150 /* Process each flag bit in styp_flags in turn. */
1153 long flag
= styp_flags
& - styp_flags
;
1154 char * unhandled
= NULL
;
1156 styp_flags
&= ~ flag
;
1158 /* We infer from the distinct read/write/execute bits the settings
1159 of some of the bfd flags; the actual values, should we need them,
1160 are also in pei_section_data (abfd, section)->pe_flags. */
1165 unhandled
= "STYP_DSECT";
1168 unhandled
= "STYP_GROUP";
1171 unhandled
= "STYP_COPY";
1174 unhandled
= "STYP_OVER";
1176 #ifdef SEC_NEVER_LOAD
1178 sec_flags
|= SEC_NEVER_LOAD
;
1181 case IMAGE_SCN_MEM_READ
:
1182 sec_flags
&= ~SEC_COFF_NOREAD
;
1184 case IMAGE_SCN_TYPE_NO_PAD
:
1187 case IMAGE_SCN_LNK_OTHER
:
1188 unhandled
= "IMAGE_SCN_LNK_OTHER";
1190 case IMAGE_SCN_MEM_NOT_CACHED
:
1191 unhandled
= "IMAGE_SCN_MEM_NOT_CACHED";
1193 case IMAGE_SCN_MEM_NOT_PAGED
:
1194 /* Generate a warning message rather using the 'unhandled'
1195 variable as this will allow some .sys files generate by
1196 other toolchains to be processed. See bugzilla issue 196. */
1197 _bfd_error_handler (_("%B: Warning: Ignoring section flag IMAGE_SCN_MEM_NOT_PAGED in section %s"),
1200 case IMAGE_SCN_MEM_EXECUTE
:
1201 sec_flags
|= SEC_CODE
;
1203 case IMAGE_SCN_MEM_WRITE
:
1204 sec_flags
&= ~ SEC_READONLY
;
1206 case IMAGE_SCN_MEM_DISCARDABLE
:
1207 /* The MS PE spec says that debug sections are DISCARDABLE,
1208 but the presence of a DISCARDABLE flag does not necessarily
1209 mean that a given section contains debug information. Thus
1210 we only set the SEC_DEBUGGING flag on sections that we
1211 recognise as containing debug information. */
1214 || strcmp (name
, _COMMENT
) == 0
1218 sec_flags
|= SEC_DEBUGGING
| SEC_READONLY
;
1221 case IMAGE_SCN_MEM_SHARED
:
1222 sec_flags
|= SEC_COFF_SHARED
;
1224 case IMAGE_SCN_LNK_REMOVE
:
1226 sec_flags
|= SEC_EXCLUDE
;
1228 case IMAGE_SCN_CNT_CODE
:
1229 sec_flags
|= SEC_CODE
| SEC_ALLOC
| SEC_LOAD
;
1231 case IMAGE_SCN_CNT_INITIALIZED_DATA
:
1233 sec_flags
|= SEC_DEBUGGING
;
1235 sec_flags
|= SEC_DATA
| SEC_ALLOC
| SEC_LOAD
;
1237 case IMAGE_SCN_CNT_UNINITIALIZED_DATA
:
1238 sec_flags
|= SEC_ALLOC
;
1240 case IMAGE_SCN_LNK_INFO
:
1241 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
1242 defined. coff_compute_section_file_positions uses
1243 COFF_PAGE_SIZE to ensure that the low order bits of the
1244 section VMA and the file offset match. If we don't know
1245 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
1246 and demand page loading of the file will fail. */
1247 #ifdef COFF_PAGE_SIZE
1248 sec_flags
|= SEC_DEBUGGING
;
1251 case IMAGE_SCN_LNK_COMDAT
:
1252 /* COMDAT gets very special treatment. */
1253 sec_flags
= handle_COMDAT (abfd
, sec_flags
, hdr
, name
, section
);
1256 /* Silently ignore for now. */
1260 /* If the section flag was not handled, report it here. */
1261 if (unhandled
!= NULL
)
1263 (*_bfd_error_handler
)
1264 (_("%B (%s): Section flag %s (0x%x) ignored"),
1265 abfd
, name
, unhandled
, flag
);
1270 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1271 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1272 only link a single copy of the section. This is used to support
1273 g++. g++ will emit each template expansion in its own section.
1274 The symbols will be defined as weak, so that multiple definitions
1275 are permitted. The GNU linker extension is to actually discard
1276 all but one of the sections. */
1277 if (CONST_STRNEQ (name
, ".gnu.linkonce"))
1278 sec_flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1282 * flags_ptr
= sec_flags
;
1287 #endif /* COFF_WITH_PE */
1289 #define get_index(symbol) ((symbol)->udata.i)
1293 bfd_coff_backend_data
1297 .{* COFF symbol classifications. *}
1299 .enum coff_symbol_classification
1301 . {* Global symbol. *}
1302 . COFF_SYMBOL_GLOBAL,
1303 . {* Common symbol. *}
1304 . COFF_SYMBOL_COMMON,
1305 . {* Undefined symbol. *}
1306 . COFF_SYMBOL_UNDEFINED,
1307 . {* Local symbol. *}
1308 . COFF_SYMBOL_LOCAL,
1309 . {* PE section symbol. *}
1310 . COFF_SYMBOL_PE_SECTION
1313 Special entry points for gdb to swap in coff symbol table parts:
1316 . void (*_bfd_coff_swap_aux_in)
1317 . (bfd *, void *, int, int, int, int, void *);
1319 . void (*_bfd_coff_swap_sym_in)
1320 . (bfd *, void *, void *);
1322 . void (*_bfd_coff_swap_lineno_in)
1323 . (bfd *, void *, void *);
1325 . unsigned int (*_bfd_coff_swap_aux_out)
1326 . (bfd *, void *, int, int, int, int, void *);
1328 . unsigned int (*_bfd_coff_swap_sym_out)
1329 . (bfd *, void *, void *);
1331 . unsigned int (*_bfd_coff_swap_lineno_out)
1332 . (bfd *, void *, void *);
1334 . unsigned int (*_bfd_coff_swap_reloc_out)
1335 . (bfd *, void *, void *);
1337 . unsigned int (*_bfd_coff_swap_filehdr_out)
1338 . (bfd *, void *, void *);
1340 . unsigned int (*_bfd_coff_swap_aouthdr_out)
1341 . (bfd *, void *, void *);
1343 . unsigned int (*_bfd_coff_swap_scnhdr_out)
1344 . (bfd *, void *, void *);
1346 . unsigned int _bfd_filhsz;
1347 . unsigned int _bfd_aoutsz;
1348 . unsigned int _bfd_scnhsz;
1349 . unsigned int _bfd_symesz;
1350 . unsigned int _bfd_auxesz;
1351 . unsigned int _bfd_relsz;
1352 . unsigned int _bfd_linesz;
1353 . unsigned int _bfd_filnmlen;
1354 . bfd_boolean _bfd_coff_long_filenames;
1356 . bfd_boolean _bfd_coff_long_section_names;
1357 . bfd_boolean (*_bfd_coff_set_long_section_names)
1360 . unsigned int _bfd_coff_default_section_alignment_power;
1361 . bfd_boolean _bfd_coff_force_symnames_in_strings;
1362 . unsigned int _bfd_coff_debug_string_prefix_length;
1364 . void (*_bfd_coff_swap_filehdr_in)
1365 . (bfd *, void *, void *);
1367 . void (*_bfd_coff_swap_aouthdr_in)
1368 . (bfd *, void *, void *);
1370 . void (*_bfd_coff_swap_scnhdr_in)
1371 . (bfd *, void *, void *);
1373 . void (*_bfd_coff_swap_reloc_in)
1374 . (bfd *abfd, void *, void *);
1376 . bfd_boolean (*_bfd_coff_bad_format_hook)
1379 . bfd_boolean (*_bfd_coff_set_arch_mach_hook)
1382 . void * (*_bfd_coff_mkobject_hook)
1383 . (bfd *, void *, void *);
1385 . bfd_boolean (*_bfd_styp_to_sec_flags_hook)
1386 . (bfd *, void *, const char *, asection *, flagword *);
1388 . void (*_bfd_set_alignment_hook)
1389 . (bfd *, asection *, void *);
1391 . bfd_boolean (*_bfd_coff_slurp_symbol_table)
1394 . bfd_boolean (*_bfd_coff_symname_in_debug)
1395 . (bfd *, struct internal_syment *);
1397 . bfd_boolean (*_bfd_coff_pointerize_aux_hook)
1398 . (bfd *, combined_entry_type *, combined_entry_type *,
1399 . unsigned int, combined_entry_type *);
1401 . bfd_boolean (*_bfd_coff_print_aux)
1402 . (bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1403 . combined_entry_type *, unsigned int);
1405 . void (*_bfd_coff_reloc16_extra_cases)
1406 . (bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
1407 . bfd_byte *, unsigned int *, unsigned int *);
1409 . int (*_bfd_coff_reloc16_estimate)
1410 . (bfd *, asection *, arelent *, unsigned int,
1411 . struct bfd_link_info *);
1413 . enum coff_symbol_classification (*_bfd_coff_classify_symbol)
1414 . (bfd *, struct internal_syment *);
1416 . bfd_boolean (*_bfd_coff_compute_section_file_positions)
1419 . bfd_boolean (*_bfd_coff_start_final_link)
1420 . (bfd *, struct bfd_link_info *);
1422 . bfd_boolean (*_bfd_coff_relocate_section)
1423 . (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
1424 . struct internal_reloc *, struct internal_syment *, asection **);
1426 . reloc_howto_type *(*_bfd_coff_rtype_to_howto)
1427 . (bfd *, asection *, struct internal_reloc *,
1428 . struct coff_link_hash_entry *, struct internal_syment *,
1431 . bfd_boolean (*_bfd_coff_adjust_symndx)
1432 . (bfd *, struct bfd_link_info *, bfd *, asection *,
1433 . struct internal_reloc *, bfd_boolean *);
1435 . bfd_boolean (*_bfd_coff_link_add_one_symbol)
1436 . (struct bfd_link_info *, bfd *, const char *, flagword,
1437 . asection *, bfd_vma, const char *, bfd_boolean, bfd_boolean,
1438 . struct bfd_link_hash_entry **);
1440 . bfd_boolean (*_bfd_coff_link_output_has_begun)
1441 . (bfd *, struct coff_final_link_info *);
1443 . bfd_boolean (*_bfd_coff_final_link_postscript)
1444 . (bfd *, struct coff_final_link_info *);
1446 . bfd_boolean (*_bfd_coff_print_pdata)
1449 .} bfd_coff_backend_data;
1451 .#define coff_backend_info(abfd) \
1452 . ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1454 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1455 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1457 .#define bfd_coff_swap_sym_in(a,e,i) \
1458 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1460 .#define bfd_coff_swap_lineno_in(a,e,i) \
1461 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1463 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1464 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1466 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1467 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1469 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1470 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1472 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1473 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1475 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1476 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1478 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1479 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1481 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1482 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1484 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1485 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1486 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1487 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1488 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1489 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1490 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1491 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1492 .#define bfd_coff_long_filenames(abfd) \
1493 . (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1494 .#define bfd_coff_long_section_names(abfd) \
1495 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1496 .#define bfd_coff_set_long_section_names(abfd, enable) \
1497 . ((coff_backend_info (abfd)->_bfd_coff_set_long_section_names) (abfd, enable))
1498 .#define bfd_coff_default_section_alignment_power(abfd) \
1499 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1500 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1501 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1503 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1504 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1506 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1507 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1509 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1510 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1512 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1513 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1515 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1516 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1517 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1518 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook)\
1519 . (abfd, filehdr, aouthdr))
1521 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\
1522 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1523 . (abfd, scnhdr, name, section, flags_ptr))
1525 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1526 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1528 .#define bfd_coff_slurp_symbol_table(abfd)\
1529 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1531 .#define bfd_coff_symname_in_debug(abfd, sym)\
1532 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1534 .#define bfd_coff_force_symnames_in_strings(abfd)\
1535 . (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
1537 .#define bfd_coff_debug_string_prefix_length(abfd)\
1538 . (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
1540 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1541 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1542 . (abfd, file, base, symbol, aux, indaux))
1544 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order,\
1545 . reloc, data, src_ptr, dst_ptr)\
1546 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1547 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1549 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1550 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1551 . (abfd, section, reloc, shrink, link_info))
1553 .#define bfd_coff_classify_symbol(abfd, sym)\
1554 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1557 .#define bfd_coff_compute_section_file_positions(abfd)\
1558 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1561 .#define bfd_coff_start_final_link(obfd, info)\
1562 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1564 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1565 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1566 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1567 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1568 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1569 . (abfd, sec, rel, h, sym, addendp))
1570 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1571 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1572 . (obfd, info, ibfd, sec, rel, adjustedp))
1573 .#define bfd_coff_link_add_one_symbol(info, abfd, name, flags, section,\
1574 . value, string, cp, coll, hashp)\
1575 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1576 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1578 .#define bfd_coff_link_output_has_begun(a,p) \
1579 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a, p))
1580 .#define bfd_coff_final_link_postscript(a,p) \
1581 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a, p))
1583 .#define bfd_coff_have_print_pdata(a) \
1584 . (coff_backend_info (a)->_bfd_coff_print_pdata)
1585 .#define bfd_coff_print_pdata(a,p) \
1586 . ((coff_backend_info (a)->_bfd_coff_print_pdata) (a, p))
1588 .{* Macro: Returns true if the bfd is a PE executable as opposed to a
1589 . PE object file. *}
1590 .#define bfd_pei_p(abfd) \
1591 . (CONST_STRNEQ ((abfd)->xvec->name, "pei-"))
1594 /* See whether the magic number matches. */
1597 coff_bad_format_hook (bfd
* abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1599 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1601 if (BADMAG (*internal_f
))
1604 /* If the optional header is NULL or not the correct size then
1605 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1606 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1607 optional header is of a different size.
1609 But the mips keeps extra stuff in it's opthdr, so dont check
1612 #if defined(M88) || defined(I960)
1613 if (internal_f
->f_opthdr
!= 0 && bfd_coff_aoutsz (abfd
) != internal_f
->f_opthdr
)
1622 ticoff0_bad_format_hook (bfd
*abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1624 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1626 if (COFF0_BADMAG (*internal_f
))
1635 ticoff1_bad_format_hook (bfd
*abfd ATTRIBUTE_UNUSED
, void * filehdr
)
1637 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1639 if (COFF1_BADMAG (*internal_f
))
1646 /* Check whether this section uses an alignment other than the
1650 coff_set_custom_section_alignment (bfd
*abfd ATTRIBUTE_UNUSED
,
1652 const struct coff_section_alignment_entry
*alignment_table
,
1653 const unsigned int table_size
)
1655 const unsigned int default_alignment
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1658 for (i
= 0; i
< table_size
; ++i
)
1660 const char *secname
= bfd_get_section_name (abfd
, section
);
1662 if (alignment_table
[i
].comparison_length
== (unsigned int) -1
1663 ? strcmp (alignment_table
[i
].name
, secname
) == 0
1664 : strncmp (alignment_table
[i
].name
, secname
,
1665 alignment_table
[i
].comparison_length
) == 0)
1668 if (i
>= table_size
)
1671 if (alignment_table
[i
].default_alignment_min
!= COFF_ALIGNMENT_FIELD_EMPTY
1672 && default_alignment
< alignment_table
[i
].default_alignment_min
)
1675 if (alignment_table
[i
].default_alignment_max
!= COFF_ALIGNMENT_FIELD_EMPTY
1676 #if COFF_DEFAULT_SECTION_ALIGNMENT_POWER != 0
1677 && default_alignment
> alignment_table
[i
].default_alignment_max
1682 section
->alignment_power
= alignment_table
[i
].alignment_power
;
1685 /* Custom section alignment records. */
1687 static const struct coff_section_alignment_entry
1688 coff_section_alignment_table
[] =
1690 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1691 COFF_SECTION_ALIGNMENT_ENTRIES
,
1693 /* There must not be any gaps between .stabstr sections. */
1694 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1695 1, COFF_ALIGNMENT_FIELD_EMPTY
, 0 },
1696 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1697 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1698 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1699 /* Similarly for the .ctors and .dtors sections. */
1700 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1701 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 },
1702 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1703 3, COFF_ALIGNMENT_FIELD_EMPTY
, 2 }
1706 static const unsigned int coff_section_alignment_table_size
=
1707 sizeof coff_section_alignment_table
/ sizeof coff_section_alignment_table
[0];
1709 /* Initialize a section structure with information peculiar to this
1710 particular implementation of COFF. */
1713 coff_new_section_hook (bfd
* abfd
, asection
* section
)
1715 combined_entry_type
*native
;
1718 section
->alignment_power
= COFF_DEFAULT_SECTION_ALIGNMENT_POWER
;
1721 if (bfd_xcoff_text_align_power (abfd
) != 0
1722 && strcmp (bfd_get_section_name (abfd
, section
), ".text") == 0)
1723 section
->alignment_power
= bfd_xcoff_text_align_power (abfd
);
1724 if (bfd_xcoff_data_align_power (abfd
) != 0
1725 && strcmp (bfd_get_section_name (abfd
, section
), ".data") == 0)
1726 section
->alignment_power
= bfd_xcoff_data_align_power (abfd
);
1729 /* Set up the section symbol. */
1730 if (!_bfd_generic_new_section_hook (abfd
, section
))
1733 /* Allocate aux records for section symbols, to store size and
1736 @@ The 10 is a guess at a plausible maximum number of aux entries
1737 (but shouldn't be a constant). */
1738 amt
= sizeof (combined_entry_type
) * 10;
1739 native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
1743 /* We don't need to set up n_name, n_value, or n_scnum in the native
1744 symbol information, since they'll be overridden by the BFD symbol
1745 anyhow. However, we do need to set the type and storage class,
1746 in case this symbol winds up getting written out. The value 0
1747 for n_numaux is already correct. */
1749 native
->u
.syment
.n_type
= T_NULL
;
1750 native
->u
.syment
.n_sclass
= C_STAT
;
1752 coffsymbol (section
->symbol
)->native
= native
;
1754 coff_set_custom_section_alignment (abfd
, section
,
1755 coff_section_alignment_table
,
1756 coff_section_alignment_table_size
);
1761 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1763 /* Set the alignment of a BFD section. */
1766 coff_set_alignment_hook (bfd
* abfd ATTRIBUTE_UNUSED
,
1770 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1774 /* Extract ALIGN from 2**ALIGN stored in section header. */
1775 for (i
= 0; i
< 32; i
++)
1776 if ((1 << i
) >= hdr
->s_align
)
1780 /* TI tools puts the alignment power in bits 8-11. */
1781 i
= (hdr
->s_flags
>> 8) & 0xF ;
1783 #ifdef COFF_DECODE_ALIGNMENT
1784 i
= COFF_DECODE_ALIGNMENT(hdr
->s_flags
);
1786 section
->alignment_power
= i
;
1788 #ifdef coff_set_section_load_page
1789 coff_set_section_load_page (section
, hdr
->s_page
);
1793 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1797 coff_set_alignment_hook (bfd
* abfd ATTRIBUTE_UNUSED
,
1801 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1803 unsigned int alignment_power_const
1804 = hdr
->s_flags
& IMAGE_SCN_ALIGN_POWER_BIT_MASK
;
1806 switch (alignment_power_const
)
1808 case IMAGE_SCN_ALIGN_8192BYTES
:
1809 case IMAGE_SCN_ALIGN_4096BYTES
:
1810 case IMAGE_SCN_ALIGN_2048BYTES
:
1811 case IMAGE_SCN_ALIGN_1024BYTES
:
1812 case IMAGE_SCN_ALIGN_512BYTES
:
1813 case IMAGE_SCN_ALIGN_256BYTES
:
1814 case IMAGE_SCN_ALIGN_128BYTES
:
1815 case IMAGE_SCN_ALIGN_64BYTES
:
1816 case IMAGE_SCN_ALIGN_32BYTES
:
1817 case IMAGE_SCN_ALIGN_16BYTES
:
1818 case IMAGE_SCN_ALIGN_8BYTES
:
1819 case IMAGE_SCN_ALIGN_4BYTES
:
1820 case IMAGE_SCN_ALIGN_2BYTES
:
1821 case IMAGE_SCN_ALIGN_1BYTES
:
1822 section
->alignment_power
1823 = IMAGE_SCN_ALIGN_POWER_NUM (alignment_power_const
);
1829 /* In a PE image file, the s_paddr field holds the virtual size of a
1830 section, while the s_size field holds the raw size. We also keep
1831 the original section flag value, since not every bit can be
1832 mapped onto a generic BFD section bit. */
1833 if (coff_section_data (abfd
, section
) == NULL
)
1835 amt
= sizeof (struct coff_section_tdata
);
1836 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
1837 if (section
->used_by_bfd
== NULL
)
1838 /* FIXME: Return error. */
1842 if (pei_section_data (abfd
, section
) == NULL
)
1844 amt
= sizeof (struct pei_section_tdata
);
1845 coff_section_data (abfd
, section
)->tdata
= bfd_zalloc (abfd
, amt
);
1846 if (coff_section_data (abfd
, section
)->tdata
== NULL
)
1847 /* FIXME: Return error. */
1850 pei_section_data (abfd
, section
)->virt_size
= hdr
->s_paddr
;
1851 pei_section_data (abfd
, section
)->pe_flags
= hdr
->s_flags
;
1853 section
->lma
= hdr
->s_vaddr
;
1855 /* Check for extended relocs. */
1856 if (hdr
->s_flags
& IMAGE_SCN_LNK_NRELOC_OVFL
)
1858 struct external_reloc dst
;
1859 struct internal_reloc n
;
1860 file_ptr oldpos
= bfd_tell (abfd
);
1861 bfd_size_type relsz
= bfd_coff_relsz (abfd
);
1863 if (bfd_seek (abfd
, (file_ptr
) hdr
->s_relptr
, 0) != 0)
1865 if (bfd_bread (& dst
, relsz
, abfd
) != relsz
)
1868 coff_swap_reloc_in (abfd
, &dst
, &n
);
1869 if (bfd_seek (abfd
, oldpos
, 0) != 0)
1871 section
->reloc_count
= hdr
->s_nreloc
= n
.r_vaddr
- 1;
1872 section
->rel_filepos
+= relsz
;
1874 else if (hdr
->s_nreloc
== 0xffff)
1875 (*_bfd_error_handler
)
1876 ("%s: warning: claims to have 0xffff relocs, without overflow",
1877 bfd_get_filename (abfd
));
1880 #undef ELIFALIGN_SET
1882 #else /* ! COFF_WITH_PE */
1885 /* We grossly abuse this function to handle XCOFF overflow headers.
1886 When we see one, we correct the reloc and line number counts in the
1887 real header, and remove the section we just created. */
1890 coff_set_alignment_hook (bfd
*abfd
, asection
*section
, void * scnhdr
)
1892 struct internal_scnhdr
*hdr
= (struct internal_scnhdr
*) scnhdr
;
1895 if ((hdr
->s_flags
& STYP_OVRFLO
) == 0)
1898 real_sec
= coff_section_from_bfd_index (abfd
, (int) hdr
->s_nreloc
);
1899 if (real_sec
== NULL
)
1902 real_sec
->reloc_count
= hdr
->s_paddr
;
1903 real_sec
->lineno_count
= hdr
->s_vaddr
;
1905 if (!bfd_section_removed_from_list (abfd
, section
))
1907 bfd_section_list_remove (abfd
, section
);
1908 --abfd
->section_count
;
1912 #else /* ! RS6000COFF_C */
1914 #define coff_set_alignment_hook \
1915 ((void (*) (bfd *, asection *, void *)) bfd_void)
1917 #endif /* ! RS6000COFF_C */
1918 #endif /* ! COFF_WITH_PE */
1919 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1921 #ifndef coff_mkobject
1924 coff_mkobject (bfd
* abfd
)
1926 coff_data_type
*coff
;
1927 bfd_size_type amt
= sizeof (coff_data_type
);
1929 abfd
->tdata
.coff_obj_data
= bfd_zalloc (abfd
, amt
);
1930 if (abfd
->tdata
.coff_obj_data
== NULL
)
1932 coff
= coff_data (abfd
);
1933 coff
->symbols
= NULL
;
1934 coff
->conversion_table
= NULL
;
1935 coff
->raw_syments
= NULL
;
1936 coff
->relocbase
= 0;
1937 coff
->local_toc_sym_map
= 0;
1939 /* make_abs_section(abfd);*/
1945 /* Create the COFF backend specific information. */
1947 #ifndef coff_mkobject_hook
1949 coff_mkobject_hook (bfd
* abfd
,
1951 void * aouthdr ATTRIBUTE_UNUSED
)
1953 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
1954 coff_data_type
*coff
;
1956 if (! coff_mkobject (abfd
))
1959 coff
= coff_data (abfd
);
1961 coff
->sym_filepos
= internal_f
->f_symptr
;
1963 /* These members communicate important constants about the symbol
1964 table to GDB's symbol-reading code. These `constants'
1965 unfortunately vary among coff implementations... */
1966 coff
->local_n_btmask
= N_BTMASK
;
1967 coff
->local_n_btshft
= N_BTSHFT
;
1968 coff
->local_n_tmask
= N_TMASK
;
1969 coff
->local_n_tshift
= N_TSHIFT
;
1970 coff
->local_symesz
= bfd_coff_symesz (abfd
);
1971 coff
->local_auxesz
= bfd_coff_auxesz (abfd
);
1972 coff
->local_linesz
= bfd_coff_linesz (abfd
);
1974 coff
->timestamp
= internal_f
->f_timdat
;
1976 obj_raw_syment_count (abfd
) =
1977 obj_conv_table_size (abfd
) =
1978 internal_f
->f_nsyms
;
1981 if ((internal_f
->f_flags
& F_SHROBJ
) != 0)
1982 abfd
->flags
|= DYNAMIC
;
1983 if (aouthdr
!= NULL
&& internal_f
->f_opthdr
>= bfd_coff_aoutsz (abfd
))
1985 struct internal_aouthdr
*internal_a
=
1986 (struct internal_aouthdr
*) aouthdr
;
1987 struct xcoff_tdata
*xcoff
;
1989 xcoff
= xcoff_data (abfd
);
1990 # ifdef U803XTOCMAGIC
1991 xcoff
->xcoff64
= internal_f
->f_magic
== U803XTOCMAGIC
;
1995 xcoff
->full_aouthdr
= TRUE
;
1996 xcoff
->toc
= internal_a
->o_toc
;
1997 xcoff
->sntoc
= internal_a
->o_sntoc
;
1998 xcoff
->snentry
= internal_a
->o_snentry
;
1999 bfd_xcoff_text_align_power (abfd
) = internal_a
->o_algntext
;
2000 bfd_xcoff_data_align_power (abfd
) = internal_a
->o_algndata
;
2001 xcoff
->modtype
= internal_a
->o_modtype
;
2002 xcoff
->cputype
= internal_a
->o_cputype
;
2003 xcoff
->maxdata
= internal_a
->o_maxdata
;
2004 xcoff
->maxstack
= internal_a
->o_maxstack
;
2009 /* Set the flags field from the COFF header read in. */
2010 if (! _bfd_coff_arm_set_private_flags (abfd
, internal_f
->f_flags
))
2015 /* FIXME: I'm not sure this is ever executed, since peicode.h
2016 defines coff_mkobject_hook. */
2017 if ((internal_f
->f_flags
& IMAGE_FILE_DEBUG_STRIPPED
) == 0)
2018 abfd
->flags
|= HAS_DEBUG
;
2021 if ((internal_f
->f_flags
& F_GO32STUB
) != 0)
2022 coff
->go32stub
= (char *) bfd_alloc (abfd
, (bfd_size_type
) GO32_STUBSIZE
);
2023 if (coff
->go32stub
!= NULL
)
2024 memcpy (coff
->go32stub
, internal_f
->go32stub
, GO32_STUBSIZE
);
2030 /* Determine the machine architecture and type. FIXME: This is target
2031 dependent because the magic numbers are defined in the target
2032 dependent header files. But there is no particular need for this.
2033 If the magic numbers were moved to a separate file, this function
2034 would be target independent and would also be much more successful
2035 at linking together COFF files for different architectures. */
2038 coff_set_arch_mach_hook (bfd
*abfd
, void * filehdr
)
2040 unsigned long machine
;
2041 enum bfd_architecture arch
;
2042 struct internal_filehdr
*internal_f
= (struct internal_filehdr
*) filehdr
;
2044 /* Zero selects the default machine for an arch. */
2046 switch (internal_f
->f_magic
)
2048 #ifdef OR32_MAGIC_BIG
2049 case OR32_MAGIC_BIG
:
2050 case OR32_MAGIC_LITTLE
:
2051 arch
= bfd_arch_or32
;
2056 arch
= bfd_arch_powerpc
;
2062 case I386AIXMAGIC
: /* Danbury PS/2 AIX C Compiler. */
2063 case LYNXCOFFMAGIC
: /* Shadows the m68k Lynx number below, sigh. */
2064 arch
= bfd_arch_i386
;
2069 arch
= bfd_arch_i386
;
2070 machine
= bfd_mach_x86_64
;
2075 arch
= bfd_arch_ia64
;
2082 arch
= bfd_arch_arm
;
2083 machine
= bfd_arm_get_mach_from_notes (abfd
, ARM_NOTE_SECTION
);
2084 if (machine
== bfd_mach_arm_unknown
)
2086 switch (internal_f
->f_flags
& F_ARM_ARCHITECTURE_MASK
)
2088 case F_ARM_2
: machine
= bfd_mach_arm_2
; break;
2089 case F_ARM_2a
: machine
= bfd_mach_arm_2a
; break;
2090 case F_ARM_3
: machine
= bfd_mach_arm_3
; break;
2092 case F_ARM_3M
: machine
= bfd_mach_arm_3M
; break;
2093 case F_ARM_4
: machine
= bfd_mach_arm_4
; break;
2094 case F_ARM_4T
: machine
= bfd_mach_arm_4T
; break;
2095 /* The COFF header does not have enough bits available
2096 to cover all the different ARM architectures. So
2097 we interpret F_ARM_5, the highest flag value to mean
2098 "the highest ARM architecture known to BFD" which is
2099 currently the XScale. */
2100 case F_ARM_5
: machine
= bfd_mach_arm_XScale
; break;
2108 #ifdef MC68KBCSMAGIC
2111 #ifdef APOLLOM68KMAGIC
2112 case APOLLOM68KMAGIC
:
2114 #ifdef LYNXCOFFMAGIC
2117 arch
= bfd_arch_m68k
;
2118 machine
= bfd_mach_m68020
;
2125 arch
= bfd_arch_m88k
;
2131 arch
= bfd_arch_z80
;
2132 switch (internal_f
->f_flags
& F_MACHMASK
)
2135 case bfd_mach_z80strict
<< 12:
2136 case bfd_mach_z80
<< 12:
2137 case bfd_mach_z80full
<< 12:
2138 case bfd_mach_r800
<< 12:
2139 machine
= ((unsigned)internal_f
->f_flags
& F_MACHMASK
) >> 12;
2148 arch
= bfd_arch_z8k
;
2149 switch (internal_f
->f_flags
& F_MACHMASK
)
2152 machine
= bfd_mach_z8001
;
2155 machine
= bfd_mach_z8002
;
2164 arch
= bfd_arch_i860
;
2171 arch
= bfd_arch_i960
;
2172 switch (F_I960TYPE
& internal_f
->f_flags
)
2176 machine
= bfd_mach_i960_core
;
2179 machine
= bfd_mach_i960_kb_sb
;
2182 machine
= bfd_mach_i960_mc
;
2185 machine
= bfd_mach_i960_xa
;
2188 machine
= bfd_mach_i960_ca
;
2191 machine
= bfd_mach_i960_ka_sa
;
2194 machine
= bfd_mach_i960_jx
;
2197 machine
= bfd_mach_i960_hx
;
2216 if (xcoff_data (abfd
)->cputype
!= -1)
2217 cputype
= xcoff_data (abfd
)->cputype
& 0xff;
2220 /* We did not get a value from the a.out header. If the
2221 file has not been stripped, we may be able to get the
2222 architecture information from the first symbol, if it
2223 is a .file symbol. */
2224 if (obj_raw_syment_count (abfd
) == 0)
2229 struct internal_syment sym
;
2230 bfd_size_type amt
= bfd_coff_symesz (abfd
);
2232 buf
= bfd_malloc (amt
);
2233 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
2234 || bfd_bread (buf
, amt
, abfd
) != amt
)
2239 bfd_coff_swap_sym_in (abfd
, buf
, & sym
);
2240 if (sym
.n_sclass
== C_FILE
)
2241 cputype
= sym
.n_type
& 0xff;
2248 /* FIXME: We don't handle all cases here. */
2253 arch
= bfd_xcoff_architecture (abfd
);
2254 machine
= bfd_xcoff_machine (abfd
);
2258 arch
= bfd_arch_powerpc
;
2259 machine
= bfd_mach_ppc_601
;
2261 case 2: /* 64 bit PowerPC */
2262 arch
= bfd_arch_powerpc
;
2263 machine
= bfd_mach_ppc_620
;
2266 arch
= bfd_arch_powerpc
;
2267 machine
= bfd_mach_ppc
;
2270 arch
= bfd_arch_rs6000
;
2271 machine
= bfd_mach_rs6k
;
2280 arch
= bfd_arch_we32k
;
2286 arch
= bfd_arch_h8300
;
2287 machine
= bfd_mach_h8300
;
2288 /* !! FIXME this probably isn't the right place for this. */
2289 abfd
->flags
|= BFD_IS_RELAXABLE
;
2295 arch
= bfd_arch_h8300
;
2296 machine
= bfd_mach_h8300h
;
2297 /* !! FIXME this probably isn't the right place for this. */
2298 abfd
->flags
|= BFD_IS_RELAXABLE
;
2304 arch
= bfd_arch_h8300
;
2305 machine
= bfd_mach_h8300s
;
2306 /* !! FIXME this probably isn't the right place for this. */
2307 abfd
->flags
|= BFD_IS_RELAXABLE
;
2313 arch
= bfd_arch_h8300
;
2314 machine
= bfd_mach_h8300hn
;
2315 /* !! FIXME this probably isn't the right place for this. */
2316 abfd
->flags
|= BFD_IS_RELAXABLE
;
2322 arch
= bfd_arch_h8300
;
2323 machine
= bfd_mach_h8300sn
;
2324 /* !! FIXME this probably isn't the right place for this. */
2325 abfd
->flags
|= BFD_IS_RELAXABLE
;
2329 #ifdef SH_ARCH_MAGIC_BIG
2330 case SH_ARCH_MAGIC_BIG
:
2331 case SH_ARCH_MAGIC_LITTLE
:
2333 case SH_ARCH_MAGIC_WINCE
:
2339 #ifdef MIPS_ARCH_MAGIC_WINCE
2340 case MIPS_ARCH_MAGIC_WINCE
:
2341 arch
= bfd_arch_mips
;
2347 arch
= bfd_arch_h8500
;
2353 #ifdef LYNXCOFFMAGIC
2356 arch
= bfd_arch_sparc
;
2362 arch
= bfd_arch_tic30
;
2367 #ifdef TICOFF_TARGET_ARCH
2368 /* This TI COFF section should be used by all new TI COFF v0 targets. */
2370 arch
= TICOFF_TARGET_ARCH
;
2371 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2377 /* This TI COFF section should be used by all new TI COFF v1/2 targets. */
2378 /* TI COFF1 and COFF2 use the target_id field to specify which arch. */
2381 switch (internal_f
->f_target_id
)
2385 arch
= TICOFF_TARGET_ARCH
;
2386 machine
= TICOFF_TARGET_MACHINE_GET (internal_f
->f_flags
);
2390 arch
= bfd_arch_obscure
;
2391 (*_bfd_error_handler
)
2392 (_("Unrecognized TI COFF target id '0x%x'"),
2393 internal_f
->f_target_id
);
2399 #ifdef TIC80_ARCH_MAGIC
2400 case TIC80_ARCH_MAGIC
:
2401 arch
= bfd_arch_tic80
;
2407 arch
= bfd_arch_mcore
;
2413 arch
= bfd_arch_w65
;
2417 default: /* Unreadable input file type. */
2418 arch
= bfd_arch_obscure
;
2422 bfd_default_set_arch_mach (abfd
, arch
, machine
);
2426 #ifdef SYMNAME_IN_DEBUG
2429 symname_in_debug_hook (bfd
* abfd ATTRIBUTE_UNUSED
, struct internal_syment
*sym
)
2431 return SYMNAME_IN_DEBUG (sym
) != 0;
2436 #define symname_in_debug_hook \
2437 (bfd_boolean (*) (bfd *, struct internal_syment *)) bfd_false
2444 #define FORCE_SYMNAMES_IN_STRINGS
2447 /* Handle the csect auxent of a C_EXT, C_AIX_WEAKEXT or C_HIDEXT symbol. */
2450 coff_pointerize_aux_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2451 combined_entry_type
*table_base
,
2452 combined_entry_type
*symbol
,
2453 unsigned int indaux
,
2454 combined_entry_type
*aux
)
2456 int n_sclass
= symbol
->u
.syment
.n_sclass
;
2458 if (CSECT_SYM_P (n_sclass
)
2459 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2461 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) == XTY_LD
)
2463 aux
->u
.auxent
.x_csect
.x_scnlen
.p
=
2464 table_base
+ aux
->u
.auxent
.x_csect
.x_scnlen
.l
;
2465 aux
->fix_scnlen
= 1;
2468 /* Return TRUE to indicate that the caller should not do any
2469 further work on this auxent. */
2473 /* Return FALSE to indicate that this auxent should be handled by
2481 /* We don't want to pointerize bal entries. */
2484 coff_pointerize_aux_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2485 combined_entry_type
*table_base ATTRIBUTE_UNUSED
,
2486 combined_entry_type
*symbol
,
2487 unsigned int indaux
,
2488 combined_entry_type
*aux ATTRIBUTE_UNUSED
)
2490 /* Return TRUE if we don't want to pointerize this aux entry, which
2491 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
2493 && (symbol
->u
.syment
.n_sclass
== C_LEAFPROC
2494 || symbol
->u
.syment
.n_sclass
== C_LEAFSTAT
2495 || symbol
->u
.syment
.n_sclass
== C_LEAFEXT
));
2500 #define coff_pointerize_aux_hook 0
2503 #endif /* ! RS6000COFF_C */
2505 /* Print an aux entry. This returns TRUE if it has printed it. */
2508 coff_print_aux (bfd
*abfd ATTRIBUTE_UNUSED
,
2509 FILE *file ATTRIBUTE_UNUSED
,
2510 combined_entry_type
*table_base ATTRIBUTE_UNUSED
,
2511 combined_entry_type
*symbol ATTRIBUTE_UNUSED
,
2512 combined_entry_type
*aux ATTRIBUTE_UNUSED
,
2513 unsigned int indaux ATTRIBUTE_UNUSED
)
2516 if (CSECT_SYM_P (symbol
->u
.syment
.n_sclass
)
2517 && indaux
+ 1 == symbol
->u
.syment
.n_numaux
)
2519 /* This is a csect entry. */
2520 fprintf (file
, "AUX ");
2521 if (SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
) != XTY_LD
)
2523 BFD_ASSERT (! aux
->fix_scnlen
);
2525 fprintf (file
, "val %5lld",
2526 (long long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2528 fprintf (file
, "val %5ld", (long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2533 fprintf (file
, "indx ");
2534 if (! aux
->fix_scnlen
)
2536 fprintf (file
, "%4lld",
2537 (long long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2539 fprintf (file
, "%4ld", (long) aux
->u
.auxent
.x_csect
.x_scnlen
.l
);
2542 fprintf (file
, "%4ld",
2543 (long) (aux
->u
.auxent
.x_csect
.x_scnlen
.p
- table_base
));
2546 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2547 aux
->u
.auxent
.x_csect
.x_parmhash
,
2548 (unsigned int) aux
->u
.auxent
.x_csect
.x_snhash
,
2549 SMTYP_SMTYP (aux
->u
.auxent
.x_csect
.x_smtyp
),
2550 SMTYP_ALIGN (aux
->u
.auxent
.x_csect
.x_smtyp
),
2551 (unsigned int) aux
->u
.auxent
.x_csect
.x_smclas
,
2552 aux
->u
.auxent
.x_csect
.x_stab
,
2553 (unsigned int) aux
->u
.auxent
.x_csect
.x_snstab
);
2558 /* Return FALSE to indicate that no special action was taken. */
2566 To write relocations, the back end steps though the
2567 canonical relocation table and create an
2568 @code{internal_reloc}. The symbol index to use is removed from
2569 the @code{offset} field in the symbol table supplied. The
2570 address comes directly from the sum of the section base
2571 address and the relocation offset; the type is dug directly
2572 from the howto field. Then the @code{internal_reloc} is
2573 swapped into the shape of an @code{external_reloc} and written
2581 /* AUX's ld wants relocations to be sorted. */
2583 compare_arelent_ptr (const void * x
, const void * y
)
2585 const arelent
**a
= (const arelent
**) x
;
2586 const arelent
**b
= (const arelent
**) y
;
2587 bfd_size_type aadr
= (*a
)->address
;
2588 bfd_size_type badr
= (*b
)->address
;
2590 return (aadr
< badr
? -1 : badr
< aadr
? 1 : 0);
2593 #endif /* TARG_AUX */
2596 coff_write_relocs (bfd
* abfd
, int first_undef
)
2600 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
2603 struct external_reloc dst
;
2610 /* Sort relocations before we write them out. */
2613 amt
= s
->reloc_count
;
2614 amt
*= sizeof (arelent
*);
2615 p
= bfd_malloc (amt
);
2616 if (p
== NULL
&& s
->reloc_count
> 0)
2618 memcpy (p
, s
->orelocation
, (size_t) amt
);
2619 qsort (p
, s
->reloc_count
, sizeof (arelent
*), compare_arelent_ptr
);
2623 if (bfd_seek (abfd
, s
->rel_filepos
, SEEK_SET
) != 0)
2627 if (obj_pe (abfd
) && s
->reloc_count
>= 0xffff)
2629 /* Encode real count here as first reloc. */
2630 struct internal_reloc n
;
2632 memset (& n
, 0, sizeof (n
));
2633 /* Add one to count *this* reloc (grr). */
2634 n
.r_vaddr
= s
->reloc_count
+ 1;
2635 coff_swap_reloc_out (abfd
, &n
, &dst
);
2636 if (bfd_bwrite (& dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2637 abfd
) != bfd_coff_relsz (abfd
))
2642 for (i
= 0; i
< s
->reloc_count
; i
++)
2644 struct internal_reloc n
;
2647 memset (& n
, 0, sizeof (n
));
2649 /* Now we've renumbered the symbols we know where the
2650 undefined symbols live in the table. Check the reloc
2651 entries for symbols who's output bfd isn't the right one.
2652 This is because the symbol was undefined (which means
2653 that all the pointers are never made to point to the same
2654 place). This is a bad thing,'cause the symbols attached
2655 to the output bfd are indexed, so that the relocation
2656 entries know which symbol index they point to. So we
2657 have to look up the output symbol here. */
2659 if (q
->sym_ptr_ptr
[0] != NULL
&& q
->sym_ptr_ptr
[0]->the_bfd
!= abfd
)
2662 const char *sname
= q
->sym_ptr_ptr
[0]->name
;
2663 asymbol
**outsyms
= abfd
->outsymbols
;
2665 for (j
= first_undef
; outsyms
[j
]; j
++)
2667 const char *intable
= outsyms
[j
]->name
;
2669 if (strcmp (intable
, sname
) == 0)
2671 /* Got a hit, so repoint the reloc. */
2672 q
->sym_ptr_ptr
= outsyms
+ j
;
2678 n
.r_vaddr
= q
->address
+ s
->vma
;
2681 /* The 29k const/consth reloc pair is a real kludge. The consth
2682 part doesn't have a symbol; it has an offset. So rebuilt
2684 if (q
->howto
->type
== R_IHCONST
)
2685 n
.r_symndx
= q
->addend
;
2688 if (q
->sym_ptr_ptr
&& q
->sym_ptr_ptr
[0] != NULL
)
2690 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2691 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q
, s
))
2693 if ((*q
->sym_ptr_ptr
)->section
== bfd_abs_section_ptr
2694 && ((*q
->sym_ptr_ptr
)->flags
& BSF_SECTION_SYM
) != 0)
2696 /* This is a relocation relative to the absolute symbol. */
2700 n
.r_symndx
= get_index ((*(q
->sym_ptr_ptr
)));
2701 /* Check to see if the symbol reloc points to a symbol
2702 we don't have in our symbol table. */
2703 if (n
.r_symndx
> obj_conv_table_size (abfd
))
2705 bfd_set_error (bfd_error_bad_value
);
2706 _bfd_error_handler (_("%B: reloc against a non-existant symbol index: %ld"),
2713 #ifdef SWAP_OUT_RELOC_OFFSET
2714 n
.r_offset
= q
->addend
;
2718 /* Work out reloc type from what is required. */
2719 SELECT_RELOC (n
, q
->howto
);
2721 n
.r_type
= q
->howto
->type
;
2723 coff_swap_reloc_out (abfd
, &n
, &dst
);
2725 if (bfd_bwrite (& dst
, (bfd_size_type
) bfd_coff_relsz (abfd
),
2726 abfd
) != bfd_coff_relsz (abfd
))
2739 /* Set flags and magic number of a coff file from architecture and machine
2740 type. Result is TRUE if we can represent the arch&type, FALSE if not. */
2743 coff_set_flags (bfd
* abfd
,
2744 unsigned int *magicp ATTRIBUTE_UNUSED
,
2745 unsigned short *flagsp ATTRIBUTE_UNUSED
)
2747 switch (bfd_get_arch (abfd
))
2752 switch (bfd_get_mach (abfd
))
2755 case bfd_mach_z80strict
:
2757 case bfd_mach_z80full
:
2759 *flagsp
= bfd_get_mach (abfd
) << 12;
2771 switch (bfd_get_mach (abfd
))
2773 case bfd_mach_z8001
: *flagsp
= F_Z8001
; break;
2774 case bfd_mach_z8002
: *flagsp
= F_Z8002
; break;
2775 default: return FALSE
;
2786 *magicp
= I960ROMAGIC
;
2788 switch (bfd_get_mach (abfd
))
2790 case bfd_mach_i960_core
: flags
= F_I960CORE
; break;
2791 case bfd_mach_i960_kb_sb
: flags
= F_I960KB
; break;
2792 case bfd_mach_i960_mc
: flags
= F_I960MC
; break;
2793 case bfd_mach_i960_xa
: flags
= F_I960XA
; break;
2794 case bfd_mach_i960_ca
: flags
= F_I960CA
; break;
2795 case bfd_mach_i960_ka_sa
: flags
= F_I960KA
; break;
2796 case bfd_mach_i960_jx
: flags
= F_I960JX
; break;
2797 case bfd_mach_i960_hx
: flags
= F_I960HX
; break;
2798 default: return FALSE
;
2807 case bfd_arch_tic30
:
2808 *magicp
= TIC30MAGIC
;
2812 #ifdef TICOFF_DEFAULT_MAGIC
2813 case TICOFF_TARGET_ARCH
:
2814 /* If there's no indication of which version we want, use the default. */
2816 *magicp
= TICOFF_DEFAULT_MAGIC
;
2819 /* We may want to output in a different COFF version. */
2820 switch (abfd
->xvec
->name
[4])
2823 *magicp
= TICOFF0MAGIC
;
2826 *magicp
= TICOFF1MAGIC
;
2829 *magicp
= TICOFF2MAGIC
;
2835 TICOFF_TARGET_MACHINE_SET (flagsp
, bfd_get_mach (abfd
));
2839 #ifdef TIC80_ARCH_MAGIC
2840 case bfd_arch_tic80
:
2841 *magicp
= TIC80_ARCH_MAGIC
;
2848 * magicp
= ARMPEMAGIC
;
2850 * magicp
= ARMMAGIC
;
2853 if (APCS_SET (abfd
))
2855 if (APCS_26_FLAG (abfd
))
2856 * flagsp
|= F_APCS26
;
2858 if (APCS_FLOAT_FLAG (abfd
))
2859 * flagsp
|= F_APCS_FLOAT
;
2861 if (PIC_FLAG (abfd
))
2864 if (INTERWORK_SET (abfd
) && INTERWORK_FLAG (abfd
))
2865 * flagsp
|= F_INTERWORK
;
2866 switch (bfd_get_mach (abfd
))
2868 case bfd_mach_arm_2
: * flagsp
|= F_ARM_2
; break;
2869 case bfd_mach_arm_2a
: * flagsp
|= F_ARM_2a
; break;
2870 case bfd_mach_arm_3
: * flagsp
|= F_ARM_3
; break;
2871 case bfd_mach_arm_3M
: * flagsp
|= F_ARM_3M
; break;
2872 case bfd_mach_arm_4
: * flagsp
|= F_ARM_4
; break;
2873 case bfd_mach_arm_4T
: * flagsp
|= F_ARM_4T
; break;
2874 case bfd_mach_arm_5
: * flagsp
|= F_ARM_5
; break;
2875 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5.
2876 See also the comment in coff_set_arch_mach_hook(). */
2877 case bfd_mach_arm_5T
: * flagsp
|= F_ARM_5
; break;
2878 case bfd_mach_arm_5TE
: * flagsp
|= F_ARM_5
; break;
2879 case bfd_mach_arm_XScale
: * flagsp
|= F_ARM_5
; break;
2885 case bfd_arch_powerpc
:
2890 #if defined(I386MAGIC) || defined(AMD64MAGIC)
2892 #if defined(I386MAGIC)
2893 *magicp
= I386MAGIC
;
2896 /* Just overwrite the usual value if we're doing Lynx. */
2897 *magicp
= LYNXCOFFMAGIC
;
2899 #if defined AMD64MAGIC
2900 *magicp
= AMD64MAGIC
;
2907 *magicp
= I860MAGIC
;
2913 *magicp
= IA64MAGIC
;
2919 #ifdef APOLLOM68KMAGIC
2920 *magicp
= APOLLO_COFF_VERSION_NUMBER
;
2922 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2923 #ifdef NAMES_HAVE_UNDERSCORE
2924 *magicp
= MC68KBCSMAGIC
;
2926 *magicp
= MC68MAGIC
;
2930 /* Just overwrite the usual value if we're doing Lynx. */
2931 *magicp
= LYNXCOFFMAGIC
;
2938 *magicp
= MC88OMAGIC
;
2943 case bfd_arch_h8300
:
2944 switch (bfd_get_mach (abfd
))
2946 case bfd_mach_h8300
: *magicp
= H8300MAGIC
; return TRUE
;
2947 case bfd_mach_h8300h
: *magicp
= H8300HMAGIC
; return TRUE
;
2948 case bfd_mach_h8300s
: *magicp
= H8300SMAGIC
; return TRUE
;
2949 case bfd_mach_h8300hn
: *magicp
= H8300HNMAGIC
; return TRUE
;
2950 case bfd_mach_h8300sn
: *magicp
= H8300SNMAGIC
; return TRUE
;
2956 #ifdef SH_ARCH_MAGIC_BIG
2958 #ifdef COFF_IMAGE_WITH_PE
2959 *magicp
= SH_ARCH_MAGIC_WINCE
;
2961 if (bfd_big_endian (abfd
))
2962 *magicp
= SH_ARCH_MAGIC_BIG
;
2964 *magicp
= SH_ARCH_MAGIC_LITTLE
;
2969 #ifdef MIPS_ARCH_MAGIC_WINCE
2971 *magicp
= MIPS_ARCH_MAGIC_WINCE
;
2976 case bfd_arch_sparc
:
2977 *magicp
= SPARCMAGIC
;
2979 /* Just overwrite the usual value if we're doing Lynx. */
2980 *magicp
= LYNXCOFFMAGIC
;
2986 case bfd_arch_h8500
:
2987 *magicp
= H8500MAGIC
;
2993 case bfd_arch_we32k
:
2994 *magicp
= WE32KMAGIC
;
2999 case bfd_arch_rs6000
:
3001 case bfd_arch_powerpc
:
3003 BFD_ASSERT (bfd_get_flavour (abfd
) == bfd_target_xcoff_flavour
);
3004 *magicp
= bfd_xcoff_magic_number (abfd
);
3009 case bfd_arch_mcore
:
3010 * magicp
= MCOREMAGIC
;
3020 #ifdef OR32_MAGIC_BIG
3022 if (bfd_big_endian (abfd
))
3023 * magicp
= OR32_MAGIC_BIG
;
3025 * magicp
= OR32_MAGIC_LITTLE
;
3029 default: /* Unknown architecture. */
3030 /* Fall through to "return FALSE" below, to avoid
3031 "statement never reached" errors on the one below. */
3039 coff_set_arch_mach (bfd
* abfd
,
3040 enum bfd_architecture arch
,
3041 unsigned long machine
)
3044 unsigned short dummy2
;
3046 if (! bfd_default_set_arch_mach (abfd
, arch
, machine
))
3049 if (arch
!= bfd_arch_unknown
3050 && ! coff_set_flags (abfd
, &dummy1
, &dummy2
))
3051 return FALSE
; /* We can't represent this type. */
3053 return TRUE
; /* We're easy... */
3056 #ifdef COFF_IMAGE_WITH_PE
3058 /* This is used to sort sections by VMA, as required by PE image
3062 sort_by_secaddr (const void * arg1
, const void * arg2
)
3064 const asection
*a
= *(const asection
**) arg1
;
3065 const asection
*b
= *(const asection
**) arg2
;
3067 if (a
->vma
< b
->vma
)
3069 else if (a
->vma
> b
->vma
)
3075 #endif /* COFF_IMAGE_WITH_PE */
3077 /* Calculate the file position for each section. */
3080 #define ALIGN_SECTIONS_IN_FILE
3082 #if defined(TIC80COFF) || defined(TICOFF)
3083 #undef ALIGN_SECTIONS_IN_FILE
3087 coff_compute_section_file_positions (bfd
* abfd
)
3090 file_ptr sofar
= bfd_coff_filhsz (abfd
);
3091 bfd_boolean align_adjust
;
3093 #ifdef ALIGN_SECTIONS_IN_FILE
3094 asection
*previous
= NULL
;
3098 #ifdef COFF_IMAGE_WITH_PE
3101 if (coff_data (abfd
)->link_info
)
3103 page_size
= pe_data (abfd
)->pe_opthdr
.FileAlignment
;
3105 /* If no file alignment has been set, default to one.
3106 This repairs 'ld -r' for arm-wince-pe target. */
3111 page_size
= PE_DEF_FILE_ALIGNMENT
;
3113 #ifdef COFF_PAGE_SIZE
3114 int page_size
= COFF_PAGE_SIZE
;
3119 /* On XCOFF, if we have symbols, set up the .debug section. */
3120 if (bfd_get_symcount (abfd
) > 0)
3123 bfd_size_type i
, symcount
;
3127 symcount
= bfd_get_symcount (abfd
);
3128 for (symp
= abfd
->outsymbols
, i
= 0; i
< symcount
; symp
++, i
++)
3130 coff_symbol_type
*cf
;
3132 cf
= coff_symbol_from (abfd
, *symp
);
3134 && cf
->native
!= NULL
3135 && SYMNAME_IN_DEBUG (&cf
->native
->u
.syment
))
3139 len
= strlen (bfd_asymbol_name (*symp
));
3140 if (len
> SYMNMLEN
|| bfd_coff_force_symnames_in_strings (abfd
))
3141 sz
+= len
+ 1 + bfd_coff_debug_string_prefix_length (abfd
);
3148 dsec
= bfd_make_section_old_way (abfd
, DOT_DEBUG
);
3152 dsec
->flags
|= SEC_HAS_CONTENTS
;
3157 if (bfd_get_start_address (abfd
))
3158 /* A start address may have been added to the original file. In this
3159 case it will need an optional header to record it. */
3160 abfd
->flags
|= EXEC_P
;
3162 if (abfd
->flags
& EXEC_P
)
3163 sofar
+= bfd_coff_aoutsz (abfd
);
3165 else if (xcoff_data (abfd
)->full_aouthdr
)
3166 sofar
+= bfd_coff_aoutsz (abfd
);
3168 sofar
+= SMALL_AOUTSZ
;
3171 sofar
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
3174 /* XCOFF handles overflows in the reloc and line number count fields
3175 by allocating a new section header to hold the correct counts. */
3176 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3177 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3178 sofar
+= bfd_coff_scnhsz (abfd
);
3181 #ifdef COFF_IMAGE_WITH_PE
3183 /* PE requires the sections to be in memory order when listed in
3184 the section headers. It also does not like empty loadable
3185 sections. The sections apparently do not have to be in the
3186 right order in the image file itself, but we do need to get the
3187 target_index values right. */
3190 asection
**section_list
;
3194 #ifdef COFF_PAGE_SIZE
3195 /* Clear D_PAGED if section alignment is smaller than
3197 if (pe_data (abfd
)->pe_opthdr
.SectionAlignment
< COFF_PAGE_SIZE
)
3198 abfd
->flags
&= ~D_PAGED
;
3202 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3205 /* We allocate an extra cell to simplify the final loop. */
3206 amt
= sizeof (struct asection
*) * (count
+ 1);
3207 section_list
= (asection
**) bfd_malloc (amt
);
3208 if (section_list
== NULL
)
3212 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3214 section_list
[i
] = current
;
3217 section_list
[i
] = NULL
;
3219 qsort (section_list
, count
, sizeof (asection
*), sort_by_secaddr
);
3221 /* Rethread the linked list into sorted order; at the same time,
3222 assign target_index values. */
3224 abfd
->sections
= NULL
;
3225 abfd
->section_last
= NULL
;
3226 for (i
= 0; i
< count
; i
++)
3228 current
= section_list
[i
];
3229 bfd_section_list_append (abfd
, current
);
3231 /* Later, if the section has zero size, we'll be throwing it
3232 away, so we don't want to number it now. Note that having
3233 a zero size and having real contents are different
3234 concepts: .bss has no contents, but (usually) non-zero
3236 if (current
->size
== 0)
3238 /* Discard. However, it still might have (valid) symbols
3239 in it, so arbitrarily set it to section 1 (indexing is
3240 1-based here; usually .text). __end__ and other
3241 contents of .endsection really have this happen.
3242 FIXME: This seems somewhat dubious. */
3243 current
->target_index
= 1;
3246 current
->target_index
= target_index
++;
3249 free (section_list
);
3251 #else /* ! COFF_IMAGE_WITH_PE */
3253 /* Set the target_index field. */
3255 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3256 current
->target_index
= target_index
++;
3258 #endif /* ! COFF_IMAGE_WITH_PE */
3260 if (target_index
>= 32768)
3262 bfd_set_error (bfd_error_file_too_big
);
3263 (*_bfd_error_handler
)
3264 (_("%B: too many sections (%d)"), abfd
, target_index
);
3268 align_adjust
= FALSE
;
3269 for (current
= abfd
->sections
;
3271 current
= current
->next
)
3273 #ifdef COFF_IMAGE_WITH_PE
3274 /* With PE we have to pad each section to be a multiple of its
3275 page size too, and remember both sizes. */
3276 if (coff_section_data (abfd
, current
) == NULL
)
3278 bfd_size_type amt
= sizeof (struct coff_section_tdata
);
3280 current
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
3281 if (current
->used_by_bfd
== NULL
)
3284 if (pei_section_data (abfd
, current
) == NULL
)
3286 bfd_size_type amt
= sizeof (struct pei_section_tdata
);
3288 coff_section_data (abfd
, current
)->tdata
= bfd_zalloc (abfd
, amt
);
3289 if (coff_section_data (abfd
, current
)->tdata
== NULL
)
3292 if (pei_section_data (abfd
, current
)->virt_size
== 0)
3293 pei_section_data (abfd
, current
)->virt_size
= current
->size
;
3296 /* Only deal with sections which have contents. */
3297 if (!(current
->flags
& SEC_HAS_CONTENTS
))
3300 current
->rawsize
= current
->size
;
3302 #ifdef COFF_IMAGE_WITH_PE
3303 /* Make sure we skip empty sections in a PE image. */
3304 if (current
->size
== 0)
3308 /* Align the sections in the file to the same boundary on
3309 which they are aligned in virtual memory. I960 doesn't
3310 do this (FIXME) so we can stay in sync with Intel. 960
3311 doesn't yet page from files... */
3312 #ifdef ALIGN_SECTIONS_IN_FILE
3313 if ((abfd
->flags
& EXEC_P
) != 0)
3315 /* Make sure this section is aligned on the right boundary - by
3316 padding the previous section up if necessary. */
3320 /* AIX loader checks the text section alignment of (vma - filepos)
3321 So even though the filepos may be aligned wrt the o_algntext, for
3322 AIX executables, this check fails. This shows up when a native
3323 AIX executable is stripped with gnu strip because the default vma
3324 of native is 0x10000150 but default for gnu is 0x10000140. Gnu
3325 stripped gnu excutable passes this check because the filepos is
3326 0x0140. This problem also show up with 64 bit shared objects. The
3327 data section must also be aligned. */
3328 if (!strcmp (current
->name
, _TEXT
)
3329 || !strcmp (current
->name
, _DATA
))
3334 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3336 align
= 1 << current
->alignment_power
;
3337 pad
= abs (current
->vma
- sofar
) % align
;
3348 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3351 if (previous
!= NULL
)
3352 previous
->size
+= sofar
- old_sofar
;
3357 /* In demand paged files the low order bits of the file offset
3358 must match the low order bits of the virtual address. */
3359 #ifdef COFF_PAGE_SIZE
3360 if ((abfd
->flags
& D_PAGED
) != 0
3361 && (current
->flags
& SEC_ALLOC
) != 0)
3362 sofar
+= (current
->vma
- (bfd_vma
) sofar
) % page_size
;
3364 current
->filepos
= sofar
;
3366 #ifdef COFF_IMAGE_WITH_PE
3367 /* Set the padded size. */
3368 current
->size
= (current
->size
+ page_size
- 1) & -page_size
;
3371 sofar
+= current
->size
;
3373 #ifdef ALIGN_SECTIONS_IN_FILE
3374 /* Make sure that this section is of the right size too. */
3375 if ((abfd
->flags
& EXEC_P
) == 0)
3377 bfd_size_type old_size
;
3379 old_size
= current
->size
;
3380 current
->size
= BFD_ALIGN (current
->size
,
3381 1 << current
->alignment_power
);
3382 align_adjust
= current
->size
!= old_size
;
3383 sofar
+= current
->size
- old_size
;
3388 sofar
= BFD_ALIGN (sofar
, 1 << current
->alignment_power
);
3389 align_adjust
= sofar
!= old_sofar
;
3390 current
->size
+= sofar
- old_sofar
;
3394 #ifdef COFF_IMAGE_WITH_PE
3395 /* For PE we need to make sure we pad out to the aligned
3396 size, in case the caller only writes out data to the
3398 if (pei_section_data (abfd
, current
)->virt_size
< current
->size
)
3399 align_adjust
= TRUE
;
3403 /* Force .lib sections to start at zero. The vma is then
3404 incremented in coff_set_section_contents. This is right for
3406 if (strcmp (current
->name
, _LIB
) == 0)
3407 bfd_set_section_vma (abfd
, current
, 0);
3410 #ifdef ALIGN_SECTIONS_IN_FILE
3415 /* It is now safe to write to the output file. If we needed an
3416 alignment adjustment for the last section, then make sure that
3417 there is a byte at offset sofar. If there are no symbols and no
3418 relocs, then nothing follows the last section. If we don't force
3419 the last byte out, then the file may appear to be truncated. */
3425 if (bfd_seek (abfd
, sofar
- 1, SEEK_SET
) != 0
3426 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
3430 /* Make sure the relocations are aligned. We don't need to make
3431 sure that this byte exists, because it will only matter if there
3432 really are relocs. */
3433 sofar
= BFD_ALIGN (sofar
, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER
);
3435 obj_relocbase (abfd
) = sofar
;
3436 abfd
->output_has_begun
= TRUE
;
3441 #ifdef COFF_IMAGE_WITH_PE
3443 static unsigned int pelength
;
3444 static unsigned int peheader
;
3447 coff_read_word (bfd
*abfd
, unsigned int *value
)
3452 status
= bfd_bread (b
, (bfd_size_type
) 2, abfd
);
3460 *value
= (unsigned int) b
[0];
3462 *value
= (unsigned int) (b
[0] + (b
[1] << 8));
3464 pelength
+= (unsigned int) status
;
3470 coff_compute_checksum (bfd
*abfd
)
3472 bfd_boolean more_data
;
3479 filepos
= (file_ptr
) 0;
3483 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
3486 more_data
= coff_read_word (abfd
, &value
);
3488 total
= 0xffff & (total
+ (total
>> 0x10));
3493 return (0xffff & (total
+ (total
>> 0x10)));
3497 coff_apply_checksum (bfd
*abfd
)
3499 unsigned int computed
;
3500 unsigned int checksum
= 0;
3502 if (bfd_seek (abfd
, 0x3c, SEEK_SET
) != 0)
3505 if (!coff_read_word (abfd
, &peheader
))
3508 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3512 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3514 if (bfd_seek (abfd
, peheader
, SEEK_SET
) != 0)
3517 computed
= coff_compute_checksum (abfd
);
3519 checksum
= computed
+ pelength
;
3521 if (bfd_seek (abfd
, peheader
+ 0x58, SEEK_SET
) != 0)
3524 bfd_bwrite (&checksum
, (bfd_size_type
) 4, abfd
);
3529 #endif /* COFF_IMAGE_WITH_PE */
3532 coff_write_object_contents (bfd
* abfd
)
3535 bfd_boolean hasrelocs
= FALSE
;
3536 bfd_boolean haslinno
= FALSE
;
3537 #ifdef COFF_IMAGE_WITH_PE
3538 bfd_boolean hasdebug
= FALSE
;
3541 file_ptr reloc_base
;
3542 file_ptr lineno_base
;
3544 unsigned long reloc_size
= 0, reloc_count
= 0;
3545 unsigned long lnno_size
= 0;
3546 bfd_boolean long_section_names
;
3547 asection
*text_sec
= NULL
;
3548 asection
*data_sec
= NULL
;
3549 asection
*bss_sec
= NULL
;
3550 struct internal_filehdr internal_f
;
3551 struct internal_aouthdr internal_a
;
3552 #ifdef COFF_LONG_SECTION_NAMES
3553 size_t string_size
= STRING_SIZE_SIZE
;
3556 bfd_set_error (bfd_error_system_call
);
3558 /* Make a pass through the symbol table to count line number entries and
3559 put them into the correct asections. */
3560 lnno_size
= coff_count_linenumbers (abfd
) * bfd_coff_linesz (abfd
);
3562 if (! abfd
->output_has_begun
)
3564 if (! coff_compute_section_file_positions (abfd
))
3568 reloc_base
= obj_relocbase (abfd
);
3570 /* Work out the size of the reloc and linno areas. */
3572 for (current
= abfd
->sections
; current
!= NULL
; current
=
3576 /* We store the actual reloc count in the first reloc's addr. */
3577 if (obj_pe (abfd
) && current
->reloc_count
>= 0xffff)
3580 reloc_count
+= current
->reloc_count
;
3583 reloc_size
= reloc_count
* bfd_coff_relsz (abfd
);
3585 lineno_base
= reloc_base
+ reloc_size
;
3586 sym_base
= lineno_base
+ lnno_size
;
3588 /* Indicate in each section->line_filepos its actual file address. */
3589 for (current
= abfd
->sections
; current
!= NULL
; current
=
3592 if (current
->lineno_count
)
3594 current
->line_filepos
= lineno_base
;
3595 current
->moving_line_filepos
= lineno_base
;
3596 lineno_base
+= current
->lineno_count
* bfd_coff_linesz (abfd
);
3599 current
->line_filepos
= 0;
3601 if (current
->reloc_count
)
3603 current
->rel_filepos
= reloc_base
;
3604 reloc_base
+= current
->reloc_count
* bfd_coff_relsz (abfd
);
3606 /* Extra reloc to hold real count. */
3607 if (obj_pe (abfd
) && current
->reloc_count
>= 0xffff)
3608 reloc_base
+= bfd_coff_relsz (abfd
);
3612 current
->rel_filepos
= 0;
3615 /* Write section headers to the file. */
3616 internal_f
.f_nscns
= 0;
3618 if ((abfd
->flags
& EXEC_P
) != 0)
3619 scn_base
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
3622 scn_base
= bfd_coff_filhsz (abfd
);
3625 if (xcoff_data (abfd
)->full_aouthdr
)
3626 scn_base
+= bfd_coff_aoutsz (abfd
);
3628 scn_base
+= SMALL_AOUTSZ
;
3633 if (bfd_seek (abfd
, scn_base
, SEEK_SET
) != 0)
3636 long_section_names
= FALSE
;
3637 for (current
= abfd
->sections
;
3639 current
= current
->next
)
3641 struct internal_scnhdr section
;
3642 #ifdef COFF_IMAGE_WITH_PE
3643 bfd_boolean is_reloc_section
= FALSE
;
3645 if (strcmp (current
->name
, DOT_RELOC
) == 0)
3647 is_reloc_section
= TRUE
;
3649 pe_data (abfd
)->has_reloc_section
= 1;
3653 internal_f
.f_nscns
++;
3655 strncpy (section
.s_name
, current
->name
, SCNNMLEN
);
3657 #ifdef COFF_LONG_SECTION_NAMES
3658 /* Handle long section names as in PE. This must be compatible
3659 with the code in coff_write_symbols and _bfd_coff_final_link. */
3660 if (bfd_coff_long_section_names (abfd
))
3664 len
= strlen (current
->name
);
3667 /* The s_name field is defined to be NUL-padded but need not be
3668 NUL-terminated. We use a temporary buffer so that we can still
3669 sprintf all eight chars without splatting a terminating NUL
3670 over the first byte of the following member (s_paddr). */
3671 char s_name_buf
[SCNNMLEN
+ 1];
3673 /* An inherent limitation of the /nnnnnnn notation used to indicate
3674 the offset of the long name in the string table is that we
3675 cannot address entries beyone the ten million byte boundary. */
3676 if (string_size
>= 10000000)
3678 bfd_set_error (bfd_error_file_too_big
);
3679 (*_bfd_error_handler
)
3680 (_("%B: section %s: string table overflow at offset %ld"),
3681 abfd
, current
->name
, string_size
);
3685 /* snprintf not strictly necessary now we've verified the value
3686 has less than eight ASCII digits, but never mind. */
3687 snprintf (s_name_buf
, SCNNMLEN
+ 1, "/%lu", (unsigned long) string_size
);
3688 /* Then strncpy takes care of any padding for us. */
3689 strncpy (section
.s_name
, s_name_buf
, SCNNMLEN
);
3690 string_size
+= len
+ 1;
3691 long_section_names
= TRUE
;
3697 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3698 Ian Taylor <ian@cygnus.com>. */
3699 if (strcmp (current
->name
, _LIB
) == 0)
3700 section
.s_vaddr
= 0;
3703 section
.s_vaddr
= current
->vma
;
3704 section
.s_paddr
= current
->lma
;
3705 section
.s_size
= current
->size
;
3706 #ifdef coff_get_section_load_page
3707 section
.s_page
= coff_get_section_load_page (current
);
3713 section
.s_paddr
= 0;
3715 #ifdef COFF_IMAGE_WITH_PE
3716 /* Reminder: s_paddr holds the virtual size of the section. */
3717 if (coff_section_data (abfd
, current
) != NULL
3718 && pei_section_data (abfd
, current
) != NULL
)
3719 section
.s_paddr
= pei_section_data (abfd
, current
)->virt_size
;
3721 section
.s_paddr
= 0;
3724 /* If this section has no size or is unloadable then the scnptr
3726 if (current
->size
== 0
3727 || (current
->flags
& (SEC_LOAD
| SEC_HAS_CONTENTS
)) == 0)
3728 section
.s_scnptr
= 0;
3730 section
.s_scnptr
= current
->filepos
;
3732 section
.s_relptr
= current
->rel_filepos
;
3733 section
.s_lnnoptr
= current
->line_filepos
;
3734 section
.s_nreloc
= current
->reloc_count
;
3735 section
.s_nlnno
= current
->lineno_count
;
3736 #ifndef COFF_IMAGE_WITH_PE
3737 /* In PEI, relocs come in the .reloc section. */
3738 if (current
->reloc_count
!= 0)
3741 if (current
->lineno_count
!= 0)
3743 #ifdef COFF_IMAGE_WITH_PE
3744 if ((current
->flags
& SEC_DEBUGGING
) != 0
3745 && ! is_reloc_section
)
3751 /* Indicate the use of an XCOFF overflow section header. */
3752 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3754 section
.s_nreloc
= 0xffff;
3755 section
.s_nlnno
= 0xffff;
3760 section
.s_flags
= sec_to_styp_flags (current
->name
, current
->flags
);
3762 if (!strcmp (current
->name
, _TEXT
))
3764 else if (!strcmp (current
->name
, _DATA
))
3766 else if (!strcmp (current
->name
, _BSS
))
3770 section
.s_align
= (current
->alignment_power
3771 ? 1 << current
->alignment_power
3775 /* TI COFF puts the alignment power in bits 8-11 of the flags. */
3776 section
.s_flags
|= (current
->alignment_power
& 0xF) << 8;
3778 #ifdef COFF_ENCODE_ALIGNMENT
3779 COFF_ENCODE_ALIGNMENT(section
, current
->alignment_power
);
3782 #ifdef COFF_IMAGE_WITH_PE
3783 /* Suppress output of the sections if they are null. ld
3784 includes the bss and data sections even if there is no size
3785 assigned to them. NT loader doesn't like it if these section
3786 headers are included if the sections themselves are not
3787 needed. See also coff_compute_section_file_positions. */
3788 if (section
.s_size
== 0)
3789 internal_f
.f_nscns
--;
3794 bfd_size_type amt
= bfd_coff_scnhsz (abfd
);
3796 if (coff_swap_scnhdr_out (abfd
, §ion
, &buff
) == 0
3797 || bfd_bwrite (& buff
, amt
, abfd
) != amt
)
3802 /* PE stores COMDAT section information in the symbol table. If
3803 this section is supposed to have some COMDAT info, track down
3804 the symbol in the symbol table and modify it. */
3805 if ((current
->flags
& SEC_LINK_ONCE
) != 0)
3807 unsigned int i
, count
;
3809 coff_symbol_type
*csym
= NULL
;
3813 count
= bfd_get_symcount (abfd
);
3814 for (i
= 0, psym
= abfd
->outsymbols
; i
< count
; i
++, psym
++)
3816 if ((*psym
)->section
!= current
)
3819 /* Remember the location of the first symbol in this
3821 if (psymsec
== NULL
)
3824 /* See if this is the section symbol. */
3825 if (strcmp ((*psym
)->name
, current
->name
) == 0)
3827 csym
= coff_symbol_from (abfd
, *psym
);
3829 || csym
->native
== NULL
3830 || csym
->native
->u
.syment
.n_numaux
< 1
3831 || csym
->native
->u
.syment
.n_sclass
!= C_STAT
3832 || csym
->native
->u
.syment
.n_type
!= T_NULL
)
3835 /* Here *PSYM is the section symbol for CURRENT. */
3842 Note that we might not if we're converting the file from
3843 some other object file format. */
3846 combined_entry_type
*aux
;
3848 /* We don't touch the x_checksum field. The
3849 x_associated field is not currently supported. */
3851 aux
= csym
->native
+ 1;
3852 switch (current
->flags
& SEC_LINK_DUPLICATES
)
3854 case SEC_LINK_DUPLICATES_DISCARD
:
3855 aux
->u
.auxent
.x_scn
.x_comdat
= IMAGE_COMDAT_SELECT_ANY
;
3858 case SEC_LINK_DUPLICATES_ONE_ONLY
:
3859 aux
->u
.auxent
.x_scn
.x_comdat
=
3860 IMAGE_COMDAT_SELECT_NODUPLICATES
;
3863 case SEC_LINK_DUPLICATES_SAME_SIZE
:
3864 aux
->u
.auxent
.x_scn
.x_comdat
=
3865 IMAGE_COMDAT_SELECT_SAME_SIZE
;
3868 case SEC_LINK_DUPLICATES_SAME_CONTENTS
:
3869 aux
->u
.auxent
.x_scn
.x_comdat
=
3870 IMAGE_COMDAT_SELECT_EXACT_MATCH
;
3874 /* The COMDAT symbol must be the first symbol from this
3875 section in the symbol table. In order to make this
3876 work, we move the COMDAT symbol before the first
3877 symbol we found in the search above. It's OK to
3878 rearrange the symbol table at this point, because
3879 coff_renumber_symbols is going to rearrange it
3880 further and fix up all the aux entries. */
3881 if (psym
!= psymsec
)
3887 for (pcopy
= psym
; pcopy
> psymsec
; pcopy
--)
3888 pcopy
[0] = pcopy
[-1];
3893 #endif /* COFF_WITH_PE */
3898 /* XCOFF handles overflows in the reloc and line number count fields
3899 by creating a new section header to hold the correct values. */
3900 for (current
= abfd
->sections
; current
!= NULL
; current
= current
->next
)
3902 if (current
->reloc_count
>= 0xffff || current
->lineno_count
>= 0xffff)
3904 struct internal_scnhdr scnhdr
;
3908 internal_f
.f_nscns
++;
3909 strncpy (&(scnhdr
.s_name
[0]), current
->name
, 8);
3910 scnhdr
.s_paddr
= current
->reloc_count
;
3911 scnhdr
.s_vaddr
= current
->lineno_count
;
3913 scnhdr
.s_scnptr
= 0;
3914 scnhdr
.s_relptr
= current
->rel_filepos
;
3915 scnhdr
.s_lnnoptr
= current
->line_filepos
;
3916 scnhdr
.s_nreloc
= current
->target_index
;
3917 scnhdr
.s_nlnno
= current
->target_index
;
3918 scnhdr
.s_flags
= STYP_OVRFLO
;
3919 amt
= bfd_coff_scnhsz (abfd
);
3920 if (coff_swap_scnhdr_out (abfd
, &scnhdr
, &buff
) == 0
3921 || bfd_bwrite (& buff
, amt
, abfd
) != amt
)
3928 /* OK, now set up the filehdr... */
3930 /* Don't include the internal abs section in the section count */
3932 /* We will NOT put a fucking timestamp in the header here. Every time you
3933 put it back, I will come in and take it out again. I'm sorry. This
3934 field does not belong here. We fill it with a 0 so it compares the
3935 same but is not a reasonable time. -- gnu@cygnus.com */
3936 internal_f
.f_timdat
= 0;
3937 internal_f
.f_flags
= 0;
3939 if (abfd
->flags
& EXEC_P
)
3940 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3943 internal_f
.f_opthdr
= 0;
3946 if (xcoff_data (abfd
)->full_aouthdr
)
3947 internal_f
.f_opthdr
= bfd_coff_aoutsz (abfd
);
3949 internal_f
.f_opthdr
= SMALL_AOUTSZ
;
3955 internal_f
.f_flags
|= F_RELFLG
;
3957 internal_f
.f_flags
|= F_LNNO
;
3958 if (abfd
->flags
& EXEC_P
)
3959 internal_f
.f_flags
|= F_EXEC
;
3960 #ifdef COFF_IMAGE_WITH_PE
3962 internal_f
.f_flags
|= IMAGE_FILE_DEBUG_STRIPPED
;
3963 if (pe_data (abfd
)->real_flags
& IMAGE_FILE_LARGE_ADDRESS_AWARE
)
3964 internal_f
.f_flags
|= IMAGE_FILE_LARGE_ADDRESS_AWARE
;
3967 #ifndef COFF_WITH_pex64
3969 internal_f
.f_flags
|= IMAGE_FILE_32BIT_MACHINE
;
3971 if (bfd_little_endian (abfd
))
3972 internal_f
.f_flags
|= F_AR32WR
;
3974 internal_f
.f_flags
|= F_AR32W
;
3979 /* Target id is used in TI COFF v1 and later; COFF0 won't use this field,
3980 but it doesn't hurt to set it internally. */
3981 internal_f
.f_target_id
= TI_TARGET_ID
;
3983 #ifdef TIC80_TARGET_ID
3984 internal_f
.f_target_id
= TIC80_TARGET_ID
;
3987 /* FIXME, should do something about the other byte orders and
3991 if ((abfd
->flags
& DYNAMIC
) != 0)
3992 internal_f
.f_flags
|= F_SHROBJ
;
3993 if (bfd_get_section_by_name (abfd
, _LOADER
) != NULL
)
3994 internal_f
.f_flags
|= F_DYNLOAD
;
3997 memset (&internal_a
, 0, sizeof internal_a
);
3999 /* Set up architecture-dependent stuff. */
4001 unsigned int magic
= 0;
4002 unsigned short flags
= 0;
4004 coff_set_flags (abfd
, &magic
, &flags
);
4005 internal_f
.f_magic
= magic
;
4006 internal_f
.f_flags
|= flags
;
4007 /* ...and the "opt"hdr... */
4009 #ifdef TICOFF_AOUT_MAGIC
4010 internal_a
.magic
= TICOFF_AOUT_MAGIC
;
4011 #define __A_MAGIC_SET__
4014 internal_a
.magic
= TIC80_ARCH_MAGIC
;
4015 #define __A_MAGIC_SET__
4018 /* FIXME: What are the a.out magic numbers for the i860? */
4019 internal_a
.magic
= 0;
4020 #define __A_MAGIC_SET__
4023 internal_a
.magic
= (magic
== I960ROMAGIC
? NMAGIC
: OMAGIC
);
4024 #define __A_MAGIC_SET__
4027 #define __A_MAGIC_SET__
4028 internal_a
.magic
= PAGEMAGICBCS
;
4032 #define __A_MAGIC_SET__
4033 internal_a
.magic
= APOLLO_COFF_VERSION_NUMBER
;
4036 #if defined(M68) || defined(WE32K) || defined(M68K)
4037 #define __A_MAGIC_SET__
4039 internal_a
.magic
= LYNXCOFFMAGIC
;
4041 #if defined(TARG_AUX)
4042 internal_a
.magic
= (abfd
->flags
& D_PAGED
? PAGEMAGICPEXECPAGED
:
4043 abfd
->flags
& WP_TEXT
? PAGEMAGICPEXECSWAPPED
:
4044 PAGEMAGICEXECSWAPPED
);
4046 #if defined (PAGEMAGICPEXECPAGED)
4047 internal_a
.magic
= PAGEMAGICPEXECPAGED
;
4049 #endif /* TARG_AUX */
4051 #endif /* M68 || WE32K || M68K */
4054 #define __A_MAGIC_SET__
4055 internal_a
.magic
= ZMAGIC
;
4059 #define __A_MAGIC_SET__
4060 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
4063 #if defined MCORE_PE
4064 #define __A_MAGIC_SET__
4065 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR_MAGIC
;
4069 #define __A_MAGIC_SET__
4071 internal_a
.magic
= LYNXCOFFMAGIC
;
4073 internal_a
.magic
= IMAGE_NT_OPTIONAL_HDR64_MAGIC
;
4075 internal_a
.magic
= ZMAGIC
;
4080 #define __A_MAGIC_SET__
4081 internal_a
.magic
= PE32PMAGIC
;
4085 #define __A_MAGIC_SET__
4087 internal_a
.magic
= LYNXCOFFMAGIC
;
4092 #define __A_MAGIC_SET__
4093 internal_a
.magic
= (abfd
->flags
& D_PAGED
) ? RS6K_AOUTHDR_ZMAGIC
:
4094 (abfd
->flags
& WP_TEXT
) ? RS6K_AOUTHDR_NMAGIC
:
4095 RS6K_AOUTHDR_OMAGIC
;
4098 #if defined(SH) && defined(COFF_WITH_PE)
4099 #define __A_MAGIC_SET__
4100 internal_a
.magic
= SH_PE_MAGIC
;
4103 #if defined(MIPS) && defined(COFF_WITH_PE)
4104 #define __A_MAGIC_SET__
4105 internal_a
.magic
= MIPS_PE_MAGIC
;
4109 #define __A_MAGIC_SET__
4110 internal_a
.magic
= NMAGIC
; /* Assume separate i/d. */
4113 #ifndef __A_MAGIC_SET__
4114 #include "Your aouthdr magic number is not being set!"
4116 #undef __A_MAGIC_SET__
4120 /* FIXME: Does anybody ever set this to another value? */
4121 internal_a
.vstamp
= 0;
4123 /* Now should write relocs, strings, syms. */
4124 obj_sym_filepos (abfd
) = sym_base
;
4126 if (bfd_get_symcount (abfd
) != 0)
4130 if (!coff_renumber_symbols (abfd
, &firstundef
))
4132 coff_mangle_symbols (abfd
);
4133 if (! coff_write_symbols (abfd
))
4135 if (! coff_write_linenumbers (abfd
))
4137 if (! coff_write_relocs (abfd
, firstundef
))
4140 #ifdef COFF_LONG_SECTION_NAMES
4141 else if (long_section_names
&& ! obj_coff_strings_written (abfd
))
4143 /* If we have long section names we have to write out the string
4144 table even if there are no symbols. */
4145 if (! coff_write_symbols (abfd
))
4149 #ifdef COFF_IMAGE_WITH_PE
4151 else if ((abfd
->flags
& EXEC_P
) != 0)
4155 /* PowerPC PE appears to require that all executable files be
4156 rounded up to the page size. */
4159 (file_ptr
) BFD_ALIGN (sym_base
, COFF_PAGE_SIZE
) - 1,
4161 || bfd_bwrite (&b
, (bfd_size_type
) 1, abfd
) != 1)
4167 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
4168 backend linker, and obj_raw_syment_count is not valid until after
4169 coff_write_symbols is called. */
4170 if (obj_raw_syment_count (abfd
) != 0)
4172 internal_f
.f_symptr
= sym_base
;
4174 /* AIX appears to require that F_RELFLG not be set if there are
4175 local symbols but no relocations. */
4176 internal_f
.f_flags
&=~ F_RELFLG
;
4181 if (long_section_names
)
4182 internal_f
.f_symptr
= sym_base
;
4184 internal_f
.f_symptr
= 0;
4185 internal_f
.f_flags
|= F_LSYMS
;
4190 internal_a
.tsize
= text_sec
->size
;
4191 internal_a
.text_start
= internal_a
.tsize
? text_sec
->vma
: 0;
4195 internal_a
.dsize
= data_sec
->size
;
4196 internal_a
.data_start
= internal_a
.dsize
? data_sec
->vma
: 0;
4200 internal_a
.bsize
= bss_sec
->size
;
4201 if (internal_a
.bsize
&& bss_sec
->vma
< internal_a
.data_start
)
4202 internal_a
.data_start
= bss_sec
->vma
;
4205 internal_a
.entry
= bfd_get_start_address (abfd
);
4206 internal_f
.f_nsyms
= obj_raw_syment_count (abfd
);
4209 if (xcoff_data (abfd
)->full_aouthdr
)
4212 asection
*loader_sec
;
4214 internal_a
.vstamp
= 1;
4216 internal_a
.o_snentry
= xcoff_data (abfd
)->snentry
;
4217 if (internal_a
.o_snentry
== 0)
4218 internal_a
.entry
= (bfd_vma
) -1;
4220 if (text_sec
!= NULL
)
4222 internal_a
.o_sntext
= text_sec
->target_index
;
4223 internal_a
.o_algntext
= bfd_get_section_alignment (abfd
, text_sec
);
4227 internal_a
.o_sntext
= 0;
4228 internal_a
.o_algntext
= 0;
4230 if (data_sec
!= NULL
)
4232 internal_a
.o_sndata
= data_sec
->target_index
;
4233 internal_a
.o_algndata
= bfd_get_section_alignment (abfd
, data_sec
);
4237 internal_a
.o_sndata
= 0;
4238 internal_a
.o_algndata
= 0;
4240 loader_sec
= bfd_get_section_by_name (abfd
, ".loader");
4241 if (loader_sec
!= NULL
)
4242 internal_a
.o_snloader
= loader_sec
->target_index
;
4244 internal_a
.o_snloader
= 0;
4245 if (bss_sec
!= NULL
)
4246 internal_a
.o_snbss
= bss_sec
->target_index
;
4248 internal_a
.o_snbss
= 0;
4250 toc
= xcoff_data (abfd
)->toc
;
4251 internal_a
.o_toc
= toc
;
4252 internal_a
.o_sntoc
= xcoff_data (abfd
)->sntoc
;
4254 internal_a
.o_modtype
= xcoff_data (abfd
)->modtype
;
4255 if (xcoff_data (abfd
)->cputype
!= -1)
4256 internal_a
.o_cputype
= xcoff_data (abfd
)->cputype
;
4259 switch (bfd_get_arch (abfd
))
4261 case bfd_arch_rs6000
:
4262 internal_a
.o_cputype
= 4;
4264 case bfd_arch_powerpc
:
4265 if (bfd_get_mach (abfd
) == bfd_mach_ppc
)
4266 internal_a
.o_cputype
= 3;
4268 internal_a
.o_cputype
= 1;
4274 internal_a
.o_maxstack
= xcoff_data (abfd
)->maxstack
;
4275 internal_a
.o_maxdata
= xcoff_data (abfd
)->maxdata
;
4279 /* Now write them. */
4280 if (bfd_seek (abfd
, (file_ptr
) 0, SEEK_SET
) != 0)
4285 bfd_size_type amount
= bfd_coff_filhsz (abfd
);
4287 buff
= (char *) bfd_malloc (amount
);
4291 bfd_coff_swap_filehdr_out (abfd
, & internal_f
, buff
);
4292 amount
= bfd_bwrite (buff
, amount
, abfd
);
4296 if (amount
!= bfd_coff_filhsz (abfd
))
4300 if (abfd
->flags
& EXEC_P
)
4302 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4303 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)). */
4305 bfd_size_type amount
= bfd_coff_aoutsz (abfd
);
4307 buff
= (char *) bfd_malloc (amount
);
4311 coff_swap_aouthdr_out (abfd
, & internal_a
, buff
);
4312 amount
= bfd_bwrite (buff
, amount
, abfd
);
4316 if (amount
!= bfd_coff_aoutsz (abfd
))
4319 #ifdef COFF_IMAGE_WITH_PE
4320 if (! coff_apply_checksum (abfd
))
4330 /* XCOFF seems to always write at least a small a.out header. */
4331 coff_swap_aouthdr_out (abfd
, & internal_a
, & buff
);
4332 if (xcoff_data (abfd
)->full_aouthdr
)
4333 size
= bfd_coff_aoutsz (abfd
);
4335 size
= SMALL_AOUTSZ
;
4336 if (bfd_bwrite (& buff
, (bfd_size_type
) size
, abfd
) != size
)
4345 coff_set_section_contents (bfd
* abfd
,
4347 const void * location
,
4349 bfd_size_type count
)
4351 if (! abfd
->output_has_begun
) /* Set by bfd.c handler. */
4353 if (! coff_compute_section_file_positions (abfd
))
4357 #if defined(_LIB) && !defined(TARG_AUX)
4358 /* The physical address field of a .lib section is used to hold the
4359 number of shared libraries in the section. This code counts the
4360 number of sections being written, and increments the lma field
4363 I have found no documentation on the contents of this section.
4364 Experimentation indicates that the section contains zero or more
4365 records, each of which has the following structure:
4367 - a (four byte) word holding the length of this record, in words,
4368 - a word that always seems to be set to "2",
4369 - the path to a shared library, null-terminated and then padded
4370 to a whole word boundary.
4372 bfd_assert calls have been added to alert if an attempt is made
4373 to write a section which doesn't follow these assumptions. The
4374 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4375 <robertl@arnet.com> (Thanks!).
4377 Gvran Uddeborg <gvran@uddeborg.pp.se>. */
4378 if (strcmp (section
->name
, _LIB
) == 0)
4380 bfd_byte
*rec
, *recend
;
4382 rec
= (bfd_byte
*) location
;
4383 recend
= rec
+ count
;
4384 while (rec
< recend
)
4387 rec
+= bfd_get_32 (abfd
, rec
) * 4;
4390 BFD_ASSERT (rec
== recend
);
4394 /* Don't write out bss sections - one way to do this is to
4395 see if the filepos has not been set. */
4396 if (section
->filepos
== 0)
4399 if (bfd_seek (abfd
, section
->filepos
+ offset
, SEEK_SET
) != 0)
4405 return bfd_bwrite (location
, count
, abfd
) == count
;
4409 buy_and_read (bfd
*abfd
, file_ptr where
, bfd_size_type size
)
4411 void * area
= bfd_alloc (abfd
, size
);
4415 if (bfd_seek (abfd
, where
, SEEK_SET
) != 0
4416 || bfd_bread (area
, size
, abfd
) != size
)
4425 Creating the linenumber table is done by reading in the entire
4426 coff linenumber table, and creating another table for internal use.
4428 A coff linenumber table is structured so that each function
4429 is marked as having a line number of 0. Each line within the
4430 function is an offset from the first line in the function. The
4431 base of the line number information for the table is stored in
4432 the symbol associated with the function.
4434 Note: The PE format uses line number 0 for a flag indicating a
4437 The information is copied from the external to the internal
4438 table, and each symbol which marks a function is marked by
4441 How does this work ?
4445 coff_sort_func_alent (const void * arg1
, const void * arg2
)
4447 const alent
*al1
= *(const alent
**) arg1
;
4448 const alent
*al2
= *(const alent
**) arg2
;
4449 const coff_symbol_type
*s1
= (const coff_symbol_type
*) (al1
->u
.sym
);
4450 const coff_symbol_type
*s2
= (const coff_symbol_type
*) (al2
->u
.sym
);
4452 if (s1
->symbol
.value
< s2
->symbol
.value
)
4454 else if (s1
->symbol
.value
> s2
->symbol
.value
)
4461 coff_slurp_line_table (bfd
*abfd
, asection
*asect
)
4463 LINENO
*native_lineno
;
4464 alent
*lineno_cache
;
4466 unsigned int counter
;
4468 bfd_vma prev_offset
= 0;
4470 unsigned int nbr_func
;
4473 BFD_ASSERT (asect
->lineno
== NULL
);
4475 amt
= ((bfd_size_type
) asect
->lineno_count
+ 1) * sizeof (alent
);
4476 lineno_cache
= (alent
*) bfd_alloc (abfd
, amt
);
4477 if (lineno_cache
== NULL
)
4480 amt
= (bfd_size_type
) bfd_coff_linesz (abfd
) * asect
->lineno_count
;
4481 native_lineno
= (LINENO
*) buy_and_read (abfd
, asect
->line_filepos
, amt
);
4482 if (native_lineno
== NULL
)
4484 (*_bfd_error_handler
)
4485 (_("%B: warning: line number table read failed"), abfd
);
4486 bfd_release (abfd
, lineno_cache
);
4490 cache_ptr
= lineno_cache
;
4491 asect
->lineno
= lineno_cache
;
4492 src
= native_lineno
;
4495 for (counter
= 0; counter
< asect
->lineno_count
; counter
++)
4497 struct internal_lineno dst
;
4499 bfd_coff_swap_lineno_in (abfd
, src
, &dst
);
4500 cache_ptr
->line_number
= dst
.l_lnno
;
4502 if (cache_ptr
->line_number
== 0)
4505 bfd_signed_vma symndx
;
4506 coff_symbol_type
*sym
;
4510 symndx
= dst
.l_addr
.l_symndx
;
4512 || (bfd_vma
) symndx
>= obj_raw_syment_count (abfd
))
4514 (*_bfd_error_handler
)
4515 (_("%B: warning: illegal symbol index %ld in line numbers"),
4516 abfd
, (long) symndx
);
4521 /* FIXME: We should not be casting between ints and
4522 pointers like this. */
4523 sym
= ((coff_symbol_type
*)
4524 ((symndx
+ obj_raw_syments (abfd
))
4525 ->u
.syment
._n
._n_n
._n_zeroes
));
4526 cache_ptr
->u
.sym
= (asymbol
*) sym
;
4527 if (sym
->lineno
!= NULL
&& ! warned
)
4528 (*_bfd_error_handler
)
4529 (_("%B: warning: duplicate line number information for `%s'"),
4530 abfd
, bfd_asymbol_name (&sym
->symbol
));
4532 sym
->lineno
= cache_ptr
;
4533 if (sym
->symbol
.value
< prev_offset
)
4535 prev_offset
= sym
->symbol
.value
;
4538 cache_ptr
->u
.offset
= dst
.l_addr
.l_paddr
4539 - bfd_section_vma (abfd
, asect
);
4544 cache_ptr
->line_number
= 0;
4545 bfd_release (abfd
, native_lineno
);
4547 /* On some systems (eg AIX5.3) the lineno table may not be sorted. */
4550 /* Sort the table. */
4552 alent
*n_lineno_cache
;
4554 /* Create a table of functions. */
4555 func_table
= (alent
**) bfd_alloc (abfd
, nbr_func
* sizeof (alent
*));
4556 if (func_table
!= NULL
)
4558 alent
**p
= func_table
;
4561 for (i
= 0; i
< counter
; i
++)
4562 if (lineno_cache
[i
].line_number
== 0)
4563 *p
++ = &lineno_cache
[i
];
4565 /* Sort by functions. */
4566 qsort (func_table
, nbr_func
, sizeof (alent
*), coff_sort_func_alent
);
4568 /* Create the new sorted table. */
4569 amt
= ((bfd_size_type
) asect
->lineno_count
+ 1) * sizeof (alent
);
4570 n_lineno_cache
= (alent
*) bfd_alloc (abfd
, amt
);
4571 if (n_lineno_cache
!= NULL
)
4573 alent
*n_cache_ptr
= n_lineno_cache
;
4575 for (i
= 0; i
< nbr_func
; i
++)
4577 coff_symbol_type
*sym
;
4578 alent
*old_ptr
= func_table
[i
];
4580 /* Copy the function entry and update it. */
4581 *n_cache_ptr
= *old_ptr
;
4582 sym
= (coff_symbol_type
*)n_cache_ptr
->u
.sym
;
4583 sym
->lineno
= n_cache_ptr
;
4587 /* Copy the line number entries. */
4588 while (old_ptr
->line_number
!= 0)
4589 *n_cache_ptr
++ = *old_ptr
++;
4591 n_cache_ptr
->line_number
= 0;
4592 memcpy (lineno_cache
, n_lineno_cache
, amt
);
4594 bfd_release (abfd
, func_table
);
4601 /* Slurp in the symbol table, converting it to generic form. Note
4602 that if coff_relocate_section is defined, the linker will read
4603 symbols via coff_link_add_symbols, rather than via this routine. */
4606 coff_slurp_symbol_table (bfd
* abfd
)
4608 combined_entry_type
*native_symbols
;
4609 coff_symbol_type
*cached_area
;
4610 unsigned int *table_ptr
;
4612 unsigned int number_of_symbols
= 0;
4614 if (obj_symbols (abfd
))
4617 /* Read in the symbol table. */
4618 if ((native_symbols
= coff_get_normalized_symtab (abfd
)) == NULL
)
4621 /* Allocate enough room for all the symbols in cached form. */
4622 amt
= obj_raw_syment_count (abfd
);
4623 amt
*= sizeof (coff_symbol_type
);
4624 cached_area
= (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
4625 if (cached_area
== NULL
)
4628 amt
= obj_raw_syment_count (abfd
);
4629 amt
*= sizeof (unsigned int);
4630 table_ptr
= (unsigned int *) bfd_alloc (abfd
, amt
);
4632 if (table_ptr
== NULL
)
4636 coff_symbol_type
*dst
= cached_area
;
4637 unsigned int last_native_index
= obj_raw_syment_count (abfd
);
4638 unsigned int this_index
= 0;
4640 while (this_index
< last_native_index
)
4642 combined_entry_type
*src
= native_symbols
+ this_index
;
4643 table_ptr
[this_index
] = number_of_symbols
;
4644 dst
->symbol
.the_bfd
= abfd
;
4646 dst
->symbol
.name
= (char *) (src
->u
.syment
._n
._n_n
._n_offset
);
4647 /* We use the native name field to point to the cached field. */
4648 src
->u
.syment
._n
._n_n
._n_zeroes
= (bfd_hostptr_t
) dst
;
4649 dst
->symbol
.section
= coff_section_from_bfd_index (abfd
,
4650 src
->u
.syment
.n_scnum
);
4651 dst
->symbol
.flags
= 0;
4652 dst
->done_lineno
= FALSE
;
4654 switch (src
->u
.syment
.n_sclass
)
4658 /* Fall through to next case. */
4665 case C_THUMBEXTFUNC
:
4671 case C_SYSTEM
: /* System Wide variable. */
4674 /* In PE, 0x68 (104) denotes a section symbol. */
4676 /* In PE, 0x69 (105) denotes a weak external symbol. */
4679 switch (coff_classify_symbol (abfd
, &src
->u
.syment
))
4681 case COFF_SYMBOL_GLOBAL
:
4682 dst
->symbol
.flags
= BSF_EXPORT
| BSF_GLOBAL
;
4683 #if defined COFF_WITH_PE
4684 /* PE sets the symbol to a value relative to the
4685 start of the section. */
4686 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4688 dst
->symbol
.value
= (src
->u
.syment
.n_value
4689 - dst
->symbol
.section
->vma
);
4691 if (ISFCN ((src
->u
.syment
.n_type
)))
4692 /* A function ext does not go at the end of a
4694 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4697 case COFF_SYMBOL_COMMON
:
4698 dst
->symbol
.section
= bfd_com_section_ptr
;
4699 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4702 case COFF_SYMBOL_UNDEFINED
:
4703 dst
->symbol
.section
= bfd_und_section_ptr
;
4704 dst
->symbol
.value
= 0;
4707 case COFF_SYMBOL_PE_SECTION
:
4708 dst
->symbol
.flags
|= BSF_EXPORT
| BSF_SECTION_SYM
;
4709 dst
->symbol
.value
= 0;
4712 case COFF_SYMBOL_LOCAL
:
4713 dst
->symbol
.flags
= BSF_LOCAL
;
4714 #if defined COFF_WITH_PE
4715 /* PE sets the symbol to a value relative to the
4716 start of the section. */
4717 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4719 dst
->symbol
.value
= (src
->u
.syment
.n_value
4720 - dst
->symbol
.section
->vma
);
4722 if (ISFCN ((src
->u
.syment
.n_type
)))
4723 dst
->symbol
.flags
|= BSF_NOT_AT_END
| BSF_FUNCTION
;
4728 /* A symbol with a csect entry should not go at the end. */
4729 if (src
->u
.syment
.n_numaux
> 0)
4730 dst
->symbol
.flags
|= BSF_NOT_AT_END
;
4734 if (src
->u
.syment
.n_sclass
== C_NT_WEAK
)
4735 dst
->symbol
.flags
|= BSF_WEAK
;
4737 if (src
->u
.syment
.n_sclass
== C_SECTION
4738 && src
->u
.syment
.n_scnum
> 0)
4739 dst
->symbol
.flags
= BSF_LOCAL
;
4741 if (src
->u
.syment
.n_sclass
== C_WEAKEXT
)
4742 dst
->symbol
.flags
|= BSF_WEAK
;
4746 case C_STAT
: /* Static. */
4748 case C_LEAFSTAT
: /* Static leaf procedure. */
4751 case C_THUMBSTAT
: /* Thumb static. */
4752 case C_THUMBLABEL
: /* Thumb label. */
4753 case C_THUMBSTATFUNC
:/* Thumb static function. */
4755 case C_LABEL
: /* Label. */
4756 if (src
->u
.syment
.n_scnum
== N_DEBUG
)
4757 dst
->symbol
.flags
= BSF_DEBUGGING
;
4759 dst
->symbol
.flags
= BSF_LOCAL
;
4761 /* Base the value as an index from the base of the
4762 section, if there is one. */
4763 if (dst
->symbol
.section
)
4765 #if defined COFF_WITH_PE
4766 /* PE sets the symbol to a value relative to the
4767 start of the section. */
4768 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4770 dst
->symbol
.value
= (src
->u
.syment
.n_value
4771 - dst
->symbol
.section
->vma
);
4775 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4778 case C_MOS
: /* Member of structure. */
4779 case C_EOS
: /* End of structure. */
4780 case C_REGPARM
: /* Register parameter. */
4781 case C_REG
: /* register variable. */
4782 /* C_AUTOARG conflicts with TI COFF C_UEXT. */
4783 #if !defined (TIC80COFF) && !defined (TICOFF)
4785 case C_AUTOARG
: /* 960-specific storage class. */
4788 case C_TPDEF
: /* Type definition. */
4790 case C_AUTO
: /* Automatic variable. */
4791 case C_FIELD
: /* Bit field. */
4792 case C_ENTAG
: /* Enumeration tag. */
4793 case C_MOE
: /* Member of enumeration. */
4794 case C_MOU
: /* Member of union. */
4795 case C_UNTAG
: /* Union tag. */
4796 dst
->symbol
.flags
= BSF_DEBUGGING
;
4797 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4800 case C_FILE
: /* File name. */
4801 case C_STRTAG
: /* Structure tag. */
4818 dst
->symbol
.flags
= BSF_DEBUGGING
;
4819 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4823 case C_BINCL
: /* Beginning of include file. */
4824 case C_EINCL
: /* Ending of include file. */
4825 /* The value is actually a pointer into the line numbers
4826 of the file. We locate the line number entry, and
4827 set the section to the section which contains it, and
4828 the value to the index in that section. */
4832 dst
->symbol
.flags
= BSF_DEBUGGING
;
4833 for (sec
= abfd
->sections
; sec
!= NULL
; sec
= sec
->next
)
4834 if (sec
->line_filepos
<= (file_ptr
) src
->u
.syment
.n_value
4835 && ((file_ptr
) (sec
->line_filepos
4836 + sec
->lineno_count
* bfd_coff_linesz (abfd
))
4837 > (file_ptr
) src
->u
.syment
.n_value
))
4840 dst
->symbol
.value
= 0;
4843 dst
->symbol
.section
= sec
;
4844 dst
->symbol
.value
= ((src
->u
.syment
.n_value
4845 - sec
->line_filepos
)
4846 / bfd_coff_linesz (abfd
));
4853 dst
->symbol
.flags
= BSF_DEBUGGING
;
4855 /* The value is actually a symbol index. Save a pointer
4856 to the symbol instead of the index. FIXME: This
4857 should use a union. */
4858 src
->u
.syment
.n_value
=
4859 (long) (intptr_t) (native_symbols
+ src
->u
.syment
.n_value
);
4860 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4865 case C_BLOCK
: /* ".bb" or ".eb". */
4866 case C_FCN
: /* ".bf" or ".ef" (or PE ".lf"). */
4867 case C_EFCN
: /* Physical end of function. */
4868 #if defined COFF_WITH_PE
4869 /* PE sets the symbol to a value relative to the start
4871 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4872 if (strcmp (dst
->symbol
.name
, ".bf") != 0)
4874 /* PE uses funny values for .ef and .lf; don't
4876 dst
->symbol
.flags
= BSF_DEBUGGING
;
4879 dst
->symbol
.flags
= BSF_DEBUGGING
| BSF_DEBUGGING_RELOC
;
4881 /* Base the value as an index from the base of the
4883 dst
->symbol
.flags
= BSF_LOCAL
;
4884 dst
->symbol
.value
= (src
->u
.syment
.n_value
4885 - dst
->symbol
.section
->vma
);
4889 case C_STATLAB
: /* Static load time label. */
4890 dst
->symbol
.value
= src
->u
.syment
.n_value
;
4891 dst
->symbol
.flags
= BSF_GLOBAL
;
4895 /* PE DLLs sometimes have zeroed out symbols for some
4896 reason. Just ignore them without a warning. */
4897 if (src
->u
.syment
.n_type
== 0
4898 && src
->u
.syment
.n_value
== 0
4899 && src
->u
.syment
.n_scnum
== 0)
4902 /* XCOFF specific: deleted entry. */
4903 if (src
->u
.syment
.n_value
== C_NULL_VALUE
)
4907 case C_EXTDEF
: /* External definition. */
4908 case C_ULABEL
: /* Undefined label. */
4909 case C_USTATIC
: /* Undefined static. */
4910 #ifndef COFF_WITH_PE
4911 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4912 class to represent a section symbol. */
4913 case C_LINE
: /* line # reformatted as symbol table entry. */
4914 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4915 case C_ALIAS
: /* Duplicate tag. */
4917 /* New storage classes for TI COFF. */
4918 #if defined(TIC80COFF) || defined(TICOFF)
4919 case C_UEXT
: /* Tentative external definition. */
4921 case C_EXTLAB
: /* External load time label. */
4922 case C_HIDDEN
: /* Ext symbol in dmert public lib. */
4924 (*_bfd_error_handler
)
4925 (_("%B: Unrecognized storage class %d for %s symbol `%s'"),
4926 abfd
, src
->u
.syment
.n_sclass
,
4927 dst
->symbol
.section
->name
, dst
->symbol
.name
);
4928 dst
->symbol
.flags
= BSF_DEBUGGING
;
4929 dst
->symbol
.value
= (src
->u
.syment
.n_value
);
4935 dst
->symbol
.udata
.i
= 0;
4937 this_index
+= (src
->u
.syment
.n_numaux
) + 1;
4939 number_of_symbols
++;
4943 obj_symbols (abfd
) = cached_area
;
4944 obj_raw_syments (abfd
) = native_symbols
;
4946 bfd_get_symcount (abfd
) = number_of_symbols
;
4947 obj_convert (abfd
) = table_ptr
;
4948 /* Slurp the line tables for each section too. */
4955 coff_slurp_line_table (abfd
, p
);
4963 /* Classify a COFF symbol. A couple of targets have globally visible
4964 symbols which are not class C_EXT, and this handles those. It also
4965 recognizes some special PE cases. */
4967 static enum coff_symbol_classification
4968 coff_classify_symbol (bfd
*abfd
,
4969 struct internal_syment
*syment
)
4971 /* FIXME: This partially duplicates the switch in
4972 coff_slurp_symbol_table. */
4973 switch (syment
->n_sclass
)
4982 case C_THUMBEXTFUNC
:
4990 if (syment
->n_scnum
== 0)
4992 if (syment
->n_value
== 0)
4993 return COFF_SYMBOL_UNDEFINED
;
4995 return COFF_SYMBOL_COMMON
;
4997 return COFF_SYMBOL_GLOBAL
;
5004 if (syment
->n_sclass
== C_STAT
)
5006 if (syment
->n_scnum
== 0)
5007 /* The Microsoft compiler sometimes generates these if a
5008 small static function is inlined every time it is used.
5009 The function is discarded, but the symbol table entry
5011 return COFF_SYMBOL_LOCAL
;
5013 #ifdef STRICT_PE_FORMAT
5014 /* This is correct for Microsoft generated objects, but it
5015 breaks gas generated objects. */
5016 if (syment
->n_value
== 0)
5019 char buf
[SYMNMLEN
+ 1];
5021 sec
= coff_section_from_bfd_index (abfd
, syment
->n_scnum
);
5023 && (strcmp (bfd_get_section_name (abfd
, sec
),
5024 _bfd_coff_internal_syment_name (abfd
, syment
, buf
))
5026 return COFF_SYMBOL_PE_SECTION
;
5030 return COFF_SYMBOL_LOCAL
;
5033 if (syment
->n_sclass
== C_SECTION
)
5035 /* In some cases in a DLL generated by the Microsoft linker, the
5036 n_value field will contain garbage. FIXME: This should
5037 probably be handled by the swapping function instead. */
5038 syment
->n_value
= 0;
5039 if (syment
->n_scnum
== 0)
5040 return COFF_SYMBOL_UNDEFINED
;
5041 return COFF_SYMBOL_PE_SECTION
;
5043 #endif /* COFF_WITH_PE */
5045 /* If it is not a global symbol, we presume it is a local symbol. */
5046 if (syment
->n_scnum
== 0)
5048 char buf
[SYMNMLEN
+ 1];
5050 (*_bfd_error_handler
)
5051 (_("warning: %B: local symbol `%s' has no section"),
5052 abfd
, _bfd_coff_internal_syment_name (abfd
, syment
, buf
));
5055 return COFF_SYMBOL_LOCAL
;
5062 Coff relocations are easily transformed into the internal BFD form
5065 Reading a coff relocation table is done in the following stages:
5067 o Read the entire coff relocation table into memory.
5069 o Process each relocation in turn; first swap it from the
5070 external to the internal form.
5072 o Turn the symbol referenced in the relocation's symbol index
5073 into a pointer into the canonical symbol table.
5074 This table is the same as the one returned by a call to
5075 @code{bfd_canonicalize_symtab}. The back end will call that
5076 routine and save the result if a canonicalization hasn't been done.
5078 o The reloc index is turned into a pointer to a howto
5079 structure, in a back end specific way. For instance, the 386
5080 and 960 use the @code{r_type} to directly produce an index
5081 into a howto table vector; the 88k subtracts a number from the
5082 @code{r_type} field and creates an addend field.
5086 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
5088 coff_symbol_type *coffsym = NULL; \
5090 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
5091 coffsym = (obj_symbols (abfd) \
5092 + (cache_ptr->sym_ptr_ptr - symbols)); \
5094 coffsym = coff_symbol_from (abfd, ptr); \
5095 if (coffsym != NULL \
5096 && coffsym->native->u.syment.n_scnum == 0) \
5097 cache_ptr->addend = 0; \
5098 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
5099 && ptr->section != NULL) \
5100 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
5102 cache_ptr->addend = 0; \
5107 coff_slurp_reloc_table (bfd
* abfd
, sec_ptr asect
, asymbol
** symbols
)
5109 RELOC
*native_relocs
;
5110 arelent
*reloc_cache
;
5115 if (asect
->relocation
)
5117 if (asect
->reloc_count
== 0)
5119 if (asect
->flags
& SEC_CONSTRUCTOR
)
5121 if (!coff_slurp_symbol_table (abfd
))
5124 amt
= (bfd_size_type
) bfd_coff_relsz (abfd
) * asect
->reloc_count
;
5125 native_relocs
= (RELOC
*) buy_and_read (abfd
, asect
->rel_filepos
, amt
);
5126 amt
= (bfd_size_type
) asect
->reloc_count
* sizeof (arelent
);
5127 reloc_cache
= (arelent
*) bfd_alloc (abfd
, amt
);
5129 if (reloc_cache
== NULL
|| native_relocs
== NULL
)
5132 for (idx
= 0; idx
< asect
->reloc_count
; idx
++)
5134 struct internal_reloc dst
;
5135 struct external_reloc
*src
;
5136 #ifndef RELOC_PROCESSING
5140 cache_ptr
= reloc_cache
+ idx
;
5141 src
= native_relocs
+ idx
;
5144 coff_swap_reloc_in (abfd
, src
, &dst
);
5146 #ifdef RELOC_PROCESSING
5147 RELOC_PROCESSING (cache_ptr
, &dst
, symbols
, abfd
, asect
);
5149 cache_ptr
->address
= dst
.r_vaddr
;
5151 if (dst
.r_symndx
!= -1)
5153 if (dst
.r_symndx
< 0 || dst
.r_symndx
>= obj_conv_table_size (abfd
))
5155 (*_bfd_error_handler
)
5156 (_("%B: warning: illegal symbol index %ld in relocs"),
5157 abfd
, (long) dst
.r_symndx
);
5158 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5163 cache_ptr
->sym_ptr_ptr
= (symbols
5164 + obj_convert (abfd
)[dst
.r_symndx
]);
5165 ptr
= *(cache_ptr
->sym_ptr_ptr
);
5170 cache_ptr
->sym_ptr_ptr
= bfd_abs_section_ptr
->symbol_ptr_ptr
;
5174 /* The symbols definitions that we have read in have been
5175 relocated as if their sections started at 0. But the offsets
5176 refering to the symbols in the raw data have not been
5177 modified, so we have to have a negative addend to compensate.
5179 Note that symbols which used to be common must be left alone. */
5181 /* Calculate any reloc addend by looking at the symbol. */
5182 CALC_ADDEND (abfd
, ptr
, dst
, cache_ptr
);
5185 cache_ptr
->address
-= asect
->vma
;
5186 /* !! cache_ptr->section = NULL;*/
5188 /* Fill in the cache_ptr->howto field from dst.r_type. */
5189 RTYPE2HOWTO (cache_ptr
, &dst
);
5190 #endif /* RELOC_PROCESSING */
5192 if (cache_ptr
->howto
== NULL
)
5194 (*_bfd_error_handler
)
5195 (_("%B: illegal relocation type %d at address 0x%lx"),
5196 abfd
, dst
.r_type
, (long) dst
.r_vaddr
);
5197 bfd_set_error (bfd_error_bad_value
);
5202 asect
->relocation
= reloc_cache
;
5206 #ifndef coff_rtype_to_howto
5209 /* Get the howto structure for a reloc. This is only used if the file
5210 including this one defines coff_relocate_section to be
5211 _bfd_coff_generic_relocate_section, so it is OK if it does not
5212 always work. It is the responsibility of the including file to
5213 make sure it is reasonable if it is needed. */
5215 static reloc_howto_type
*
5216 coff_rtype_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
5217 asection
*sec ATTRIBUTE_UNUSED
,
5218 struct internal_reloc
*rel
,
5219 struct coff_link_hash_entry
*h ATTRIBUTE_UNUSED
,
5220 struct internal_syment
*sym ATTRIBUTE_UNUSED
,
5221 bfd_vma
*addendp ATTRIBUTE_UNUSED
)
5225 genrel
.howto
= NULL
;
5226 RTYPE2HOWTO (&genrel
, rel
);
5227 return genrel
.howto
;
5230 #else /* ! defined (RTYPE2HOWTO) */
5232 #define coff_rtype_to_howto NULL
5234 #endif /* ! defined (RTYPE2HOWTO) */
5235 #endif /* ! defined (coff_rtype_to_howto) */
5237 /* This is stupid. This function should be a boolean predicate. */
5240 coff_canonicalize_reloc (bfd
* abfd
,
5245 arelent
*tblptr
= section
->relocation
;
5246 unsigned int count
= 0;
5248 if (section
->flags
& SEC_CONSTRUCTOR
)
5250 /* This section has relocs made up by us, they are not in the
5251 file, so take them out of their chain and place them into
5252 the data area provided. */
5253 arelent_chain
*chain
= section
->constructor_chain
;
5255 for (count
= 0; count
< section
->reloc_count
; count
++)
5257 *relptr
++ = &chain
->relent
;
5258 chain
= chain
->next
;
5263 if (! coff_slurp_reloc_table (abfd
, section
, symbols
))
5266 tblptr
= section
->relocation
;
5268 for (; count
++ < section
->reloc_count
;)
5269 *relptr
++ = tblptr
++;
5272 return section
->reloc_count
;
5275 #ifndef coff_reloc16_estimate
5276 #define coff_reloc16_estimate dummy_reloc16_estimate
5279 dummy_reloc16_estimate (bfd
*abfd ATTRIBUTE_UNUSED
,
5280 asection
*input_section ATTRIBUTE_UNUSED
,
5281 arelent
*reloc ATTRIBUTE_UNUSED
,
5282 unsigned int shrink ATTRIBUTE_UNUSED
,
5283 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
)
5291 #ifndef coff_reloc16_extra_cases
5293 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
5295 /* This works even if abort is not declared in any header file. */
5298 dummy_reloc16_extra_cases (bfd
*abfd ATTRIBUTE_UNUSED
,
5299 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
,
5300 struct bfd_link_order
*link_order ATTRIBUTE_UNUSED
,
5301 arelent
*reloc ATTRIBUTE_UNUSED
,
5302 bfd_byte
*data ATTRIBUTE_UNUSED
,
5303 unsigned int *src_ptr ATTRIBUTE_UNUSED
,
5304 unsigned int *dst_ptr ATTRIBUTE_UNUSED
)
5310 #ifndef coff_bfd_link_hash_table_free
5311 #define coff_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
5314 /* If coff_relocate_section is defined, we can use the optimized COFF
5315 backend linker. Otherwise we must continue to use the old linker. */
5317 #ifdef coff_relocate_section
5319 #ifndef coff_bfd_link_hash_table_create
5320 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5322 #ifndef coff_bfd_link_add_symbols
5323 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5325 #ifndef coff_bfd_final_link
5326 #define coff_bfd_final_link _bfd_coff_final_link
5329 #else /* ! defined (coff_relocate_section) */
5331 #define coff_relocate_section NULL
5332 #ifndef coff_bfd_link_hash_table_create
5333 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5335 #ifndef coff_bfd_link_add_symbols
5336 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5338 #define coff_bfd_final_link _bfd_generic_final_link
5340 #endif /* ! defined (coff_relocate_section) */
5342 #define coff_bfd_link_just_syms _bfd_generic_link_just_syms
5343 #define coff_bfd_copy_link_hash_symbol_type \
5344 _bfd_generic_copy_link_hash_symbol_type
5345 #define coff_bfd_link_split_section _bfd_generic_link_split_section
5347 #ifndef coff_start_final_link
5348 #define coff_start_final_link NULL
5351 #ifndef coff_adjust_symndx
5352 #define coff_adjust_symndx NULL
5355 #ifndef coff_link_add_one_symbol
5356 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5359 #ifndef coff_link_output_has_begun
5362 coff_link_output_has_begun (bfd
* abfd
,
5363 struct coff_final_link_info
* info ATTRIBUTE_UNUSED
)
5365 return abfd
->output_has_begun
;
5369 #ifndef coff_final_link_postscript
5372 coff_final_link_postscript (bfd
* abfd ATTRIBUTE_UNUSED
,
5373 struct coff_final_link_info
* pfinfo ATTRIBUTE_UNUSED
)
5379 #ifndef coff_SWAP_aux_in
5380 #define coff_SWAP_aux_in coff_swap_aux_in
5382 #ifndef coff_SWAP_sym_in
5383 #define coff_SWAP_sym_in coff_swap_sym_in
5385 #ifndef coff_SWAP_lineno_in
5386 #define coff_SWAP_lineno_in coff_swap_lineno_in
5388 #ifndef coff_SWAP_aux_out
5389 #define coff_SWAP_aux_out coff_swap_aux_out
5391 #ifndef coff_SWAP_sym_out
5392 #define coff_SWAP_sym_out coff_swap_sym_out
5394 #ifndef coff_SWAP_lineno_out
5395 #define coff_SWAP_lineno_out coff_swap_lineno_out
5397 #ifndef coff_SWAP_reloc_out
5398 #define coff_SWAP_reloc_out coff_swap_reloc_out
5400 #ifndef coff_SWAP_filehdr_out
5401 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5403 #ifndef coff_SWAP_aouthdr_out
5404 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5406 #ifndef coff_SWAP_scnhdr_out
5407 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5409 #ifndef coff_SWAP_reloc_in
5410 #define coff_SWAP_reloc_in coff_swap_reloc_in
5412 #ifndef coff_SWAP_filehdr_in
5413 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5415 #ifndef coff_SWAP_aouthdr_in
5416 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5418 #ifndef coff_SWAP_scnhdr_in
5419 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5422 static bfd_coff_backend_data bfd_coff_std_swap_table ATTRIBUTE_UNUSED
=
5424 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5425 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5426 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5427 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5428 coff_SWAP_scnhdr_out
,
5429 FILHSZ
, AOUTSZ
, SCNHSZ
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5430 #ifdef COFF_LONG_FILENAMES
5435 COFF_DEFAULT_LONG_SECTION_NAMES
,
5436 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5437 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5442 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5447 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5448 coff_SWAP_reloc_in
, coff_bad_format_hook
, coff_set_arch_mach_hook
,
5449 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5450 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5451 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5452 coff_classify_symbol
, coff_compute_section_file_positions
,
5453 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5454 coff_adjust_symndx
, coff_link_add_one_symbol
,
5455 coff_link_output_has_begun
, coff_final_link_postscript
,
5460 /* COFF0 differs in file/section header size and relocation entry size. */
5462 static bfd_coff_backend_data ticoff0_swap_table
=
5464 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5465 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5466 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5467 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5468 coff_SWAP_scnhdr_out
,
5469 FILHSZ_V0
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ_V0
, LINESZ
, FILNMLEN
,
5470 #ifdef COFF_LONG_FILENAMES
5475 COFF_DEFAULT_LONG_SECTION_NAMES
,
5476 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5477 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5482 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5487 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5488 coff_SWAP_reloc_in
, ticoff0_bad_format_hook
, coff_set_arch_mach_hook
,
5489 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5490 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5491 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5492 coff_classify_symbol
, coff_compute_section_file_positions
,
5493 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5494 coff_adjust_symndx
, coff_link_add_one_symbol
,
5495 coff_link_output_has_begun
, coff_final_link_postscript
,
5501 /* COFF1 differs in section header size. */
5503 static bfd_coff_backend_data ticoff1_swap_table
=
5505 coff_SWAP_aux_in
, coff_SWAP_sym_in
, coff_SWAP_lineno_in
,
5506 coff_SWAP_aux_out
, coff_SWAP_sym_out
,
5507 coff_SWAP_lineno_out
, coff_SWAP_reloc_out
,
5508 coff_SWAP_filehdr_out
, coff_SWAP_aouthdr_out
,
5509 coff_SWAP_scnhdr_out
,
5510 FILHSZ
, AOUTSZ
, SCNHSZ_V01
, SYMESZ
, AUXESZ
, RELSZ
, LINESZ
, FILNMLEN
,
5511 #ifdef COFF_LONG_FILENAMES
5516 COFF_DEFAULT_LONG_SECTION_NAMES
,
5517 COFF_DEFAULT_SECTION_ALIGNMENT_POWER
,
5518 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5523 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5528 coff_SWAP_filehdr_in
, coff_SWAP_aouthdr_in
, coff_SWAP_scnhdr_in
,
5529 coff_SWAP_reloc_in
, ticoff1_bad_format_hook
, coff_set_arch_mach_hook
,
5530 coff_mkobject_hook
, styp_to_sec_flags
, coff_set_alignment_hook
,
5531 coff_slurp_symbol_table
, symname_in_debug_hook
, coff_pointerize_aux_hook
,
5532 coff_print_aux
, coff_reloc16_extra_cases
, coff_reloc16_estimate
,
5533 coff_classify_symbol
, coff_compute_section_file_positions
,
5534 coff_start_final_link
, coff_relocate_section
, coff_rtype_to_howto
,
5535 coff_adjust_symndx
, coff_link_add_one_symbol
,
5536 coff_link_output_has_begun
, coff_final_link_postscript
,
5537 bfd_pe_print_pdata
/* huh */
5541 #ifndef coff_close_and_cleanup
5542 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
5545 #ifndef coff_bfd_free_cached_info
5546 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
5549 #ifndef coff_get_section_contents
5550 #define coff_get_section_contents _bfd_generic_get_section_contents
5553 #ifndef coff_bfd_copy_private_symbol_data
5554 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5557 #ifndef coff_bfd_copy_private_header_data
5558 #define coff_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data
5561 #ifndef coff_bfd_copy_private_section_data
5562 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5565 #ifndef coff_bfd_copy_private_bfd_data
5566 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5569 #ifndef coff_bfd_merge_private_bfd_data
5570 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5573 #ifndef coff_bfd_set_private_flags
5574 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5577 #ifndef coff_bfd_print_private_bfd_data
5578 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5581 #ifndef coff_bfd_is_local_label_name
5582 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5585 #ifndef coff_bfd_is_target_special_symbol
5586 #define coff_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
5589 #ifndef coff_read_minisymbols
5590 #define coff_read_minisymbols _bfd_generic_read_minisymbols
5593 #ifndef coff_minisymbol_to_symbol
5594 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5597 /* The reloc lookup routine must be supplied by each individual COFF
5599 #ifndef coff_bfd_reloc_type_lookup
5600 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5602 #ifndef coff_bfd_reloc_name_lookup
5603 #define coff_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
5606 #ifndef coff_bfd_get_relocated_section_contents
5607 #define coff_bfd_get_relocated_section_contents \
5608 bfd_generic_get_relocated_section_contents
5611 #ifndef coff_bfd_relax_section
5612 #define coff_bfd_relax_section bfd_generic_relax_section
5615 #ifndef coff_bfd_gc_sections
5616 #define coff_bfd_gc_sections bfd_generic_gc_sections
5619 #ifndef coff_bfd_merge_sections
5620 #define coff_bfd_merge_sections bfd_generic_merge_sections
5623 #ifndef coff_bfd_is_group_section
5624 #define coff_bfd_is_group_section bfd_generic_is_group_section
5627 #ifndef coff_bfd_discard_group
5628 #define coff_bfd_discard_group bfd_generic_discard_group
5631 #ifndef coff_section_already_linked
5632 #define coff_section_already_linked \
5633 _bfd_generic_section_already_linked
5636 #ifndef coff_bfd_define_common_symbol
5637 #define coff_bfd_define_common_symbol bfd_generic_define_common_symbol
5640 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5641 const bfd_target VAR = \
5644 bfd_target_coff_flavour, \
5645 BFD_ENDIAN_BIG, /* Data byte order is big. */ \
5646 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
5647 /* object flags */ \
5648 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5649 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5650 /* section flags */ \
5651 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5652 UNDER, /* Leading symbol underscore. */ \
5653 '/', /* AR_pad_char. */ \
5654 15, /* AR_max_namelen. */ \
5656 /* Data conversion functions. */ \
5657 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5658 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5659 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5661 /* Header conversion functions. */ \
5662 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5663 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5664 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5666 /* bfd_check_format. */ \
5667 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5668 _bfd_dummy_target }, \
5669 /* bfd_set_format. */ \
5670 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5671 /* bfd_write_contents. */ \
5672 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5675 BFD_JUMP_TABLE_GENERIC (coff), \
5676 BFD_JUMP_TABLE_COPY (coff), \
5677 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5678 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5679 BFD_JUMP_TABLE_SYMBOLS (coff), \
5680 BFD_JUMP_TABLE_RELOCS (coff), \
5681 BFD_JUMP_TABLE_WRITE (coff), \
5682 BFD_JUMP_TABLE_LINK (coff), \
5683 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5690 #define CREATE_BIGHDR_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5691 const bfd_target VAR = \
5694 bfd_target_coff_flavour, \
5695 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
5696 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
5697 /* object flags */ \
5698 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5699 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5700 /* section flags */ \
5701 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5702 UNDER, /* Leading symbol underscore. */ \
5703 '/', /* AR_pad_char. */ \
5704 15, /* AR_max_namelen. */ \
5706 /* Data conversion functions. */ \
5707 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5708 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5709 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5711 /* Header conversion functions. */ \
5712 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5713 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5714 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5716 /* bfd_check_format. */ \
5717 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5718 _bfd_dummy_target }, \
5719 /* bfd_set_format. */ \
5720 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5721 /* bfd_write_contents. */ \
5722 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5725 BFD_JUMP_TABLE_GENERIC (coff), \
5726 BFD_JUMP_TABLE_COPY (coff), \
5727 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5728 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5729 BFD_JUMP_TABLE_SYMBOLS (coff), \
5730 BFD_JUMP_TABLE_RELOCS (coff), \
5731 BFD_JUMP_TABLE_WRITE (coff), \
5732 BFD_JUMP_TABLE_LINK (coff), \
5733 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5740 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5741 const bfd_target VAR = \
5744 bfd_target_coff_flavour, \
5745 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
5746 BFD_ENDIAN_LITTLE, /* Header byte order is little. */ \
5747 /* object flags */ \
5748 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5749 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5750 /* section flags */ \
5751 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5752 UNDER, /* Leading symbol underscore. */ \
5753 '/', /* AR_pad_char. */ \
5754 15, /* AR_max_namelen. */ \
5756 /* Data conversion functions. */ \
5757 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5758 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5759 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5760 /* Header conversion functions. */ \
5761 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5762 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5763 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5764 /* bfd_check_format. */ \
5765 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5766 _bfd_dummy_target }, \
5767 /* bfd_set_format. */ \
5768 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5769 /* bfd_write_contents. */ \
5770 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5773 BFD_JUMP_TABLE_GENERIC (coff), \
5774 BFD_JUMP_TABLE_COPY (coff), \
5775 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5776 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5777 BFD_JUMP_TABLE_SYMBOLS (coff), \
5778 BFD_JUMP_TABLE_RELOCS (coff), \
5779 BFD_JUMP_TABLE_WRITE (coff), \
5780 BFD_JUMP_TABLE_LINK (coff), \
5781 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \