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