merge from gcc
[binutils.git] / bfd / coffcode.h
blob15d97093f67b0132cd29ddbd21994fb581d3b951
1 /* Support for the generic parts of most COFF variants, for BFD.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003
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 hierarchy 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 . bfd_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
313 PARAMS ((const char *, flagword));
314 static bfd_boolean styp_to_sec_flags
315 PARAMS ((bfd *, PTR, const char *, asection *, flagword *));
316 static bfd_boolean coff_bad_format_hook
317 PARAMS ((bfd *, PTR));
318 static void coff_set_custom_section_alignment
319 PARAMS ((bfd *, asection *, const struct coff_section_alignment_entry *,
320 const unsigned int));
321 static bfd_boolean coff_new_section_hook
322 PARAMS ((bfd *, asection *));
323 static bfd_boolean coff_set_arch_mach_hook
324 PARAMS ((bfd *, PTR));
325 static bfd_boolean coff_write_relocs
326 PARAMS ((bfd *, int));
327 static bfd_boolean coff_set_flags
328 PARAMS ((bfd *, unsigned int *, unsigned short *));
329 static bfd_boolean coff_set_arch_mach
330 PARAMS ((bfd *, enum bfd_architecture, unsigned long)) ATTRIBUTE_UNUSED;
331 static bfd_boolean coff_compute_section_file_positions
332 PARAMS ((bfd *));
333 static bfd_boolean coff_write_object_contents
334 PARAMS ((bfd *)) ATTRIBUTE_UNUSED;
335 static bfd_boolean coff_set_section_contents
336 PARAMS ((bfd *, asection *, const PTR, file_ptr, bfd_size_type));
337 static PTR buy_and_read
338 PARAMS ((bfd *, file_ptr, bfd_size_type));
339 static bfd_boolean coff_slurp_line_table
340 PARAMS ((bfd *, asection *));
341 static bfd_boolean coff_slurp_symbol_table
342 PARAMS ((bfd *));
343 static enum coff_symbol_classification coff_classify_symbol
344 PARAMS ((bfd *, struct internal_syment *));
345 static bfd_boolean coff_slurp_reloc_table
346 PARAMS ((bfd *, asection *, asymbol **));
347 static long coff_canonicalize_reloc
348 PARAMS ((bfd *, asection *, arelent **, asymbol **));
349 #ifndef coff_mkobject_hook
350 static PTR coff_mkobject_hook
351 PARAMS ((bfd *, PTR, PTR));
352 #endif
353 #ifdef COFF_WITH_PE
354 static flagword handle_COMDAT
355 PARAMS ((bfd *, flagword, PTR, const char *, asection *));
356 #endif
357 #ifdef COFF_IMAGE_WITH_PE
358 static bfd_boolean coff_read_word
359 PARAMS ((bfd *, unsigned int *));
360 static unsigned int coff_compute_checksum
361 PARAMS ((bfd *));
362 static bfd_boolean coff_apply_checksum
363 PARAMS ((bfd *));
364 #endif
365 #ifdef TICOFF
366 static bfd_boolean ticoff0_bad_format_hook
367 PARAMS ((bfd *, PTR ));
368 static bfd_boolean ticoff1_bad_format_hook
369 PARAMS ((bfd *, PTR ));
370 #endif
372 /* void warning(); */
374 /* Return a word with STYP_* (scnhdr.s_flags) flags set to represent
375 the incoming SEC_* flags. The inverse of this function is
376 styp_to_sec_flags(). NOTE: If you add to/change this routine, you
377 should probably mirror the changes in styp_to_sec_flags(). */
379 #ifndef COFF_WITH_PE
381 /* Macros for setting debugging flags. */
382 #ifdef STYP_DEBUG
383 #define STYP_XCOFF_DEBUG STYP_DEBUG
384 #else
385 #define STYP_XCOFF_DEBUG STYP_INFO
386 #endif
388 #ifdef COFF_ALIGN_IN_S_FLAGS
389 #define STYP_DEBUG_INFO STYP_DSECT
390 #else
391 #define STYP_DEBUG_INFO STYP_INFO
392 #endif
394 static long
395 sec_to_styp_flags (sec_name, sec_flags)
396 const char *sec_name;
397 flagword sec_flags;
399 long styp_flags = 0;
401 if (!strcmp (sec_name, _TEXT))
403 styp_flags = STYP_TEXT;
405 else if (!strcmp (sec_name, _DATA))
407 styp_flags = STYP_DATA;
409 else if (!strcmp (sec_name, _BSS))
411 styp_flags = STYP_BSS;
412 #ifdef _COMMENT
414 else if (!strcmp (sec_name, _COMMENT))
416 styp_flags = STYP_INFO;
417 #endif /* _COMMENT */
418 #ifdef _LIB
420 else if (!strcmp (sec_name, _LIB))
422 styp_flags = STYP_LIB;
423 #endif /* _LIB */
424 #ifdef _LIT
426 else if (!strcmp (sec_name, _LIT))
428 styp_flags = STYP_LIT;
429 #endif /* _LIT */
431 else if (!strncmp (sec_name, ".debug", 6))
433 /* Handle the XCOFF debug section and DWARF2 debug sections. */
434 if (!sec_name[6])
435 styp_flags = STYP_XCOFF_DEBUG;
436 else
437 styp_flags = STYP_DEBUG_INFO;
439 else if (!strncmp (sec_name, ".stab", 5))
441 styp_flags = STYP_DEBUG_INFO;
443 #ifdef COFF_LONG_SECTION_NAMES
444 else if (!strncmp (sec_name, ".gnu.linkonce.wi.", 17))
446 styp_flags = STYP_DEBUG_INFO;
448 #endif
449 #ifdef RS6000COFF_C
450 else if (!strcmp (sec_name, _PAD))
452 styp_flags = STYP_PAD;
454 else if (!strcmp (sec_name, _LOADER))
456 styp_flags = STYP_LOADER;
458 else if (!strcmp (sec_name, _EXCEPT))
460 styp_flags = STYP_EXCEPT;
462 else if (!strcmp (sec_name, _TYPCHK))
464 styp_flags = STYP_TYPCHK;
466 #endif
467 /* Try and figure out what it should be */
468 else if (sec_flags & SEC_CODE)
470 styp_flags = STYP_TEXT;
472 else if (sec_flags & SEC_DATA)
474 styp_flags = STYP_DATA;
476 else if (sec_flags & SEC_READONLY)
478 #ifdef STYP_LIT /* 29k readonly text/data section */
479 styp_flags = STYP_LIT;
480 #else
481 styp_flags = STYP_TEXT;
482 #endif /* STYP_LIT */
484 else if (sec_flags & SEC_LOAD)
486 styp_flags = STYP_TEXT;
488 else if (sec_flags & SEC_ALLOC)
490 styp_flags = STYP_BSS;
493 #ifdef STYP_CLINK
494 if (sec_flags & SEC_CLINK)
495 styp_flags |= STYP_CLINK;
496 #endif
498 #ifdef STYP_BLOCK
499 if (sec_flags & SEC_BLOCK)
500 styp_flags |= STYP_BLOCK;
501 #endif
503 #ifdef STYP_NOLOAD
504 if ((sec_flags & (SEC_NEVER_LOAD | SEC_COFF_SHARED_LIBRARY)) != 0)
505 styp_flags |= STYP_NOLOAD;
506 #endif
508 return styp_flags;
511 #else /* COFF_WITH_PE */
513 /* The PE version; see above for the general comments. The non-PE
514 case seems to be more guessing, and breaks PE format; specifically,
515 .rdata is readonly, but it sure ain't text. Really, all this
516 should be set up properly in gas (or whatever assembler is in use),
517 and honor whatever objcopy/strip, etc. sent us as input. */
519 static long
520 sec_to_styp_flags (sec_name, sec_flags)
521 const char *sec_name ATTRIBUTE_UNUSED;
522 flagword sec_flags;
524 long styp_flags = 0;
526 /* caution: there are at least three groups of symbols that have
527 very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
528 SEC_* are the BFD internal flags, used for generic BFD
529 information. STYP_* are the COFF section flags which appear in
530 COFF files. IMAGE_SCN_* are the PE section flags which appear in
531 PE files. The STYP_* flags and the IMAGE_SCN_* flags overlap,
532 but there are more IMAGE_SCN_* flags. */
534 /* skip LOAD */
535 /* READONLY later */
536 /* skip RELOC */
537 if ((sec_flags & SEC_CODE) != 0)
538 styp_flags |= IMAGE_SCN_CNT_CODE;
539 if ((sec_flags & SEC_DATA) != 0)
540 styp_flags |= IMAGE_SCN_CNT_INITIALIZED_DATA;
541 if ((sec_flags & SEC_ALLOC) != 0 && (sec_flags & SEC_LOAD) == 0)
542 styp_flags |= IMAGE_SCN_CNT_UNINITIALIZED_DATA; /* ==STYP_BSS */
543 /* skip ROM */
544 /* skip constRUCTOR */
545 /* skip CONTENTS */
546 #ifdef STYP_NOLOAD
547 if ((sec_flags & (SEC_NEVER_LOAD | SEC_COFF_SHARED_LIBRARY)) != 0)
548 styp_flags |= STYP_NOLOAD;
549 #endif
550 if ((sec_flags & SEC_IS_COMMON) != 0)
551 styp_flags |= IMAGE_SCN_LNK_COMDAT;
552 if ((sec_flags & SEC_DEBUGGING) != 0)
553 styp_flags |= IMAGE_SCN_MEM_DISCARDABLE;
554 if ((sec_flags & SEC_EXCLUDE) != 0)
555 styp_flags |= IMAGE_SCN_LNK_REMOVE;
556 if ((sec_flags & SEC_NEVER_LOAD) != 0)
557 styp_flags |= IMAGE_SCN_LNK_REMOVE;
558 /* skip IN_MEMORY */
559 /* skip SORT */
560 if (sec_flags & SEC_LINK_ONCE)
561 styp_flags |= IMAGE_SCN_LNK_COMDAT;
562 /* skip LINK_DUPLICATES */
563 /* skip LINKER_CREATED */
565 /* For now, the read/write bits are mapped onto SEC_READONLY, even
566 though the semantics don't quite match. The bits from the input
567 are retained in pei_section_data(abfd, section)->pe_flags. */
569 styp_flags |= IMAGE_SCN_MEM_READ; /* Always readable. */
570 if ((sec_flags & SEC_READONLY) == 0)
571 styp_flags |= IMAGE_SCN_MEM_WRITE; /* Invert READONLY for write. */
572 if (sec_flags & SEC_CODE)
573 styp_flags |= IMAGE_SCN_MEM_EXECUTE; /* CODE->EXECUTE. */
574 if (sec_flags & SEC_SHARED)
575 styp_flags |= IMAGE_SCN_MEM_SHARED; /* Shared remains meaningful. */
577 return styp_flags;
580 #endif /* COFF_WITH_PE */
582 /* Return a word with SEC_* flags set to represent the incoming STYP_*
583 flags (from scnhdr.s_flags). The inverse of this function is
584 sec_to_styp_flags(). NOTE: If you add to/change this routine, you
585 should probably mirror the changes in sec_to_styp_flags(). */
587 #ifndef COFF_WITH_PE
589 static bfd_boolean
590 styp_to_sec_flags (abfd, hdr, name, section, flags_ptr)
591 bfd *abfd ATTRIBUTE_UNUSED;
592 PTR hdr;
593 const char *name;
594 asection *section ATTRIBUTE_UNUSED;
595 flagword *flags_ptr;
597 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
598 long styp_flags = internal_s->s_flags;
599 flagword sec_flags = 0;
601 #ifdef STYP_BLOCK
602 if (styp_flags & STYP_BLOCK)
603 sec_flags |= SEC_BLOCK;
604 #endif
606 #ifdef STYP_CLINK
607 if (styp_flags & STYP_CLINK)
608 sec_flags |= SEC_CLINK;
609 #endif
611 #ifdef STYP_NOLOAD
612 if (styp_flags & STYP_NOLOAD)
613 sec_flags |= SEC_NEVER_LOAD;
614 #endif /* STYP_NOLOAD */
616 /* For 386 COFF, at least, an unloadable text or data section is
617 actually a shared library section. */
618 if (styp_flags & STYP_TEXT)
620 if (sec_flags & SEC_NEVER_LOAD)
621 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
622 else
623 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
625 else if (styp_flags & STYP_DATA)
627 if (sec_flags & SEC_NEVER_LOAD)
628 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
629 else
630 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
632 else if (styp_flags & STYP_BSS)
634 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
635 if (sec_flags & SEC_NEVER_LOAD)
636 sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
637 else
638 #endif
639 sec_flags |= SEC_ALLOC;
641 else if (styp_flags & STYP_INFO)
643 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
644 defined. coff_compute_section_file_positions uses
645 COFF_PAGE_SIZE to ensure that the low order bits of the
646 section VMA and the file offset match. If we don't know
647 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
648 and demand page loading of the file will fail. */
649 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
650 sec_flags |= SEC_DEBUGGING;
651 #endif
653 else if (styp_flags & STYP_PAD)
654 sec_flags = 0;
655 else if (strcmp (name, _TEXT) == 0)
657 if (sec_flags & SEC_NEVER_LOAD)
658 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
659 else
660 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
662 else if (strcmp (name, _DATA) == 0)
664 if (sec_flags & SEC_NEVER_LOAD)
665 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
666 else
667 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
669 else if (strcmp (name, _BSS) == 0)
671 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
672 if (sec_flags & SEC_NEVER_LOAD)
673 sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
674 else
675 #endif
676 sec_flags |= SEC_ALLOC;
678 else if (strncmp (name, ".debug", 6) == 0
679 #ifdef _COMMENT
680 || strcmp (name, _COMMENT) == 0
681 #endif
682 #ifdef COFF_LONG_SECTION_NAMES
683 || strncmp (name, ".gnu.linkonce.wi.", 17) == 0
684 #endif
685 || strncmp (name, ".stab", 5) == 0)
687 #ifdef COFF_PAGE_SIZE
688 sec_flags |= SEC_DEBUGGING;
689 #endif
691 #ifdef _LIB
692 else if (strcmp (name, _LIB) == 0)
694 #endif
695 #ifdef _LIT
696 else if (strcmp (name, _LIT) == 0)
697 sec_flags = SEC_LOAD | SEC_ALLOC | SEC_READONLY;
698 #endif
699 else
700 sec_flags |= SEC_ALLOC | SEC_LOAD;
702 #ifdef STYP_LIT /* A29k readonly text/data section type. */
703 if ((styp_flags & STYP_LIT) == STYP_LIT)
704 sec_flags = (SEC_LOAD | SEC_ALLOC | SEC_READONLY);
705 #endif /* STYP_LIT */
707 #ifdef STYP_OTHER_LOAD /* Other loaded sections. */
708 if (styp_flags & STYP_OTHER_LOAD)
709 sec_flags = (SEC_LOAD | SEC_ALLOC);
710 #endif /* STYP_SDATA */
712 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
713 /* As a GNU extension, if the name begins with .gnu.linkonce, we
714 only link a single copy of the section. This is used to support
715 g++. g++ will emit each template expansion in its own section.
716 The symbols will be defined as weak, so that multiple definitions
717 are permitted. The GNU linker extension is to actually discard
718 all but one of the sections. */
719 if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
720 sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
721 #endif
723 if (flags_ptr == NULL)
724 return FALSE;
726 * flags_ptr = sec_flags;
727 return TRUE;
730 #else /* COFF_WITH_PE */
732 static flagword
733 handle_COMDAT (abfd, sec_flags, hdr, name, section)
734 bfd * abfd;
735 flagword sec_flags;
736 PTR hdr;
737 const char *name;
738 asection *section;
740 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
741 bfd_byte *esymstart, *esym, *esymend;
742 int seen_state = 0;
743 char *target_name = NULL;
745 sec_flags |= SEC_LINK_ONCE;
747 /* Unfortunately, the PE format stores essential information in
748 the symbol table, of all places. We need to extract that
749 information now, so that objdump and the linker will know how
750 to handle the section without worrying about the symbols. We
751 can't call slurp_symtab, because the linker doesn't want the
752 swapped symbols. */
754 /* COMDAT sections are special. The first symbol is the section
755 symbol, which tells what kind of COMDAT section it is. The
756 second symbol is the "comdat symbol" - the one with the
757 unique name. GNU uses the section symbol for the unique
758 name; MS uses ".text" for every comdat section. Sigh. - DJ */
760 /* This is not mirrored in sec_to_styp_flags(), but there
761 doesn't seem to be a need to, either, and it would at best be
762 rather messy. */
764 if (! _bfd_coff_get_external_symbols (abfd))
765 return sec_flags;
767 esymstart = esym = (bfd_byte *) obj_coff_external_syms (abfd);
768 esymend = esym + obj_raw_syment_count (abfd) * bfd_coff_symesz (abfd);
770 while (esym < esymend)
772 struct internal_syment isym;
773 char buf[SYMNMLEN + 1];
774 const char *symname;
776 bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &isym);
778 if (sizeof (internal_s->s_name) > SYMNMLEN)
780 /* This case implies that the matching
781 symbol name will be in the string table. */
782 abort ();
785 if (isym.n_scnum == section->target_index)
787 /* According to the MSVC documentation, the first
788 TWO entries with the section # are both of
789 interest to us. The first one is the "section
790 symbol" (section name). The second is the comdat
791 symbol name. Here, we've found the first
792 qualifying entry; we distinguish it from the
793 second with a state flag.
795 In the case of gas-generated (at least until that
796 is fixed) .o files, it isn't necessarily the
797 second one. It may be some other later symbol.
799 Since gas also doesn't follow MS conventions and
800 emits the section similar to .text$<name>, where
801 <something> is the name we're looking for, we
802 distinguish the two as follows:
804 If the section name is simply a section name (no
805 $) we presume it's MS-generated, and look at
806 precisely the second symbol for the comdat name.
807 If the section name has a $, we assume it's
808 gas-generated, and look for <something> (whatever
809 follows the $) as the comdat symbol. */
811 /* All 3 branches use this. */
812 symname = _bfd_coff_internal_syment_name (abfd, &isym, buf);
814 if (symname == NULL)
815 abort ();
817 switch (seen_state)
819 case 0:
821 /* The first time we've seen the symbol. */
822 union internal_auxent aux;
824 seen_state = 1;
826 /* If it isn't the stuff we're expecting, die;
827 The MS documentation is vague, but it
828 appears that the second entry serves BOTH
829 as the comdat symbol and the defining
830 symbol record (either C_STAT or C_EXT,
831 possibly with an aux entry with debug
832 information if it's a function.) It
833 appears the only way to find the second one
834 is to count. (On Intel, they appear to be
835 adjacent, but on Alpha, they have been
836 found separated.)
838 Here, we think we've found the first one,
839 but there's some checking we can do to be
840 sure. */
842 if (! (isym.n_sclass == C_STAT
843 && isym.n_type == T_NULL
844 && isym.n_value == 0))
845 abort ();
847 /* FIXME LATER: MSVC generates section names
848 like .text for comdats. Gas generates
849 names like .text$foo__Fv (in the case of a
850 function). See comment above for more. */
852 if (strcmp (name, symname) != 0)
853 abort ();
855 /* This is the section symbol. */
856 bfd_coff_swap_aux_in (abfd, (PTR) (esym + bfd_coff_symesz (abfd)),
857 isym.n_type, isym.n_sclass,
858 0, isym.n_numaux, (PTR) &aux);
860 target_name = strchr (name, '$');
861 if (target_name != NULL)
863 /* Gas mode. */
864 seen_state = 2;
865 /* Skip the `$'. */
866 target_name += 1;
869 /* FIXME: Microsoft uses NODUPLICATES and
870 ASSOCIATIVE, but gnu uses ANY and
871 SAME_SIZE. Unfortunately, gnu doesn't do
872 the comdat symbols right. So, until we can
873 fix it to do the right thing, we are
874 temporarily disabling comdats for the MS
875 types (they're used in DLLs and C++, but we
876 don't support *their* C++ libraries anyway
877 - DJ. */
879 /* Cygwin does not follow the MS style, and
880 uses ANY and SAME_SIZE where NODUPLICATES
881 and ASSOCIATIVE should be used. For
882 Interix, we just do the right thing up
883 front. */
885 switch (aux.x_scn.x_comdat)
887 case IMAGE_COMDAT_SELECT_NODUPLICATES:
888 #ifdef STRICT_PE_FORMAT
889 sec_flags |= SEC_LINK_DUPLICATES_ONE_ONLY;
890 #else
891 sec_flags &= ~SEC_LINK_ONCE;
892 #endif
893 break;
895 case IMAGE_COMDAT_SELECT_ANY:
896 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
897 break;
899 case IMAGE_COMDAT_SELECT_SAME_SIZE:
900 sec_flags |= SEC_LINK_DUPLICATES_SAME_SIZE;
901 break;
903 case IMAGE_COMDAT_SELECT_EXACT_MATCH:
904 /* Not yet fully implemented ??? */
905 sec_flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS;
906 break;
908 /* debug$S gets this case; other
909 implications ??? */
911 /* There may be no symbol... we'll search
912 the whole table... Is this the right
913 place to play this game? Or should we do
914 it when reading it in. */
915 case IMAGE_COMDAT_SELECT_ASSOCIATIVE:
916 #ifdef STRICT_PE_FORMAT
917 /* FIXME: This is not currently implemented. */
918 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
919 #else
920 sec_flags &= ~SEC_LINK_ONCE;
921 #endif
922 break;
924 default: /* 0 means "no symbol" */
925 /* debug$F gets this case; other
926 implications ??? */
927 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
928 break;
931 break;
933 case 2:
934 /* Gas mode: the first matching on partial name. */
936 #ifndef TARGET_UNDERSCORE
937 #define TARGET_UNDERSCORE 0
938 #endif
939 /* Is this the name we're looking for ? */
940 if (strcmp (target_name,
941 symname + (TARGET_UNDERSCORE ? 1 : 0)) != 0)
943 /* Not the name we're looking for */
944 esym += (isym.n_numaux + 1) * bfd_coff_symesz (abfd);
945 continue;
947 /* Fall through. */
948 case 1:
949 /* MSVC mode: the lexically second symbol (or
950 drop through from the above). */
952 char *newname;
953 bfd_size_type amt;
955 /* This must the second symbol with the
956 section #. It is the actual symbol name.
957 Intel puts the two adjacent, but Alpha (at
958 least) spreads them out. */
960 amt = sizeof (struct bfd_comdat_info);
961 section->comdat = bfd_alloc (abfd, amt);
962 if (section->comdat == NULL)
963 abort ();
965 section->comdat->symbol =
966 (esym - esymstart) / bfd_coff_symesz (abfd);
968 amt = strlen (symname) + 1;
969 newname = bfd_alloc (abfd, amt);
970 if (newname == NULL)
971 abort ();
973 strcpy (newname, symname);
974 section->comdat->name = newname;
977 goto breakloop;
981 esym += (isym.n_numaux + 1) * bfd_coff_symesz (abfd);
984 breakloop:
985 return sec_flags;
989 /* The PE version; see above for the general comments.
991 Since to set the SEC_LINK_ONCE and associated flags, we have to
992 look at the symbol table anyway, we return the symbol table index
993 of the symbol being used as the COMDAT symbol. This is admittedly
994 ugly, but there's really nowhere else that we have access to the
995 required information. FIXME: Is the COMDAT symbol index used for
996 any purpose other than objdump? */
998 static bfd_boolean
999 styp_to_sec_flags (abfd, hdr, name, section, flags_ptr)
1000 bfd *abfd;
1001 PTR hdr;
1002 const char *name;
1003 asection *section;
1004 flagword *flags_ptr;
1006 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
1007 long styp_flags = internal_s->s_flags;
1008 flagword sec_flags;
1009 bfd_boolean result = TRUE;
1011 /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
1012 sec_flags = SEC_READONLY;
1014 /* Process each flag bit in styp_flags in turn. */
1015 while (styp_flags)
1017 long flag = styp_flags & - styp_flags;
1018 char * unhandled = NULL;
1020 styp_flags &= ~ flag;
1022 /* We infer from the distinct read/write/execute bits the settings
1023 of some of the bfd flags; the actual values, should we need them,
1024 are also in pei_section_data (abfd, section)->pe_flags. */
1026 switch (flag)
1028 case STYP_DSECT:
1029 unhandled = "STYP_DSECT";
1030 break;
1031 case STYP_GROUP:
1032 unhandled = "STYP_GROUP";
1033 break;
1034 case STYP_COPY:
1035 unhandled = "STYP_COPY";
1036 break;
1037 case STYP_OVER:
1038 unhandled = "STYP_OVER";
1039 break;
1040 #ifdef SEC_NEVER_LOAD
1041 case STYP_NOLOAD:
1042 sec_flags |= SEC_NEVER_LOAD;
1043 break;
1044 #endif
1045 case IMAGE_SCN_MEM_READ:
1046 /* Ignored, assume it always to be true. */
1047 break;
1048 case IMAGE_SCN_TYPE_NO_PAD:
1049 /* Skip. */
1050 break;
1051 case IMAGE_SCN_LNK_OTHER:
1052 unhandled = "IMAGE_SCN_LNK_OTHER";
1053 break;
1054 case IMAGE_SCN_MEM_NOT_CACHED:
1055 unhandled = "IMAGE_SCN_MEM_NOT_CACHED";
1056 break;
1057 case IMAGE_SCN_MEM_NOT_PAGED:
1058 unhandled = "IMAGE_SCN_MEM_NOT_PAGED";
1059 break;
1060 case IMAGE_SCN_MEM_EXECUTE:
1061 sec_flags |= SEC_CODE;
1062 break;
1063 case IMAGE_SCN_MEM_WRITE:
1064 sec_flags &= ~ SEC_READONLY;
1065 break;
1066 case IMAGE_SCN_MEM_DISCARDABLE:
1067 /* The MS PE spec sets the DISCARDABLE flag on .reloc sections
1068 but we do not want them to be labelled as debug section, since
1069 then strip would remove them. */
1070 if (strncmp (name, ".reloc", sizeof ".reloc" - 1) != 0)
1071 sec_flags |= SEC_DEBUGGING;
1072 break;
1073 case IMAGE_SCN_MEM_SHARED:
1074 sec_flags |= SEC_SHARED;
1075 break;
1076 case IMAGE_SCN_LNK_REMOVE:
1077 sec_flags |= SEC_EXCLUDE;
1078 break;
1079 case IMAGE_SCN_CNT_CODE:
1080 sec_flags |= SEC_CODE | SEC_ALLOC | SEC_LOAD;
1081 break;
1082 case IMAGE_SCN_CNT_INITIALIZED_DATA:
1083 sec_flags |= SEC_DATA | SEC_ALLOC | SEC_LOAD;
1084 break;
1085 case IMAGE_SCN_CNT_UNINITIALIZED_DATA:
1086 sec_flags |= SEC_ALLOC;
1087 break;
1088 case IMAGE_SCN_LNK_INFO:
1089 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
1090 defined. coff_compute_section_file_positions uses
1091 COFF_PAGE_SIZE to ensure that the low order bits of the
1092 section VMA and the file offset match. If we don't know
1093 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
1094 and demand page loading of the file will fail. */
1095 #ifdef COFF_PAGE_SIZE
1096 sec_flags |= SEC_DEBUGGING;
1097 #endif
1098 break;
1099 case IMAGE_SCN_LNK_COMDAT:
1100 /* COMDAT gets very special treatment. */
1101 sec_flags = handle_COMDAT (abfd, sec_flags, hdr, name, section);
1102 break;
1103 default:
1104 /* Silently ignore for now. */
1105 break;
1108 /* If the section flag was not handled, report it here. */
1109 if (unhandled != NULL)
1111 (*_bfd_error_handler)
1112 (_("%s (%s): Section flag %s (0x%x) ignored"),
1113 bfd_archive_filename (abfd), name, unhandled, flag);
1114 result = FALSE;
1118 #if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1119 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1120 only link a single copy of the section. This is used to support
1121 g++. g++ will emit each template expansion in its own section.
1122 The symbols will be defined as weak, so that multiple definitions
1123 are permitted. The GNU linker extension is to actually discard
1124 all but one of the sections. */
1125 if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
1126 sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
1127 #endif
1129 if (flags_ptr)
1130 * flags_ptr = sec_flags;
1132 return result;
1135 #endif /* COFF_WITH_PE */
1137 #define get_index(symbol) ((symbol)->udata.i)
1140 INTERNAL_DEFINITION
1141 bfd_coff_backend_data
1143 CODE_FRAGMENT
1145 .{* COFF symbol classifications. *}
1147 .enum coff_symbol_classification
1149 . {* Global symbol. *}
1150 . COFF_SYMBOL_GLOBAL,
1151 . {* Common symbol. *}
1152 . COFF_SYMBOL_COMMON,
1153 . {* Undefined symbol. *}
1154 . COFF_SYMBOL_UNDEFINED,
1155 . {* Local symbol. *}
1156 . COFF_SYMBOL_LOCAL,
1157 . {* PE section symbol. *}
1158 . COFF_SYMBOL_PE_SECTION
1161 Special entry points for gdb to swap in coff symbol table parts:
1162 .typedef struct
1164 . void (*_bfd_coff_swap_aux_in)
1165 . PARAMS ((bfd *, PTR, int, int, int, int, PTR));
1167 . void (*_bfd_coff_swap_sym_in)
1168 . PARAMS ((bfd *, PTR, PTR));
1170 . void (*_bfd_coff_swap_lineno_in)
1171 . PARAMS ((bfd *, PTR, PTR));
1173 . unsigned int (*_bfd_coff_swap_aux_out)
1174 . PARAMS ((bfd *, PTR, int, int, int, int, PTR));
1176 . unsigned int (*_bfd_coff_swap_sym_out)
1177 . PARAMS ((bfd *, PTR, PTR));
1179 . unsigned int (*_bfd_coff_swap_lineno_out)
1180 . PARAMS ((bfd *, PTR, PTR));
1182 . unsigned int (*_bfd_coff_swap_reloc_out)
1183 . PARAMS ((bfd *, PTR, PTR));
1185 . unsigned int (*_bfd_coff_swap_filehdr_out)
1186 . PARAMS ((bfd *, PTR, PTR));
1188 . unsigned int (*_bfd_coff_swap_aouthdr_out)
1189 . PARAMS ((bfd *, PTR, PTR));
1191 . unsigned int (*_bfd_coff_swap_scnhdr_out)
1192 . PARAMS ((bfd *, PTR, PTR));
1194 . unsigned int _bfd_filhsz;
1195 . unsigned int _bfd_aoutsz;
1196 . unsigned int _bfd_scnhsz;
1197 . unsigned int _bfd_symesz;
1198 . unsigned int _bfd_auxesz;
1199 . unsigned int _bfd_relsz;
1200 . unsigned int _bfd_linesz;
1201 . unsigned int _bfd_filnmlen;
1202 . bfd_boolean _bfd_coff_long_filenames;
1203 . bfd_boolean _bfd_coff_long_section_names;
1204 . unsigned int _bfd_coff_default_section_alignment_power;
1205 . bfd_boolean _bfd_coff_force_symnames_in_strings;
1206 . unsigned int _bfd_coff_debug_string_prefix_length;
1208 . void (*_bfd_coff_swap_filehdr_in)
1209 . PARAMS ((bfd *, PTR, PTR));
1211 . void (*_bfd_coff_swap_aouthdr_in)
1212 . PARAMS ((bfd *, PTR, PTR));
1214 . void (*_bfd_coff_swap_scnhdr_in)
1215 . PARAMS ((bfd *, PTR, PTR));
1217 . void (*_bfd_coff_swap_reloc_in)
1218 . PARAMS ((bfd *abfd, PTR, PTR));
1220 . bfd_boolean (*_bfd_coff_bad_format_hook)
1221 . PARAMS ((bfd *, PTR));
1223 . bfd_boolean (*_bfd_coff_set_arch_mach_hook)
1224 . PARAMS ((bfd *, PTR));
1226 . PTR (*_bfd_coff_mkobject_hook)
1227 . PARAMS ((bfd *, PTR, PTR));
1229 . bfd_boolean (*_bfd_styp_to_sec_flags_hook)
1230 . PARAMS ((bfd *, PTR, const char *, asection *, flagword *));
1232 . void (*_bfd_set_alignment_hook)
1233 . PARAMS ((bfd *, asection *, PTR));
1235 . bfd_boolean (*_bfd_coff_slurp_symbol_table)
1236 . PARAMS ((bfd *));
1238 . bfd_boolean (*_bfd_coff_symname_in_debug)
1239 . PARAMS ((bfd *, struct internal_syment *));
1241 . bfd_boolean (*_bfd_coff_pointerize_aux_hook)
1242 . PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
1243 . unsigned int, combined_entry_type *));
1245 . bfd_boolean (*_bfd_coff_print_aux)
1246 . PARAMS ((bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1247 . combined_entry_type *, unsigned int));
1249 . void (*_bfd_coff_reloc16_extra_cases)
1250 . PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
1251 . bfd_byte *, unsigned int *, unsigned int *));
1253 . int (*_bfd_coff_reloc16_estimate)
1254 . PARAMS ((bfd *, asection *, arelent *, unsigned int,
1255 . struct bfd_link_info *));
1257 . enum coff_symbol_classification (*_bfd_coff_classify_symbol)
1258 . PARAMS ((bfd *, struct internal_syment *));
1260 . bfd_boolean (*_bfd_coff_compute_section_file_positions)
1261 . PARAMS ((bfd *));
1263 . bfd_boolean (*_bfd_coff_start_final_link)
1264 . PARAMS ((bfd *, struct bfd_link_info *));
1266 . bfd_boolean (*_bfd_coff_relocate_section)
1267 . PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
1268 . struct internal_reloc *, struct internal_syment *, asection **));
1270 . reloc_howto_type *(*_bfd_coff_rtype_to_howto)
1271 . PARAMS ((bfd *, asection *, struct internal_reloc *,
1272 . struct coff_link_hash_entry *, struct internal_syment *,
1273 . bfd_vma *));
1275 . bfd_boolean (*_bfd_coff_adjust_symndx)
1276 . PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *,
1277 . struct internal_reloc *, bfd_boolean *));
1279 . bfd_boolean (*_bfd_coff_link_add_one_symbol)
1280 . PARAMS ((struct bfd_link_info *, bfd *, const char *, flagword,
1281 . asection *, bfd_vma, const char *, bfd_boolean, bfd_boolean,
1282 . struct bfd_link_hash_entry **));
1284 . bfd_boolean (*_bfd_coff_link_output_has_begun)
1285 . PARAMS ((bfd *, struct coff_final_link_info *));
1287 . bfd_boolean (*_bfd_coff_final_link_postscript)
1288 . PARAMS ((bfd *, struct coff_final_link_info *));
1290 .} bfd_coff_backend_data;
1292 .#define coff_backend_info(abfd) \
1293 . ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1295 .#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1296 . ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1298 .#define bfd_coff_swap_sym_in(a,e,i) \
1299 . ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1301 .#define bfd_coff_swap_lineno_in(a,e,i) \
1302 . ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1304 .#define bfd_coff_swap_reloc_out(abfd, i, o) \
1305 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1307 .#define bfd_coff_swap_lineno_out(abfd, i, o) \
1308 . ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1310 .#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1311 . ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1313 .#define bfd_coff_swap_sym_out(abfd, i,o) \
1314 . ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1316 .#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1317 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1319 .#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1320 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1322 .#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1323 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1325 .#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1326 .#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1327 .#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1328 .#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1329 .#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1330 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1331 .#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
1332 .#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
1333 .#define bfd_coff_long_filenames(abfd) \
1334 . (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1335 .#define bfd_coff_long_section_names(abfd) \
1336 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1337 .#define bfd_coff_default_section_alignment_power(abfd) \
1338 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1339 .#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1340 . ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1342 .#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1343 . ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1345 .#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1346 . ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1348 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
1349 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1351 .#define bfd_coff_bad_format_hook(abfd, filehdr) \
1352 . ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1354 .#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1355 . ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1356 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1357 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook)\
1358 . (abfd, filehdr, aouthdr))
1360 .#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\
1361 . ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1362 . (abfd, scnhdr, name, section, flags_ptr))
1364 .#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1365 . ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1367 .#define bfd_coff_slurp_symbol_table(abfd)\
1368 . ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1370 .#define bfd_coff_symname_in_debug(abfd, sym)\
1371 . ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1373 .#define bfd_coff_force_symnames_in_strings(abfd)\
1374 . (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
1376 .#define bfd_coff_debug_string_prefix_length(abfd)\
1377 . (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
1379 .#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1380 . ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1381 . (abfd, file, base, symbol, aux, indaux))
1383 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order,\
1384 . reloc, data, src_ptr, dst_ptr)\
1385 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1386 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1388 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1389 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1390 . (abfd, section, reloc, shrink, link_info))
1392 .#define bfd_coff_classify_symbol(abfd, sym)\
1393 . ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1394 . (abfd, sym))
1396 .#define bfd_coff_compute_section_file_positions(abfd)\
1397 . ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1398 . (abfd))
1400 .#define bfd_coff_start_final_link(obfd, info)\
1401 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1402 . (obfd, info))
1403 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1404 . ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1405 . (obfd, info, ibfd, o, con, rel, isyms, secs))
1406 .#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1407 . ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1408 . (abfd, sec, rel, h, sym, addendp))
1409 .#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1410 . ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1411 . (obfd, info, ibfd, sec, rel, adjustedp))
1412 .#define bfd_coff_link_add_one_symbol(info, abfd, name, flags, section,\
1413 . value, string, cp, coll, hashp)\
1414 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1415 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1417 .#define bfd_coff_link_output_has_begun(a,p) \
1418 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a,p))
1419 .#define bfd_coff_final_link_postscript(a,p) \
1420 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a,p))
1424 /* See whether the magic number matches. */
1426 static bfd_boolean
1427 coff_bad_format_hook (abfd, filehdr)
1428 bfd * abfd ATTRIBUTE_UNUSED;
1429 PTR filehdr;
1431 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1433 if (BADMAG (*internal_f))
1434 return FALSE;
1436 /* If the optional header is NULL or not the correct size then
1437 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1438 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1439 optional header is of a different size.
1441 But the mips keeps extra stuff in it's opthdr, so dont check
1442 when doing that. */
1444 #if defined(M88) || defined(I960)
1445 if (internal_f->f_opthdr != 0 && bfd_coff_aoutsz (abfd) != internal_f->f_opthdr)
1446 return FALSE;
1447 #endif
1449 return TRUE;
1452 #ifdef TICOFF
1453 static bfd_boolean
1454 ticoff0_bad_format_hook (abfd, filehdr)
1455 bfd *abfd ATTRIBUTE_UNUSED;
1456 PTR filehdr;
1458 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1460 if (COFF0_BADMAG (*internal_f))
1461 return FALSE;
1463 return TRUE;
1465 #endif
1467 #ifdef TICOFF
1468 static bfd_boolean
1469 ticoff1_bad_format_hook (abfd, filehdr)
1470 bfd *abfd ATTRIBUTE_UNUSED;
1471 PTR filehdr;
1473 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1475 if (COFF1_BADMAG (*internal_f))
1476 return FALSE;
1478 return TRUE;
1480 #endif
1482 /* Check whether this section uses an alignment other than the
1483 default. */
1485 static void
1486 coff_set_custom_section_alignment (abfd, section, alignment_table, table_size)
1487 bfd *abfd ATTRIBUTE_UNUSED;
1488 asection *section;
1489 const struct coff_section_alignment_entry *alignment_table;
1490 const unsigned int table_size;
1492 const unsigned int default_alignment = COFF_DEFAULT_SECTION_ALIGNMENT_POWER;
1493 unsigned int i;
1495 for (i = 0; i < table_size; ++i)
1497 const char *secname = bfd_get_section_name (abfd, section);
1499 if (alignment_table[i].comparison_length == (unsigned int) -1
1500 ? strcmp (alignment_table[i].name, secname) == 0
1501 : strncmp (alignment_table[i].name, secname,
1502 alignment_table[i].comparison_length) == 0)
1503 break;
1505 if (i >= table_size)
1506 return;
1508 if (alignment_table[i].default_alignment_min != COFF_ALIGNMENT_FIELD_EMPTY
1509 && default_alignment < alignment_table[i].default_alignment_min)
1510 return;
1512 if (alignment_table[i].default_alignment_max != COFF_ALIGNMENT_FIELD_EMPTY
1513 #if COFF_DEFAULT_SECTION_ALIGNMENT_POWER != 0
1514 && default_alignment > alignment_table[i].default_alignment_max
1515 #endif
1517 return;
1519 section->alignment_power = alignment_table[i].alignment_power;
1522 /* Custom section alignment records. */
1524 static const struct coff_section_alignment_entry
1525 coff_section_alignment_table[] =
1527 #ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1528 COFF_SECTION_ALIGNMENT_ENTRIES,
1529 #endif
1530 /* There must not be any gaps between .stabstr sections. */
1531 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1532 1, COFF_ALIGNMENT_FIELD_EMPTY, 0 },
1533 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1534 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1535 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 },
1536 /* Similarly for the .ctors and .dtors sections. */
1537 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1538 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 },
1539 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1540 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 }
1543 static const unsigned int coff_section_alignment_table_size =
1544 sizeof coff_section_alignment_table / sizeof coff_section_alignment_table[0];
1546 /* Initialize a section structure with information peculiar to this
1547 particular implementation of COFF. */
1549 static bfd_boolean
1550 coff_new_section_hook (abfd, section)
1551 bfd * abfd;
1552 asection * section;
1554 combined_entry_type *native;
1555 bfd_size_type amt;
1557 section->alignment_power = COFF_DEFAULT_SECTION_ALIGNMENT_POWER;
1559 #ifdef RS6000COFF_C
1560 if (bfd_xcoff_text_align_power (abfd) != 0
1561 && strcmp (bfd_get_section_name (abfd, section), ".text") == 0)
1562 section->alignment_power = bfd_xcoff_text_align_power (abfd);
1563 if (bfd_xcoff_data_align_power (abfd) != 0
1564 && strcmp (bfd_get_section_name (abfd, section), ".data") == 0)
1565 section->alignment_power = bfd_xcoff_data_align_power (abfd);
1566 #endif
1568 /* Allocate aux records for section symbols, to store size and
1569 related info.
1571 @@ The 10 is a guess at a plausible maximum number of aux entries
1572 (but shouldn't be a constant). */
1573 amt = sizeof (combined_entry_type) * 10;
1574 native = (combined_entry_type *) bfd_zalloc (abfd, amt);
1575 if (native == NULL)
1576 return FALSE;
1578 /* We don't need to set up n_name, n_value, or n_scnum in the native
1579 symbol information, since they'll be overridden by the BFD symbol
1580 anyhow. However, we do need to set the type and storage class,
1581 in case this symbol winds up getting written out. The value 0
1582 for n_numaux is already correct. */
1584 native->u.syment.n_type = T_NULL;
1585 native->u.syment.n_sclass = C_STAT;
1587 coffsymbol (section->symbol)->native = native;
1589 coff_set_custom_section_alignment (abfd, section,
1590 coff_section_alignment_table,
1591 coff_section_alignment_table_size);
1593 return TRUE;
1596 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1598 /* Set the alignment of a BFD section. */
1600 static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1602 static void
1603 coff_set_alignment_hook (abfd, section, scnhdr)
1604 bfd * abfd ATTRIBUTE_UNUSED;
1605 asection * section;
1606 PTR scnhdr;
1608 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1609 unsigned int i;
1611 #ifdef I960
1612 /* Extract ALIGN from 2**ALIGN stored in section header. */
1613 for (i = 0; i < 32; i++)
1614 if ((1 << i) >= hdr->s_align)
1615 break;
1616 #endif
1617 #ifdef TIC80COFF
1618 /* TI tools puts the alignment power in bits 8-11. */
1619 i = (hdr->s_flags >> 8) & 0xF ;
1620 #endif
1621 #ifdef COFF_DECODE_ALIGNMENT
1622 i = COFF_DECODE_ALIGNMENT(hdr->s_flags);
1623 #endif
1624 section->alignment_power = i;
1626 #ifdef coff_set_section_load_page
1627 coff_set_section_load_page (section, hdr->s_page);
1628 #endif
1631 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1632 #ifdef COFF_WITH_PE
1634 /* A couple of macros to help setting the alignment power field. */
1635 #define ALIGN_SET(field,x,y) \
1636 if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x )\
1638 section->alignment_power = y;\
1641 #define ELIFALIGN_SET(field,x,y) \
1642 else if (( (field) & IMAGE_SCN_ALIGN_64BYTES) == x ) \
1644 section->alignment_power = y;\
1647 static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1649 static void
1650 coff_set_alignment_hook (abfd, section, scnhdr)
1651 bfd * abfd ATTRIBUTE_UNUSED;
1652 asection * section;
1653 PTR scnhdr;
1655 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1656 bfd_size_type amt;
1658 ALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_64BYTES, 6)
1659 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_32BYTES, 5)
1660 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_16BYTES, 4)
1661 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_8BYTES, 3)
1662 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_4BYTES, 2)
1663 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_2BYTES, 1)
1664 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_1BYTES, 0)
1666 /* In a PE image file, the s_paddr field holds the virtual size of a
1667 section, while the s_size field holds the raw size. We also keep
1668 the original section flag value, since not every bit can be
1669 mapped onto a generic BFD section bit. */
1670 if (coff_section_data (abfd, section) == NULL)
1672 amt = sizeof (struct coff_section_tdata);
1673 section->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
1674 if (section->used_by_bfd == NULL)
1676 /* FIXME: Return error. */
1677 abort ();
1680 if (pei_section_data (abfd, section) == NULL)
1682 amt = sizeof (struct pei_section_tdata);
1683 coff_section_data (abfd, section)->tdata = (PTR) bfd_zalloc (abfd, amt);
1684 if (coff_section_data (abfd, section)->tdata == NULL)
1686 /* FIXME: Return error. */
1687 abort ();
1690 pei_section_data (abfd, section)->virt_size = hdr->s_paddr;
1691 pei_section_data (abfd, section)->pe_flags = hdr->s_flags;
1693 section->lma = hdr->s_vaddr;
1695 /* Check for extended relocs. */
1696 if (hdr->s_flags & IMAGE_SCN_LNK_NRELOC_OVFL)
1698 struct external_reloc dst;
1699 struct internal_reloc n;
1700 file_ptr oldpos = bfd_tell (abfd);
1701 bfd_size_type relsz = bfd_coff_relsz (abfd);
1703 bfd_seek (abfd, (file_ptr) hdr->s_relptr, 0);
1704 if (bfd_bread ((PTR) &dst, relsz, abfd) != relsz)
1705 return;
1707 coff_swap_reloc_in (abfd, &dst, &n);
1708 bfd_seek (abfd, oldpos, 0);
1709 section->reloc_count = hdr->s_nreloc = n.r_vaddr - 1;
1710 section->rel_filepos += relsz;
1712 else if (hdr->s_nreloc == 0xffff)
1713 (*_bfd_error_handler)
1714 ("%s: warning: claims to have 0xffff relocs, without overflow",
1715 bfd_get_filename (abfd));
1717 #undef ALIGN_SET
1718 #undef ELIFALIGN_SET
1720 #else /* ! COFF_WITH_PE */
1721 #ifdef RS6000COFF_C
1723 /* We grossly abuse this function to handle XCOFF overflow headers.
1724 When we see one, we correct the reloc and line number counts in the
1725 real header, and remove the section we just created. */
1727 static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1729 static void
1730 coff_set_alignment_hook (abfd, section, scnhdr)
1731 bfd *abfd;
1732 asection *section;
1733 PTR scnhdr;
1735 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1736 asection *real_sec;
1737 asection **ps;
1739 if ((hdr->s_flags & STYP_OVRFLO) == 0)
1740 return;
1742 real_sec = coff_section_from_bfd_index (abfd, (int) hdr->s_nreloc);
1743 if (real_sec == NULL)
1744 return;
1746 real_sec->reloc_count = hdr->s_paddr;
1747 real_sec->lineno_count = hdr->s_vaddr;
1749 for (ps = &abfd->sections; *ps != NULL; ps = &(*ps)->next)
1751 if (*ps == section)
1753 bfd_section_list_remove (abfd, ps);
1754 --abfd->section_count;
1755 break;
1760 #else /* ! RS6000COFF_C */
1762 #define coff_set_alignment_hook \
1763 ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
1765 #endif /* ! RS6000COFF_C */
1766 #endif /* ! COFF_WITH_PE */
1767 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1769 #ifndef coff_mkobject
1771 static bfd_boolean coff_mkobject PARAMS ((bfd *));
1773 static bfd_boolean
1774 coff_mkobject (abfd)
1775 bfd * abfd;
1777 coff_data_type *coff;
1778 bfd_size_type amt = sizeof (coff_data_type);
1780 abfd->tdata.coff_obj_data = (struct coff_tdata *) bfd_zalloc (abfd, amt);
1781 if (abfd->tdata.coff_obj_data == 0)
1782 return FALSE;
1783 coff = coff_data (abfd);
1784 coff->symbols = (coff_symbol_type *) NULL;
1785 coff->conversion_table = (unsigned int *) NULL;
1786 coff->raw_syments = (struct coff_ptr_struct *) NULL;
1787 coff->relocbase = 0;
1788 coff->local_toc_sym_map = 0;
1790 /* make_abs_section(abfd);*/
1792 return TRUE;
1794 #endif
1796 /* Create the COFF backend specific information. */
1798 #ifndef coff_mkobject_hook
1799 static PTR
1800 coff_mkobject_hook (abfd, filehdr, aouthdr)
1801 bfd * abfd;
1802 PTR filehdr;
1803 PTR aouthdr ATTRIBUTE_UNUSED;
1805 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1806 coff_data_type *coff;
1808 if (! coff_mkobject (abfd))
1809 return NULL;
1811 coff = coff_data (abfd);
1813 coff->sym_filepos = internal_f->f_symptr;
1815 /* These members communicate important constants about the symbol
1816 table to GDB's symbol-reading code. These `constants'
1817 unfortunately vary among coff implementations... */
1818 coff->local_n_btmask = N_BTMASK;
1819 coff->local_n_btshft = N_BTSHFT;
1820 coff->local_n_tmask = N_TMASK;
1821 coff->local_n_tshift = N_TSHIFT;
1822 coff->local_symesz = bfd_coff_symesz (abfd);
1823 coff->local_auxesz = bfd_coff_auxesz (abfd);
1824 coff->local_linesz = bfd_coff_linesz (abfd);
1826 coff->timestamp = internal_f->f_timdat;
1828 obj_raw_syment_count (abfd) =
1829 obj_conv_table_size (abfd) =
1830 internal_f->f_nsyms;
1832 #ifdef RS6000COFF_C
1833 if ((internal_f->f_flags & F_SHROBJ) != 0)
1834 abfd->flags |= DYNAMIC;
1835 if (aouthdr != NULL && internal_f->f_opthdr >= bfd_coff_aoutsz (abfd))
1837 struct internal_aouthdr *internal_a =
1838 (struct internal_aouthdr *) aouthdr;
1839 struct xcoff_tdata *xcoff;
1841 xcoff = xcoff_data (abfd);
1842 # ifdef U803XTOCMAGIC
1843 xcoff->xcoff64 = internal_f->f_magic == U803XTOCMAGIC;
1844 # else
1845 xcoff->xcoff64 = 0;
1846 # endif
1847 xcoff->full_aouthdr = TRUE;
1848 xcoff->toc = internal_a->o_toc;
1849 xcoff->sntoc = internal_a->o_sntoc;
1850 xcoff->snentry = internal_a->o_snentry;
1851 bfd_xcoff_text_align_power (abfd) = internal_a->o_algntext;
1852 bfd_xcoff_data_align_power (abfd) = internal_a->o_algndata;
1853 xcoff->modtype = internal_a->o_modtype;
1854 xcoff->cputype = internal_a->o_cputype;
1855 xcoff->maxdata = internal_a->o_maxdata;
1856 xcoff->maxstack = internal_a->o_maxstack;
1858 #endif
1860 #ifdef ARM
1861 /* Set the flags field from the COFF header read in. */
1862 if (! _bfd_coff_arm_set_private_flags (abfd, internal_f->f_flags))
1863 coff->flags = 0;
1864 #endif
1866 #ifdef COFF_WITH_PE
1867 /* FIXME: I'm not sure this is ever executed, since peicode.h
1868 defines coff_mkobject_hook. */
1869 if ((internal_f->f_flags & IMAGE_FILE_DEBUG_STRIPPED) == 0)
1870 abfd->flags |= HAS_DEBUG;
1871 #endif
1873 return (PTR) coff;
1875 #endif
1877 /* Determine the machine architecture and type. FIXME: This is target
1878 dependent because the magic numbers are defined in the target
1879 dependent header files. But there is no particular need for this.
1880 If the magic numbers were moved to a separate file, this function
1881 would be target independent and would also be much more successful
1882 at linking together COFF files for different architectures. */
1884 static bfd_boolean
1885 coff_set_arch_mach_hook (abfd, filehdr)
1886 bfd *abfd;
1887 PTR filehdr;
1889 unsigned long machine;
1890 enum bfd_architecture arch;
1891 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1893 /* Zero selects the default machine for an arch. */
1894 machine = 0;
1895 switch (internal_f->f_magic)
1897 #ifdef OR32_MAGIC_BIG
1898 case OR32_MAGIC_BIG:
1899 case OR32_MAGIC_LITTLE:
1900 arch = bfd_arch_or32;
1901 break;
1902 #endif
1903 #ifdef PPCMAGIC
1904 case PPCMAGIC:
1905 arch = bfd_arch_powerpc;
1906 break;
1907 #endif
1908 #ifdef I386MAGIC
1909 case I386MAGIC:
1910 case I386PTXMAGIC:
1911 case I386AIXMAGIC: /* Danbury PS/2 AIX C Compiler */
1912 case LYNXCOFFMAGIC: /* shadows the m68k Lynx number below, sigh */
1913 arch = bfd_arch_i386;
1914 break;
1915 #endif
1916 #ifdef IA64MAGIC
1917 case IA64MAGIC:
1918 arch = bfd_arch_ia64;
1919 break;
1920 #endif
1921 #ifdef A29K_MAGIC_BIG
1922 case A29K_MAGIC_BIG:
1923 case A29K_MAGIC_LITTLE:
1924 arch = bfd_arch_a29k;
1925 break;
1926 #endif
1927 #ifdef ARMMAGIC
1928 case ARMMAGIC:
1929 case ARMPEMAGIC:
1930 case THUMBPEMAGIC:
1931 arch = bfd_arch_arm;
1932 machine = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION);
1933 if (machine == bfd_mach_arm_unknown)
1935 switch (internal_f->f_flags & F_ARM_ARCHITECTURE_MASK)
1937 case F_ARM_2: machine = bfd_mach_arm_2; break;
1938 case F_ARM_2a: machine = bfd_mach_arm_2a; break;
1939 case F_ARM_3: machine = bfd_mach_arm_3; break;
1940 default:
1941 case F_ARM_3M: machine = bfd_mach_arm_3M; break;
1942 case F_ARM_4: machine = bfd_mach_arm_4; break;
1943 case F_ARM_4T: machine = bfd_mach_arm_4T; break;
1944 /* The COFF header does not have enough bits available
1945 to cover all the different ARM architectures. So
1946 we interpret F_ARM_5, the highest flag value to mean
1947 "the highest ARM architecture known to BFD" which is
1948 currently the XScale. */
1949 case F_ARM_5: machine = bfd_mach_arm_XScale; break;
1952 break;
1953 #endif
1954 #ifdef MC68MAGIC
1955 case MC68MAGIC:
1956 case M68MAGIC:
1957 #ifdef MC68KBCSMAGIC
1958 case MC68KBCSMAGIC:
1959 #endif
1960 #ifdef APOLLOM68KMAGIC
1961 case APOLLOM68KMAGIC:
1962 #endif
1963 #ifdef LYNXCOFFMAGIC
1964 case LYNXCOFFMAGIC:
1965 #endif
1966 arch = bfd_arch_m68k;
1967 machine = bfd_mach_m68020;
1968 break;
1969 #endif
1970 #ifdef MC88MAGIC
1971 case MC88MAGIC:
1972 case MC88DMAGIC:
1973 case MC88OMAGIC:
1974 arch = bfd_arch_m88k;
1975 machine = 88100;
1976 break;
1977 #endif
1978 #ifdef Z8KMAGIC
1979 case Z8KMAGIC:
1980 arch = bfd_arch_z8k;
1981 switch (internal_f->f_flags & F_MACHMASK)
1983 case F_Z8001:
1984 machine = bfd_mach_z8001;
1985 break;
1986 case F_Z8002:
1987 machine = bfd_mach_z8002;
1988 break;
1989 default:
1990 return FALSE;
1992 break;
1993 #endif
1994 #ifdef I860
1995 case I860MAGIC:
1996 arch = bfd_arch_i860;
1997 break;
1998 #endif
1999 #ifdef I960
2000 #ifdef I960ROMAGIC
2001 case I960ROMAGIC:
2002 case I960RWMAGIC:
2003 arch = bfd_arch_i960;
2004 switch (F_I960TYPE & internal_f->f_flags)
2006 default:
2007 case F_I960CORE:
2008 machine = bfd_mach_i960_core;
2009 break;
2010 case F_I960KB:
2011 machine = bfd_mach_i960_kb_sb;
2012 break;
2013 case F_I960MC:
2014 machine = bfd_mach_i960_mc;
2015 break;
2016 case F_I960XA:
2017 machine = bfd_mach_i960_xa;
2018 break;
2019 case F_I960CA:
2020 machine = bfd_mach_i960_ca;
2021 break;
2022 case F_I960KA:
2023 machine = bfd_mach_i960_ka_sa;
2024 break;
2025 case F_I960JX:
2026 machine = bfd_mach_i960_jx;
2027 break;
2028 case F_I960HX:
2029 machine = bfd_mach_i960_hx;
2030 break;
2032 break;
2033 #endif
2034 #endif
2036 #ifdef RS6000COFF_C
2037 #ifdef XCOFF64
2038 case U64_TOCMAGIC:
2039 case U803XTOCMAGIC:
2040 #else
2041 case U802ROMAGIC:
2042 case U802WRMAGIC:
2043 case U802TOCMAGIC:
2044 #endif
2046 int cputype;
2048 if (xcoff_data (abfd)->cputype != -1)
2049 cputype = xcoff_data (abfd)->cputype & 0xff;
2050 else
2052 /* We did not get a value from the a.out header. If the
2053 file has not been stripped, we may be able to get the
2054 architecture information from the first symbol, if it
2055 is a .file symbol. */
2056 if (obj_raw_syment_count (abfd) == 0)
2057 cputype = 0;
2058 else
2060 bfd_byte *buf;
2061 struct internal_syment sym;
2062 bfd_size_type amt = bfd_coff_symesz (abfd);
2064 buf = (bfd_byte *) bfd_malloc (amt);
2065 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
2066 || bfd_bread (buf, amt, abfd) != amt)
2068 free (buf);
2069 return FALSE;
2071 bfd_coff_swap_sym_in (abfd, (PTR) buf, (PTR) &sym);
2072 if (sym.n_sclass == C_FILE)
2073 cputype = sym.n_type & 0xff;
2074 else
2075 cputype = 0;
2076 free (buf);
2080 /* FIXME: We don't handle all cases here. */
2081 switch (cputype)
2083 default:
2084 case 0:
2085 arch = bfd_xcoff_architecture (abfd);
2086 machine = bfd_xcoff_machine (abfd);
2087 break;
2089 case 1:
2090 arch = bfd_arch_powerpc;
2091 machine = bfd_mach_ppc_601;
2092 break;
2093 case 2: /* 64 bit PowerPC */
2094 arch = bfd_arch_powerpc;
2095 machine = bfd_mach_ppc_620;
2096 break;
2097 case 3:
2098 arch = bfd_arch_powerpc;
2099 machine = bfd_mach_ppc;
2100 break;
2101 case 4:
2102 arch = bfd_arch_rs6000;
2103 machine = bfd_mach_rs6k;
2104 break;
2107 break;
2108 #endif
2110 #ifdef WE32KMAGIC
2111 case WE32KMAGIC:
2112 arch = bfd_arch_we32k;
2113 break;
2114 #endif
2116 #ifdef H8300MAGIC
2117 case H8300MAGIC:
2118 arch = bfd_arch_h8300;
2119 machine = bfd_mach_h8300;
2120 /* !! FIXME this probably isn't the right place for this. */
2121 abfd->flags |= BFD_IS_RELAXABLE;
2122 break;
2123 #endif
2125 #ifdef H8300HMAGIC
2126 case H8300HMAGIC:
2127 arch = bfd_arch_h8300;
2128 machine = bfd_mach_h8300h;
2129 /* !! FIXME this probably isn't the right place for this. */
2130 abfd->flags |= BFD_IS_RELAXABLE;
2131 break;
2132 #endif
2134 #ifdef H8300SMAGIC
2135 case H8300SMAGIC:
2136 arch = bfd_arch_h8300;
2137 machine = bfd_mach_h8300s;
2138 /* !! FIXME this probably isn't the right place for this. */
2139 abfd->flags |= BFD_IS_RELAXABLE;
2140 break;
2141 #endif
2143 #ifdef H8300HNMAGIC
2144 case H8300HNMAGIC:
2145 arch = bfd_arch_h8300;
2146 machine = bfd_mach_h8300hn;
2147 /* !! FIXME this probably isn't the right place for this. */
2148 abfd->flags |= BFD_IS_RELAXABLE;
2149 break;
2150 #endif
2152 #ifdef H8300SNMAGIC
2153 case H8300SNMAGIC:
2154 arch = bfd_arch_h8300;
2155 machine = bfd_mach_h8300sn;
2156 /* !! FIXME this probably isn't the right place for this. */
2157 abfd->flags |= BFD_IS_RELAXABLE;
2158 break;
2159 #endif
2161 #ifdef SH_ARCH_MAGIC_BIG
2162 case SH_ARCH_MAGIC_BIG:
2163 case SH_ARCH_MAGIC_LITTLE:
2164 #ifdef COFF_WITH_PE
2165 case SH_ARCH_MAGIC_WINCE:
2166 #endif
2167 arch = bfd_arch_sh;
2168 break;
2169 #endif
2171 #ifdef MIPS_ARCH_MAGIC_WINCE
2172 case MIPS_ARCH_MAGIC_WINCE:
2173 arch = bfd_arch_mips;
2174 break;
2175 #endif
2177 #ifdef H8500MAGIC
2178 case H8500MAGIC:
2179 arch = bfd_arch_h8500;
2180 break;
2181 #endif
2183 #ifdef SPARCMAGIC
2184 case SPARCMAGIC:
2185 #ifdef LYNXCOFFMAGIC
2186 case LYNXCOFFMAGIC:
2187 #endif
2188 arch = bfd_arch_sparc;
2189 break;
2190 #endif
2192 #ifdef TIC30MAGIC
2193 case TIC30MAGIC:
2194 arch = bfd_arch_tic30;
2195 break;
2196 #endif
2198 #ifdef TICOFF0MAGIC
2199 #ifdef TICOFF_TARGET_ARCH
2200 /* This TI COFF section should be used by all new TI COFF v0 targets. */
2201 case TICOFF0MAGIC:
2202 arch = TICOFF_TARGET_ARCH;
2203 machine = TICOFF_TARGET_MACHINE_GET (internal_f->f_flags);
2204 break;
2205 #endif
2206 #endif
2208 #ifdef TICOFF1MAGIC
2209 /* This TI COFF section should be used by all new TI COFF v1/2 targets. */
2210 /* TI COFF1 and COFF2 use the target_id field to specify which arch. */
2211 case TICOFF1MAGIC:
2212 case TICOFF2MAGIC:
2213 switch (internal_f->f_target_id)
2215 #ifdef TI_TARGET_ID
2216 case TI_TARGET_ID:
2217 arch = TICOFF_TARGET_ARCH;
2218 machine = TICOFF_TARGET_MACHINE_GET (internal_f->f_flags);
2219 break;
2220 #endif
2221 default:
2222 arch = bfd_arch_obscure;
2223 (*_bfd_error_handler)
2224 (_("Unrecognized TI COFF target id '0x%x'"),
2225 internal_f->f_target_id);
2226 break;
2228 break;
2229 #endif
2231 #ifdef TIC80_ARCH_MAGIC
2232 case TIC80_ARCH_MAGIC:
2233 arch = bfd_arch_tic80;
2234 break;
2235 #endif
2237 #ifdef MCOREMAGIC
2238 case MCOREMAGIC:
2239 arch = bfd_arch_mcore;
2240 break;
2241 #endif
2243 #ifdef W65MAGIC
2244 case W65MAGIC:
2245 arch = bfd_arch_w65;
2246 break;
2247 #endif
2249 default: /* Unreadable input file type. */
2250 arch = bfd_arch_obscure;
2251 break;
2254 bfd_default_set_arch_mach (abfd, arch, machine);
2255 return TRUE;
2258 #ifdef SYMNAME_IN_DEBUG
2260 static bfd_boolean symname_in_debug_hook
2261 PARAMS ((bfd *, struct internal_syment *));
2263 static bfd_boolean
2264 symname_in_debug_hook (abfd, sym)
2265 bfd * abfd ATTRIBUTE_UNUSED;
2266 struct internal_syment *sym;
2268 return SYMNAME_IN_DEBUG (sym) != 0;
2271 #else
2273 #define symname_in_debug_hook \
2274 (bfd_boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
2276 #endif
2278 #ifdef RS6000COFF_C
2280 #ifdef XCOFF64
2281 #define FORCE_SYMNAMES_IN_STRINGS
2282 #endif
2284 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */
2286 static bfd_boolean coff_pointerize_aux_hook
2287 PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
2288 unsigned int, combined_entry_type *));
2290 static bfd_boolean
2291 coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux)
2292 bfd *abfd ATTRIBUTE_UNUSED;
2293 combined_entry_type *table_base;
2294 combined_entry_type *symbol;
2295 unsigned int indaux;
2296 combined_entry_type *aux;
2298 int class = symbol->u.syment.n_sclass;
2300 if ((class == C_EXT || class == C_HIDEXT)
2301 && indaux + 1 == symbol->u.syment.n_numaux)
2303 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD)
2305 aux->u.auxent.x_csect.x_scnlen.p =
2306 table_base + aux->u.auxent.x_csect.x_scnlen.l;
2307 aux->fix_scnlen = 1;
2310 /* Return TRUE to indicate that the caller should not do any
2311 further work on this auxent. */
2312 return TRUE;
2315 /* Return FALSE to indicate that this auxent should be handled by
2316 the caller. */
2317 return FALSE;
2320 #else
2321 #ifdef I960
2323 /* We don't want to pointerize bal entries. */
2325 static bfd_boolean coff_pointerize_aux_hook
2326 PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
2327 unsigned int, combined_entry_type *));
2329 static bfd_boolean
2330 coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux)
2331 bfd *abfd ATTRIBUTE_UNUSED;
2332 combined_entry_type *table_base ATTRIBUTE_UNUSED;
2333 combined_entry_type *symbol;
2334 unsigned int indaux;
2335 combined_entry_type *aux ATTRIBUTE_UNUSED;
2337 /* Return TRUE if we don't want to pointerize this aux entry, which
2338 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
2339 return (indaux == 1
2340 && (symbol->u.syment.n_sclass == C_LEAFPROC
2341 || symbol->u.syment.n_sclass == C_LEAFSTAT
2342 || symbol->u.syment.n_sclass == C_LEAFEXT));
2345 #else /* ! I960 */
2347 #define coff_pointerize_aux_hook 0
2349 #endif /* ! I960 */
2350 #endif /* ! RS6000COFF_C */
2352 /* Print an aux entry. This returns TRUE if it has printed it. */
2354 static bfd_boolean coff_print_aux
2355 PARAMS ((bfd *, FILE *, combined_entry_type *, combined_entry_type *,
2356 combined_entry_type *, unsigned int));
2358 static bfd_boolean
2359 coff_print_aux (abfd, file, table_base, symbol, aux, indaux)
2360 bfd *abfd ATTRIBUTE_UNUSED;
2361 FILE *file ATTRIBUTE_UNUSED;
2362 combined_entry_type *table_base ATTRIBUTE_UNUSED;
2363 combined_entry_type *symbol ATTRIBUTE_UNUSED;
2364 combined_entry_type *aux ATTRIBUTE_UNUSED;
2365 unsigned int indaux ATTRIBUTE_UNUSED;
2367 #ifdef RS6000COFF_C
2368 if ((symbol->u.syment.n_sclass == C_EXT
2369 || symbol->u.syment.n_sclass == C_HIDEXT)
2370 && indaux + 1 == symbol->u.syment.n_numaux)
2372 /* This is a csect entry. */
2373 fprintf (file, "AUX ");
2374 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) != XTY_LD)
2376 BFD_ASSERT (! aux->fix_scnlen);
2377 #ifdef XCOFF64
2378 fprintf (file, "val %5lld", aux->u.auxent.x_csect.x_scnlen.l);
2379 #else
2380 fprintf (file, "val %5ld", (long) aux->u.auxent.x_csect.x_scnlen.l);
2381 #endif
2383 else
2385 fprintf (file, "indx ");
2386 if (! aux->fix_scnlen)
2387 #ifdef XCOFF64
2388 fprintf (file, "%4lld", aux->u.auxent.x_csect.x_scnlen.l);
2389 #else
2390 fprintf (file, "%4ld", (long) aux->u.auxent.x_csect.x_scnlen.l);
2391 #endif
2392 else
2393 fprintf (file, "%4ld",
2394 (long) (aux->u.auxent.x_csect.x_scnlen.p - table_base));
2396 fprintf (file,
2397 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2398 aux->u.auxent.x_csect.x_parmhash,
2399 (unsigned int) aux->u.auxent.x_csect.x_snhash,
2400 SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp),
2401 SMTYP_ALIGN (aux->u.auxent.x_csect.x_smtyp),
2402 (unsigned int) aux->u.auxent.x_csect.x_smclas,
2403 aux->u.auxent.x_csect.x_stab,
2404 (unsigned int) aux->u.auxent.x_csect.x_snstab);
2405 return TRUE;
2407 #endif
2409 /* Return FALSE to indicate that no special action was taken. */
2410 return FALSE;
2414 SUBSUBSECTION
2415 Writing relocations
2417 To write relocations, the back end steps though the
2418 canonical relocation table and create an
2419 @code{internal_reloc}. The symbol index to use is removed from
2420 the @code{offset} field in the symbol table supplied. The
2421 address comes directly from the sum of the section base
2422 address and the relocation offset; the type is dug directly
2423 from the howto field. Then the @code{internal_reloc} is
2424 swapped into the shape of an @code{external_reloc} and written
2425 out to disk.
2429 #ifdef TARG_AUX
2431 static int compare_arelent_ptr PARAMS ((const PTR, const PTR));
2433 /* AUX's ld wants relocations to be sorted. */
2434 static int
2435 compare_arelent_ptr (x, y)
2436 const PTR x;
2437 const PTR y;
2439 const arelent **a = (const arelent **) x;
2440 const arelent **b = (const arelent **) y;
2441 bfd_size_type aadr = (*a)->address;
2442 bfd_size_type badr = (*b)->address;
2444 return (aadr < badr ? -1 : badr < aadr ? 1 : 0);
2447 #endif /* TARG_AUX */
2449 static bfd_boolean
2450 coff_write_relocs (abfd, first_undef)
2451 bfd * abfd;
2452 int first_undef;
2454 asection *s;
2456 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
2458 unsigned int i;
2459 struct external_reloc dst;
2460 arelent **p;
2462 #ifndef TARG_AUX
2463 p = s->orelocation;
2464 #else
2466 /* Sort relocations before we write them out. */
2467 bfd_size_type amt;
2469 amt = s->reloc_count;
2470 amt *= sizeof (arelent *);
2471 p = (arelent **) bfd_malloc (amt);
2472 if (p == NULL && s->reloc_count > 0)
2473 return FALSE;
2474 memcpy (p, s->orelocation, (size_t) amt);
2475 qsort (p, s->reloc_count, sizeof (arelent *), compare_arelent_ptr);
2477 #endif
2479 if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0)
2480 return FALSE;
2482 #ifdef COFF_WITH_PE
2483 if (obj_pe (abfd) && s->reloc_count >= 0xffff)
2485 /* Encode real count here as first reloc. */
2486 struct internal_reloc n;
2488 memset ((PTR) & n, 0, sizeof (n));
2489 /* Add one to count *this* reloc (grr). */
2490 n.r_vaddr = s->reloc_count + 1;
2491 coff_swap_reloc_out (abfd, &n, &dst);
2492 if (bfd_bwrite ((PTR) & dst, (bfd_size_type) bfd_coff_relsz (abfd),
2493 abfd) != bfd_coff_relsz (abfd))
2494 return FALSE;
2496 #endif
2498 for (i = 0; i < s->reloc_count; i++)
2500 struct internal_reloc n;
2501 arelent *q = p[i];
2503 memset ((PTR) & n, 0, sizeof (n));
2505 /* Now we've renumbered the symbols we know where the
2506 undefined symbols live in the table. Check the reloc
2507 entries for symbols who's output bfd isn't the right one.
2508 This is because the symbol was undefined (which means
2509 that all the pointers are never made to point to the same
2510 place). This is a bad thing,'cause the symbols attached
2511 to the output bfd are indexed, so that the relocation
2512 entries know which symbol index they point to. So we
2513 have to look up the output symbol here. */
2515 if (q->sym_ptr_ptr[0]->the_bfd != abfd)
2517 int j;
2518 const char *sname = q->sym_ptr_ptr[0]->name;
2519 asymbol **outsyms = abfd->outsymbols;
2521 for (j = first_undef; outsyms[j]; j++)
2523 const char *intable = outsyms[j]->name;
2525 if (strcmp (intable, sname) == 0) {
2526 /* Got a hit, so repoint the reloc. */
2527 q->sym_ptr_ptr = outsyms + j;
2528 break;
2533 n.r_vaddr = q->address + s->vma;
2535 #ifdef R_IHCONST
2536 /* The 29k const/consth reloc pair is a real kludge. The consth
2537 part doesn't have a symbol; it has an offset. So rebuilt
2538 that here. */
2539 if (q->howto->type == R_IHCONST)
2540 n.r_symndx = q->addend;
2541 else
2542 #endif
2543 if (q->sym_ptr_ptr)
2545 #ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2546 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q,s))
2547 #else
2548 if ((*q->sym_ptr_ptr)->section == bfd_abs_section_ptr
2549 && ((*q->sym_ptr_ptr)->flags & BSF_SECTION_SYM) != 0)
2550 #endif
2551 /* This is a relocation relative to the absolute symbol. */
2552 n.r_symndx = -1;
2553 else
2555 n.r_symndx = get_index ((*(q->sym_ptr_ptr)));
2556 /* Take notice if the symbol reloc points to a symbol
2557 we don't have in our symbol table. What should we
2558 do for this?? */
2559 if (n.r_symndx > obj_conv_table_size (abfd))
2560 abort ();
2564 #ifdef SWAP_OUT_RELOC_OFFSET
2565 n.r_offset = q->addend;
2566 #endif
2568 #ifdef SELECT_RELOC
2569 /* Work out reloc type from what is required. */
2570 SELECT_RELOC (n, q->howto);
2571 #else
2572 n.r_type = q->howto->type;
2573 #endif
2574 coff_swap_reloc_out (abfd, &n, &dst);
2576 if (bfd_bwrite ((PTR) & dst, (bfd_size_type) bfd_coff_relsz (abfd),
2577 abfd) != bfd_coff_relsz (abfd))
2578 return FALSE;
2581 #ifdef TARG_AUX
2582 if (p != NULL)
2583 free (p);
2584 #endif
2587 return TRUE;
2590 /* Set flags and magic number of a coff file from architecture and machine
2591 type. Result is TRUE if we can represent the arch&type, FALSE if not. */
2593 static bfd_boolean
2594 coff_set_flags (abfd, magicp, flagsp)
2595 bfd * abfd;
2596 unsigned int *magicp ATTRIBUTE_UNUSED;
2597 unsigned short *flagsp ATTRIBUTE_UNUSED;
2599 switch (bfd_get_arch (abfd))
2601 #ifdef Z8KMAGIC
2602 case bfd_arch_z8k:
2603 *magicp = Z8KMAGIC;
2604 switch (bfd_get_mach (abfd))
2606 case bfd_mach_z8001:
2607 *flagsp = F_Z8001;
2608 break;
2609 case bfd_mach_z8002:
2610 *flagsp = F_Z8002;
2611 break;
2612 default:
2613 return FALSE;
2615 return TRUE;
2616 #endif
2617 #ifdef I960ROMAGIC
2619 case bfd_arch_i960:
2622 unsigned flags;
2623 *magicp = I960ROMAGIC;
2625 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
2626 I960RWMAGIC); FIXME???
2628 switch (bfd_get_mach (abfd))
2630 case bfd_mach_i960_core:
2631 flags = F_I960CORE;
2632 break;
2633 case bfd_mach_i960_kb_sb:
2634 flags = F_I960KB;
2635 break;
2636 case bfd_mach_i960_mc:
2637 flags = F_I960MC;
2638 break;
2639 case bfd_mach_i960_xa:
2640 flags = F_I960XA;
2641 break;
2642 case bfd_mach_i960_ca:
2643 flags = F_I960CA;
2644 break;
2645 case bfd_mach_i960_ka_sa:
2646 flags = F_I960KA;
2647 break;
2648 case bfd_mach_i960_jx:
2649 flags = F_I960JX;
2650 break;
2651 case bfd_mach_i960_hx:
2652 flags = F_I960HX;
2653 break;
2654 default:
2655 return FALSE;
2657 *flagsp = flags;
2658 return TRUE;
2660 break;
2661 #endif
2663 #ifdef TIC30MAGIC
2664 case bfd_arch_tic30:
2665 *magicp = TIC30MAGIC;
2666 return TRUE;
2667 #endif
2669 #ifdef TICOFF_DEFAULT_MAGIC
2670 case TICOFF_TARGET_ARCH:
2671 /* If there's no indication of which version we want, use the default. */
2672 if (!abfd->xvec )
2673 *magicp = TICOFF_DEFAULT_MAGIC;
2674 else
2676 /* We may want to output in a different COFF version. */
2677 switch (abfd->xvec->name[4])
2679 case '0':
2680 *magicp = TICOFF0MAGIC;
2681 break;
2682 case '1':
2683 *magicp = TICOFF1MAGIC;
2684 break;
2685 case '2':
2686 *magicp = TICOFF2MAGIC;
2687 break;
2688 default:
2689 return FALSE;
2692 TICOFF_TARGET_MACHINE_SET (flagsp, bfd_get_mach (abfd));
2693 return TRUE;
2694 #endif
2696 #ifdef TIC80_ARCH_MAGIC
2697 case bfd_arch_tic80:
2698 *magicp = TIC80_ARCH_MAGIC;
2699 return TRUE;
2700 #endif
2701 #ifdef ARMMAGIC
2702 case bfd_arch_arm:
2703 #ifdef ARM_WINCE
2704 * magicp = ARMPEMAGIC;
2705 #else
2706 * magicp = ARMMAGIC;
2707 #endif
2708 * flagsp = 0;
2709 if (APCS_SET (abfd))
2711 if (APCS_26_FLAG (abfd))
2712 * flagsp |= F_APCS26;
2714 if (APCS_FLOAT_FLAG (abfd))
2715 * flagsp |= F_APCS_FLOAT;
2717 if (PIC_FLAG (abfd))
2718 * flagsp |= F_PIC;
2720 if (INTERWORK_SET (abfd) && INTERWORK_FLAG (abfd))
2721 * flagsp |= F_INTERWORK;
2722 switch (bfd_get_mach (abfd))
2724 case bfd_mach_arm_2: * flagsp |= F_ARM_2; break;
2725 case bfd_mach_arm_2a: * flagsp |= F_ARM_2a; break;
2726 case bfd_mach_arm_3: * flagsp |= F_ARM_3; break;
2727 case bfd_mach_arm_3M: * flagsp |= F_ARM_3M; break;
2728 case bfd_mach_arm_4: * flagsp |= F_ARM_4; break;
2729 case bfd_mach_arm_4T: * flagsp |= F_ARM_4T; break;
2730 case bfd_mach_arm_5: * flagsp |= F_ARM_5; break;
2731 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5.
2732 See also the comment in coff_set_arch_mach_hook(). */
2733 case bfd_mach_arm_5T: * flagsp |= F_ARM_5; break;
2734 case bfd_mach_arm_5TE: * flagsp |= F_ARM_5; break;
2735 case bfd_mach_arm_XScale: * flagsp |= F_ARM_5; break;
2737 return TRUE;
2738 #endif
2739 #ifdef PPCMAGIC
2740 case bfd_arch_powerpc:
2741 *magicp = PPCMAGIC;
2742 return TRUE;
2743 break;
2744 #endif
2745 #ifdef I386MAGIC
2746 case bfd_arch_i386:
2747 *magicp = I386MAGIC;
2748 #ifdef LYNXOS
2749 /* Just overwrite the usual value if we're doing Lynx. */
2750 *magicp = LYNXCOFFMAGIC;
2751 #endif
2752 return TRUE;
2753 break;
2754 #endif
2755 #ifdef I860MAGIC
2756 case bfd_arch_i860:
2757 *magicp = I860MAGIC;
2758 return TRUE;
2759 break;
2760 #endif
2761 #ifdef IA64MAGIC
2762 case bfd_arch_ia64:
2763 *magicp = IA64MAGIC;
2764 return TRUE;
2765 break;
2766 #endif
2767 #ifdef MC68MAGIC
2768 case bfd_arch_m68k:
2769 #ifdef APOLLOM68KMAGIC
2770 *magicp = APOLLO_COFF_VERSION_NUMBER;
2771 #else
2772 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2773 #ifdef NAMES_HAVE_UNDERSCORE
2774 *magicp = MC68KBCSMAGIC;
2775 #else
2776 *magicp = MC68MAGIC;
2777 #endif
2778 #endif
2779 #ifdef LYNXOS
2780 /* Just overwrite the usual value if we're doing Lynx. */
2781 *magicp = LYNXCOFFMAGIC;
2782 #endif
2783 return TRUE;
2784 break;
2785 #endif
2787 #ifdef MC88MAGIC
2788 case bfd_arch_m88k:
2789 *magicp = MC88OMAGIC;
2790 return TRUE;
2791 break;
2792 #endif
2793 #ifdef H8300MAGIC
2794 case bfd_arch_h8300:
2795 switch (bfd_get_mach (abfd))
2797 case bfd_mach_h8300:
2798 *magicp = H8300MAGIC;
2799 return TRUE;
2800 case bfd_mach_h8300h:
2801 *magicp = H8300HMAGIC;
2802 return TRUE;
2803 case bfd_mach_h8300s:
2804 *magicp = H8300SMAGIC;
2805 return TRUE;
2806 case bfd_mach_h8300hn:
2807 *magicp = H8300HNMAGIC;
2808 return TRUE;
2809 case bfd_mach_h8300sn:
2810 *magicp = H8300SNMAGIC;
2811 return TRUE;
2813 break;
2814 #endif
2816 #ifdef SH_ARCH_MAGIC_BIG
2817 case bfd_arch_sh:
2818 #ifdef COFF_IMAGE_WITH_PE
2819 *magicp = SH_ARCH_MAGIC_WINCE;
2820 #else
2821 if (bfd_big_endian (abfd))
2822 *magicp = SH_ARCH_MAGIC_BIG;
2823 else
2824 *magicp = SH_ARCH_MAGIC_LITTLE;
2825 #endif
2826 return TRUE;
2827 break;
2828 #endif
2830 #ifdef MIPS_ARCH_MAGIC_WINCE
2831 case bfd_arch_mips:
2832 *magicp = MIPS_ARCH_MAGIC_WINCE;
2833 return TRUE;
2834 break;
2835 #endif
2837 #ifdef SPARCMAGIC
2838 case bfd_arch_sparc:
2839 *magicp = SPARCMAGIC;
2840 #ifdef LYNXOS
2841 /* Just overwrite the usual value if we're doing Lynx. */
2842 *magicp = LYNXCOFFMAGIC;
2843 #endif
2844 return TRUE;
2845 break;
2846 #endif
2848 #ifdef H8500MAGIC
2849 case bfd_arch_h8500:
2850 *magicp = H8500MAGIC;
2851 return TRUE;
2852 break;
2853 #endif
2854 #ifdef A29K_MAGIC_BIG
2855 case bfd_arch_a29k:
2856 if (bfd_big_endian (abfd))
2857 *magicp = A29K_MAGIC_BIG;
2858 else
2859 *magicp = A29K_MAGIC_LITTLE;
2860 return TRUE;
2861 break;
2862 #endif
2864 #ifdef WE32KMAGIC
2865 case bfd_arch_we32k:
2866 *magicp = WE32KMAGIC;
2867 return TRUE;
2868 break;
2869 #endif
2871 #ifdef RS6000COFF_C
2872 case bfd_arch_rs6000:
2873 #ifndef PPCMAGIC
2874 case bfd_arch_powerpc:
2875 #endif
2876 BFD_ASSERT (bfd_get_flavour (abfd) == bfd_target_xcoff_flavour);
2877 *magicp = bfd_xcoff_magic_number (abfd);
2878 return TRUE;
2879 break;
2880 #endif
2882 #ifdef MCOREMAGIC
2883 case bfd_arch_mcore:
2884 * magicp = MCOREMAGIC;
2885 return TRUE;
2886 #endif
2888 #ifdef W65MAGIC
2889 case bfd_arch_w65:
2890 *magicp = W65MAGIC;
2891 return TRUE;
2892 #endif
2894 #ifdef OR32_MAGIC_BIG
2895 case bfd_arch_or32:
2896 if (bfd_big_endian (abfd))
2897 * magicp = OR32_MAGIC_BIG;
2898 else
2899 * magicp = OR32_MAGIC_LITTLE;
2900 return TRUE;
2901 #endif
2903 default: /* Unknown architecture. */
2904 /* Fall through to "return FALSE" below, to avoid
2905 "statement never reached" errors on the one below. */
2906 break;
2909 return FALSE;
2912 static bfd_boolean
2913 coff_set_arch_mach (abfd, arch, machine)
2914 bfd * abfd;
2915 enum bfd_architecture arch;
2916 unsigned long machine;
2918 unsigned dummy1;
2919 unsigned short dummy2;
2921 if (! bfd_default_set_arch_mach (abfd, arch, machine))
2922 return FALSE;
2924 if (arch != bfd_arch_unknown
2925 && ! coff_set_flags (abfd, &dummy1, &dummy2))
2926 return FALSE; /* We can't represent this type */
2928 return TRUE; /* We're easy ... */
2931 #ifdef COFF_IMAGE_WITH_PE
2933 /* This is used to sort sections by VMA, as required by PE image
2934 files. */
2936 static int sort_by_secaddr PARAMS ((const PTR, const PTR));
2938 static int
2939 sort_by_secaddr (arg1, arg2)
2940 const PTR arg1;
2941 const PTR arg2;
2943 const asection *a = *(const asection **) arg1;
2944 const asection *b = *(const asection **) arg2;
2946 if (a->vma < b->vma)
2947 return -1;
2948 else if (a->vma > b->vma)
2949 return 1;
2950 else
2951 return 0;
2954 #endif /* COFF_IMAGE_WITH_PE */
2956 /* Calculate the file position for each section. */
2958 #ifndef I960
2959 #define ALIGN_SECTIONS_IN_FILE
2960 #endif
2961 #if defined(TIC80COFF) || defined(TICOFF)
2962 #undef ALIGN_SECTIONS_IN_FILE
2963 #endif
2965 static bfd_boolean
2966 coff_compute_section_file_positions (abfd)
2967 bfd * abfd;
2969 asection *current;
2970 asection *previous = (asection *) NULL;
2971 file_ptr sofar = bfd_coff_filhsz (abfd);
2972 bfd_boolean align_adjust;
2973 #ifdef ALIGN_SECTIONS_IN_FILE
2974 file_ptr old_sofar;
2975 #endif
2977 #ifdef RS6000COFF_C
2978 /* On XCOFF, if we have symbols, set up the .debug section. */
2979 if (bfd_get_symcount (abfd) > 0)
2981 bfd_size_type sz;
2982 bfd_size_type i, symcount;
2983 asymbol **symp;
2985 sz = 0;
2986 symcount = bfd_get_symcount (abfd);
2987 for (symp = abfd->outsymbols, i = 0; i < symcount; symp++, i++)
2989 coff_symbol_type *cf;
2991 cf = coff_symbol_from (abfd, *symp);
2992 if (cf != NULL
2993 && cf->native != NULL
2994 && SYMNAME_IN_DEBUG (&cf->native->u.syment))
2996 size_t len;
2998 len = strlen (bfd_asymbol_name (*symp));
2999 if (len > SYMNMLEN || bfd_coff_force_symnames_in_strings (abfd))
3000 sz += len + 1 + bfd_coff_debug_string_prefix_length (abfd);
3003 if (sz > 0)
3005 asection *dsec;
3007 dsec = bfd_make_section_old_way (abfd, ".debug");
3008 if (dsec == NULL)
3009 abort ();
3010 dsec->_raw_size = sz;
3011 dsec->flags |= SEC_HAS_CONTENTS;
3014 #endif
3016 #ifdef COFF_IMAGE_WITH_PE
3017 int page_size;
3018 if (coff_data (abfd)->link_info)
3020 page_size = pe_data (abfd)->pe_opthdr.FileAlignment;
3022 /* If no file alignment has been set, default to one.
3023 This repairs 'ld -r' for arm-wince-pe target. */
3024 if (page_size == 0)
3025 page_size = 1;
3027 else
3028 page_size = PE_DEF_FILE_ALIGNMENT;
3029 #else
3030 #ifdef COFF_PAGE_SIZE
3031 int page_size = COFF_PAGE_SIZE;
3032 #endif
3033 #endif
3035 if (bfd_get_start_address (abfd))
3037 /* A start address may have been added to the original file. In this
3038 case it will need an optional header to record it. */
3039 abfd->flags |= EXEC_P;
3042 if (abfd->flags & EXEC_P)
3043 sofar += bfd_coff_aoutsz (abfd);
3044 #ifdef RS6000COFF_C
3045 else if (xcoff_data (abfd)->full_aouthdr)
3046 sofar += bfd_coff_aoutsz (abfd);
3047 else
3048 sofar += SMALL_AOUTSZ;
3049 #endif
3051 sofar += abfd->section_count * bfd_coff_scnhsz (abfd);
3053 #ifdef RS6000COFF_C
3054 /* XCOFF handles overflows in the reloc and line number count fields
3055 by allocating a new section header to hold the correct counts. */
3056 for (current = abfd->sections; current != NULL; current = current->next)
3057 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3058 sofar += bfd_coff_scnhsz (abfd);
3059 #endif
3061 #ifdef COFF_IMAGE_WITH_PE
3063 /* PE requires the sections to be in memory order when listed in
3064 the section headers. It also does not like empty loadable
3065 sections. The sections apparently do not have to be in the
3066 right order in the image file itself, but we do need to get the
3067 target_index values right. */
3069 unsigned int count;
3070 asection **section_list;
3071 unsigned int i;
3072 int target_index;
3073 bfd_size_type amt;
3075 count = 0;
3076 for (current = abfd->sections; current != NULL; current = current->next)
3077 ++count;
3079 /* We allocate an extra cell to simplify the final loop. */
3080 amt = sizeof (struct asection *) * (count + 1);
3081 section_list = bfd_malloc (amt);
3082 if (section_list == NULL)
3083 return FALSE;
3085 i = 0;
3086 for (current = abfd->sections; current != NULL; current = current->next)
3088 section_list[i] = current;
3089 ++i;
3091 section_list[i] = NULL;
3093 qsort (section_list, count, sizeof (asection *), sort_by_secaddr);
3095 /* Rethread the linked list into sorted order; at the same time,
3096 assign target_index values. */
3097 target_index = 1;
3098 abfd->sections = section_list[0];
3099 for (i = 0; i < count; i++)
3101 current = section_list[i];
3102 current->next = section_list[i + 1];
3104 /* Later, if the section has zero size, we'll be throwing it
3105 away, so we don't want to number it now. Note that having
3106 a zero size and having real contents are different
3107 concepts: .bss has no contents, but (usually) non-zero
3108 size. */
3109 if (current->_raw_size == 0)
3111 /* Discard. However, it still might have (valid) symbols
3112 in it, so arbitrarily set it to section 1 (indexing is
3113 1-based here; usually .text). __end__ and other
3114 contents of .endsection really have this happen.
3115 FIXME: This seems somewhat dubious. */
3116 current->target_index = 1;
3118 else
3119 current->target_index = target_index++;
3121 abfd->section_tail = &current->next;
3123 free (section_list);
3125 #else /* ! COFF_IMAGE_WITH_PE */
3127 /* Set the target_index field. */
3128 int target_index;
3130 target_index = 1;
3131 for (current = abfd->sections; current != NULL; current = current->next)
3132 current->target_index = target_index++;
3134 #endif /* ! COFF_IMAGE_WITH_PE */
3136 align_adjust = FALSE;
3137 for (current = abfd->sections;
3138 current != (asection *) NULL;
3139 current = current->next)
3141 #ifdef COFF_IMAGE_WITH_PE
3142 /* With PE we have to pad each section to be a multiple of its
3143 page size too, and remember both sizes. */
3144 if (coff_section_data (abfd, current) == NULL)
3146 bfd_size_type amt = sizeof (struct coff_section_tdata);
3147 current->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
3148 if (current->used_by_bfd == NULL)
3149 return FALSE;
3151 if (pei_section_data (abfd, current) == NULL)
3153 bfd_size_type amt = sizeof (struct pei_section_tdata);
3154 coff_section_data (abfd, current)->tdata
3155 = (PTR) bfd_zalloc (abfd, amt);
3156 if (coff_section_data (abfd, current)->tdata == NULL)
3157 return FALSE;
3159 if (pei_section_data (abfd, current)->virt_size == 0)
3160 pei_section_data (abfd, current)->virt_size = current->_raw_size;
3161 #endif
3163 /* Only deal with sections which have contents. */
3164 if (!(current->flags & SEC_HAS_CONTENTS))
3165 continue;
3167 #ifdef COFF_IMAGE_WITH_PE
3168 /* Make sure we skip empty sections in a PE image. */
3169 if (current->_raw_size == 0)
3170 continue;
3171 #endif
3173 /* Align the sections in the file to the same boundary on
3174 which they are aligned in virtual memory. I960 doesn't
3175 do this (FIXME) so we can stay in sync with Intel. 960
3176 doesn't yet page from files... */
3177 #ifdef ALIGN_SECTIONS_IN_FILE
3178 if ((abfd->flags & EXEC_P) != 0)
3180 /* Make sure this section is aligned on the right boundary - by
3181 padding the previous section up if necessary. */
3183 old_sofar = sofar;
3184 #ifdef RS6000COFF_C
3185 /* AIX loader checks the text section alignment of (vma - filepos)
3186 So even though the filepos may be aligned wrt the o_algntext, for
3187 AIX executables, this check fails. This shows up when a native
3188 AIX executable is stripped with gnu strip because the default vma
3189 of native is 0x10000150 but default for gnu is 0x10000140. Gnu
3190 stripped gnu excutable passes this check because the filepos is
3191 0x0140. This problem also show up with 64 bit shared objects. The
3192 data section must also be aligned. */
3193 if (!strcmp (current->name, _TEXT)
3194 || !strcmp (current->name, _DATA))
3196 bfd_vma pad;
3197 bfd_vma align;
3199 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3201 align = 1 << current->alignment_power;
3202 pad = abs (current->vma - sofar) % align;
3204 if (pad)
3206 pad = align - pad;
3207 sofar += pad;
3210 else
3211 #else
3213 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3215 #endif
3216 if (previous != (asection *) NULL)
3217 previous->_raw_size += sofar - old_sofar;
3220 #endif
3222 /* In demand paged files the low order bits of the file offset
3223 must match the low order bits of the virtual address. */
3224 #ifdef COFF_PAGE_SIZE
3225 if ((abfd->flags & D_PAGED) != 0
3226 && (current->flags & SEC_ALLOC) != 0)
3227 sofar += (current->vma - sofar) % page_size;
3228 #endif
3229 current->filepos = sofar;
3231 #ifdef COFF_IMAGE_WITH_PE
3232 /* Set the padded size. */
3233 current->_raw_size = (current->_raw_size + page_size -1) & -page_size;
3234 #endif
3236 sofar += current->_raw_size;
3238 #ifdef ALIGN_SECTIONS_IN_FILE
3239 /* Make sure that this section is of the right size too. */
3240 if ((abfd->flags & EXEC_P) == 0)
3242 bfd_size_type old_size;
3244 old_size = current->_raw_size;
3245 current->_raw_size = BFD_ALIGN (current->_raw_size,
3246 1 << current->alignment_power);
3247 align_adjust = current->_raw_size != old_size;
3248 sofar += current->_raw_size - old_size;
3250 else
3252 old_sofar = sofar;
3253 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3254 align_adjust = sofar != old_sofar;
3255 current->_raw_size += sofar - old_sofar;
3257 #endif
3259 #ifdef COFF_IMAGE_WITH_PE
3260 /* For PE we need to make sure we pad out to the aligned
3261 _raw_size, in case the caller only writes out data to the
3262 unaligned _raw_size. */
3263 if (pei_section_data (abfd, current)->virt_size < current->_raw_size)
3264 align_adjust = TRUE;
3265 #endif
3267 #ifdef _LIB
3268 /* Force .lib sections to start at zero. The vma is then
3269 incremented in coff_set_section_contents. This is right for
3270 SVR3.2. */
3271 if (strcmp (current->name, _LIB) == 0)
3272 bfd_set_section_vma (abfd, current, 0);
3273 #endif
3275 previous = current;
3278 /* It is now safe to write to the output file. If we needed an
3279 alignment adjustment for the last section, then make sure that
3280 there is a byte at offset sofar. If there are no symbols and no
3281 relocs, then nothing follows the last section. If we don't force
3282 the last byte out, then the file may appear to be truncated. */
3283 if (align_adjust)
3285 bfd_byte b;
3287 b = 0;
3288 if (bfd_seek (abfd, sofar - 1, SEEK_SET) != 0
3289 || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
3290 return FALSE;
3293 /* Make sure the relocations are aligned. We don't need to make
3294 sure that this byte exists, because it will only matter if there
3295 really are relocs. */
3296 sofar = BFD_ALIGN (sofar, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER);
3298 obj_relocbase (abfd) = sofar;
3299 abfd->output_has_begun = TRUE;
3301 return TRUE;
3304 #if 0
3306 /* This can never work, because it is called too late--after the
3307 section positions have been set. I can't figure out what it is
3308 for, so I am going to disable it--Ian Taylor 20 March 1996. */
3310 /* If .file, .text, .data, .bss symbols are missing, add them. */
3311 /* @@ Should we only be adding missing symbols, or overriding the aux
3312 values for existing section symbols? */
3313 static bfd_boolean
3314 coff_add_missing_symbols (abfd)
3315 bfd *abfd;
3317 unsigned int nsyms = bfd_get_symcount (abfd);
3318 asymbol **sympp = abfd->outsymbols;
3319 asymbol **sympp2;
3320 unsigned int i;
3321 int need_text = 1, need_data = 1, need_bss = 1, need_file = 1;
3322 bfd_size_type amt;
3324 for (i = 0; i < nsyms; i++)
3326 coff_symbol_type *csym = coff_symbol_from (abfd, sympp[i]);
3327 const char *name;
3329 if (csym)
3331 /* Only do this if there is a coff representation of the input
3332 symbol. */
3333 if (csym->native && csym->native->u.syment.n_sclass == C_FILE)
3335 need_file = 0;
3336 continue;
3338 name = csym->symbol.name;
3339 if (!name)
3340 continue;
3341 if (!strcmp (name, _TEXT))
3342 need_text = 0;
3343 #ifdef APOLLO_M68
3344 else if (!strcmp (name, ".wtext"))
3345 need_text = 0;
3346 #endif
3347 else if (!strcmp (name, _DATA))
3348 need_data = 0;
3349 else if (!strcmp (name, _BSS))
3350 need_bss = 0;
3353 /* Now i == bfd_get_symcount (abfd). */
3354 /* @@ For now, don't deal with .file symbol. */
3355 need_file = 0;
3357 if (!need_text && !need_data && !need_bss && !need_file)
3358 return TRUE;
3359 nsyms += need_text + need_data + need_bss + need_file;
3360 amt = nsyms;
3361 amt *= sizeof (asymbol *);
3362 sympp2 = (asymbol **) bfd_alloc (abfd, amt);
3363 if (!sympp2)
3364 return FALSE;
3365 memcpy (sympp2, sympp, i * sizeof (asymbol *));
3367 if (need_file)
3368 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
3369 abort ();
3371 if (need_text)
3372 sympp2[i++] = coff_section_symbol (abfd, _TEXT);
3373 if (need_data)
3374 sympp2[i++] = coff_section_symbol (abfd, _DATA);
3375 if (need_bss)
3376 sympp2[i++] = coff_section_symbol (abfd, _BSS);
3377 BFD_ASSERT (i == nsyms);
3378 bfd_set_symtab (abfd, sympp2, nsyms);
3379 return TRUE;
3382 #endif /* 0 */
3384 #ifdef COFF_IMAGE_WITH_PE
3386 static unsigned int pelength;
3387 static unsigned int peheader;
3389 static bfd_boolean
3390 coff_read_word (abfd, value)
3391 bfd *abfd;
3392 unsigned int *value;
3394 unsigned char b[2];
3395 int status;
3397 status = bfd_bread (b, (bfd_size_type) 2, abfd);
3398 if (status < 1)
3400 *value = 0;
3401 return FALSE;
3404 if (status == 1)
3405 *value = (unsigned int) b[0];
3406 else
3407 *value = (unsigned int) (b[0] + (b[1] << 8));
3409 pelength += (unsigned int) status;
3411 return TRUE;
3414 static unsigned int
3415 coff_compute_checksum (abfd)
3416 bfd *abfd;
3418 bfd_boolean more_data;
3419 file_ptr filepos;
3420 unsigned int value;
3421 unsigned int total;
3423 total = 0;
3424 pelength = 0;
3425 filepos = (file_ptr) 0;
3429 if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
3430 return 0;
3432 more_data = coff_read_word (abfd, &value);
3433 total += value;
3434 total = 0xffff & (total + (total >> 0x10));
3435 filepos += 2;
3437 while (more_data);
3439 return (0xffff & (total + (total >> 0x10)));
3442 static bfd_boolean
3443 coff_apply_checksum (abfd)
3444 bfd *abfd;
3446 unsigned int computed;
3447 unsigned int checksum = 0;
3449 if (bfd_seek (abfd, 0x3c, SEEK_SET) != 0)
3450 return FALSE;
3452 if (!coff_read_word (abfd, &peheader))
3453 return FALSE;
3455 if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0)
3456 return FALSE;
3458 checksum = 0;
3459 bfd_bwrite (&checksum, (bfd_size_type) 4, abfd);
3461 if (bfd_seek (abfd, peheader, SEEK_SET) != 0)
3462 return FALSE;
3464 computed = coff_compute_checksum (abfd);
3466 checksum = computed + pelength;
3468 if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0)
3469 return FALSE;
3471 bfd_bwrite (&checksum, (bfd_size_type) 4, abfd);
3473 return TRUE;
3476 #endif /* COFF_IMAGE_WITH_PE */
3478 /* SUPPRESS 558 */
3479 /* SUPPRESS 529 */
3480 static bfd_boolean
3481 coff_write_object_contents (abfd)
3482 bfd * abfd;
3484 asection *current;
3485 bfd_boolean hasrelocs = FALSE;
3486 bfd_boolean haslinno = FALSE;
3487 bfd_boolean hasdebug = FALSE;
3488 file_ptr scn_base;
3489 file_ptr reloc_base;
3490 file_ptr lineno_base;
3491 file_ptr sym_base;
3492 unsigned long reloc_size = 0, reloc_count = 0;
3493 unsigned long lnno_size = 0;
3494 bfd_boolean long_section_names;
3495 asection *text_sec = NULL;
3496 asection *data_sec = NULL;
3497 asection *bss_sec = NULL;
3498 struct internal_filehdr internal_f;
3499 struct internal_aouthdr internal_a;
3500 #ifdef COFF_LONG_SECTION_NAMES
3501 size_t string_size = STRING_SIZE_SIZE;
3502 #endif
3504 bfd_set_error (bfd_error_system_call);
3506 /* Make a pass through the symbol table to count line number entries and
3507 put them into the correct asections. */
3509 lnno_size = coff_count_linenumbers (abfd) * bfd_coff_linesz (abfd);
3511 if (! abfd->output_has_begun)
3513 if (! coff_compute_section_file_positions (abfd))
3514 return FALSE;
3517 reloc_base = obj_relocbase (abfd);
3519 /* Work out the size of the reloc and linno areas. */
3521 for (current = abfd->sections; current != NULL; current =
3522 current->next)
3524 #ifdef COFF_WITH_PE
3525 /* We store the actual reloc count in the first reloc's addr. */
3526 if (obj_pe (abfd) && current->reloc_count >= 0xffff)
3527 reloc_count ++;
3528 #endif
3529 reloc_count += current->reloc_count;
3532 reloc_size = reloc_count * bfd_coff_relsz (abfd);
3534 lineno_base = reloc_base + reloc_size;
3535 sym_base = lineno_base + lnno_size;
3537 /* Indicate in each section->line_filepos its actual file address. */
3538 for (current = abfd->sections; current != NULL; current =
3539 current->next)
3541 if (current->lineno_count)
3543 current->line_filepos = lineno_base;
3544 current->moving_line_filepos = lineno_base;
3545 lineno_base += current->lineno_count * bfd_coff_linesz (abfd);
3547 else
3549 current->line_filepos = 0;
3551 if (current->reloc_count)
3553 current->rel_filepos = reloc_base;
3554 reloc_base += current->reloc_count * bfd_coff_relsz (abfd);
3555 #ifdef COFF_WITH_PE
3556 /* Extra reloc to hold real count. */
3557 if (obj_pe (abfd) && current->reloc_count >= 0xffff)
3558 reloc_base += bfd_coff_relsz (abfd);
3559 #endif
3561 else
3563 current->rel_filepos = 0;
3567 /* Write section headers to the file. */
3568 internal_f.f_nscns = 0;
3570 if ((abfd->flags & EXEC_P) != 0)
3571 scn_base = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
3572 else
3574 scn_base = bfd_coff_filhsz (abfd);
3575 #ifdef RS6000COFF_C
3576 #ifndef XCOFF64
3577 if (xcoff_data (abfd)->full_aouthdr)
3578 scn_base += bfd_coff_aoutsz (abfd);
3579 else
3580 scn_base += SMALL_AOUTSZ;
3581 #endif
3582 #endif
3585 if (bfd_seek (abfd, scn_base, SEEK_SET) != 0)
3586 return FALSE;
3588 long_section_names = FALSE;
3589 for (current = abfd->sections;
3590 current != NULL;
3591 current = current->next)
3593 struct internal_scnhdr section;
3594 bfd_boolean is_reloc_section = FALSE;
3596 #ifdef COFF_IMAGE_WITH_PE
3597 if (strcmp (current->name, ".reloc") == 0)
3599 is_reloc_section = TRUE;
3600 hasrelocs = TRUE;
3601 pe_data (abfd)->has_reloc_section = 1;
3603 #endif
3605 internal_f.f_nscns++;
3607 strncpy (section.s_name, current->name, SCNNMLEN);
3609 #ifdef COFF_LONG_SECTION_NAMES
3610 /* Handle long section names as in PE. This must be compatible
3611 with the code in coff_write_symbols and _bfd_coff_final_link. */
3613 size_t len;
3615 len = strlen (current->name);
3616 if (len > SCNNMLEN)
3618 memset (section.s_name, 0, SCNNMLEN);
3619 sprintf (section.s_name, "/%lu", (unsigned long) string_size);
3620 string_size += len + 1;
3621 long_section_names = TRUE;
3624 #endif
3626 #ifdef _LIB
3627 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3628 Ian Taylor <ian@cygnus.com>. */
3629 if (strcmp (current->name, _LIB) == 0)
3630 section.s_vaddr = 0;
3631 else
3632 #endif
3633 section.s_vaddr = current->vma;
3634 section.s_paddr = current->lma;
3635 section.s_size = current->_raw_size;
3636 #ifdef coff_get_section_load_page
3637 section.s_page = coff_get_section_load_page (current);
3638 #endif
3640 #ifdef COFF_WITH_PE
3641 section.s_paddr = 0;
3642 #endif
3643 #ifdef COFF_IMAGE_WITH_PE
3644 /* Reminder: s_paddr holds the virtual size of the section. */
3645 if (coff_section_data (abfd, current) != NULL
3646 && pei_section_data (abfd, current) != NULL)
3647 section.s_paddr = pei_section_data (abfd, current)->virt_size;
3648 else
3649 section.s_paddr = 0;
3650 #endif
3652 /* If this section has no size or is unloadable then the scnptr
3653 will be 0 too. */
3654 if (current->_raw_size == 0 ||
3655 (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
3656 section.s_scnptr = 0;
3657 else
3658 section.s_scnptr = current->filepos;
3660 section.s_relptr = current->rel_filepos;
3661 section.s_lnnoptr = current->line_filepos;
3662 section.s_nreloc = current->reloc_count;
3663 section.s_nlnno = current->lineno_count;
3664 #ifndef COFF_IMAGE_WITH_PE
3665 /* In PEI, relocs come in the .reloc section. */
3666 if (current->reloc_count != 0)
3667 hasrelocs = TRUE;
3668 #endif
3669 if (current->lineno_count != 0)
3670 haslinno = TRUE;
3671 if ((current->flags & SEC_DEBUGGING) != 0
3672 && ! is_reloc_section)
3673 hasdebug = TRUE;
3675 #ifdef RS6000COFF_C
3676 #ifndef XCOFF64
3677 /* Indicate the use of an XCOFF overflow section header. */
3678 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3680 section.s_nreloc = 0xffff;
3681 section.s_nlnno = 0xffff;
3683 #endif
3684 #endif
3686 section.s_flags = sec_to_styp_flags (current->name, current->flags);
3688 if (!strcmp (current->name, _TEXT))
3689 text_sec = current;
3690 else if (!strcmp (current->name, _DATA))
3691 data_sec = current;
3692 else if (!strcmp (current->name, _BSS))
3693 bss_sec = current;
3695 #ifdef I960
3696 section.s_align = (current->alignment_power
3697 ? 1 << current->alignment_power
3698 : 0);
3699 #endif
3700 #ifdef TIC80COFF
3701 /* TI COFF puts the alignment power in bits 8-11 of the flags. */
3702 section.s_flags |= (current->alignment_power & 0xF) << 8;
3703 #endif
3704 #ifdef COFF_ENCODE_ALIGNMENT
3705 COFF_ENCODE_ALIGNMENT(section, current->alignment_power);
3706 #endif
3708 #ifdef COFF_IMAGE_WITH_PE
3709 /* Suppress output of the sections if they are null. ld
3710 includes the bss and data sections even if there is no size
3711 assigned to them. NT loader doesn't like it if these section
3712 headers are included if the sections themselves are not
3713 needed. See also coff_compute_section_file_positions. */
3714 if (section.s_size == 0)
3715 internal_f.f_nscns--;
3716 else
3717 #endif
3719 SCNHDR buff;
3720 bfd_size_type amt = bfd_coff_scnhsz (abfd);
3722 if (coff_swap_scnhdr_out (abfd, &section, &buff) == 0
3723 || bfd_bwrite ((PTR) &buff, amt, abfd) != amt)
3724 return FALSE;
3727 #ifdef COFF_WITH_PE
3728 /* PE stores COMDAT section information in the symbol table. If
3729 this section is supposed to have some COMDAT info, track down
3730 the symbol in the symbol table and modify it. */
3731 if ((current->flags & SEC_LINK_ONCE) != 0)
3733 unsigned int i, count;
3734 asymbol **psym;
3735 coff_symbol_type *csym = NULL;
3736 asymbol **psymsec;
3738 psymsec = NULL;
3739 count = bfd_get_symcount (abfd);
3740 for (i = 0, psym = abfd->outsymbols; i < count; i++, psym++)
3742 if ((*psym)->section != current)
3743 continue;
3745 /* Remember the location of the first symbol in this
3746 section. */
3747 if (psymsec == NULL)
3748 psymsec = psym;
3750 /* See if this is the section symbol. */
3751 if (strcmp ((*psym)->name, current->name) == 0)
3753 csym = coff_symbol_from (abfd, *psym);
3754 if (csym == NULL
3755 || csym->native == NULL
3756 || csym->native->u.syment.n_numaux < 1
3757 || csym->native->u.syment.n_sclass != C_STAT
3758 || csym->native->u.syment.n_type != T_NULL)
3759 continue;
3761 /* Here *PSYM is the section symbol for CURRENT. */
3763 break;
3767 /* Did we find it?
3768 Note that we might not if we're converting the file from
3769 some other object file format. */
3770 if (i < count)
3772 combined_entry_type *aux;
3774 /* We don't touch the x_checksum field. The
3775 x_associated field is not currently supported. */
3777 aux = csym->native + 1;
3778 switch (current->flags & SEC_LINK_DUPLICATES)
3780 case SEC_LINK_DUPLICATES_DISCARD:
3781 aux->u.auxent.x_scn.x_comdat = IMAGE_COMDAT_SELECT_ANY;
3782 break;
3784 case SEC_LINK_DUPLICATES_ONE_ONLY:
3785 aux->u.auxent.x_scn.x_comdat =
3786 IMAGE_COMDAT_SELECT_NODUPLICATES;
3787 break;
3789 case SEC_LINK_DUPLICATES_SAME_SIZE:
3790 aux->u.auxent.x_scn.x_comdat =
3791 IMAGE_COMDAT_SELECT_SAME_SIZE;
3792 break;
3794 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
3795 aux->u.auxent.x_scn.x_comdat =
3796 IMAGE_COMDAT_SELECT_EXACT_MATCH;
3797 break;
3800 /* The COMDAT symbol must be the first symbol from this
3801 section in the symbol table. In order to make this
3802 work, we move the COMDAT symbol before the first
3803 symbol we found in the search above. It's OK to
3804 rearrange the symbol table at this point, because
3805 coff_renumber_symbols is going to rearrange it
3806 further and fix up all the aux entries. */
3807 if (psym != psymsec)
3809 asymbol *hold;
3810 asymbol **pcopy;
3812 hold = *psym;
3813 for (pcopy = psym; pcopy > psymsec; pcopy--)
3814 pcopy[0] = pcopy[-1];
3815 *psymsec = hold;
3819 #endif /* COFF_WITH_PE */
3822 #ifdef RS6000COFF_C
3823 #ifndef XCOFF64
3824 /* XCOFF handles overflows in the reloc and line number count fields
3825 by creating a new section header to hold the correct values. */
3826 for (current = abfd->sections; current != NULL; current = current->next)
3828 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3830 struct internal_scnhdr scnhdr;
3831 SCNHDR buff;
3832 bfd_size_type amt;
3834 internal_f.f_nscns++;
3835 strncpy (&(scnhdr.s_name[0]), current->name, 8);
3836 scnhdr.s_paddr = current->reloc_count;
3837 scnhdr.s_vaddr = current->lineno_count;
3838 scnhdr.s_size = 0;
3839 scnhdr.s_scnptr = 0;
3840 scnhdr.s_relptr = current->rel_filepos;
3841 scnhdr.s_lnnoptr = current->line_filepos;
3842 scnhdr.s_nreloc = current->target_index;
3843 scnhdr.s_nlnno = current->target_index;
3844 scnhdr.s_flags = STYP_OVRFLO;
3845 amt = bfd_coff_scnhsz (abfd);
3846 if (coff_swap_scnhdr_out (abfd, &scnhdr, &buff) == 0
3847 || bfd_bwrite ((PTR) &buff, amt, abfd) != amt)
3848 return FALSE;
3851 #endif
3852 #endif
3854 /* OK, now set up the filehdr... */
3856 /* Don't include the internal abs section in the section count */
3858 /* We will NOT put a fucking timestamp in the header here. Every time you
3859 put it back, I will come in and take it out again. I'm sorry. This
3860 field does not belong here. We fill it with a 0 so it compares the
3861 same but is not a reasonable time. -- gnu@cygnus.com */
3862 internal_f.f_timdat = 0;
3863 internal_f.f_flags = 0;
3865 if (abfd->flags & EXEC_P)
3866 internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
3867 else
3869 internal_f.f_opthdr = 0;
3870 #ifdef RS6000COFF_C
3871 #ifndef XCOFF64
3872 if (xcoff_data (abfd)->full_aouthdr)
3873 internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
3874 else
3875 internal_f.f_opthdr = SMALL_AOUTSZ;
3876 #endif
3877 #endif
3880 if (!hasrelocs)
3881 internal_f.f_flags |= F_RELFLG;
3882 if (!haslinno)
3883 internal_f.f_flags |= F_LNNO;
3884 if (abfd->flags & EXEC_P)
3885 internal_f.f_flags |= F_EXEC;
3886 #ifdef COFF_IMAGE_WITH_PE
3887 if (! hasdebug)
3888 internal_f.f_flags |= IMAGE_FILE_DEBUG_STRIPPED;
3889 #endif
3891 #ifdef COFF_WITH_PE
3892 internal_f.f_flags |= IMAGE_FILE_32BIT_MACHINE;
3893 #else
3894 if (bfd_little_endian (abfd))
3895 internal_f.f_flags |= F_AR32WR;
3896 else
3897 internal_f.f_flags |= F_AR32W;
3898 #endif
3900 #ifdef TI_TARGET_ID
3901 /* Target id is used in TI COFF v1 and later; COFF0 won't use this field,
3902 but it doesn't hurt to set it internally. */
3903 internal_f.f_target_id = TI_TARGET_ID;
3904 #endif
3905 #ifdef TIC80_TARGET_ID
3906 internal_f.f_target_id = TIC80_TARGET_ID;
3907 #endif
3909 /* FIXME, should do something about the other byte orders and
3910 architectures. */
3912 #ifdef RS6000COFF_C
3913 if ((abfd->flags & DYNAMIC) != 0)
3914 internal_f.f_flags |= F_SHROBJ;
3915 if (bfd_get_section_by_name (abfd, _LOADER) != NULL)
3916 internal_f.f_flags |= F_DYNLOAD;
3917 #endif
3919 memset (&internal_a, 0, sizeof internal_a);
3921 /* Set up architecture-dependent stuff. */
3923 unsigned int magic = 0;
3924 unsigned short flags = 0;
3926 coff_set_flags (abfd, &magic, &flags);
3927 internal_f.f_magic = magic;
3928 internal_f.f_flags |= flags;
3929 /* ...and the "opt"hdr... */
3931 #ifdef A29K
3932 #ifdef ULTRA3 /* NYU's machine */
3933 /* FIXME: This is a bogus check. I really want to see if there
3934 is a .shbss or a .shdata section, if so then set the magic
3935 number to indicate a shared data executable. */
3936 if (internal_f.f_nscns >= 7)
3937 internal_a.magic = SHMAGIC; /* Shared magic. */
3938 else
3939 #endif /* ULTRA3 */
3940 internal_a.magic = NMAGIC; /* Assume separate i/d. */
3941 #define __A_MAGIC_SET__
3942 #endif /* A29K */
3943 #ifdef TICOFF_AOUT_MAGIC
3944 internal_a.magic = TICOFF_AOUT_MAGIC;
3945 #define __A_MAGIC_SET__
3946 #endif
3947 #ifdef TIC80COFF
3948 internal_a.magic = TIC80_ARCH_MAGIC;
3949 #define __A_MAGIC_SET__
3950 #endif /* TIC80 */
3951 #ifdef I860
3952 /* FIXME: What are the a.out magic numbers for the i860? */
3953 internal_a.magic = 0;
3954 #define __A_MAGIC_SET__
3955 #endif /* I860 */
3956 #ifdef I960
3957 internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
3958 #define __A_MAGIC_SET__
3959 #endif /* I960 */
3960 #if M88
3961 #define __A_MAGIC_SET__
3962 internal_a.magic = PAGEMAGICBCS;
3963 #endif /* M88 */
3965 #if APOLLO_M68
3966 #define __A_MAGIC_SET__
3967 internal_a.magic = APOLLO_COFF_VERSION_NUMBER;
3968 #endif
3970 #if defined(M68) || defined(WE32K) || defined(M68K)
3971 #define __A_MAGIC_SET__
3972 #if defined(LYNXOS)
3973 internal_a.magic = LYNXCOFFMAGIC;
3974 #else
3975 #if defined(TARG_AUX)
3976 internal_a.magic = (abfd->flags & D_PAGED ? PAGEMAGICPEXECPAGED :
3977 abfd->flags & WP_TEXT ? PAGEMAGICPEXECSWAPPED :
3978 PAGEMAGICEXECSWAPPED);
3979 #else
3980 #if defined (PAGEMAGICPEXECPAGED)
3981 internal_a.magic = PAGEMAGICPEXECPAGED;
3982 #endif
3983 #endif /* TARG_AUX */
3984 #endif /* LYNXOS */
3985 #endif /* M68 || WE32K || M68K */
3987 #if defined(ARM)
3988 #define __A_MAGIC_SET__
3989 internal_a.magic = ZMAGIC;
3990 #endif
3992 #if defined(PPC_PE)
3993 #define __A_MAGIC_SET__
3994 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
3995 #endif
3997 #if defined MCORE_PE
3998 #define __A_MAGIC_SET__
3999 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
4000 #endif
4002 #if defined(I386)
4003 #define __A_MAGIC_SET__
4004 #if defined(LYNXOS)
4005 internal_a.magic = LYNXCOFFMAGIC;
4006 #else /* LYNXOS */
4007 internal_a.magic = ZMAGIC;
4008 #endif /* LYNXOS */
4009 #endif /* I386 */
4011 #if defined(IA64)
4012 #define __A_MAGIC_SET__
4013 internal_a.magic = ZMAGIC;
4014 #endif /* IA64 */
4016 #if defined(SPARC)
4017 #define __A_MAGIC_SET__
4018 #if defined(LYNXOS)
4019 internal_a.magic = LYNXCOFFMAGIC;
4020 #endif /* LYNXOS */
4021 #endif /* SPARC */
4023 #ifdef RS6000COFF_C
4024 #define __A_MAGIC_SET__
4025 internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC :
4026 (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC :
4027 RS6K_AOUTHDR_OMAGIC;
4028 #endif
4030 #if defined(SH) && defined(COFF_WITH_PE)
4031 #define __A_MAGIC_SET__
4032 internal_a.magic = SH_PE_MAGIC;
4033 #endif
4035 #if defined(MIPS) && defined(COFF_WITH_PE)
4036 #define __A_MAGIC_SET__
4037 internal_a.magic = MIPS_PE_MAGIC;
4038 #endif
4040 #ifdef OR32
4041 #define __A_MAGIC_SET__
4042 internal_a.magic = NMAGIC; /* Assume separate i/d. */
4043 #endif
4045 #ifndef __A_MAGIC_SET__
4046 #include "Your aouthdr magic number is not being set!"
4047 #else
4048 #undef __A_MAGIC_SET__
4049 #endif
4052 /* FIXME: Does anybody ever set this to another value? */
4053 internal_a.vstamp = 0;
4055 /* Now should write relocs, strings, syms. */
4056 obj_sym_filepos (abfd) = sym_base;
4058 if (bfd_get_symcount (abfd) != 0)
4060 int firstundef;
4061 #if 0
4062 if (!coff_add_missing_symbols (abfd))
4063 return FALSE;
4064 #endif
4065 if (!coff_renumber_symbols (abfd, &firstundef))
4066 return FALSE;
4067 coff_mangle_symbols (abfd);
4068 if (! coff_write_symbols (abfd))
4069 return FALSE;
4070 if (! coff_write_linenumbers (abfd))
4071 return FALSE;
4072 if (! coff_write_relocs (abfd, firstundef))
4073 return FALSE;
4075 #ifdef COFF_LONG_SECTION_NAMES
4076 else if (long_section_names && ! obj_coff_strings_written (abfd))
4078 /* If we have long section names we have to write out the string
4079 table even if there are no symbols. */
4080 if (! coff_write_symbols (abfd))
4081 return FALSE;
4083 #endif
4084 #ifdef COFF_IMAGE_WITH_PE
4085 #ifdef PPC_PE
4086 else if ((abfd->flags & EXEC_P) != 0)
4088 bfd_byte b;
4090 /* PowerPC PE appears to require that all executable files be
4091 rounded up to the page size. */
4092 b = 0;
4093 if (bfd_seek (abfd,
4094 (file_ptr) BFD_ALIGN (sym_base, COFF_PAGE_SIZE) - 1,
4095 SEEK_SET) != 0
4096 || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
4097 return FALSE;
4099 #endif
4100 #endif
4102 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
4103 backend linker, and obj_raw_syment_count is not valid until after
4104 coff_write_symbols is called. */
4105 if (obj_raw_syment_count (abfd) != 0)
4107 internal_f.f_symptr = sym_base;
4108 #ifdef RS6000COFF_C
4109 /* AIX appears to require that F_RELFLG not be set if there are
4110 local symbols but no relocations. */
4111 internal_f.f_flags &=~ F_RELFLG;
4112 #endif
4114 else
4116 if (long_section_names)
4117 internal_f.f_symptr = sym_base;
4118 else
4119 internal_f.f_symptr = 0;
4120 internal_f.f_flags |= F_LSYMS;
4123 if (text_sec)
4125 internal_a.tsize = bfd_get_section_size_before_reloc (text_sec);
4126 internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
4128 if (data_sec)
4130 internal_a.dsize = bfd_get_section_size_before_reloc (data_sec);
4131 internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
4133 if (bss_sec)
4135 internal_a.bsize = bfd_get_section_size_before_reloc (bss_sec);
4136 if (internal_a.bsize && bss_sec->vma < internal_a.data_start)
4137 internal_a.data_start = bss_sec->vma;
4140 internal_a.entry = bfd_get_start_address (abfd);
4141 internal_f.f_nsyms = obj_raw_syment_count (abfd);
4143 #ifdef RS6000COFF_C
4144 if (xcoff_data (abfd)->full_aouthdr)
4146 bfd_vma toc;
4147 asection *loader_sec;
4149 internal_a.vstamp = 1;
4151 internal_a.o_snentry = xcoff_data (abfd)->snentry;
4152 if (internal_a.o_snentry == 0)
4153 internal_a.entry = (bfd_vma) -1;
4155 if (text_sec != NULL)
4157 internal_a.o_sntext = text_sec->target_index;
4158 internal_a.o_algntext = bfd_get_section_alignment (abfd, text_sec);
4160 else
4162 internal_a.o_sntext = 0;
4163 internal_a.o_algntext = 0;
4165 if (data_sec != NULL)
4167 internal_a.o_sndata = data_sec->target_index;
4168 internal_a.o_algndata = bfd_get_section_alignment (abfd, data_sec);
4170 else
4172 internal_a.o_sndata = 0;
4173 internal_a.o_algndata = 0;
4175 loader_sec = bfd_get_section_by_name (abfd, ".loader");
4176 if (loader_sec != NULL)
4177 internal_a.o_snloader = loader_sec->target_index;
4178 else
4179 internal_a.o_snloader = 0;
4180 if (bss_sec != NULL)
4181 internal_a.o_snbss = bss_sec->target_index;
4182 else
4183 internal_a.o_snbss = 0;
4185 toc = xcoff_data (abfd)->toc;
4186 internal_a.o_toc = toc;
4187 internal_a.o_sntoc = xcoff_data (abfd)->sntoc;
4189 internal_a.o_modtype = xcoff_data (abfd)->modtype;
4190 if (xcoff_data (abfd)->cputype != -1)
4191 internal_a.o_cputype = xcoff_data (abfd)->cputype;
4192 else
4194 switch (bfd_get_arch (abfd))
4196 case bfd_arch_rs6000:
4197 internal_a.o_cputype = 4;
4198 break;
4199 case bfd_arch_powerpc:
4200 if (bfd_get_mach (abfd) == bfd_mach_ppc)
4201 internal_a.o_cputype = 3;
4202 else
4203 internal_a.o_cputype = 1;
4204 break;
4205 default:
4206 abort ();
4209 internal_a.o_maxstack = xcoff_data (abfd)->maxstack;
4210 internal_a.o_maxdata = xcoff_data (abfd)->maxdata;
4212 #endif
4214 /* now write them */
4215 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
4216 return FALSE;
4219 char * buff;
4220 bfd_size_type amount = bfd_coff_filhsz (abfd);
4222 buff = bfd_malloc (amount);
4223 if (buff == NULL)
4224 return FALSE;
4226 bfd_coff_swap_filehdr_out (abfd, (PTR) &internal_f, (PTR) buff);
4227 amount = bfd_bwrite ((PTR) buff, amount, abfd);
4229 free (buff);
4231 if (amount != bfd_coff_filhsz (abfd))
4232 return FALSE;
4235 if (abfd->flags & EXEC_P)
4237 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
4238 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)). */
4239 char * buff;
4240 bfd_size_type amount = bfd_coff_aoutsz (abfd);
4242 buff = bfd_malloc (amount);
4243 if (buff == NULL)
4244 return FALSE;
4246 coff_swap_aouthdr_out (abfd, (PTR) &internal_a, (PTR) buff);
4247 amount = bfd_bwrite ((PTR) buff, amount, abfd);
4249 free (buff);
4251 if (amount != bfd_coff_aoutsz (abfd))
4252 return FALSE;
4254 #ifdef COFF_IMAGE_WITH_PE
4255 if (! coff_apply_checksum (abfd))
4256 return FALSE;
4257 #endif
4259 #ifdef RS6000COFF_C
4260 else
4262 AOUTHDR buff;
4263 size_t size;
4265 /* XCOFF seems to always write at least a small a.out header. */
4266 coff_swap_aouthdr_out (abfd, (PTR) &internal_a, (PTR) &buff);
4267 if (xcoff_data (abfd)->full_aouthdr)
4268 size = bfd_coff_aoutsz (abfd);
4269 else
4270 size = SMALL_AOUTSZ;
4271 if (bfd_bwrite ((PTR) &buff, (bfd_size_type) size, abfd) != size)
4272 return FALSE;
4274 #endif
4276 return TRUE;
4279 static bfd_boolean
4280 coff_set_section_contents (abfd, section, location, offset, count)
4281 bfd * abfd;
4282 sec_ptr section;
4283 const PTR location;
4284 file_ptr offset;
4285 bfd_size_type count;
4287 if (! abfd->output_has_begun) /* Set by bfd.c handler. */
4289 if (! coff_compute_section_file_positions (abfd))
4290 return FALSE;
4293 #if defined(_LIB) && !defined(TARG_AUX)
4295 /* The physical address field of a .lib section is used to hold the
4296 number of shared libraries in the section. This code counts the
4297 number of sections being written, and increments the lma field
4298 with the number.
4300 I have found no documentation on the contents of this section.
4301 Experimentation indicates that the section contains zero or more
4302 records, each of which has the following structure:
4304 - a (four byte) word holding the length of this record, in words,
4305 - a word that always seems to be set to "2",
4306 - the path to a shared library, null-terminated and then padded
4307 to a whole word boundary.
4309 bfd_assert calls have been added to alert if an attempt is made
4310 to write a section which doesn't follow these assumptions. The
4311 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4312 <robertl@arnet.com> (Thanks!).
4314 Gvran Uddeborg <gvran@uddeborg.pp.se>. */
4316 if (strcmp (section->name, _LIB) == 0)
4318 bfd_byte *rec, *recend;
4320 rec = (bfd_byte *) location;
4321 recend = rec + count;
4322 while (rec < recend)
4324 ++section->lma;
4325 rec += bfd_get_32 (abfd, rec) * 4;
4328 BFD_ASSERT (rec == recend);
4331 #endif
4333 /* Don't write out bss sections - one way to do this is to
4334 see if the filepos has not been set. */
4335 if (section->filepos == 0)
4336 return TRUE;
4338 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0)
4339 return FALSE;
4341 if (count == 0)
4342 return TRUE;
4344 return bfd_bwrite (location, count, abfd) == count;
4346 #if 0
4347 static bfd_boolean
4348 coff_close_and_cleanup (abfd)
4349 bfd *abfd;
4351 if (!bfd_read_p (abfd))
4352 switch (abfd->format)
4354 case bfd_archive:
4355 if (!_bfd_write_archive_contents (abfd))
4356 return FALSE;
4357 break;
4358 case bfd_object:
4359 if (!coff_write_object_contents (abfd))
4360 return FALSE;
4361 break;
4362 default:
4363 bfd_set_error (bfd_error_invalid_operation);
4364 return FALSE;
4367 /* We depend on bfd_close to free all the memory on the objalloc. */
4368 return TRUE;
4371 #endif
4373 static PTR
4374 buy_and_read (abfd, where, size)
4375 bfd *abfd;
4376 file_ptr where;
4377 bfd_size_type size;
4379 PTR area = (PTR) bfd_alloc (abfd, size);
4380 if (!area)
4381 return (NULL);
4382 if (bfd_seek (abfd, where, SEEK_SET) != 0
4383 || bfd_bread (area, size, abfd) != size)
4384 return (NULL);
4385 return (area);
4386 } /* buy_and_read() */
4389 SUBSUBSECTION
4390 Reading linenumbers
4392 Creating the linenumber table is done by reading in the entire
4393 coff linenumber table, and creating another table for internal use.
4395 A coff linenumber table is structured so that each function
4396 is marked as having a line number of 0. Each line within the
4397 function is an offset from the first line in the function. The
4398 base of the line number information for the table is stored in
4399 the symbol associated with the function.
4401 Note: The PE format uses line number 0 for a flag indicating a
4402 new source file.
4404 The information is copied from the external to the internal
4405 table, and each symbol which marks a function is marked by
4406 pointing its...
4408 How does this work ?
4412 static bfd_boolean
4413 coff_slurp_line_table (abfd, asect)
4414 bfd *abfd;
4415 asection *asect;
4417 LINENO *native_lineno;
4418 alent *lineno_cache;
4419 bfd_size_type amt;
4421 BFD_ASSERT (asect->lineno == (alent *) NULL);
4423 amt = (bfd_size_type) bfd_coff_linesz (abfd) * asect->lineno_count;
4424 native_lineno = (LINENO *) buy_and_read (abfd, asect->line_filepos, amt);
4425 if (native_lineno == NULL)
4427 (*_bfd_error_handler)
4428 (_("%s: warning: line number table read failed"),
4429 bfd_archive_filename (abfd));
4430 return FALSE;
4432 amt = ((bfd_size_type) asect->lineno_count + 1) * sizeof (alent);
4433 lineno_cache = (alent *) bfd_alloc (abfd, amt);
4434 if (lineno_cache == NULL)
4435 return FALSE;
4436 else
4438 unsigned int counter = 0;
4439 alent *cache_ptr = lineno_cache;
4440 LINENO *src = native_lineno;
4442 while (counter < asect->lineno_count)
4444 struct internal_lineno dst;
4446 bfd_coff_swap_lineno_in (abfd, src, &dst);
4447 cache_ptr->line_number = dst.l_lnno;
4449 if (cache_ptr->line_number == 0)
4451 bfd_boolean warned;
4452 bfd_signed_vma symndx;
4453 coff_symbol_type *sym;
4455 warned = FALSE;
4456 symndx = dst.l_addr.l_symndx;
4457 if (symndx < 0
4458 || (bfd_vma) symndx >= obj_raw_syment_count (abfd))
4460 (*_bfd_error_handler)
4461 (_("%s: warning: illegal symbol index %ld in line numbers"),
4462 bfd_archive_filename (abfd), dst.l_addr.l_symndx);
4463 symndx = 0;
4464 warned = TRUE;
4466 /* FIXME: We should not be casting between ints and
4467 pointers like this. */
4468 sym = ((coff_symbol_type *)
4469 ((symndx + obj_raw_syments (abfd))
4470 ->u.syment._n._n_n._n_zeroes));
4471 cache_ptr->u.sym = (asymbol *) sym;
4472 if (sym->lineno != NULL && ! warned)
4474 (*_bfd_error_handler)
4475 (_("%s: warning: duplicate line number information for `%s'"),
4476 bfd_archive_filename (abfd),
4477 bfd_asymbol_name (&sym->symbol));
4479 sym->lineno = cache_ptr;
4481 else
4483 cache_ptr->u.offset = dst.l_addr.l_paddr
4484 - bfd_section_vma (abfd, asect);
4485 } /* If no linenumber expect a symbol index */
4487 cache_ptr++;
4488 src++;
4489 counter++;
4491 cache_ptr->line_number = 0;
4494 asect->lineno = lineno_cache;
4495 /* FIXME, free native_lineno here, or use alloca or something. */
4496 return TRUE;
4499 /* Slurp in the symbol table, converting it to generic form. Note
4500 that if coff_relocate_section is defined, the linker will read
4501 symbols via coff_link_add_symbols, rather than via this routine. */
4503 static bfd_boolean
4504 coff_slurp_symbol_table (abfd)
4505 bfd * abfd;
4507 combined_entry_type *native_symbols;
4508 coff_symbol_type *cached_area;
4509 unsigned int *table_ptr;
4510 bfd_size_type amt;
4511 unsigned int number_of_symbols = 0;
4513 if (obj_symbols (abfd))
4514 return TRUE;
4516 /* Read in the symbol table. */
4517 if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL)
4518 return FALSE;
4520 /* Allocate enough room for all the symbols in cached form. */
4521 amt = obj_raw_syment_count (abfd);
4522 amt *= sizeof (coff_symbol_type);
4523 cached_area = (coff_symbol_type *) bfd_alloc (abfd, amt);
4524 if (cached_area == NULL)
4525 return FALSE;
4527 amt = obj_raw_syment_count (abfd);
4528 amt *= sizeof (unsigned int);
4529 table_ptr = (unsigned int *) bfd_alloc (abfd, amt);
4531 if (table_ptr == NULL)
4532 return FALSE;
4533 else
4535 coff_symbol_type *dst = cached_area;
4536 unsigned int last_native_index = obj_raw_syment_count (abfd);
4537 unsigned int this_index = 0;
4539 while (this_index < last_native_index)
4541 combined_entry_type *src = native_symbols + this_index;
4542 table_ptr[this_index] = number_of_symbols;
4543 dst->symbol.the_bfd = abfd;
4545 dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset);
4546 /* We use the native name field to point to the cached field. */
4547 src->u.syment._n._n_n._n_zeroes = (long) dst;
4548 dst->symbol.section = coff_section_from_bfd_index (abfd,
4549 src->u.syment.n_scnum);
4550 dst->symbol.flags = 0;
4551 dst->done_lineno = FALSE;
4553 switch (src->u.syment.n_sclass)
4555 #ifdef I960
4556 case C_LEAFEXT:
4557 #if 0
4558 dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
4559 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
4560 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4561 #endif
4562 /* Fall through to next case. */
4563 #endif
4565 case C_EXT:
4566 case C_WEAKEXT:
4567 #if defined ARM
4568 case C_THUMBEXT:
4569 case C_THUMBEXTFUNC:
4570 #endif
4571 #ifdef RS6000COFF_C
4572 case C_HIDEXT:
4573 #endif
4574 #ifdef C_SYSTEM
4575 case C_SYSTEM: /* System Wide variable. */
4576 #endif
4577 #ifdef COFF_WITH_PE
4578 /* In PE, 0x68 (104) denotes a section symbol. */
4579 case C_SECTION:
4580 /* In PE, 0x69 (105) denotes a weak external symbol. */
4581 case C_NT_WEAK:
4582 #endif
4583 switch (coff_classify_symbol (abfd, &src->u.syment))
4585 case COFF_SYMBOL_GLOBAL:
4586 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
4587 #if defined COFF_WITH_PE
4588 /* PE sets the symbol to a value relative to the
4589 start of the section. */
4590 dst->symbol.value = src->u.syment.n_value;
4591 #else
4592 dst->symbol.value = (src->u.syment.n_value
4593 - dst->symbol.section->vma);
4594 #endif
4595 if (ISFCN ((src->u.syment.n_type)))
4597 /* A function ext does not go at the end of a
4598 file. */
4599 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4601 break;
4603 case COFF_SYMBOL_COMMON:
4604 dst->symbol.section = bfd_com_section_ptr;
4605 dst->symbol.value = src->u.syment.n_value;
4606 break;
4608 case COFF_SYMBOL_UNDEFINED:
4609 dst->symbol.section = bfd_und_section_ptr;
4610 dst->symbol.value = 0;
4611 break;
4613 case COFF_SYMBOL_PE_SECTION:
4614 dst->symbol.flags |= BSF_EXPORT | BSF_SECTION_SYM;
4615 dst->symbol.value = 0;
4616 break;
4618 case COFF_SYMBOL_LOCAL:
4619 dst->symbol.flags = BSF_LOCAL;
4620 #if defined COFF_WITH_PE
4621 /* PE sets the symbol to a value relative to the
4622 start of the section. */
4623 dst->symbol.value = src->u.syment.n_value;
4624 #else
4625 dst->symbol.value = (src->u.syment.n_value
4626 - dst->symbol.section->vma);
4627 #endif
4628 if (ISFCN ((src->u.syment.n_type)))
4629 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4630 break;
4633 #ifdef RS6000COFF_C
4634 /* A symbol with a csect entry should not go at the end. */
4635 if (src->u.syment.n_numaux > 0)
4636 dst->symbol.flags |= BSF_NOT_AT_END;
4637 #endif
4639 #ifdef COFF_WITH_PE
4640 if (src->u.syment.n_sclass == C_NT_WEAK)
4641 dst->symbol.flags |= BSF_WEAK;
4643 if (src->u.syment.n_sclass == C_SECTION
4644 && src->u.syment.n_scnum > 0)
4645 dst->symbol.flags = BSF_LOCAL;
4646 #endif
4647 if (src->u.syment.n_sclass == C_WEAKEXT)
4648 dst->symbol.flags |= BSF_WEAK;
4650 break;
4652 case C_STAT: /* Static. */
4653 #ifdef I960
4654 case C_LEAFSTAT: /* Static leaf procedure. */
4655 #endif
4656 #if defined ARM
4657 case C_THUMBSTAT: /* Thumb static. */
4658 case C_THUMBLABEL: /* Thumb label. */
4659 case C_THUMBSTATFUNC:/* Thumb static function. */
4660 #endif
4661 case C_LABEL: /* Label. */
4662 if (src->u.syment.n_scnum == N_DEBUG)
4663 dst->symbol.flags = BSF_DEBUGGING;
4664 else
4665 dst->symbol.flags = BSF_LOCAL;
4667 /* Base the value as an index from the base of the
4668 section, if there is one. */
4669 if (dst->symbol.section)
4671 #if defined COFF_WITH_PE
4672 /* PE sets the symbol to a value relative to the
4673 start of the section. */
4674 dst->symbol.value = src->u.syment.n_value;
4675 #else
4676 dst->symbol.value = (src->u.syment.n_value
4677 - dst->symbol.section->vma);
4678 #endif
4680 else
4681 dst->symbol.value = src->u.syment.n_value;
4682 break;
4684 case C_MOS: /* Member of structure. */
4685 case C_EOS: /* End of structure. */
4686 #ifdef NOTDEF /* C_AUTOARG has the same value. */
4687 #ifdef C_GLBLREG
4688 case C_GLBLREG: /* A29k-specific storage class. */
4689 #endif
4690 #endif
4691 case C_REGPARM: /* Register parameter. */
4692 case C_REG: /* register variable. */
4693 /* C_AUTOARG conflicts with TI COFF C_UEXT. */
4694 #if !defined (TIC80COFF) && !defined (TICOFF)
4695 #ifdef C_AUTOARG
4696 case C_AUTOARG: /* 960-specific storage class. */
4697 #endif
4698 #endif
4699 case C_TPDEF: /* Type definition. */
4700 case C_ARG:
4701 case C_AUTO: /* Automatic variable. */
4702 case C_FIELD: /* Bit field. */
4703 case C_ENTAG: /* Enumeration tag. */
4704 case C_MOE: /* Member of enumeration. */
4705 case C_MOU: /* Member of union. */
4706 case C_UNTAG: /* Union tag. */
4707 dst->symbol.flags = BSF_DEBUGGING;
4708 dst->symbol.value = (src->u.syment.n_value);
4709 break;
4711 case C_FILE: /* File name. */
4712 case C_STRTAG: /* Structure tag. */
4713 #ifdef RS6000COFF_C
4714 case C_GSYM:
4715 case C_LSYM:
4716 case C_PSYM:
4717 case C_RSYM:
4718 case C_RPSYM:
4719 case C_STSYM:
4720 case C_TCSYM:
4721 case C_BCOMM:
4722 case C_ECOML:
4723 case C_ECOMM:
4724 case C_DECL:
4725 case C_ENTRY:
4726 case C_FUN:
4727 case C_ESTAT:
4728 #endif
4729 dst->symbol.flags = BSF_DEBUGGING;
4730 dst->symbol.value = (src->u.syment.n_value);
4731 break;
4733 #ifdef RS6000COFF_C
4734 case C_BINCL: /* Beginning of include file. */
4735 case C_EINCL: /* Ending of include file. */
4736 /* The value is actually a pointer into the line numbers
4737 of the file. We locate the line number entry, and
4738 set the section to the section which contains it, and
4739 the value to the index in that section. */
4741 asection *sec;
4743 dst->symbol.flags = BSF_DEBUGGING;
4744 for (sec = abfd->sections; sec != NULL; sec = sec->next)
4745 if (sec->line_filepos <= (file_ptr) src->u.syment.n_value
4746 && ((file_ptr) (sec->line_filepos
4747 + sec->lineno_count * bfd_coff_linesz (abfd))
4748 > (file_ptr) src->u.syment.n_value))
4749 break;
4750 if (sec == NULL)
4751 dst->symbol.value = 0;
4752 else
4754 dst->symbol.section = sec;
4755 dst->symbol.value = ((src->u.syment.n_value
4756 - sec->line_filepos)
4757 / bfd_coff_linesz (abfd));
4758 src->fix_line = 1;
4761 break;
4763 case C_BSTAT:
4764 dst->symbol.flags = BSF_DEBUGGING;
4766 /* The value is actually a symbol index. Save a pointer
4767 to the symbol instead of the index. FIXME: This
4768 should use a union. */
4769 src->u.syment.n_value =
4770 (long) (native_symbols + src->u.syment.n_value);
4771 dst->symbol.value = src->u.syment.n_value;
4772 src->fix_value = 1;
4773 break;
4774 #endif
4776 case C_BLOCK: /* ".bb" or ".eb". */
4777 case C_FCN: /* ".bf" or ".ef" (or PE ".lf"). */
4778 case C_EFCN: /* Physical end of function. */
4779 #if defined COFF_WITH_PE
4780 /* PE sets the symbol to a value relative to the start
4781 of the section. */
4782 dst->symbol.value = src->u.syment.n_value;
4783 if (strcmp (dst->symbol.name, ".bf") != 0)
4785 /* PE uses funny values for .ef and .lf; don't
4786 relocate them. */
4787 dst->symbol.flags = BSF_DEBUGGING;
4789 else
4790 dst->symbol.flags = BSF_DEBUGGING | BSF_DEBUGGING_RELOC;
4791 #else
4792 /* Base the value as an index from the base of the
4793 section. */
4794 dst->symbol.flags = BSF_LOCAL;
4795 dst->symbol.value = (src->u.syment.n_value
4796 - dst->symbol.section->vma);
4797 #endif
4798 break;
4800 case C_STATLAB: /* Static load time label. */
4801 dst->symbol.value = src->u.syment.n_value;
4802 dst->symbol.flags = BSF_GLOBAL;
4803 break;
4805 case C_NULL:
4806 /* PE DLLs sometimes have zeroed out symbols for some
4807 reason. Just ignore them without a warning. */
4808 if (src->u.syment.n_type == 0
4809 && src->u.syment.n_value == 0
4810 && src->u.syment.n_scnum == 0)
4811 break;
4812 /* Fall through. */
4813 case C_EXTDEF: /* External definition. */
4814 case C_ULABEL: /* Undefined label. */
4815 case C_USTATIC: /* Undefined static. */
4816 #ifndef COFF_WITH_PE
4817 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4818 class to represent a section symbol. */
4819 case C_LINE: /* line # reformatted as symbol table entry. */
4820 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4821 case C_ALIAS: /* Duplicate tag. */
4822 #endif
4823 /* New storage classes for TI COFF. */
4824 #if defined(TIC80COFF) || defined(TICOFF)
4825 case C_UEXT: /* Tentative external definition. */
4826 #endif
4827 case C_EXTLAB: /* External load time label. */
4828 case C_HIDDEN: /* Ext symbol in dmert public lib. */
4829 default:
4830 (*_bfd_error_handler)
4831 (_("%s: Unrecognized storage class %d for %s symbol `%s'"),
4832 bfd_archive_filename (abfd), src->u.syment.n_sclass,
4833 dst->symbol.section->name, dst->symbol.name);
4834 dst->symbol.flags = BSF_DEBUGGING;
4835 dst->symbol.value = (src->u.syment.n_value);
4836 break;
4839 /* BFD_ASSERT(dst->symbol.flags != 0);*/
4841 dst->native = src;
4843 dst->symbol.udata.i = 0;
4844 dst->lineno = (alent *) NULL;
4845 this_index += (src->u.syment.n_numaux) + 1;
4846 dst++;
4847 number_of_symbols++;
4851 obj_symbols (abfd) = cached_area;
4852 obj_raw_syments (abfd) = native_symbols;
4854 bfd_get_symcount (abfd) = number_of_symbols;
4855 obj_convert (abfd) = table_ptr;
4856 /* Slurp the line tables for each section too. */
4858 asection *p;
4860 p = abfd->sections;
4861 while (p)
4863 coff_slurp_line_table (abfd, p);
4864 p = p->next;
4868 return TRUE;
4869 } /* coff_slurp_symbol_table() */
4871 /* Classify a COFF symbol. A couple of targets have globally visible
4872 symbols which are not class C_EXT, and this handles those. It also
4873 recognizes some special PE cases. */
4875 static enum coff_symbol_classification
4876 coff_classify_symbol (abfd, syment)
4877 bfd *abfd;
4878 struct internal_syment *syment;
4880 /* FIXME: This partially duplicates the switch in
4881 coff_slurp_symbol_table. */
4882 switch (syment->n_sclass)
4884 case C_EXT:
4885 case C_WEAKEXT:
4886 #ifdef I960
4887 case C_LEAFEXT:
4888 #endif
4889 #ifdef ARM
4890 case C_THUMBEXT:
4891 case C_THUMBEXTFUNC:
4892 #endif
4893 #ifdef C_SYSTEM
4894 case C_SYSTEM:
4895 #endif
4896 #ifdef COFF_WITH_PE
4897 case C_NT_WEAK:
4898 #endif
4899 if (syment->n_scnum == 0)
4901 if (syment->n_value == 0)
4902 return COFF_SYMBOL_UNDEFINED;
4903 else
4904 return COFF_SYMBOL_COMMON;
4906 return COFF_SYMBOL_GLOBAL;
4908 default:
4909 break;
4912 #ifdef COFF_WITH_PE
4913 if (syment->n_sclass == C_STAT)
4915 if (syment->n_scnum == 0)
4917 /* The Microsoft compiler sometimes generates these if a
4918 small static function is inlined every time it is used.
4919 The function is discarded, but the symbol table entry
4920 remains. */
4921 return COFF_SYMBOL_LOCAL;
4924 #ifdef STRICT_PE_FORMAT
4925 /* This is correct for Microsoft generated objects, but it
4926 breaks gas generated objects. */
4928 if (syment->n_value == 0)
4930 asection *sec;
4931 char buf[SYMNMLEN + 1];
4933 sec = coff_section_from_bfd_index (abfd, syment->n_scnum);
4934 if (sec != NULL
4935 && (strcmp (bfd_get_section_name (abfd, sec),
4936 _bfd_coff_internal_syment_name (abfd, syment, buf))
4937 == 0))
4938 return COFF_SYMBOL_PE_SECTION;
4940 #endif
4942 return COFF_SYMBOL_LOCAL;
4945 if (syment->n_sclass == C_SECTION)
4947 /* In some cases in a DLL generated by the Microsoft linker, the
4948 n_value field will contain garbage. FIXME: This should
4949 probably be handled by the swapping function instead. */
4950 syment->n_value = 0;
4951 if (syment->n_scnum == 0)
4952 return COFF_SYMBOL_UNDEFINED;
4953 return COFF_SYMBOL_PE_SECTION;
4955 #endif /* COFF_WITH_PE */
4957 /* If it is not a global symbol, we presume it is a local symbol. */
4959 if (syment->n_scnum == 0)
4961 char buf[SYMNMLEN + 1];
4963 (*_bfd_error_handler)
4964 (_("warning: %s: local symbol `%s' has no section"),
4965 bfd_archive_filename (abfd),
4966 _bfd_coff_internal_syment_name (abfd, syment, buf));
4969 return COFF_SYMBOL_LOCAL;
4973 SUBSUBSECTION
4974 Reading relocations
4976 Coff relocations are easily transformed into the internal BFD form
4977 (@code{arelent}).
4979 Reading a coff relocation table is done in the following stages:
4981 o Read the entire coff relocation table into memory.
4983 o Process each relocation in turn; first swap it from the
4984 external to the internal form.
4986 o Turn the symbol referenced in the relocation's symbol index
4987 into a pointer into the canonical symbol table.
4988 This table is the same as the one returned by a call to
4989 @code{bfd_canonicalize_symtab}. The back end will call that
4990 routine and save the result if a canonicalization hasn't been done.
4992 o The reloc index is turned into a pointer to a howto
4993 structure, in a back end specific way. For instance, the 386
4994 and 960 use the @code{r_type} to directly produce an index
4995 into a howto table vector; the 88k subtracts a number from the
4996 @code{r_type} field and creates an addend field.
5000 #ifndef CALC_ADDEND
5001 #define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
5003 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \
5004 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
5005 coffsym = (obj_symbols (abfd) \
5006 + (cache_ptr->sym_ptr_ptr - symbols)); \
5007 else if (ptr) \
5008 coffsym = coff_symbol_from (abfd, ptr); \
5009 if (coffsym != (coff_symbol_type *) NULL \
5010 && coffsym->native->u.syment.n_scnum == 0) \
5011 cache_ptr->addend = 0; \
5012 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
5013 && ptr->section != (asection *) NULL) \
5014 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
5015 else \
5016 cache_ptr->addend = 0; \
5018 #endif
5020 static bfd_boolean
5021 coff_slurp_reloc_table (abfd, asect, symbols)
5022 bfd * abfd;
5023 sec_ptr asect;
5024 asymbol ** symbols;
5026 RELOC *native_relocs;
5027 arelent *reloc_cache;
5028 arelent *cache_ptr;
5029 unsigned int idx;
5030 bfd_size_type amt;
5032 if (asect->relocation)
5033 return TRUE;
5034 if (asect->reloc_count == 0)
5035 return TRUE;
5036 if (asect->flags & SEC_CONSTRUCTOR)
5037 return TRUE;
5038 if (!coff_slurp_symbol_table (abfd))
5039 return FALSE;
5040 amt = (bfd_size_type) bfd_coff_relsz (abfd) * asect->reloc_count;
5041 native_relocs = (RELOC *) buy_and_read (abfd, asect->rel_filepos, amt);
5042 amt = (bfd_size_type) asect->reloc_count * sizeof (arelent);
5043 reloc_cache = (arelent *) bfd_alloc (abfd, amt);
5045 if (reloc_cache == NULL)
5046 return FALSE;
5048 for (idx = 0; idx < asect->reloc_count; idx++)
5050 struct internal_reloc dst;
5051 struct external_reloc *src;
5052 #ifndef RELOC_PROCESSING
5053 asymbol *ptr;
5054 #endif
5056 cache_ptr = reloc_cache + idx;
5057 src = native_relocs + idx;
5059 coff_swap_reloc_in (abfd, src, &dst);
5061 #ifdef RELOC_PROCESSING
5062 RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
5063 #else
5064 cache_ptr->address = dst.r_vaddr;
5066 if (dst.r_symndx != -1)
5068 if (dst.r_symndx < 0 || dst.r_symndx >= obj_conv_table_size (abfd))
5070 (*_bfd_error_handler)
5071 (_("%s: warning: illegal symbol index %ld in relocs"),
5072 bfd_archive_filename (abfd), dst.r_symndx);
5073 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
5074 ptr = NULL;
5076 else
5078 cache_ptr->sym_ptr_ptr = (symbols
5079 + obj_convert (abfd)[dst.r_symndx]);
5080 ptr = *(cache_ptr->sym_ptr_ptr);
5083 else
5085 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
5086 ptr = NULL;
5089 /* The symbols definitions that we have read in have been
5090 relocated as if their sections started at 0. But the offsets
5091 refering to the symbols in the raw data have not been
5092 modified, so we have to have a negative addend to compensate.
5094 Note that symbols which used to be common must be left alone. */
5096 /* Calculate any reloc addend by looking at the symbol. */
5097 CALC_ADDEND (abfd, ptr, dst, cache_ptr);
5099 cache_ptr->address -= asect->vma;
5100 /* !! cache_ptr->section = (asection *) NULL;*/
5102 /* Fill in the cache_ptr->howto field from dst.r_type. */
5103 RTYPE2HOWTO (cache_ptr, &dst);
5104 #endif /* RELOC_PROCESSING */
5106 if (cache_ptr->howto == NULL)
5108 (*_bfd_error_handler)
5109 (_("%s: illegal relocation type %d at address 0x%lx"),
5110 bfd_archive_filename (abfd), dst.r_type, (long) dst.r_vaddr);
5111 bfd_set_error (bfd_error_bad_value);
5112 return FALSE;
5116 asect->relocation = reloc_cache;
5117 return TRUE;
5120 #ifndef coff_rtype_to_howto
5121 #ifdef RTYPE2HOWTO
5123 /* Get the howto structure for a reloc. This is only used if the file
5124 including this one defines coff_relocate_section to be
5125 _bfd_coff_generic_relocate_section, so it is OK if it does not
5126 always work. It is the responsibility of the including file to
5127 make sure it is reasonable if it is needed. */
5129 static reloc_howto_type *coff_rtype_to_howto
5130 PARAMS ((bfd *, asection *, struct internal_reloc *,
5131 struct coff_link_hash_entry *, struct internal_syment *,
5132 bfd_vma *));
5134 static reloc_howto_type *
5135 coff_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
5136 bfd *abfd ATTRIBUTE_UNUSED;
5137 asection *sec ATTRIBUTE_UNUSED;
5138 struct internal_reloc *rel;
5139 struct coff_link_hash_entry *h ATTRIBUTE_UNUSED;
5140 struct internal_syment *sym ATTRIBUTE_UNUSED;
5141 bfd_vma *addendp ATTRIBUTE_UNUSED;
5143 arelent genrel;
5145 RTYPE2HOWTO (&genrel, rel);
5146 return genrel.howto;
5149 #else /* ! defined (RTYPE2HOWTO) */
5151 #define coff_rtype_to_howto NULL
5153 #endif /* ! defined (RTYPE2HOWTO) */
5154 #endif /* ! defined (coff_rtype_to_howto) */
5156 /* This is stupid. This function should be a boolean predicate. */
5157 static long
5158 coff_canonicalize_reloc (abfd, section, relptr, symbols)
5159 bfd * abfd;
5160 sec_ptr section;
5161 arelent ** relptr;
5162 asymbol ** symbols;
5164 arelent *tblptr = section->relocation;
5165 unsigned int count = 0;
5167 if (section->flags & SEC_CONSTRUCTOR)
5169 /* This section has relocs made up by us, they are not in the
5170 file, so take them out of their chain and place them into
5171 the data area provided. */
5172 arelent_chain *chain = section->constructor_chain;
5174 for (count = 0; count < section->reloc_count; count++)
5176 *relptr++ = &chain->relent;
5177 chain = chain->next;
5180 else
5182 if (! coff_slurp_reloc_table (abfd, section, symbols))
5183 return -1;
5185 tblptr = section->relocation;
5187 for (; count++ < section->reloc_count;)
5188 *relptr++ = tblptr++;
5190 *relptr = 0;
5191 return section->reloc_count;
5194 #ifdef GNU960
5195 file_ptr
5196 coff_sym_filepos (abfd)
5197 bfd *abfd;
5199 return obj_sym_filepos (abfd);
5201 #endif
5203 #ifndef coff_reloc16_estimate
5204 #define coff_reloc16_estimate dummy_reloc16_estimate
5206 static int dummy_reloc16_estimate
5207 PARAMS ((bfd *, asection *, arelent *, unsigned int,
5208 struct bfd_link_info *));
5210 static int
5211 dummy_reloc16_estimate (abfd, input_section, reloc, shrink, link_info)
5212 bfd *abfd ATTRIBUTE_UNUSED;
5213 asection *input_section ATTRIBUTE_UNUSED;
5214 arelent *reloc ATTRIBUTE_UNUSED;
5215 unsigned int shrink ATTRIBUTE_UNUSED;
5216 struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
5218 abort ();
5219 return 0;
5222 #endif
5224 #ifndef coff_reloc16_extra_cases
5226 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
5228 /* This works even if abort is not declared in any header file. */
5230 static void dummy_reloc16_extra_cases
5231 PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
5232 bfd_byte *, unsigned int *, unsigned int *));
5234 static void
5235 dummy_reloc16_extra_cases (abfd, link_info, link_order, reloc, data, src_ptr,
5236 dst_ptr)
5237 bfd *abfd ATTRIBUTE_UNUSED;
5238 struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
5239 struct bfd_link_order *link_order ATTRIBUTE_UNUSED;
5240 arelent *reloc ATTRIBUTE_UNUSED;
5241 bfd_byte *data ATTRIBUTE_UNUSED;
5242 unsigned int *src_ptr ATTRIBUTE_UNUSED;
5243 unsigned int *dst_ptr ATTRIBUTE_UNUSED;
5245 abort ();
5247 #endif
5249 #ifndef coff_bfd_link_hash_table_free
5250 #define coff_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
5251 #endif
5253 /* If coff_relocate_section is defined, we can use the optimized COFF
5254 backend linker. Otherwise we must continue to use the old linker. */
5255 #ifdef coff_relocate_section
5256 #ifndef coff_bfd_link_hash_table_create
5257 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5258 #endif
5259 #ifndef coff_bfd_link_add_symbols
5260 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5261 #endif
5262 #ifndef coff_bfd_final_link
5263 #define coff_bfd_final_link _bfd_coff_final_link
5264 #endif
5265 #else /* ! defined (coff_relocate_section) */
5266 #define coff_relocate_section NULL
5267 #ifndef coff_bfd_link_hash_table_create
5268 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5269 #endif
5270 #ifndef coff_bfd_link_add_symbols
5271 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5272 #endif
5273 #define coff_bfd_final_link _bfd_generic_final_link
5274 #endif /* ! defined (coff_relocate_section) */
5276 #define coff_bfd_link_just_syms _bfd_generic_link_just_syms
5277 #define coff_bfd_link_split_section _bfd_generic_link_split_section
5279 #ifndef coff_start_final_link
5280 #define coff_start_final_link NULL
5281 #endif
5283 #ifndef coff_adjust_symndx
5284 #define coff_adjust_symndx NULL
5285 #endif
5287 #ifndef coff_link_add_one_symbol
5288 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5289 #endif
5291 #ifndef coff_link_output_has_begun
5293 static bfd_boolean coff_link_output_has_begun
5294 PARAMS ((bfd *, struct coff_final_link_info *));
5296 static bfd_boolean
5297 coff_link_output_has_begun (abfd, info)
5298 bfd * abfd;
5299 struct coff_final_link_info * info ATTRIBUTE_UNUSED;
5301 return abfd->output_has_begun;
5303 #endif
5305 #ifndef coff_final_link_postscript
5307 static bfd_boolean coff_final_link_postscript
5308 PARAMS ((bfd *, struct coff_final_link_info *));
5310 static bfd_boolean
5311 coff_final_link_postscript (abfd, pfinfo)
5312 bfd * abfd ATTRIBUTE_UNUSED;
5313 struct coff_final_link_info * pfinfo ATTRIBUTE_UNUSED;
5315 return TRUE;
5317 #endif
5319 #ifndef coff_SWAP_aux_in
5320 #define coff_SWAP_aux_in coff_swap_aux_in
5321 #endif
5322 #ifndef coff_SWAP_sym_in
5323 #define coff_SWAP_sym_in coff_swap_sym_in
5324 #endif
5325 #ifndef coff_SWAP_lineno_in
5326 #define coff_SWAP_lineno_in coff_swap_lineno_in
5327 #endif
5328 #ifndef coff_SWAP_aux_out
5329 #define coff_SWAP_aux_out coff_swap_aux_out
5330 #endif
5331 #ifndef coff_SWAP_sym_out
5332 #define coff_SWAP_sym_out coff_swap_sym_out
5333 #endif
5334 #ifndef coff_SWAP_lineno_out
5335 #define coff_SWAP_lineno_out coff_swap_lineno_out
5336 #endif
5337 #ifndef coff_SWAP_reloc_out
5338 #define coff_SWAP_reloc_out coff_swap_reloc_out
5339 #endif
5340 #ifndef coff_SWAP_filehdr_out
5341 #define coff_SWAP_filehdr_out coff_swap_filehdr_out
5342 #endif
5343 #ifndef coff_SWAP_aouthdr_out
5344 #define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5345 #endif
5346 #ifndef coff_SWAP_scnhdr_out
5347 #define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5348 #endif
5349 #ifndef coff_SWAP_reloc_in
5350 #define coff_SWAP_reloc_in coff_swap_reloc_in
5351 #endif
5352 #ifndef coff_SWAP_filehdr_in
5353 #define coff_SWAP_filehdr_in coff_swap_filehdr_in
5354 #endif
5355 #ifndef coff_SWAP_aouthdr_in
5356 #define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5357 #endif
5358 #ifndef coff_SWAP_scnhdr_in
5359 #define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5360 #endif
5362 static const bfd_coff_backend_data bfd_coff_std_swap_table =
5364 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5365 coff_SWAP_aux_out, coff_SWAP_sym_out,
5366 coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5367 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5368 coff_SWAP_scnhdr_out,
5369 FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
5370 #ifdef COFF_LONG_FILENAMES
5371 TRUE,
5372 #else
5373 FALSE,
5374 #endif
5375 #ifdef COFF_LONG_SECTION_NAMES
5376 TRUE,
5377 #else
5378 FALSE,
5379 #endif
5380 COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5381 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5382 TRUE,
5383 #else
5384 FALSE,
5385 #endif
5386 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5388 #else
5390 #endif
5391 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5392 coff_SWAP_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook,
5393 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5394 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5395 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5396 coff_classify_symbol, coff_compute_section_file_positions,
5397 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5398 coff_adjust_symndx, coff_link_add_one_symbol,
5399 coff_link_output_has_begun, coff_final_link_postscript
5402 #ifdef TICOFF
5403 /* COFF0 differs in file/section header size and relocation entry size. */
5404 static const bfd_coff_backend_data ticoff0_swap_table =
5406 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5407 coff_SWAP_aux_out, coff_SWAP_sym_out,
5408 coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5409 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5410 coff_SWAP_scnhdr_out,
5411 FILHSZ_V0, AOUTSZ, SCNHSZ_V01, SYMESZ, AUXESZ, RELSZ_V0, LINESZ, FILNMLEN,
5412 #ifdef COFF_LONG_FILENAMES
5413 TRUE,
5414 #else
5415 FALSE,
5416 #endif
5417 #ifdef COFF_LONG_SECTION_NAMES
5418 TRUE,
5419 #else
5420 FALSE,
5421 #endif
5422 COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5423 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5424 TRUE,
5425 #else
5426 FALSE,
5427 #endif
5428 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5430 #else
5432 #endif
5433 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5434 coff_SWAP_reloc_in, ticoff0_bad_format_hook, coff_set_arch_mach_hook,
5435 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5436 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5437 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5438 coff_classify_symbol, coff_compute_section_file_positions,
5439 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5440 coff_adjust_symndx, coff_link_add_one_symbol,
5441 coff_link_output_has_begun, coff_final_link_postscript
5443 #endif
5445 #ifdef TICOFF
5446 /* COFF1 differs in section header size. */
5447 static const bfd_coff_backend_data ticoff1_swap_table =
5449 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5450 coff_SWAP_aux_out, coff_SWAP_sym_out,
5451 coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5452 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5453 coff_SWAP_scnhdr_out,
5454 FILHSZ, AOUTSZ, SCNHSZ_V01, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
5455 #ifdef COFF_LONG_FILENAMES
5456 TRUE,
5457 #else
5458 FALSE,
5459 #endif
5460 #ifdef COFF_LONG_SECTION_NAMES
5461 TRUE,
5462 #else
5463 FALSE,
5464 #endif
5465 COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5466 #ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5467 TRUE,
5468 #else
5469 FALSE,
5470 #endif
5471 #ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5473 #else
5475 #endif
5476 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5477 coff_SWAP_reloc_in, ticoff1_bad_format_hook, coff_set_arch_mach_hook,
5478 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5479 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5480 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5481 coff_classify_symbol, coff_compute_section_file_positions,
5482 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5483 coff_adjust_symndx, coff_link_add_one_symbol,
5484 coff_link_output_has_begun, coff_final_link_postscript
5486 #endif
5488 #ifndef coff_close_and_cleanup
5489 #define coff_close_and_cleanup _bfd_generic_close_and_cleanup
5490 #endif
5492 #ifndef coff_bfd_free_cached_info
5493 #define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
5494 #endif
5496 #ifndef coff_get_section_contents
5497 #define coff_get_section_contents _bfd_generic_get_section_contents
5498 #endif
5500 #ifndef coff_bfd_copy_private_symbol_data
5501 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5502 #endif
5504 #ifndef coff_bfd_copy_private_section_data
5505 #define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5506 #endif
5508 #ifndef coff_bfd_copy_private_bfd_data
5509 #define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5510 #endif
5512 #ifndef coff_bfd_merge_private_bfd_data
5513 #define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5514 #endif
5516 #ifndef coff_bfd_set_private_flags
5517 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5518 #endif
5520 #ifndef coff_bfd_print_private_bfd_data
5521 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5522 #endif
5524 #ifndef coff_bfd_is_local_label_name
5525 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5526 #endif
5528 #ifndef coff_read_minisymbols
5529 #define coff_read_minisymbols _bfd_generic_read_minisymbols
5530 #endif
5532 #ifndef coff_minisymbol_to_symbol
5533 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5534 #endif
5536 /* The reloc lookup routine must be supplied by each individual COFF
5537 backend. */
5538 #ifndef coff_bfd_reloc_type_lookup
5539 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5540 #endif
5542 #ifndef coff_bfd_get_relocated_section_contents
5543 #define coff_bfd_get_relocated_section_contents \
5544 bfd_generic_get_relocated_section_contents
5545 #endif
5547 #ifndef coff_bfd_relax_section
5548 #define coff_bfd_relax_section bfd_generic_relax_section
5549 #endif
5551 #ifndef coff_bfd_gc_sections
5552 #define coff_bfd_gc_sections bfd_generic_gc_sections
5553 #endif
5555 #ifndef coff_bfd_merge_sections
5556 #define coff_bfd_merge_sections bfd_generic_merge_sections
5557 #endif
5559 #ifndef coff_bfd_discard_group
5560 #define coff_bfd_discard_group bfd_generic_discard_group
5561 #endif
5563 #define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5564 const bfd_target VAR = \
5566 NAME , \
5567 bfd_target_coff_flavour, \
5568 BFD_ENDIAN_BIG, /* data byte order is big */ \
5569 BFD_ENDIAN_BIG, /* header byte order is big */ \
5570 /* object flags */ \
5571 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5572 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5573 /* section flags */ \
5574 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5575 UNDER, /* leading symbol underscore */ \
5576 '/', /* ar_pad_char */ \
5577 15, /* ar_max_namelen */ \
5579 /* Data conversion functions. */ \
5580 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5581 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5582 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5584 /* Header conversion functions. */ \
5585 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5586 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5587 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5589 /* bfd_check_format */ \
5590 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5591 _bfd_dummy_target }, \
5592 /* bfd_set_format */ \
5593 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5594 /* bfd_write_contents */ \
5595 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5596 bfd_false }, \
5598 BFD_JUMP_TABLE_GENERIC (coff), \
5599 BFD_JUMP_TABLE_COPY (coff), \
5600 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5601 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5602 BFD_JUMP_TABLE_SYMBOLS (coff), \
5603 BFD_JUMP_TABLE_RELOCS (coff), \
5604 BFD_JUMP_TABLE_WRITE (coff), \
5605 BFD_JUMP_TABLE_LINK (coff), \
5606 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5608 ALTERNATIVE, \
5610 SWAP_TABLE \
5613 #define CREATE_BIGHDR_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5614 const bfd_target VAR = \
5616 NAME , \
5617 bfd_target_coff_flavour, \
5618 BFD_ENDIAN_LITTLE, /* data byte order is little */ \
5619 BFD_ENDIAN_BIG, /* header byte order is big */ \
5620 /* object flags */ \
5621 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5622 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5623 /* section flags */ \
5624 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5625 UNDER, /* leading symbol underscore */ \
5626 '/', /* ar_pad_char */ \
5627 15, /* ar_max_namelen */ \
5629 /* Data conversion functions. */ \
5630 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5631 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5632 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5634 /* Header conversion functions. */ \
5635 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5636 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5637 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5639 /* bfd_check_format */ \
5640 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5641 _bfd_dummy_target }, \
5642 /* bfd_set_format */ \
5643 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5644 /* bfd_write_contents */ \
5645 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5646 bfd_false }, \
5648 BFD_JUMP_TABLE_GENERIC (coff), \
5649 BFD_JUMP_TABLE_COPY (coff), \
5650 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5651 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5652 BFD_JUMP_TABLE_SYMBOLS (coff), \
5653 BFD_JUMP_TABLE_RELOCS (coff), \
5654 BFD_JUMP_TABLE_WRITE (coff), \
5655 BFD_JUMP_TABLE_LINK (coff), \
5656 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5658 ALTERNATIVE, \
5660 SWAP_TABLE \
5663 #define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5664 const bfd_target VAR = \
5666 NAME , \
5667 bfd_target_coff_flavour, \
5668 BFD_ENDIAN_LITTLE, /* data byte order is little */ \
5669 BFD_ENDIAN_LITTLE, /* header byte order is little */ \
5670 /* object flags */ \
5671 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5672 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5673 /* section flags */ \
5674 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5675 UNDER, /* leading symbol underscore */ \
5676 '/', /* ar_pad_char */ \
5677 15, /* ar_max_namelen */ \
5679 /* Data conversion functions. */ \
5680 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5681 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5682 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5683 /* Header conversion functions. */ \
5684 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5685 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5686 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5687 /* bfd_check_format */ \
5688 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5689 _bfd_dummy_target }, \
5690 /* bfd_set_format */ \
5691 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5692 /* bfd_write_contents */ \
5693 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5694 bfd_false }, \
5696 BFD_JUMP_TABLE_GENERIC (coff), \
5697 BFD_JUMP_TABLE_COPY (coff), \
5698 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5699 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5700 BFD_JUMP_TABLE_SYMBOLS (coff), \
5701 BFD_JUMP_TABLE_RELOCS (coff), \
5702 BFD_JUMP_TABLE_WRITE (coff), \
5703 BFD_JUMP_TABLE_LINK (coff), \
5704 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5706 ALTERNATIVE, \
5708 SWAP_TABLE \