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