* bfd.c (struct bfd_preserve): New.
[binutils.git] / bfd / coffcode.h
blob694fb12f4d869f2546bfbcb0ffdee74116c3b9b7
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
4 Free Software Foundation, Inc.
5 Written by Cygnus Support.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
24 Most of this hacked by Steve Chamberlain,
25 sac@cygnus.com
29 SECTION
30 coff backends
32 BFD supports a number of different flavours of coff format.
33 The major differences between formats are the sizes and
34 alignments of fields in structures on disk, and the occasional
35 extra field.
37 Coff in all its varieties is implemented with a few common
38 files and a number of implementation specific files. For
39 example, The 88k bcs coff format is implemented in the file
40 @file{coff-m88k.c}. This file @code{#include}s
41 @file{coff/m88k.h} which defines the external structure of the
42 coff format for the 88k, and @file{coff/internal.h} which
43 defines the internal structure. @file{coff-m88k.c} also
44 defines the relocations used by the 88k format
45 @xref{Relocations}.
47 The Intel i960 processor version of coff is implemented in
48 @file{coff-i960.c}. This file has the same structure as
49 @file{coff-m88k.c}, except that it includes @file{coff/i960.h}
50 rather than @file{coff-m88k.h}.
52 SUBSECTION
53 Porting to a new version of coff
55 The recommended method is to select from the existing
56 implementations the version of coff which is most like the one
57 you want to use. For example, we'll say that i386 coff is
58 the one you select, and that your coff flavour is called foo.
59 Copy @file{i386coff.c} to @file{foocoff.c}, copy
60 @file{../include/coff/i386.h} to @file{../include/coff/foo.h},
61 and add the lines to @file{targets.c} and @file{Makefile.in}
62 so that your new back end is used. Alter the shapes of the
63 structures in @file{../include/coff/foo.h} so that they match
64 what you need. You will probably also have to add
65 @code{#ifdef}s to the code in @file{coff/internal.h} and
66 @file{coffcode.h} if your version of coff is too wild.
68 You can verify that your new BFD backend works quite simply by
69 building @file{objdump} from the @file{binutils} directory,
70 and making sure that its version of what's going on and your
71 host system's idea (assuming it has the pretty standard coff
72 dump utility, usually called @code{att-dump} or just
73 @code{dump}) are the same. Then clean up your code, and send
74 what you've done to Cygnus. Then your stuff will be in the
75 next release, and you won't have to keep integrating it.
77 SUBSECTION
78 How the coff backend works
80 SUBSUBSECTION
81 File layout
83 The Coff backend is split into generic routines that are
84 applicable to any Coff target and routines that are specific
85 to a particular target. The target-specific routines are
86 further split into ones which are basically the same for all
87 Coff targets except that they use the external symbol format
88 or use different values for certain constants.
90 The generic routines are in @file{coffgen.c}. These routines
91 work for any Coff target. They use some hooks into the target
92 specific code; the hooks are in a @code{bfd_coff_backend_data}
93 structure, one of which exists for each target.
95 The essentially similar target-specific routines are in
96 @file{coffcode.h}. This header file includes executable C code.
97 The various Coff targets first include the appropriate Coff
98 header file, make any special defines that are needed, and
99 then include @file{coffcode.h}.
101 Some of the Coff targets then also have additional routines in
102 the target source file itself.
104 For example, @file{coff-i960.c} includes
105 @file{coff/internal.h} and @file{coff/i960.h}. It then
106 defines a few constants, such as @code{I960}, and includes
107 @file{coffcode.h}. Since the i960 has complex relocation
108 types, @file{coff-i960.c} also includes some code to
109 manipulate the i960 relocs. This code is not in
110 @file{coffcode.h} because it would not be used by any other
111 target.
113 SUBSUBSECTION
114 Bit twiddling
116 Each flavour of coff supported in BFD has its own header file
117 describing the external layout of the structures. There is also
118 an internal description of the coff layout, in
119 @file{coff/internal.h}. A major function of the
120 coff backend is swapping the bytes and twiddling the bits to
121 translate the external form of the structures into the normal
122 internal form. This is all performed in the
123 @code{bfd_swap}_@i{thing}_@i{direction} routines. Some
124 elements are different sizes between different versions of
125 coff; it is the duty of the coff version specific include file
126 to override the definitions of various packing routines in
127 @file{coffcode.h}. E.g., the size of line number entry in coff is
128 sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
129 @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
130 correct one. No doubt, some day someone will find a version of
131 coff which has a varying field size not catered to at the
132 moment. To port BFD, that person will have to add more @code{#defines}.
133 Three of the bit twiddling routines are exported to
134 @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
135 and @code{coff_swap_lineno_in}. @code{GDB} reads the symbol
136 table on its own, but uses BFD to fix things up. More of the
137 bit twiddlers are exported for @code{gas};
138 @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
139 @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
140 @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
141 @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
142 of all the symbol table and reloc drudgery itself, thereby
143 saving the internal BFD overhead, but uses BFD to swap things
144 on the way out, making cross ports much safer. Doing so also
145 allows BFD (and thus the linker) to use the same header files
146 as @code{gas}, which makes one avenue to disaster disappear.
148 SUBSUBSECTION
149 Symbol reading
151 The simple canonical form for symbols used by BFD is not rich
152 enough to keep all the information available in a coff symbol
153 table. The back end gets around this problem by keeping the original
154 symbol table around, "behind the scenes".
156 When a symbol table is requested (through a call to
157 @code{bfd_canonicalize_symtab}), a request gets through to
158 @code{coff_get_normalized_symtab}. This reads the symbol table from
159 the coff file and swaps all the structures inside into the
160 internal form. It also fixes up all the pointers in the table
161 (represented in the file by offsets from the first symbol in
162 the table) into physical pointers to elements in the new
163 internal table. This involves some work since the meanings of
164 fields change depending upon context: a field that is a
165 pointer to another structure in the symbol table at one moment
166 may be the size in bytes of a structure at the next. Another
167 pass is made over the table. All symbols which mark file names
168 (<<C_FILE>> symbols) are modified so that the internal
169 string points to the value in the auxent (the real filename)
170 rather than the normal text associated with the symbol
171 (@code{".file"}).
173 At this time the symbol names are moved around. Coff stores
174 all symbols less than nine characters long physically
175 within the symbol table; longer strings are kept at the end of
176 the file in the string table. This pass moves all strings
177 into memory and replaces them with pointers to the strings.
179 The symbol table is massaged once again, this time to create
180 the canonical table used by the BFD application. Each symbol
181 is inspected in turn, and a decision made (using the
182 @code{sclass} field) about the various flags to set in the
183 @code{asymbol}. @xref{Symbols}. The generated canonical table
184 shares strings with the hidden internal symbol table.
186 Any linenumbers are read from the coff file too, and attached
187 to the symbols which own the functions the linenumbers belong to.
189 SUBSUBSECTION
190 Symbol writing
192 Writing a symbol to a coff file which didn't come from a coff
193 file will lose any debugging information. The @code{asymbol}
194 structure remembers the BFD from which the symbol was taken, and on
195 output the back end makes sure that the same destination target as
196 source target is present.
198 When the symbols have come from a coff file then all the
199 debugging information is preserved.
201 Symbol tables are provided for writing to the back end in a
202 vector of pointers to pointers. This allows applications like
203 the linker to accumulate and output large symbol tables
204 without having to do too much byte copying.
206 This function runs through the provided symbol table and
207 patches each symbol marked as a file place holder
208 (@code{C_FILE}) to point to the next file place holder in the
209 list. It also marks each @code{offset} field in the list with
210 the offset from the first symbol of the current symbol.
212 Another function of this procedure is to turn the canonical
213 value form of BFD into the form used by coff. Internally, BFD
214 expects symbol values to be offsets from a section base; so a
215 symbol physically at 0x120, but in a section starting at
216 0x100, would have the value 0x20. Coff expects symbols to
217 contain their final value, so symbols have their values
218 changed at this point to reflect their sum with their owning
219 section. This transformation uses the
220 <<output_section>> field of the @code{asymbol}'s
221 @code{asection} @xref{Sections}.
223 o <<coff_mangle_symbols>>
225 This routine runs though the provided symbol table and uses
226 the offsets generated by the previous pass and the pointers
227 generated when the symbol table was read in to create the
228 structured hierachy required by coff. It changes each pointer
229 to a symbol into the index into the symbol table of the asymbol.
231 o <<coff_write_symbols>>
233 This routine runs through the symbol table and patches up the
234 symbols from their internal form into the coff way, calls the
235 bit twiddlers, and writes out the table to the file.
240 INTERNAL_DEFINITION
241 coff_symbol_type
243 DESCRIPTION
244 The hidden information for an <<asymbol>> is described in a
245 <<combined_entry_type>>:
247 CODE_FRAGMENT
249 .typedef struct coff_ptr_struct
251 . {* Remembers the offset from the first symbol in the file for
252 . this symbol. Generated by coff_renumber_symbols. *}
253 . unsigned int offset;
255 . {* Should the value of this symbol be renumbered. Used for
256 . XCOFF C_BSTAT symbols. Set by coff_slurp_symbol_table. *}
257 . unsigned int fix_value : 1;
259 . {* Should the tag field of this symbol be renumbered.
260 . Created by coff_pointerize_aux. *}
261 . unsigned int fix_tag : 1;
263 . {* Should the endidx field of this symbol be renumbered.
264 . Created by coff_pointerize_aux. *}
265 . unsigned int fix_end : 1;
267 . {* Should the x_csect.x_scnlen field be renumbered.
268 . Created by coff_pointerize_aux. *}
269 . unsigned int fix_scnlen : 1;
271 . {* Fix up an XCOFF C_BINCL/C_EINCL symbol. The value is the
272 . index into the line number entries. Set by coff_slurp_symbol_table. *}
273 . unsigned int fix_line : 1;
275 . {* The container for the symbol structure as read and translated
276 . from the file. *}
277 . union
279 . union internal_auxent auxent;
280 . struct internal_syment syment;
281 . } u;
282 .} combined_entry_type;
285 .{* Each canonical asymbol really looks like this: *}
287 .typedef struct coff_symbol_struct
289 . {* The actual symbol which the rest of BFD works with *}
290 . asymbol symbol;
292 . {* A pointer to the hidden information for this symbol *}
293 . combined_entry_type *native;
295 . {* A pointer to the linenumber information for this symbol *}
296 . struct lineno_cache_entry *lineno;
298 . {* Have the line numbers been relocated yet ? *}
299 . boolean done_lineno;
300 .} coff_symbol_type;
304 #ifdef COFF_WITH_PE
305 #include "peicode.h"
306 #else
307 #include "coffswap.h"
308 #endif
310 #define STRING_SIZE_SIZE (4)
312 static long sec_to_styp_flags PARAMS ((const char *, flagword));
313 static boolean styp_to_sec_flags
314 PARAMS ((bfd *, PTR, const char *, asection *, flagword *));
315 static boolean coff_bad_format_hook PARAMS ((bfd *, PTR));
316 static void coff_set_custom_section_alignment
317 PARAMS ((bfd *, asection *, const struct coff_section_alignment_entry *,
318 const unsigned int));
319 static boolean coff_new_section_hook PARAMS ((bfd *, asection *));
320 static boolean coff_set_arch_mach_hook PARAMS ((bfd *, PTR));
321 static boolean coff_write_relocs PARAMS ((bfd *, int));
322 static boolean coff_set_flags
323 PARAMS ((bfd *, unsigned int *, unsigned short *));
324 static boolean coff_set_arch_mach
325 PARAMS ((bfd *, enum bfd_architecture, unsigned long)) ATTRIBUTE_UNUSED;
326 static boolean coff_compute_section_file_positions PARAMS ((bfd *));
327 static boolean coff_write_object_contents PARAMS ((bfd *)) ATTRIBUTE_UNUSED;
328 static boolean coff_set_section_contents
329 PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type));
330 static PTR buy_and_read PARAMS ((bfd *, file_ptr, bfd_size_type));
331 static boolean coff_slurp_line_table PARAMS ((bfd *, asection *));
332 static boolean coff_slurp_symbol_table PARAMS ((bfd *));
333 static enum coff_symbol_classification coff_classify_symbol
334 PARAMS ((bfd *, struct internal_syment *));
335 static boolean coff_slurp_reloc_table PARAMS ((bfd *, asection *, asymbol **));
336 static long coff_canonicalize_reloc
337 PARAMS ((bfd *, asection *, arelent **, asymbol **));
338 #ifndef coff_mkobject_hook
339 static PTR coff_mkobject_hook PARAMS ((bfd *, PTR, PTR));
340 #endif
341 #ifdef COFF_WITH_PE
342 static flagword handle_COMDAT PARAMS ((bfd *, flagword, PTR, const char *, asection *));
343 #endif
344 #ifdef COFF_IMAGE_WITH_PE
345 static boolean coff_read_word PARAMS ((bfd *, unsigned int *));
346 static unsigned int coff_compute_checksum PARAMS ((bfd *));
347 static boolean coff_apply_checksum PARAMS ((bfd *));
348 #endif
350 /* void warning(); */
352 /* Return a word with STYP_* (scnhdr.s_flags) flags set to represent
353 the incoming SEC_* flags. The inverse of this function is
354 styp_to_sec_flags(). NOTE: If you add to/change this routine, you
355 should probably mirror the changes in styp_to_sec_flags(). */
357 #ifndef COFF_WITH_PE
359 /* Macros for setting debugging flags. */
360 #ifdef STYP_DEBUG
361 #define STYP_XCOFF_DEBUG STYP_DEBUG
362 #else
363 #define STYP_XCOFF_DEBUG STYP_INFO
364 #endif
366 #ifdef COFF_ALIGN_IN_S_FLAGS
367 #define STYP_DEBUG_INFO STYP_DSECT
368 #else
369 #define STYP_DEBUG_INFO STYP_INFO
370 #endif
372 static long
373 sec_to_styp_flags (sec_name, sec_flags)
374 const char *sec_name;
375 flagword sec_flags;
377 long styp_flags = 0;
379 if (!strcmp (sec_name, _TEXT))
381 styp_flags = STYP_TEXT;
383 else if (!strcmp (sec_name, _DATA))
385 styp_flags = STYP_DATA;
387 else if (!strcmp (sec_name, _BSS))
389 styp_flags = STYP_BSS;
390 #ifdef _COMMENT
392 else if (!strcmp (sec_name, _COMMENT))
394 styp_flags = STYP_INFO;
395 #endif /* _COMMENT */
396 #ifdef _LIB
398 else if (!strcmp (sec_name, _LIB))
400 styp_flags = STYP_LIB;
401 #endif /* _LIB */
402 #ifdef _LIT
404 else if (!strcmp (sec_name, _LIT))
406 styp_flags = STYP_LIT;
407 #endif /* _LIT */
409 else if (!strncmp (sec_name, ".debug", 6))
411 /* Handle the XCOFF debug section and DWARF2 debug sections. */
412 if (!sec_name[6])
413 styp_flags = STYP_XCOFF_DEBUG;
414 else
415 styp_flags = STYP_DEBUG_INFO;
417 else if (!strncmp (sec_name, ".stab", 5))
419 styp_flags = STYP_DEBUG_INFO;
421 #ifdef COFF_LONG_SECTION_NAMES
422 else if (!strncmp (sec_name, ".gnu.linkonce.wi.", 17))
424 styp_flags = STYP_DEBUG_INFO;
426 #endif
427 #ifdef RS6000COFF_C
428 else if (!strcmp (sec_name, _PAD))
430 styp_flags = STYP_PAD;
432 else if (!strcmp (sec_name, _LOADER))
434 styp_flags = STYP_LOADER;
436 else if (!strcmp (sec_name, _EXCEPT))
438 styp_flags = STYP_EXCEPT;
440 else if (!strcmp (sec_name, _TYPCHK))
442 styp_flags = STYP_TYPCHK;
444 #endif
445 /* Try and figure out what it should be */
446 else if (sec_flags & SEC_CODE)
448 styp_flags = STYP_TEXT;
450 else if (sec_flags & SEC_DATA)
452 styp_flags = STYP_DATA;
454 else if (sec_flags & SEC_READONLY)
456 #ifdef STYP_LIT /* 29k readonly text/data section */
457 styp_flags = STYP_LIT;
458 #else
459 styp_flags = STYP_TEXT;
460 #endif /* STYP_LIT */
462 else if (sec_flags & SEC_LOAD)
464 styp_flags = STYP_TEXT;
466 else if (sec_flags & SEC_ALLOC)
468 styp_flags = STYP_BSS;
471 #ifdef STYP_CLINK
472 if (sec_flags & SEC_CLINK)
473 styp_flags |= STYP_CLINK;
474 #endif
476 #ifdef STYP_BLOCK
477 if (sec_flags & SEC_BLOCK)
478 styp_flags |= STYP_BLOCK;
479 #endif
481 #ifdef STYP_NOLOAD
482 if ((sec_flags & (SEC_NEVER_LOAD | SEC_COFF_SHARED_LIBRARY)) != 0)
483 styp_flags |= STYP_NOLOAD;
484 #endif
486 return styp_flags;
489 #else /* COFF_WITH_PE */
491 /* The PE version; see above for the general comments. The non-PE
492 case seems to be more guessing, and breaks PE format; specifically,
493 .rdata is readonly, but it sure ain't text. Really, all this
494 should be set up properly in gas (or whatever assembler is in use),
495 and honor whatever objcopy/strip, etc. sent us as input. */
497 static long
498 sec_to_styp_flags (sec_name, sec_flags)
499 const char *sec_name ATTRIBUTE_UNUSED;
500 flagword sec_flags;
502 long styp_flags = 0;
504 /* caution: there are at least three groups of symbols that have
505 very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
506 SEC_* are the BFD internal flags, used for generic BFD
507 information. STYP_* are the COFF section flags which appear in
508 COFF files. IMAGE_SCN_* are the PE section flags which appear in
509 PE files. The STYP_* flags and the IMAGE_SCN_* flags overlap,
510 but there are more IMAGE_SCN_* flags. */
512 /* skip LOAD */
513 /* READONLY later */
514 /* skip RELOC */
515 if ((sec_flags & SEC_CODE) != 0)
516 styp_flags |= IMAGE_SCN_CNT_CODE;
517 if ((sec_flags & SEC_DATA) != 0)
518 styp_flags |= IMAGE_SCN_CNT_INITIALIZED_DATA;
519 if ((sec_flags & SEC_ALLOC) != 0 && (sec_flags & SEC_LOAD) == 0)
520 styp_flags |= IMAGE_SCN_CNT_UNINITIALIZED_DATA; /* ==STYP_BSS */
521 /* skip ROM */
522 /* skip constRUCTOR */
523 /* skip CONTENTS */
524 #ifdef STYP_NOLOAD
525 if ((sec_flags & (SEC_NEVER_LOAD | SEC_COFF_SHARED_LIBRARY)) != 0)
526 styp_flags |= STYP_NOLOAD;
527 #endif
528 if ((sec_flags & SEC_IS_COMMON) != 0)
529 styp_flags |= IMAGE_SCN_LNK_COMDAT;
530 if ((sec_flags & SEC_DEBUGGING) != 0)
531 styp_flags |= IMAGE_SCN_MEM_DISCARDABLE;
532 if ((sec_flags & SEC_EXCLUDE) != 0)
533 styp_flags |= IMAGE_SCN_LNK_REMOVE;
534 if ((sec_flags & SEC_NEVER_LOAD) != 0)
535 styp_flags |= IMAGE_SCN_LNK_REMOVE;
536 /* skip IN_MEMORY */
537 /* skip SORT */
538 if (sec_flags & SEC_LINK_ONCE)
539 styp_flags |= IMAGE_SCN_LNK_COMDAT;
540 /* skip LINK_DUPLICATES */
541 /* skip LINKER_CREATED */
543 /* For now, the read/write bits are mapped onto SEC_READONLY, even
544 though the semantics don't quite match. The bits from the input
545 are retained in pei_section_data(abfd, section)->pe_flags */
547 styp_flags |= IMAGE_SCN_MEM_READ; /* always readable. */
548 if ((sec_flags & SEC_READONLY) == 0)
549 styp_flags |= IMAGE_SCN_MEM_WRITE; /* Invert READONLY for write */
550 if (sec_flags & SEC_CODE)
551 styp_flags |= IMAGE_SCN_MEM_EXECUTE; /* CODE->EXECUTE */
552 if (sec_flags & SEC_SHARED)
553 styp_flags |= IMAGE_SCN_MEM_SHARED; /* Shared remains meaningful */
555 return styp_flags;
558 #endif /* COFF_WITH_PE */
560 /* Return a word with SEC_* flags set to represent the incoming STYP_*
561 flags (from scnhdr.s_flags). The inverse of this function is
562 sec_to_styp_flags(). NOTE: If you add to/change this routine, you
563 should probably mirror the changes in sec_to_styp_flags(). */
565 #ifndef COFF_WITH_PE
567 static boolean
568 styp_to_sec_flags (abfd, hdr, name, section, flags_ptr)
569 bfd *abfd ATTRIBUTE_UNUSED;
570 PTR hdr;
571 const char *name;
572 asection *section ATTRIBUTE_UNUSED;
573 flagword *flags_ptr;
575 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
576 long styp_flags = internal_s->s_flags;
577 flagword sec_flags = 0;
579 #ifdef STYP_BLOCK
580 if (styp_flags & STYP_BLOCK)
581 sec_flags |= SEC_BLOCK;
582 #endif
584 #ifdef STYP_CLINK
585 if (styp_flags & STYP_CLINK)
586 sec_flags |= SEC_CLINK;
587 #endif
589 #ifdef STYP_NOLOAD
590 if (styp_flags & STYP_NOLOAD)
591 sec_flags |= SEC_NEVER_LOAD;
592 #endif /* STYP_NOLOAD */
594 /* For 386 COFF, at least, an unloadable text or data section is
595 actually a shared library section. */
596 if (styp_flags & STYP_TEXT)
598 if (sec_flags & SEC_NEVER_LOAD)
599 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
600 else
601 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
603 else if (styp_flags & STYP_DATA)
605 if (sec_flags & SEC_NEVER_LOAD)
606 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
607 else
608 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
610 else if (styp_flags & STYP_BSS)
612 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
613 if (sec_flags & SEC_NEVER_LOAD)
614 sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
615 else
616 #endif
617 sec_flags |= SEC_ALLOC;
619 else if (styp_flags & STYP_INFO)
621 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
622 defined. coff_compute_section_file_positions uses
623 COFF_PAGE_SIZE to ensure that the low order bits of the
624 section VMA and the file offset match. If we don't know
625 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
626 and demand page loading of the file will fail. */
627 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
628 sec_flags |= SEC_DEBUGGING;
629 #endif
631 else if (styp_flags & STYP_PAD)
632 sec_flags = 0;
633 else if (strcmp (name, _TEXT) == 0)
635 if (sec_flags & SEC_NEVER_LOAD)
636 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
637 else
638 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
640 else if (strcmp (name, _DATA) == 0)
642 if (sec_flags & SEC_NEVER_LOAD)
643 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
644 else
645 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
647 else if (strcmp (name, _BSS) == 0)
649 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
650 if (sec_flags & SEC_NEVER_LOAD)
651 sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
652 else
653 #endif
654 sec_flags |= SEC_ALLOC;
656 else if (strncmp (name, ".debug", 6) == 0
657 #ifdef _COMMENT
658 || strcmp (name, _COMMENT) == 0
659 #endif
660 #ifdef COFF_LONG_SECTION_NAMES
661 || strncmp (name, ".gnu.linkonce.wi.", 17) == 0
662 #endif
663 || strncmp (name, ".stab", 5) == 0)
665 #ifdef COFF_PAGE_SIZE
666 sec_flags |= SEC_DEBUGGING;
667 #endif
669 #ifdef _LIB
670 else if (strcmp (name, _LIB) == 0)
672 #endif
673 #ifdef _LIT
674 else if (strcmp (name, _LIT) == 0)
675 sec_flags = SEC_LOAD | SEC_ALLOC | SEC_READONLY;
676 #endif
677 else
678 sec_flags |= SEC_ALLOC | SEC_LOAD;
680 #ifdef STYP_LIT /* A29k readonly text/data section type */
681 if ((styp_flags & STYP_LIT) == STYP_LIT)
682 sec_flags = (SEC_LOAD | SEC_ALLOC | SEC_READONLY);
683 #endif /* STYP_LIT */
685 #ifdef STYP_OTHER_LOAD /* Other loaded sections */
686 if (styp_flags & STYP_OTHER_LOAD)
687 sec_flags = (SEC_LOAD | SEC_ALLOC);
688 #endif /* STYP_SDATA */
690 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
691 /* As a GNU extension, if the name begins with .gnu.linkonce, we
692 only link a single copy of the section. This is used to support
693 g++. g++ will emit each template expansion in its own section.
694 The symbols will be defined as weak, so that multiple definitions
695 are permitted. The GNU linker extension is to actually discard
696 all but one of the sections. */
697 if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
698 sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
699 #endif
701 if (flags_ptr == NULL)
702 return false;
704 * flags_ptr = sec_flags;
705 return true;
708 #else /* COFF_WITH_PE */
710 static flagword
711 handle_COMDAT (abfd, sec_flags, hdr, name, section)
712 bfd * abfd;
713 flagword sec_flags;
714 PTR hdr;
715 const char *name;
716 asection *section;
718 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
719 bfd_byte *esymstart, *esym, *esymend;
720 int seen_state = 0;
721 char *target_name = NULL;
723 sec_flags |= SEC_LINK_ONCE;
725 /* Unfortunately, the PE format stores essential information in
726 the symbol table, of all places. We need to extract that
727 information now, so that objdump and the linker will know how
728 to handle the section without worrying about the symbols. We
729 can't call slurp_symtab, because the linker doesn't want the
730 swapped symbols. */
732 /* COMDAT sections are special. The first symbol is the section
733 symbol, which tells what kind of COMDAT section it is. The
734 second symbol is the "comdat symbol" - the one with the
735 unique name. GNU uses the section symbol for the unique
736 name; MS uses ".text" for every comdat section. Sigh. - DJ */
738 /* This is not mirrored in sec_to_styp_flags(), but there
739 doesn't seem to be a need to, either, and it would at best be
740 rather messy. */
742 if (! _bfd_coff_get_external_symbols (abfd))
743 return sec_flags;
745 esymstart = esym = (bfd_byte *) obj_coff_external_syms (abfd);
746 esymend = esym + obj_raw_syment_count (abfd) * bfd_coff_symesz (abfd);
748 while (esym < esymend)
750 struct internal_syment isym;
751 char buf[SYMNMLEN + 1];
752 const char *symname;
754 bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &isym);
756 if (sizeof (internal_s->s_name) > SYMNMLEN)
758 /* This case implies that the matching
759 symbol name will be in the string table. */
760 abort ();
763 if (isym.n_scnum == section->target_index)
765 /* According to the MSVC documentation, the first
766 TWO entries with the section # are both of
767 interest to us. The first one is the "section
768 symbol" (section name). The second is the comdat
769 symbol name. Here, we've found the first
770 qualifying entry; we distinguish it from the
771 second with a state flag.
773 In the case of gas-generated (at least until that
774 is fixed) .o files, it isn't necessarily the
775 second one. It may be some other later symbol.
777 Since gas also doesn't follow MS conventions and
778 emits the section similar to .text$<name>, where
779 <something> is the name we're looking for, we
780 distinguish the two as follows:
782 If the section name is simply a section name (no
783 $) we presume it's MS-generated, and look at
784 precisely the second symbol for the comdat name.
785 If the section name has a $, we assume it's
786 gas-generated, and look for <something> (whatever
787 follows the $) as the comdat symbol. */
789 /* All 3 branches use this */
790 symname = _bfd_coff_internal_syment_name (abfd, &isym, buf);
792 if (symname == NULL)
793 abort ();
795 switch (seen_state)
797 case 0:
799 /* The first time we've seen the symbol. */
800 union internal_auxent aux;
802 seen_state = 1;
804 /* If it isn't the stuff we're expecting, die;
805 The MS documentation is vague, but it
806 appears that the second entry serves BOTH
807 as the comdat symbol and the defining
808 symbol record (either C_STAT or C_EXT,
809 possibly with an aux entry with debug
810 information if it's a function.) It
811 appears the only way to find the second one
812 is to count. (On Intel, they appear to be
813 adjacent, but on Alpha, they have been
814 found separated.)
816 Here, we think we've found the first one,
817 but there's some checking we can do to be
818 sure. */
820 if (! (isym.n_sclass == C_STAT
821 && isym.n_type == T_NULL
822 && isym.n_value == 0))
823 abort ();
825 /* FIXME LATER: MSVC generates section names
826 like .text for comdats. Gas generates
827 names like .text$foo__Fv (in the case of a
828 function). See comment above for more. */
830 if (strcmp (name, symname) != 0)
831 abort ();
833 /* This is the section symbol. */
834 bfd_coff_swap_aux_in (abfd, (PTR) (esym + bfd_coff_symesz (abfd)),
835 isym.n_type, isym.n_sclass,
836 0, isym.n_numaux, (PTR) &aux);
838 target_name = strchr (name, '$');
839 if (target_name != NULL)
841 /* Gas mode. */
842 seen_state = 2;
843 /* Skip the `$'. */
844 target_name += 1;
847 /* FIXME: Microsoft uses NODUPLICATES and
848 ASSOCIATIVE, but gnu uses ANY and
849 SAME_SIZE. Unfortunately, gnu doesn't do
850 the comdat symbols right. So, until we can
851 fix it to do the right thing, we are
852 temporarily disabling comdats for the MS
853 types (they're used in DLLs and C++, but we
854 don't support *their* C++ libraries anyway
855 - DJ. */
857 /* Cygwin does not follow the MS style, and
858 uses ANY and SAME_SIZE where NODUPLICATES
859 and ASSOCIATIVE should be used. For
860 Interix, we just do the right thing up
861 front. */
863 switch (aux.x_scn.x_comdat)
865 case IMAGE_COMDAT_SELECT_NODUPLICATES:
866 #ifdef STRICT_PE_FORMAT
867 sec_flags |= SEC_LINK_DUPLICATES_ONE_ONLY;
868 #else
869 sec_flags &= ~SEC_LINK_ONCE;
870 #endif
871 break;
873 case IMAGE_COMDAT_SELECT_ANY:
874 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
875 break;
877 case IMAGE_COMDAT_SELECT_SAME_SIZE:
878 sec_flags |= SEC_LINK_DUPLICATES_SAME_SIZE;
879 break;
881 case IMAGE_COMDAT_SELECT_EXACT_MATCH:
882 /* Not yet fully implemented ??? */
883 sec_flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS;
884 break;
886 /* debug$S gets this case; other
887 implications ??? */
889 /* There may be no symbol... we'll search
890 the whole table... Is this the right
891 place to play this game? Or should we do
892 it when reading it in. */
893 case IMAGE_COMDAT_SELECT_ASSOCIATIVE:
894 #ifdef STRICT_PE_FORMAT
895 /* FIXME: This is not currently implemented. */
896 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
897 #else
898 sec_flags &= ~SEC_LINK_ONCE;
899 #endif
900 break;
902 default: /* 0 means "no symbol" */
903 /* debug$F gets this case; other
904 implications ??? */
905 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
906 break;
909 break;
911 case 2:
912 /* Gas mode: the first matching on partial name. */
914 #ifndef TARGET_UNDERSCORE
915 #define TARGET_UNDERSCORE 0
916 #endif
917 /* Is this the name we're looking for? */
918 if (strcmp (target_name,
919 symname + (TARGET_UNDERSCORE ? 1 : 0)) != 0)
921 /* Not the name we're looking for */
922 esym += (isym.n_numaux + 1) * bfd_coff_symesz (abfd);
923 continue;
925 /* Fall through. */
926 case 1:
927 /* MSVC mode: the lexically second symbol (or
928 drop through from the above). */
930 char *newname;
931 bfd_size_type amt;
933 /* This must the second symbol with the
934 section #. It is the actual symbol name.
935 Intel puts the two adjacent, but Alpha (at
936 least) spreads them out. */
938 amt = sizeof (struct bfd_comdat_info);
939 section->comdat = bfd_alloc (abfd, amt);
940 if (section->comdat == NULL)
941 abort ();
943 section->comdat->symbol =
944 (esym - esymstart) / bfd_coff_symesz (abfd);
946 amt = strlen (symname) + 1;
947 newname = bfd_alloc (abfd, amt);
948 if (newname == NULL)
949 abort ();
951 strcpy (newname, symname);
952 section->comdat->name = newname;
955 goto breakloop;
959 esym += (isym.n_numaux + 1) * bfd_coff_symesz (abfd);
962 breakloop:
963 return sec_flags;
967 /* The PE version; see above for the general comments.
969 Since to set the SEC_LINK_ONCE and associated flags, we have to
970 look at the symbol table anyway, we return the symbol table index
971 of the symbol being used as the COMDAT symbol. This is admittedly
972 ugly, but there's really nowhere else that we have access to the
973 required information. FIXME: Is the COMDAT symbol index used for
974 any purpose other than objdump? */
976 static boolean
977 styp_to_sec_flags (abfd, hdr, name, section, flags_ptr)
978 bfd *abfd;
979 PTR hdr;
980 const char *name;
981 asection *section;
982 flagword *flags_ptr;
984 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
985 long styp_flags = internal_s->s_flags;
986 flagword sec_flags;
987 boolean result = true;
989 /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
990 sec_flags = SEC_READONLY;
992 /* Process each flag bit in styp_flags in turn. */
993 while (styp_flags)
995 long flag = styp_flags & - styp_flags;
996 char * unhandled = NULL;
998 styp_flags &= ~ flag;
1000 /* We infer from the distinct read/write/execute bits the settings
1001 of some of the bfd flags; the actual values, should we need them,
1002 are also in pei_section_data (abfd, section)->pe_flags. */
1004 switch (flag)
1006 case STYP_DSECT:
1007 unhandled = "STYP_DSECT";
1008 break;
1009 case STYP_GROUP:
1010 unhandled = "STYP_GROUP";
1011 break;
1012 case STYP_COPY:
1013 unhandled = "STYP_COPY";
1014 break;
1015 case STYP_OVER:
1016 unhandled = "STYP_OVER";
1017 break;
1018 #ifdef SEC_NEVER_LOAD
1019 case STYP_NOLOAD:
1020 sec_flags |= SEC_NEVER_LOAD;
1021 break;
1022 #endif
1023 case IMAGE_SCN_MEM_READ:
1024 /* Ignored, assume it always to be true. */
1025 break;
1026 case IMAGE_SCN_TYPE_NO_PAD:
1027 /* Skip. */
1028 break;
1029 case IMAGE_SCN_LNK_OTHER:
1030 unhandled = "IMAGE_SCN_LNK_OTHER";
1031 break;
1032 case IMAGE_SCN_MEM_NOT_CACHED:
1033 unhandled = "IMAGE_SCN_MEM_NOT_CACHED";
1034 break;
1035 case IMAGE_SCN_MEM_NOT_PAGED:
1036 unhandled = "IMAGE_SCN_MEM_NOT_PAGED";
1037 break;
1038 case IMAGE_SCN_MEM_EXECUTE:
1039 sec_flags |= SEC_CODE;
1040 break;
1041 case IMAGE_SCN_MEM_WRITE:
1042 sec_flags &= ~ SEC_READONLY;
1043 break;
1044 case IMAGE_SCN_MEM_DISCARDABLE:
1045 sec_flags |= SEC_DEBUGGING;
1046 break;
1047 case IMAGE_SCN_MEM_SHARED:
1048 sec_flags |= SEC_SHARED;
1049 break;
1050 case IMAGE_SCN_LNK_REMOVE:
1051 sec_flags |= SEC_EXCLUDE;
1052 break;
1053 case IMAGE_SCN_CNT_CODE:
1054 sec_flags |= SEC_CODE | SEC_ALLOC | SEC_LOAD;
1055 break;
1056 case IMAGE_SCN_CNT_INITIALIZED_DATA:
1057 sec_flags |= SEC_DATA | SEC_ALLOC | SEC_LOAD;
1058 break;
1059 case IMAGE_SCN_CNT_UNINITIALIZED_DATA:
1060 sec_flags |= SEC_ALLOC;
1061 break;
1062 case IMAGE_SCN_LNK_INFO:
1063 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
1064 defined. coff_compute_section_file_positions uses
1065 COFF_PAGE_SIZE to ensure that the low order bits of the
1066 section VMA and the file offset match. If we don't know
1067 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
1068 and demand page loading of the file will fail. */
1069 #ifdef COFF_PAGE_SIZE
1070 sec_flags |= SEC_DEBUGGING;
1071 #endif
1072 break;
1073 case IMAGE_SCN_LNK_COMDAT:
1074 /* COMDAT gets very special treatment. */
1075 sec_flags = handle_COMDAT (abfd, sec_flags, hdr, name, section);
1076 break;
1077 default:
1078 /* Silently ignore for now. */
1079 break;
1082 /* If the section flag was not handled, report it here. */
1083 if (unhandled != NULL)
1085 (*_bfd_error_handler)
1086 (_("%s (%s): Section flag %s (0x%x) ignored"),
1087 bfd_archive_filename (abfd), name, unhandled, flag);
1088 result = false;
1092 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1093 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1094 only link a single copy of the section. This is used to support
1095 g++. g++ will emit each template expansion in its own section.
1096 The symbols will be defined as weak, so that multiple definitions
1097 are permitted. The GNU linker extension is to actually discard
1098 all but one of the sections. */
1099 if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
1100 sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
1101 #endif
1103 if (flags_ptr)
1104 * flags_ptr = sec_flags;
1106 return result;
1109 #endif /* COFF_WITH_PE */
1111 #define get_index(symbol) ((symbol)->udata.i)
1114 INTERNAL_DEFINITION
1115 bfd_coff_backend_data
1117 CODE_FRAGMENT
1119 .{* COFF symbol classifications. *}
1121 .enum coff_symbol_classification
1123 . {* Global symbol. *}
1124 . COFF_SYMBOL_GLOBAL,
1125 . {* Common symbol. *}
1126 . COFF_SYMBOL_COMMON,
1127 . {* Undefined symbol. *}
1128 . COFF_SYMBOL_UNDEFINED,
1129 . {* Local symbol. *}
1130 . COFF_SYMBOL_LOCAL,
1131 . {* PE section symbol. *}
1132 . COFF_SYMBOL_PE_SECTION
1135 Special entry points for gdb to swap in coff symbol table parts:
1136 .typedef struct
1138 . void (*_bfd_coff_swap_aux_in)
1139 . PARAMS ((bfd *, PTR, int, int, int, int, PTR));
1141 . void (*_bfd_coff_swap_sym_in)
1142 . PARAMS ((bfd *, PTR, PTR));
1144 . void (*_bfd_coff_swap_lineno_in)
1145 . PARAMS ((bfd *, PTR, PTR));
1147 . unsigned int (*_bfd_coff_swap_aux_out)
1148 . PARAMS ((bfd *, PTR, int, int, int, int, PTR));
1150 . unsigned int (*_bfd_coff_swap_sym_out)
1151 . PARAMS ((bfd *, PTR, PTR));
1153 . unsigned int (*_bfd_coff_swap_lineno_out)
1154 . PARAMS ((bfd *, PTR, PTR));
1156 . unsigned int (*_bfd_coff_swap_reloc_out)
1157 . PARAMS ((bfd *, PTR, PTR));
1159 . unsigned int (*_bfd_coff_swap_filehdr_out)
1160 . PARAMS ((bfd *, PTR, PTR));
1162 . unsigned int (*_bfd_coff_swap_aouthdr_out)
1163 . PARAMS ((bfd *, PTR, PTR));
1165 . unsigned int (*_bfd_coff_swap_scnhdr_out)
1166 . PARAMS ((bfd *, PTR, PTR));
1168 . unsigned int _bfd_filhsz;
1169 . unsigned int _bfd_aoutsz;
1170 . unsigned int _bfd_scnhsz;
1171 . unsigned int _bfd_symesz;
1172 . unsigned int _bfd_auxesz;
1173 . unsigned int _bfd_relsz;
1174 . unsigned int _bfd_linesz;
1175 . unsigned int _bfd_filnmlen;
1176 . boolean _bfd_coff_long_filenames;
1177 . boolean _bfd_coff_long_section_names;
1178 . unsigned int _bfd_coff_default_section_alignment_power;
1179 . boolean _bfd_coff_force_symnames_in_strings;
1180 . unsigned int _bfd_coff_debug_string_prefix_length;
1182 . void (*_bfd_coff_swap_filehdr_in)
1183 . PARAMS ((bfd *, PTR, PTR));
1185 . void (*_bfd_coff_swap_aouthdr_in)
1186 . PARAMS ((bfd *, PTR, PTR));
1188 . void (*_bfd_coff_swap_scnhdr_in)
1189 . PARAMS ((bfd *, PTR, PTR));
1191 . void (*_bfd_coff_swap_reloc_in)
1192 . PARAMS ((bfd *abfd, PTR, PTR));
1194 . boolean (*_bfd_coff_bad_format_hook)
1195 . PARAMS ((bfd *, PTR));
1197 . boolean (*_bfd_coff_set_arch_mach_hook)
1198 . PARAMS ((bfd *, PTR));
1200 . PTR (*_bfd_coff_mkobject_hook)
1201 . PARAMS ((bfd *, PTR, PTR));
1203 . boolean (*_bfd_styp_to_sec_flags_hook)
1204 . PARAMS ((bfd *, PTR, const char *, asection *, flagword *));
1206 . void (*_bfd_set_alignment_hook)
1207 . PARAMS ((bfd *, asection *, PTR));
1209 . boolean (*_bfd_coff_slurp_symbol_table)
1210 . PARAMS ((bfd *));
1212 . boolean (*_bfd_coff_symname_in_debug)
1213 . PARAMS ((bfd *, struct internal_syment *));
1215 . boolean (*_bfd_coff_pointerize_aux_hook)
1216 . PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
1217 . unsigned int, combined_entry_type *));
1219 . boolean (*_bfd_coff_print_aux)
1220 . PARAMS ((bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1221 . combined_entry_type *, unsigned int));
1223 . void (*_bfd_coff_reloc16_extra_cases)
1224 . PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
1225 . bfd_byte *, unsigned int *, unsigned int *));
1227 . int (*_bfd_coff_reloc16_estimate)
1228 . PARAMS ((bfd *, asection *, arelent *, unsigned int,
1229 . struct bfd_link_info *));
1231 . enum coff_symbol_classification (*_bfd_coff_classify_symbol)
1232 . PARAMS ((bfd *, struct internal_syment *));
1234 . boolean (*_bfd_coff_compute_section_file_positions)
1235 . PARAMS ((bfd *));
1237 . boolean (*_bfd_coff_start_final_link)
1238 . PARAMS ((bfd *, struct bfd_link_info *));
1240 . boolean (*_bfd_coff_relocate_section)
1241 . PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
1242 . struct internal_reloc *, struct internal_syment *, asection **));
1244 . reloc_howto_type *(*_bfd_coff_rtype_to_howto)
1245 . PARAMS ((bfd *, asection *, struct internal_reloc *,
1246 . struct coff_link_hash_entry *, struct internal_syment *,
1247 . bfd_vma *));
1249 . boolean (*_bfd_coff_adjust_symndx)
1250 . PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *,
1251 . struct internal_reloc *, boolean *));
1253 . boolean (*_bfd_coff_link_add_one_symbol)
1254 . PARAMS ((struct bfd_link_info *, bfd *, const char *, flagword,
1255 . asection *, bfd_vma, const char *, boolean, boolean,
1256 . struct bfd_link_hash_entry **));
1258 . boolean (*_bfd_coff_link_output_has_begun)
1259 . PARAMS ((bfd *, struct coff_final_link_info *));
1261 . boolean (*_bfd_coff_final_link_postscript)
1262 . PARAMS ((bfd *, struct coff_final_link_info *));
1264 .} bfd_coff_backend_data;
1266 .#define coff_backend_info(abfd) \
1267 . ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1269 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1270 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1272 .#define bfd_coff_swap_sym_in(a,e,i) \
1273 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1275 .#define bfd_coff_swap_lineno_in(a,e,i) \
1276 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1278 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1279 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1281 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1282 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1284 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1285 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1287 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1288 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1290 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1291 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1293 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1294 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1296 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1297 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1299 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1300 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1301 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1302 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1303 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1304 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1305 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1306 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1307 .#define bfd_coff_long_filenames(abfd) \
1308 . (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1309 .#define bfd_coff_long_section_names(abfd) \
1310 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1311 .#define bfd_coff_default_section_alignment_power(abfd) \
1312 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1313 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1314 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1316 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1317 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1319 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1320 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1322 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1323 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1325 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1326 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1328 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1329 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1330 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1331 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook) (abfd, filehdr, aouthdr))
1333 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\
1334 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1335 . (abfd, scnhdr, name, section, flags_ptr))
1337 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1338 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1340 .#define bfd_coff_slurp_symbol_table(abfd)\
1341 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1343 .#define bfd_coff_symname_in_debug(abfd, sym)\
1344 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1346 .#define bfd_coff_force_symnames_in_strings(abfd)\
1347 . (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
1349 .#define bfd_coff_debug_string_prefix_length(abfd)\
1350 . (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
1352 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1353 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1354 . (abfd, file, base, symbol, aux, indaux))
1356 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)\
1357 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1358 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1360 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1361 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1362 . (abfd, section, reloc, shrink, link_info))
1364 .#define bfd_coff_classify_symbol(abfd, sym)\
1365 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1366 . (abfd, sym))
1368 .#define bfd_coff_compute_section_file_positions(abfd)\
1369 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1370 . (abfd))
1372 .#define bfd_coff_start_final_link(obfd, info)\
1373 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1374 . (obfd, info))
1375 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1376 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1377 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1378 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1379 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1380 . (abfd, sec, rel, h, sym, addendp))
1381 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1382 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1383 . (obfd, info, ibfd, sec, rel, adjustedp))
1384 .#define bfd_coff_link_add_one_symbol(info,abfd,name,flags,section,value,string,cp,coll,hashp)\
1385 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1386 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1388 .#define bfd_coff_link_output_has_begun(a,p) \
1389 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a,p))
1390 .#define bfd_coff_final_link_postscript(a,p) \
1391 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a,p))
1395 /* See whether the magic number matches. */
1397 static boolean
1398 coff_bad_format_hook (abfd, filehdr)
1399 bfd * abfd ATTRIBUTE_UNUSED;
1400 PTR filehdr;
1402 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1404 if (BADMAG (*internal_f))
1405 return false;
1407 /* if the optional header is NULL or not the correct size then
1408 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1409 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1410 optional header is of a different size.
1412 But the mips keeps extra stuff in it's opthdr, so dont check
1413 when doing that
1416 #if defined(M88) || defined(I960)
1417 if (internal_f->f_opthdr != 0 && bfd_coff_aoutsz (abfd) != internal_f->f_opthdr)
1418 return false;
1419 #endif
1421 return true;
1424 /* Check whether this section uses an alignment other than the
1425 default. */
1427 static void
1428 coff_set_custom_section_alignment (abfd, section, alignment_table, table_size)
1429 bfd *abfd ATTRIBUTE_UNUSED;
1430 asection *section;
1431 const struct coff_section_alignment_entry *alignment_table;
1432 const unsigned int table_size;
1434 const unsigned int default_alignment = COFF_DEFAULT_SECTION_ALIGNMENT_POWER;
1435 unsigned int i;
1437 for (i = 0; i < table_size; ++i)
1439 const char *secname = bfd_get_section_name (abfd, section);
1440 if (alignment_table[i].comparison_length == (unsigned int) -1
1441 ? strcmp (alignment_table[i].name, secname) == 0
1442 : strncmp (alignment_table[i].name, secname,
1443 alignment_table[i].comparison_length) == 0)
1444 break;
1446 if (i >= table_size)
1447 return;
1449 if (alignment_table[i].default_alignment_min != COFF_ALIGNMENT_FIELD_EMPTY
1450 && default_alignment < alignment_table[i].default_alignment_min)
1451 return;
1453 if (alignment_table[i].default_alignment_max != COFF_ALIGNMENT_FIELD_EMPTY
1454 #if COFF_DEFAULT_SECTION_ALIGNMENT_POWER != 0
1455 && default_alignment > alignment_table[i].default_alignment_max
1456 #endif
1458 return;
1460 section->alignment_power = alignment_table[i].alignment_power;
1463 /* Custom section alignment records. */
1465 static const struct coff_section_alignment_entry
1466 coff_section_alignment_table[] =
1468 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1469 COFF_SECTION_ALIGNMENT_ENTRIES,
1470 #endif
1471 /* There must not be any gaps between .stabstr sections. */
1472 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1473 1, COFF_ALIGNMENT_FIELD_EMPTY, 0 },
1474 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1475 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1476 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 },
1477 /* Similarly for the .ctors and .dtors sections. */
1478 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1479 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 },
1480 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1481 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 }
1484 static const unsigned int coff_section_alignment_table_size =
1485 sizeof coff_section_alignment_table / sizeof coff_section_alignment_table[0];
1487 /* Initialize a section structure with information peculiar to this
1488 particular implementation of COFF. */
1490 static boolean
1491 coff_new_section_hook (abfd, section)
1492 bfd * abfd;
1493 asection * section;
1495 combined_entry_type *native;
1496 bfd_size_type amt;
1498 section->alignment_power = COFF_DEFAULT_SECTION_ALIGNMENT_POWER;
1500 #ifdef RS6000COFF_C
1501 if (bfd_xcoff_text_align_power (abfd) != 0
1502 && strcmp (bfd_get_section_name (abfd, section), ".text") == 0)
1503 section->alignment_power = bfd_xcoff_text_align_power (abfd);
1504 if (bfd_xcoff_data_align_power (abfd) != 0
1505 && strcmp (bfd_get_section_name (abfd, section), ".data") == 0)
1506 section->alignment_power = bfd_xcoff_data_align_power (abfd);
1507 #endif
1509 /* Allocate aux records for section symbols, to store size and
1510 related info.
1512 @@ The 10 is a guess at a plausible maximum number of aux entries
1513 (but shouldn't be a constant). */
1514 amt = sizeof (combined_entry_type) * 10;
1515 native = (combined_entry_type *) bfd_zalloc (abfd, amt);
1516 if (native == NULL)
1517 return false;
1519 /* We don't need to set up n_name, n_value, or n_scnum in the native
1520 symbol information, since they'll be overriden by the BFD symbol
1521 anyhow. However, we do need to set the type and storage class,
1522 in case this symbol winds up getting written out. The value 0
1523 for n_numaux is already correct. */
1525 native->u.syment.n_type = T_NULL;
1526 native->u.syment.n_sclass = C_STAT;
1528 coffsymbol (section->symbol)->native = native;
1530 coff_set_custom_section_alignment (abfd, section,
1531 coff_section_alignment_table,
1532 coff_section_alignment_table_size);
1534 return true;
1537 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1539 /* Set the alignment of a BFD section. */
1541 static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1543 static void
1544 coff_set_alignment_hook (abfd, section, scnhdr)
1545 bfd * abfd ATTRIBUTE_UNUSED;
1546 asection * section;
1547 PTR scnhdr;
1549 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1550 unsigned int i;
1552 #ifdef I960
1553 /* Extract ALIGN from 2**ALIGN stored in section header */
1554 for (i = 0; i < 32; i++)
1555 if ((1 << i) >= hdr->s_align)
1556 break;
1557 #endif
1558 #ifdef TIC80COFF
1559 /* TI tools puts the alignment power in bits 8-11 */
1560 i = (hdr->s_flags >> 8) & 0xF ;
1561 #endif
1562 #ifdef COFF_DECODE_ALIGNMENT
1563 i = COFF_DECODE_ALIGNMENT(hdr->s_flags);
1564 #endif
1565 section->alignment_power = i;
1567 #ifdef coff_set_section_load_page
1568 coff_set_section_load_page (section, hdr->s_page);
1569 #endif
1572 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1573 #ifdef COFF_WITH_PE
1575 /* a couple of macros to help setting the alignment power field */
1576 #define ALIGN_SET(field,x,y) \
1577 if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x )\
1579 section->alignment_power = y;\
1582 #define ELIFALIGN_SET(field,x,y) \
1583 else if (( (field) & IMAGE_SCN_ALIGN_64BYTES) == x ) \
1585 section->alignment_power = y;\
1588 static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1590 static void
1591 coff_set_alignment_hook (abfd, section, scnhdr)
1592 bfd * abfd ATTRIBUTE_UNUSED;
1593 asection * section;
1594 PTR scnhdr;
1596 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1597 bfd_size_type amt;
1599 ALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_64BYTES, 6)
1600 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_32BYTES, 5)
1601 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_16BYTES, 4)
1602 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_8BYTES, 3)
1603 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_4BYTES, 2)
1604 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_2BYTES, 1)
1605 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_1BYTES, 0)
1607 /* In a PE image file, the s_paddr field holds the virtual size of a
1608 section, while the s_size field holds the raw size. We also keep
1609 the original section flag value, since not every bit can be
1610 mapped onto a generic BFD section bit. */
1611 if (coff_section_data (abfd, section) == NULL)
1613 amt = sizeof (struct coff_section_tdata);
1614 section->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
1615 if (section->used_by_bfd == NULL)
1617 /* FIXME: Return error. */
1618 abort ();
1621 if (pei_section_data (abfd, section) == NULL)
1623 amt = sizeof (struct pei_section_tdata);
1624 coff_section_data (abfd, section)->tdata = (PTR) bfd_zalloc (abfd, amt);
1625 if (coff_section_data (abfd, section)->tdata == NULL)
1627 /* FIXME: Return error. */
1628 abort ();
1631 pei_section_data (abfd, section)->virt_size = hdr->s_paddr;
1632 pei_section_data (abfd, section)->pe_flags = hdr->s_flags;
1634 section->lma = hdr->s_vaddr;
1636 /* check for extended relocs */
1637 if (hdr->s_flags & IMAGE_SCN_LNK_NRELOC_OVFL)
1639 struct external_reloc dst;
1640 struct internal_reloc n;
1641 file_ptr oldpos = bfd_tell (abfd);
1642 bfd_seek (abfd, (file_ptr) hdr->s_relptr, 0);
1643 if (bfd_bread ((PTR) &dst, (bfd_size_type) bfd_coff_relsz (abfd), abfd)
1644 != bfd_coff_relsz (abfd))
1645 return;
1647 coff_swap_reloc_in (abfd, &dst, &n);
1648 bfd_seek (abfd, oldpos, 0);
1649 section->reloc_count = hdr->s_nreloc = n.r_vaddr;
1652 #undef ALIGN_SET
1653 #undef ELIFALIGN_SET
1655 #else /* ! COFF_WITH_PE */
1656 #ifdef RS6000COFF_C
1658 /* We grossly abuse this function to handle XCOFF overflow headers.
1659 When we see one, we correct the reloc and line number counts in the
1660 real header, and remove the section we just created. */
1662 static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1664 static void
1665 coff_set_alignment_hook (abfd, section, scnhdr)
1666 bfd *abfd;
1667 asection *section;
1668 PTR scnhdr;
1670 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1671 asection *real_sec;
1672 asection **ps;
1674 if ((hdr->s_flags & STYP_OVRFLO) == 0)
1675 return;
1677 real_sec = coff_section_from_bfd_index (abfd, (int) hdr->s_nreloc);
1678 if (real_sec == NULL)
1679 return;
1681 real_sec->reloc_count = hdr->s_paddr;
1682 real_sec->lineno_count = hdr->s_vaddr;
1684 for (ps = &abfd->sections; *ps != NULL; ps = &(*ps)->next)
1686 if (*ps == section)
1688 bfd_section_list_remove (abfd, ps);
1689 --abfd->section_count;
1690 break;
1695 #else /* ! RS6000COFF_C */
1697 #define coff_set_alignment_hook \
1698 ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
1700 #endif /* ! RS6000COFF_C */
1701 #endif /* ! COFF_WITH_PE */
1702 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1704 #ifndef coff_mkobject
1706 static boolean coff_mkobject PARAMS ((bfd *));
1708 static boolean
1709 coff_mkobject (abfd)
1710 bfd * abfd;
1712 coff_data_type *coff;
1713 bfd_size_type amt = sizeof (coff_data_type);
1715 abfd->tdata.coff_obj_data = (struct coff_tdata *) bfd_zalloc (abfd, amt);
1716 if (abfd->tdata.coff_obj_data == 0)
1717 return false;
1718 coff = coff_data (abfd);
1719 coff->symbols = (coff_symbol_type *) NULL;
1720 coff->conversion_table = (unsigned int *) NULL;
1721 coff->raw_syments = (struct coff_ptr_struct *) NULL;
1722 coff->relocbase = 0;
1723 coff->local_toc_sym_map = 0;
1725 /* make_abs_section(abfd);*/
1727 return true;
1729 #endif
1731 /* Create the COFF backend specific information. */
1732 #ifndef coff_mkobject_hook
1733 static PTR
1734 coff_mkobject_hook (abfd, filehdr, aouthdr)
1735 bfd * abfd;
1736 PTR filehdr;
1737 PTR aouthdr ATTRIBUTE_UNUSED;
1739 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1740 coff_data_type *coff;
1742 if (! coff_mkobject (abfd))
1743 return NULL;
1745 coff = coff_data (abfd);
1747 coff->sym_filepos = internal_f->f_symptr;
1749 /* These members communicate important constants about the symbol
1750 table to GDB's symbol-reading code. These `constants'
1751 unfortunately vary among coff implementations... */
1752 coff->local_n_btmask = N_BTMASK;
1753 coff->local_n_btshft = N_BTSHFT;
1754 coff->local_n_tmask = N_TMASK;
1755 coff->local_n_tshift = N_TSHIFT;
1756 coff->local_symesz = bfd_coff_symesz (abfd);
1757 coff->local_auxesz = bfd_coff_auxesz (abfd);
1758 coff->local_linesz = bfd_coff_linesz (abfd);
1760 coff->timestamp = internal_f->f_timdat;
1762 obj_raw_syment_count (abfd) =
1763 obj_conv_table_size (abfd) =
1764 internal_f->f_nsyms;
1766 #ifdef RS6000COFF_C
1767 if ((internal_f->f_flags & F_SHROBJ) != 0)
1768 abfd->flags |= DYNAMIC;
1769 if (aouthdr != NULL && internal_f->f_opthdr >= bfd_coff_aoutsz (abfd))
1771 struct internal_aouthdr *internal_a =
1772 (struct internal_aouthdr *) aouthdr;
1773 struct xcoff_tdata *xcoff;
1775 xcoff = xcoff_data (abfd);
1776 # ifdef U803XTOCMAGIC
1777 xcoff->xcoff64 = internal_f->f_magic == U803XTOCMAGIC;
1778 # else
1779 xcoff->xcoff64 = 0;
1780 # endif
1781 xcoff->full_aouthdr = true;
1782 xcoff->toc = internal_a->o_toc;
1783 xcoff->sntoc = internal_a->o_sntoc;
1784 xcoff->snentry = internal_a->o_snentry;
1785 bfd_xcoff_text_align_power (abfd) = internal_a->o_algntext;
1786 bfd_xcoff_data_align_power (abfd) = internal_a->o_algndata;
1787 xcoff->modtype = internal_a->o_modtype;
1788 xcoff->cputype = internal_a->o_cputype;
1789 xcoff->maxdata = internal_a->o_maxdata;
1790 xcoff->maxstack = internal_a->o_maxstack;
1792 #endif
1794 #ifdef ARM
1795 /* Set the flags field from the COFF header read in. */
1796 if (! _bfd_coff_arm_set_private_flags (abfd, internal_f->f_flags))
1797 coff->flags = 0;
1798 #endif
1800 #ifdef COFF_WITH_PE
1801 /* FIXME: I'm not sure this is ever executed, since peicode.h
1802 defines coff_mkobject_hook. */
1803 if ((internal_f->f_flags & IMAGE_FILE_DEBUG_STRIPPED) == 0)
1804 abfd->flags |= HAS_DEBUG;
1805 #endif
1807 return (PTR) coff;
1809 #endif
1811 /* Determine the machine architecture and type. FIXME: This is target
1812 dependent because the magic numbers are defined in the target
1813 dependent header files. But there is no particular need for this.
1814 If the magic numbers were moved to a separate file, this function
1815 would be target independent and would also be much more successful
1816 at linking together COFF files for different architectures. */
1818 static boolean
1819 coff_set_arch_mach_hook (abfd, filehdr)
1820 bfd *abfd;
1821 PTR filehdr;
1823 unsigned long machine;
1824 enum bfd_architecture arch;
1825 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1827 /* Zero selects the default machine for an arch. */
1828 machine = 0;
1829 switch (internal_f->f_magic)
1831 #ifdef OR32_MAGIC_BIG
1832 case OR32_MAGIC_BIG:
1833 case OR32_MAGIC_LITTLE:
1834 arch = bfd_arch_or32;
1835 break;
1836 #endif
1837 #ifdef PPCMAGIC
1838 case PPCMAGIC:
1839 arch = bfd_arch_powerpc;
1840 break;
1841 #endif
1842 #ifdef I386MAGIC
1843 case I386MAGIC:
1844 case I386PTXMAGIC:
1845 case I386AIXMAGIC: /* Danbury PS/2 AIX C Compiler */
1846 case LYNXCOFFMAGIC: /* shadows the m68k Lynx number below, sigh */
1847 arch = bfd_arch_i386;
1848 break;
1849 #endif
1850 #ifdef IA64MAGIC
1851 case IA64MAGIC:
1852 arch = bfd_arch_ia64;
1853 break;
1854 #endif
1855 #ifdef A29K_MAGIC_BIG
1856 case A29K_MAGIC_BIG:
1857 case A29K_MAGIC_LITTLE:
1858 arch = bfd_arch_a29k;
1859 break;
1860 #endif
1861 #ifdef ARMMAGIC
1862 case ARMMAGIC:
1863 case ARMPEMAGIC:
1864 case THUMBPEMAGIC:
1865 arch = bfd_arch_arm;
1866 switch (internal_f->f_flags & F_ARM_ARCHITECTURE_MASK)
1868 case F_ARM_2: machine = bfd_mach_arm_2; break;
1869 case F_ARM_2a: machine = bfd_mach_arm_2a; break;
1870 case F_ARM_3: machine = bfd_mach_arm_3; break;
1871 default:
1872 case F_ARM_3M: machine = bfd_mach_arm_3M; break;
1873 case F_ARM_4: machine = bfd_mach_arm_4; break;
1874 case F_ARM_4T: machine = bfd_mach_arm_4T; break;
1875 /* The COFF header does not have enough bits available
1876 to cover all the different ARM architectures. So
1877 we interpret F_ARM_5, the highest flag value to mean
1878 "the highest ARM architecture known to BFD" which is
1879 currently the XScale. */
1880 case F_ARM_5: machine = bfd_mach_arm_XScale; break;
1882 break;
1883 #endif
1884 #ifdef MC68MAGIC
1885 case MC68MAGIC:
1886 case M68MAGIC:
1887 #ifdef MC68KBCSMAGIC
1888 case MC68KBCSMAGIC:
1889 #endif
1890 #ifdef APOLLOM68KMAGIC
1891 case APOLLOM68KMAGIC:
1892 #endif
1893 #ifdef LYNXCOFFMAGIC
1894 case LYNXCOFFMAGIC:
1895 #endif
1896 arch = bfd_arch_m68k;
1897 machine = bfd_mach_m68020;
1898 break;
1899 #endif
1900 #ifdef MC88MAGIC
1901 case MC88MAGIC:
1902 case MC88DMAGIC:
1903 case MC88OMAGIC:
1904 arch = bfd_arch_m88k;
1905 machine = 88100;
1906 break;
1907 #endif
1908 #ifdef Z8KMAGIC
1909 case Z8KMAGIC:
1910 arch = bfd_arch_z8k;
1911 switch (internal_f->f_flags & F_MACHMASK)
1913 case F_Z8001:
1914 machine = bfd_mach_z8001;
1915 break;
1916 case F_Z8002:
1917 machine = bfd_mach_z8002;
1918 break;
1919 default:
1920 return false;
1922 break;
1923 #endif
1924 #ifdef I860
1925 case I860MAGIC:
1926 arch = bfd_arch_i860;
1927 break;
1928 #endif
1929 #ifdef I960
1930 #ifdef I960ROMAGIC
1931 case I960ROMAGIC:
1932 case I960RWMAGIC:
1933 arch = bfd_arch_i960;
1934 switch (F_I960TYPE & internal_f->f_flags)
1936 default:
1937 case F_I960CORE:
1938 machine = bfd_mach_i960_core;
1939 break;
1940 case F_I960KB:
1941 machine = bfd_mach_i960_kb_sb;
1942 break;
1943 case F_I960MC:
1944 machine = bfd_mach_i960_mc;
1945 break;
1946 case F_I960XA:
1947 machine = bfd_mach_i960_xa;
1948 break;
1949 case F_I960CA:
1950 machine = bfd_mach_i960_ca;
1951 break;
1952 case F_I960KA:
1953 machine = bfd_mach_i960_ka_sa;
1954 break;
1955 case F_I960JX:
1956 machine = bfd_mach_i960_jx;
1957 break;
1958 case F_I960HX:
1959 machine = bfd_mach_i960_hx;
1960 break;
1962 break;
1963 #endif
1964 #endif
1966 #ifdef RS6000COFF_C
1967 #ifdef XCOFF64
1968 case U64_TOCMAGIC:
1969 case U803XTOCMAGIC:
1970 #else
1971 case U802ROMAGIC:
1972 case U802WRMAGIC:
1973 case U802TOCMAGIC:
1974 #endif
1976 int cputype;
1978 if (xcoff_data (abfd)->cputype != -1)
1979 cputype = xcoff_data (abfd)->cputype & 0xff;
1980 else
1982 /* We did not get a value from the a.out header. If the
1983 file has not been stripped, we may be able to get the
1984 architecture information from the first symbol, if it
1985 is a .file symbol. */
1986 if (obj_raw_syment_count (abfd) == 0)
1987 cputype = 0;
1988 else
1990 bfd_byte *buf;
1991 struct internal_syment sym;
1992 bfd_size_type amt = bfd_coff_symesz (abfd);
1994 buf = (bfd_byte *) bfd_malloc (amt);
1995 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
1996 || bfd_bread (buf, amt, abfd) != amt)
1998 free (buf);
1999 return false;
2001 bfd_coff_swap_sym_in (abfd, (PTR) buf, (PTR) &sym);
2002 if (sym.n_sclass == C_FILE)
2003 cputype = sym.n_type & 0xff;
2004 else
2005 cputype = 0;
2006 free (buf);
2010 /* FIXME: We don't handle all cases here. */
2011 switch (cputype)
2013 default:
2014 case 0:
2015 arch = bfd_xcoff_architecture (abfd);
2016 machine = bfd_xcoff_machine (abfd);
2017 break;
2019 case 1:
2020 arch = bfd_arch_powerpc;
2021 machine = bfd_mach_ppc_601;
2022 break;
2023 case 2: /* 64 bit PowerPC */
2024 arch = bfd_arch_powerpc;
2025 machine = bfd_mach_ppc_620;
2026 break;
2027 case 3:
2028 arch = bfd_arch_powerpc;
2029 machine = bfd_mach_ppc;
2030 break;
2031 case 4:
2032 arch = bfd_arch_rs6000;
2033 machine = bfd_mach_rs6k;
2034 break;
2037 break;
2038 #endif
2040 #ifdef WE32KMAGIC
2041 case WE32KMAGIC:
2042 arch = bfd_arch_we32k;
2043 break;
2044 #endif
2046 #ifdef H8300MAGIC
2047 case H8300MAGIC:
2048 arch = bfd_arch_h8300;
2049 machine = bfd_mach_h8300;
2050 /* !! FIXME this probably isn't the right place for this */
2051 abfd->flags |= BFD_IS_RELAXABLE;
2052 break;
2053 #endif
2055 #ifdef H8300HMAGIC
2056 case H8300HMAGIC:
2057 arch = bfd_arch_h8300;
2058 machine = bfd_mach_h8300h;
2059 /* !! FIXME this probably isn't the right place for this */
2060 abfd->flags |= BFD_IS_RELAXABLE;
2061 break;
2062 #endif
2064 #ifdef H8300SMAGIC
2065 case H8300SMAGIC:
2066 arch = bfd_arch_h8300;
2067 machine = bfd_mach_h8300s;
2068 /* !! FIXME this probably isn't the right place for this */
2069 abfd->flags |= BFD_IS_RELAXABLE;
2070 break;
2071 #endif
2073 #ifdef SH_ARCH_MAGIC_BIG
2074 case SH_ARCH_MAGIC_BIG:
2075 case SH_ARCH_MAGIC_LITTLE:
2076 #ifdef COFF_WITH_PE
2077 case SH_ARCH_MAGIC_WINCE:
2078 #endif
2079 arch = bfd_arch_sh;
2080 break;
2081 #endif
2083 #ifdef MIPS_ARCH_MAGIC_WINCE
2084 case MIPS_ARCH_MAGIC_WINCE:
2085 arch = bfd_arch_mips;
2086 break;
2087 #endif
2089 #ifdef H8500MAGIC
2090 case H8500MAGIC:
2091 arch = bfd_arch_h8500;
2092 break;
2093 #endif
2095 #ifdef SPARCMAGIC
2096 case SPARCMAGIC:
2097 #ifdef LYNXCOFFMAGIC
2098 case LYNXCOFFMAGIC:
2099 #endif
2100 arch = bfd_arch_sparc;
2101 break;
2102 #endif
2104 #ifdef TIC30MAGIC
2105 case TIC30MAGIC:
2106 arch = bfd_arch_tic30;
2107 break;
2108 #endif
2110 #ifdef TICOFF0MAGIC
2111 #ifdef TICOFF_TARGET_ARCH
2112 /* this TI COFF section should be used by all new TI COFF v0 targets */
2113 case TICOFF0MAGIC:
2114 arch = TICOFF_TARGET_ARCH;
2115 break;
2116 #endif
2117 #endif
2119 #ifdef TICOFF1MAGIC
2120 /* this TI COFF section should be used by all new TI COFF v1/2 targets */
2121 /* TI COFF1 and COFF2 use the target_id field to specify which arch */
2122 case TICOFF1MAGIC:
2123 case TICOFF2MAGIC:
2124 switch (internal_f->f_target_id)
2126 #ifdef TI_TARGET_ID
2127 case TI_TARGET_ID:
2128 arch = TICOFF_TARGET_ARCH;
2129 break;
2130 #endif
2131 default:
2132 arch = bfd_arch_obscure;
2133 (*_bfd_error_handler)
2134 (_("Unrecognized TI COFF target id '0x%x'"),
2135 internal_f->f_target_id);
2136 break;
2138 break;
2139 #endif
2141 #ifdef TIC80_ARCH_MAGIC
2142 case TIC80_ARCH_MAGIC:
2143 arch = bfd_arch_tic80;
2144 break;
2145 #endif
2147 #ifdef MCOREMAGIC
2148 case MCOREMAGIC:
2149 arch = bfd_arch_mcore;
2150 break;
2151 #endif
2153 #ifdef W65MAGIC
2154 case W65MAGIC:
2155 arch = bfd_arch_w65;
2156 break;
2157 #endif
2159 default: /* Unreadable input file type */
2160 arch = bfd_arch_obscure;
2161 break;
2164 bfd_default_set_arch_mach (abfd, arch, machine);
2165 return true;
2168 #ifdef SYMNAME_IN_DEBUG
2170 static boolean symname_in_debug_hook
2171 PARAMS ((bfd *, struct internal_syment *));
2173 static boolean
2174 symname_in_debug_hook (abfd, sym)
2175 bfd * abfd ATTRIBUTE_UNUSED;
2176 struct internal_syment *sym;
2178 return SYMNAME_IN_DEBUG (sym) != 0;
2181 #else
2183 #define symname_in_debug_hook \
2184 (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
2186 #endif
2188 #ifdef RS6000COFF_C
2190 #ifdef XCOFF64
2191 #define FORCE_SYMNAMES_IN_STRINGS
2192 #endif
2194 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */
2196 static boolean coff_pointerize_aux_hook
2197 PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
2198 unsigned int, combined_entry_type *));
2200 /*ARGSUSED*/
2201 static boolean
2202 coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux)
2203 bfd *abfd ATTRIBUTE_UNUSED;
2204 combined_entry_type *table_base;
2205 combined_entry_type *symbol;
2206 unsigned int indaux;
2207 combined_entry_type *aux;
2209 int class = symbol->u.syment.n_sclass;
2211 if ((class == C_EXT || class == C_HIDEXT)
2212 && indaux + 1 == symbol->u.syment.n_numaux)
2214 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD)
2216 aux->u.auxent.x_csect.x_scnlen.p =
2217 table_base + aux->u.auxent.x_csect.x_scnlen.l;
2218 aux->fix_scnlen = 1;
2221 /* Return true to indicate that the caller should not do any
2222 further work on this auxent. */
2223 return true;
2226 /* Return false to indicate that this auxent should be handled by
2227 the caller. */
2228 return false;
2231 #else
2232 #ifdef I960
2234 /* We don't want to pointerize bal entries. */
2236 static boolean coff_pointerize_aux_hook
2237 PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
2238 unsigned int, combined_entry_type *));
2240 /*ARGSUSED*/
2241 static boolean
2242 coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux)
2243 bfd *abfd ATTRIBUTE_UNUSED;
2244 combined_entry_type *table_base ATTRIBUTE_UNUSED;
2245 combined_entry_type *symbol;
2246 unsigned int indaux;
2247 combined_entry_type *aux ATTRIBUTE_UNUSED;
2249 /* Return true if we don't want to pointerize this aux entry, which
2250 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
2251 return (indaux == 1
2252 && (symbol->u.syment.n_sclass == C_LEAFPROC
2253 || symbol->u.syment.n_sclass == C_LEAFSTAT
2254 || symbol->u.syment.n_sclass == C_LEAFEXT));
2257 #else /* ! I960 */
2259 #define coff_pointerize_aux_hook 0
2261 #endif /* ! I960 */
2262 #endif /* ! RS6000COFF_C */
2264 /* Print an aux entry. This returns true if it has printed it. */
2266 static boolean coff_print_aux
2267 PARAMS ((bfd *, FILE *, combined_entry_type *, combined_entry_type *,
2268 combined_entry_type *, unsigned int));
2270 static boolean
2271 coff_print_aux (abfd, file, table_base, symbol, aux, indaux)
2272 bfd *abfd ATTRIBUTE_UNUSED;
2273 FILE *file ATTRIBUTE_UNUSED;
2274 combined_entry_type *table_base ATTRIBUTE_UNUSED;
2275 combined_entry_type *symbol ATTRIBUTE_UNUSED;
2276 combined_entry_type *aux ATTRIBUTE_UNUSED;
2277 unsigned int indaux ATTRIBUTE_UNUSED;
2279 #ifdef RS6000COFF_C
2280 if ((symbol->u.syment.n_sclass == C_EXT
2281 || symbol->u.syment.n_sclass == C_HIDEXT)
2282 && indaux + 1 == symbol->u.syment.n_numaux)
2284 /* This is a csect entry. */
2285 fprintf (file, "AUX ");
2286 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) != XTY_LD)
2288 BFD_ASSERT (! aux->fix_scnlen);
2289 #ifdef XCOFF64
2290 fprintf (file, "val %5lld", aux->u.auxent.x_csect.x_scnlen.l);
2291 #else
2292 fprintf (file, "val %5ld", (long) aux->u.auxent.x_csect.x_scnlen.l);
2293 #endif
2295 else
2297 fprintf (file, "indx ");
2298 if (! aux->fix_scnlen)
2299 #ifdef XCOFF64
2300 fprintf (file, "%4lld", aux->u.auxent.x_csect.x_scnlen.l);
2301 #else
2302 fprintf (file, "%4ld", (long) aux->u.auxent.x_csect.x_scnlen.l);
2303 #endif
2304 else
2305 fprintf (file, "%4ld",
2306 (long) (aux->u.auxent.x_csect.x_scnlen.p - table_base));
2308 fprintf (file,
2309 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2310 aux->u.auxent.x_csect.x_parmhash,
2311 (unsigned int) aux->u.auxent.x_csect.x_snhash,
2312 SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp),
2313 SMTYP_ALIGN (aux->u.auxent.x_csect.x_smtyp),
2314 (unsigned int) aux->u.auxent.x_csect.x_smclas,
2315 aux->u.auxent.x_csect.x_stab,
2316 (unsigned int) aux->u.auxent.x_csect.x_snstab);
2317 return true;
2319 #endif
2321 /* Return false to indicate that no special action was taken. */
2322 return false;
2326 SUBSUBSECTION
2327 Writing relocations
2329 To write relocations, the back end steps though the
2330 canonical relocation table and create an
2331 @code{internal_reloc}. The symbol index to use is removed from
2332 the @code{offset} field in the symbol table supplied. The
2333 address comes directly from the sum of the section base
2334 address and the relocation offset; the type is dug directly
2335 from the howto field. Then the @code{internal_reloc} is
2336 swapped into the shape of an @code{external_reloc} and written
2337 out to disk.
2341 #ifdef TARG_AUX
2343 static int compare_arelent_ptr PARAMS ((const PTR, const PTR));
2345 /* AUX's ld wants relocations to be sorted */
2346 static int
2347 compare_arelent_ptr (x, y)
2348 const PTR x;
2349 const PTR y;
2351 const arelent **a = (const arelent **) x;
2352 const arelent **b = (const arelent **) y;
2353 bfd_size_type aadr = (*a)->address;
2354 bfd_size_type badr = (*b)->address;
2356 return (aadr < badr ? -1 : badr < aadr ? 1 : 0);
2359 #endif /* TARG_AUX */
2361 static boolean
2362 coff_write_relocs (abfd, first_undef)
2363 bfd * abfd;
2364 int first_undef;
2366 asection *s;
2368 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
2370 unsigned int i;
2371 struct external_reloc dst;
2372 arelent **p;
2374 #ifndef TARG_AUX
2375 p = s->orelocation;
2376 #else
2378 /* sort relocations before we write them out */
2379 bfd_size_type amt;
2381 amt = s->reloc_count;
2382 amt *= sizeof (arelent *);
2383 p = (arelent **) bfd_malloc (amt);
2384 if (p == NULL && s->reloc_count > 0)
2385 return false;
2386 memcpy (p, s->orelocation, (size_t) amt);
2387 qsort (p, s->reloc_count, sizeof (arelent *), compare_arelent_ptr);
2389 #endif
2391 if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0)
2392 return false;
2394 #ifdef COFF_WITH_PE
2395 if (obj_pe (abfd) && s->reloc_count >= 0xffff)
2397 /* encode real count here as first reloc */
2398 struct internal_reloc n;
2399 memset ((PTR) & n, 0, sizeof (n));
2400 /* add one to count *this* reloc (grr) */
2401 n.r_vaddr = s->reloc_count + 1;
2402 coff_swap_reloc_out (abfd, &n, &dst);
2403 if (bfd_bwrite ((PTR) & dst, (bfd_size_type) bfd_coff_relsz (abfd),
2404 abfd) != bfd_coff_relsz (abfd))
2405 return false;
2407 #endif
2409 for (i = 0; i < s->reloc_count; i++)
2411 struct internal_reloc n;
2412 arelent *q = p[i];
2413 memset ((PTR) & n, 0, sizeof (n));
2415 /* Now we've renumbered the symbols we know where the
2416 undefined symbols live in the table. Check the reloc
2417 entries for symbols who's output bfd isn't the right one.
2418 This is because the symbol was undefined (which means
2419 that all the pointers are never made to point to the same
2420 place). This is a bad thing,'cause the symbols attached
2421 to the output bfd are indexed, so that the relocation
2422 entries know which symbol index they point to. So we
2423 have to look up the output symbol here. */
2425 if (q->sym_ptr_ptr[0]->the_bfd != abfd)
2427 int j;
2428 const char *sname = q->sym_ptr_ptr[0]->name;
2429 asymbol **outsyms = abfd->outsymbols;
2430 for (j = first_undef; outsyms[j]; j++)
2432 const char *intable = outsyms[j]->name;
2433 if (strcmp (intable, sname) == 0) {
2434 /* got a hit, so repoint the reloc */
2435 q->sym_ptr_ptr = outsyms + j;
2436 break;
2441 n.r_vaddr = q->address + s->vma;
2443 #ifdef R_IHCONST
2444 /* The 29k const/consth reloc pair is a real kludge. The consth
2445 part doesn't have a symbol; it has an offset. So rebuilt
2446 that here. */
2447 if (q->howto->type == R_IHCONST)
2448 n.r_symndx = q->addend;
2449 else
2450 #endif
2451 if (q->sym_ptr_ptr)
2453 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2454 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q,s))
2455 #else
2456 if ((*q->sym_ptr_ptr)->section == bfd_abs_section_ptr
2457 && ((*q->sym_ptr_ptr)->flags & BSF_SECTION_SYM) != 0)
2458 #endif
2459 /* This is a relocation relative to the absolute symbol. */
2460 n.r_symndx = -1;
2461 else
2463 n.r_symndx = get_index ((*(q->sym_ptr_ptr)));
2464 /* Take notice if the symbol reloc points to a symbol
2465 we don't have in our symbol table. What should we
2466 do for this?? */
2467 if (n.r_symndx > obj_conv_table_size (abfd))
2468 abort ();
2472 #ifdef SWAP_OUT_RELOC_OFFSET
2473 n.r_offset = q->addend;
2474 #endif
2476 #ifdef SELECT_RELOC
2477 /* Work out reloc type from what is required */
2478 SELECT_RELOC (n, q->howto);
2479 #else
2480 n.r_type = q->howto->type;
2481 #endif
2482 coff_swap_reloc_out (abfd, &n, &dst);
2483 if (bfd_bwrite ((PTR) & dst, (bfd_size_type) bfd_coff_relsz (abfd),
2484 abfd) != bfd_coff_relsz (abfd))
2485 return false;
2488 #ifdef TARG_AUX
2489 if (p != NULL)
2490 free (p);
2491 #endif
2494 return true;
2497 /* Set flags and magic number of a coff file from architecture and machine
2498 type. Result is true if we can represent the arch&type, false if not. */
2500 static boolean
2501 coff_set_flags (abfd, magicp, flagsp)
2502 bfd * abfd;
2503 unsigned int *magicp ATTRIBUTE_UNUSED;
2504 unsigned short *flagsp ATTRIBUTE_UNUSED;
2506 switch (bfd_get_arch (abfd))
2508 #ifdef Z8KMAGIC
2509 case bfd_arch_z8k:
2510 *magicp = Z8KMAGIC;
2511 switch (bfd_get_mach (abfd))
2513 case bfd_mach_z8001:
2514 *flagsp = F_Z8001;
2515 break;
2516 case bfd_mach_z8002:
2517 *flagsp = F_Z8002;
2518 break;
2519 default:
2520 return false;
2522 return true;
2523 #endif
2524 #ifdef I960ROMAGIC
2526 case bfd_arch_i960:
2529 unsigned flags;
2530 *magicp = I960ROMAGIC;
2532 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
2533 I960RWMAGIC); FIXME???
2535 switch (bfd_get_mach (abfd))
2537 case bfd_mach_i960_core:
2538 flags = F_I960CORE;
2539 break;
2540 case bfd_mach_i960_kb_sb:
2541 flags = F_I960KB;
2542 break;
2543 case bfd_mach_i960_mc:
2544 flags = F_I960MC;
2545 break;
2546 case bfd_mach_i960_xa:
2547 flags = F_I960XA;
2548 break;
2549 case bfd_mach_i960_ca:
2550 flags = F_I960CA;
2551 break;
2552 case bfd_mach_i960_ka_sa:
2553 flags = F_I960KA;
2554 break;
2555 case bfd_mach_i960_jx:
2556 flags = F_I960JX;
2557 break;
2558 case bfd_mach_i960_hx:
2559 flags = F_I960HX;
2560 break;
2561 default:
2562 return false;
2564 *flagsp = flags;
2565 return true;
2567 break;
2568 #endif
2570 #ifdef TIC30MAGIC
2571 case bfd_arch_tic30:
2572 *magicp = TIC30MAGIC;
2573 return true;
2574 #endif
2576 #ifdef TICOFF_DEFAULT_MAGIC
2577 case TICOFF_TARGET_ARCH:
2578 /* if there's no indication of which version we want, use the default */
2579 if (!abfd->xvec )
2580 *magicp = TICOFF_DEFAULT_MAGIC;
2581 else
2583 /* we may want to output in a different COFF version */
2584 switch (abfd->xvec->name[4])
2586 case '0':
2587 *magicp = TICOFF0MAGIC;
2588 break;
2589 case '1':
2590 *magicp = TICOFF1MAGIC;
2591 break;
2592 case '2':
2593 *magicp = TICOFF2MAGIC;
2594 break;
2595 default:
2596 return false;
2599 return true;
2600 #endif
2602 #ifdef TIC80_ARCH_MAGIC
2603 case bfd_arch_tic80:
2604 *magicp = TIC80_ARCH_MAGIC;
2605 return true;
2606 #endif
2607 #ifdef ARMMAGIC
2608 case bfd_arch_arm:
2609 #ifdef ARM_WINCE
2610 * magicp = ARMPEMAGIC;
2611 #else
2612 * magicp = ARMMAGIC;
2613 #endif
2614 * flagsp = 0;
2615 if (APCS_SET (abfd))
2617 if (APCS_26_FLAG (abfd))
2618 * flagsp |= F_APCS26;
2620 if (APCS_FLOAT_FLAG (abfd))
2621 * flagsp |= F_APCS_FLOAT;
2623 if (PIC_FLAG (abfd))
2624 * flagsp |= F_PIC;
2626 if (INTERWORK_SET (abfd) && INTERWORK_FLAG (abfd))
2627 * flagsp |= F_INTERWORK;
2628 switch (bfd_get_mach (abfd))
2630 case bfd_mach_arm_2: * flagsp |= F_ARM_2; break;
2631 case bfd_mach_arm_2a: * flagsp |= F_ARM_2a; break;
2632 case bfd_mach_arm_3: * flagsp |= F_ARM_3; break;
2633 case bfd_mach_arm_3M: * flagsp |= F_ARM_3M; break;
2634 case bfd_mach_arm_4: * flagsp |= F_ARM_4; break;
2635 case bfd_mach_arm_4T: * flagsp |= F_ARM_4T; break;
2636 case bfd_mach_arm_5: * flagsp |= F_ARM_5; break;
2637 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5.
2638 See also the comment in coff_set_arch_mach_hook(). */
2639 case bfd_mach_arm_5T: * flagsp |= F_ARM_5; break;
2640 case bfd_mach_arm_5TE: * flagsp |= F_ARM_5; break;
2641 case bfd_mach_arm_XScale: * flagsp |= F_ARM_5; break;
2643 return true;
2644 #endif
2645 #ifdef PPCMAGIC
2646 case bfd_arch_powerpc:
2647 *magicp = PPCMAGIC;
2648 return true;
2649 break;
2650 #endif
2651 #ifdef I386MAGIC
2652 case bfd_arch_i386:
2653 *magicp = I386MAGIC;
2654 #ifdef LYNXOS
2655 /* Just overwrite the usual value if we're doing Lynx. */
2656 *magicp = LYNXCOFFMAGIC;
2657 #endif
2658 return true;
2659 break;
2660 #endif
2661 #ifdef I860MAGIC
2662 case bfd_arch_i860:
2663 *magicp = I860MAGIC;
2664 return true;
2665 break;
2666 #endif
2667 #ifdef IA64MAGIC
2668 case bfd_arch_ia64:
2669 *magicp = IA64MAGIC;
2670 return true;
2671 break;
2672 #endif
2673 #ifdef MC68MAGIC
2674 case bfd_arch_m68k:
2675 #ifdef APOLLOM68KMAGIC
2676 *magicp = APOLLO_COFF_VERSION_NUMBER;
2677 #else
2678 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2679 #ifdef NAMES_HAVE_UNDERSCORE
2680 *magicp = MC68KBCSMAGIC;
2681 #else
2682 *magicp = MC68MAGIC;
2683 #endif
2684 #endif
2685 #ifdef LYNXOS
2686 /* Just overwrite the usual value if we're doing Lynx. */
2687 *magicp = LYNXCOFFMAGIC;
2688 #endif
2689 return true;
2690 break;
2691 #endif
2693 #ifdef MC88MAGIC
2694 case bfd_arch_m88k:
2695 *magicp = MC88OMAGIC;
2696 return true;
2697 break;
2698 #endif
2699 #ifdef H8300MAGIC
2700 case bfd_arch_h8300:
2701 switch (bfd_get_mach (abfd))
2703 case bfd_mach_h8300:
2704 *magicp = H8300MAGIC;
2705 return true;
2706 case bfd_mach_h8300h:
2707 *magicp = H8300HMAGIC;
2708 return true;
2709 case bfd_mach_h8300s:
2710 *magicp = H8300SMAGIC;
2711 return true;
2713 break;
2714 #endif
2716 #ifdef SH_ARCH_MAGIC_BIG
2717 case bfd_arch_sh:
2718 #ifdef COFF_IMAGE_WITH_PE
2719 *magicp = SH_ARCH_MAGIC_WINCE;
2720 #else
2721 if (bfd_big_endian (abfd))
2722 *magicp = SH_ARCH_MAGIC_BIG;
2723 else
2724 *magicp = SH_ARCH_MAGIC_LITTLE;
2725 #endif
2726 return true;
2727 break;
2728 #endif
2730 #ifdef MIPS_ARCH_MAGIC_WINCE
2731 case bfd_arch_mips:
2732 *magicp = MIPS_ARCH_MAGIC_WINCE;
2733 return true;
2734 break;
2735 #endif
2737 #ifdef SPARCMAGIC
2738 case bfd_arch_sparc:
2739 *magicp = SPARCMAGIC;
2740 #ifdef LYNXOS
2741 /* Just overwrite the usual value if we're doing Lynx. */
2742 *magicp = LYNXCOFFMAGIC;
2743 #endif
2744 return true;
2745 break;
2746 #endif
2748 #ifdef H8500MAGIC
2749 case bfd_arch_h8500:
2750 *magicp = H8500MAGIC;
2751 return true;
2752 break;
2753 #endif
2754 #ifdef A29K_MAGIC_BIG
2755 case bfd_arch_a29k:
2756 if (bfd_big_endian (abfd))
2757 *magicp = A29K_MAGIC_BIG;
2758 else
2759 *magicp = A29K_MAGIC_LITTLE;
2760 return true;
2761 break;
2762 #endif
2764 #ifdef WE32KMAGIC
2765 case bfd_arch_we32k:
2766 *magicp = WE32KMAGIC;
2767 return true;
2768 break;
2769 #endif
2771 #ifdef RS6000COFF_C
2772 case bfd_arch_rs6000:
2773 #ifndef PPCMAGIC
2774 case bfd_arch_powerpc:
2775 #endif
2776 BFD_ASSERT (bfd_get_flavour (abfd) == bfd_target_xcoff_flavour);
2777 *magicp = bfd_xcoff_magic_number (abfd);
2778 return true;
2779 break;
2780 #endif
2782 #ifdef MCOREMAGIC
2783 case bfd_arch_mcore:
2784 * magicp = MCOREMAGIC;
2785 return true;
2786 #endif
2788 #ifdef W65MAGIC
2789 case bfd_arch_w65:
2790 *magicp = W65MAGIC;
2791 return true;
2792 #endif
2794 #ifdef OR32_MAGIC_BIG
2795 case bfd_arch_or32:
2796 if (bfd_big_endian (abfd))
2797 * magicp = OR32_MAGIC_BIG;
2798 else
2799 * magicp = OR32_MAGIC_LITTLE;
2800 return true;
2801 #endif
2803 default: /* Unknown architecture. */
2804 /* Fall through to "return false" below, to avoid
2805 "statement never reached" errors on the one below. */
2806 break;
2809 return false;
2812 static boolean
2813 coff_set_arch_mach (abfd, arch, machine)
2814 bfd * abfd;
2815 enum bfd_architecture arch;
2816 unsigned long machine;
2818 unsigned dummy1;
2819 unsigned short dummy2;
2821 if (! bfd_default_set_arch_mach (abfd, arch, machine))
2822 return false;
2824 if (arch != bfd_arch_unknown
2825 && ! coff_set_flags (abfd, &dummy1, &dummy2))
2826 return false; /* We can't represent this type */
2828 return true; /* We're easy ... */
2831 #ifdef COFF_IMAGE_WITH_PE
2833 /* This is used to sort sections by VMA, as required by PE image
2834 files. */
2836 static int sort_by_secaddr PARAMS ((const PTR, const PTR));
2838 static int
2839 sort_by_secaddr (arg1, arg2)
2840 const PTR arg1;
2841 const PTR arg2;
2843 const asection *a = *(const asection **) arg1;
2844 const asection *b = *(const asection **) arg2;
2846 if (a->vma < b->vma)
2847 return -1;
2848 else if (a->vma > b->vma)
2849 return 1;
2850 else
2851 return 0;
2854 #endif /* COFF_IMAGE_WITH_PE */
2856 /* Calculate the file position for each section. */
2858 #ifndef I960
2859 #define ALIGN_SECTIONS_IN_FILE
2860 #endif
2861 #if defined(TIC80COFF) || defined(TICOFF)
2862 #undef ALIGN_SECTIONS_IN_FILE
2863 #endif
2865 static boolean
2866 coff_compute_section_file_positions (abfd)
2867 bfd * abfd;
2869 asection *current;
2870 asection *previous = (asection *) NULL;
2871 file_ptr sofar = bfd_coff_filhsz (abfd);
2872 boolean align_adjust;
2873 #ifdef ALIGN_SECTIONS_IN_FILE
2874 file_ptr old_sofar;
2875 #endif
2877 #ifdef RS6000COFF_C
2878 /* On XCOFF, if we have symbols, set up the .debug section. */
2879 if (bfd_get_symcount (abfd) > 0)
2881 bfd_size_type sz;
2882 bfd_size_type i, symcount;
2883 asymbol **symp;
2885 sz = 0;
2886 symcount = bfd_get_symcount (abfd);
2887 for (symp = abfd->outsymbols, i = 0; i < symcount; symp++, i++)
2889 coff_symbol_type *cf;
2891 cf = coff_symbol_from (abfd, *symp);
2892 if (cf != NULL
2893 && cf->native != NULL
2894 && SYMNAME_IN_DEBUG (&cf->native->u.syment))
2896 size_t len;
2898 len = strlen (bfd_asymbol_name (*symp));
2899 if (len > SYMNMLEN || bfd_coff_force_symnames_in_strings (abfd))
2900 sz += len + 1 + bfd_coff_debug_string_prefix_length (abfd);
2903 if (sz > 0)
2905 asection *dsec;
2907 dsec = bfd_make_section_old_way (abfd, ".debug");
2908 if (dsec == NULL)
2909 abort ();
2910 dsec->_raw_size = sz;
2911 dsec->flags |= SEC_HAS_CONTENTS;
2914 #endif
2916 #ifdef COFF_IMAGE_WITH_PE
2917 int page_size;
2918 if (coff_data (abfd)->link_info)
2920 page_size = pe_data (abfd)->pe_opthdr.FileAlignment;
2922 else
2923 page_size = PE_DEF_FILE_ALIGNMENT;
2924 #else
2925 #ifdef COFF_PAGE_SIZE
2926 int page_size = COFF_PAGE_SIZE;
2927 #endif
2928 #endif
2930 if (bfd_get_start_address (abfd))
2932 /* A start address may have been added to the original file. In this
2933 case it will need an optional header to record it. */
2934 abfd->flags |= EXEC_P;
2937 if (abfd->flags & EXEC_P)
2938 sofar += bfd_coff_aoutsz (abfd);
2939 #ifdef RS6000COFF_C
2940 else if (xcoff_data (abfd)->full_aouthdr)
2941 sofar += bfd_coff_aoutsz (abfd);
2942 else
2943 sofar += SMALL_AOUTSZ;
2944 #endif
2946 sofar += abfd->section_count * bfd_coff_scnhsz (abfd);
2948 #ifdef RS6000COFF_C
2949 /* XCOFF handles overflows in the reloc and line number count fields
2950 by allocating a new section header to hold the correct counts. */
2951 for (current = abfd->sections; current != NULL; current = current->next)
2952 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
2953 sofar += bfd_coff_scnhsz (abfd);
2954 #endif
2956 #ifdef COFF_IMAGE_WITH_PE
2958 /* PE requires the sections to be in memory order when listed in
2959 the section headers. It also does not like empty loadable
2960 sections. The sections apparently do not have to be in the
2961 right order in the image file itself, but we do need to get the
2962 target_index values right. */
2964 unsigned int count;
2965 asection **section_list;
2966 unsigned int i;
2967 int target_index;
2968 bfd_size_type amt;
2970 count = 0;
2971 for (current = abfd->sections; current != NULL; current = current->next)
2972 ++count;
2974 /* We allocate an extra cell to simplify the final loop. */
2975 amt = sizeof (struct asection *) * (count + 1);
2976 section_list = bfd_malloc (amt);
2977 if (section_list == NULL)
2978 return false;
2980 i = 0;
2981 for (current = abfd->sections; current != NULL; current = current->next)
2983 section_list[i] = current;
2984 ++i;
2986 section_list[i] = NULL;
2988 qsort (section_list, count, sizeof (asection *), sort_by_secaddr);
2990 /* Rethread the linked list into sorted order; at the same time,
2991 assign target_index values. */
2992 target_index = 1;
2993 abfd->sections = section_list[0];
2994 for (i = 0; i < count; i++)
2996 current = section_list[i];
2997 current->next = section_list[i + 1];
2999 /* Later, if the section has zero size, we'll be throwing it
3000 away, so we don't want to number it now. Note that having
3001 a zero size and having real contents are different
3002 concepts: .bss has no contents, but (usually) non-zero
3003 size. */
3004 if (current->_raw_size == 0)
3006 /* Discard. However, it still might have (valid) symbols
3007 in it, so arbitrarily set it to section 1 (indexing is
3008 1-based here; usually .text). __end__ and other
3009 contents of .endsection really have this happen.
3010 FIXME: This seems somewhat dubious. */
3011 current->target_index = 1;
3013 else
3014 current->target_index = target_index++;
3016 abfd->section_tail = &current->next;
3018 free (section_list);
3020 #else /* ! COFF_IMAGE_WITH_PE */
3022 /* Set the target_index field. */
3023 int target_index;
3025 target_index = 1;
3026 for (current = abfd->sections; current != NULL; current = current->next)
3027 current->target_index = target_index++;
3029 #endif /* ! COFF_IMAGE_WITH_PE */
3031 align_adjust = false;
3032 for (current = abfd->sections;
3033 current != (asection *) NULL;
3034 current = current->next)
3036 #ifdef COFF_IMAGE_WITH_PE
3037 /* With PE we have to pad each section to be a multiple of its
3038 page size too, and remember both sizes. */
3039 if (coff_section_data (abfd, current) == NULL)
3041 bfd_size_type amt = sizeof (struct coff_section_tdata);
3042 current->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
3043 if (current->used_by_bfd == NULL)
3044 return false;
3046 if (pei_section_data (abfd, current) == NULL)
3048 bfd_size_type amt = sizeof (struct pei_section_tdata);
3049 coff_section_data (abfd, current)->tdata
3050 = (PTR) bfd_zalloc (abfd, amt);
3051 if (coff_section_data (abfd, current)->tdata == NULL)
3052 return false;
3054 if (pei_section_data (abfd, current)->virt_size == 0)
3055 pei_section_data (abfd, current)->virt_size = current->_raw_size;
3056 #endif
3058 /* Only deal with sections which have contents. */
3059 if (!(current->flags & SEC_HAS_CONTENTS))
3060 continue;
3062 #ifdef COFF_IMAGE_WITH_PE
3063 /* Make sure we skip empty sections in a PE image. */
3064 if (current->_raw_size == 0)
3065 continue;
3066 #endif
3068 /* Align the sections in the file to the same boundary on
3069 which they are aligned in virtual memory. I960 doesn't
3070 do this (FIXME) so we can stay in sync with Intel. 960
3071 doesn't yet page from files... */
3072 #ifdef ALIGN_SECTIONS_IN_FILE
3073 if ((abfd->flags & EXEC_P) != 0)
3075 /* make sure this section is aligned on the right boundary - by
3076 padding the previous section up if necessary */
3078 old_sofar = sofar;
3079 #ifdef RS6000COFF_C
3080 /* AIX loader checks the text section alignment of (vma - filepos)
3081 So even though the filepos may be aligned wrt the o_algntext, for
3082 AIX executables, this check fails. This shows up when an native
3083 AIX executable is stripped with gnu strip because the default vma
3084 of native is 0x10000150 but default for gnu is 0x10000140. Gnu
3085 stripped gnu excutable passes this check because the filepos is
3086 0x0140. This problem also show up with 64 bit shared objects. The
3087 data section must also be aligned. */
3088 if (!strcmp (current->name, _TEXT)
3089 || !strcmp (current->name, _DATA))
3091 bfd_vma pad;
3092 bfd_vma align;
3094 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3096 align = 1 << current->alignment_power;
3097 pad = abs (current->vma - sofar) % align;
3099 if (pad)
3101 pad = align - pad;
3102 sofar += pad;
3105 else
3106 #else
3108 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3110 #endif
3111 if (previous != (asection *) NULL)
3113 previous->_raw_size += sofar - old_sofar;
3117 #endif
3119 /* In demand paged files the low order bits of the file offset
3120 must match the low order bits of the virtual address. */
3121 #ifdef COFF_PAGE_SIZE
3122 if ((abfd->flags & D_PAGED) != 0
3123 && (current->flags & SEC_ALLOC) != 0)
3124 sofar += (current->vma - sofar) % page_size;
3125 #endif
3126 current->filepos = sofar;
3128 #ifdef COFF_IMAGE_WITH_PE
3129 /* Set the padded size. */
3130 current->_raw_size = (current->_raw_size + page_size -1) & -page_size;
3131 #endif
3133 sofar += current->_raw_size;
3135 #ifdef ALIGN_SECTIONS_IN_FILE
3136 /* make sure that this section is of the right size too */
3137 if ((abfd->flags & EXEC_P) == 0)
3139 bfd_size_type old_size;
3141 old_size = current->_raw_size;
3142 current->_raw_size = BFD_ALIGN (current->_raw_size,
3143 1 << current->alignment_power);
3144 align_adjust = current->_raw_size != old_size;
3145 sofar += current->_raw_size - old_size;
3147 else
3149 old_sofar = sofar;
3150 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3151 align_adjust = sofar != old_sofar;
3152 current->_raw_size += sofar - old_sofar;
3154 #endif
3156 #ifdef COFF_IMAGE_WITH_PE
3157 /* For PE we need to make sure we pad out to the aligned
3158 _raw_size, in case the caller only writes out data to the
3159 unaligned _raw_size. */
3160 if (pei_section_data (abfd, current)->virt_size < current->_raw_size)
3161 align_adjust = true;
3162 #endif
3164 #ifdef _LIB
3165 /* Force .lib sections to start at zero. The vma is then
3166 incremented in coff_set_section_contents. This is right for
3167 SVR3.2. */
3168 if (strcmp (current->name, _LIB) == 0)
3169 bfd_set_section_vma (abfd, current, 0);
3170 #endif
3172 previous = current;
3175 /* It is now safe to write to the output file. If we needed an
3176 alignment adjustment for the last section, then make sure that
3177 there is a byte at offset sofar. If there are no symbols and no
3178 relocs, then nothing follows the last section. If we don't force
3179 the last byte out, then the file may appear to be truncated. */
3180 if (align_adjust)
3182 bfd_byte b;
3184 b = 0;
3185 if (bfd_seek (abfd, sofar - 1, SEEK_SET) != 0
3186 || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
3187 return false;
3190 /* Make sure the relocations are aligned. We don't need to make
3191 sure that this byte exists, because it will only matter if there
3192 really are relocs. */
3193 sofar = BFD_ALIGN (sofar, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER);
3195 obj_relocbase (abfd) = sofar;
3196 abfd->output_has_begun = true;
3198 return true;
3201 #if 0
3203 /* This can never work, because it is called too late--after the
3204 section positions have been set. I can't figure out what it is
3205 for, so I am going to disable it--Ian Taylor 20 March 1996. */
3207 /* If .file, .text, .data, .bss symbols are missing, add them. */
3208 /* @@ Should we only be adding missing symbols, or overriding the aux
3209 values for existing section symbols? */
3210 static boolean
3211 coff_add_missing_symbols (abfd)
3212 bfd *abfd;
3214 unsigned int nsyms = bfd_get_symcount (abfd);
3215 asymbol **sympp = abfd->outsymbols;
3216 asymbol **sympp2;
3217 unsigned int i;
3218 int need_text = 1, need_data = 1, need_bss = 1, need_file = 1;
3219 bfd_size_type amt;
3221 for (i = 0; i < nsyms; i++)
3223 coff_symbol_type *csym = coff_symbol_from (abfd, sympp[i]);
3224 const char *name;
3225 if (csym)
3227 /* only do this if there is a coff representation of the input
3228 symbol */
3229 if (csym->native && csym->native->u.syment.n_sclass == C_FILE)
3231 need_file = 0;
3232 continue;
3234 name = csym->symbol.name;
3235 if (!name)
3236 continue;
3237 if (!strcmp (name, _TEXT))
3238 need_text = 0;
3239 #ifdef APOLLO_M68
3240 else if (!strcmp (name, ".wtext"))
3241 need_text = 0;
3242 #endif
3243 else if (!strcmp (name, _DATA))
3244 need_data = 0;
3245 else if (!strcmp (name, _BSS))
3246 need_bss = 0;
3249 /* Now i == bfd_get_symcount (abfd). */
3250 /* @@ For now, don't deal with .file symbol. */
3251 need_file = 0;
3253 if (!need_text && !need_data && !need_bss && !need_file)
3254 return true;
3255 nsyms += need_text + need_data + need_bss + need_file;
3256 amt = nsyms;
3257 amt *= sizeof (asymbol *);
3258 sympp2 = (asymbol **) bfd_alloc (abfd, amt);
3259 if (!sympp2)
3260 return false;
3261 memcpy (sympp2, sympp, i * sizeof (asymbol *));
3262 if (need_file)
3264 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
3265 abort ();
3267 if (need_text)
3268 sympp2[i++] = coff_section_symbol (abfd, _TEXT);
3269 if (need_data)
3270 sympp2[i++] = coff_section_symbol (abfd, _DATA);
3271 if (need_bss)
3272 sympp2[i++] = coff_section_symbol (abfd, _BSS);
3273 BFD_ASSERT (i == nsyms);
3274 bfd_set_symtab (abfd, sympp2, nsyms);
3275 return true;
3278 #endif /* 0 */
3280 #ifdef COFF_IMAGE_WITH_PE
3282 static unsigned int pelength;
3283 static unsigned int peheader;
3285 static boolean
3286 coff_read_word (abfd, value)
3287 bfd *abfd;
3288 unsigned int *value;
3290 unsigned char b[2];
3291 int status;
3293 status = bfd_bread (b, (bfd_size_type) 2, abfd);
3294 if (status < 1)
3296 *value = 0;
3297 return false;
3300 if (status == 1)
3301 *value = (unsigned int) b[0];
3302 else
3303 *value = (unsigned int) (b[0] + (b[1] << 8));
3305 pelength += (unsigned int) status;
3307 return true;
3310 static unsigned int
3311 coff_compute_checksum (abfd)
3312 bfd *abfd;
3314 boolean more_data;
3315 file_ptr filepos;
3316 unsigned int value;
3317 unsigned int total;
3319 total = 0;
3320 pelength = 0;
3321 filepos = (file_ptr) 0;
3325 if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
3326 return 0;
3328 more_data = coff_read_word (abfd, &value);
3329 total += value;
3330 total = 0xffff & (total + (total >> 0x10));
3331 filepos += 2;
3333 while (more_data);
3335 return (0xffff & (total + (total >> 0x10)));
3338 static boolean
3339 coff_apply_checksum (abfd)
3340 bfd *abfd;
3342 unsigned int computed;
3343 unsigned int checksum = 0;
3345 if (bfd_seek (abfd, 0x3c, SEEK_SET) != 0)
3346 return false;
3348 if (!coff_read_word (abfd, &peheader))
3349 return false;
3351 if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0)
3352 return false;
3354 checksum = 0;
3355 bfd_bwrite (&checksum, (bfd_size_type) 4, abfd);
3357 if (bfd_seek (abfd, peheader, SEEK_SET) != 0)
3358 return false;
3360 computed = coff_compute_checksum (abfd);
3362 checksum = computed + pelength;
3364 if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0)
3365 return false;
3367 bfd_bwrite (&checksum, (bfd_size_type) 4, abfd);
3369 return true;
3372 #endif /* COFF_IMAGE_WITH_PE */
3374 /* SUPPRESS 558 */
3375 /* SUPPRESS 529 */
3376 static boolean
3377 coff_write_object_contents (abfd)
3378 bfd * abfd;
3380 asection *current;
3381 boolean hasrelocs = false;
3382 boolean haslinno = false;
3383 boolean hasdebug = false;
3384 file_ptr scn_base;
3385 file_ptr reloc_base;
3386 file_ptr lineno_base;
3387 file_ptr sym_base;
3388 unsigned long reloc_size = 0, reloc_count = 0;
3389 unsigned long lnno_size = 0;
3390 boolean long_section_names;
3391 asection *text_sec = NULL;
3392 asection *data_sec = NULL;
3393 asection *bss_sec = NULL;
3394 struct internal_filehdr internal_f;
3395 struct internal_aouthdr internal_a;
3396 #ifdef COFF_LONG_SECTION_NAMES
3397 size_t string_size = STRING_SIZE_SIZE;
3398 #endif
3400 bfd_set_error (bfd_error_system_call);
3402 /* Make a pass through the symbol table to count line number entries and
3403 put them into the correct asections */
3405 lnno_size = coff_count_linenumbers (abfd) * bfd_coff_linesz (abfd);
3407 if (! abfd->output_has_begun)
3409 if (! coff_compute_section_file_positions (abfd))
3410 return false;
3413 reloc_base = obj_relocbase (abfd);
3415 /* Work out the size of the reloc and linno areas */
3417 for (current = abfd->sections; current != NULL; current =
3418 current->next)
3420 #ifdef COFF_WITH_PE
3421 /* we store the actual reloc count in the first reloc's addr */
3422 if (obj_pe (abfd) && current->reloc_count >= 0xffff)
3423 reloc_count ++;
3424 #endif
3425 reloc_count += current->reloc_count;
3428 reloc_size = reloc_count * bfd_coff_relsz (abfd);
3430 lineno_base = reloc_base + reloc_size;
3431 sym_base = lineno_base + lnno_size;
3433 /* Indicate in each section->line_filepos its actual file address */
3434 for (current = abfd->sections; current != NULL; current =
3435 current->next)
3437 if (current->lineno_count)
3439 current->line_filepos = lineno_base;
3440 current->moving_line_filepos = lineno_base;
3441 lineno_base += current->lineno_count * bfd_coff_linesz (abfd);
3443 else
3445 current->line_filepos = 0;
3447 if (current->reloc_count)
3449 current->rel_filepos = reloc_base;
3450 reloc_base += current->reloc_count * bfd_coff_relsz (abfd);
3451 #ifdef COFF_WITH_PE
3452 /* extra reloc to hold real count */
3453 if (obj_pe (abfd) && current->reloc_count >= 0xffff)
3454 reloc_base += bfd_coff_relsz (abfd);
3455 #endif
3457 else
3459 current->rel_filepos = 0;
3463 /* Write section headers to the file. */
3464 internal_f.f_nscns = 0;
3466 if ((abfd->flags & EXEC_P) != 0)
3467 scn_base = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
3468 else
3470 scn_base = bfd_coff_filhsz (abfd);
3471 #ifdef RS6000COFF_C
3472 #ifndef XCOFF64
3473 if (xcoff_data (abfd)->full_aouthdr)
3474 scn_base += bfd_coff_aoutsz (abfd);
3475 else
3476 scn_base += SMALL_AOUTSZ;
3477 #endif
3478 #endif
3481 if (bfd_seek (abfd, scn_base, SEEK_SET) != 0)
3482 return false;
3484 long_section_names = false;
3485 for (current = abfd->sections;
3486 current != NULL;
3487 current = current->next)
3489 struct internal_scnhdr section;
3490 boolean is_reloc_section = false;
3492 #ifdef COFF_IMAGE_WITH_PE
3493 if (strcmp (current->name, ".reloc") == 0)
3495 is_reloc_section = true;
3496 hasrelocs = true;
3497 pe_data (abfd)->has_reloc_section = 1;
3499 #endif
3501 internal_f.f_nscns++;
3503 strncpy (section.s_name, current->name, SCNNMLEN);
3505 #ifdef COFF_LONG_SECTION_NAMES
3506 /* Handle long section names as in PE. This must be compatible
3507 with the code in coff_write_symbols and _bfd_coff_final_link. */
3509 size_t len;
3511 len = strlen (current->name);
3512 if (len > SCNNMLEN)
3514 memset (section.s_name, 0, SCNNMLEN);
3515 sprintf (section.s_name, "/%lu", (unsigned long) string_size);
3516 string_size += len + 1;
3517 long_section_names = true;
3520 #endif
3522 #ifdef _LIB
3523 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3524 Ian Taylor <ian@cygnus.com>. */
3525 if (strcmp (current->name, _LIB) == 0)
3526 section.s_vaddr = 0;
3527 else
3528 #endif
3529 section.s_vaddr = current->vma;
3530 section.s_paddr = current->lma;
3531 section.s_size = current->_raw_size;
3532 #ifdef coff_get_section_load_page
3533 section.s_page = coff_get_section_load_page (current);
3534 #endif
3536 #ifdef COFF_WITH_PE
3537 section.s_paddr = 0;
3538 #endif
3539 #ifdef COFF_IMAGE_WITH_PE
3540 /* Reminder: s_paddr holds the virtual size of the section. */
3541 if (coff_section_data (abfd, current) != NULL
3542 && pei_section_data (abfd, current) != NULL)
3543 section.s_paddr = pei_section_data (abfd, current)->virt_size;
3544 else
3545 section.s_paddr = 0;
3546 #endif
3549 If this section has no size or is unloadable then the scnptr
3550 will be 0 too
3552 if (current->_raw_size == 0 ||
3553 (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
3555 section.s_scnptr = 0;
3557 else
3559 section.s_scnptr = current->filepos;
3561 section.s_relptr = current->rel_filepos;
3562 section.s_lnnoptr = current->line_filepos;
3563 section.s_nreloc = current->reloc_count;
3564 section.s_nlnno = current->lineno_count;
3565 #ifndef COFF_IMAGE_WITH_PE
3566 /* In PEI, relocs come in the .reloc section. */
3567 if (current->reloc_count != 0)
3568 hasrelocs = true;
3569 #endif
3570 if (current->lineno_count != 0)
3571 haslinno = true;
3572 if ((current->flags & SEC_DEBUGGING) != 0
3573 && ! is_reloc_section)
3574 hasdebug = true;
3576 #ifdef RS6000COFF_C
3577 #ifndef XCOFF64
3578 /* Indicate the use of an XCOFF overflow section header. */
3579 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3581 section.s_nreloc = 0xffff;
3582 section.s_nlnno = 0xffff;
3584 #endif
3585 #endif
3587 section.s_flags = sec_to_styp_flags (current->name, current->flags);
3589 if (!strcmp (current->name, _TEXT))
3591 text_sec = current;
3593 else if (!strcmp (current->name, _DATA))
3595 data_sec = current;
3597 else if (!strcmp (current->name, _BSS))
3599 bss_sec = current;
3602 #ifdef I960
3603 section.s_align = (current->alignment_power
3604 ? 1 << current->alignment_power
3605 : 0);
3606 #endif
3607 #ifdef TIC80COFF
3608 /* TI COFF puts the alignment power in bits 8-11 of the flags */
3609 section.s_flags |= (current->alignment_power & 0xF) << 8;
3610 #endif
3611 #ifdef COFF_ENCODE_ALIGNMENT
3612 COFF_ENCODE_ALIGNMENT(section, current->alignment_power);
3613 #endif
3615 #ifdef COFF_IMAGE_WITH_PE
3616 /* Suppress output of the sections if they are null. ld
3617 includes the bss and data sections even if there is no size
3618 assigned to them. NT loader doesn't like it if these section
3619 headers are included if the sections themselves are not
3620 needed. See also coff_compute_section_file_positions. */
3621 if (section.s_size == 0)
3622 internal_f.f_nscns--;
3623 else
3624 #endif
3626 SCNHDR buff;
3627 bfd_size_type amt = bfd_coff_scnhsz (abfd);
3629 if (coff_swap_scnhdr_out (abfd, &section, &buff) == 0
3630 || bfd_bwrite ((PTR) &buff, amt, abfd) != amt)
3631 return false;
3634 #ifdef COFF_WITH_PE
3635 /* PE stores COMDAT section information in the symbol table. If
3636 this section is supposed to have some COMDAT info, track down
3637 the symbol in the symbol table and modify it. */
3638 if ((current->flags & SEC_LINK_ONCE) != 0)
3640 unsigned int i, count;
3641 asymbol **psym;
3642 coff_symbol_type *csym = NULL;
3643 asymbol **psymsec;
3645 psymsec = NULL;
3646 count = bfd_get_symcount (abfd);
3647 for (i = 0, psym = abfd->outsymbols; i < count; i++, psym++)
3649 if ((*psym)->section != current)
3650 continue;
3652 /* Remember the location of the first symbol in this
3653 section. */
3654 if (psymsec == NULL)
3655 psymsec = psym;
3657 /* See if this is the section symbol. */
3658 if (strcmp ((*psym)->name, current->name) == 0)
3660 csym = coff_symbol_from (abfd, *psym);
3661 if (csym == NULL
3662 || csym->native == NULL
3663 || csym->native->u.syment.n_numaux < 1
3664 || csym->native->u.syment.n_sclass != C_STAT
3665 || csym->native->u.syment.n_type != T_NULL)
3666 continue;
3668 /* Here *PSYM is the section symbol for CURRENT. */
3670 break;
3674 /* Did we find it?
3675 Note that we might not if we're converting the file from
3676 some other object file format. */
3677 if (i < count)
3679 combined_entry_type *aux;
3681 /* We don't touch the x_checksum field. The
3682 x_associated field is not currently supported. */
3684 aux = csym->native + 1;
3685 switch (current->flags & SEC_LINK_DUPLICATES)
3687 case SEC_LINK_DUPLICATES_DISCARD:
3688 aux->u.auxent.x_scn.x_comdat = IMAGE_COMDAT_SELECT_ANY;
3689 break;
3691 case SEC_LINK_DUPLICATES_ONE_ONLY:
3692 aux->u.auxent.x_scn.x_comdat =
3693 IMAGE_COMDAT_SELECT_NODUPLICATES;
3694 break;
3696 case SEC_LINK_DUPLICATES_SAME_SIZE:
3697 aux->u.auxent.x_scn.x_comdat =
3698 IMAGE_COMDAT_SELECT_SAME_SIZE;
3699 break;
3701 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
3702 aux->u.auxent.x_scn.x_comdat =
3703 IMAGE_COMDAT_SELECT_EXACT_MATCH;
3704 break;
3707 /* The COMDAT symbol must be the first symbol from this
3708 section in the symbol table. In order to make this
3709 work, we move the COMDAT symbol before the first
3710 symbol we found in the search above. It's OK to
3711 rearrange the symbol table at this point, because
3712 coff_renumber_symbols is going to rearrange it
3713 further and fix up all the aux entries. */
3714 if (psym != psymsec)
3716 asymbol *hold;
3717 asymbol **pcopy;
3719 hold = *psym;
3720 for (pcopy = psym; pcopy > psymsec; pcopy--)
3721 pcopy[0] = pcopy[-1];
3722 *psymsec = hold;
3726 #endif /* COFF_WITH_PE */
3729 #ifdef RS6000COFF_C
3730 #ifndef XCOFF64
3731 /* XCOFF handles overflows in the reloc and line number count fields
3732 by creating a new section header to hold the correct values. */
3733 for (current = abfd->sections; current != NULL; current = current->next)
3735 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3737 struct internal_scnhdr scnhdr;
3738 SCNHDR buff;
3739 bfd_size_type amt;
3741 internal_f.f_nscns++;
3742 strncpy (&(scnhdr.s_name[0]), current->name, 8);
3743 scnhdr.s_paddr = current->reloc_count;
3744 scnhdr.s_vaddr = current->lineno_count;
3745 scnhdr.s_size = 0;
3746 scnhdr.s_scnptr = 0;
3747 scnhdr.s_relptr = current->rel_filepos;
3748 scnhdr.s_lnnoptr = current->line_filepos;
3749 scnhdr.s_nreloc = current->target_index;
3750 scnhdr.s_nlnno = current->target_index;
3751 scnhdr.s_flags = STYP_OVRFLO;
3752 amt = bfd_coff_scnhsz (abfd);
3753 if (coff_swap_scnhdr_out (abfd, &scnhdr, &buff) == 0
3754 || bfd_bwrite ((PTR) &buff, amt, abfd) != amt)
3755 return false;
3758 #endif
3759 #endif
3761 /* OK, now set up the filehdr... */
3763 /* Don't include the internal abs section in the section count */
3766 We will NOT put a fucking timestamp in the header here. Every time you
3767 put it back, I will come in and take it out again. I'm sorry. This
3768 field does not belong here. We fill it with a 0 so it compares the
3769 same but is not a reasonable time. -- gnu@cygnus.com
3771 internal_f.f_timdat = 0;
3773 internal_f.f_flags = 0;
3775 if (abfd->flags & EXEC_P)
3776 internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
3777 else
3779 internal_f.f_opthdr = 0;
3780 #ifdef RS6000COFF_C
3781 #ifndef XCOFF64
3782 if (xcoff_data (abfd)->full_aouthdr)
3783 internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
3784 else
3785 internal_f.f_opthdr = SMALL_AOUTSZ;
3786 #endif
3787 #endif
3790 if (!hasrelocs)
3791 internal_f.f_flags |= F_RELFLG;
3792 if (!haslinno)
3793 internal_f.f_flags |= F_LNNO;
3794 if (abfd->flags & EXEC_P)
3795 internal_f.f_flags |= F_EXEC;
3796 #ifdef COFF_IMAGE_WITH_PE
3797 if (! hasdebug)
3798 internal_f.f_flags |= IMAGE_FILE_DEBUG_STRIPPED;
3799 #endif
3801 #ifndef COFF_WITH_PE
3802 if (bfd_little_endian (abfd))
3803 internal_f.f_flags |= F_AR32WR;
3804 else
3805 internal_f.f_flags |= F_AR32W;
3806 #endif
3808 #ifdef TI_TARGET_ID
3809 /* target id is used in TI COFF v1 and later; COFF0 won't use this field,
3810 but it doesn't hurt to set it internally */
3811 internal_f.f_target_id = TI_TARGET_ID;
3812 #endif
3813 #ifdef TIC80_TARGET_ID
3814 internal_f.f_target_id = TIC80_TARGET_ID;
3815 #endif
3818 FIXME, should do something about the other byte orders and
3819 architectures.
3822 #ifdef RS6000COFF_C
3823 if ((abfd->flags & DYNAMIC) != 0)
3824 internal_f.f_flags |= F_SHROBJ;
3825 if (bfd_get_section_by_name (abfd, _LOADER) != NULL)
3826 internal_f.f_flags |= F_DYNLOAD;
3827 #endif
3829 memset (&internal_a, 0, sizeof internal_a);
3831 /* Set up architecture-dependent stuff */
3834 unsigned int magic = 0;
3835 unsigned short flags = 0;
3836 coff_set_flags (abfd, &magic, &flags);
3837 internal_f.f_magic = magic;
3838 internal_f.f_flags |= flags;
3839 /* ...and the "opt"hdr... */
3841 #ifdef A29K
3842 #ifdef ULTRA3 /* NYU's machine */
3843 /* FIXME: This is a bogus check. I really want to see if there
3844 * is a .shbss or a .shdata section, if so then set the magic
3845 * number to indicate a shared data executable.
3847 if (internal_f.f_nscns >= 7)
3848 internal_a.magic = SHMAGIC; /* Shared magic */
3849 else
3850 #endif /* ULTRA3 */
3851 internal_a.magic = NMAGIC; /* Assume separate i/d */
3852 #define __A_MAGIC_SET__
3853 #endif /* A29K */
3854 #ifdef TICOFF_AOUT_MAGIC
3855 internal_a.magic = TICOFF_AOUT_MAGIC;
3856 #define __A_MAGIC_SET__
3857 #endif
3858 #ifdef TIC80COFF
3859 internal_a.magic = TIC80_ARCH_MAGIC;
3860 #define __A_MAGIC_SET__
3861 #endif /* TIC80 */
3862 #ifdef I860
3863 /* FIXME: What are the a.out magic numbers for the i860? */
3864 internal_a.magic = 0;
3865 #define __A_MAGIC_SET__
3866 #endif /* I860 */
3867 #ifdef I960
3868 internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
3869 #define __A_MAGIC_SET__
3870 #endif /* I960 */
3871 #if M88
3872 #define __A_MAGIC_SET__
3873 internal_a.magic = PAGEMAGICBCS;
3874 #endif /* M88 */
3876 #if APOLLO_M68
3877 #define __A_MAGIC_SET__
3878 internal_a.magic = APOLLO_COFF_VERSION_NUMBER;
3879 #endif
3881 #if defined(M68) || defined(WE32K) || defined(M68K)
3882 #define __A_MAGIC_SET__
3883 #if defined(LYNXOS)
3884 internal_a.magic = LYNXCOFFMAGIC;
3885 #else
3886 #if defined(TARG_AUX)
3887 internal_a.magic = (abfd->flags & D_PAGED ? PAGEMAGICPEXECPAGED :
3888 abfd->flags & WP_TEXT ? PAGEMAGICPEXECSWAPPED :
3889 PAGEMAGICEXECSWAPPED);
3890 #else
3891 #if defined (PAGEMAGICPEXECPAGED)
3892 internal_a.magic = PAGEMAGICPEXECPAGED;
3893 #endif
3894 #endif /* TARG_AUX */
3895 #endif /* LYNXOS */
3896 #endif /* M68 || WE32K || M68K */
3898 #if defined(ARM)
3899 #define __A_MAGIC_SET__
3900 internal_a.magic = ZMAGIC;
3901 #endif
3903 #if defined(PPC_PE)
3904 #define __A_MAGIC_SET__
3905 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
3906 #endif
3908 #if defined MCORE_PE
3909 #define __A_MAGIC_SET__
3910 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
3911 #endif
3913 #if defined(I386)
3914 #define __A_MAGIC_SET__
3915 #if defined(LYNXOS)
3916 internal_a.magic = LYNXCOFFMAGIC;
3917 #else /* LYNXOS */
3918 internal_a.magic = ZMAGIC;
3919 #endif /* LYNXOS */
3920 #endif /* I386 */
3922 #if defined(IA64)
3923 #define __A_MAGIC_SET__
3924 internal_a.magic = ZMAGIC;
3925 #endif /* IA64 */
3927 #if defined(SPARC)
3928 #define __A_MAGIC_SET__
3929 #if defined(LYNXOS)
3930 internal_a.magic = LYNXCOFFMAGIC;
3931 #endif /* LYNXOS */
3932 #endif /* SPARC */
3934 #ifdef RS6000COFF_C
3935 #define __A_MAGIC_SET__
3936 internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC :
3937 (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC :
3938 RS6K_AOUTHDR_OMAGIC;
3939 #endif
3941 #if defined(SH) && defined(COFF_WITH_PE)
3942 #define __A_MAGIC_SET__
3943 internal_a.magic = SH_PE_MAGIC;
3944 #endif
3946 #if defined(MIPS) && defined(COFF_WITH_PE)
3947 #define __A_MAGIC_SET__
3948 internal_a.magic = MIPS_PE_MAGIC;
3949 #endif
3951 #ifdef OR32
3952 #define __A_MAGIC_SET__
3953 internal_a.magic = NMAGIC; /* Assume separate i/d. */
3954 #endif
3956 #ifndef __A_MAGIC_SET__
3957 #include "Your aouthdr magic number is not being set!"
3958 #else
3959 #undef __A_MAGIC_SET__
3960 #endif
3963 /* FIXME: Does anybody ever set this to another value? */
3964 internal_a.vstamp = 0;
3966 /* Now should write relocs, strings, syms */
3967 obj_sym_filepos (abfd) = sym_base;
3969 if (bfd_get_symcount (abfd) != 0)
3971 int firstundef;
3972 #if 0
3973 if (!coff_add_missing_symbols (abfd))
3974 return false;
3975 #endif
3976 if (!coff_renumber_symbols (abfd, &firstundef))
3977 return false;
3978 coff_mangle_symbols (abfd);
3979 if (! coff_write_symbols (abfd))
3980 return false;
3981 if (! coff_write_linenumbers (abfd))
3982 return false;
3983 if (! coff_write_relocs (abfd, firstundef))
3984 return false;
3986 #ifdef COFF_LONG_SECTION_NAMES
3987 else if (long_section_names && ! obj_coff_strings_written (abfd))
3989 /* If we have long section names we have to write out the string
3990 table even if there are no symbols. */
3991 if (! coff_write_symbols (abfd))
3992 return false;
3994 #endif
3995 #ifdef COFF_IMAGE_WITH_PE
3996 #ifdef PPC_PE
3997 else if ((abfd->flags & EXEC_P) != 0)
3999 bfd_byte b;
4001 /* PowerPC PE appears to require that all executable files be
4002 rounded up to the page size. */
4003 b = 0;
4004 if (bfd_seek (abfd,
4005 (file_ptr) BFD_ALIGN (sym_base, COFF_PAGE_SIZE) - 1,
4006 SEEK_SET) != 0
4007 || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
4008 return false;
4010 #endif
4011 #endif
4013 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
4014 backend linker, and obj_raw_syment_count is not valid until after
4015 coff_write_symbols is called. */
4016 if (obj_raw_syment_count (abfd) != 0)
4018 internal_f.f_symptr = sym_base;
4019 #ifdef RS6000COFF_C
4020 /* AIX appears to require that F_RELFLG not be set if there are
4021 local symbols but no relocations. */
4022 internal_f.f_flags &=~ F_RELFLG;
4023 #endif
4025 else
4027 if (long_section_names)
4028 internal_f.f_symptr = sym_base;
4029 else
4030 internal_f.f_symptr = 0;
4031 internal_f.f_flags |= F_LSYMS;
4034 if (text_sec)
4036 internal_a.tsize = bfd_get_section_size_before_reloc (text_sec);
4037 internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
4039 if (data_sec)
4041 internal_a.dsize = bfd_get_section_size_before_reloc (data_sec);
4042 internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
4044 if (bss_sec)
4046 internal_a.bsize = bfd_get_section_size_before_reloc (bss_sec);
4047 if (internal_a.bsize && bss_sec->vma < internal_a.data_start)
4048 internal_a.data_start = bss_sec->vma;
4051 internal_a.entry = bfd_get_start_address (abfd);
4052 internal_f.f_nsyms = obj_raw_syment_count (abfd);
4054 #ifdef RS6000COFF_C
4055 if (xcoff_data (abfd)->full_aouthdr)
4057 bfd_vma toc;
4058 asection *loader_sec;
4060 internal_a.vstamp = 1;
4062 internal_a.o_snentry = xcoff_data (abfd)->snentry;
4063 if (internal_a.o_snentry == 0)
4064 internal_a.entry = (bfd_vma) -1;
4066 if (text_sec != NULL)
4068 internal_a.o_sntext = text_sec->target_index;
4069 internal_a.o_algntext = bfd_get_section_alignment (abfd, text_sec);
4071 else
4073 internal_a.o_sntext = 0;
4074 internal_a.o_algntext = 0;
4076 if (data_sec != NULL)
4078 internal_a.o_sndata = data_sec->target_index;
4079 internal_a.o_algndata = bfd_get_section_alignment (abfd, data_sec);
4081 else
4083 internal_a.o_sndata = 0;
4084 internal_a.o_algndata = 0;
4086 loader_sec = bfd_get_section_by_name (abfd, ".loader");
4087 if (loader_sec != NULL)
4088 internal_a.o_snloader = loader_sec->target_index;
4089 else
4090 internal_a.o_snloader = 0;
4091 if (bss_sec != NULL)
4092 internal_a.o_snbss = bss_sec->target_index;
4093 else
4094 internal_a.o_snbss = 0;
4096 toc = xcoff_data (abfd)->toc;
4097 internal_a.o_toc = toc;
4098 internal_a.o_sntoc = xcoff_data (abfd)->sntoc;
4100 internal_a.o_modtype = xcoff_data (abfd)->modtype;
4101 if (xcoff_data (abfd)->cputype != -1)
4102 internal_a.o_cputype = xcoff_data (abfd)->cputype;
4103 else
4105 switch (bfd_get_arch (abfd))
4107 case bfd_arch_rs6000:
4108 internal_a.o_cputype = 4;
4109 break;
4110 case bfd_arch_powerpc:
4111 if (bfd_get_mach (abfd) == bfd_mach_ppc)
4112 internal_a.o_cputype = 3;
4113 else
4114 internal_a.o_cputype = 1;
4115 break;
4116 default:
4117 abort ();
4120 internal_a.o_maxstack = xcoff_data (abfd)->maxstack;
4121 internal_a.o_maxdata = xcoff_data (abfd)->maxdata;
4123 #endif
4125 /* now write them */
4126 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
4127 return false;
4130 char * buff;
4131 bfd_size_type amount = bfd_coff_filhsz (abfd);
4133 buff = bfd_malloc (amount);
4134 if (buff == NULL)
4135 return false;
4137 bfd_coff_swap_filehdr_out (abfd, (PTR) &internal_f, (PTR) buff);
4138 amount = bfd_bwrite ((PTR) buff, amount, abfd);
4140 free (buff);
4142 if (amount != bfd_coff_filhsz (abfd))
4143 return false;
4146 if (abfd->flags & EXEC_P)
4148 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4149 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)) */
4150 char * buff;
4151 bfd_size_type amount = bfd_coff_aoutsz (abfd);
4153 buff = bfd_malloc (amount);
4154 if (buff == NULL)
4155 return false;
4157 coff_swap_aouthdr_out (abfd, (PTR) &internal_a, (PTR) buff);
4158 amount = bfd_bwrite ((PTR) buff, amount, abfd);
4160 free (buff);
4162 if (amount != bfd_coff_aoutsz (abfd))
4163 return false;
4165 #ifdef COFF_IMAGE_WITH_PE
4166 if (! coff_apply_checksum (abfd))
4167 return false;
4168 #endif
4170 #ifdef RS6000COFF_C
4171 else
4173 AOUTHDR buff;
4174 size_t size;
4176 /* XCOFF seems to always write at least a small a.out header. */
4177 coff_swap_aouthdr_out (abfd, (PTR) &internal_a, (PTR) &buff);
4178 if (xcoff_data (abfd)->full_aouthdr)
4179 size = bfd_coff_aoutsz (abfd);
4180 else
4181 size = SMALL_AOUTSZ;
4182 if (bfd_bwrite ((PTR) &buff, (bfd_size_type) size, abfd) != size)
4183 return false;
4185 #endif
4187 return true;
4190 static boolean
4191 coff_set_section_contents (abfd, section, location, offset, count)
4192 bfd * abfd;
4193 sec_ptr section;
4194 PTR location;
4195 file_ptr offset;
4196 bfd_size_type count;
4198 if (! abfd->output_has_begun) /* set by bfd.c handler */
4200 if (! coff_compute_section_file_positions (abfd))
4201 return false;
4204 #if defined(_LIB) && !defined(TARG_AUX)
4206 /* The physical address field of a .lib section is used to hold the
4207 number of shared libraries in the section. This code counts the
4208 number of sections being written, and increments the lma field
4209 with the number.
4211 I have found no documentation on the contents of this section.
4212 Experimentation indicates that the section contains zero or more
4213 records, each of which has the following structure:
4215 - a (four byte) word holding the length of this record, in words,
4216 - a word that always seems to be set to "2",
4217 - the path to a shared library, null-terminated and then padded
4218 to a whole word boundary.
4220 bfd_assert calls have been added to alert if an attempt is made
4221 to write a section which doesn't follow these assumptions. The
4222 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4223 <robertl@arnet.com> (Thanks!).
4225 Gvran Uddeborg <gvran@uddeborg.pp.se> */
4227 if (strcmp (section->name, _LIB) == 0)
4229 bfd_byte *rec, *recend;
4231 rec = (bfd_byte *) location;
4232 recend = rec + count;
4233 while (rec < recend)
4235 ++section->lma;
4236 rec += bfd_get_32 (abfd, rec) * 4;
4239 BFD_ASSERT (rec == recend);
4242 #endif
4244 /* Don't write out bss sections - one way to do this is to
4245 see if the filepos has not been set. */
4246 if (section->filepos == 0)
4247 return true;
4249 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0)
4250 return false;
4252 if (count == 0)
4253 return true;
4255 return bfd_bwrite (location, count, abfd) == count;
4257 #if 0
4258 static boolean
4259 coff_close_and_cleanup (abfd)
4260 bfd *abfd;
4262 if (!bfd_read_p (abfd))
4263 switch (abfd->format)
4265 case bfd_archive:
4266 if (!_bfd_write_archive_contents (abfd))
4267 return false;
4268 break;
4269 case bfd_object:
4270 if (!coff_write_object_contents (abfd))
4271 return false;
4272 break;
4273 default:
4274 bfd_set_error (bfd_error_invalid_operation);
4275 return false;
4278 /* We depend on bfd_close to free all the memory on the objalloc. */
4279 return true;
4282 #endif
4284 static PTR
4285 buy_and_read (abfd, where, size)
4286 bfd *abfd;
4287 file_ptr where;
4288 bfd_size_type size;
4290 PTR area = (PTR) bfd_alloc (abfd, size);
4291 if (!area)
4292 return (NULL);
4293 if (bfd_seek (abfd, where, SEEK_SET) != 0
4294 || bfd_bread (area, size, abfd) != size)
4295 return (NULL);
4296 return (area);
4297 } /* buy_and_read() */
4300 SUBSUBSECTION
4301 Reading linenumbers
4303 Creating the linenumber table is done by reading in the entire
4304 coff linenumber table, and creating another table for internal use.
4306 A coff linenumber table is structured so that each function
4307 is marked as having a line number of 0. Each line within the
4308 function is an offset from the first line in the function. The
4309 base of the line number information for the table is stored in
4310 the symbol associated with the function.
4312 Note: The PE format uses line number 0 for a flag indicating a
4313 new source file.
4315 The information is copied from the external to the internal
4316 table, and each symbol which marks a function is marked by
4317 pointing its...
4319 How does this work ?
4323 static boolean
4324 coff_slurp_line_table (abfd, asect)
4325 bfd *abfd;
4326 asection *asect;
4328 LINENO *native_lineno;
4329 alent *lineno_cache;
4330 bfd_size_type amt;
4332 BFD_ASSERT (asect->lineno == (alent *) NULL);
4334 amt = (bfd_size_type) bfd_coff_linesz (abfd) * asect->lineno_count;
4335 native_lineno = (LINENO *) buy_and_read (abfd, asect->line_filepos, amt);
4336 amt = ((bfd_size_type) asect->lineno_count + 1) * sizeof (alent);
4337 lineno_cache = (alent *) bfd_alloc (abfd, amt);
4338 if (lineno_cache == NULL)
4339 return false;
4340 else
4342 unsigned int counter = 0;
4343 alent *cache_ptr = lineno_cache;
4344 LINENO *src = native_lineno;
4346 while (counter < asect->lineno_count)
4348 struct internal_lineno dst;
4349 bfd_coff_swap_lineno_in (abfd, src, &dst);
4350 cache_ptr->line_number = dst.l_lnno;
4352 if (cache_ptr->line_number == 0)
4354 boolean warned;
4355 bfd_signed_vma symndx;
4356 coff_symbol_type *sym;
4358 warned = false;
4359 symndx = dst.l_addr.l_symndx;
4360 if (symndx < 0
4361 || (bfd_vma) symndx >= obj_raw_syment_count (abfd))
4363 (*_bfd_error_handler)
4364 (_("%s: warning: illegal symbol index %ld in line numbers"),
4365 bfd_archive_filename (abfd), dst.l_addr.l_symndx);
4366 symndx = 0;
4367 warned = true;
4369 /* FIXME: We should not be casting between ints and
4370 pointers like this. */
4371 sym = ((coff_symbol_type *)
4372 ((symndx + obj_raw_syments (abfd))
4373 ->u.syment._n._n_n._n_zeroes));
4374 cache_ptr->u.sym = (asymbol *) sym;
4375 if (sym->lineno != NULL && ! warned)
4377 (*_bfd_error_handler)
4378 (_("%s: warning: duplicate line number information for `%s'"),
4379 bfd_archive_filename (abfd),
4380 bfd_asymbol_name (&sym->symbol));
4382 sym->lineno = cache_ptr;
4384 else
4386 cache_ptr->u.offset = dst.l_addr.l_paddr
4387 - bfd_section_vma (abfd, asect);
4388 } /* If no linenumber expect a symbol index */
4390 cache_ptr++;
4391 src++;
4392 counter++;
4394 cache_ptr->line_number = 0;
4397 asect->lineno = lineno_cache;
4398 /* FIXME, free native_lineno here, or use alloca or something. */
4399 return true;
4402 /* Slurp in the symbol table, converting it to generic form. Note
4403 that if coff_relocate_section is defined, the linker will read
4404 symbols via coff_link_add_symbols, rather than via this routine. */
4406 static boolean
4407 coff_slurp_symbol_table (abfd)
4408 bfd * abfd;
4410 combined_entry_type *native_symbols;
4411 coff_symbol_type *cached_area;
4412 unsigned int *table_ptr;
4413 bfd_size_type amt;
4415 unsigned int number_of_symbols = 0;
4417 if (obj_symbols (abfd))
4418 return true;
4420 /* Read in the symbol table */
4421 if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL)
4423 return (false);
4424 } /* on error */
4426 /* Allocate enough room for all the symbols in cached form */
4427 amt = obj_raw_syment_count (abfd);
4428 amt *= sizeof (coff_symbol_type);
4429 cached_area = (coff_symbol_type *) bfd_alloc (abfd, amt);
4430 if (cached_area == NULL)
4431 return false;
4433 amt = obj_raw_syment_count (abfd);
4434 amt *= sizeof (unsigned int);
4435 table_ptr = (unsigned int *) bfd_alloc (abfd, amt);
4437 if (table_ptr == NULL)
4438 return false;
4439 else
4441 coff_symbol_type *dst = cached_area;
4442 unsigned int last_native_index = obj_raw_syment_count (abfd);
4443 unsigned int this_index = 0;
4444 while (this_index < last_native_index)
4446 combined_entry_type *src = native_symbols + this_index;
4447 table_ptr[this_index] = number_of_symbols;
4448 dst->symbol.the_bfd = abfd;
4450 dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset);
4451 /* We use the native name field to point to the cached field. */
4452 src->u.syment._n._n_n._n_zeroes = (long) dst;
4453 dst->symbol.section = coff_section_from_bfd_index (abfd,
4454 src->u.syment.n_scnum);
4455 dst->symbol.flags = 0;
4456 dst->done_lineno = false;
4458 switch (src->u.syment.n_sclass)
4460 #ifdef I960
4461 case C_LEAFEXT:
4462 #if 0
4463 dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
4464 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
4465 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4466 #endif
4467 /* Fall through to next case */
4469 #endif
4471 case C_EXT:
4472 case C_WEAKEXT:
4473 #if defined ARM
4474 case C_THUMBEXT:
4475 case C_THUMBEXTFUNC:
4476 #endif
4477 #ifdef RS6000COFF_C
4478 case C_HIDEXT:
4479 #endif
4480 #ifdef C_SYSTEM
4481 case C_SYSTEM: /* System Wide variable */
4482 #endif
4483 #ifdef COFF_WITH_PE
4484 /* In PE, 0x68 (104) denotes a section symbol */
4485 case C_SECTION:
4486 /* In PE, 0x69 (105) denotes a weak external symbol. */
4487 case C_NT_WEAK:
4488 #endif
4489 switch (coff_classify_symbol (abfd, &src->u.syment))
4491 case COFF_SYMBOL_GLOBAL:
4492 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
4493 #if defined COFF_WITH_PE
4494 /* PE sets the symbol to a value relative to the
4495 start of the section. */
4496 dst->symbol.value = src->u.syment.n_value;
4497 #else
4498 dst->symbol.value = (src->u.syment.n_value
4499 - dst->symbol.section->vma);
4500 #endif
4501 if (ISFCN ((src->u.syment.n_type)))
4503 /* A function ext does not go at the end of a
4504 file. */
4505 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4507 break;
4509 case COFF_SYMBOL_COMMON:
4510 dst->symbol.section = bfd_com_section_ptr;
4511 dst->symbol.value = src->u.syment.n_value;
4512 break;
4514 case COFF_SYMBOL_UNDEFINED:
4515 dst->symbol.section = bfd_und_section_ptr;
4516 dst->symbol.value = 0;
4517 break;
4519 case COFF_SYMBOL_PE_SECTION:
4520 dst->symbol.flags |= BSF_EXPORT | BSF_SECTION_SYM;
4521 dst->symbol.value = 0;
4522 break;
4524 case COFF_SYMBOL_LOCAL:
4525 dst->symbol.flags = BSF_LOCAL;
4526 #if defined COFF_WITH_PE
4527 /* PE sets the symbol to a value relative to the
4528 start of the section. */
4529 dst->symbol.value = src->u.syment.n_value;
4530 #else
4531 dst->symbol.value = (src->u.syment.n_value
4532 - dst->symbol.section->vma);
4533 #endif
4534 if (ISFCN ((src->u.syment.n_type)))
4535 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4536 break;
4539 #ifdef RS6000COFF_C
4540 /* A symbol with a csect entry should not go at the end. */
4541 if (src->u.syment.n_numaux > 0)
4542 dst->symbol.flags |= BSF_NOT_AT_END;
4543 #endif
4545 #ifdef COFF_WITH_PE
4546 if (src->u.syment.n_sclass == C_NT_WEAK)
4547 dst->symbol.flags |= BSF_WEAK;
4549 if (src->u.syment.n_sclass == C_SECTION
4550 && src->u.syment.n_scnum > 0)
4551 dst->symbol.flags = BSF_LOCAL;
4552 #endif
4553 if (src->u.syment.n_sclass == C_WEAKEXT)
4554 dst->symbol.flags |= BSF_WEAK;
4556 break;
4558 case C_STAT: /* static */
4559 #ifdef I960
4560 case C_LEAFSTAT: /* static leaf procedure */
4561 #endif
4562 #if defined ARM
4563 case C_THUMBSTAT: /* Thumb static */
4564 case C_THUMBLABEL: /* Thumb label */
4565 case C_THUMBSTATFUNC:/* Thumb static function */
4566 #endif
4567 case C_LABEL: /* label */
4568 if (src->u.syment.n_scnum == N_DEBUG)
4569 dst->symbol.flags = BSF_DEBUGGING;
4570 else
4571 dst->symbol.flags = BSF_LOCAL;
4573 /* Base the value as an index from the base of the
4574 section, if there is one. */
4575 if (dst->symbol.section)
4577 #if defined COFF_WITH_PE
4578 /* PE sets the symbol to a value relative to the
4579 start of the section. */
4580 dst->symbol.value = src->u.syment.n_value;
4581 #else
4582 dst->symbol.value = (src->u.syment.n_value
4583 - dst->symbol.section->vma);
4584 #endif
4586 else
4587 dst->symbol.value = src->u.syment.n_value;
4588 break;
4590 case C_MOS: /* member of structure */
4591 case C_EOS: /* end of structure */
4592 #ifdef NOTDEF /* C_AUTOARG has the same value */
4593 #ifdef C_GLBLREG
4594 case C_GLBLREG: /* A29k-specific storage class */
4595 #endif
4596 #endif
4597 case C_REGPARM: /* register parameter */
4598 case C_REG: /* register variable */
4599 /* C_AUTOARG conflictes with TI COFF C_UEXT */
4600 #if !defined (TIC80COFF) && !defined (TICOFF)
4601 #ifdef C_AUTOARG
4602 case C_AUTOARG: /* 960-specific storage class */
4603 #endif
4604 #endif
4605 case C_TPDEF: /* type definition */
4606 case C_ARG:
4607 case C_AUTO: /* automatic variable */
4608 case C_FIELD: /* bit field */
4609 case C_ENTAG: /* enumeration tag */
4610 case C_MOE: /* member of enumeration */
4611 case C_MOU: /* member of union */
4612 case C_UNTAG: /* union tag */
4613 dst->symbol.flags = BSF_DEBUGGING;
4614 dst->symbol.value = (src->u.syment.n_value);
4615 break;
4617 case C_FILE: /* file name */
4618 case C_STRTAG: /* structure tag */
4619 #ifdef RS6000COFF_C
4620 case C_GSYM:
4621 case C_LSYM:
4622 case C_PSYM:
4623 case C_RSYM:
4624 case C_RPSYM:
4625 case C_STSYM:
4626 case C_BCOMM:
4627 case C_ECOMM:
4628 case C_DECL:
4629 case C_ENTRY:
4630 case C_FUN:
4631 case C_ESTAT:
4632 #endif
4633 dst->symbol.flags = BSF_DEBUGGING;
4634 dst->symbol.value = (src->u.syment.n_value);
4635 break;
4637 #ifdef RS6000COFF_C
4638 case C_BINCL: /* beginning of include file */
4639 case C_EINCL: /* ending of include file */
4640 /* The value is actually a pointer into the line numbers
4641 of the file. We locate the line number entry, and
4642 set the section to the section which contains it, and
4643 the value to the index in that section. */
4645 asection *sec;
4647 dst->symbol.flags = BSF_DEBUGGING;
4648 for (sec = abfd->sections; sec != NULL; sec = sec->next)
4649 if (sec->line_filepos <= (file_ptr) src->u.syment.n_value
4650 && ((file_ptr) (sec->line_filepos
4651 + sec->lineno_count * bfd_coff_linesz (abfd))
4652 > (file_ptr) src->u.syment.n_value))
4653 break;
4654 if (sec == NULL)
4655 dst->symbol.value = 0;
4656 else
4658 dst->symbol.section = sec;
4659 dst->symbol.value = ((src->u.syment.n_value
4660 - sec->line_filepos)
4661 / bfd_coff_linesz (abfd));
4662 src->fix_line = 1;
4665 break;
4667 case C_BSTAT:
4668 dst->symbol.flags = BSF_DEBUGGING;
4670 /* The value is actually a symbol index. Save a pointer
4671 to the symbol instead of the index. FIXME: This
4672 should use a union. */
4673 src->u.syment.n_value =
4674 (long) (native_symbols + src->u.syment.n_value);
4675 dst->symbol.value = src->u.syment.n_value;
4676 src->fix_value = 1;
4677 break;
4678 #endif
4680 case C_BLOCK: /* ".bb" or ".eb" */
4681 case C_FCN: /* ".bf" or ".ef" (or PE ".lf") */
4682 case C_EFCN: /* physical end of function */
4683 #if defined COFF_WITH_PE
4684 /* PE sets the symbol to a value relative to the start
4685 of the section. */
4686 dst->symbol.value = src->u.syment.n_value;
4687 if (strcmp (dst->symbol.name, ".bf") != 0)
4689 /* PE uses funny values for .ef and .lf; don't
4690 relocate them. */
4691 dst->symbol.flags = BSF_DEBUGGING;
4693 else
4694 dst->symbol.flags = BSF_DEBUGGING | BSF_DEBUGGING_RELOC;
4695 #else
4696 /* Base the value as an index from the base of the
4697 section. */
4698 dst->symbol.flags = BSF_LOCAL;
4699 dst->symbol.value = (src->u.syment.n_value
4700 - dst->symbol.section->vma);
4701 #endif
4702 break;
4704 case C_STATLAB: /* Static load time label */
4705 dst->symbol.value = src->u.syment.n_value;
4706 dst->symbol.flags = BSF_GLOBAL;
4707 break;
4709 case C_NULL:
4710 /* PE DLLs sometimes have zeroed out symbols for some
4711 reason. Just ignore them without a warning. */
4712 if (src->u.syment.n_type == 0
4713 && src->u.syment.n_value == 0
4714 && src->u.syment.n_scnum == 0)
4715 break;
4716 /* Fall through. */
4717 case C_EXTDEF: /* external definition */
4718 case C_ULABEL: /* undefined label */
4719 case C_USTATIC: /* undefined static */
4720 #ifndef COFF_WITH_PE
4721 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4722 class to represent a section symbol */
4723 case C_LINE: /* line # reformatted as symbol table entry */
4724 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4725 case C_ALIAS: /* duplicate tag */
4726 #endif
4727 /* New storage classes for TI COFF */
4728 #if defined(TIC80COFF) || defined(TICOFF)
4729 case C_UEXT: /* Tentative external definition */
4730 #endif
4731 case C_EXTLAB: /* External load time label */
4732 case C_HIDDEN: /* ext symbol in dmert public lib */
4733 default:
4734 (*_bfd_error_handler)
4735 (_("%s: Unrecognized storage class %d for %s symbol `%s'"),
4736 bfd_archive_filename (abfd), src->u.syment.n_sclass,
4737 dst->symbol.section->name, dst->symbol.name);
4738 dst->symbol.flags = BSF_DEBUGGING;
4739 dst->symbol.value = (src->u.syment.n_value);
4740 break;
4743 /* BFD_ASSERT(dst->symbol.flags != 0);*/
4745 dst->native = src;
4747 dst->symbol.udata.i = 0;
4748 dst->lineno = (alent *) NULL;
4749 this_index += (src->u.syment.n_numaux) + 1;
4750 dst++;
4751 number_of_symbols++;
4752 } /* walk the native symtab */
4753 } /* bfdize the native symtab */
4755 obj_symbols (abfd) = cached_area;
4756 obj_raw_syments (abfd) = native_symbols;
4758 bfd_get_symcount (abfd) = number_of_symbols;
4759 obj_convert (abfd) = table_ptr;
4760 /* Slurp the line tables for each section too */
4762 asection *p;
4763 p = abfd->sections;
4764 while (p)
4766 coff_slurp_line_table (abfd, p);
4767 p = p->next;
4770 return true;
4771 } /* coff_slurp_symbol_table() */
4773 /* Classify a COFF symbol. A couple of targets have globally visible
4774 symbols which are not class C_EXT, and this handles those. It also
4775 recognizes some special PE cases. */
4777 static enum coff_symbol_classification
4778 coff_classify_symbol (abfd, syment)
4779 bfd *abfd;
4780 struct internal_syment *syment;
4782 /* FIXME: This partially duplicates the switch in
4783 coff_slurp_symbol_table. */
4784 switch (syment->n_sclass)
4786 case C_EXT:
4787 case C_WEAKEXT:
4788 #ifdef I960
4789 case C_LEAFEXT:
4790 #endif
4791 #ifdef ARM
4792 case C_THUMBEXT:
4793 case C_THUMBEXTFUNC:
4794 #endif
4795 #ifdef C_SYSTEM
4796 case C_SYSTEM:
4797 #endif
4798 #ifdef COFF_WITH_PE
4799 case C_NT_WEAK:
4800 #endif
4801 if (syment->n_scnum == 0)
4803 if (syment->n_value == 0)
4804 return COFF_SYMBOL_UNDEFINED;
4805 else
4806 return COFF_SYMBOL_COMMON;
4808 return COFF_SYMBOL_GLOBAL;
4810 default:
4811 break;
4814 #ifdef COFF_WITH_PE
4815 if (syment->n_sclass == C_STAT)
4817 if (syment->n_scnum == 0)
4819 /* The Microsoft compiler sometimes generates these if a
4820 small static function is inlined every time it is used.
4821 The function is discarded, but the symbol table entry
4822 remains. */
4823 return COFF_SYMBOL_LOCAL;
4826 #ifdef STRICT_PE_FORMAT
4827 /* This is correct for Microsoft generated objects, but it
4828 breaks gas generated objects. */
4830 if (syment->n_value == 0)
4832 asection *sec;
4833 char buf[SYMNMLEN + 1];
4835 sec = coff_section_from_bfd_index (abfd, syment->n_scnum);
4836 if (sec != NULL
4837 && (strcmp (bfd_get_section_name (abfd, sec),
4838 _bfd_coff_internal_syment_name (abfd, syment, buf))
4839 == 0))
4840 return COFF_SYMBOL_PE_SECTION;
4842 #endif
4844 return COFF_SYMBOL_LOCAL;
4847 if (syment->n_sclass == C_SECTION)
4849 /* In some cases in a DLL generated by the Microsoft linker, the
4850 n_value field will contain garbage. FIXME: This should
4851 probably be handled by the swapping function instead. */
4852 syment->n_value = 0;
4853 if (syment->n_scnum == 0)
4854 return COFF_SYMBOL_UNDEFINED;
4855 return COFF_SYMBOL_PE_SECTION;
4857 #endif /* COFF_WITH_PE */
4859 /* If it is not a global symbol, we presume it is a local symbol. */
4861 if (syment->n_scnum == 0)
4863 char buf[SYMNMLEN + 1];
4865 (*_bfd_error_handler)
4866 (_("warning: %s: local symbol `%s' has no section"),
4867 bfd_archive_filename (abfd),
4868 _bfd_coff_internal_syment_name (abfd, syment, buf));
4871 return COFF_SYMBOL_LOCAL;
4875 SUBSUBSECTION
4876 Reading relocations
4878 Coff relocations are easily transformed into the internal BFD form
4879 (@code{arelent}).
4881 Reading a coff relocation table is done in the following stages:
4883 o Read the entire coff relocation table into memory.
4885 o Process each relocation in turn; first swap it from the
4886 external to the internal form.
4888 o Turn the symbol referenced in the relocation's symbol index
4889 into a pointer into the canonical symbol table.
4890 This table is the same as the one returned by a call to
4891 @code{bfd_canonicalize_symtab}. The back end will call that
4892 routine and save the result if a canonicalization hasn't been done.
4894 o The reloc index is turned into a pointer to a howto
4895 structure, in a back end specific way. For instance, the 386
4896 and 960 use the @code{r_type} to directly produce an index
4897 into a howto table vector; the 88k subtracts a number from the
4898 @code{r_type} field and creates an addend field.
4902 #ifndef CALC_ADDEND
4903 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
4905 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \
4906 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
4907 coffsym = (obj_symbols (abfd) \
4908 + (cache_ptr->sym_ptr_ptr - symbols)); \
4909 else if (ptr) \
4910 coffsym = coff_symbol_from (abfd, ptr); \
4911 if (coffsym != (coff_symbol_type *) NULL \
4912 && coffsym->native->u.syment.n_scnum == 0) \
4913 cache_ptr->addend = 0; \
4914 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
4915 && ptr->section != (asection *) NULL) \
4916 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
4917 else \
4918 cache_ptr->addend = 0; \
4920 #endif
4922 static boolean
4923 coff_slurp_reloc_table (abfd, asect, symbols)
4924 bfd * abfd;
4925 sec_ptr asect;
4926 asymbol ** symbols;
4928 RELOC *native_relocs;
4929 arelent *reloc_cache;
4930 arelent *cache_ptr;
4931 unsigned int idx;
4932 bfd_size_type amt;
4934 if (asect->relocation)
4935 return true;
4936 if (asect->reloc_count == 0)
4937 return true;
4938 if (asect->flags & SEC_CONSTRUCTOR)
4939 return true;
4940 if (!coff_slurp_symbol_table (abfd))
4941 return false;
4942 amt = (bfd_size_type) bfd_coff_relsz (abfd) * asect->reloc_count;
4943 native_relocs = (RELOC *) buy_and_read (abfd, asect->rel_filepos, amt);
4944 amt = (bfd_size_type) asect->reloc_count * sizeof (arelent);
4945 reloc_cache = (arelent *) bfd_alloc (abfd, amt);
4947 if (reloc_cache == NULL)
4948 return false;
4950 for (idx = 0; idx < asect->reloc_count; idx++)
4952 struct internal_reloc dst;
4953 struct external_reloc *src;
4954 #ifndef RELOC_PROCESSING
4955 asymbol *ptr;
4956 #endif
4958 cache_ptr = reloc_cache + idx;
4959 src = native_relocs + idx;
4961 coff_swap_reloc_in (abfd, src, &dst);
4963 #ifdef RELOC_PROCESSING
4964 RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
4965 #else
4966 cache_ptr->address = dst.r_vaddr;
4968 if (dst.r_symndx != -1)
4970 if (dst.r_symndx < 0 || dst.r_symndx >= obj_conv_table_size (abfd))
4972 (*_bfd_error_handler)
4973 (_("%s: warning: illegal symbol index %ld in relocs"),
4974 bfd_archive_filename (abfd), dst.r_symndx);
4975 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
4976 ptr = NULL;
4978 else
4980 cache_ptr->sym_ptr_ptr = (symbols
4981 + obj_convert (abfd)[dst.r_symndx]);
4982 ptr = *(cache_ptr->sym_ptr_ptr);
4985 else
4987 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
4988 ptr = NULL;
4991 /* The symbols definitions that we have read in have been
4992 relocated as if their sections started at 0. But the offsets
4993 refering to the symbols in the raw data have not been
4994 modified, so we have to have a negative addend to compensate.
4996 Note that symbols which used to be common must be left alone */
4998 /* Calculate any reloc addend by looking at the symbol */
4999 CALC_ADDEND (abfd, ptr, dst, cache_ptr);
5001 cache_ptr->address -= asect->vma;
5002 /* !! cache_ptr->section = (asection *) NULL;*/
5004 /* Fill in the cache_ptr->howto field from dst.r_type */
5005 RTYPE2HOWTO (cache_ptr, &dst);
5006 #endif /* RELOC_PROCESSING */
5008 if (cache_ptr->howto == NULL)
5010 (*_bfd_error_handler)
5011 (_("%s: illegal relocation type %d at address 0x%lx"),
5012 bfd_archive_filename (abfd), dst.r_type, (long) dst.r_vaddr);
5013 bfd_set_error (bfd_error_bad_value);
5014 return false;
5018 asect->relocation = reloc_cache;
5019 return true;
5022 #ifndef coff_rtype_to_howto
5023 #ifdef RTYPE2HOWTO
5025 /* Get the howto structure for a reloc. This is only used if the file
5026 including this one defines coff_relocate_section to be
5027 _bfd_coff_generic_relocate_section, so it is OK if it does not
5028 always work. It is the responsibility of the including file to
5029 make sure it is reasonable if it is needed. */
5031 static reloc_howto_type *coff_rtype_to_howto
5032 PARAMS ((bfd *, asection *, struct internal_reloc *,
5033 struct coff_link_hash_entry *, struct internal_syment *,
5034 bfd_vma *));
5036 /*ARGSUSED*/
5037 static reloc_howto_type *
5038 coff_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
5039 bfd *abfd ATTRIBUTE_UNUSED;
5040 asection *sec ATTRIBUTE_UNUSED;
5041 struct internal_reloc *rel;
5042 struct coff_link_hash_entry *h ATTRIBUTE_UNUSED;
5043 struct internal_syment *sym ATTRIBUTE_UNUSED;
5044 bfd_vma *addendp ATTRIBUTE_UNUSED;
5046 arelent genrel;
5048 RTYPE2HOWTO (&genrel, rel);
5049 return genrel.howto;
5052 #else /* ! defined (RTYPE2HOWTO) */
5054 #define coff_rtype_to_howto NULL
5056 #endif /* ! defined (RTYPE2HOWTO) */
5057 #endif /* ! defined (coff_rtype_to_howto) */
5059 /* This is stupid. This function should be a boolean predicate. */
5060 static long
5061 coff_canonicalize_reloc (abfd, section, relptr, symbols)
5062 bfd * abfd;
5063 sec_ptr section;
5064 arelent ** relptr;
5065 asymbol ** symbols;
5067 arelent *tblptr = section->relocation;
5068 unsigned int count = 0;
5070 if (section->flags & SEC_CONSTRUCTOR)
5072 /* this section has relocs made up by us, they are not in the
5073 file, so take them out of their chain and place them into
5074 the data area provided */
5075 arelent_chain *chain = section->constructor_chain;
5076 for (count = 0; count < section->reloc_count; count++)
5078 *relptr++ = &chain->relent;
5079 chain = chain->next;
5083 else
5085 if (! coff_slurp_reloc_table (abfd, section, symbols))
5086 return -1;
5088 tblptr = section->relocation;
5090 for (; count++ < section->reloc_count;)
5091 *relptr++ = tblptr++;
5093 *relptr = 0;
5094 return section->reloc_count;
5097 #ifdef GNU960
5098 file_ptr
5099 coff_sym_filepos (abfd)
5100 bfd *abfd;
5102 return obj_sym_filepos (abfd);
5104 #endif
5106 #ifndef coff_reloc16_estimate
5107 #define coff_reloc16_estimate dummy_reloc16_estimate
5109 static int dummy_reloc16_estimate
5110 PARAMS ((bfd *, asection *, arelent *, unsigned int,
5111 struct bfd_link_info *));
5113 static int
5114 dummy_reloc16_estimate (abfd, input_section, reloc, shrink, link_info)
5115 bfd *abfd ATTRIBUTE_UNUSED;
5116 asection *input_section ATTRIBUTE_UNUSED;
5117 arelent *reloc ATTRIBUTE_UNUSED;
5118 unsigned int shrink ATTRIBUTE_UNUSED;
5119 struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
5121 abort ();
5122 return 0;
5125 #endif
5127 #ifndef coff_reloc16_extra_cases
5129 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
5131 /* This works even if abort is not declared in any header file. */
5133 static void dummy_reloc16_extra_cases
5134 PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
5135 bfd_byte *, unsigned int *, unsigned int *));
5137 static void
5138 dummy_reloc16_extra_cases (abfd, link_info, link_order, reloc, data, src_ptr,
5139 dst_ptr)
5140 bfd *abfd ATTRIBUTE_UNUSED;
5141 struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
5142 struct bfd_link_order *link_order ATTRIBUTE_UNUSED;
5143 arelent *reloc ATTRIBUTE_UNUSED;
5144 bfd_byte *data ATTRIBUTE_UNUSED;
5145 unsigned int *src_ptr ATTRIBUTE_UNUSED;
5146 unsigned int *dst_ptr ATTRIBUTE_UNUSED;
5148 abort ();
5150 #endif
5152 #ifndef coff_bfd_link_hash_table_free
5153 #define coff_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
5154 #endif
5156 /* If coff_relocate_section is defined, we can use the optimized COFF
5157 backend linker. Otherwise we must continue to use the old linker. */
5158 #ifdef coff_relocate_section
5159 #ifndef coff_bfd_link_hash_table_create
5160 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5161 #endif
5162 #ifndef coff_bfd_link_add_symbols
5163 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5164 #endif
5165 #ifndef coff_bfd_final_link
5166 #define coff_bfd_final_link _bfd_coff_final_link
5167 #endif
5168 #else /* ! defined (coff_relocate_section) */
5169 #define coff_relocate_section NULL
5170 #ifndef coff_bfd_link_hash_table_create
5171 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5172 #endif
5173 #ifndef coff_bfd_link_add_symbols
5174 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5175 #endif
5176 #define coff_bfd_final_link _bfd_generic_final_link
5177 #endif /* ! defined (coff_relocate_section) */
5179 #define coff_bfd_link_just_syms _bfd_generic_link_just_syms
5180 #define coff_bfd_link_split_section _bfd_generic_link_split_section
5182 #ifndef coff_start_final_link
5183 #define coff_start_final_link NULL
5184 #endif
5186 #ifndef coff_adjust_symndx
5187 #define coff_adjust_symndx NULL
5188 #endif
5190 #ifndef coff_link_add_one_symbol
5191 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5192 #endif
5194 #ifndef coff_link_output_has_begun
5196 static boolean coff_link_output_has_begun
5197 PARAMS ((bfd *, struct coff_final_link_info *));
5199 static boolean
5200 coff_link_output_has_begun (abfd, info)
5201 bfd * abfd;
5202 struct coff_final_link_info * info ATTRIBUTE_UNUSED;
5204 return abfd->output_has_begun;
5206 #endif
5208 #ifndef coff_final_link_postscript
5210 static boolean coff_final_link_postscript
5211 PARAMS ((bfd *, struct coff_final_link_info *));
5213 static boolean
5214 coff_final_link_postscript (abfd, pfinfo)
5215 bfd * abfd ATTRIBUTE_UNUSED;
5216 struct coff_final_link_info * pfinfo ATTRIBUTE_UNUSED;
5218 return true;
5220 #endif
5222 #ifndef coff_SWAP_aux_in
5223 #define coff_SWAP_aux_in coff_swap_aux_in
5224 #endif
5225 #ifndef coff_SWAP_sym_in
5226 #define coff_SWAP_sym_in coff_swap_sym_in
5227 #endif
5228 #ifndef coff_SWAP_lineno_in
5229 #define coff_SWAP_lineno_in coff_swap_lineno_in
5230 #endif
5231 #ifndef coff_SWAP_aux_out
5232 #define coff_SWAP_aux_out coff_swap_aux_out
5233 #endif
5234 #ifndef coff_SWAP_sym_out
5235 #define coff_SWAP_sym_out coff_swap_sym_out
5236 #endif
5237 #ifndef coff_SWAP_lineno_out
5238 #define coff_SWAP_lineno_out coff_swap_lineno_out
5239 #endif
5240 #ifndef coff_SWAP_reloc_out
5241 #define coff_SWAP_reloc_out coff_swap_reloc_out
5242 #endif
5243 #ifndef coff_SWAP_filehdr_out
5244 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5245 #endif
5246 #ifndef coff_SWAP_aouthdr_out
5247 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5248 #endif
5249 #ifndef coff_SWAP_scnhdr_out
5250 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5251 #endif
5252 #ifndef coff_SWAP_reloc_in
5253 #define coff_SWAP_reloc_in coff_swap_reloc_in
5254 #endif
5255 #ifndef coff_SWAP_filehdr_in
5256 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5257 #endif
5258 #ifndef coff_SWAP_aouthdr_in
5259 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5260 #endif
5261 #ifndef coff_SWAP_scnhdr_in
5262 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5263 #endif
5265 static const bfd_coff_backend_data bfd_coff_std_swap_table =
5267 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5268 coff_SWAP_aux_out, coff_SWAP_sym_out,
5269 coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5270 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5271 coff_SWAP_scnhdr_out,
5272 FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
5273 #ifdef COFF_LONG_FILENAMES
5274 true,
5275 #else
5276 false,
5277 #endif
5278 #ifdef COFF_LONG_SECTION_NAMES
5279 true,
5280 #else
5281 false,
5282 #endif
5283 COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5284 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5285 true,
5286 #else
5287 false,
5288 #endif
5289 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5291 #else
5293 #endif
5294 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5295 coff_SWAP_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook,
5296 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5297 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5298 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5299 coff_classify_symbol, coff_compute_section_file_positions,
5300 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5301 coff_adjust_symndx, coff_link_add_one_symbol,
5302 coff_link_output_has_begun, coff_final_link_postscript
5305 #ifndef coff_close_and_cleanup
5306 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
5307 #endif
5309 #ifndef coff_bfd_free_cached_info
5310 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
5311 #endif
5313 #ifndef coff_get_section_contents
5314 #define coff_get_section_contents _bfd_generic_get_section_contents
5315 #endif
5317 #ifndef coff_bfd_copy_private_symbol_data
5318 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5319 #endif
5321 #ifndef coff_bfd_copy_private_section_data
5322 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5323 #endif
5325 #ifndef coff_bfd_copy_private_bfd_data
5326 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5327 #endif
5329 #ifndef coff_bfd_merge_private_bfd_data
5330 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5331 #endif
5333 #ifndef coff_bfd_set_private_flags
5334 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5335 #endif
5337 #ifndef coff_bfd_print_private_bfd_data
5338 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5339 #endif
5341 #ifndef coff_bfd_is_local_label_name
5342 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5343 #endif
5345 #ifndef coff_read_minisymbols
5346 #define coff_read_minisymbols _bfd_generic_read_minisymbols
5347 #endif
5349 #ifndef coff_minisymbol_to_symbol
5350 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5351 #endif
5353 /* The reloc lookup routine must be supplied by each individual COFF
5354 backend. */
5355 #ifndef coff_bfd_reloc_type_lookup
5356 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5357 #endif
5359 #ifndef coff_bfd_get_relocated_section_contents
5360 #define coff_bfd_get_relocated_section_contents \
5361 bfd_generic_get_relocated_section_contents
5362 #endif
5364 #ifndef coff_bfd_relax_section
5365 #define coff_bfd_relax_section bfd_generic_relax_section
5366 #endif
5368 #ifndef coff_bfd_gc_sections
5369 #define coff_bfd_gc_sections bfd_generic_gc_sections
5370 #endif
5372 #ifndef coff_bfd_merge_sections
5373 #define coff_bfd_merge_sections bfd_generic_merge_sections
5374 #endif
5376 #ifndef coff_bfd_discard_group
5377 #define coff_bfd_discard_group bfd_generic_discard_group
5378 #endif
5380 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
5381 const bfd_target VAR = \
5383 NAME , \
5384 bfd_target_coff_flavour, \
5385 BFD_ENDIAN_BIG, /* data byte order is big */ \
5386 BFD_ENDIAN_BIG, /* header byte order is big */ \
5387 /* object flags */ \
5388 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5389 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5390 /* section flags */ \
5391 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5392 UNDER, /* leading symbol underscore */ \
5393 '/', /* ar_pad_char */ \
5394 15, /* ar_max_namelen */ \
5396 /* Data conversion functions. */ \
5397 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5398 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5399 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5401 /* Header conversion functions. */ \
5402 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5403 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5404 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5406 /* bfd_check_format */ \
5407 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5408 _bfd_dummy_target }, \
5409 /* bfd_set_format */ \
5410 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5411 /* bfd_write_contents */ \
5412 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5413 bfd_false }, \
5415 BFD_JUMP_TABLE_GENERIC (coff), \
5416 BFD_JUMP_TABLE_COPY (coff), \
5417 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5418 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5419 BFD_JUMP_TABLE_SYMBOLS (coff), \
5420 BFD_JUMP_TABLE_RELOCS (coff), \
5421 BFD_JUMP_TABLE_WRITE (coff), \
5422 BFD_JUMP_TABLE_LINK (coff), \
5423 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5425 ALTERNATIVE, \
5427 COFF_SWAP_TABLE \
5430 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
5431 const bfd_target VAR = \
5433 NAME , \
5434 bfd_target_coff_flavour, \
5435 BFD_ENDIAN_LITTLE, /* data byte order is little */ \
5436 BFD_ENDIAN_LITTLE, /* header byte order is little */ \
5437 /* object flags */ \
5438 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5439 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5440 /* section flags */ \
5441 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5442 UNDER, /* leading symbol underscore */ \
5443 '/', /* ar_pad_char */ \
5444 15, /* ar_max_namelen */ \
5446 /* Data conversion functions. */ \
5447 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5448 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5449 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5450 /* Header conversion functions. */ \
5451 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5452 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5453 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5454 /* bfd_check_format */ \
5455 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5456 _bfd_dummy_target }, \
5457 /* bfd_set_format */ \
5458 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5459 /* bfd_write_contents */ \
5460 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5461 bfd_false }, \
5463 BFD_JUMP_TABLE_GENERIC (coff), \
5464 BFD_JUMP_TABLE_COPY (coff), \
5465 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5466 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5467 BFD_JUMP_TABLE_SYMBOLS (coff), \
5468 BFD_JUMP_TABLE_RELOCS (coff), \
5469 BFD_JUMP_TABLE_WRITE (coff), \
5470 BFD_JUMP_TABLE_LINK (coff), \
5471 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5473 ALTERNATIVE, \
5475 COFF_SWAP_TABLE \