projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Oops, accidental commit, reverting.
[deliverable/binutils-gdb.git] / bfd / coffcode.h
CommitLineData
252b5132 1/* Support for the generic parts of most COFF variants, for BFD.
7898deda 2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
ed781d5d 3 2000, 2001, 2002, 2003
252b5132
RH		 4 Free Software Foundation, Inc.
5 Written by Cygnus Support.
6
ed781d5d 7 This file is part of BFD, the Binary File Descriptor library.
252b5132 8
ed781d5d
NC		 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.
252b5132 13
ed781d5d
NC		 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.
252b5132 18
ed781d5d
NC		 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. */
252b5132
RH		 22
23/*
24Most of this hacked by Steve Chamberlain,
25 sac@cygnus.com
26*/
27/*
28
29SECTION
30 coff backends
31
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.
36
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}.
46
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}.
51
52SUBSECTION
53 Porting to a new version of coff
54
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.
67
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.
76
77SUBSECTION
78 How the coff backend works
79
80SUBSUBSECTION
81 File layout
82
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.
89
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.
94
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}.
100
101 Some of the Coff targets then also have additional routines in
102 the target source file itself.
103
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.
112
113SUBSUBSECTION
114 Bit twiddling
115
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}
00692651 135 and @code{coff_swap_lineno_in}. @code{GDB} reads the symbol
252b5132
RH		 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.
147
148SUBSUBSECTION
149 Symbol reading
150
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".
155
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"}).
172
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.
178
252b5132
RH		 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.
185
186 Any linenumbers are read from the coff file too, and attached
187 to the symbols which own the functions the linenumbers belong to.
188
189SUBSUBSECTION
190 Symbol writing
191
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.
197
198 When the symbols have come from a coff file then all the
199 debugging information is preserved.
200
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.
205
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.
211
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}.
222
223 o <<coff_mangle_symbols>>
224
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
ed781d5d 228 structured hierarchy required by coff. It changes each pointer
252b5132
RH		 229 to a symbol into the index into the symbol table of the asymbol.
230
231 o <<coff_write_symbols>>
232
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.
236
237*/
238
239/*
240INTERNAL_DEFINITION
241 coff_symbol_type
242
243DESCRIPTION
244 The hidden information for an <<asymbol>> is described in a
245 <<combined_entry_type>>:
246
247CODE_FRAGMENT
248.
249.typedef struct coff_ptr_struct
250.{
dc810e39
AM		 251. {* Remembers the offset from the first symbol in the file for
252. this symbol. Generated by coff_renumber_symbols. *}
253. unsigned int offset;
252b5132 254.
dc810e39
AM		 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;
252b5132 258.
dc810e39
AM		 259. {* Should the tag field of this symbol be renumbered.
260. Created by coff_pointerize_aux. *}
261. unsigned int fix_tag : 1;
252b5132 262.
dc810e39
AM		 263. {* Should the endidx field of this symbol be renumbered.
264. Created by coff_pointerize_aux. *}
265. unsigned int fix_end : 1;
252b5132 266.
dc810e39
AM		 267. {* Should the x_csect.x_scnlen field be renumbered.
268. Created by coff_pointerize_aux. *}
269. unsigned int fix_scnlen : 1;
252b5132 270.
dc810e39
AM		 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;
252b5132 274.
dc810e39
AM		 275. {* The container for the symbol structure as read and translated
276. from the file. *}
277. union
278. {
279. union internal_auxent auxent;
280. struct internal_syment syment;
281. } u;
252b5132
RH		 282.} combined_entry_type;
283.
284.
285.{* Each canonical asymbol really looks like this: *}
286.
287.typedef struct coff_symbol_struct
288.{
dc810e39
AM		 289. {* The actual symbol which the rest of BFD works with *}
290. asymbol symbol;
252b5132 291.
dc810e39
AM		 292. {* A pointer to the hidden information for this symbol *}
293. combined_entry_type *native;
252b5132 294.
dc810e39
AM		 295. {* A pointer to the linenumber information for this symbol *}
296. struct lineno_cache_entry *lineno;
252b5132 297.
dc810e39 298. {* Have the line numbers been relocated yet ? *}
b34976b6 299. bfd_boolean done_lineno;
252b5132
RH		 300.} coff_symbol_type;
301
252b5132
RH		 302*/
303
304#ifdef COFF_WITH_PE
305#include "peicode.h"
306#else
307#include "coffswap.h"
308#endif
309
310#define STRING_SIZE_SIZE (4)
311
b34976b6
AM		 312static long sec_to_styp_flags
313 PARAMS ((const char *, flagword));
314static bfd_boolean styp_to_sec_flags
7c8ca0e4 315 PARAMS ((bfd *, PTR, const char *, asection *, flagword *));
b34976b6
AM		 316static bfd_boolean coff_bad_format_hook
317 PARAMS ((bfd *, PTR));
5dccc1dd
ILT		 318static void coff_set_custom_section_alignment
319 PARAMS ((bfd *, asection *, const struct coff_section_alignment_entry *,
8a1ad8e7 320 const unsigned int));
b34976b6
AM		 321static bfd_boolean coff_new_section_hook
322 PARAMS ((bfd *, asection *));
323static bfd_boolean coff_set_arch_mach_hook
324 PARAMS ((bfd *, PTR));
325static bfd_boolean coff_write_relocs
326 PARAMS ((bfd *, int));
327static bfd_boolean coff_set_flags
252b5132 328 PARAMS ((bfd *, unsigned int *, unsigned short *));
b34976b6 329static bfd_boolean coff_set_arch_mach
dc810e39 330 PARAMS ((bfd *, enum bfd_architecture, unsigned long)) ATTRIBUTE_UNUSED;
b34976b6
AM		 331static bfd_boolean coff_compute_section_file_positions
332 PARAMS ((bfd *));
333static bfd_boolean coff_write_object_contents
334 PARAMS ((bfd *)) ATTRIBUTE_UNUSED;
335static bfd_boolean coff_set_section_contents
0f867abe 336 PARAMS ((bfd *, asection *, const PTR, file_ptr, bfd_size_type));
b34976b6
AM		 337static PTR buy_and_read
338 PARAMS ((bfd *, file_ptr, bfd_size_type));
339static bfd_boolean coff_slurp_line_table
340 PARAMS ((bfd *, asection *));
341static bfd_boolean coff_slurp_symbol_table
342 PARAMS ((bfd *));
5d54c628
ILT		 343static enum coff_symbol_classification coff_classify_symbol
344 PARAMS ((bfd *, struct internal_syment *));
b34976b6
AM		 345static bfd_boolean coff_slurp_reloc_table
346 PARAMS ((bfd *, asection *, asymbol **));
252b5132
RH		 347static long coff_canonicalize_reloc
348 PARAMS ((bfd *, asection *, arelent **, asymbol **));
349#ifndef coff_mkobject_hook
b34976b6
AM		 350static PTR coff_mkobject_hook
351 PARAMS ((bfd *, PTR, PTR));
252b5132 352#endif
1276aefa 353#ifdef COFF_WITH_PE
b34976b6
AM		 354static flagword handle_COMDAT
355 PARAMS ((bfd *, flagword, PTR, const char *, asection *));
1276aefa 356#endif
05793179 357#ifdef COFF_IMAGE_WITH_PE
b34976b6
AM		 358static bfd_boolean coff_read_word
359 PARAMS ((bfd *, unsigned int *));
360static unsigned int coff_compute_checksum
361 PARAMS ((bfd *));
362static bfd_boolean coff_apply_checksum
363 PARAMS ((bfd *));
05793179 364#endif
5a5b9651
SS		 365#ifdef TICOFF
366static bfd_boolean ticoff0_bad_format_hook
367 PARAMS ((bfd *, PTR ));
368static bfd_boolean ticoff1_bad_format_hook
369 PARAMS ((bfd *, PTR ));
370#endif
252b5132
RH		 371\f
372/* void warning(); */
373
41733515
ILT		 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(). */
378
379#ifndef COFF_WITH_PE
380
51db3708
NC		 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
387
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
393
252b5132
RH		 394static long
395sec_to_styp_flags (sec_name, sec_flags)
dc810e39 396 const char *sec_name;
252b5132
RH		 397 flagword sec_flags;
398{
399 long styp_flags = 0;
400
401 if (!strcmp (sec_name, _TEXT))
402 {
403 styp_flags = STYP_TEXT;
404 }
405 else if (!strcmp (sec_name, _DATA))
406 {
407 styp_flags = STYP_DATA;
408 }
409 else if (!strcmp (sec_name, _BSS))
410 {
411 styp_flags = STYP_BSS;
412#ifdef _COMMENT
413 }
414 else if (!strcmp (sec_name, _COMMENT))
415 {
416 styp_flags = STYP_INFO;
417#endif /* _COMMENT */
418#ifdef _LIB
419 }
420 else if (!strcmp (sec_name, _LIB))
421 {
422 styp_flags = STYP_LIB;
423#endif /* _LIB */
424#ifdef _LIT
425 }
426 else if (!strcmp (sec_name, _LIT))
427 {
428 styp_flags = STYP_LIT;
429#endif /* _LIT */
430 }
51db3708 431 else if (!strncmp (sec_name, ".debug", 6))
252b5132 432 {
51db3708
NC		 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;
252b5132
RH		 438 }
439 else if (!strncmp (sec_name, ".stab", 5))
440 {
51db3708
NC		 441 styp_flags = STYP_DEBUG_INFO;
442 }
443#ifdef COFF_LONG_SECTION_NAMES
444 else if (!strncmp (sec_name, ".gnu.linkonce.wi.", 17))
445 {
446 styp_flags = STYP_DEBUG_INFO;
252b5132 447 }
51db3708 448#endif
252b5132
RH		 449#ifdef RS6000COFF_C
450 else if (!strcmp (sec_name, _PAD))
451 {
452 styp_flags = STYP_PAD;
453 }
454 else if (!strcmp (sec_name, _LOADER))
455 {
456 styp_flags = STYP_LOADER;
457 }
67fdeebe
TR		 458 else if (!strcmp (sec_name, _EXCEPT))
459 {
460 styp_flags = STYP_EXCEPT;
461 }
462 else if (!strcmp (sec_name, _TYPCHK))
463 {
464 styp_flags = STYP_TYPCHK;
465 }
252b5132
RH		 466#endif
467 /* Try and figure out what it should be */
468 else if (sec_flags & SEC_CODE)
469 {
470 styp_flags = STYP_TEXT;
471 }
472 else if (sec_flags & SEC_DATA)
473 {
474 styp_flags = STYP_DATA;
475 }
476 else if (sec_flags & SEC_READONLY)
477 {
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 */
483 }
484 else if (sec_flags & SEC_LOAD)
485 {
486 styp_flags = STYP_TEXT;
487 }
488 else if (sec_flags & SEC_ALLOC)
489 {
490 styp_flags = STYP_BSS;
491 }
492
34cbe64e
TW		 493#ifdef STYP_CLINK
494 if (sec_flags & SEC_CLINK)
495 styp_flags |= STYP_CLINK;
496#endif
497
498#ifdef STYP_BLOCK
499 if (sec_flags & SEC_BLOCK)
500 styp_flags |= STYP_BLOCK;
501#endif
502
252b5132
RH		 503#ifdef STYP_NOLOAD
504 if ((sec_flags & (SEC_NEVER_LOAD | SEC_COFF_SHARED_LIBRARY)) != 0)
505 styp_flags |= STYP_NOLOAD;
506#endif
507
41733515
ILT		 508 return styp_flags;
509}
510
511#else /* COFF_WITH_PE */
512
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. */
518
519static long
520sec_to_styp_flags (sec_name, sec_flags)
521 const char *sec_name ATTRIBUTE_UNUSED;
522 flagword sec_flags;
523{
524 long styp_flags = 0;
525
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. */
533
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 */
dc810e39 544 /* skip constRUCTOR */
41733515
ILT		 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)
252b5132 551 styp_flags |= IMAGE_SCN_LNK_COMDAT;
41733515
ILT		 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 */
e60b52c6
KH		 560 if (sec_flags & SEC_LINK_ONCE)
561 styp_flags |= IMAGE_SCN_LNK_COMDAT;
41733515
ILT		 562 /* skip LINK_DUPLICATES */
563 /* skip LINKER_CREATED */
564
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
ed781d5d 567 are retained in pei_section_data(abfd, section)->pe_flags. */
41733515 568
ed781d5d 569 styp_flags |= IMAGE_SCN_MEM_READ; /* Always readable. */
41733515 570 if ((sec_flags & SEC_READONLY) == 0)
ed781d5d 571 styp_flags |= IMAGE_SCN_MEM_WRITE; /* Invert READONLY for write. */
41733515 572 if (sec_flags & SEC_CODE)
ed781d5d 573 styp_flags |= IMAGE_SCN_MEM_EXECUTE; /* CODE->EXECUTE. */
bd826630 574 if (sec_flags & SEC_SHARED)
ed781d5d 575 styp_flags |= IMAGE_SCN_MEM_SHARED; /* Shared remains meaningful. */
252b5132 576
e60b52c6 577 return styp_flags;
252b5132 578}
41733515
ILT		 579
580#endif /* COFF_WITH_PE */
581
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(). */
586
587#ifndef COFF_WITH_PE
588
b34976b6 589static bfd_boolean
7c8ca0e4 590styp_to_sec_flags (abfd, hdr, name, section, flags_ptr)
5f771d47 591 bfd *abfd ATTRIBUTE_UNUSED;
252b5132
RH		 592 PTR hdr;
593 const char *name;
41733515 594 asection *section ATTRIBUTE_UNUSED;
7c8ca0e4 595 flagword *flags_ptr;
252b5132
RH		 596{
597 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
598 long styp_flags = internal_s->s_flags;
599 flagword sec_flags = 0;
600
34cbe64e
TW		 601#ifdef STYP_BLOCK
602 if (styp_flags & STYP_BLOCK)
7c8ca0e4 603 sec_flags |= SEC_BLOCK;
e60b52c6 604#endif
34cbe64e
TW		 605
606#ifdef STYP_CLINK
607 if (styp_flags & STYP_CLINK)
7c8ca0e4 608 sec_flags |= SEC_CLINK;
e60b52c6 609#endif
34cbe64e 610
252b5132
RH		 611#ifdef STYP_NOLOAD
612 if (styp_flags & STYP_NOLOAD)
7c8ca0e4 613 sec_flags |= SEC_NEVER_LOAD;
252b5132
RH		 614#endif /* STYP_NOLOAD */
615
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)
619 {
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;
624 }
625 else if (styp_flags & STYP_DATA)
626 {
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;
631 }
632 else if (styp_flags & STYP_BSS)
633 {
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;
640 }
641 else if (styp_flags & STYP_INFO)
642 {
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
652 }
653 else if (styp_flags & STYP_PAD)
7c8ca0e4 654 sec_flags = 0;
252b5132
RH		 655 else if (strcmp (name, _TEXT) == 0)
656 {
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;
661 }
662 else if (strcmp (name, _DATA) == 0)
663 {
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;
668 }
669 else if (strcmp (name, _BSS) == 0)
670 {
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;
677 }
51db3708 678 else if (strncmp (name, ".debug", 6) == 0
252b5132
RH		 679#ifdef _COMMENT
680 || strcmp (name, _COMMENT) == 0
51db3708
NC		 681#endif
682#ifdef COFF_LONG_SECTION_NAMES
683 || strncmp (name, ".gnu.linkonce.wi.", 17) == 0
252b5132
RH		 684#endif
685 || strncmp (name, ".stab", 5) == 0)
686 {
687#ifdef COFF_PAGE_SIZE
688 sec_flags |= SEC_DEBUGGING;
689#endif
690 }
691#ifdef _LIB
692 else if (strcmp (name, _LIB) == 0)
693 ;
694#endif
695#ifdef _LIT
696 else if (strcmp (name, _LIT) == 0)
7c8ca0e4 697 sec_flags = SEC_LOAD | SEC_ALLOC | SEC_READONLY;
252b5132
RH		 698#endif
699 else
7c8ca0e4 700 sec_flags |= SEC_ALLOC | SEC_LOAD;
252b5132 701
ed781d5d 702#ifdef STYP_LIT /* A29k readonly text/data section type. */
252b5132 703 if ((styp_flags & STYP_LIT) == STYP_LIT)
7c8ca0e4 704 sec_flags = (SEC_LOAD | SEC_ALLOC | SEC_READONLY);
252b5132 705#endif /* STYP_LIT */
7c8ca0e4 706
ed781d5d 707#ifdef STYP_OTHER_LOAD /* Other loaded sections. */
252b5132 708 if (styp_flags & STYP_OTHER_LOAD)
7c8ca0e4 709 sec_flags = (SEC_LOAD | SEC_ALLOC);
252b5132
RH		 710#endif /* STYP_SDATA */
711
41733515
ILT		 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
722
7c8ca0e4 723 if (flags_ptr == NULL)
b34976b6 724 return FALSE;
7c8ca0e4
NC		 725
726 * flags_ptr = sec_flags;
b34976b6 727 return TRUE;
41733515
ILT		 728}
729
730#else /* COFF_WITH_PE */
731
41733515 732static flagword
1276aefa
NC		 733handle_COMDAT (abfd, sec_flags, hdr, name, section)
734 bfd * abfd;
735 flagword sec_flags;
41733515
ILT		 736 PTR hdr;
737 const char *name;
738 asection *section;
739{
740 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
1276aefa
NC		 741 bfd_byte *esymstart, *esym, *esymend;
742 int seen_state = 0;
743 char *target_name = NULL;
744
745 sec_flags |= SEC_LINK_ONCE;
746
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. */
753
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 */
759
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. */
763
764 if (! _bfd_coff_get_external_symbols (abfd))
765 return sec_flags;
dc810e39 766
1276aefa
NC		 767 esymstart = esym = (bfd_byte *) obj_coff_external_syms (abfd);
768 esymend = esym + obj_raw_syment_count (abfd) * bfd_coff_symesz (abfd);
769
770 while (esym < esymend)
41733515 771 {
1276aefa
NC		 772 struct internal_syment isym;
773 char buf[SYMNMLEN + 1];
774 const char *symname;
252b5132 775
1276aefa 776 bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &isym);
252b5132 777
1276aefa
NC		 778 if (sizeof (internal_s->s_name) > SYMNMLEN)
779 {
780 /* This case implies that the matching
781 symbol name will be in the string table. */
782 abort ();
783 }
784
785 if (isym.n_scnum == section->target_index)
786 {
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.
794
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.
798
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:
803
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. */
810
ed781d5d 811 /* All 3 branches use this. */
1276aefa
NC		 812 symname = _bfd_coff_internal_syment_name (abfd, &isym, buf);
813
814 if (symname == NULL)
815 abort ();
816
817 switch (seen_state)
252b5132 818 {
1276aefa
NC		 819 case 0:
820 {
821 /* The first time we've seen the symbol. */
822 union internal_auxent aux;
823
824 seen_state = 1;
825
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.)
837
838 Here, we think we've found the first one,
839 but there's some checking we can do to be
840 sure. */
841
842 if (! (isym.n_sclass == C_STAT
843 && isym.n_type == T_NULL
844 && isym.n_value == 0))
845 abort ();
252b5132 846
1276aefa
NC		 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. */
252b5132 851
1276aefa 852 if (strcmp (name, symname) != 0)
252b5132 853 abort ();
252b5132 854
1276aefa
NC		 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);
859
860 target_name = strchr (name, '$');
861 if (target_name != NULL)
862 {
863 /* Gas mode. */
864 seen_state = 2;
865 /* Skip the `$'. */
866 target_name += 1;
867 }
868
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. */
878
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. */
884
885 switch (aux.x_scn.x_comdat)
886 {
887 case IMAGE_COMDAT_SELECT_NODUPLICATES:
e60b52c6 888#ifdef STRICT_PE_FORMAT
1276aefa 889 sec_flags |= SEC_LINK_DUPLICATES_ONE_ONLY;
ec0ef80e 890#else
1276aefa 891 sec_flags &= ~SEC_LINK_ONCE;
ec0ef80e 892#endif
1276aefa 893 break;
252b5132 894
1276aefa
NC		 895 case IMAGE_COMDAT_SELECT_ANY:
896 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
897 break;
252b5132 898
1276aefa
NC		 899 case IMAGE_COMDAT_SELECT_SAME_SIZE:
900 sec_flags |= SEC_LINK_DUPLICATES_SAME_SIZE;
901 break;
252b5132 902
1276aefa
NC		 903 case IMAGE_COMDAT_SELECT_EXACT_MATCH:
904 /* Not yet fully implemented ??? */
905 sec_flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS;
906 break;
252b5132 907
1276aefa
NC		 908 /* debug$S gets this case; other
909 implications ??? */
e5db213d 910
1276aefa
NC		 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:
0717ebb7 916#ifdef STRICT_PE_FORMAT
1276aefa
NC		 917 /* FIXME: This is not currently implemented. */
918 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
ec0ef80e 919#else
1276aefa 920 sec_flags &= ~SEC_LINK_ONCE;
ec0ef80e 921#endif
1276aefa 922 break;
e5db213d 923
1276aefa
NC		 924 default: /* 0 means "no symbol" */
925 /* debug$F gets this case; other
926 implications ??? */
927 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
928 break;
929 }
930 }
931 break;
41733515 932
1276aefa
NC		 933 case 2:
934 /* Gas mode: the first matching on partial name. */
252b5132 935
e5db213d
ILT		 936#ifndef TARGET_UNDERSCORE
937#define TARGET_UNDERSCORE 0
938#endif
ed781d5d 939 /* Is this the name we're looking for ? */
1276aefa
NC		 940 if (strcmp (target_name,
941 symname + (TARGET_UNDERSCORE ? 1 : 0)) != 0)
942 {
943 /* Not the name we're looking for */
944 esym += (isym.n_numaux + 1) * bfd_coff_symesz (abfd);
945 continue;
252b5132 946 }
1276aefa
NC		 947 /* Fall through. */
948 case 1:
949 /* MSVC mode: the lexically second symbol (or
950 drop through from the above). */
951 {
952 char *newname;
dc810e39 953 bfd_size_type amt;
1276aefa 954
08da05b0 955 /* This must the second symbol with the
1276aefa
NC		 956 section #. It is the actual symbol name.
957 Intel puts the two adjacent, but Alpha (at
958 least) spreads them out. */
959
dc810e39
AM		 960 amt = sizeof (struct bfd_comdat_info);
961 section->comdat = bfd_alloc (abfd, amt);
1276aefa
NC		 962 if (section->comdat == NULL)
963 abort ();
964
965 section->comdat->symbol =
966 (esym - esymstart) / bfd_coff_symesz (abfd);
967
dc810e39
AM		 968 amt = strlen (symname) + 1;
969 newname = bfd_alloc (abfd, amt);
1276aefa
NC		 970 if (newname == NULL)
971 abort ();
972
973 strcpy (newname, symname);
974 section->comdat->name = newname;
975 }
252b5132 976
1276aefa 977 goto breakloop;
252b5132
RH		 978 }
979 }
1276aefa
NC		 980
981 esym += (isym.n_numaux + 1) * bfd_coff_symesz (abfd);
982 }
983
984 breakloop:
985 return sec_flags;
986}
987
988
989/* The PE version; see above for the general comments.
990
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? */
997
b34976b6 998static bfd_boolean
7c8ca0e4 999styp_to_sec_flags (abfd, hdr, name, section, flags_ptr)
1276aefa
NC		 1000 bfd *abfd;
1001 PTR hdr;
1002 const char *name;
1003 asection *section;
7c8ca0e4 1004 flagword *flags_ptr;
1276aefa
NC		 1005{
1006 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
1007 long styp_flags = internal_s->s_flags;
1008 flagword sec_flags;
b34976b6 1009 bfd_boolean result = TRUE;
1276aefa
NC		 1010
1011 /* Assume read only unless IMAGE_SCN_MEM_WRITE is specified. */
1012 sec_flags = SEC_READONLY;
1013
1014 /* Process each flag bit in styp_flags in turn. */
1015 while (styp_flags)
1016 {
1017 long flag = styp_flags & - styp_flags;
1018 char * unhandled = NULL;
dc810e39 1019
1276aefa
NC		 1020 styp_flags &= ~ flag;
1021
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. */
1025
1026 switch (flag)
1027 {
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;
dc810e39 1044#endif
1276aefa
NC		 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 sec_flags |= SEC_DEBUGGING;
1068 break;
1069 case IMAGE_SCN_MEM_SHARED:
1070 sec_flags |= SEC_SHARED;
1071 break;
1072 case IMAGE_SCN_LNK_REMOVE:
1073 sec_flags |= SEC_EXCLUDE;
1074 break;
1075 case IMAGE_SCN_CNT_CODE:
1076 sec_flags |= SEC_CODE | SEC_ALLOC | SEC_LOAD;
1077 break;
1078 case IMAGE_SCN_CNT_INITIALIZED_DATA:
1079 sec_flags |= SEC_DATA | SEC_ALLOC | SEC_LOAD;
1080 break;
1081 case IMAGE_SCN_CNT_UNINITIALIZED_DATA:
1082 sec_flags |= SEC_ALLOC;
1083 break;
1084 case IMAGE_SCN_LNK_INFO:
1085 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
1086 defined. coff_compute_section_file_positions uses
1087 COFF_PAGE_SIZE to ensure that the low order bits of the
1088 section VMA and the file offset match. If we don't know
1089 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
1090 and demand page loading of the file will fail. */
1091#ifdef COFF_PAGE_SIZE
1092 sec_flags |= SEC_DEBUGGING;
1093#endif
1094 break;
1095 case IMAGE_SCN_LNK_COMDAT:
1096 /* COMDAT gets very special treatment. */
1097 sec_flags = handle_COMDAT (abfd, sec_flags, hdr, name, section);
1098 break;
1099 default:
1100 /* Silently ignore for now. */
dc810e39 1101 break;
1276aefa
NC		 1102 }
1103
7c8ca0e4 1104 /* If the section flag was not handled, report it here. */
1276aefa 1105 if (unhandled != NULL)
7c8ca0e4
NC		 1106 {
1107 (*_bfd_error_handler)
1108 (_("%s (%s): Section flag %s (0x%x) ignored"),
8f615d07 1109 bfd_archive_filename (abfd), name, unhandled, flag);
b34976b6 1110 result = FALSE;
7c8ca0e4 1111 }
252b5132 1112 }
252b5132 1113
242eabea
ILT		 1114#if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1115 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1116 only link a single copy of the section. This is used to support
1117 g++. g++ will emit each template expansion in its own section.
1118 The symbols will be defined as weak, so that multiple definitions
1119 are permitted. The GNU linker extension is to actually discard
1120 all but one of the sections. */
1121 if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
1122 sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
1123#endif
1124
7c8ca0e4
NC		 1125 if (flags_ptr)
1126 * flags_ptr = sec_flags;
dc810e39 1127
7c8ca0e4 1128 return result;
252b5132
RH		 1129}
1130
41733515
ILT		 1131#endif /* COFF_WITH_PE */
1132
252b5132
RH		 1133#define get_index(symbol) ((symbol)->udata.i)
1134
1135/*
1136INTERNAL_DEFINITION
1137 bfd_coff_backend_data
1138
1139CODE_FRAGMENT
1140
5d54c628
ILT		 1141.{* COFF symbol classifications. *}
1142.
1143.enum coff_symbol_classification
1144.{
1145. {* Global symbol. *}
1146. COFF_SYMBOL_GLOBAL,
1147. {* Common symbol. *}
1148. COFF_SYMBOL_COMMON,
1149. {* Undefined symbol. *}
1150. COFF_SYMBOL_UNDEFINED,
1151. {* Local symbol. *}
1152. COFF_SYMBOL_LOCAL,
1153. {* PE section symbol. *}
1154. COFF_SYMBOL_PE_SECTION
1155.};
1156.
252b5132
RH		 1157Special entry points for gdb to swap in coff symbol table parts:
1158.typedef struct
1159.{
dc810e39
AM		 1160. void (*_bfd_coff_swap_aux_in)
1161. PARAMS ((bfd *, PTR, int, int, int, int, PTR));
252b5132 1162.
dc810e39
AM		 1163. void (*_bfd_coff_swap_sym_in)
1164. PARAMS ((bfd *, PTR, PTR));
252b5132 1165.
dc810e39
AM		 1166. void (*_bfd_coff_swap_lineno_in)
1167. PARAMS ((bfd *, PTR, PTR));
252b5132 1168.
dc810e39
AM		 1169. unsigned int (*_bfd_coff_swap_aux_out)
1170. PARAMS ((bfd *, PTR, int, int, int, int, PTR));
252b5132 1171.
dc810e39
AM		 1172. unsigned int (*_bfd_coff_swap_sym_out)
1173. PARAMS ((bfd *, PTR, PTR));
252b5132 1174.
dc810e39
AM		 1175. unsigned int (*_bfd_coff_swap_lineno_out)
1176. PARAMS ((bfd *, PTR, PTR));
252b5132 1177.
dc810e39
AM		 1178. unsigned int (*_bfd_coff_swap_reloc_out)
1179. PARAMS ((bfd *, PTR, PTR));
252b5132 1180.
dc810e39
AM		 1181. unsigned int (*_bfd_coff_swap_filehdr_out)
1182. PARAMS ((bfd *, PTR, PTR));
252b5132 1183.
dc810e39
AM		 1184. unsigned int (*_bfd_coff_swap_aouthdr_out)
1185. PARAMS ((bfd *, PTR, PTR));
252b5132 1186.
dc810e39
AM		 1187. unsigned int (*_bfd_coff_swap_scnhdr_out)
1188. PARAMS ((bfd *, PTR, PTR));
252b5132 1189.
dc810e39
AM		 1190. unsigned int _bfd_filhsz;
1191. unsigned int _bfd_aoutsz;
1192. unsigned int _bfd_scnhsz;
1193. unsigned int _bfd_symesz;
1194. unsigned int _bfd_auxesz;
1195. unsigned int _bfd_relsz;
1196. unsigned int _bfd_linesz;
1197. unsigned int _bfd_filnmlen;
b34976b6
AM		 1198. bfd_boolean _bfd_coff_long_filenames;
1199. bfd_boolean _bfd_coff_long_section_names;
dc810e39 1200. unsigned int _bfd_coff_default_section_alignment_power;
b34976b6 1201. bfd_boolean _bfd_coff_force_symnames_in_strings;
dc810e39
AM		 1202. unsigned int _bfd_coff_debug_string_prefix_length;
1203.
1204. void (*_bfd_coff_swap_filehdr_in)
1205. PARAMS ((bfd *, PTR, PTR));
1206.
1207. void (*_bfd_coff_swap_aouthdr_in)
1208. PARAMS ((bfd *, PTR, PTR));
1209.
1210. void (*_bfd_coff_swap_scnhdr_in)
1211. PARAMS ((bfd *, PTR, PTR));
1212.
1213. void (*_bfd_coff_swap_reloc_in)
1214. PARAMS ((bfd *abfd, PTR, PTR));
1215.
b34976b6 1216. bfd_boolean (*_bfd_coff_bad_format_hook)
dc810e39
AM		 1217. PARAMS ((bfd *, PTR));
1218.
b34976b6 1219. bfd_boolean (*_bfd_coff_set_arch_mach_hook)
dc810e39
AM		 1220. PARAMS ((bfd *, PTR));
1221.
1222. PTR (*_bfd_coff_mkobject_hook)
1223. PARAMS ((bfd *, PTR, PTR));
1224.
b34976b6 1225. bfd_boolean (*_bfd_styp_to_sec_flags_hook)
dc810e39
AM		 1226. PARAMS ((bfd *, PTR, const char *, asection *, flagword *));
1227.
1228. void (*_bfd_set_alignment_hook)
1229. PARAMS ((bfd *, asection *, PTR));
1230.
b34976b6 1231. bfd_boolean (*_bfd_coff_slurp_symbol_table)
dc810e39
AM		 1232. PARAMS ((bfd *));
1233.
b34976b6 1234. bfd_boolean (*_bfd_coff_symname_in_debug)
dc810e39
AM		 1235. PARAMS ((bfd *, struct internal_syment *));
1236.
b34976b6 1237. bfd_boolean (*_bfd_coff_pointerize_aux_hook)
dc810e39
AM		 1238. PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
1239. unsigned int, combined_entry_type *));
1240.
b34976b6 1241. bfd_boolean (*_bfd_coff_print_aux)
dc810e39
AM		 1242. PARAMS ((bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1243. combined_entry_type *, unsigned int));
1244.
1245. void (*_bfd_coff_reloc16_extra_cases)
1246. PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
1247. bfd_byte *, unsigned int *, unsigned int *));
1248.
1249. int (*_bfd_coff_reloc16_estimate)
1250. PARAMS ((bfd *, asection *, arelent *, unsigned int,
1251. struct bfd_link_info *));
1252.
1253. enum coff_symbol_classification (*_bfd_coff_classify_symbol)
1254. PARAMS ((bfd *, struct internal_syment *));
1255.
b34976b6 1256. bfd_boolean (*_bfd_coff_compute_section_file_positions)
dc810e39 1257. PARAMS ((bfd *));
252b5132 1258.
b34976b6 1259. bfd_boolean (*_bfd_coff_start_final_link)
dc810e39
AM		 1260. PARAMS ((bfd *, struct bfd_link_info *));
1261.
b34976b6 1262. bfd_boolean (*_bfd_coff_relocate_section)
dc810e39
AM		 1263. PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
1264. struct internal_reloc *, struct internal_syment *, asection **));
1265.
1266. reloc_howto_type *(*_bfd_coff_rtype_to_howto)
1267. PARAMS ((bfd *, asection *, struct internal_reloc *,
1268. struct coff_link_hash_entry *, struct internal_syment *,
1269. bfd_vma *));
1270.
b34976b6 1271. bfd_boolean (*_bfd_coff_adjust_symndx)
dc810e39 1272. PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *,
b34976b6 1273. struct internal_reloc *, bfd_boolean *));
dc810e39 1274.
b34976b6 1275. bfd_boolean (*_bfd_coff_link_add_one_symbol)
dc810e39 1276. PARAMS ((struct bfd_link_info *, bfd *, const char *, flagword,
b34976b6 1277. asection *, bfd_vma, const char *, bfd_boolean, bfd_boolean,
dc810e39
AM		 1278. struct bfd_link_hash_entry **));
1279.
b34976b6 1280. bfd_boolean (*_bfd_coff_link_output_has_begun)
dc810e39
AM		 1281. PARAMS ((bfd *, struct coff_final_link_info *));
1282.
b34976b6 1283. bfd_boolean (*_bfd_coff_final_link_postscript)
dc810e39 1284. PARAMS ((bfd *, struct coff_final_link_info *));
252b5132
RH		 1285.
1286.} bfd_coff_backend_data;
1287.
dc810e39
AM		 1288.#define coff_backend_info(abfd) \
1289. ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
252b5132
RH		 1290.
1291.#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
dc810e39 1292. ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
252b5132
RH		 1293.
1294.#define bfd_coff_swap_sym_in(a,e,i) \
dc810e39 1295. ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
252b5132
RH		 1296.
1297.#define bfd_coff_swap_lineno_in(a,e,i) \
dc810e39 1298. ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
252b5132
RH		 1299.
1300.#define bfd_coff_swap_reloc_out(abfd, i, o) \
dc810e39 1301. ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
252b5132
RH		 1302.
1303.#define bfd_coff_swap_lineno_out(abfd, i, o) \
dc810e39 1304. ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
252b5132
RH		 1305.
1306.#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
dc810e39 1307. ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
252b5132
RH		 1308.
1309.#define bfd_coff_swap_sym_out(abfd, i,o) \
dc810e39 1310. ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
252b5132
RH		 1311.
1312.#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
dc810e39 1313. ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
252b5132
RH		 1314.
1315.#define bfd_coff_swap_filehdr_out(abfd, i,o) \
dc810e39 1316. ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
252b5132
RH		 1317.
1318.#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
dc810e39 1319. ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
252b5132
RH		 1320.
1321.#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1322.#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1323.#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1324.#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1325.#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1326.#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1327.#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
692b7d62 1328.#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
dc810e39
AM		 1329.#define bfd_coff_long_filenames(abfd) \
1330. (coff_backend_info (abfd)->_bfd_coff_long_filenames)
252b5132 1331.#define bfd_coff_long_section_names(abfd) \
dc810e39 1332. (coff_backend_info (abfd)->_bfd_coff_long_section_names)
252b5132 1333.#define bfd_coff_default_section_alignment_power(abfd) \
dc810e39 1334. (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
252b5132 1335.#define bfd_coff_swap_filehdr_in(abfd, i,o) \
dc810e39 1336. ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
252b5132
RH		 1337.
1338.#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
dc810e39 1339. ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
252b5132
RH		 1340.
1341.#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
dc810e39 1342. ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
252b5132
RH		 1343.
1344.#define bfd_coff_swap_reloc_in(abfd, i, o) \
dc810e39 1345. ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
252b5132
RH		 1346.
1347.#define bfd_coff_bad_format_hook(abfd, filehdr) \
dc810e39 1348. ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
252b5132
RH		 1349.
1350.#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
dc810e39 1351. ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
252b5132 1352.#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
ed781d5d
NC		 1353. ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook)\
1354. (abfd, filehdr, aouthdr))
252b5132 1355.
7c8ca0e4 1356.#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section, flags_ptr)\
dc810e39
AM		 1357. ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1358. (abfd, scnhdr, name, section, flags_ptr))
252b5132
RH		 1359.
1360.#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
dc810e39 1361. ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
252b5132
RH		 1362.
1363.#define bfd_coff_slurp_symbol_table(abfd)\
dc810e39 1364. ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
252b5132
RH		 1365.
1366.#define bfd_coff_symname_in_debug(abfd, sym)\
dc810e39 1367. ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
252b5132 1368.
2243c419 1369.#define bfd_coff_force_symnames_in_strings(abfd)\
dc810e39 1370. (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
2243c419
CP		 1371.
1372.#define bfd_coff_debug_string_prefix_length(abfd)\
dc810e39 1373. (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
2243c419 1374.
252b5132 1375.#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
dc810e39
AM		 1376. ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1377. (abfd, file, base, symbol, aux, indaux))
252b5132 1378.
ed781d5d
NC		 1379.#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order,\
1380. reloc, data, src_ptr, dst_ptr)\
dc810e39
AM		 1381. ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1382. (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
252b5132
RH		 1383.
1384.#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
dc810e39
AM		 1385. ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1386. (abfd, section, reloc, shrink, link_info))
252b5132 1387.
5d54c628 1388.#define bfd_coff_classify_symbol(abfd, sym)\
dc810e39
AM		 1389. ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
1390. (abfd, sym))
252b5132
RH		 1391.
1392.#define bfd_coff_compute_section_file_positions(abfd)\
dc810e39
AM		 1393. ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1394. (abfd))
252b5132
RH		 1395.
1396.#define bfd_coff_start_final_link(obfd, info)\
dc810e39
AM		 1397. ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1398. (obfd, info))
252b5132 1399.#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
dc810e39
AM		 1400. ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1401. (obfd, info, ibfd, o, con, rel, isyms, secs))
252b5132 1402.#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
dc810e39
AM		 1403. ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1404. (abfd, sec, rel, h, sym, addendp))
252b5132 1405.#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
dc810e39
AM		 1406. ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1407. (obfd, info, ibfd, sec, rel, adjustedp))
ed781d5d
NC		 1408.#define bfd_coff_link_add_one_symbol(info, abfd, name, flags, section,\
1409. value, string, cp, coll, hashp)\
dc810e39
AM		 1410. ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1411. (info, abfd, name, flags, section, value, string, cp, coll, hashp))
252b5132
RH		 1412.
1413.#define bfd_coff_link_output_has_begun(a,p) \
dc810e39 1414. ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a,p))
252b5132 1415.#define bfd_coff_final_link_postscript(a,p) \
dc810e39 1416. ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a,p))
252b5132
RH		 1417.
1418*/
1419
1420/* See whether the magic number matches. */
1421
b34976b6 1422static bfd_boolean
252b5132 1423coff_bad_format_hook (abfd, filehdr)
5f771d47 1424 bfd * abfd ATTRIBUTE_UNUSED;
252b5132
RH		 1425 PTR filehdr;
1426{
1427 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1428
1429 if (BADMAG (*internal_f))
b34976b6 1430 return FALSE;
252b5132 1431
ed781d5d 1432 /* If the optional header is NULL or not the correct size then
252b5132
RH		 1433 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1434 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1435 optional header is of a different size.
1436
1437 But the mips keeps extra stuff in it's opthdr, so dont check
ed781d5d 1438 when doing that. */
252b5132
RH		 1439
1440#if defined(M88) || defined(I960)
6b3b007b 1441 if (internal_f->f_opthdr != 0 && bfd_coff_aoutsz (abfd) != internal_f->f_opthdr)
b34976b6 1442 return FALSE;
252b5132
RH		 1443#endif
1444
b34976b6 1445 return TRUE;
252b5132
RH		 1446}
1447
5a5b9651
SS		 1448#ifdef TICOFF
1449static bfd_boolean
1450ticoff0_bad_format_hook (abfd, filehdr)
1451 bfd *abfd ATTRIBUTE_UNUSED;
1452 PTR filehdr;
1453{
1454 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1455
1456 if (COFF0_BADMAG (*internal_f))
1457 return FALSE;
1458
1459 return TRUE;
1460}
1461#endif
1462
1463#ifdef TICOFF
1464static bfd_boolean
1465ticoff1_bad_format_hook (abfd, filehdr)
1466 bfd *abfd ATTRIBUTE_UNUSED;
1467 PTR filehdr;
1468{
1469 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1470
1471 if (COFF1_BADMAG (*internal_f))
1472 return FALSE;
1473
1474 return TRUE;
1475}
1476#endif
1477
5dccc1dd
ILT		 1478/* Check whether this section uses an alignment other than the
1479 default. */
1480
1481static void
1482coff_set_custom_section_alignment (abfd, section, alignment_table, table_size)
1483 bfd *abfd ATTRIBUTE_UNUSED;
1484 asection *section;
1485 const struct coff_section_alignment_entry *alignment_table;
1486 const unsigned int table_size;
1487{
1488 const unsigned int default_alignment = COFF_DEFAULT_SECTION_ALIGNMENT_POWER;
1489 unsigned int i;
1490
1491 for (i = 0; i < table_size; ++i)
1492 {
1493 const char *secname = bfd_get_section_name (abfd, section);
ed781d5d 1494
5dccc1dd
ILT		 1495 if (alignment_table[i].comparison_length == (unsigned int) -1
1496 ? strcmp (alignment_table[i].name, secname) == 0
1497 : strncmp (alignment_table[i].name, secname,
1498 alignment_table[i].comparison_length) == 0)
1499 break;
1500 }
1501 if (i >= table_size)
1502 return;
1503
1504 if (alignment_table[i].default_alignment_min != COFF_ALIGNMENT_FIELD_EMPTY
1505 && default_alignment < alignment_table[i].default_alignment_min)
1506 return;
1507
1508 if (alignment_table[i].default_alignment_max != COFF_ALIGNMENT_FIELD_EMPTY
1e738b87
NC		 1509#if COFF_DEFAULT_SECTION_ALIGNMENT_POWER != 0
1510 && default_alignment > alignment_table[i].default_alignment_max
1511#endif
1512 )
5dccc1dd
ILT		 1513 return;
1514
1515 section->alignment_power = alignment_table[i].alignment_power;
1516}
1517
1518/* Custom section alignment records. */
1519
1520static const struct coff_section_alignment_entry
1521coff_section_alignment_table[] =
1522{
1523#ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1524 COFF_SECTION_ALIGNMENT_ENTRIES,
1525#endif
1526 /* There must not be any gaps between .stabstr sections. */
1527 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1528 1, COFF_ALIGNMENT_FIELD_EMPTY, 0 },
1529 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1530 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1531 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 },
1532 /* Similarly for the .ctors and .dtors sections. */
1533 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1534 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 },
1535 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1536 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 }
1537};
1538
1539static const unsigned int coff_section_alignment_table_size =
1540 sizeof coff_section_alignment_table / sizeof coff_section_alignment_table[0];
1541
1542/* Initialize a section structure with information peculiar to this
1543 particular implementation of COFF. */
252b5132 1544
b34976b6 1545static bfd_boolean
252b5132 1546coff_new_section_hook (abfd, section)
60bcf0fa
NC		 1547 bfd * abfd;
1548 asection * section;
252b5132
RH		 1549{
1550 combined_entry_type *native;
dc810e39 1551 bfd_size_type amt;
252b5132
RH		 1552
1553 section->alignment_power = COFF_DEFAULT_SECTION_ALIGNMENT_POWER;
1554
1555#ifdef RS6000COFF_C
eb1e0e80 1556 if (bfd_xcoff_text_align_power (abfd) != 0
252b5132 1557 && strcmp (bfd_get_section_name (abfd, section), ".text") == 0)
eb1e0e80
NC		 1558 section->alignment_power = bfd_xcoff_text_align_power (abfd);
1559 if (bfd_xcoff_data_align_power (abfd) != 0
252b5132 1560 && strcmp (bfd_get_section_name (abfd, section), ".data") == 0)
eb1e0e80 1561 section->alignment_power = bfd_xcoff_data_align_power (abfd);
252b5132
RH		 1562#endif
1563
1564 /* Allocate aux records for section symbols, to store size and
1565 related info.
1566
1567 @@ The 10 is a guess at a plausible maximum number of aux entries
1568 (but shouldn't be a constant). */
dc810e39
AM		 1569 amt = sizeof (combined_entry_type) * 10;
1570 native = (combined_entry_type *) bfd_zalloc (abfd, amt);
252b5132 1571 if (native == NULL)
b34976b6 1572 return FALSE;
252b5132
RH		 1573
1574 /* We don't need to set up n_name, n_value, or n_scnum in the native
1575 symbol information, since they'll be overriden by the BFD symbol
1576 anyhow. However, we do need to set the type and storage class,
1577 in case this symbol winds up getting written out. The value 0
1578 for n_numaux is already correct. */
1579
1580 native->u.syment.n_type = T_NULL;
1581 native->u.syment.n_sclass = C_STAT;
1582
1583 coffsymbol (section->symbol)->native = native;
1584
5dccc1dd
ILT		 1585 coff_set_custom_section_alignment (abfd, section,
1586 coff_section_alignment_table,
1587 coff_section_alignment_table_size);
252b5132 1588
b34976b6 1589 return TRUE;
252b5132
RH		 1590}
1591
1592#ifdef COFF_ALIGN_IN_SECTION_HEADER
1593
1594/* Set the alignment of a BFD section. */
1595
1596static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1597
1598static void
1599coff_set_alignment_hook (abfd, section, scnhdr)
5f771d47 1600 bfd * abfd ATTRIBUTE_UNUSED;
252b5132
RH		 1601 asection * section;
1602 PTR scnhdr;
1603{
1604 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1605 unsigned int i;
1606
1607#ifdef I960
ed781d5d 1608 /* Extract ALIGN from 2**ALIGN stored in section header. */
252b5132
RH		 1609 for (i = 0; i < 32; i++)
1610 if ((1 << i) >= hdr->s_align)
1611 break;
1612#endif
1613#ifdef TIC80COFF
ed781d5d 1614 /* TI tools puts the alignment power in bits 8-11. */
252b5132 1615 i = (hdr->s_flags >> 8) & 0xF ;
81635ce4
TW		 1616#endif
1617#ifdef COFF_DECODE_ALIGNMENT
1618 i = COFF_DECODE_ALIGNMENT(hdr->s_flags);
252b5132
RH		 1619#endif
1620 section->alignment_power = i;
b9af77f5
TW		 1621
1622#ifdef coff_set_section_load_page
1623 coff_set_section_load_page (section, hdr->s_page);
1624#endif
252b5132
RH		 1625}
1626
1627#else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1628#ifdef COFF_WITH_PE
1629
ed781d5d 1630/* A couple of macros to help setting the alignment power field. */
252b5132
RH		 1631#define ALIGN_SET(field,x,y) \
1632 if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x )\
1633 {\
1634 section->alignment_power = y;\
1635 }
1636
1637#define ELIFALIGN_SET(field,x,y) \
1638 else if (( (field) & IMAGE_SCN_ALIGN_64BYTES) == x ) \
1639 {\
1640 section->alignment_power = y;\
1641 }
1642
1643static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1644
1645static void
1646coff_set_alignment_hook (abfd, section, scnhdr)
5f771d47 1647 bfd * abfd ATTRIBUTE_UNUSED;
252b5132
RH		 1648 asection * section;
1649 PTR scnhdr;
1650{
1651 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
dc810e39 1652 bfd_size_type amt;
252b5132
RH		 1653
1654 ALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_64BYTES, 6)
1655 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_32BYTES, 5)
1656 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_16BYTES, 4)
1657 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_8BYTES, 3)
1658 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_4BYTES, 2)
1659 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_2BYTES, 1)
1660 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_1BYTES, 0)
1661
252b5132 1662 /* In a PE image file, the s_paddr field holds the virtual size of a
8d3ad4e1
ILT		 1663 section, while the s_size field holds the raw size. We also keep
1664 the original section flag value, since not every bit can be
1665 mapped onto a generic BFD section bit. */
1666 if (coff_section_data (abfd, section) == NULL)
252b5132 1667 {
dc810e39
AM		 1668 amt = sizeof (struct coff_section_tdata);
1669 section->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
8d3ad4e1 1670 if (section->used_by_bfd == NULL)
252b5132 1671 {
8d3ad4e1
ILT		 1672 /* FIXME: Return error. */
1673 abort ();
252b5132 1674 }
8d3ad4e1
ILT		 1675 }
1676 if (pei_section_data (abfd, section) == NULL)
1677 {
dc810e39
AM		 1678 amt = sizeof (struct pei_section_tdata);
1679 coff_section_data (abfd, section)->tdata = (PTR) bfd_zalloc (abfd, amt);
8d3ad4e1 1680 if (coff_section_data (abfd, section)->tdata == NULL)
252b5132 1681 {
8d3ad4e1
ILT		 1682 /* FIXME: Return error. */
1683 abort ();
252b5132 1684 }
252b5132 1685 }
8d3ad4e1
ILT		 1686 pei_section_data (abfd, section)->virt_size = hdr->s_paddr;
1687 pei_section_data (abfd, section)->pe_flags = hdr->s_flags;
252b5132 1688
9d8cefa9 1689 section->lma = hdr->s_vaddr;
3e4554a2 1690
ed781d5d 1691 /* Check for extended relocs. */
3e4554a2
DD		 1692 if (hdr->s_flags & IMAGE_SCN_LNK_NRELOC_OVFL)
1693 {
1694 struct external_reloc dst;
1695 struct internal_reloc n;
dc810e39 1696 file_ptr oldpos = bfd_tell (abfd);
cd339148
NS		 1697 bfd_size_type relsz = bfd_coff_relsz (abfd);
1698
dc810e39 1699 bfd_seek (abfd, (file_ptr) hdr->s_relptr, 0);
cd339148 1700 if (bfd_bread ((PTR) &dst, relsz, abfd) != relsz)
3e4554a2 1701 return;
e60b52c6 1702
3e4554a2
DD		 1703 coff_swap_reloc_in (abfd, &dst, &n);
1704 bfd_seek (abfd, oldpos, 0);
cd339148
NS		 1705 section->reloc_count = hdr->s_nreloc = n.r_vaddr - 1;
1706 section->rel_filepos += relsz;
3e4554a2 1707 }
cd339148
NS		 1708 else if (hdr->s_nreloc == 0xffff)
1709 (*_bfd_error_handler)
1710 ("%s: warning: claims to have 0xffff relocs, without overflow",
1711 bfd_get_filename (abfd));
252b5132
RH		 1712}
1713#undef ALIGN_SET
1714#undef ELIFALIGN_SET
1715
1716#else /* ! COFF_WITH_PE */
1717#ifdef RS6000COFF_C
1718
1719/* We grossly abuse this function to handle XCOFF overflow headers.
1720 When we see one, we correct the reloc and line number counts in the
1721 real header, and remove the section we just created. */
1722
1723static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1724
1725static void
1726coff_set_alignment_hook (abfd, section, scnhdr)
1727 bfd *abfd;
1728 asection *section;
1729 PTR scnhdr;
1730{
1731 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1732 asection *real_sec;
1733 asection **ps;
1734
1735 if ((hdr->s_flags & STYP_OVRFLO) == 0)
1736 return;
1737
dc810e39 1738 real_sec = coff_section_from_bfd_index (abfd, (int) hdr->s_nreloc);
252b5132
RH		 1739 if (real_sec == NULL)
1740 return;
1741
1742 real_sec->reloc_count = hdr->s_paddr;
1743 real_sec->lineno_count = hdr->s_vaddr;
1744
1745 for (ps = &abfd->sections; *ps != NULL; ps = &(*ps)->next)
1746 {
1747 if (*ps == section)
1748 {
9e7b37b3 1749 bfd_section_list_remove (abfd, ps);
252b5132
RH		 1750 --abfd->section_count;
1751 break;
1752 }
1753 }
1754}
1755
1756#else /* ! RS6000COFF_C */
1757
1758#define coff_set_alignment_hook \
1759 ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
1760
1761#endif /* ! RS6000COFF_C */
1762#endif /* ! COFF_WITH_PE */
1763#endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1764
1765#ifndef coff_mkobject
1766
b34976b6 1767static bfd_boolean coff_mkobject PARAMS ((bfd *));
252b5132 1768
b34976b6 1769static bfd_boolean
252b5132
RH		 1770coff_mkobject (abfd)
1771 bfd * abfd;
1772{
1773 coff_data_type *coff;
dc810e39 1774 bfd_size_type amt = sizeof (coff_data_type);
252b5132 1775
dc810e39 1776 abfd->tdata.coff_obj_data = (struct coff_tdata *) bfd_zalloc (abfd, amt);
252b5132 1777 if (abfd->tdata.coff_obj_data == 0)
b34976b6 1778 return FALSE;
252b5132
RH		 1779 coff = coff_data (abfd);
1780 coff->symbols = (coff_symbol_type *) NULL;
1781 coff->conversion_table = (unsigned int *) NULL;
1782 coff->raw_syments = (struct coff_ptr_struct *) NULL;
1783 coff->relocbase = 0;
1784 coff->local_toc_sym_map = 0;
1785
1786/* make_abs_section(abfd);*/
1787
b34976b6 1788 return TRUE;
252b5132
RH		 1789}
1790#endif
1791
1792/* Create the COFF backend specific information. */
ed781d5d 1793
252b5132
RH		 1794#ifndef coff_mkobject_hook
1795static PTR
1796coff_mkobject_hook (abfd, filehdr, aouthdr)
1797 bfd * abfd;
1798 PTR filehdr;
5f771d47 1799 PTR aouthdr ATTRIBUTE_UNUSED;
252b5132
RH		 1800{
1801 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1802 coff_data_type *coff;
1803
82e51918 1804 if (! coff_mkobject (abfd))
252b5132
RH		 1805 return NULL;
1806
1807 coff = coff_data (abfd);
1808
1809 coff->sym_filepos = internal_f->f_symptr;
1810
1811 /* These members communicate important constants about the symbol
1812 table to GDB's symbol-reading code. These `constants'
1813 unfortunately vary among coff implementations... */
1814 coff->local_n_btmask = N_BTMASK;
1815 coff->local_n_btshft = N_BTSHFT;
1816 coff->local_n_tmask = N_TMASK;
1817 coff->local_n_tshift = N_TSHIFT;
6b3b007b
NC		 1818 coff->local_symesz = bfd_coff_symesz (abfd);
1819 coff->local_auxesz = bfd_coff_auxesz (abfd);
1820 coff->local_linesz = bfd_coff_linesz (abfd);
252b5132 1821
1135238b
ILT		 1822 coff->timestamp = internal_f->f_timdat;
1823
252b5132
RH		 1824 obj_raw_syment_count (abfd) =
1825 obj_conv_table_size (abfd) =
1826 internal_f->f_nsyms;
1827
1828#ifdef RS6000COFF_C
1829 if ((internal_f->f_flags & F_SHROBJ) != 0)
1830 abfd->flags |= DYNAMIC;
6b3b007b 1831 if (aouthdr != NULL && internal_f->f_opthdr >= bfd_coff_aoutsz (abfd))
252b5132
RH		 1832 {
1833 struct internal_aouthdr *internal_a =
1834 (struct internal_aouthdr *) aouthdr;
1835 struct xcoff_tdata *xcoff;
1836
1837 xcoff = xcoff_data (abfd);
a2fdf270
ND		 1838# ifdef U803XTOCMAGIC
1839 xcoff->xcoff64 = internal_f->f_magic == U803XTOCMAGIC;
1840# else
1841 xcoff->xcoff64 = 0;
1842# endif
b34976b6 1843 xcoff->full_aouthdr = TRUE;
252b5132
RH		 1844 xcoff->toc = internal_a->o_toc;
1845 xcoff->sntoc = internal_a->o_sntoc;
1846 xcoff->snentry = internal_a->o_snentry;
f3813499
TR		 1847 bfd_xcoff_text_align_power (abfd) = internal_a->o_algntext;
1848 bfd_xcoff_data_align_power (abfd) = internal_a->o_algndata;
252b5132
RH		 1849 xcoff->modtype = internal_a->o_modtype;
1850 xcoff->cputype = internal_a->o_cputype;
1851 xcoff->maxdata = internal_a->o_maxdata;
1852 xcoff->maxstack = internal_a->o_maxstack;
1853 }
1854#endif
1855
e60b52c6 1856#ifdef ARM
f13b834e 1857 /* Set the flags field from the COFF header read in. */
252b5132
RH		 1858 if (! _bfd_coff_arm_set_private_flags (abfd, internal_f->f_flags))
1859 coff->flags = 0;
1860#endif
e60b52c6 1861
4cfec37b
ILT		 1862#ifdef COFF_WITH_PE
1863 /* FIXME: I'm not sure this is ever executed, since peicode.h
1864 defines coff_mkobject_hook. */
1865 if ((internal_f->f_flags & IMAGE_FILE_DEBUG_STRIPPED) == 0)
1866 abfd->flags |= HAS_DEBUG;
1867#endif
1868
252b5132
RH		 1869 return (PTR) coff;
1870}
1871#endif
1872
1873/* Determine the machine architecture and type. FIXME: This is target
1874 dependent because the magic numbers are defined in the target
1875 dependent header files. But there is no particular need for this.
1876 If the magic numbers were moved to a separate file, this function
1877 would be target independent and would also be much more successful
1878 at linking together COFF files for different architectures. */
1879
b34976b6 1880static bfd_boolean
252b5132
RH		 1881coff_set_arch_mach_hook (abfd, filehdr)
1882 bfd *abfd;
1883 PTR filehdr;
1884{
dc810e39 1885 unsigned long machine;
252b5132
RH		 1886 enum bfd_architecture arch;
1887 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1888
250d94fd 1889 /* Zero selects the default machine for an arch. */
252b5132
RH		 1890 machine = 0;
1891 switch (internal_f->f_magic)
1892 {
3b16e843
NC		 1893#ifdef OR32_MAGIC_BIG
1894 case OR32_MAGIC_BIG:
1895 case OR32_MAGIC_LITTLE:
1896 arch = bfd_arch_or32;
3b16e843
NC		 1897 break;
1898#endif
252b5132
RH		 1899#ifdef PPCMAGIC
1900 case PPCMAGIC:
1901 arch = bfd_arch_powerpc;
e60b52c6 1902 break;
252b5132
RH		 1903#endif
1904#ifdef I386MAGIC
1905 case I386MAGIC:
1906 case I386PTXMAGIC:
1907 case I386AIXMAGIC: /* Danbury PS/2 AIX C Compiler */
1908 case LYNXCOFFMAGIC: /* shadows the m68k Lynx number below, sigh */
1909 arch = bfd_arch_i386;
252b5132
RH		 1910 break;
1911#endif
fac41780
JW		 1912#ifdef IA64MAGIC
1913 case IA64MAGIC:
1914 arch = bfd_arch_ia64;
fac41780
JW		 1915 break;
1916#endif
252b5132
RH		 1917#ifdef A29K_MAGIC_BIG
1918 case A29K_MAGIC_BIG:
1919 case A29K_MAGIC_LITTLE:
1920 arch = bfd_arch_a29k;
252b5132
RH		 1921 break;
1922#endif
1923#ifdef ARMMAGIC
1924 case ARMMAGIC:
17505c5c
NC		 1925 case ARMPEMAGIC:
1926 case THUMBPEMAGIC:
252b5132 1927 arch = bfd_arch_arm;
5a6c6817
NC		 1928 machine = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION);
1929 if (machine == bfd_mach_arm_unknown)
252b5132 1930 {
5a6c6817
NC		 1931 switch (internal_f->f_flags & F_ARM_ARCHITECTURE_MASK)
1932 {
1933 case F_ARM_2: machine = bfd_mach_arm_2; break;
1934 case F_ARM_2a: machine = bfd_mach_arm_2a; break;
1935 case F_ARM_3: machine = bfd_mach_arm_3; break;
1936 default:
1937 case F_ARM_3M: machine = bfd_mach_arm_3M; break;
1938 case F_ARM_4: machine = bfd_mach_arm_4; break;
1939 case F_ARM_4T: machine = bfd_mach_arm_4T; break;
1940 /* The COFF header does not have enough bits available
1941 to cover all the different ARM architectures. So
1942 we interpret F_ARM_5, the highest flag value to mean
1943 "the highest ARM architecture known to BFD" which is
1944 currently the XScale. */
1945 case F_ARM_5: machine = bfd_mach_arm_XScale; break;
1946 }
252b5132
RH		 1947 }
1948 break;
1949#endif
1950#ifdef MC68MAGIC
1951 case MC68MAGIC:
1952 case M68MAGIC:
1953#ifdef MC68KBCSMAGIC
1954 case MC68KBCSMAGIC:
1955#endif
1956#ifdef APOLLOM68KMAGIC
1957 case APOLLOM68KMAGIC:
1958#endif
1959#ifdef LYNXCOFFMAGIC
1960 case LYNXCOFFMAGIC:
1961#endif
1962 arch = bfd_arch_m68k;
1963 machine = bfd_mach_m68020;
1964 break;
1965#endif
1966#ifdef MC88MAGIC
1967 case MC88MAGIC:
1968 case MC88DMAGIC:
1969 case MC88OMAGIC:
1970 arch = bfd_arch_m88k;
1971 machine = 88100;
1972 break;
1973#endif
1974#ifdef Z8KMAGIC
1975 case Z8KMAGIC:
1976 arch = bfd_arch_z8k;
1977 switch (internal_f->f_flags & F_MACHMASK)
1978 {
1979 case F_Z8001:
1980 machine = bfd_mach_z8001;
1981 break;
1982 case F_Z8002:
1983 machine = bfd_mach_z8002;
1984 break;
1985 default:
b34976b6 1986 return FALSE;
252b5132
RH		 1987 }
1988 break;
1989#endif
1990#ifdef I860
1991 case I860MAGIC:
1992 arch = bfd_arch_i860;
1993 break;
1994#endif
1995#ifdef I960
1996#ifdef I960ROMAGIC
1997 case I960ROMAGIC:
1998 case I960RWMAGIC:
1999 arch = bfd_arch_i960;
2000 switch (F_I960TYPE & internal_f->f_flags)
2001 {
2002 default:
2003 case F_I960CORE:
2004 machine = bfd_mach_i960_core;
2005 break;
2006 case F_I960KB:
2007 machine = bfd_mach_i960_kb_sb;
2008 break;
2009 case F_I960MC:
2010 machine = bfd_mach_i960_mc;
2011 break;
2012 case F_I960XA:
2013 machine = bfd_mach_i960_xa;
2014 break;
2015 case F_I960CA:
2016 machine = bfd_mach_i960_ca;
2017 break;
2018 case F_I960KA:
2019 machine = bfd_mach_i960_ka_sa;
2020 break;
2021 case F_I960JX:
2022 machine = bfd_mach_i960_jx;
2023 break;
2024 case F_I960HX:
2025 machine = bfd_mach_i960_hx;
2026 break;
2027 }
2028 break;
2029#endif
2030#endif
2031
2032#ifdef RS6000COFF_C
7f6d05e8 2033#ifdef XCOFF64
eb1e0e80 2034 case U64_TOCMAGIC:
c6664dfb 2035 case U803XTOCMAGIC:
7f6d05e8 2036#else
252b5132
RH		 2037 case U802ROMAGIC:
2038 case U802WRMAGIC:
2039 case U802TOCMAGIC:
7f6d05e8 2040#endif
252b5132
RH		 2041 {
2042 int cputype;
2043
2044 if (xcoff_data (abfd)->cputype != -1)
2045 cputype = xcoff_data (abfd)->cputype & 0xff;
2046 else
2047 {
2048 /* We did not get a value from the a.out header. If the
2049 file has not been stripped, we may be able to get the
2050 architecture information from the first symbol, if it
2051 is a .file symbol. */
2052 if (obj_raw_syment_count (abfd) == 0)
2053 cputype = 0;
2054 else
2055 {
5ea1af0d 2056 bfd_byte *buf;
252b5132 2057 struct internal_syment sym;
dc810e39 2058 bfd_size_type amt = bfd_coff_symesz (abfd);
252b5132 2059
dc810e39 2060 buf = (bfd_byte *) bfd_malloc (amt);
252b5132 2061 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
dc810e39 2062 || bfd_bread (buf, amt, abfd) != amt)
5ea1af0d 2063 {
2fca4467 2064 free (buf);
b34976b6 2065 return FALSE;
5ea1af0d 2066 }
7f6d05e8 2067 bfd_coff_swap_sym_in (abfd, (PTR) buf, (PTR) &sym);
252b5132
RH		 2068 if (sym.n_sclass == C_FILE)
2069 cputype = sym.n_type & 0xff;
2070 else
2071 cputype = 0;
2fca4467 2072 free (buf);
252b5132
RH		 2073 }
2074 }
2075
2076 /* FIXME: We don't handle all cases here. */
2077 switch (cputype)
2078 {
2079 default:
2080 case 0:
beb1bf64
TR		 2081 arch = bfd_xcoff_architecture (abfd);
2082 machine = bfd_xcoff_machine (abfd);
252b5132
RH		 2083 break;
2084
2085 case 1:
2086 arch = bfd_arch_powerpc;
87f33987 2087 machine = bfd_mach_ppc_601;
252b5132
RH		 2088 break;
2089 case 2: /* 64 bit PowerPC */
2090 arch = bfd_arch_powerpc;
87f33987 2091 machine = bfd_mach_ppc_620;
252b5132
RH		 2092 break;
2093 case 3:
2094 arch = bfd_arch_powerpc;
87f33987 2095 machine = bfd_mach_ppc;
252b5132
RH		 2096 break;
2097 case 4:
2098 arch = bfd_arch_rs6000;
87f33987 2099 machine = bfd_mach_rs6k;
252b5132
RH		 2100 break;
2101 }
2102 }
2103 break;
2104#endif
2105
2106#ifdef WE32KMAGIC
2107 case WE32KMAGIC:
2108 arch = bfd_arch_we32k;
252b5132
RH		 2109 break;
2110#endif
2111
2112#ifdef H8300MAGIC
2113 case H8300MAGIC:
2114 arch = bfd_arch_h8300;
2115 machine = bfd_mach_h8300;
8d9cd6b1 2116 /* !! FIXME this probably isn't the right place for this. */
252b5132
RH		 2117 abfd->flags |= BFD_IS_RELAXABLE;
2118 break;
2119#endif
2120
2121#ifdef H8300HMAGIC
2122 case H8300HMAGIC:
2123 arch = bfd_arch_h8300;
2124 machine = bfd_mach_h8300h;
8d9cd6b1 2125 /* !! FIXME this probably isn't the right place for this. */
252b5132
RH		 2126 abfd->flags |= BFD_IS_RELAXABLE;
2127 break;
2128#endif
2129
2130#ifdef H8300SMAGIC
2131 case H8300SMAGIC:
2132 arch = bfd_arch_h8300;
2133 machine = bfd_mach_h8300s;
8d9cd6b1
NC		 2134 /* !! FIXME this probably isn't the right place for this. */
2135 abfd->flags |= BFD_IS_RELAXABLE;
2136 break;
2137#endif
2138
2139#ifdef H8300HNMAGIC
2140 case H8300HNMAGIC:
2141 arch = bfd_arch_h8300;
2142 machine = bfd_mach_h8300hn;
2143 /* !! FIXME this probably isn't the right place for this. */
2144 abfd->flags |= BFD_IS_RELAXABLE;
2145 break;
2146#endif
2147
2148#ifdef H8300SNMAGIC
2149 case H8300SNMAGIC:
2150 arch = bfd_arch_h8300;
2151 machine = bfd_mach_h8300sn;
2152 /* !! FIXME this probably isn't the right place for this. */
252b5132
RH		 2153 abfd->flags |= BFD_IS_RELAXABLE;
2154 break;
2155#endif
2156
2157#ifdef SH_ARCH_MAGIC_BIG
2158 case SH_ARCH_MAGIC_BIG:
2159 case SH_ARCH_MAGIC_LITTLE:
17505c5c
NC		 2160#ifdef COFF_WITH_PE
2161 case SH_ARCH_MAGIC_WINCE:
2162#endif
252b5132 2163 arch = bfd_arch_sh;
252b5132
RH		 2164 break;
2165#endif
2166
17505c5c
NC		 2167#ifdef MIPS_ARCH_MAGIC_WINCE
2168 case MIPS_ARCH_MAGIC_WINCE:
2169 arch = bfd_arch_mips;
17505c5c
NC		 2170 break;
2171#endif
2172
252b5132
RH		 2173#ifdef H8500MAGIC
2174 case H8500MAGIC:
2175 arch = bfd_arch_h8500;
252b5132
RH		 2176 break;
2177#endif
2178
2179#ifdef SPARCMAGIC
2180 case SPARCMAGIC:
2181#ifdef LYNXCOFFMAGIC
2182 case LYNXCOFFMAGIC:
2183#endif
2184 arch = bfd_arch_sparc;
252b5132
RH		 2185 break;
2186#endif
2187
2188#ifdef TIC30MAGIC
2189 case TIC30MAGIC:
2190 arch = bfd_arch_tic30;
2191 break;
2192#endif
2193
81635ce4
TW		 2194#ifdef TICOFF0MAGIC
2195#ifdef TICOFF_TARGET_ARCH
ed781d5d 2196 /* This TI COFF section should be used by all new TI COFF v0 targets. */
81635ce4
TW		 2197 case TICOFF0MAGIC:
2198 arch = TICOFF_TARGET_ARCH;
0da35f8b 2199 machine = TICOFF_TARGET_MACHINE_GET (internal_f->f_flags);
81635ce4
TW		 2200 break;
2201#endif
2202#endif
2203
2204#ifdef TICOFF1MAGIC
ed781d5d
NC		 2205 /* This TI COFF section should be used by all new TI COFF v1/2 targets. */
2206 /* TI COFF1 and COFF2 use the target_id field to specify which arch. */
81635ce4
TW		 2207 case TICOFF1MAGIC:
2208 case TICOFF2MAGIC:
2209 switch (internal_f->f_target_id)
2210 {
2211#ifdef TI_TARGET_ID
2212 case TI_TARGET_ID:
2213 arch = TICOFF_TARGET_ARCH;
0da35f8b 2214 machine = TICOFF_TARGET_MACHINE_GET (internal_f->f_flags);
81635ce4
TW		 2215 break;
2216#endif
2217 default:
4af1d5f6 2218 arch = bfd_arch_obscure;
81635ce4 2219 (*_bfd_error_handler)
e60b52c6 2220 (_("Unrecognized TI COFF target id '0x%x'"),
81635ce4
TW		 2221 internal_f->f_target_id);
2222 break;
2223 }
2224 break;
2225#endif
2226
252b5132
RH		 2227#ifdef TIC80_ARCH_MAGIC
2228 case TIC80_ARCH_MAGIC:
2229 arch = bfd_arch_tic80;
2230 break;
2231#endif
2232
2233#ifdef MCOREMAGIC
2234 case MCOREMAGIC:
2235 arch = bfd_arch_mcore;
2236 break;
2237#endif
c8e48751
AM		 2238
2239#ifdef W65MAGIC
2240 case W65MAGIC:
2241 arch = bfd_arch_w65;
2242 break;
2243#endif
2244
ed781d5d 2245 default: /* Unreadable input file type. */
252b5132
RH		 2246 arch = bfd_arch_obscure;
2247 break;
2248 }
2249
2250 bfd_default_set_arch_mach (abfd, arch, machine);
b34976b6 2251 return TRUE;
252b5132
RH		 2252}
2253
2254#ifdef SYMNAME_IN_DEBUG
2255
b34976b6 2256static bfd_boolean symname_in_debug_hook
252b5132
RH		 2257 PARAMS ((bfd *, struct internal_syment *));
2258
b34976b6 2259static bfd_boolean
252b5132 2260symname_in_debug_hook (abfd, sym)
5f771d47 2261 bfd * abfd ATTRIBUTE_UNUSED;
252b5132
RH		 2262 struct internal_syment *sym;
2263{
82e51918 2264 return SYMNAME_IN_DEBUG (sym) != 0;
252b5132
RH		 2265}
2266
2267#else
2268
2269#define symname_in_debug_hook \
b34976b6 2270 (bfd_boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
252b5132
RH		 2271
2272#endif
2273
2274#ifdef RS6000COFF_C
2275
7f6d05e8
CP		 2276#ifdef XCOFF64
2277#define FORCE_SYMNAMES_IN_STRINGS
2278#endif
a022216b 2279
252b5132
RH		 2280/* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */
2281
b34976b6 2282static bfd_boolean coff_pointerize_aux_hook
252b5132
RH		 2283 PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
2284 unsigned int, combined_entry_type *));
2285
b34976b6 2286static bfd_boolean
252b5132 2287coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux)
5f771d47 2288 bfd *abfd ATTRIBUTE_UNUSED;
252b5132
RH		 2289 combined_entry_type *table_base;
2290 combined_entry_type *symbol;
2291 unsigned int indaux;
2292 combined_entry_type *aux;
2293{
2294 int class = symbol->u.syment.n_sclass;
2295
2296 if ((class == C_EXT || class == C_HIDEXT)
2297 && indaux + 1 == symbol->u.syment.n_numaux)
2298 {
2299 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD)
2300 {
2301 aux->u.auxent.x_csect.x_scnlen.p =
2302 table_base + aux->u.auxent.x_csect.x_scnlen.l;
2303 aux->fix_scnlen = 1;
2304 }
2305
b34976b6 2306 /* Return TRUE to indicate that the caller should not do any
252b5132 2307 further work on this auxent. */
b34976b6 2308 return TRUE;
252b5132
RH		 2309 }
2310
b34976b6 2311 /* Return FALSE to indicate that this auxent should be handled by
252b5132 2312 the caller. */
b34976b6 2313 return FALSE;
252b5132
RH		 2314}
2315
2316#else
2317#ifdef I960
2318
2319/* We don't want to pointerize bal entries. */
2320
b34976b6 2321static bfd_boolean coff_pointerize_aux_hook
252b5132
RH		 2322 PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
2323 unsigned int, combined_entry_type *));
2324
b34976b6 2325static bfd_boolean
252b5132 2326coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux)
5f771d47
ILT		 2327 bfd *abfd ATTRIBUTE_UNUSED;
2328 combined_entry_type *table_base ATTRIBUTE_UNUSED;
252b5132
RH		 2329 combined_entry_type *symbol;
2330 unsigned int indaux;
5f771d47 2331 combined_entry_type *aux ATTRIBUTE_UNUSED;
252b5132 2332{
b34976b6 2333 /* Return TRUE if we don't want to pointerize this aux entry, which
252b5132
RH		 2334 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
2335 return (indaux == 1
2336 && (symbol->u.syment.n_sclass == C_LEAFPROC
2337 || symbol->u.syment.n_sclass == C_LEAFSTAT
2338 || symbol->u.syment.n_sclass == C_LEAFEXT));
2339}
2340
2341#else /* ! I960 */
2342
2343#define coff_pointerize_aux_hook 0
2344
2345#endif /* ! I960 */
2346#endif /* ! RS6000COFF_C */
2347
b34976b6 2348/* Print an aux entry. This returns TRUE if it has printed it. */
252b5132 2349
b34976b6 2350static bfd_boolean coff_print_aux
252b5132
RH		 2351 PARAMS ((bfd *, FILE *, combined_entry_type *, combined_entry_type *,
2352 combined_entry_type *, unsigned int));
2353
b34976b6 2354static bfd_boolean
252b5132 2355coff_print_aux (abfd, file, table_base, symbol, aux, indaux)
5f771d47
ILT		 2356 bfd *abfd ATTRIBUTE_UNUSED;
2357 FILE *file ATTRIBUTE_UNUSED;
2358 combined_entry_type *table_base ATTRIBUTE_UNUSED;
2359 combined_entry_type *symbol ATTRIBUTE_UNUSED;
2360 combined_entry_type *aux ATTRIBUTE_UNUSED;
2361 unsigned int indaux ATTRIBUTE_UNUSED;
252b5132
RH		 2362{
2363#ifdef RS6000COFF_C
2364 if ((symbol->u.syment.n_sclass == C_EXT
2365 || symbol->u.syment.n_sclass == C_HIDEXT)
2366 && indaux + 1 == symbol->u.syment.n_numaux)
2367 {
2368 /* This is a csect entry. */
2369 fprintf (file, "AUX ");
2370 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) != XTY_LD)
2371 {
2372 BFD_ASSERT (! aux->fix_scnlen);
dc810e39 2373#ifdef XCOFF64
beb1bf64
TR		 2374 fprintf (file, "val %5lld", aux->u.auxent.x_csect.x_scnlen.l);
2375#else
2376 fprintf (file, "val %5ld", (long) aux->u.auxent.x_csect.x_scnlen.l);
2377#endif
252b5132
RH		 2378 }
2379 else
2380 {
2381 fprintf (file, "indx ");
2382 if (! aux->fix_scnlen)
beb1bf64
TR		 2383#ifdef XCOFF64
2384 fprintf (file, "%4lld", aux->u.auxent.x_csect.x_scnlen.l);
2385#else
2386 fprintf (file, "%4ld", (long) aux->u.auxent.x_csect.x_scnlen.l);
2387#endif
252b5132
RH		 2388 else
2389 fprintf (file, "%4ld",
2390 (long) (aux->u.auxent.x_csect.x_scnlen.p - table_base));
2391 }
2392 fprintf (file,
2393 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2394 aux->u.auxent.x_csect.x_parmhash,
2395 (unsigned int) aux->u.auxent.x_csect.x_snhash,
2396 SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp),
2397 SMTYP_ALIGN (aux->u.auxent.x_csect.x_smtyp),
2398 (unsigned int) aux->u.auxent.x_csect.x_smclas,
2399 aux->u.auxent.x_csect.x_stab,
2400 (unsigned int) aux->u.auxent.x_csect.x_snstab);
b34976b6 2401 return TRUE;
252b5132
RH		 2402 }
2403#endif
2404
b34976b6
AM		 2405 /* Return FALSE to indicate that no special action was taken. */
2406 return FALSE;
252b5132
RH		 2407}
2408
2409/*
2410SUBSUBSECTION
2411 Writing relocations
2412
2413 To write relocations, the back end steps though the
2414 canonical relocation table and create an
2415 @code{internal_reloc}. The symbol index to use is removed from
2416 the @code{offset} field in the symbol table supplied. The
2417 address comes directly from the sum of the section base
2418 address and the relocation offset; the type is dug directly
2419 from the howto field. Then the @code{internal_reloc} is
2420 swapped into the shape of an @code{external_reloc} and written
2421 out to disk.
2422
2423*/
2424
2425#ifdef TARG_AUX
2426
2427static int compare_arelent_ptr PARAMS ((const PTR, const PTR));
2428
ed781d5d 2429/* AUX's ld wants relocations to be sorted. */
252b5132
RH		 2430static int
2431compare_arelent_ptr (x, y)
2432 const PTR x;
2433 const PTR y;
2434{
2435 const arelent **a = (const arelent **) x;
2436 const arelent **b = (const arelent **) y;
2437 bfd_size_type aadr = (*a)->address;
2438 bfd_size_type badr = (*b)->address;
2439
2440 return (aadr < badr ? -1 : badr < aadr ? 1 : 0);
2441}
2442
2443#endif /* TARG_AUX */
2444
b34976b6 2445static bfd_boolean
252b5132
RH		 2446coff_write_relocs (abfd, first_undef)
2447 bfd * abfd;
2448 int first_undef;
2449{
2450 asection *s;
2451
2452 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
2453 {
2454 unsigned int i;
2455 struct external_reloc dst;
2456 arelent **p;
2457
2458#ifndef TARG_AUX
2459 p = s->orelocation;
2460#else
dc810e39 2461 {
ed781d5d 2462 /* Sort relocations before we write them out. */
dc810e39
AM		 2463 bfd_size_type amt;
2464
2465 amt = s->reloc_count;
2466 amt *= sizeof (arelent *);
2467 p = (arelent **) bfd_malloc (amt);
2468 if (p == NULL && s->reloc_count > 0)
b34976b6 2469 return FALSE;
dc810e39
AM		 2470 memcpy (p, s->orelocation, (size_t) amt);
2471 qsort (p, s->reloc_count, sizeof (arelent *), compare_arelent_ptr);
2472 }
252b5132
RH		 2473#endif
2474
2475 if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0)
b34976b6 2476 return FALSE;
3e4554a2
DD		 2477
2478#ifdef COFF_WITH_PE
e9168c1e 2479 if (obj_pe (abfd) && s->reloc_count >= 0xffff)
3e4554a2 2480 {
ed781d5d 2481 /* Encode real count here as first reloc. */
3e4554a2 2482 struct internal_reloc n;
ed781d5d 2483
3e4554a2 2484 memset ((PTR) & n, 0, sizeof (n));
ed781d5d 2485 /* Add one to count *this* reloc (grr). */
3e4554a2
DD		 2486 n.r_vaddr = s->reloc_count + 1;
2487 coff_swap_reloc_out (abfd, &n, &dst);
dc810e39
AM		 2488 if (bfd_bwrite ((PTR) & dst, (bfd_size_type) bfd_coff_relsz (abfd),
2489 abfd) != bfd_coff_relsz (abfd))
b34976b6 2490 return FALSE;
3e4554a2
DD		 2491 }
2492#endif
2493
252b5132
RH		 2494 for (i = 0; i < s->reloc_count; i++)
2495 {
2496 struct internal_reloc n;
2497 arelent *q = p[i];
ed781d5d 2498
252b5132
RH		 2499 memset ((PTR) & n, 0, sizeof (n));
2500
2501 /* Now we've renumbered the symbols we know where the
2502 undefined symbols live in the table. Check the reloc
2503 entries for symbols who's output bfd isn't the right one.
2504 This is because the symbol was undefined (which means
2505 that all the pointers are never made to point to the same
2506 place). This is a bad thing,'cause the symbols attached
2507 to the output bfd are indexed, so that the relocation
2508 entries know which symbol index they point to. So we
e60b52c6 2509 have to look up the output symbol here. */
252b5132
RH		 2510
2511 if (q->sym_ptr_ptr[0]->the_bfd != abfd)
2512 {
dc810e39 2513 int j;
252b5132
RH		 2514 const char *sname = q->sym_ptr_ptr[0]->name;
2515 asymbol **outsyms = abfd->outsymbols;
ed781d5d 2516
dc810e39 2517 for (j = first_undef; outsyms[j]; j++)
252b5132 2518 {
dc810e39 2519 const char *intable = outsyms[j]->name;
ed781d5d 2520
252b5132 2521 if (strcmp (intable, sname) == 0) {
ed781d5d 2522 /* Got a hit, so repoint the reloc. */
dc810e39 2523 q->sym_ptr_ptr = outsyms + j;
252b5132
RH		 2524 break;
2525 }
2526 }
2527 }
2528
2529 n.r_vaddr = q->address + s->vma;
2530
2531#ifdef R_IHCONST
2532 /* The 29k const/consth reloc pair is a real kludge. The consth
2533 part doesn't have a symbol; it has an offset. So rebuilt
2534 that here. */
2535 if (q->howto->type == R_IHCONST)
2536 n.r_symndx = q->addend;
2537 else
2538#endif
2539 if (q->sym_ptr_ptr)
2540 {
6c784c9a
TW		 2541#ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2542 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q,s))
2543#else
250d94fd
AM		 2544 if ((*q->sym_ptr_ptr)->section == bfd_abs_section_ptr
2545 && ((*q->sym_ptr_ptr)->flags & BSF_SECTION_SYM) != 0)
6c784c9a 2546#endif
252b5132
RH		 2547 /* This is a relocation relative to the absolute symbol. */
2548 n.r_symndx = -1;
2549 else
2550 {
2551 n.r_symndx = get_index ((*(q->sym_ptr_ptr)));
2552 /* Take notice if the symbol reloc points to a symbol
2553 we don't have in our symbol table. What should we
2554 do for this?? */
2555 if (n.r_symndx > obj_conv_table_size (abfd))
2556 abort ();
2557 }
2558 }
2559
2560#ifdef SWAP_OUT_RELOC_OFFSET
2561 n.r_offset = q->addend;
2562#endif
2563
2564#ifdef SELECT_RELOC
ed781d5d 2565 /* Work out reloc type from what is required. */
252b5132
RH		 2566 SELECT_RELOC (n, q->howto);
2567#else
2568 n.r_type = q->howto->type;
2569#endif
2570 coff_swap_reloc_out (abfd, &n, &dst);
ed781d5d 2571
dc810e39
AM		 2572 if (bfd_bwrite ((PTR) & dst, (bfd_size_type) bfd_coff_relsz (abfd),
2573 abfd) != bfd_coff_relsz (abfd))
b34976b6 2574 return FALSE;
252b5132
RH		 2575 }
2576
2577#ifdef TARG_AUX
2578 if (p != NULL)
2579 free (p);
2580#endif
2581 }
2582
b34976b6 2583 return TRUE;
252b5132
RH		 2584}
2585
2586/* Set flags and magic number of a coff file from architecture and machine
b34976b6 2587 type. Result is TRUE if we can represent the arch&type, FALSE if not. */
252b5132 2588
b34976b6 2589static bfd_boolean
252b5132
RH		 2590coff_set_flags (abfd, magicp, flagsp)
2591 bfd * abfd;
5f771d47
ILT		 2592 unsigned int *magicp ATTRIBUTE_UNUSED;
2593 unsigned short *flagsp ATTRIBUTE_UNUSED;
252b5132
RH		 2594{
2595 switch (bfd_get_arch (abfd))
2596 {
2597#ifdef Z8KMAGIC
2598 case bfd_arch_z8k:
2599 *magicp = Z8KMAGIC;
2600 switch (bfd_get_mach (abfd))
2601 {
2602 case bfd_mach_z8001:
2603 *flagsp = F_Z8001;
2604 break;
2605 case bfd_mach_z8002:
2606 *flagsp = F_Z8002;
2607 break;
2608 default:
b34976b6 2609 return FALSE;
252b5132 2610 }
b34976b6 2611 return TRUE;
252b5132
RH		 2612#endif
2613#ifdef I960ROMAGIC
2614
2615 case bfd_arch_i960:
2616
2617 {
2618 unsigned flags;
2619 *magicp = I960ROMAGIC;
2620 /*
2621 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
2622 I960RWMAGIC); FIXME???
2623 */
2624 switch (bfd_get_mach (abfd))
2625 {
2626 case bfd_mach_i960_core:
2627 flags = F_I960CORE;
2628 break;
2629 case bfd_mach_i960_kb_sb:
2630 flags = F_I960KB;
2631 break;
2632 case bfd_mach_i960_mc:
2633 flags = F_I960MC;
2634 break;
2635 case bfd_mach_i960_xa:
2636 flags = F_I960XA;
2637 break;
2638 case bfd_mach_i960_ca:
2639 flags = F_I960CA;
2640 break;
2641 case bfd_mach_i960_ka_sa:
2642 flags = F_I960KA;
2643 break;
2644 case bfd_mach_i960_jx:
2645 flags = F_I960JX;
2646 break;
2647 case bfd_mach_i960_hx:
2648 flags = F_I960HX;
2649 break;
2650 default:
b34976b6 2651 return FALSE;
252b5132
RH		 2652 }
2653 *flagsp = flags;
b34976b6 2654 return TRUE;
252b5132
RH		 2655 }
2656 break;
2657#endif
2658
2659#ifdef TIC30MAGIC
2660 case bfd_arch_tic30:
2661 *magicp = TIC30MAGIC;
b34976b6 2662 return TRUE;
252b5132 2663#endif
81635ce4
TW		 2664
2665#ifdef TICOFF_DEFAULT_MAGIC
2666 case TICOFF_TARGET_ARCH:
ed781d5d 2667 /* If there's no indication of which version we want, use the default. */
81635ce4
TW		 2668 if (!abfd->xvec )
2669 *magicp = TICOFF_DEFAULT_MAGIC;
2670 else
2671 {
ed781d5d 2672 /* We may want to output in a different COFF version. */
81635ce4
TW		 2673 switch (abfd->xvec->name[4])
2674 {
2675 case '0':
2676 *magicp = TICOFF0MAGIC;
2677 break;
2678 case '1':
2679 *magicp = TICOFF1MAGIC;
2680 break;
2681 case '2':
2682 *magicp = TICOFF2MAGIC;
2683 break;
2684 default:
b34976b6 2685 return FALSE;
81635ce4
TW		 2686 }
2687 }
0da35f8b 2688 TICOFF_TARGET_MACHINE_SET (flagsp, bfd_get_mach (abfd));
b34976b6 2689 return TRUE;
81635ce4
TW		 2690#endif
2691
252b5132
RH		 2692#ifdef TIC80_ARCH_MAGIC
2693 case bfd_arch_tic80:
2694 *magicp = TIC80_ARCH_MAGIC;
b34976b6 2695 return TRUE;
252b5132
RH		 2696#endif
2697#ifdef ARMMAGIC
2698 case bfd_arch_arm:
17505c5c
NC		 2699#ifdef ARM_WINCE
2700 * magicp = ARMPEMAGIC;
2701#else
252b5132 2702 * magicp = ARMMAGIC;
17505c5c 2703#endif
252b5132
RH		 2704 * flagsp = 0;
2705 if (APCS_SET (abfd))
2706 {
2707 if (APCS_26_FLAG (abfd))
2708 * flagsp |= F_APCS26;
e60b52c6 2709
252b5132
RH		 2710 if (APCS_FLOAT_FLAG (abfd))
2711 * flagsp |= F_APCS_FLOAT;
e60b52c6 2712
252b5132 2713 if (PIC_FLAG (abfd))
948221a8 2714 * flagsp |= F_PIC;
252b5132
RH		 2715 }
2716 if (INTERWORK_SET (abfd) && INTERWORK_FLAG (abfd))
2717 * flagsp |= F_INTERWORK;
2718 switch (bfd_get_mach (abfd))
2719 {
2720 case bfd_mach_arm_2: * flagsp |= F_ARM_2; break;
2721 case bfd_mach_arm_2a: * flagsp |= F_ARM_2a; break;
2722 case bfd_mach_arm_3: * flagsp |= F_ARM_3; break;
2723 case bfd_mach_arm_3M: * flagsp |= F_ARM_3M; break;
2724 case bfd_mach_arm_4: * flagsp |= F_ARM_4; break;
2725 case bfd_mach_arm_4T: * flagsp |= F_ARM_4T; break;
478d07d6 2726 case bfd_mach_arm_5: * flagsp |= F_ARM_5; break;
f13b834e
NC		 2727 /* FIXME: we do not have F_ARM vaues greater than F_ARM_5.
2728 See also the comment in coff_set_arch_mach_hook(). */
077b8428
NC		 2729 case bfd_mach_arm_5T: * flagsp |= F_ARM_5; break;
2730 case bfd_mach_arm_5TE: * flagsp |= F_ARM_5; break;
2731 case bfd_mach_arm_XScale: * flagsp |= F_ARM_5; break;
252b5132 2732 }
b34976b6 2733 return TRUE;
252b5132
RH		 2734#endif
2735#ifdef PPCMAGIC
2736 case bfd_arch_powerpc:
2737 *magicp = PPCMAGIC;
b34976b6 2738 return TRUE;
252b5132
RH		 2739 break;
2740#endif
2741#ifdef I386MAGIC
2742 case bfd_arch_i386:
2743 *magicp = I386MAGIC;
2744#ifdef LYNXOS
e60b52c6 2745 /* Just overwrite the usual value if we're doing Lynx. */
252b5132
RH		 2746 *magicp = LYNXCOFFMAGIC;
2747#endif
b34976b6 2748 return TRUE;
252b5132
RH		 2749 break;
2750#endif
2751#ifdef I860MAGIC
2752 case bfd_arch_i860:
2753 *magicp = I860MAGIC;
b34976b6 2754 return TRUE;
252b5132
RH		 2755 break;
2756#endif
fac41780
JW		 2757#ifdef IA64MAGIC
2758 case bfd_arch_ia64:
2759 *magicp = IA64MAGIC;
b34976b6 2760 return TRUE;
fac41780
JW		 2761 break;
2762#endif
252b5132
RH		 2763#ifdef MC68MAGIC
2764 case bfd_arch_m68k:
2765#ifdef APOLLOM68KMAGIC
2766 *magicp = APOLLO_COFF_VERSION_NUMBER;
2767#else
2768 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2769#ifdef NAMES_HAVE_UNDERSCORE
2770 *magicp = MC68KBCSMAGIC;
2771#else
2772 *magicp = MC68MAGIC;
2773#endif
2774#endif
2775#ifdef LYNXOS
e60b52c6 2776 /* Just overwrite the usual value if we're doing Lynx. */
252b5132
RH		 2777 *magicp = LYNXCOFFMAGIC;
2778#endif
b34976b6 2779 return TRUE;
252b5132
RH		 2780 break;
2781#endif
2782
2783#ifdef MC88MAGIC
2784 case bfd_arch_m88k:
2785 *magicp = MC88OMAGIC;
b34976b6 2786 return TRUE;
252b5132
RH		 2787 break;
2788#endif
2789#ifdef H8300MAGIC
2790 case bfd_arch_h8300:
2791 switch (bfd_get_mach (abfd))
2792 {
2793 case bfd_mach_h8300:
2794 *magicp = H8300MAGIC;
b34976b6 2795 return TRUE;
252b5132
RH		 2796 case bfd_mach_h8300h:
2797 *magicp = H8300HMAGIC;
b34976b6 2798 return TRUE;
252b5132
RH		 2799 case bfd_mach_h8300s:
2800 *magicp = H8300SMAGIC;
b34976b6 2801 return TRUE;
8d9cd6b1
NC		 2802 case bfd_mach_h8300hn:
2803 *magicp = H8300HNMAGIC;
2804 return TRUE;
2805 case bfd_mach_h8300sn:
2806 *magicp = H8300SNMAGIC;
2807 return TRUE;
252b5132
RH		 2808 }
2809 break;
2810#endif
2811
2812#ifdef SH_ARCH_MAGIC_BIG
2813 case bfd_arch_sh:
17505c5c
NC		 2814#ifdef COFF_IMAGE_WITH_PE
2815 *magicp = SH_ARCH_MAGIC_WINCE;
2816#else
252b5132
RH		 2817 if (bfd_big_endian (abfd))
2818 *magicp = SH_ARCH_MAGIC_BIG;
2819 else
2820 *magicp = SH_ARCH_MAGIC_LITTLE;
17505c5c 2821#endif
b34976b6 2822 return TRUE;
17505c5c
NC		 2823 break;
2824#endif
2825
2826#ifdef MIPS_ARCH_MAGIC_WINCE
2827 case bfd_arch_mips:
2828 *magicp = MIPS_ARCH_MAGIC_WINCE;
b34976b6 2829 return TRUE;
252b5132
RH		 2830 break;
2831#endif
2832
2833#ifdef SPARCMAGIC
2834 case bfd_arch_sparc:
2835 *magicp = SPARCMAGIC;
2836#ifdef LYNXOS
e60b52c6 2837 /* Just overwrite the usual value if we're doing Lynx. */
252b5132
RH		 2838 *magicp = LYNXCOFFMAGIC;
2839#endif
b34976b6 2840 return TRUE;
252b5132
RH		 2841 break;
2842#endif
2843
2844#ifdef H8500MAGIC
2845 case bfd_arch_h8500:
2846 *magicp = H8500MAGIC;
b34976b6 2847 return TRUE;
252b5132
RH		 2848 break;
2849#endif
2850#ifdef A29K_MAGIC_BIG
2851 case bfd_arch_a29k:
2852 if (bfd_big_endian (abfd))
2853 *magicp = A29K_MAGIC_BIG;
2854 else
2855 *magicp = A29K_MAGIC_LITTLE;
b34976b6 2856 return TRUE;
252b5132
RH		 2857 break;
2858#endif
2859
2860#ifdef WE32KMAGIC
2861 case bfd_arch_we32k:
2862 *magicp = WE32KMAGIC;
b34976b6 2863 return TRUE;
252b5132
RH		 2864 break;
2865#endif
2866
7f6d05e8 2867#ifdef RS6000COFF_C
252b5132
RH		 2868 case bfd_arch_rs6000:
2869#ifndef PPCMAGIC
2870 case bfd_arch_powerpc:
2871#endif
eb1e0e80
NC		 2872 BFD_ASSERT (bfd_get_flavour (abfd) == bfd_target_xcoff_flavour);
2873 *magicp = bfd_xcoff_magic_number (abfd);
b34976b6 2874 return TRUE;
252b5132
RH		 2875 break;
2876#endif
2877
2878#ifdef MCOREMAGIC
2879 case bfd_arch_mcore:
2880 * magicp = MCOREMAGIC;
b34976b6 2881 return TRUE;
252b5132 2882#endif
e60b52c6 2883
371e71b8
NC		 2884#ifdef W65MAGIC
2885 case bfd_arch_w65:
2886 *magicp = W65MAGIC;
b34976b6 2887 return TRUE;
371e71b8
NC		 2888#endif
2889
3b16e843
NC		 2890#ifdef OR32_MAGIC_BIG
2891 case bfd_arch_or32:
2892 if (bfd_big_endian (abfd))
2893 * magicp = OR32_MAGIC_BIG;
2894 else
2895 * magicp = OR32_MAGIC_LITTLE;
b34976b6 2896 return TRUE;
3b16e843
NC		 2897#endif
2898
371e71b8 2899 default: /* Unknown architecture. */
b34976b6 2900 /* Fall through to "return FALSE" below, to avoid
371e71b8 2901 "statement never reached" errors on the one below. */
252b5132
RH		 2902 break;
2903 }
2904
b34976b6 2905 return FALSE;
252b5132
RH		 2906}
2907
b34976b6 2908static bfd_boolean
252b5132
RH		 2909coff_set_arch_mach (abfd, arch, machine)
2910 bfd * abfd;
2911 enum bfd_architecture arch;
2912 unsigned long machine;
2913{
2914 unsigned dummy1;
2915 unsigned short dummy2;
2916
2917 if (! bfd_default_set_arch_mach (abfd, arch, machine))
b34976b6 2918 return FALSE;
252b5132 2919
82e51918
AM		 2920 if (arch != bfd_arch_unknown
2921 && ! coff_set_flags (abfd, &dummy1, &dummy2))
b34976b6 2922 return FALSE; /* We can't represent this type */
252b5132 2923
b34976b6 2924 return TRUE; /* We're easy ... */
252b5132
RH		 2925}
2926
75cc7189
ILT		 2927#ifdef COFF_IMAGE_WITH_PE
2928
2929/* This is used to sort sections by VMA, as required by PE image
2930 files. */
2931
2932static int sort_by_secaddr PARAMS ((const PTR, const PTR));
2933
2934static int
2935sort_by_secaddr (arg1, arg2)
2936 const PTR arg1;
2937 const PTR arg2;
2938{
2939 const asection *a = *(const asection **) arg1;
2940 const asection *b = *(const asection **) arg2;
2941
2942 if (a->vma < b->vma)
2943 return -1;
2944 else if (a->vma > b->vma)
2945 return 1;
2946 else
2947 return 0;
2948}
2949
2950#endif /* COFF_IMAGE_WITH_PE */
252b5132 2951
e60b52c6 2952/* Calculate the file position for each section. */
252b5132
RH		 2953
2954#ifndef I960
2955#define ALIGN_SECTIONS_IN_FILE
2956#endif
81635ce4 2957#if defined(TIC80COFF) || defined(TICOFF)
252b5132
RH		 2958#undef ALIGN_SECTIONS_IN_FILE
2959#endif
2960
b34976b6 2961static bfd_boolean
252b5132
RH		 2962coff_compute_section_file_positions (abfd)
2963 bfd * abfd;
2964{
2965 asection *current;
2966 asection *previous = (asection *) NULL;
6b3b007b 2967 file_ptr sofar = bfd_coff_filhsz (abfd);
b34976b6 2968 bfd_boolean align_adjust;
252b5132
RH		 2969#ifdef ALIGN_SECTIONS_IN_FILE
2970 file_ptr old_sofar;
2971#endif
2972
2973#ifdef RS6000COFF_C
2974 /* On XCOFF, if we have symbols, set up the .debug section. */
2975 if (bfd_get_symcount (abfd) > 0)
2976 {
2977 bfd_size_type sz;
2978 bfd_size_type i, symcount;
2979 asymbol **symp;
2980
2981 sz = 0;
2982 symcount = bfd_get_symcount (abfd);
2983 for (symp = abfd->outsymbols, i = 0; i < symcount; symp++, i++)
2984 {
2985 coff_symbol_type *cf;
2986
2987 cf = coff_symbol_from (abfd, *symp);
2988 if (cf != NULL
2989 && cf->native != NULL
2990 && SYMNAME_IN_DEBUG (&cf->native->u.syment))
2991 {
2992 size_t len;
2993
2994 len = strlen (bfd_asymbol_name (*symp));
7f6d05e8
CP		 2995 if (len > SYMNMLEN || bfd_coff_force_symnames_in_strings (abfd))
2996 sz += len + 1 + bfd_coff_debug_string_prefix_length (abfd);
252b5132
RH		 2997 }
2998 }
2999 if (sz > 0)
3000 {
3001 asection *dsec;
3002
3003 dsec = bfd_make_section_old_way (abfd, ".debug");
3004 if (dsec == NULL)
3005 abort ();
3006 dsec->_raw_size = sz;
3007 dsec->flags |= SEC_HAS_CONTENTS;
3008 }
3009 }
3010#endif
3011
3012#ifdef COFF_IMAGE_WITH_PE
3013 int page_size;
e60b52c6 3014 if (coff_data (abfd)->link_info)
252b5132
RH		 3015 {
3016 page_size = pe_data (abfd)->pe_opthdr.FileAlignment;
3017 }
3018 else
3019 page_size = PE_DEF_FILE_ALIGNMENT;
3020#else
3021#ifdef COFF_PAGE_SIZE
3022 int page_size = COFF_PAGE_SIZE;
3023#endif
3024#endif
3025
3026 if (bfd_get_start_address (abfd))
3027 {
3028 /* A start address may have been added to the original file. In this
3029 case it will need an optional header to record it. */
3030 abfd->flags |= EXEC_P;
3031 }
3032
3033 if (abfd->flags & EXEC_P)
6b3b007b 3034 sofar += bfd_coff_aoutsz (abfd);
252b5132
RH		 3035#ifdef RS6000COFF_C
3036 else if (xcoff_data (abfd)->full_aouthdr)
6b3b007b 3037 sofar += bfd_coff_aoutsz (abfd);
252b5132
RH		 3038 else
3039 sofar += SMALL_AOUTSZ;
3040#endif
3041
6b3b007b 3042 sofar += abfd->section_count * bfd_coff_scnhsz (abfd);
252b5132
RH		 3043
3044#ifdef RS6000COFF_C
3045 /* XCOFF handles overflows in the reloc and line number count fields
3046 by allocating a new section header to hold the correct counts. */
3047 for (current = abfd->sections; current != NULL; current = current->next)
3048 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
6b3b007b 3049 sofar += bfd_coff_scnhsz (abfd);
252b5132
RH		 3050#endif
3051
75cc7189
ILT		 3052#ifdef COFF_IMAGE_WITH_PE
3053 {
3054 /* PE requires the sections to be in memory order when listed in
3055 the section headers. It also does not like empty loadable
3056 sections. The sections apparently do not have to be in the
3057 right order in the image file itself, but we do need to get the
3058 target_index values right. */
3059
dc810e39 3060 unsigned int count;
75cc7189 3061 asection **section_list;
dc810e39 3062 unsigned int i;
75cc7189 3063 int target_index;
dc810e39 3064 bfd_size_type amt;
75cc7189
ILT		 3065
3066 count = 0;
3067 for (current = abfd->sections; current != NULL; current = current->next)
3068 ++count;
3069
3070 /* We allocate an extra cell to simplify the final loop. */
dc810e39
AM		 3071 amt = sizeof (struct asection *) * (count + 1);
3072 section_list = bfd_malloc (amt);
75cc7189 3073 if (section_list == NULL)
b34976b6 3074 return FALSE;
75cc7189
ILT		 3075
3076 i = 0;
3077 for (current = abfd->sections; current != NULL; current = current->next)
3078 {
3079 section_list[i] = current;
3080 ++i;
3081 }
3082 section_list[i] = NULL;
3083
3084 qsort (section_list, count, sizeof (asection *), sort_by_secaddr);
3085
3086 /* Rethread the linked list into sorted order; at the same time,
3087 assign target_index values. */
3088 target_index = 1;
3089 abfd->sections = section_list[0];
3090 for (i = 0; i < count; i++)
3091 {
3092 current = section_list[i];
3093 current->next = section_list[i + 1];
3094
3095 /* Later, if the section has zero size, we'll be throwing it
3096 away, so we don't want to number it now. Note that having
3097 a zero size and having real contents are different
3098 concepts: .bss has no contents, but (usually) non-zero
3099 size. */
3100 if (current->_raw_size == 0)
3101 {
3102 /* Discard. However, it still might have (valid) symbols
3103 in it, so arbitrarily set it to section 1 (indexing is
3104 1-based here; usually .text). __end__ and other
3105 contents of .endsection really have this happen.
3106 FIXME: This seems somewhat dubious. */
3107 current->target_index = 1;
3108 }
3109 else
3110 current->target_index = target_index++;
3111 }
fd55a5df 3112 abfd->section_tail = &current->next;
75cc7189 3113
2fca4467 3114 free (section_list);
75cc7189
ILT		 3115 }
3116#else /* ! COFF_IMAGE_WITH_PE */
3117 {
3118 /* Set the target_index field. */
3119 int target_index;
3120
3121 target_index = 1;
3122 for (current = abfd->sections; current != NULL; current = current->next)
3123 current->target_index = target_index++;
3124 }
3125#endif /* ! COFF_IMAGE_WITH_PE */
3126
b34976b6 3127 align_adjust = FALSE;
75cc7189 3128 for (current = abfd->sections;
252b5132 3129 current != (asection *) NULL;
75cc7189 3130 current = current->next)
252b5132
RH		 3131 {
3132#ifdef COFF_IMAGE_WITH_PE
75cc7189
ILT		 3133 /* With PE we have to pad each section to be a multiple of its
3134 page size too, and remember both sizes. */
3135 if (coff_section_data (abfd, current) == NULL)
252b5132 3136 {
dc810e39
AM		 3137 bfd_size_type amt = sizeof (struct coff_section_tdata);
3138 current->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
75cc7189 3139 if (current->used_by_bfd == NULL)
b34976b6 3140 return FALSE;
252b5132 3141 }
75cc7189
ILT		 3142 if (pei_section_data (abfd, current) == NULL)
3143 {
dc810e39
AM		 3144 bfd_size_type amt = sizeof (struct pei_section_tdata);
3145 coff_section_data (abfd, current)->tdata
3146 = (PTR) bfd_zalloc (abfd, amt);
75cc7189 3147 if (coff_section_data (abfd, current)->tdata == NULL)
b34976b6 3148 return FALSE;
75cc7189
ILT		 3149 }
3150 if (pei_section_data (abfd, current)->virt_size == 0)
3151 pei_section_data (abfd, current)->virt_size = current->_raw_size;
252b5132
RH		 3152#endif
3153
75cc7189 3154 /* Only deal with sections which have contents. */
252b5132
RH		 3155 if (!(current->flags & SEC_HAS_CONTENTS))
3156 continue;
3157
75cc7189
ILT		 3158#ifdef COFF_IMAGE_WITH_PE
3159 /* Make sure we skip empty sections in a PE image. */
3160 if (current->_raw_size == 0)
3161 continue;
3162#endif
3163
252b5132
RH		 3164 /* Align the sections in the file to the same boundary on
3165 which they are aligned in virtual memory. I960 doesn't
3166 do this (FIXME) so we can stay in sync with Intel. 960
e60b52c6 3167 doesn't yet page from files... */
252b5132
RH		 3168#ifdef ALIGN_SECTIONS_IN_FILE
3169 if ((abfd->flags & EXEC_P) != 0)
3170 {
ed781d5d
NC		 3171 /* Make sure this section is aligned on the right boundary - by
3172 padding the previous section up if necessary. */
252b5132
RH		 3173
3174 old_sofar = sofar;
47ede03a
TR		 3175#ifdef RS6000COFF_C
3176 /* AIX loader checks the text section alignment of (vma - filepos)
3177 So even though the filepos may be aligned wrt the o_algntext, for
19852a2a 3178 AIX executables, this check fails. This shows up when a native
47ede03a
TR		 3179 AIX executable is stripped with gnu strip because the default vma
3180 of native is 0x10000150 but default for gnu is 0x10000140. Gnu
b34976b6 3181 stripped gnu excutable passes this check because the filepos is
f3813499
TR		 3182 0x0140. This problem also show up with 64 bit shared objects. The
3183 data section must also be aligned. */
b34976b6
AM		 3184 if (!strcmp (current->name, _TEXT)
3185 || !strcmp (current->name, _DATA))
47ede03a
TR		 3186 {
3187 bfd_vma pad;
3188 bfd_vma align;
3189
3190 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3191
3192 align = 1 << current->alignment_power;
3193 pad = abs (current->vma - sofar) % align;
b34976b6
AM		 3194
3195 if (pad)
47ede03a
TR		 3196 {
3197 pad = align - pad;
3198 sofar += pad;
3199 }
3200 }
3201 else
3202#else
3203 {
3204 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3205 }
3206#endif
252b5132 3207 if (previous != (asection *) NULL)
ed781d5d 3208 previous->_raw_size += sofar - old_sofar;
252b5132
RH		 3209 }
3210
3211#endif
3212
3213 /* In demand paged files the low order bits of the file offset
3214 must match the low order bits of the virtual address. */
3215#ifdef COFF_PAGE_SIZE
3216 if ((abfd->flags & D_PAGED) != 0
3217 && (current->flags & SEC_ALLOC) != 0)
3218 sofar += (current->vma - sofar) % page_size;
3219#endif
3220 current->filepos = sofar;
3221
3222#ifdef COFF_IMAGE_WITH_PE
75cc7189 3223 /* Set the padded size. */
252b5132
RH		 3224 current->_raw_size = (current->_raw_size + page_size -1) & -page_size;
3225#endif
3226
3227 sofar += current->_raw_size;
3228
3229#ifdef ALIGN_SECTIONS_IN_FILE
ed781d5d 3230 /* Make sure that this section is of the right size too. */
252b5132
RH		 3231 if ((abfd->flags & EXEC_P) == 0)
3232 {
3233 bfd_size_type old_size;
3234
3235 old_size = current->_raw_size;
3236 current->_raw_size = BFD_ALIGN (current->_raw_size,
3237 1 << current->alignment_power);
3238 align_adjust = current->_raw_size != old_size;
3239 sofar += current->_raw_size - old_size;
3240 }
3241 else
3242 {
3243 old_sofar = sofar;
3244 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3245 align_adjust = sofar != old_sofar;
3246 current->_raw_size += sofar - old_sofar;
3247 }
3248#endif
3249
3250#ifdef COFF_IMAGE_WITH_PE
3251 /* For PE we need to make sure we pad out to the aligned
3252 _raw_size, in case the caller only writes out data to the
3253 unaligned _raw_size. */
3254 if (pei_section_data (abfd, current)->virt_size < current->_raw_size)
b34976b6 3255 align_adjust = TRUE;
252b5132
RH		 3256#endif
3257
3258#ifdef _LIB
3259 /* Force .lib sections to start at zero. The vma is then
3260 incremented in coff_set_section_contents. This is right for
3261 SVR3.2. */
3262 if (strcmp (current->name, _LIB) == 0)
3263 bfd_set_section_vma (abfd, current, 0);
3264#endif
3265
3266 previous = current;
3267 }
3268
3269 /* It is now safe to write to the output file. If we needed an
3270 alignment adjustment for the last section, then make sure that
3271 there is a byte at offset sofar. If there are no symbols and no
3272 relocs, then nothing follows the last section. If we don't force
3273 the last byte out, then the file may appear to be truncated. */
3274 if (align_adjust)
3275 {
3276 bfd_byte b;
3277
3278 b = 0;
3279 if (bfd_seek (abfd, sofar - 1, SEEK_SET) != 0
dc810e39 3280 || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
b34976b6 3281 return FALSE;
252b5132
RH		 3282 }
3283
3284 /* Make sure the relocations are aligned. We don't need to make
3285 sure that this byte exists, because it will only matter if there
3286 really are relocs. */
3287 sofar = BFD_ALIGN (sofar, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER);
3288
3289 obj_relocbase (abfd) = sofar;
b34976b6 3290 abfd->output_has_begun = TRUE;
252b5132 3291
b34976b6 3292 return TRUE;
252b5132
RH		 3293}
3294
3295#if 0
3296
3297/* This can never work, because it is called too late--after the
3298 section positions have been set. I can't figure out what it is
3299 for, so I am going to disable it--Ian Taylor 20 March 1996. */
3300
3301/* If .file, .text, .data, .bss symbols are missing, add them. */
3302/* @@ Should we only be adding missing symbols, or overriding the aux
3303 values for existing section symbols? */
b34976b6 3304static bfd_boolean
252b5132
RH		 3305coff_add_missing_symbols (abfd)
3306 bfd *abfd;
3307{
3308 unsigned int nsyms = bfd_get_symcount (abfd);
3309 asymbol **sympp = abfd->outsymbols;
3310 asymbol **sympp2;
3311 unsigned int i;
3312 int need_text = 1, need_data = 1, need_bss = 1, need_file = 1;
dc810e39 3313 bfd_size_type amt;
252b5132
RH		 3314
3315 for (i = 0; i < nsyms; i++)
3316 {
3317 coff_symbol_type *csym = coff_symbol_from (abfd, sympp[i]);
dc810e39 3318 const char *name;
ed781d5d 3319
252b5132
RH		 3320 if (csym)
3321 {
ed781d5d
NC		 3322 /* Only do this if there is a coff representation of the input
3323 symbol. */
252b5132
RH		 3324 if (csym->native && csym->native->u.syment.n_sclass == C_FILE)
3325 {
3326 need_file = 0;
3327 continue;
3328 }
3329 name = csym->symbol.name;
3330 if (!name)
3331 continue;
3332 if (!strcmp (name, _TEXT))
3333 need_text = 0;
3334#ifdef APOLLO_M68
3335 else if (!strcmp (name, ".wtext"))
3336 need_text = 0;
3337#endif
3338 else if (!strcmp (name, _DATA))
3339 need_data = 0;
3340 else if (!strcmp (name, _BSS))
3341 need_bss = 0;
3342 }
3343 }
3344 /* Now i == bfd_get_symcount (abfd). */
3345 /* @@ For now, don't deal with .file symbol. */
3346 need_file = 0;
3347
3348 if (!need_text && !need_data && !need_bss && !need_file)
b34976b6 3349 return TRUE;
252b5132 3350 nsyms += need_text + need_data + need_bss + need_file;
dc810e39
AM		 3351 amt = nsyms;
3352 amt *= sizeof (asymbol *);
3353 sympp2 = (asymbol **) bfd_alloc (abfd, amt);
252b5132 3354 if (!sympp2)
b34976b6 3355 return FALSE;
252b5132 3356 memcpy (sympp2, sympp, i * sizeof (asymbol *));
ed781d5d 3357
252b5132 3358 if (need_file)
ed781d5d
NC		 3359 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
3360 abort ();
3361
252b5132
RH		 3362 if (need_text)
3363 sympp2[i++] = coff_section_symbol (abfd, _TEXT);
3364 if (need_data)
3365 sympp2[i++] = coff_section_symbol (abfd, _DATA);
3366 if (need_bss)
3367 sympp2[i++] = coff_section_symbol (abfd, _BSS);
3368 BFD_ASSERT (i == nsyms);
3369 bfd_set_symtab (abfd, sympp2, nsyms);
b34976b6 3370 return TRUE;
252b5132
RH		 3371}
3372
3373#endif /* 0 */
3374
05793179
NC		 3375#ifdef COFF_IMAGE_WITH_PE
3376
3377static unsigned int pelength;
3378static unsigned int peheader;
3379
b34976b6 3380static bfd_boolean
05793179
NC		 3381coff_read_word (abfd, value)
3382 bfd *abfd;
3383 unsigned int *value;
3384{
3385 unsigned char b[2];
3386 int status;
3387
3388 status = bfd_bread (b, (bfd_size_type) 2, abfd);
3389 if (status < 1)
3390 {
3391 *value = 0;
b34976b6 3392 return FALSE;
05793179
NC		 3393 }
3394
3395 if (status == 1)
3396 *value = (unsigned int) b[0];
3397 else
3398 *value = (unsigned int) (b[0] + (b[1] << 8));
3399
3400 pelength += (unsigned int) status;
3401
b34976b6 3402 return TRUE;
05793179
NC		 3403}
3404
3405static unsigned int
3406coff_compute_checksum (abfd)
3407 bfd *abfd;
3408{
b34976b6 3409 bfd_boolean more_data;
05793179
NC		 3410 file_ptr filepos;
3411 unsigned int value;
3412 unsigned int total;
3413
3414 total = 0;
3415 pelength = 0;
3416 filepos = (file_ptr) 0;
3417
3418 do
3419 {
3420 if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
3421 return 0;
3422
3423 more_data = coff_read_word (abfd, &value);
3424 total += value;
3425 total = 0xffff & (total + (total >> 0x10));
3426 filepos += 2;
3427 }
3428 while (more_data);
3429
3430 return (0xffff & (total + (total >> 0x10)));
3431}
3432
b34976b6 3433static bfd_boolean
05793179
NC		 3434coff_apply_checksum (abfd)
3435 bfd *abfd;
3436{
3437 unsigned int computed;
3438 unsigned int checksum = 0;
3439
3440 if (bfd_seek (abfd, 0x3c, SEEK_SET) != 0)
b34976b6 3441 return FALSE;
05793179
NC		 3442
3443 if (!coff_read_word (abfd, &peheader))
b34976b6 3444 return FALSE;
05793179
NC		 3445
3446 if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0)
b34976b6 3447 return FALSE;
05793179
NC		 3448
3449 checksum = 0;
3450 bfd_bwrite (&checksum, (bfd_size_type) 4, abfd);
3451
3452 if (bfd_seek (abfd, peheader, SEEK_SET) != 0)
b34976b6 3453 return FALSE;
05793179
NC		 3454
3455 computed = coff_compute_checksum (abfd);
3456
3457 checksum = computed + pelength;
3458
3459 if (bfd_seek (abfd, peheader + 0x58, SEEK_SET) != 0)
b34976b6 3460 return FALSE;
05793179
NC		 3461
3462 bfd_bwrite (&checksum, (bfd_size_type) 4, abfd);
3463
b34976b6 3464 return TRUE;
05793179
NC		 3465}
3466
3467#endif /* COFF_IMAGE_WITH_PE */
3468
252b5132
RH		 3469/* SUPPRESS 558 */
3470/* SUPPRESS 529 */
b34976b6 3471static bfd_boolean
252b5132
RH		 3472coff_write_object_contents (abfd)
3473 bfd * abfd;
3474{
3475 asection *current;
b34976b6
AM		 3476 bfd_boolean hasrelocs = FALSE;
3477 bfd_boolean haslinno = FALSE;
3478 bfd_boolean hasdebug = FALSE;
252b5132
RH		 3479 file_ptr scn_base;
3480 file_ptr reloc_base;
3481 file_ptr lineno_base;
3482 file_ptr sym_base;
3e4554a2 3483 unsigned long reloc_size = 0, reloc_count = 0;
252b5132 3484 unsigned long lnno_size = 0;
b34976b6 3485 bfd_boolean long_section_names;
252b5132
RH		 3486 asection *text_sec = NULL;
3487 asection *data_sec = NULL;
3488 asection *bss_sec = NULL;
3489 struct internal_filehdr internal_f;
3490 struct internal_aouthdr internal_a;
3491#ifdef COFF_LONG_SECTION_NAMES
3492 size_t string_size = STRING_SIZE_SIZE;
3493#endif
3494
3495 bfd_set_error (bfd_error_system_call);
3496
3497 /* Make a pass through the symbol table to count line number entries and
ed781d5d 3498 put them into the correct asections. */
252b5132 3499
6b3b007b 3500 lnno_size = coff_count_linenumbers (abfd) * bfd_coff_linesz (abfd);
252b5132 3501
82e51918 3502 if (! abfd->output_has_begun)
252b5132
RH		 3503 {
3504 if (! coff_compute_section_file_positions (abfd))
b34976b6 3505 return FALSE;
252b5132
RH		 3506 }
3507
3508 reloc_base = obj_relocbase (abfd);
3509
ed781d5d 3510 /* Work out the size of the reloc and linno areas. */
252b5132
RH		 3511
3512 for (current = abfd->sections; current != NULL; current =
3513 current->next)
3e4554a2
DD		 3514 {
3515#ifdef COFF_WITH_PE
ed781d5d 3516 /* We store the actual reloc count in the first reloc's addr. */
e9168c1e 3517 if (obj_pe (abfd) && current->reloc_count >= 0xffff)
3e4554a2
DD		 3518 reloc_count ++;
3519#endif
3520 reloc_count += current->reloc_count;
3521 }
3522
3523 reloc_size = reloc_count * bfd_coff_relsz (abfd);
252b5132
RH		 3524
3525 lineno_base = reloc_base + reloc_size;
3526 sym_base = lineno_base + lnno_size;
3527
ed781d5d 3528 /* Indicate in each section->line_filepos its actual file address. */
252b5132
RH		 3529 for (current = abfd->sections; current != NULL; current =
3530 current->next)
3531 {
3532 if (current->lineno_count)
3533 {
3534 current->line_filepos = lineno_base;
3535 current->moving_line_filepos = lineno_base;
6b3b007b 3536 lineno_base += current->lineno_count * bfd_coff_linesz (abfd);
252b5132
RH		 3537 }
3538 else
3539 {
3540 current->line_filepos = 0;
3541 }
3542 if (current->reloc_count)
3543 {
3544 current->rel_filepos = reloc_base;
6b3b007b 3545 reloc_base += current->reloc_count * bfd_coff_relsz (abfd);
3e4554a2 3546#ifdef COFF_WITH_PE
ed781d5d 3547 /* Extra reloc to hold real count. */
e9168c1e 3548 if (obj_pe (abfd) && current->reloc_count >= 0xffff)
3e4554a2
DD		 3549 reloc_base += bfd_coff_relsz (abfd);
3550#endif
252b5132
RH		 3551 }
3552 else
3553 {
3554 current->rel_filepos = 0;
3555 }
3556 }
3557
3558 /* Write section headers to the file. */
3559 internal_f.f_nscns = 0;
3560
3561 if ((abfd->flags & EXEC_P) != 0)
6b3b007b 3562 scn_base = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
252b5132
RH		 3563 else
3564 {
6b3b007b 3565 scn_base = bfd_coff_filhsz (abfd);
252b5132 3566#ifdef RS6000COFF_C
dc810e39 3567#ifndef XCOFF64
252b5132 3568 if (xcoff_data (abfd)->full_aouthdr)
6b3b007b 3569 scn_base += bfd_coff_aoutsz (abfd);
252b5132
RH		 3570 else
3571 scn_base += SMALL_AOUTSZ;
dc810e39 3572#endif
252b5132
RH		 3573#endif
3574 }
3575
3576 if (bfd_seek (abfd, scn_base, SEEK_SET) != 0)
b34976b6 3577 return FALSE;
252b5132 3578
b34976b6 3579 long_section_names = FALSE;
252b5132
RH		 3580 for (current = abfd->sections;
3581 current != NULL;
3582 current = current->next)
3583 {
3584 struct internal_scnhdr section;
b34976b6 3585 bfd_boolean is_reloc_section = FALSE;
252b5132
RH		 3586
3587#ifdef COFF_IMAGE_WITH_PE
3588 if (strcmp (current->name, ".reloc") == 0)
3589 {
b34976b6
AM		 3590 is_reloc_section = TRUE;
3591 hasrelocs = TRUE;
252b5132
RH		 3592 pe_data (abfd)->has_reloc_section = 1;
3593 }
3594#endif
3595
252b5132
RH		 3596 internal_f.f_nscns++;
3597
3598 strncpy (section.s_name, current->name, SCNNMLEN);
3599
3600#ifdef COFF_LONG_SECTION_NAMES
3601 /* Handle long section names as in PE. This must be compatible
00692651 3602 with the code in coff_write_symbols and _bfd_coff_final_link. */
252b5132
RH		 3603 {
3604 size_t len;
3605
3606 len = strlen (current->name);
3607 if (len > SCNNMLEN)
3608 {
3609 memset (section.s_name, 0, SCNNMLEN);
3610 sprintf (section.s_name, "/%lu", (unsigned long) string_size);
3611 string_size += len + 1;
b34976b6 3612 long_section_names = TRUE;
252b5132
RH		 3613 }
3614 }
3615#endif
3616
3617#ifdef _LIB
3618 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3619 Ian Taylor <ian@cygnus.com>. */
3620 if (strcmp (current->name, _LIB) == 0)
3621 section.s_vaddr = 0;
3622 else
3623#endif
3624 section.s_vaddr = current->vma;
3625 section.s_paddr = current->lma;
3626 section.s_size = current->_raw_size;
b9af77f5 3627#ifdef coff_get_section_load_page
e60b52c6 3628 section.s_page = coff_get_section_load_page (current);
b9af77f5 3629#endif
252b5132
RH		 3630
3631#ifdef COFF_WITH_PE
3632 section.s_paddr = 0;
3633#endif
3634#ifdef COFF_IMAGE_WITH_PE
3635 /* Reminder: s_paddr holds the virtual size of the section. */
3636 if (coff_section_data (abfd, current) != NULL
3637 && pei_section_data (abfd, current) != NULL)
3638 section.s_paddr = pei_section_data (abfd, current)->virt_size;
3639 else
3640 section.s_paddr = 0;
3641#endif
3642
ed781d5d
NC		 3643 /* If this section has no size or is unloadable then the scnptr
3644 will be 0 too. */
252b5132
RH		 3645 if (current->_raw_size == 0 ||
3646 (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
ed781d5d 3647 section.s_scnptr = 0;
252b5132 3648 else
ed781d5d
NC		 3649 section.s_scnptr = current->filepos;
3650
252b5132
RH		 3651 section.s_relptr = current->rel_filepos;
3652 section.s_lnnoptr = current->line_filepos;
3653 section.s_nreloc = current->reloc_count;
3654 section.s_nlnno = current->lineno_count;
79207490
ILT		 3655#ifndef COFF_IMAGE_WITH_PE
3656 /* In PEI, relocs come in the .reloc section. */
252b5132 3657 if (current->reloc_count != 0)
b34976b6 3658 hasrelocs = TRUE;
79207490 3659#endif
252b5132 3660 if (current->lineno_count != 0)
b34976b6 3661 haslinno = TRUE;
4cfec37b
ILT		 3662 if ((current->flags & SEC_DEBUGGING) != 0
3663 && ! is_reloc_section)
b34976b6 3664 hasdebug = TRUE;
252b5132 3665
60bcf0fa 3666#ifdef RS6000COFF_C
7f6d05e8 3667#ifndef XCOFF64
252b5132
RH		 3668 /* Indicate the use of an XCOFF overflow section header. */
3669 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3670 {
3671 section.s_nreloc = 0xffff;
3672 section.s_nlnno = 0xffff;
3673 }
7f6d05e8 3674#endif
252b5132
RH		 3675#endif
3676
3677 section.s_flags = sec_to_styp_flags (current->name, current->flags);
3678
3679 if (!strcmp (current->name, _TEXT))
ed781d5d 3680 text_sec = current;
252b5132 3681 else if (!strcmp (current->name, _DATA))
ed781d5d 3682 data_sec = current;
252b5132 3683 else if (!strcmp (current->name, _BSS))
ed781d5d 3684 bss_sec = current;
252b5132
RH		 3685
3686#ifdef I960
3687 section.s_align = (current->alignment_power
3688 ? 1 << current->alignment_power
3689 : 0);
81635ce4 3690#endif
e60b52c6 3691#ifdef TIC80COFF
ed781d5d 3692 /* TI COFF puts the alignment power in bits 8-11 of the flags. */
252b5132
RH		 3693 section.s_flags |= (current->alignment_power & 0xF) << 8;
3694#endif
81635ce4
TW		 3695#ifdef COFF_ENCODE_ALIGNMENT
3696 COFF_ENCODE_ALIGNMENT(section, current->alignment_power);
252b5132
RH		 3697#endif
3698
3699#ifdef COFF_IMAGE_WITH_PE
00692651
ILT		 3700 /* Suppress output of the sections if they are null. ld
3701 includes the bss and data sections even if there is no size
3702 assigned to them. NT loader doesn't like it if these section
3703 headers are included if the sections themselves are not
3704 needed. See also coff_compute_section_file_positions. */
252b5132
RH		 3705 if (section.s_size == 0)
3706 internal_f.f_nscns--;
3707 else
3708#endif
3709 {
3710 SCNHDR buff;
dc810e39
AM		 3711 bfd_size_type amt = bfd_coff_scnhsz (abfd);
3712
252b5132 3713 if (coff_swap_scnhdr_out (abfd, &section, &buff) == 0
dc810e39 3714 || bfd_bwrite ((PTR) &buff, amt, abfd) != amt)
b34976b6 3715 return FALSE;
252b5132
RH		 3716 }
3717
3718#ifdef COFF_WITH_PE
3719 /* PE stores COMDAT section information in the symbol table. If
3720 this section is supposed to have some COMDAT info, track down
3721 the symbol in the symbol table and modify it. */
3722 if ((current->flags & SEC_LINK_ONCE) != 0)
3723 {
3724 unsigned int i, count;
3725 asymbol **psym;
3726 coff_symbol_type *csym = NULL;
3727 asymbol **psymsec;
3728
3729 psymsec = NULL;
3730 count = bfd_get_symcount (abfd);
3731 for (i = 0, psym = abfd->outsymbols; i < count; i++, psym++)
3732 {
3733 if ((*psym)->section != current)
3734 continue;
3735
3736 /* Remember the location of the first symbol in this
3737 section. */
3738 if (psymsec == NULL)
3739 psymsec = psym;
3740
3741 /* See if this is the section symbol. */
3742 if (strcmp ((*psym)->name, current->name) == 0)
3743 {
3744 csym = coff_symbol_from (abfd, *psym);
3745 if (csym == NULL
3746 || csym->native == NULL
3747 || csym->native->u.syment.n_numaux < 1
3748 || csym->native->u.syment.n_sclass != C_STAT
3749 || csym->native->u.syment.n_type != T_NULL)
3750 continue;
3751
3752 /* Here *PSYM is the section symbol for CURRENT. */
3753
3754 break;
3755 }
3756 }
3757
3758 /* Did we find it?
3759 Note that we might not if we're converting the file from
3760 some other object file format. */
3761 if (i < count)
3762 {
3763 combined_entry_type *aux;
3764
3765 /* We don't touch the x_checksum field. The
3766 x_associated field is not currently supported. */
3767
3768 aux = csym->native + 1;
3769 switch (current->flags & SEC_LINK_DUPLICATES)
3770 {
3771 case SEC_LINK_DUPLICATES_DISCARD:
3772 aux->u.auxent.x_scn.x_comdat = IMAGE_COMDAT_SELECT_ANY;
3773 break;
3774
3775 case SEC_LINK_DUPLICATES_ONE_ONLY:
3776 aux->u.auxent.x_scn.x_comdat =
3777 IMAGE_COMDAT_SELECT_NODUPLICATES;
3778 break;
3779
3780 case SEC_LINK_DUPLICATES_SAME_SIZE:
3781 aux->u.auxent.x_scn.x_comdat =
3782 IMAGE_COMDAT_SELECT_SAME_SIZE;
3783 break;
3784
3785 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
3786 aux->u.auxent.x_scn.x_comdat =
3787 IMAGE_COMDAT_SELECT_EXACT_MATCH;
3788 break;
3789 }
3790
3791 /* The COMDAT symbol must be the first symbol from this
3792 section in the symbol table. In order to make this
3793 work, we move the COMDAT symbol before the first
3794 symbol we found in the search above. It's OK to
3795 rearrange the symbol table at this point, because
3796 coff_renumber_symbols is going to rearrange it
3797 further and fix up all the aux entries. */
3798 if (psym != psymsec)
3799 {
3800 asymbol *hold;
3801 asymbol **pcopy;
3802
3803 hold = *psym;
3804 for (pcopy = psym; pcopy > psymsec; pcopy--)
3805 pcopy[0] = pcopy[-1];
3806 *psymsec = hold;
3807 }
3808 }
3809 }
3810#endif /* COFF_WITH_PE */
3811 }
3812
3813#ifdef RS6000COFF_C
dc810e39 3814#ifndef XCOFF64
252b5132
RH		 3815 /* XCOFF handles overflows in the reloc and line number count fields
3816 by creating a new section header to hold the correct values. */
3817 for (current = abfd->sections; current != NULL; current = current->next)
3818 {
3819 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3820 {
3821 struct internal_scnhdr scnhdr;
3822 SCNHDR buff;
dc810e39 3823 bfd_size_type amt;
252b5132
RH		 3824
3825 internal_f.f_nscns++;
3826 strncpy (&(scnhdr.s_name[0]), current->name, 8);
3827 scnhdr.s_paddr = current->reloc_count;
3828 scnhdr.s_vaddr = current->lineno_count;
3829 scnhdr.s_size = 0;
3830 scnhdr.s_scnptr = 0;
3831 scnhdr.s_relptr = current->rel_filepos;
3832 scnhdr.s_lnnoptr = current->line_filepos;
3833 scnhdr.s_nreloc = current->target_index;
3834 scnhdr.s_nlnno = current->target_index;
3835 scnhdr.s_flags = STYP_OVRFLO;
dc810e39 3836 amt = bfd_coff_scnhsz (abfd);
252b5132 3837 if (coff_swap_scnhdr_out (abfd, &scnhdr, &buff) == 0
dc810e39 3838 || bfd_bwrite ((PTR) &buff, amt, abfd) != amt)
b34976b6 3839 return FALSE;
252b5132
RH		 3840 }
3841 }
beb1bf64 3842#endif
252b5132
RH		 3843#endif
3844
e60b52c6 3845 /* OK, now set up the filehdr... */
252b5132
RH		 3846
3847 /* Don't include the internal abs section in the section count */
3848
ed781d5d 3849 /* We will NOT put a fucking timestamp in the header here. Every time you
252b5132
RH		 3850 put it back, I will come in and take it out again. I'm sorry. This
3851 field does not belong here. We fill it with a 0 so it compares the
ed781d5d 3852 same but is not a reasonable time. -- gnu@cygnus.com */
252b5132 3853 internal_f.f_timdat = 0;
252b5132
RH		 3854 internal_f.f_flags = 0;
3855
3856 if (abfd->flags & EXEC_P)
6b3b007b 3857 internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
252b5132
RH		 3858 else
3859 {
3860 internal_f.f_opthdr = 0;
3861#ifdef RS6000COFF_C
dc810e39 3862#ifndef XCOFF64
252b5132 3863 if (xcoff_data (abfd)->full_aouthdr)
6b3b007b 3864 internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
252b5132
RH		 3865 else
3866 internal_f.f_opthdr = SMALL_AOUTSZ;
dc810e39 3867#endif
252b5132
RH		 3868#endif
3869 }
3870
3871 if (!hasrelocs)
3872 internal_f.f_flags |= F_RELFLG;
3873 if (!haslinno)
3874 internal_f.f_flags |= F_LNNO;
3875 if (abfd->flags & EXEC_P)
3876 internal_f.f_flags |= F_EXEC;
4cfec37b
ILT		 3877#ifdef COFF_IMAGE_WITH_PE
3878 if (! hasdebug)
3879 internal_f.f_flags |= IMAGE_FILE_DEBUG_STRIPPED;
3880#endif
252b5132 3881
bcb9b88d
NC		 3882#ifdef COFF_WITH_PE
3883 internal_f.f_flags |= IMAGE_FILE_32BIT_MACHINE;
3884#else
252b5132
RH		 3885 if (bfd_little_endian (abfd))
3886 internal_f.f_flags |= F_AR32WR;
3887 else
3888 internal_f.f_flags |= F_AR32W;
8a1ad8e7 3889#endif
252b5132 3890
81635ce4 3891#ifdef TI_TARGET_ID
ed781d5d
NC		 3892 /* Target id is used in TI COFF v1 and later; COFF0 won't use this field,
3893 but it doesn't hurt to set it internally. */
81635ce4
TW		 3894 internal_f.f_target_id = TI_TARGET_ID;
3895#endif
252b5132
RH		 3896#ifdef TIC80_TARGET_ID
3897 internal_f.f_target_id = TIC80_TARGET_ID;
3898#endif
3899
ed781d5d
NC		 3900 /* FIXME, should do something about the other byte orders and
3901 architectures. */
252b5132
RH		 3902
3903#ifdef RS6000COFF_C
3904 if ((abfd->flags & DYNAMIC) != 0)
3905 internal_f.f_flags |= F_SHROBJ;
3906 if (bfd_get_section_by_name (abfd, _LOADER) != NULL)
3907 internal_f.f_flags |= F_DYNLOAD;
3908#endif
3909
3910 memset (&internal_a, 0, sizeof internal_a);
3911
ed781d5d 3912 /* Set up architecture-dependent stuff. */
252b5132
RH		 3913 {
3914 unsigned int magic = 0;
3915 unsigned short flags = 0;
ed781d5d 3916
252b5132
RH		 3917 coff_set_flags (abfd, &magic, &flags);
3918 internal_f.f_magic = magic;
3919 internal_f.f_flags |= flags;
e60b52c6 3920 /* ...and the "opt"hdr... */
252b5132
RH		 3921
3922#ifdef A29K
3923#ifdef ULTRA3 /* NYU's machine */
3924 /* FIXME: This is a bogus check. I really want to see if there
ed781d5d
NC		 3925 is a .shbss or a .shdata section, if so then set the magic
3926 number to indicate a shared data executable. */
252b5132 3927 if (internal_f.f_nscns >= 7)
ed781d5d 3928 internal_a.magic = SHMAGIC; /* Shared magic. */
252b5132
RH		 3929 else
3930#endif /* ULTRA3 */
ed781d5d 3931 internal_a.magic = NMAGIC; /* Assume separate i/d. */
252b5132
RH		 3932#define __A_MAGIC_SET__
3933#endif /* A29K */
81635ce4
TW		 3934#ifdef TICOFF_AOUT_MAGIC
3935 internal_a.magic = TICOFF_AOUT_MAGIC;
3936#define __A_MAGIC_SET__
3937#endif
252b5132
RH		 3938#ifdef TIC80COFF
3939 internal_a.magic = TIC80_ARCH_MAGIC;
3940#define __A_MAGIC_SET__
3941#endif /* TIC80 */
3942#ifdef I860
3943 /* FIXME: What are the a.out magic numbers for the i860? */
3944 internal_a.magic = 0;
3945#define __A_MAGIC_SET__
3946#endif /* I860 */
3947#ifdef I960
3948 internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
3949#define __A_MAGIC_SET__
3950#endif /* I960 */
3951#if M88
3952#define __A_MAGIC_SET__
3953 internal_a.magic = PAGEMAGICBCS;
3954#endif /* M88 */
3955
3956#if APOLLO_M68
3957#define __A_MAGIC_SET__
3958 internal_a.magic = APOLLO_COFF_VERSION_NUMBER;
3959#endif
3960
3961#if defined(M68) || defined(WE32K) || defined(M68K)
3962#define __A_MAGIC_SET__
3963#if defined(LYNXOS)
3964 internal_a.magic = LYNXCOFFMAGIC;
3965#else
3966#if defined(TARG_AUX)
3967 internal_a.magic = (abfd->flags & D_PAGED ? PAGEMAGICPEXECPAGED :
3968 abfd->flags & WP_TEXT ? PAGEMAGICPEXECSWAPPED :
3969 PAGEMAGICEXECSWAPPED);
3970#else
3971#if defined (PAGEMAGICPEXECPAGED)
3972 internal_a.magic = PAGEMAGICPEXECPAGED;
3973#endif
3974#endif /* TARG_AUX */
3975#endif /* LYNXOS */
3976#endif /* M68 || WE32K || M68K */
3977
3978#if defined(ARM)
3979#define __A_MAGIC_SET__
3980 internal_a.magic = ZMAGIC;
e60b52c6 3981#endif
252b5132
RH		 3982
3983#if defined(PPC_PE)
3984#define __A_MAGIC_SET__
3985 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
3986#endif
3987
3988#if defined MCORE_PE
3989#define __A_MAGIC_SET__
3990 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
e60b52c6 3991#endif
252b5132
RH		 3992
3993#if defined(I386)
3994#define __A_MAGIC_SET__
3995#if defined(LYNXOS)
3996 internal_a.magic = LYNXCOFFMAGIC;
3997#else /* LYNXOS */
3998 internal_a.magic = ZMAGIC;
3999#endif /* LYNXOS */
4000#endif /* I386 */
4001
fac41780
JW		 4002#if defined(IA64)
4003#define __A_MAGIC_SET__
4004 internal_a.magic = ZMAGIC;
4005#endif /* IA64 */
4006
252b5132
RH		 4007#if defined(SPARC)
4008#define __A_MAGIC_SET__
4009#if defined(LYNXOS)
4010 internal_a.magic = LYNXCOFFMAGIC;
4011#endif /* LYNXOS */
4012#endif /* SPARC */
4013
4014#ifdef RS6000COFF_C
4015#define __A_MAGIC_SET__
4016 internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC :
4017 (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC :
4018 RS6K_AOUTHDR_OMAGIC;
4019#endif
4020
17505c5c
NC		 4021#if defined(SH) && defined(COFF_WITH_PE)
4022#define __A_MAGIC_SET__
4023 internal_a.magic = SH_PE_MAGIC;
4024#endif
4025
4026#if defined(MIPS) && defined(COFF_WITH_PE)
4027#define __A_MAGIC_SET__
4028 internal_a.magic = MIPS_PE_MAGIC;
4029#endif
4030
3b16e843
NC		 4031#ifdef OR32
4032#define __A_MAGIC_SET__
4033 internal_a.magic = NMAGIC; /* Assume separate i/d. */
4034#endif
4035
252b5132
RH		 4036#ifndef __A_MAGIC_SET__
4037#include "Your aouthdr magic number is not being set!"
4038#else
4039#undef __A_MAGIC_SET__
4040#endif
4041 }
4042
4043 /* FIXME: Does anybody ever set this to another value? */
4044 internal_a.vstamp = 0;
4045
ed781d5d 4046 /* Now should write relocs, strings, syms. */
252b5132
RH		 4047 obj_sym_filepos (abfd) = sym_base;
4048
4049 if (bfd_get_symcount (abfd) != 0)
4050 {
4051 int firstundef;
4052#if 0
4053 if (!coff_add_missing_symbols (abfd))
b34976b6 4054 return FALSE;
252b5132
RH		 4055#endif
4056 if (!coff_renumber_symbols (abfd, &firstundef))
b34976b6 4057 return FALSE;
252b5132
RH		 4058 coff_mangle_symbols (abfd);
4059 if (! coff_write_symbols (abfd))
b34976b6 4060 return FALSE;
252b5132 4061 if (! coff_write_linenumbers (abfd))
b34976b6 4062 return FALSE;
252b5132 4063 if (! coff_write_relocs (abfd, firstundef))
b34976b6 4064 return FALSE;
252b5132
RH		 4065 }
4066#ifdef COFF_LONG_SECTION_NAMES
d71f672e 4067 else if (long_section_names && ! obj_coff_strings_written (abfd))
252b5132
RH		 4068 {
4069 /* If we have long section names we have to write out the string
4070 table even if there are no symbols. */
4071 if (! coff_write_symbols (abfd))
b34976b6 4072 return FALSE;
252b5132
RH		 4073 }
4074#endif
4075#ifdef COFF_IMAGE_WITH_PE
4076#ifdef PPC_PE
4077 else if ((abfd->flags & EXEC_P) != 0)
4078 {
4079 bfd_byte b;
4080
4081 /* PowerPC PE appears to require that all executable files be
4082 rounded up to the page size. */
4083 b = 0;
4084 if (bfd_seek (abfd,
dc810e39 4085 (file_ptr) BFD_ALIGN (sym_base, COFF_PAGE_SIZE) - 1,
252b5132 4086 SEEK_SET) != 0
dc810e39 4087 || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
b34976b6 4088 return FALSE;
252b5132
RH		 4089 }
4090#endif
4091#endif
4092
4093 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
4094 backend linker, and obj_raw_syment_count is not valid until after
4095 coff_write_symbols is called. */
4096 if (obj_raw_syment_count (abfd) != 0)
4097 {
4098 internal_f.f_symptr = sym_base;
4099#ifdef RS6000COFF_C
4100 /* AIX appears to require that F_RELFLG not be set if there are
4101 local symbols but no relocations. */
4102 internal_f.f_flags &=~ F_RELFLG;
4103#endif
4104 }
4105 else
4106 {
4107 if (long_section_names)
4108 internal_f.f_symptr = sym_base;
4109 else
4110 internal_f.f_symptr = 0;
4111 internal_f.f_flags |= F_LSYMS;
4112 }
4113
4114 if (text_sec)
4115 {
4116 internal_a.tsize = bfd_get_section_size_before_reloc (text_sec);
4117 internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
4118 }
4119 if (data_sec)
4120 {
4121 internal_a.dsize = bfd_get_section_size_before_reloc (data_sec);
4122 internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
4123 }
4124 if (bss_sec)
4125 {
4126 internal_a.bsize = bfd_get_section_size_before_reloc (bss_sec);
4127 if (internal_a.bsize && bss_sec->vma < internal_a.data_start)
4128 internal_a.data_start = bss_sec->vma;
4129 }
4130
4131 internal_a.entry = bfd_get_start_address (abfd);
4132 internal_f.f_nsyms = obj_raw_syment_count (abfd);
4133
4134#ifdef RS6000COFF_C
4135 if (xcoff_data (abfd)->full_aouthdr)
4136 {
4137 bfd_vma toc;
4138 asection *loader_sec;
4139
4140 internal_a.vstamp = 1;
4141
4142 internal_a.o_snentry = xcoff_data (abfd)->snentry;
4143 if (internal_a.o_snentry == 0)
4144 internal_a.entry = (bfd_vma) -1;
4145
4146 if (text_sec != NULL)
4147 {
4148 internal_a.o_sntext = text_sec->target_index;
4149 internal_a.o_algntext = bfd_get_section_alignment (abfd, text_sec);
4150 }
4151 else
4152 {
4153 internal_a.o_sntext = 0;
4154 internal_a.o_algntext = 0;
4155 }
4156 if (data_sec != NULL)
4157 {
4158 internal_a.o_sndata = data_sec->target_index;
4159 internal_a.o_algndata = bfd_get_section_alignment (abfd, data_sec);
4160 }
4161 else
4162 {
4163 internal_a.o_sndata = 0;
4164 internal_a.o_algndata = 0;
4165 }
4166 loader_sec = bfd_get_section_by_name (abfd, ".loader");
4167 if (loader_sec != NULL)
4168 internal_a.o_snloader = loader_sec->target_index;
4169 else
4170 internal_a.o_snloader = 0;
4171 if (bss_sec != NULL)
4172 internal_a.o_snbss = bss_sec->target_index;
4173 else
4174 internal_a.o_snbss = 0;
4175
4176 toc = xcoff_data (abfd)->toc;
4177 internal_a.o_toc = toc;
4178 internal_a.o_sntoc = xcoff_data (abfd)->sntoc;
4179
4180 internal_a.o_modtype = xcoff_data (abfd)->modtype;
4181 if (xcoff_data (abfd)->cputype != -1)
4182 internal_a.o_cputype = xcoff_data (abfd)->cputype;
4183 else
4184 {
4185 switch (bfd_get_arch (abfd))
4186 {
4187 case bfd_arch_rs6000:
4188 internal_a.o_cputype = 4;
4189 break;
4190 case bfd_arch_powerpc:
250d94fd 4191 if (bfd_get_mach (abfd) == bfd_mach_ppc)
252b5132
RH		 4192 internal_a.o_cputype = 3;
4193 else
4194 internal_a.o_cputype = 1;
4195 break;
4196 default:
4197 abort ();
4198 }
4199 }
4200 internal_a.o_maxstack = xcoff_data (abfd)->maxstack;
4201 internal_a.o_maxdata = xcoff_data (abfd)->maxdata;
4202 }
4203#endif
4204
4205 /* now write them */
4206 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
b34976b6 4207 return FALSE;
e60b52c6 4208
252b5132 4209 {
b5f303f0 4210 char * buff;
dc810e39 4211 bfd_size_type amount = bfd_coff_filhsz (abfd);
e60b52c6 4212
dc810e39 4213 buff = bfd_malloc (amount);
e60b52c6 4214 if (buff == NULL)
b34976b6 4215 return FALSE;
e60b52c6 4216
dc810e39
AM		 4217 bfd_coff_swap_filehdr_out (abfd, (PTR) &internal_f, (PTR) buff);
4218 amount = bfd_bwrite ((PTR) buff, amount, abfd);
e60b52c6 4219
2fca4467 4220 free (buff);
e60b52c6 4221
b5f303f0 4222 if (amount != bfd_coff_filhsz (abfd))
b34976b6 4223 return FALSE;
252b5132 4224 }
e60b52c6 4225
252b5132
RH		 4226 if (abfd->flags & EXEC_P)
4227 {
e60b52c6 4228 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
ed781d5d 4229 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)). */
b5f303f0 4230 char * buff;
dc810e39 4231 bfd_size_type amount = bfd_coff_aoutsz (abfd);
b5f303f0 4232
dc810e39 4233 buff = bfd_malloc (amount);
e60b52c6 4234 if (buff == NULL)
b34976b6 4235 return FALSE;
e60b52c6 4236
dc810e39
AM		 4237 coff_swap_aouthdr_out (abfd, (PTR) &internal_a, (PTR) buff);
4238 amount = bfd_bwrite ((PTR) buff, amount, abfd);
e60b52c6 4239
2fca4467 4240 free (buff);
e60b52c6 4241
b5f303f0 4242 if (amount != bfd_coff_aoutsz (abfd))
b34976b6 4243 return FALSE;
05793179
NC		 4244
4245#ifdef COFF_IMAGE_WITH_PE
4246 if (! coff_apply_checksum (abfd))
b34976b6 4247 return FALSE;
05793179 4248#endif
252b5132
RH		 4249 }
4250#ifdef RS6000COFF_C
4251 else
4252 {
4253 AOUTHDR buff;
4254 size_t size;
4255
4256 /* XCOFF seems to always write at least a small a.out header. */
4257 coff_swap_aouthdr_out (abfd, (PTR) &internal_a, (PTR) &buff);
4258 if (xcoff_data (abfd)->full_aouthdr)
6b3b007b 4259 size = bfd_coff_aoutsz (abfd);
252b5132
RH		 4260 else
4261 size = SMALL_AOUTSZ;
dc810e39 4262 if (bfd_bwrite ((PTR) &buff, (bfd_size_type) size, abfd) != size)
b34976b6 4263 return FALSE;
252b5132
RH		 4264 }
4265#endif
4266
b34976b6 4267 return TRUE;
252b5132
RH		 4268}
4269
b34976b6 4270static bfd_boolean
252b5132
RH		 4271coff_set_section_contents (abfd, section, location, offset, count)
4272 bfd * abfd;
4273 sec_ptr section;
0f867abe 4274 const PTR location;
252b5132
RH		 4275 file_ptr offset;
4276 bfd_size_type count;
4277{
ed781d5d 4278 if (! abfd->output_has_begun) /* Set by bfd.c handler. */
252b5132
RH		 4279 {
4280 if (! coff_compute_section_file_positions (abfd))
b34976b6 4281 return FALSE;
252b5132
RH		 4282 }
4283
4284#if defined(_LIB) && !defined(TARG_AUX)
4285
4286 /* The physical address field of a .lib section is used to hold the
4287 number of shared libraries in the section. This code counts the
4288 number of sections being written, and increments the lma field
4289 with the number.
4290
4291 I have found no documentation on the contents of this section.
4292 Experimentation indicates that the section contains zero or more
4293 records, each of which has the following structure:
4294
4295 - a (four byte) word holding the length of this record, in words,
4296 - a word that always seems to be set to "2",
4297 - the path to a shared library, null-terminated and then padded
4298 to a whole word boundary.
4299
4300 bfd_assert calls have been added to alert if an attempt is made
4301 to write a section which doesn't follow these assumptions. The
4302 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4303 <robertl@arnet.com> (Thanks!).
e60b52c6 4304
ed781d5d 4305 Gvran Uddeborg <gvran@uddeborg.pp.se>. */
252b5132
RH		 4306
4307 if (strcmp (section->name, _LIB) == 0)
4308 {
4309 bfd_byte *rec, *recend;
4310
4311 rec = (bfd_byte *) location;
4312 recend = rec + count;
4313 while (rec < recend)
4314 {
4315 ++section->lma;
4316 rec += bfd_get_32 (abfd, rec) * 4;
4317 }
4318
4319 BFD_ASSERT (rec == recend);
4320 }
4321
4322#endif
4323
4324 /* Don't write out bss sections - one way to do this is to
e60b52c6 4325 see if the filepos has not been set. */
252b5132 4326 if (section->filepos == 0)
b34976b6 4327 return TRUE;
252b5132 4328
dc810e39 4329 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0)
b34976b6 4330 return FALSE;
252b5132 4331
dc810e39 4332 if (count == 0)
b34976b6 4333 return TRUE;
dc810e39
AM		 4334
4335 return bfd_bwrite (location, count, abfd) == count;
252b5132
RH		 4336}
4337#if 0
b34976b6 4338static bfd_boolean
252b5132
RH		 4339coff_close_and_cleanup (abfd)
4340 bfd *abfd;
4341{
4342 if (!bfd_read_p (abfd))
4343 switch (abfd->format)
4344 {
4345 case bfd_archive:
4346 if (!_bfd_write_archive_contents (abfd))
b34976b6 4347 return FALSE;
252b5132
RH		 4348 break;
4349 case bfd_object:
4350 if (!coff_write_object_contents (abfd))
b34976b6 4351 return FALSE;
252b5132
RH		 4352 break;
4353 default:
4354 bfd_set_error (bfd_error_invalid_operation);
b34976b6 4355 return FALSE;
252b5132
RH		 4356 }
4357
4358 /* We depend on bfd_close to free all the memory on the objalloc. */
b34976b6 4359 return TRUE;
252b5132
RH		 4360}
4361
4362#endif
4363
4364static PTR
dc810e39 4365buy_and_read (abfd, where, size)
252b5132
RH		 4366 bfd *abfd;
4367 file_ptr where;
dc810e39 4368 bfd_size_type size;
252b5132
RH		 4369{
4370 PTR area = (PTR) bfd_alloc (abfd, size);
4371 if (!area)
4372 return (NULL);
dc810e39
AM		 4373 if (bfd_seek (abfd, where, SEEK_SET) != 0
4374 || bfd_bread (area, size, abfd) != size)
252b5132
RH		 4375 return (NULL);
4376 return (area);
4377} /* buy_and_read() */
4378
4379/*
4380SUBSUBSECTION
4381 Reading linenumbers
4382
4383 Creating the linenumber table is done by reading in the entire
4384 coff linenumber table, and creating another table for internal use.
4385
4386 A coff linenumber table is structured so that each function
4387 is marked as having a line number of 0. Each line within the
4388 function is an offset from the first line in the function. The
4389 base of the line number information for the table is stored in
4390 the symbol associated with the function.
4391
00692651
ILT		 4392 Note: The PE format uses line number 0 for a flag indicating a
4393 new source file.
4394
252b5132
RH		 4395 The information is copied from the external to the internal
4396 table, and each symbol which marks a function is marked by
4397 pointing its...
4398
4399 How does this work ?
4400
4401*/
4402
b34976b6 4403static bfd_boolean
252b5132
RH		 4404coff_slurp_line_table (abfd, asect)
4405 bfd *abfd;
4406 asection *asect;
4407{
4408 LINENO *native_lineno;
4409 alent *lineno_cache;
dc810e39 4410 bfd_size_type amt;
252b5132
RH		 4411
4412 BFD_ASSERT (asect->lineno == (alent *) NULL);
4413
dc810e39
AM		 4414 amt = (bfd_size_type) bfd_coff_linesz (abfd) * asect->lineno_count;
4415 native_lineno = (LINENO *) buy_and_read (abfd, asect->line_filepos, amt);
14abcef9
NC		 4416 if (native_lineno == NULL)
4417 {
4418 (*_bfd_error_handler)
4419 (_("%s: warning: line number table read failed"),
4420 bfd_archive_filename (abfd));
4421 return FALSE;
4422 }
dc810e39
AM		 4423 amt = ((bfd_size_type) asect->lineno_count + 1) * sizeof (alent);
4424 lineno_cache = (alent *) bfd_alloc (abfd, amt);
252b5132 4425 if (lineno_cache == NULL)
b34976b6 4426 return FALSE;
252b5132
RH		 4427 else
4428 {
4429 unsigned int counter = 0;
4430 alent *cache_ptr = lineno_cache;
4431 LINENO *src = native_lineno;
4432
4433 while (counter < asect->lineno_count)
4434 {
4435 struct internal_lineno dst;
ed781d5d 4436
7f6d05e8 4437 bfd_coff_swap_lineno_in (abfd, src, &dst);
252b5132
RH		 4438 cache_ptr->line_number = dst.l_lnno;
4439
4440 if (cache_ptr->line_number == 0)
4441 {
b34976b6 4442 bfd_boolean warned;
beb1bf64 4443 bfd_signed_vma symndx;
252b5132
RH		 4444 coff_symbol_type *sym;
4445
b34976b6 4446 warned = FALSE;
252b5132
RH		 4447 symndx = dst.l_addr.l_symndx;
4448 if (symndx < 0
beb1bf64 4449 || (bfd_vma) symndx >= obj_raw_syment_count (abfd))
252b5132
RH		 4450 {
4451 (*_bfd_error_handler)
4452 (_("%s: warning: illegal symbol index %ld in line numbers"),
8f615d07 4453 bfd_archive_filename (abfd), dst.l_addr.l_symndx);
252b5132 4454 symndx = 0;
b34976b6 4455 warned = TRUE;
252b5132
RH		 4456 }
4457 /* FIXME: We should not be casting between ints and
4458 pointers like this. */
4459 sym = ((coff_symbol_type *)
4460 ((symndx + obj_raw_syments (abfd))
4461 ->u.syment._n._n_n._n_zeroes));
4462 cache_ptr->u.sym = (asymbol *) sym;
4463 if (sym->lineno != NULL && ! warned)
4464 {
4465 (*_bfd_error_handler)
4466 (_("%s: warning: duplicate line number information for `%s'"),
8f615d07 4467 bfd_archive_filename (abfd),
252b5132
RH		 4468 bfd_asymbol_name (&sym->symbol));
4469 }
4470 sym->lineno = cache_ptr;
4471 }
4472 else
4473 {
4474 cache_ptr->u.offset = dst.l_addr.l_paddr
4475 - bfd_section_vma (abfd, asect);
4476 } /* If no linenumber expect a symbol index */
4477
4478 cache_ptr++;
4479 src++;
4480 counter++;
4481 }
4482 cache_ptr->line_number = 0;
4483
4484 }
4485 asect->lineno = lineno_cache;
e60b52c6 4486 /* FIXME, free native_lineno here, or use alloca or something. */
b34976b6 4487 return TRUE;
252b5132
RH		 4488}
4489
00692651
ILT		 4490/* Slurp in the symbol table, converting it to generic form. Note
4491 that if coff_relocate_section is defined, the linker will read
4492 symbols via coff_link_add_symbols, rather than via this routine. */
4493
b34976b6 4494static bfd_boolean
252b5132
RH		 4495coff_slurp_symbol_table (abfd)
4496 bfd * abfd;
4497{
4498 combined_entry_type *native_symbols;
4499 coff_symbol_type *cached_area;
4500 unsigned int *table_ptr;
dc810e39 4501 bfd_size_type amt;
252b5132
RH		 4502 unsigned int number_of_symbols = 0;
4503
4504 if (obj_symbols (abfd))
b34976b6 4505 return TRUE;
252b5132 4506
ed781d5d 4507 /* Read in the symbol table. */
252b5132 4508 if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL)
ed781d5d 4509 return FALSE;
252b5132 4510
ed781d5d 4511 /* Allocate enough room for all the symbols in cached form. */
dc810e39
AM		 4512 amt = obj_raw_syment_count (abfd);
4513 amt *= sizeof (coff_symbol_type);
4514 cached_area = (coff_symbol_type *) bfd_alloc (abfd, amt);
252b5132 4515 if (cached_area == NULL)
b34976b6 4516 return FALSE;
dc810e39
AM		 4517
4518 amt = obj_raw_syment_count (abfd);
4519 amt *= sizeof (unsigned int);
4520 table_ptr = (unsigned int *) bfd_alloc (abfd, amt);
252b5132
RH		 4521
4522 if (table_ptr == NULL)
b34976b6 4523 return FALSE;
252b5132
RH		 4524 else
4525 {
4526 coff_symbol_type *dst = cached_area;
4527 unsigned int last_native_index = obj_raw_syment_count (abfd);
4528 unsigned int this_index = 0;
ed781d5d 4529
252b5132
RH		 4530 while (this_index < last_native_index)
4531 {
4532 combined_entry_type *src = native_symbols + this_index;
4533 table_ptr[this_index] = number_of_symbols;
4534 dst->symbol.the_bfd = abfd;
4535
4536 dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset);
4537 /* We use the native name field to point to the cached field. */
4538 src->u.syment._n._n_n._n_zeroes = (long) dst;
4539 dst->symbol.section = coff_section_from_bfd_index (abfd,
4540 src->u.syment.n_scnum);
4541 dst->symbol.flags = 0;
b34976b6 4542 dst->done_lineno = FALSE;
252b5132
RH		 4543
4544 switch (src->u.syment.n_sclass)
4545 {
4546#ifdef I960
4547 case C_LEAFEXT:
4548#if 0
4549 dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
4550 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
4551 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4552#endif
ed781d5d 4553 /* Fall through to next case. */
252b5132
RH		 4554#endif
4555
4556 case C_EXT:
4557 case C_WEAKEXT:
4558#if defined ARM
4559 case C_THUMBEXT:
4560 case C_THUMBEXTFUNC:
4561#endif
4562#ifdef RS6000COFF_C
4563 case C_HIDEXT:
4564#endif
4565#ifdef C_SYSTEM
ed781d5d 4566 case C_SYSTEM: /* System Wide variable. */
252b5132
RH		 4567#endif
4568#ifdef COFF_WITH_PE
ed781d5d 4569 /* In PE, 0x68 (104) denotes a section symbol. */
252b5132 4570 case C_SECTION:
5d54c628 4571 /* In PE, 0x69 (105) denotes a weak external symbol. */
252b5132
RH		 4572 case C_NT_WEAK:
4573#endif
5d54c628 4574 switch (coff_classify_symbol (abfd, &src->u.syment))
252b5132 4575 {
5d54c628 4576 case COFF_SYMBOL_GLOBAL:
252b5132 4577 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
252b5132
RH		 4578#if defined COFF_WITH_PE
4579 /* PE sets the symbol to a value relative to the
4580 start of the section. */
4581 dst->symbol.value = src->u.syment.n_value;
4582#else
4583 dst->symbol.value = (src->u.syment.n_value
4584 - dst->symbol.section->vma);
4585#endif
252b5132
RH		 4586 if (ISFCN ((src->u.syment.n_type)))
4587 {
4588 /* A function ext does not go at the end of a
4589 file. */
4590 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4591 }
5d54c628
ILT		 4592 break;
4593
4594 case COFF_SYMBOL_COMMON:
4595 dst->symbol.section = bfd_com_section_ptr;
4596 dst->symbol.value = src->u.syment.n_value;
4597 break;
4598
4599 case COFF_SYMBOL_UNDEFINED:
4600 dst->symbol.section = bfd_und_section_ptr;
4601 dst->symbol.value = 0;
e60b52c6 4602 break;
5d54c628
ILT		 4603
4604 case COFF_SYMBOL_PE_SECTION:
4605 dst->symbol.flags |= BSF_EXPORT | BSF_SECTION_SYM;
4606 dst->symbol.value = 0;
4607 break;
4608
4609 case COFF_SYMBOL_LOCAL:
4610 dst->symbol.flags = BSF_LOCAL;
4611#if defined COFF_WITH_PE
4612 /* PE sets the symbol to a value relative to the
4613 start of the section. */
4614 dst->symbol.value = src->u.syment.n_value;
4615#else
4616 dst->symbol.value = (src->u.syment.n_value
4617 - dst->symbol.section->vma);
4618#endif
4619 if (ISFCN ((src->u.syment.n_type)))
4620 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4621 break;
252b5132
RH		 4622 }
4623
4624#ifdef RS6000COFF_C
252b5132
RH		 4625 /* A symbol with a csect entry should not go at the end. */
4626 if (src->u.syment.n_numaux > 0)
4627 dst->symbol.flags |= BSF_NOT_AT_END;
4628#endif
4629
4630#ifdef COFF_WITH_PE
4631 if (src->u.syment.n_sclass == C_NT_WEAK)
a181be0a
NC		 4632 dst->symbol.flags |= BSF_WEAK;
4633
ec0ef80e
DD		 4634 if (src->u.syment.n_sclass == C_SECTION
4635 && src->u.syment.n_scnum > 0)
eb1e0e80 4636 dst->symbol.flags = BSF_LOCAL;
252b5132 4637#endif
252b5132 4638 if (src->u.syment.n_sclass == C_WEAKEXT)
a181be0a 4639 dst->symbol.flags |= BSF_WEAK;
252b5132
RH		 4640
4641 break;
4642
ed781d5d 4643 case C_STAT: /* Static. */
252b5132 4644#ifdef I960
ed781d5d 4645 case C_LEAFSTAT: /* Static leaf procedure. */
252b5132 4646#endif
e60b52c6 4647#if defined ARM
ed781d5d
NC		 4648 case C_THUMBSTAT: /* Thumb static. */
4649 case C_THUMBLABEL: /* Thumb label. */
4650 case C_THUMBSTATFUNC:/* Thumb static function. */
252b5132 4651#endif
ed781d5d 4652 case C_LABEL: /* Label. */
00692651 4653 if (src->u.syment.n_scnum == N_DEBUG)
252b5132
RH		 4654 dst->symbol.flags = BSF_DEBUGGING;
4655 else
4656 dst->symbol.flags = BSF_LOCAL;
4657
4658 /* Base the value as an index from the base of the
4659 section, if there is one. */
4660 if (dst->symbol.section)
4661 {
4662#if defined COFF_WITH_PE
4663 /* PE sets the symbol to a value relative to the
4664 start of the section. */
4665 dst->symbol.value = src->u.syment.n_value;
4666#else
4667 dst->symbol.value = (src->u.syment.n_value
4668 - dst->symbol.section->vma);
4669#endif
4670 }
4671 else
4672 dst->symbol.value = src->u.syment.n_value;
4673 break;
4674
ed781d5d
NC		 4675 case C_MOS: /* Member of structure. */
4676 case C_EOS: /* End of structure. */
4677#ifdef NOTDEF /* C_AUTOARG has the same value. */
252b5132 4678#ifdef C_GLBLREG
ed781d5d 4679 case C_GLBLREG: /* A29k-specific storage class. */
252b5132
RH		 4680#endif
4681#endif
ed781d5d
NC		 4682 case C_REGPARM: /* Register parameter. */
4683 case C_REG: /* register variable. */
4684 /* C_AUTOARG conflictes with TI COFF C_UEXT. */
81635ce4 4685#if !defined (TIC80COFF) && !defined (TICOFF)
252b5132 4686#ifdef C_AUTOARG
ed781d5d 4687 case C_AUTOARG: /* 960-specific storage class. */
252b5132
RH		 4688#endif
4689#endif
ed781d5d 4690 case C_TPDEF: /* Type definition. */
252b5132 4691 case C_ARG:
ed781d5d
NC		 4692 case C_AUTO: /* Automatic variable. */
4693 case C_FIELD: /* Bit field. */
4694 case C_ENTAG: /* Enumeration tag. */
4695 case C_MOE: /* Member of enumeration. */
4696 case C_MOU: /* Member of union. */
4697 case C_UNTAG: /* Union tag. */
252b5132
RH		 4698 dst->symbol.flags = BSF_DEBUGGING;
4699 dst->symbol.value = (src->u.syment.n_value);
4700 break;
4701
ed781d5d
NC		 4702 case C_FILE: /* File name. */
4703 case C_STRTAG: /* Structure tag. */
252b5132
RH		 4704#ifdef RS6000COFF_C
4705 case C_GSYM:
4706 case C_LSYM:
4707 case C_PSYM:
4708 case C_RSYM:
4709 case C_RPSYM:
4710 case C_STSYM:
f9f3cf65 4711 case C_TCSYM:
252b5132 4712 case C_BCOMM:
f9f3cf65 4713 case C_ECOML:
252b5132
RH		 4714 case C_ECOMM:
4715 case C_DECL:
4716 case C_ENTRY:
4717 case C_FUN:
4718 case C_ESTAT:
4719#endif
4720 dst->symbol.flags = BSF_DEBUGGING;
4721 dst->symbol.value = (src->u.syment.n_value);
4722 break;
4723
4724#ifdef RS6000COFF_C
ed781d5d
NC		 4725 case C_BINCL: /* Beginning of include file. */
4726 case C_EINCL: /* Ending of include file. */
252b5132
RH		 4727 /* The value is actually a pointer into the line numbers
4728 of the file. We locate the line number entry, and
4729 set the section to the section which contains it, and
4730 the value to the index in that section. */
4731 {
4732 asection *sec;
4733
4734 dst->symbol.flags = BSF_DEBUGGING;
4735 for (sec = abfd->sections; sec != NULL; sec = sec->next)
4736 if (sec->line_filepos <= (file_ptr) src->u.syment.n_value
4737 && ((file_ptr) (sec->line_filepos
6b3b007b 4738 + sec->lineno_count * bfd_coff_linesz (abfd))
252b5132
RH		 4739 > (file_ptr) src->u.syment.n_value))
4740 break;
4741 if (sec == NULL)
4742 dst->symbol.value = 0;
4743 else
4744 {
4745 dst->symbol.section = sec;
4746 dst->symbol.value = ((src->u.syment.n_value
4747 - sec->line_filepos)
6b3b007b 4748 / bfd_coff_linesz (abfd));
252b5132
RH		 4749 src->fix_line = 1;
4750 }
4751 }
4752 break;
4753
4754 case C_BSTAT:
4755 dst->symbol.flags = BSF_DEBUGGING;
4756
4757 /* The value is actually a symbol index. Save a pointer
4758 to the symbol instead of the index. FIXME: This
4759 should use a union. */
4760 src->u.syment.n_value =
4761 (long) (native_symbols + src->u.syment.n_value);
4762 dst->symbol.value = src->u.syment.n_value;
4763 src->fix_value = 1;
4764 break;
4765#endif
4766
ed781d5d
NC		 4767 case C_BLOCK: /* ".bb" or ".eb". */
4768 case C_FCN: /* ".bf" or ".ef" (or PE ".lf"). */
4769 case C_EFCN: /* Physical end of function. */
252b5132
RH		 4770#if defined COFF_WITH_PE
4771 /* PE sets the symbol to a value relative to the start
4772 of the section. */
4773 dst->symbol.value = src->u.syment.n_value;
d510f9a6
ILT		 4774 if (strcmp (dst->symbol.name, ".bf") != 0)
4775 {
4776 /* PE uses funny values for .ef and .lf; don't
4777 relocate them. */
4778 dst->symbol.flags = BSF_DEBUGGING;
4779 }
4780 else
4781 dst->symbol.flags = BSF_DEBUGGING | BSF_DEBUGGING_RELOC;
252b5132
RH		 4782#else
4783 /* Base the value as an index from the base of the
4784 section. */
d510f9a6 4785 dst->symbol.flags = BSF_LOCAL;
252b5132
RH		 4786 dst->symbol.value = (src->u.syment.n_value
4787 - dst->symbol.section->vma);
4788#endif
4789 break;
4790
ed781d5d 4791 case C_STATLAB: /* Static load time label. */
34cbe64e
TW		 4792 dst->symbol.value = src->u.syment.n_value;
4793 dst->symbol.flags = BSF_GLOBAL;
4794 break;
4795
252b5132 4796 case C_NULL:
00692651
ILT		 4797 /* PE DLLs sometimes have zeroed out symbols for some
4798 reason. Just ignore them without a warning. */
4799 if (src->u.syment.n_type == 0
4800 && src->u.syment.n_value == 0
4801 && src->u.syment.n_scnum == 0)
4802 break;
4803 /* Fall through. */
ed781d5d
NC		 4804 case C_EXTDEF: /* External definition. */
4805 case C_ULABEL: /* Undefined label. */
4806 case C_USTATIC: /* Undefined static. */
252b5132
RH		 4807#ifndef COFF_WITH_PE
4808 /* C_LINE in regular coff is 0x68. NT has taken over this storage
ed781d5d
NC		 4809 class to represent a section symbol. */
4810 case C_LINE: /* line # reformatted as symbol table entry. */
252b5132 4811 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
ed781d5d 4812 case C_ALIAS: /* Duplicate tag. */
252b5132 4813#endif
ed781d5d 4814 /* New storage classes for TI COFF. */
81635ce4 4815#if defined(TIC80COFF) || defined(TICOFF)
ed781d5d 4816 case C_UEXT: /* Tentative external definition. */
252b5132 4817#endif
ed781d5d
NC		 4818 case C_EXTLAB: /* External load time label. */
4819 case C_HIDDEN: /* Ext symbol in dmert public lib. */
252b5132
RH		 4820 default:
4821 (*_bfd_error_handler)
4822 (_("%s: Unrecognized storage class %d for %s symbol `%s'"),
8f615d07 4823 bfd_archive_filename (abfd), src->u.syment.n_sclass,
252b5132
RH		 4824 dst->symbol.section->name, dst->symbol.name);
4825 dst->symbol.flags = BSF_DEBUGGING;
4826 dst->symbol.value = (src->u.syment.n_value);
4827 break;
4828 }
4829
4830/* BFD_ASSERT(dst->symbol.flags != 0);*/
4831
4832 dst->native = src;
4833
4834 dst->symbol.udata.i = 0;
4835 dst->lineno = (alent *) NULL;
4836 this_index += (src->u.syment.n_numaux) + 1;
4837 dst++;
4838 number_of_symbols++;
ed781d5d
NC		 4839 }
4840 }
252b5132
RH		 4841
4842 obj_symbols (abfd) = cached_area;
4843 obj_raw_syments (abfd) = native_symbols;
4844
4845 bfd_get_symcount (abfd) = number_of_symbols;
4846 obj_convert (abfd) = table_ptr;
ed781d5d 4847 /* Slurp the line tables for each section too. */
252b5132
RH		 4848 {
4849 asection *p;
ed781d5d 4850
252b5132
RH		 4851 p = abfd->sections;
4852 while (p)
4853 {
4854 coff_slurp_line_table (abfd, p);
4855 p = p->next;
4856 }
4857 }
ed781d5d 4858
b34976b6 4859 return TRUE;
252b5132
RH		 4860} /* coff_slurp_symbol_table() */
4861
5d54c628
ILT		 4862/* Classify a COFF symbol. A couple of targets have globally visible
4863 symbols which are not class C_EXT, and this handles those. It also
4864 recognizes some special PE cases. */
252b5132 4865
5d54c628
ILT		 4866static enum coff_symbol_classification
4867coff_classify_symbol (abfd, syment)
4868 bfd *abfd;
4869 struct internal_syment *syment;
4870{
4871 /* FIXME: This partially duplicates the switch in
4872 coff_slurp_symbol_table. */
4873 switch (syment->n_sclass)
4874 {
4875 case C_EXT:
4876 case C_WEAKEXT:
252b5132 4877#ifdef I960
5d54c628 4878 case C_LEAFEXT:
252b5132 4879#endif
5d54c628
ILT		 4880#ifdef ARM
4881 case C_THUMBEXT:
4882 case C_THUMBEXTFUNC:
252b5132 4883#endif
5d54c628
ILT		 4884#ifdef C_SYSTEM
4885 case C_SYSTEM:
252b5132 4886#endif
5d54c628
ILT		 4887#ifdef COFF_WITH_PE
4888 case C_NT_WEAK:
4889#endif
4890 if (syment->n_scnum == 0)
4891 {
4892 if (syment->n_value == 0)
4893 return COFF_SYMBOL_UNDEFINED;
4894 else
4895 return COFF_SYMBOL_COMMON;
4896 }
4897 return COFF_SYMBOL_GLOBAL;
4898
4899 default:
4900 break;
4901 }
252b5132 4902
5d54c628
ILT		 4903#ifdef COFF_WITH_PE
4904 if (syment->n_sclass == C_STAT)
4905 {
4906 if (syment->n_scnum == 0)
4907 {
4908 /* The Microsoft compiler sometimes generates these if a
4909 small static function is inlined every time it is used.
4910 The function is discarded, but the symbol table entry
4911 remains. */
4912 return COFF_SYMBOL_LOCAL;
4913 }
252b5132 4914
0717ebb7 4915#ifdef STRICT_PE_FORMAT
bd826630
ILT		 4916 /* This is correct for Microsoft generated objects, but it
4917 breaks gas generated objects. */
4918
5d54c628
ILT		 4919 if (syment->n_value == 0)
4920 {
4921 asection *sec;
4922 char buf[SYMNMLEN + 1];
4923
4924 sec = coff_section_from_bfd_index (abfd, syment->n_scnum);
4925 if (sec != NULL
4926 && (strcmp (bfd_get_section_name (abfd, sec),
4927 _bfd_coff_internal_syment_name (abfd, syment, buf))
4928 == 0))
4929 return COFF_SYMBOL_PE_SECTION;
4930 }
bd826630 4931#endif
252b5132 4932
5d54c628
ILT		 4933 return COFF_SYMBOL_LOCAL;
4934 }
252b5132 4935
5d54c628
ILT		 4936 if (syment->n_sclass == C_SECTION)
4937 {
4938 /* In some cases in a DLL generated by the Microsoft linker, the
4939 n_value field will contain garbage. FIXME: This should
4940 probably be handled by the swapping function instead. */
4941 syment->n_value = 0;
4942 if (syment->n_scnum == 0)
4943 return COFF_SYMBOL_UNDEFINED;
4944 return COFF_SYMBOL_PE_SECTION;
4945 }
4946#endif /* COFF_WITH_PE */
252b5132 4947
5d54c628 4948 /* If it is not a global symbol, we presume it is a local symbol. */
252b5132 4949
5d54c628
ILT		 4950 if (syment->n_scnum == 0)
4951 {
4952 char buf[SYMNMLEN + 1];
252b5132 4953
5d54c628
ILT		 4954 (*_bfd_error_handler)
4955 (_("warning: %s: local symbol `%s' has no section"),
8f615d07 4956 bfd_archive_filename (abfd),
5d54c628
ILT		 4957 _bfd_coff_internal_syment_name (abfd, syment, buf));
4958 }
252b5132 4959
5d54c628
ILT		 4960 return COFF_SYMBOL_LOCAL;
4961}
252b5132
RH		 4962
4963/*
4964SUBSUBSECTION
4965 Reading relocations
4966
4967 Coff relocations are easily transformed into the internal BFD form
4968 (@code{arelent}).
4969
4970 Reading a coff relocation table is done in the following stages:
4971
4972 o Read the entire coff relocation table into memory.
4973
4974 o Process each relocation in turn; first swap it from the
4975 external to the internal form.
4976
4977 o Turn the symbol referenced in the relocation's symbol index
4978 into a pointer into the canonical symbol table.
4979 This table is the same as the one returned by a call to
4980 @code{bfd_canonicalize_symtab}. The back end will call that
4981 routine and save the result if a canonicalization hasn't been done.
4982
4983 o The reloc index is turned into a pointer to a howto
4984 structure, in a back end specific way. For instance, the 386
4985 and 960 use the @code{r_type} to directly produce an index
4986 into a howto table vector; the 88k subtracts a number from the
4987 @code{r_type} field and creates an addend field.
4988
252b5132
RH		 4989*/
4990
4991#ifndef CALC_ADDEND
4992#define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
4993 { \
4994 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \
4995 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
4996 coffsym = (obj_symbols (abfd) \
4997 + (cache_ptr->sym_ptr_ptr - symbols)); \
4998 else if (ptr) \
4999 coffsym = coff_symbol_from (abfd, ptr); \
5000 if (coffsym != (coff_symbol_type *) NULL \
5001 && coffsym->native->u.syment.n_scnum == 0) \
5002 cache_ptr->addend = 0; \
5003 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
5004 && ptr->section != (asection *) NULL) \
5005 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
5006 else \
5007 cache_ptr->addend = 0; \
5008 }
5009#endif
5010
b34976b6 5011static bfd_boolean
252b5132
RH		 5012coff_slurp_reloc_table (abfd, asect, symbols)
5013 bfd * abfd;
5014 sec_ptr asect;
5015 asymbol ** symbols;
5016{
5017 RELOC *native_relocs;
5018 arelent *reloc_cache;
5019 arelent *cache_ptr;
252b5132 5020 unsigned int idx;
dc810e39 5021 bfd_size_type amt;
252b5132
RH		 5022
5023 if (asect->relocation)
b34976b6 5024 return TRUE;
252b5132 5025 if (asect->reloc_count == 0)
b34976b6 5026 return TRUE;
252b5132 5027 if (asect->flags & SEC_CONSTRUCTOR)
b34976b6 5028 return TRUE;
252b5132 5029 if (!coff_slurp_symbol_table (abfd))
b34976b6 5030 return FALSE;
dc810e39
AM		 5031 amt = (bfd_size_type) bfd_coff_relsz (abfd) * asect->reloc_count;
5032 native_relocs = (RELOC *) buy_and_read (abfd, asect->rel_filepos, amt);
5033 amt = (bfd_size_type) asect->reloc_count * sizeof (arelent);
5034 reloc_cache = (arelent *) bfd_alloc (abfd, amt);
252b5132
RH		 5035
5036 if (reloc_cache == NULL)
b34976b6 5037 return FALSE;
252b5132 5038
252b5132
RH		 5039 for (idx = 0; idx < asect->reloc_count; idx++)
5040 {
5041 struct internal_reloc dst;
5042 struct external_reloc *src;
5043#ifndef RELOC_PROCESSING
5044 asymbol *ptr;
5045#endif
5046
5047 cache_ptr = reloc_cache + idx;
5048 src = native_relocs + idx;
5049
5050 coff_swap_reloc_in (abfd, src, &dst);
5051
5052#ifdef RELOC_PROCESSING
5053 RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
5054#else
5055 cache_ptr->address = dst.r_vaddr;
5056
5057 if (dst.r_symndx != -1)
5058 {
5059 if (dst.r_symndx < 0 || dst.r_symndx >= obj_conv_table_size (abfd))
5060 {
5061 (*_bfd_error_handler)
5062 (_("%s: warning: illegal symbol index %ld in relocs"),
8f615d07 5063 bfd_archive_filename (abfd), dst.r_symndx);
252b5132
RH		 5064 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
5065 ptr = NULL;
5066 }
5067 else
5068 {
5069 cache_ptr->sym_ptr_ptr = (symbols
5070 + obj_convert (abfd)[dst.r_symndx]);
5071 ptr = *(cache_ptr->sym_ptr_ptr);
5072 }
5073 }
5074 else
5075 {
5076 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
5077 ptr = NULL;
5078 }
5079
5080 /* The symbols definitions that we have read in have been
5081 relocated as if their sections started at 0. But the offsets
5082 refering to the symbols in the raw data have not been
5083 modified, so we have to have a negative addend to compensate.
5084
ed781d5d 5085 Note that symbols which used to be common must be left alone. */
252b5132 5086
ed781d5d 5087 /* Calculate any reloc addend by looking at the symbol. */
252b5132
RH		 5088 CALC_ADDEND (abfd, ptr, dst, cache_ptr);
5089
5090 cache_ptr->address -= asect->vma;
5091/* !! cache_ptr->section = (asection *) NULL;*/
5092
ed781d5d 5093 /* Fill in the cache_ptr->howto field from dst.r_type. */
252b5132
RH		 5094 RTYPE2HOWTO (cache_ptr, &dst);
5095#endif /* RELOC_PROCESSING */
5096
5097 if (cache_ptr->howto == NULL)
5098 {
5099 (*_bfd_error_handler)
5100 (_("%s: illegal relocation type %d at address 0x%lx"),
8f615d07 5101 bfd_archive_filename (abfd), dst.r_type, (long) dst.r_vaddr);
252b5132 5102 bfd_set_error (bfd_error_bad_value);
b34976b6 5103 return FALSE;
252b5132
RH		 5104 }
5105 }
5106
5107 asect->relocation = reloc_cache;
b34976b6 5108 return TRUE;
252b5132
RH		 5109}
5110
5111#ifndef coff_rtype_to_howto
5112#ifdef RTYPE2HOWTO
5113
5114/* Get the howto structure for a reloc. This is only used if the file
5115 including this one defines coff_relocate_section to be
5116 _bfd_coff_generic_relocate_section, so it is OK if it does not
5117 always work. It is the responsibility of the including file to
5118 make sure it is reasonable if it is needed. */
5119
5120static reloc_howto_type *coff_rtype_to_howto
5121 PARAMS ((bfd *, asection *, struct internal_reloc *,
5122 struct coff_link_hash_entry *, struct internal_syment *,
5123 bfd_vma *));
5124
5125/*ARGSUSED*/
5126static reloc_howto_type *
5127coff_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
5f771d47
ILT		 5128 bfd *abfd ATTRIBUTE_UNUSED;
5129 asection *sec ATTRIBUTE_UNUSED;
252b5132 5130 struct internal_reloc *rel;
5f771d47
ILT		 5131 struct coff_link_hash_entry *h ATTRIBUTE_UNUSED;
5132 struct internal_syment *sym ATTRIBUTE_UNUSED;
5133 bfd_vma *addendp ATTRIBUTE_UNUSED;
252b5132
RH		 5134{
5135 arelent genrel;
5136
5137 RTYPE2HOWTO (&genrel, rel);
5138 return genrel.howto;
5139}
5140
5141#else /* ! defined (RTYPE2HOWTO) */
5142
5143#define coff_rtype_to_howto NULL
5144
5145#endif /* ! defined (RTYPE2HOWTO) */
5146#endif /* ! defined (coff_rtype_to_howto) */
5147
5148/* This is stupid. This function should be a boolean predicate. */
5149static long
5150coff_canonicalize_reloc (abfd, section, relptr, symbols)
5151 bfd * abfd;
5152 sec_ptr section;
5153 arelent ** relptr;
5154 asymbol ** symbols;
5155{
5156 arelent *tblptr = section->relocation;
5157 unsigned int count = 0;
5158
252b5132
RH		 5159 if (section->flags & SEC_CONSTRUCTOR)
5160 {
ed781d5d
NC		 5161 /* This section has relocs made up by us, they are not in the
5162 file, so take them out of their chain and place them into
5163 the data area provided. */
252b5132 5164 arelent_chain *chain = section->constructor_chain;
ed781d5d 5165
252b5132
RH		 5166 for (count = 0; count < section->reloc_count; count++)
5167 {
5168 *relptr++ = &chain->relent;
5169 chain = chain->next;
5170 }
252b5132
RH		 5171 }
5172 else
5173 {
5174 if (! coff_slurp_reloc_table (abfd, section, symbols))
5175 return -1;
5176
5177 tblptr = section->relocation;
5178
5179 for (; count++ < section->reloc_count;)
5180 *relptr++ = tblptr++;
252b5132
RH		 5181 }
5182 *relptr = 0;
5183 return section->reloc_count;
5184}
5185
5186#ifdef GNU960
5187file_ptr
5188coff_sym_filepos (abfd)
5189 bfd *abfd;
5190{
5191 return obj_sym_filepos (abfd);
5192}
5193#endif
5194
5195#ifndef coff_reloc16_estimate
5196#define coff_reloc16_estimate dummy_reloc16_estimate
5197
5198static int dummy_reloc16_estimate
5199 PARAMS ((bfd *, asection *, arelent *, unsigned int,
5200 struct bfd_link_info *));
5201
5202static int
5203dummy_reloc16_estimate (abfd, input_section, reloc, shrink, link_info)
5f771d47
ILT		 5204 bfd *abfd ATTRIBUTE_UNUSED;
5205 asection *input_section ATTRIBUTE_UNUSED;
5206 arelent *reloc ATTRIBUTE_UNUSED;
5207 unsigned int shrink ATTRIBUTE_UNUSED;
5208 struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
252b5132
RH		 5209{
5210 abort ();
00692651 5211 return 0;
252b5132
RH		 5212}
5213
5214#endif
5215
5216#ifndef coff_reloc16_extra_cases
5217
5218#define coff_reloc16_extra_cases dummy_reloc16_extra_cases
5219
5220/* This works even if abort is not declared in any header file. */
5221
5222static void dummy_reloc16_extra_cases
5223 PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
5224 bfd_byte *, unsigned int *, unsigned int *));
5225
5226static void
5227dummy_reloc16_extra_cases (abfd, link_info, link_order, reloc, data, src_ptr,
5228 dst_ptr)
5f771d47
ILT		 5229 bfd *abfd ATTRIBUTE_UNUSED;
5230 struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
5231 struct bfd_link_order *link_order ATTRIBUTE_UNUSED;
5232 arelent *reloc ATTRIBUTE_UNUSED;
5233 bfd_byte *data ATTRIBUTE_UNUSED;
5234 unsigned int *src_ptr ATTRIBUTE_UNUSED;
5235 unsigned int *dst_ptr ATTRIBUTE_UNUSED;
252b5132
RH		 5236{
5237 abort ();
5238}
5239#endif
5240
e2d34d7d
DJ		 5241#ifndef coff_bfd_link_hash_table_free
5242#define coff_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
5243#endif
5244
252b5132
RH		 5245/* If coff_relocate_section is defined, we can use the optimized COFF
5246 backend linker. Otherwise we must continue to use the old linker. */
5247#ifdef coff_relocate_section
5248#ifndef coff_bfd_link_hash_table_create
5249#define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5250#endif
5251#ifndef coff_bfd_link_add_symbols
5252#define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5253#endif
5254#ifndef coff_bfd_final_link
5255#define coff_bfd_final_link _bfd_coff_final_link
5256#endif
5257#else /* ! defined (coff_relocate_section) */
5258#define coff_relocate_section NULL
5259#ifndef coff_bfd_link_hash_table_create
5260#define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5261#endif
5262#ifndef coff_bfd_link_add_symbols
5263#define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5264#endif
5265#define coff_bfd_final_link _bfd_generic_final_link
5266#endif /* ! defined (coff_relocate_section) */
5267
2d653fc7 5268#define coff_bfd_link_just_syms _bfd_generic_link_just_syms
252b5132
RH		 5269#define coff_bfd_link_split_section _bfd_generic_link_split_section
5270
5271#ifndef coff_start_final_link
5272#define coff_start_final_link NULL
5273#endif
5274
5275#ifndef coff_adjust_symndx
5276#define coff_adjust_symndx NULL
5277#endif
5278
5279#ifndef coff_link_add_one_symbol
5280#define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5281#endif
5282
5283#ifndef coff_link_output_has_begun
5284
b34976b6 5285static bfd_boolean coff_link_output_has_begun
252b5132
RH		 5286 PARAMS ((bfd *, struct coff_final_link_info *));
5287
b34976b6 5288static bfd_boolean
252b5132
RH		 5289coff_link_output_has_begun (abfd, info)
5290 bfd * abfd;
5f771d47 5291 struct coff_final_link_info * info ATTRIBUTE_UNUSED;
252b5132
RH		 5292{
5293 return abfd->output_has_begun;
5294}
5295#endif
5296
5297#ifndef coff_final_link_postscript
5298
b34976b6 5299static bfd_boolean coff_final_link_postscript
252b5132
RH		 5300 PARAMS ((bfd *, struct coff_final_link_info *));
5301
b34976b6 5302static bfd_boolean
252b5132 5303coff_final_link_postscript (abfd, pfinfo)
5f771d47
ILT		 5304 bfd * abfd ATTRIBUTE_UNUSED;
5305 struct coff_final_link_info * pfinfo ATTRIBUTE_UNUSED;
252b5132 5306{
b34976b6 5307 return TRUE;
252b5132
RH		 5308}
5309#endif
5310
5311#ifndef coff_SWAP_aux_in
5312#define coff_SWAP_aux_in coff_swap_aux_in
5313#endif
5314#ifndef coff_SWAP_sym_in
5315#define coff_SWAP_sym_in coff_swap_sym_in
5316#endif
5317#ifndef coff_SWAP_lineno_in
5318#define coff_SWAP_lineno_in coff_swap_lineno_in
5319#endif
5320#ifndef coff_SWAP_aux_out
5321#define coff_SWAP_aux_out coff_swap_aux_out
5322#endif
5323#ifndef coff_SWAP_sym_out
5324#define coff_SWAP_sym_out coff_swap_sym_out
5325#endif
5326#ifndef coff_SWAP_lineno_out
5327#define coff_SWAP_lineno_out coff_swap_lineno_out
5328#endif
5329#ifndef coff_SWAP_reloc_out
5330#define coff_SWAP_reloc_out coff_swap_reloc_out
5331#endif
5332#ifndef coff_SWAP_filehdr_out
5333#define coff_SWAP_filehdr_out coff_swap_filehdr_out
5334#endif
5335#ifndef coff_SWAP_aouthdr_out
5336#define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5337#endif
5338#ifndef coff_SWAP_scnhdr_out
5339#define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5340#endif
5341#ifndef coff_SWAP_reloc_in
5342#define coff_SWAP_reloc_in coff_swap_reloc_in
5343#endif
5344#ifndef coff_SWAP_filehdr_in
5345#define coff_SWAP_filehdr_in coff_swap_filehdr_in
5346#endif
5347#ifndef coff_SWAP_aouthdr_in
5348#define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5349#endif
5350#ifndef coff_SWAP_scnhdr_in
5351#define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5352#endif
5353
692b7d62 5354static const bfd_coff_backend_data bfd_coff_std_swap_table =
252b5132
RH		 5355{
5356 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5357 coff_SWAP_aux_out, coff_SWAP_sym_out,
5358 coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5359 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5360 coff_SWAP_scnhdr_out,
692b7d62 5361 FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
252b5132 5362#ifdef COFF_LONG_FILENAMES
b34976b6 5363 TRUE,
252b5132 5364#else
b34976b6 5365 FALSE,
252b5132
RH		 5366#endif
5367#ifdef COFF_LONG_SECTION_NAMES
b34976b6 5368 TRUE,
252b5132 5369#else
b34976b6 5370 FALSE,
252b5132 5371#endif
a022216b 5372 COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
7f6d05e8 5373#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
b34976b6 5374 TRUE,
7f6d05e8 5375#else
b34976b6 5376 FALSE,
7f6d05e8
CP		 5377#endif
5378#ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5379 4,
5380#else
5381 2,
5382#endif
252b5132
RH		 5383 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5384 coff_SWAP_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook,
5385 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5386 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5387 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5d54c628 5388 coff_classify_symbol, coff_compute_section_file_positions,
252b5132
RH		 5389 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5390 coff_adjust_symndx, coff_link_add_one_symbol,
5391 coff_link_output_has_begun, coff_final_link_postscript
5392};
5393
5a5b9651
SS		 5394#ifdef TICOFF
5395/* COFF0 differs in file/section header size and relocation entry size. */
5396static const bfd_coff_backend_data ticoff0_swap_table =
5397{
5398 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5399 coff_SWAP_aux_out, coff_SWAP_sym_out,
5400 coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5401 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5402 coff_SWAP_scnhdr_out,
5403 FILHSZ_V0, AOUTSZ, SCNHSZ_V01, SYMESZ, AUXESZ, RELSZ_V0, LINESZ, FILNMLEN,
5404#ifdef COFF_LONG_FILENAMES
5405 TRUE,
5406#else
5407 FALSE,
5408#endif
5409#ifdef COFF_LONG_SECTION_NAMES
5410 TRUE,
5411#else
5412 FALSE,
5413#endif
5414 COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5415#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5416 TRUE,
5417#else
5418 FALSE,
5419#endif
5420#ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5421 4,
5422#else
5423 2,
5424#endif
5425 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5426 coff_SWAP_reloc_in, ticoff0_bad_format_hook, coff_set_arch_mach_hook,
5427 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5428 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5429 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5430 coff_classify_symbol, coff_compute_section_file_positions,
5431 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5432 coff_adjust_symndx, coff_link_add_one_symbol,
5433 coff_link_output_has_begun, coff_final_link_postscript
5434};
5435#endif
5436
5437#ifdef TICOFF
5438/* COFF1 differs in section header size. */
5439static const bfd_coff_backend_data ticoff1_swap_table =
5440{
5441 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5442 coff_SWAP_aux_out, coff_SWAP_sym_out,
5443 coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5444 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5445 coff_SWAP_scnhdr_out,
5446 FILHSZ, AOUTSZ, SCNHSZ_V01, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
5447#ifdef COFF_LONG_FILENAMES
5448 TRUE,
5449#else
5450 FALSE,
5451#endif
5452#ifdef COFF_LONG_SECTION_NAMES
5453 TRUE,
5454#else
5455 FALSE,
5456#endif
5457 COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5458#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5459 TRUE,
5460#else
5461 FALSE,
5462#endif
5463#ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5464 4,
5465#else
5466 2,
5467#endif
5468 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5469 coff_SWAP_reloc_in, ticoff1_bad_format_hook, coff_set_arch_mach_hook,
5470 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5471 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5472 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5473 coff_classify_symbol, coff_compute_section_file_positions,
5474 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5475 coff_adjust_symndx, coff_link_add_one_symbol,
5476 coff_link_output_has_begun, coff_final_link_postscript
5477};
5478#endif
5479
252b5132
RH		 5480#ifndef coff_close_and_cleanup
5481#define coff_close_and_cleanup _bfd_generic_close_and_cleanup
5482#endif
5483
5484#ifndef coff_bfd_free_cached_info
5485#define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
5486#endif
5487
5488#ifndef coff_get_section_contents
5489#define coff_get_section_contents _bfd_generic_get_section_contents
5490#endif
5491
5492#ifndef coff_bfd_copy_private_symbol_data
5493#define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5494#endif
5495
5496#ifndef coff_bfd_copy_private_section_data
5497#define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5498#endif
5499
e60b52c6 5500#ifndef coff_bfd_copy_private_bfd_data
252b5132
RH		 5501#define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5502#endif
5503
5504#ifndef coff_bfd_merge_private_bfd_data
5505#define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5506#endif
5507
5508#ifndef coff_bfd_set_private_flags
5509#define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5510#endif
5511
e60b52c6 5512#ifndef coff_bfd_print_private_bfd_data
252b5132
RH		 5513#define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5514#endif
5515
5516#ifndef coff_bfd_is_local_label_name
5517#define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5518#endif
5519
5520#ifndef coff_read_minisymbols
5521#define coff_read_minisymbols _bfd_generic_read_minisymbols
5522#endif
5523
5524#ifndef coff_minisymbol_to_symbol
5525#define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5526#endif
5527
5528/* The reloc lookup routine must be supplied by each individual COFF
5529 backend. */
5530#ifndef coff_bfd_reloc_type_lookup
5531#define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5532#endif
5533
5534#ifndef coff_bfd_get_relocated_section_contents
5535#define coff_bfd_get_relocated_section_contents \
5536 bfd_generic_get_relocated_section_contents
5537#endif
5538
5539#ifndef coff_bfd_relax_section
5540#define coff_bfd_relax_section bfd_generic_relax_section
5541#endif
5542
5543#ifndef coff_bfd_gc_sections
5544#define coff_bfd_gc_sections bfd_generic_gc_sections
5545#endif
c3c89269 5546
8550eb6e
JJ		 5547#ifndef coff_bfd_merge_sections
5548#define coff_bfd_merge_sections bfd_generic_merge_sections
5549#endif
5550
e61463e1
AM		 5551#ifndef coff_bfd_discard_group
5552#define coff_bfd_discard_group bfd_generic_discard_group
5553#endif
5554
3fa78519 5555#define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
4c117b10
ILT		 5556const bfd_target VAR = \
5557{ \
5558 NAME , \
5559 bfd_target_coff_flavour, \
5560 BFD_ENDIAN_BIG, /* data byte order is big */ \
5561 BFD_ENDIAN_BIG, /* header byte order is big */ \
5562 /* object flags */ \
5563 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5564 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5565 /* section flags */ \
5566 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5567 UNDER, /* leading symbol underscore */ \
5568 '/', /* ar_pad_char */ \
5569 15, /* ar_max_namelen */ \
5570 \
5571 /* Data conversion functions. */ \
5572 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5573 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5574 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5575 \
5576 /* Header conversion functions. */ \
5577 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5578 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5579 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5580 \
5581 /* bfd_check_format */ \
5582 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5583 _bfd_dummy_target }, \
5584 /* bfd_set_format */ \
5585 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5586 /* bfd_write_contents */ \
5587 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5588 bfd_false }, \
5589 \
5590 BFD_JUMP_TABLE_GENERIC (coff), \
5591 BFD_JUMP_TABLE_COPY (coff), \
5592 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5593 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5594 BFD_JUMP_TABLE_SYMBOLS (coff), \
5595 BFD_JUMP_TABLE_RELOCS (coff), \
5596 BFD_JUMP_TABLE_WRITE (coff), \
5597 BFD_JUMP_TABLE_LINK (coff), \
5598 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5599 \
5600 ALTERNATIVE, \
5601 \
3fa78519 5602 SWAP_TABLE \
c3c89269
NC		 5603};
5604
3fa78519
SS		 5605#define CREATE_BIGHDR_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5606const bfd_target VAR = \
5607{ \
5608 NAME , \
5609 bfd_target_coff_flavour, \
5610 BFD_ENDIAN_LITTLE, /* data byte order is little */ \
5611 BFD_ENDIAN_BIG, /* header byte order is big */ \
5612 /* object flags */ \
5613 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5614 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5615 /* section flags */ \
5616 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5617 UNDER, /* leading symbol underscore */ \
5618 '/', /* ar_pad_char */ \
5619 15, /* ar_max_namelen */ \
5620 \
5621 /* Data conversion functions. */ \
5622 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5623 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5624 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5625 \
5626 /* Header conversion functions. */ \
5627 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5628 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5629 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5630 \
5631 /* bfd_check_format */ \
5632 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5633 _bfd_dummy_target }, \
5634 /* bfd_set_format */ \
5635 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5636 /* bfd_write_contents */ \
5637 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5638 bfd_false }, \
5639 \
5640 BFD_JUMP_TABLE_GENERIC (coff), \
5641 BFD_JUMP_TABLE_COPY (coff), \
5642 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5643 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5644 BFD_JUMP_TABLE_SYMBOLS (coff), \
5645 BFD_JUMP_TABLE_RELOCS (coff), \
5646 BFD_JUMP_TABLE_WRITE (coff), \
5647 BFD_JUMP_TABLE_LINK (coff), \
5648 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5649 \
5650 ALTERNATIVE, \
5651 \
5652 SWAP_TABLE \
5653};
5654
5655#define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
4c117b10
ILT		 5656const bfd_target VAR = \
5657{ \
5658 NAME , \
5659 bfd_target_coff_flavour, \
5660 BFD_ENDIAN_LITTLE, /* data byte order is little */ \
5661 BFD_ENDIAN_LITTLE, /* header byte order is little */ \
5662 /* object flags */ \
5663 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5664 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5665 /* section flags */ \
5666 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5667 UNDER, /* leading symbol underscore */ \
5668 '/', /* ar_pad_char */ \
5669 15, /* ar_max_namelen */ \
5670 \
5671 /* Data conversion functions. */ \
5672 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5673 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5674 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5675 /* Header conversion functions. */ \
5676 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5677 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5678 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5679 /* bfd_check_format */ \
5680 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5681 _bfd_dummy_target }, \
5682 /* bfd_set_format */ \
5683 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5684 /* bfd_write_contents */ \
5685 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5686 bfd_false }, \
5687 \
5688 BFD_JUMP_TABLE_GENERIC (coff), \
5689 BFD_JUMP_TABLE_COPY (coff), \
5690 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5691 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5692 BFD_JUMP_TABLE_SYMBOLS (coff), \
5693 BFD_JUMP_TABLE_RELOCS (coff), \
5694 BFD_JUMP_TABLE_WRITE (coff), \
5695 BFD_JUMP_TABLE_LINK (coff), \
5696 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5697 \
5698 ALTERNATIVE, \
5699 \
3fa78519 5700 SWAP_TABLE \
c3c89269 5701};
GDB Binutils - Deliverables
This page took 0.584522 seconds and 4 git commands to generate.