]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - bfd/coffcode.h
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
include/coff/
[thirdparty/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 {
6b1cecf3
DK		 3632 /* The s_name field is defined to be NUL-padded but need not be
3633 NUL-terminated. We use a temporary buffer so that we can still
3634 sprintf all eight chars without splatting a terminating NUL
3635 over the first byte of the following member (s_paddr). */
3636 char s_name_buf[SCNNMLEN + 1];
3637
3638 /* An inherent limitation of the /nnnnnnn notation used to indicate
3639 the offset of the long name in the string table is that we
3640 cannot address entries beyone the ten million byte boundary. */
3641 if (string_size >= 10000000)
3642 {
3643 bfd_set_error (bfd_error_file_too_big);
3644 (*_bfd_error_handler)
3645 (_("%B: section %s: string table overflow at offset %ld"),
3646 abfd, current->name, string_size);
3647 return FALSE;
3648 }
3649
3650 /* snprintf not strictly necessary now we've verified the value
3651 has less than eight ASCII digits, but never mind. */
3652 snprintf (s_name_buf, SCNNMLEN + 1, "/%lu", (unsigned long) string_size);
3653 /* Then strncpy takes care of any padding for us. */
3654 strncpy (section.s_name, s_name_buf, SCNNMLEN);
88183869
DK		 3655 string_size += len + 1;
3656 long_section_names = TRUE;
3657 }
3658 }
252b5132
RH		 3659#endif
3660
3661#ifdef _LIB
3662 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3663 Ian Taylor <ian@cygnus.com>. */
3664 if (strcmp (current->name, _LIB) == 0)
3665 section.s_vaddr = 0;
3666 else
3667#endif
3668 section.s_vaddr = current->vma;
3669 section.s_paddr = current->lma;
eea6121a 3670 section.s_size = current->size;
b9af77f5 3671#ifdef coff_get_section_load_page
e60b52c6 3672 section.s_page = coff_get_section_load_page (current);
44f74642
NC		 3673#else
3674 section.s_page = 0;
b9af77f5 3675#endif
252b5132
RH		 3676
3677#ifdef COFF_WITH_PE
3678 section.s_paddr = 0;
3679#endif
3680#ifdef COFF_IMAGE_WITH_PE
3681 /* Reminder: s_paddr holds the virtual size of the section. */
3682 if (coff_section_data (abfd, current) != NULL
3683 && pei_section_data (abfd, current) != NULL)
3684 section.s_paddr = pei_section_data (abfd, current)->virt_size;
3685 else
3686 section.s_paddr = 0;
3687#endif
3688
ed781d5d
NC		 3689 /* If this section has no size or is unloadable then the scnptr
3690 will be 0 too. */
eea6121a
AM		 3691 if (current->size == 0
3692 || (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
ed781d5d 3693 section.s_scnptr = 0;
252b5132 3694 else
ed781d5d
NC		 3695 section.s_scnptr = current->filepos;
3696
252b5132
RH		 3697 section.s_relptr = current->rel_filepos;
3698 section.s_lnnoptr = current->line_filepos;
3699 section.s_nreloc = current->reloc_count;
3700 section.s_nlnno = current->lineno_count;
79207490
ILT		 3701#ifndef COFF_IMAGE_WITH_PE
3702 /* In PEI, relocs come in the .reloc section. */
252b5132 3703 if (current->reloc_count != 0)
b34976b6 3704 hasrelocs = TRUE;
79207490 3705#endif
252b5132 3706 if (current->lineno_count != 0)
b34976b6 3707 haslinno = TRUE;
4cfec37b
ILT		 3708 if ((current->flags & SEC_DEBUGGING) != 0
3709 && ! is_reloc_section)
b34976b6 3710 hasdebug = TRUE;
252b5132 3711
60bcf0fa 3712#ifdef RS6000COFF_C
7f6d05e8 3713#ifndef XCOFF64
252b5132
RH		 3714 /* Indicate the use of an XCOFF overflow section header. */
3715 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3716 {
3717 section.s_nreloc = 0xffff;
3718 section.s_nlnno = 0xffff;
3719 }
7f6d05e8 3720#endif
252b5132
RH		 3721#endif
3722
3723 section.s_flags = sec_to_styp_flags (current->name, current->flags);
3724
3725 if (!strcmp (current->name, _TEXT))
ed781d5d 3726 text_sec = current;
252b5132 3727 else if (!strcmp (current->name, _DATA))
ed781d5d 3728 data_sec = current;
252b5132 3729 else if (!strcmp (current->name, _BSS))
ed781d5d 3730 bss_sec = current;
252b5132
RH		 3731
3732#ifdef I960
3733 section.s_align = (current->alignment_power
3734 ? 1 << current->alignment_power
3735 : 0);
81635ce4 3736#endif
e60b52c6 3737#ifdef TIC80COFF
ed781d5d 3738 /* TI COFF puts the alignment power in bits 8-11 of the flags. */
252b5132
RH		 3739 section.s_flags |= (current->alignment_power & 0xF) << 8;
3740#endif
81635ce4
TW		 3741#ifdef COFF_ENCODE_ALIGNMENT
3742 COFF_ENCODE_ALIGNMENT(section, current->alignment_power);
252b5132
RH		 3743#endif
3744
3745#ifdef COFF_IMAGE_WITH_PE
00692651
ILT		 3746 /* Suppress output of the sections if they are null. ld
3747 includes the bss and data sections even if there is no size
3748 assigned to them. NT loader doesn't like it if these section
3749 headers are included if the sections themselves are not
3750 needed. See also coff_compute_section_file_positions. */
252b5132
RH		 3751 if (section.s_size == 0)
3752 internal_f.f_nscns--;
3753 else
3754#endif
3755 {
3756 SCNHDR buff;
dc810e39
AM		 3757 bfd_size_type amt = bfd_coff_scnhsz (abfd);
3758
252b5132 3759 if (coff_swap_scnhdr_out (abfd, &section, &buff) == 0
7920ce38 3760 || bfd_bwrite (& buff, amt, abfd) != amt)
b34976b6 3761 return FALSE;
252b5132
RH		 3762 }
3763
3764#ifdef COFF_WITH_PE
3765 /* PE stores COMDAT section information in the symbol table. If
46f2f11d
AM		 3766 this section is supposed to have some COMDAT info, track down
3767 the symbol in the symbol table and modify it. */
252b5132
RH		 3768 if ((current->flags & SEC_LINK_ONCE) != 0)
3769 {
3770 unsigned int i, count;
3771 asymbol **psym;
3772 coff_symbol_type *csym = NULL;
3773 asymbol **psymsec;
3774
3775 psymsec = NULL;
3776 count = bfd_get_symcount (abfd);
3777 for (i = 0, psym = abfd->outsymbols; i < count; i++, psym++)
3778 {
3779 if ((*psym)->section != current)
3780 continue;
3781
3782 /* Remember the location of the first symbol in this
46f2f11d 3783 section. */
252b5132
RH		 3784 if (psymsec == NULL)
3785 psymsec = psym;
3786
3787 /* See if this is the section symbol. */
3788 if (strcmp ((*psym)->name, current->name) == 0)
3789 {
3790 csym = coff_symbol_from (abfd, *psym);
3791 if (csym == NULL
3792 || csym->native == NULL
3793 || csym->native->u.syment.n_numaux < 1
3794 || csym->native->u.syment.n_sclass != C_STAT
3795 || csym->native->u.syment.n_type != T_NULL)
3796 continue;
3797
3798 /* Here *PSYM is the section symbol for CURRENT. */
3799
3800 break;
3801 }
3802 }
3803
3804 /* Did we find it?
3805 Note that we might not if we're converting the file from
3806 some other object file format. */
3807 if (i < count)
3808 {
3809 combined_entry_type *aux;
3810
3811 /* We don't touch the x_checksum field. The
3812 x_associated field is not currently supported. */
3813
3814 aux = csym->native + 1;
3815 switch (current->flags & SEC_LINK_DUPLICATES)
3816 {
3817 case SEC_LINK_DUPLICATES_DISCARD:
3818 aux->u.auxent.x_scn.x_comdat = IMAGE_COMDAT_SELECT_ANY;
3819 break;
3820
3821 case SEC_LINK_DUPLICATES_ONE_ONLY:
3822 aux->u.auxent.x_scn.x_comdat =
3823 IMAGE_COMDAT_SELECT_NODUPLICATES;
3824 break;
3825
3826 case SEC_LINK_DUPLICATES_SAME_SIZE:
3827 aux->u.auxent.x_scn.x_comdat =
3828 IMAGE_COMDAT_SELECT_SAME_SIZE;
3829 break;
3830
3831 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
3832 aux->u.auxent.x_scn.x_comdat =
3833 IMAGE_COMDAT_SELECT_EXACT_MATCH;
3834 break;
3835 }
3836
3837 /* The COMDAT symbol must be the first symbol from this
46f2f11d
AM		 3838 section in the symbol table. In order to make this
3839 work, we move the COMDAT symbol before the first
3840 symbol we found in the search above. It's OK to
3841 rearrange the symbol table at this point, because
3842 coff_renumber_symbols is going to rearrange it
3843 further and fix up all the aux entries. */
252b5132
RH		 3844 if (psym != psymsec)
3845 {
3846 asymbol *hold;
3847 asymbol **pcopy;
3848
3849 hold = *psym;
3850 for (pcopy = psym; pcopy > psymsec; pcopy--)
3851 pcopy[0] = pcopy[-1];
3852 *psymsec = hold;
3853 }
3854 }
3855 }
3856#endif /* COFF_WITH_PE */
3857 }
3858
3859#ifdef RS6000COFF_C
dc810e39 3860#ifndef XCOFF64
252b5132
RH		 3861 /* XCOFF handles overflows in the reloc and line number count fields
3862 by creating a new section header to hold the correct values. */
3863 for (current = abfd->sections; current != NULL; current = current->next)
3864 {
3865 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3866 {
3867 struct internal_scnhdr scnhdr;
3868 SCNHDR buff;
dc810e39 3869 bfd_size_type amt;
252b5132
RH		 3870
3871 internal_f.f_nscns++;
3872 strncpy (&(scnhdr.s_name[0]), current->name, 8);
3873 scnhdr.s_paddr = current->reloc_count;
3874 scnhdr.s_vaddr = current->lineno_count;
3875 scnhdr.s_size = 0;
3876 scnhdr.s_scnptr = 0;
3877 scnhdr.s_relptr = current->rel_filepos;
3878 scnhdr.s_lnnoptr = current->line_filepos;
3879 scnhdr.s_nreloc = current->target_index;
3880 scnhdr.s_nlnno = current->target_index;
3881 scnhdr.s_flags = STYP_OVRFLO;
dc810e39 3882 amt = bfd_coff_scnhsz (abfd);
252b5132 3883 if (coff_swap_scnhdr_out (abfd, &scnhdr, &buff) == 0
7920ce38 3884 || bfd_bwrite (& buff, amt, abfd) != amt)
b34976b6 3885 return FALSE;
252b5132
RH		 3886 }
3887 }
beb1bf64 3888#endif
252b5132
RH		 3889#endif
3890
e60b52c6 3891 /* OK, now set up the filehdr... */
252b5132
RH		 3892
3893 /* Don't include the internal abs section in the section count */
3894
ed781d5d 3895 /* We will NOT put a fucking timestamp in the header here. Every time you
252b5132
RH		 3896 put it back, I will come in and take it out again. I'm sorry. This
3897 field does not belong here. We fill it with a 0 so it compares the
ed781d5d 3898 same but is not a reasonable time. -- gnu@cygnus.com */
252b5132 3899 internal_f.f_timdat = 0;
252b5132
RH		 3900 internal_f.f_flags = 0;
3901
3902 if (abfd->flags & EXEC_P)
6b3b007b 3903 internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
252b5132
RH		 3904 else
3905 {
3906 internal_f.f_opthdr = 0;
3907#ifdef RS6000COFF_C
dc810e39 3908#ifndef XCOFF64
252b5132 3909 if (xcoff_data (abfd)->full_aouthdr)
6b3b007b 3910 internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
252b5132
RH		 3911 else
3912 internal_f.f_opthdr = SMALL_AOUTSZ;
dc810e39 3913#endif
252b5132
RH		 3914#endif
3915 }
3916
3917 if (!hasrelocs)
3918 internal_f.f_flags |= F_RELFLG;
3919 if (!haslinno)
3920 internal_f.f_flags |= F_LNNO;
3921 if (abfd->flags & EXEC_P)
3922 internal_f.f_flags |= F_EXEC;
4cfec37b
ILT		 3923#ifdef COFF_IMAGE_WITH_PE
3924 if (! hasdebug)
3925 internal_f.f_flags |= IMAGE_FILE_DEBUG_STRIPPED;
d70270c5
BF		 3926 if (pe_data (abfd)->real_flags & IMAGE_FILE_LARGE_ADDRESS_AWARE)
3927 internal_f.f_flags |= IMAGE_FILE_LARGE_ADDRESS_AWARE;
4cfec37b 3928#endif
252b5132 3929
99ad8390 3930#ifndef COFF_WITH_pex64
bcb9b88d
NC		 3931#ifdef COFF_WITH_PE
3932 internal_f.f_flags |= IMAGE_FILE_32BIT_MACHINE;
3933#else
252b5132
RH		 3934 if (bfd_little_endian (abfd))
3935 internal_f.f_flags |= F_AR32WR;
3936 else
3937 internal_f.f_flags |= F_AR32W;
8a1ad8e7 3938#endif
99ad8390 3939#endif
252b5132 3940
81635ce4 3941#ifdef TI_TARGET_ID
ed781d5d
NC		 3942 /* Target id is used in TI COFF v1 and later; COFF0 won't use this field,
3943 but it doesn't hurt to set it internally. */
81635ce4
TW		 3944 internal_f.f_target_id = TI_TARGET_ID;
3945#endif
252b5132
RH		 3946#ifdef TIC80_TARGET_ID
3947 internal_f.f_target_id = TIC80_TARGET_ID;
3948#endif
3949
ed781d5d
NC		 3950 /* FIXME, should do something about the other byte orders and
3951 architectures. */
252b5132
RH		 3952
3953#ifdef RS6000COFF_C
3954 if ((abfd->flags & DYNAMIC) != 0)
3955 internal_f.f_flags |= F_SHROBJ;
3956 if (bfd_get_section_by_name (abfd, _LOADER) != NULL)
3957 internal_f.f_flags |= F_DYNLOAD;
3958#endif
3959
3960 memset (&internal_a, 0, sizeof internal_a);
3961
ed781d5d 3962 /* Set up architecture-dependent stuff. */
252b5132
RH		 3963 {
3964 unsigned int magic = 0;
3965 unsigned short flags = 0;
ed781d5d 3966
252b5132
RH		 3967 coff_set_flags (abfd, &magic, &flags);
3968 internal_f.f_magic = magic;
3969 internal_f.f_flags |= flags;
e60b52c6 3970 /* ...and the "opt"hdr... */
252b5132 3971
81635ce4
TW		 3972#ifdef TICOFF_AOUT_MAGIC
3973 internal_a.magic = TICOFF_AOUT_MAGIC;
3974#define __A_MAGIC_SET__
3975#endif
252b5132
RH		 3976#ifdef TIC80COFF
3977 internal_a.magic = TIC80_ARCH_MAGIC;
3978#define __A_MAGIC_SET__
3979#endif /* TIC80 */
3980#ifdef I860
3981 /* FIXME: What are the a.out magic numbers for the i860? */
3982 internal_a.magic = 0;
3983#define __A_MAGIC_SET__
3984#endif /* I860 */
3985#ifdef I960
3986 internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
3987#define __A_MAGIC_SET__
3988#endif /* I960 */
3989#if M88
3990#define __A_MAGIC_SET__
3991 internal_a.magic = PAGEMAGICBCS;
3992#endif /* M88 */
3993
3994#if APOLLO_M68
3995#define __A_MAGIC_SET__
3996 internal_a.magic = APOLLO_COFF_VERSION_NUMBER;
3997#endif
3998
3999#if defined(M68) || defined(WE32K) || defined(M68K)
4000#define __A_MAGIC_SET__
4001#if defined(LYNXOS)
4002 internal_a.magic = LYNXCOFFMAGIC;
4003#else
4004#if defined(TARG_AUX)
4005 internal_a.magic = (abfd->flags & D_PAGED ? PAGEMAGICPEXECPAGED :
4006 abfd->flags & WP_TEXT ? PAGEMAGICPEXECSWAPPED :
4007 PAGEMAGICEXECSWAPPED);
4008#else
4009#if defined (PAGEMAGICPEXECPAGED)
4010 internal_a.magic = PAGEMAGICPEXECPAGED;
4011#endif
4012#endif /* TARG_AUX */
4013#endif /* LYNXOS */
4014#endif /* M68 || WE32K || M68K */
4015
4016#if defined(ARM)
4017#define __A_MAGIC_SET__
4018 internal_a.magic = ZMAGIC;
e60b52c6 4019#endif
252b5132
RH		 4020
4021#if defined(PPC_PE)
4022#define __A_MAGIC_SET__
4023 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
4024#endif
4025
4026#if defined MCORE_PE
4027#define __A_MAGIC_SET__
4028 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
e60b52c6 4029#endif
252b5132
RH		 4030
4031#if defined(I386)
4032#define __A_MAGIC_SET__
99ad8390 4033#if defined LYNXOS
252b5132 4034 internal_a.magic = LYNXCOFFMAGIC;
99ad8390
NC		 4035#elif defined AMD64
4036 internal_a.magic = IMAGE_NT_OPTIONAL_HDR64_MAGIC;
4037#else
252b5132 4038 internal_a.magic = ZMAGIC;
99ad8390 4039#endif
252b5132
RH		 4040#endif /* I386 */
4041
fac41780
JW		 4042#if defined(IA64)
4043#define __A_MAGIC_SET__
7a2ec0a6 4044 internal_a.magic = PE32PMAGIC;
fac41780
JW		 4045#endif /* IA64 */
4046
252b5132
RH		 4047#if defined(SPARC)
4048#define __A_MAGIC_SET__
4049#if defined(LYNXOS)
4050 internal_a.magic = LYNXCOFFMAGIC;
4051#endif /* LYNXOS */
4052#endif /* SPARC */
4053
4054#ifdef RS6000COFF_C
4055#define __A_MAGIC_SET__
4056 internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC :
4057 (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC :
4058 RS6K_AOUTHDR_OMAGIC;
4059#endif
4060
17505c5c
NC		 4061#if defined(SH) && defined(COFF_WITH_PE)
4062#define __A_MAGIC_SET__
4063 internal_a.magic = SH_PE_MAGIC;
4064#endif
4065
4066#if defined(MIPS) && defined(COFF_WITH_PE)
4067#define __A_MAGIC_SET__
4068 internal_a.magic = MIPS_PE_MAGIC;
4069#endif
4070
3b16e843
NC		 4071#ifdef OR32
4072#define __A_MAGIC_SET__
4073 internal_a.magic = NMAGIC; /* Assume separate i/d. */
4074#endif
4075
7499d566
NC		 4076#ifdef MAXQ20MAGIC
4077#define __A_MAGIC_SET__
4078 internal_a.magic = MAXQ20MAGIC;
4079#endif
46f2f11d 4080
252b5132
RH		 4081#ifndef __A_MAGIC_SET__
4082#include "Your aouthdr magic number is not being set!"
4083#else
4084#undef __A_MAGIC_SET__
4085#endif
4086 }
4087
4088 /* FIXME: Does anybody ever set this to another value? */
4089 internal_a.vstamp = 0;
4090
ed781d5d 4091 /* Now should write relocs, strings, syms. */
252b5132
RH		 4092 obj_sym_filepos (abfd) = sym_base;
4093
4094 if (bfd_get_symcount (abfd) != 0)
4095 {
4096 int firstundef;
0e71e495 4097
252b5132 4098 if (!coff_renumber_symbols (abfd, &firstundef))
b34976b6 4099 return FALSE;
252b5132
RH		 4100 coff_mangle_symbols (abfd);
4101 if (! coff_write_symbols (abfd))
b34976b6 4102 return FALSE;
252b5132 4103 if (! coff_write_linenumbers (abfd))
b34976b6 4104 return FALSE;
252b5132 4105 if (! coff_write_relocs (abfd, firstundef))
b34976b6 4106 return FALSE;
252b5132
RH		 4107 }
4108#ifdef COFF_LONG_SECTION_NAMES
d71f672e 4109 else if (long_section_names && ! obj_coff_strings_written (abfd))
252b5132
RH		 4110 {
4111 /* If we have long section names we have to write out the string
46f2f11d 4112 table even if there are no symbols. */
252b5132 4113 if (! coff_write_symbols (abfd))
b34976b6 4114 return FALSE;
252b5132
RH		 4115 }
4116#endif
4117#ifdef COFF_IMAGE_WITH_PE
4118#ifdef PPC_PE
4119 else if ((abfd->flags & EXEC_P) != 0)
4120 {
4121 bfd_byte b;
4122
4123 /* PowerPC PE appears to require that all executable files be
46f2f11d 4124 rounded up to the page size. */
252b5132
RH		 4125 b = 0;
4126 if (bfd_seek (abfd,
dc810e39 4127 (file_ptr) BFD_ALIGN (sym_base, COFF_PAGE_SIZE) - 1,
252b5132 4128 SEEK_SET) != 0
dc810e39 4129 || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
b34976b6 4130 return FALSE;
252b5132
RH		 4131 }
4132#endif
4133#endif
4134
4135 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
4136 backend linker, and obj_raw_syment_count is not valid until after
4137 coff_write_symbols is called. */
4138 if (obj_raw_syment_count (abfd) != 0)
4139 {
4140 internal_f.f_symptr = sym_base;
4141#ifdef RS6000COFF_C
4142 /* AIX appears to require that F_RELFLG not be set if there are
46f2f11d 4143 local symbols but no relocations. */
252b5132
RH		 4144 internal_f.f_flags &=~ F_RELFLG;
4145#endif
4146 }
4147 else
4148 {
4149 if (long_section_names)
4150 internal_f.f_symptr = sym_base;
4151 else
4152 internal_f.f_symptr = 0;
4153 internal_f.f_flags |= F_LSYMS;
4154 }
4155
4156 if (text_sec)
4157 {
eea6121a 4158 internal_a.tsize = text_sec->size;
252b5132
RH		 4159 internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
4160 }
4161 if (data_sec)
4162 {
eea6121a 4163 internal_a.dsize = data_sec->size;
252b5132
RH		 4164 internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
4165 }
4166 if (bss_sec)
4167 {
eea6121a 4168 internal_a.bsize = bss_sec->size;
252b5132
RH		 4169 if (internal_a.bsize && bss_sec->vma < internal_a.data_start)
4170 internal_a.data_start = bss_sec->vma;
4171 }
4172
4173 internal_a.entry = bfd_get_start_address (abfd);
4174 internal_f.f_nsyms = obj_raw_syment_count (abfd);
4175
4176#ifdef RS6000COFF_C
4177 if (xcoff_data (abfd)->full_aouthdr)
4178 {
4179 bfd_vma toc;
4180 asection *loader_sec;
4181
4182 internal_a.vstamp = 1;
4183
4184 internal_a.o_snentry = xcoff_data (abfd)->snentry;
4185 if (internal_a.o_snentry == 0)
4186 internal_a.entry = (bfd_vma) -1;
4187
4188 if (text_sec != NULL)
4189 {
4190 internal_a.o_sntext = text_sec->target_index;
4191 internal_a.o_algntext = bfd_get_section_alignment (abfd, text_sec);
4192 }
4193 else
4194 {
4195 internal_a.o_sntext = 0;
4196 internal_a.o_algntext = 0;
4197 }
4198 if (data_sec != NULL)
4199 {
4200 internal_a.o_sndata = data_sec->target_index;
4201 internal_a.o_algndata = bfd_get_section_alignment (abfd, data_sec);
4202 }
4203 else
4204 {
4205 internal_a.o_sndata = 0;
4206 internal_a.o_algndata = 0;
4207 }
4208 loader_sec = bfd_get_section_by_name (abfd, ".loader");
4209 if (loader_sec != NULL)
4210 internal_a.o_snloader = loader_sec->target_index;
4211 else
4212 internal_a.o_snloader = 0;
4213 if (bss_sec != NULL)
4214 internal_a.o_snbss = bss_sec->target_index;
4215 else
4216 internal_a.o_snbss = 0;
4217
4218 toc = xcoff_data (abfd)->toc;
4219 internal_a.o_toc = toc;
4220 internal_a.o_sntoc = xcoff_data (abfd)->sntoc;
4221
4222 internal_a.o_modtype = xcoff_data (abfd)->modtype;
4223 if (xcoff_data (abfd)->cputype != -1)
4224 internal_a.o_cputype = xcoff_data (abfd)->cputype;
4225 else
4226 {
4227 switch (bfd_get_arch (abfd))
4228 {
4229 case bfd_arch_rs6000:
4230 internal_a.o_cputype = 4;
4231 break;
4232 case bfd_arch_powerpc:
250d94fd 4233 if (bfd_get_mach (abfd) == bfd_mach_ppc)
252b5132
RH		 4234 internal_a.o_cputype = 3;
4235 else
4236 internal_a.o_cputype = 1;
4237 break;
4238 default:
4239 abort ();
4240 }
4241 }
4242 internal_a.o_maxstack = xcoff_data (abfd)->maxstack;
4243 internal_a.o_maxdata = xcoff_data (abfd)->maxdata;
4244 }
4245#endif
4246
7920ce38 4247 /* Now write them. */
252b5132 4248 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
b34976b6 4249 return FALSE;
e60b52c6 4250
252b5132 4251 {
b5f303f0 4252 char * buff;
dc810e39 4253 bfd_size_type amount = bfd_coff_filhsz (abfd);
e60b52c6 4254
dc810e39 4255 buff = bfd_malloc (amount);
e60b52c6 4256 if (buff == NULL)
b34976b6 4257 return FALSE;
e60b52c6 4258
7920ce38
NC		 4259 bfd_coff_swap_filehdr_out (abfd, & internal_f, buff);
4260 amount = bfd_bwrite (buff, amount, abfd);
e60b52c6 4261
2fca4467 4262 free (buff);
e60b52c6 4263
b5f303f0 4264 if (amount != bfd_coff_filhsz (abfd))
b34976b6 4265 return FALSE;
252b5132 4266 }
e60b52c6 4267
252b5132
RH		 4268 if (abfd->flags & EXEC_P)
4269 {
e60b52c6 4270 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
ed781d5d 4271 include/coff/pe.h sets AOUTSZ == sizeof (PEAOUTHDR)). */
b5f303f0 4272 char * buff;
dc810e39 4273 bfd_size_type amount = bfd_coff_aoutsz (abfd);
b5f303f0 4274
dc810e39 4275 buff = bfd_malloc (amount);
e60b52c6 4276 if (buff == NULL)
b34976b6 4277 return FALSE;
e60b52c6 4278
7920ce38
NC		 4279 coff_swap_aouthdr_out (abfd, & internal_a, buff);
4280 amount = bfd_bwrite (buff, amount, abfd);
e60b52c6 4281
2fca4467 4282 free (buff);
e60b52c6 4283
b5f303f0 4284 if (amount != bfd_coff_aoutsz (abfd))
b34976b6 4285 return FALSE;
05793179
NC		 4286
4287#ifdef COFF_IMAGE_WITH_PE
4288 if (! coff_apply_checksum (abfd))
b34976b6 4289 return FALSE;
05793179 4290#endif
252b5132
RH		 4291 }
4292#ifdef RS6000COFF_C
4293 else
4294 {
4295 AOUTHDR buff;
4296 size_t size;
4297
4298 /* XCOFF seems to always write at least a small a.out header. */
7920ce38 4299 coff_swap_aouthdr_out (abfd, & internal_a, & buff);
252b5132 4300 if (xcoff_data (abfd)->full_aouthdr)
6b3b007b 4301 size = bfd_coff_aoutsz (abfd);
252b5132
RH		 4302 else
4303 size = SMALL_AOUTSZ;
7920ce38 4304 if (bfd_bwrite (& buff, (bfd_size_type) size, abfd) != size)
b34976b6 4305 return FALSE;
252b5132
RH		 4306 }
4307#endif
4308
b34976b6 4309 return TRUE;
252b5132
RH		 4310}
4311
b34976b6 4312static bfd_boolean
7920ce38
NC		 4313coff_set_section_contents (bfd * abfd,
4314 sec_ptr section,
4315 const void * location,
4316 file_ptr offset,
4317 bfd_size_type count)
252b5132 4318{
ed781d5d 4319 if (! abfd->output_has_begun) /* Set by bfd.c handler. */
252b5132
RH		 4320 {
4321 if (! coff_compute_section_file_positions (abfd))
b34976b6 4322 return FALSE;
252b5132
RH		 4323 }
4324
4325#if defined(_LIB) && !defined(TARG_AUX)
252b5132
RH		 4326 /* The physical address field of a .lib section is used to hold the
4327 number of shared libraries in the section. This code counts the
4328 number of sections being written, and increments the lma field
4329 with the number.
4330
4331 I have found no documentation on the contents of this section.
4332 Experimentation indicates that the section contains zero or more
4333 records, each of which has the following structure:
4334
4335 - a (four byte) word holding the length of this record, in words,
4336 - a word that always seems to be set to "2",
4337 - the path to a shared library, null-terminated and then padded
4338 to a whole word boundary.
4339
4340 bfd_assert calls have been added to alert if an attempt is made
4341 to write a section which doesn't follow these assumptions. The
4342 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
4343 <robertl@arnet.com> (Thanks!).
e60b52c6 4344
ed781d5d 4345 Gvran Uddeborg <gvran@uddeborg.pp.se>. */
252b5132
RH		 4346 if (strcmp (section->name, _LIB) == 0)
4347 {
4348 bfd_byte *rec, *recend;
4349
4350 rec = (bfd_byte *) location;
4351 recend = rec + count;
4352 while (rec < recend)
4353 {
4354 ++section->lma;
4355 rec += bfd_get_32 (abfd, rec) * 4;
4356 }
4357
4358 BFD_ASSERT (rec == recend);
4359 }
252b5132
RH		 4360#endif
4361
4362 /* Don't write out bss sections - one way to do this is to
e60b52c6 4363 see if the filepos has not been set. */
252b5132 4364 if (section->filepos == 0)
b34976b6 4365 return TRUE;
252b5132 4366
dc810e39 4367 if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0)
b34976b6 4368 return FALSE;
252b5132 4369
dc810e39 4370 if (count == 0)
b34976b6 4371 return TRUE;
dc810e39
AM		 4372
4373 return bfd_bwrite (location, count, abfd) == count;
252b5132 4374}
252b5132 4375
7920ce38
NC		 4376static void *
4377buy_and_read (bfd *abfd, file_ptr where, bfd_size_type size)
252b5132 4378{
7920ce38
NC		 4379 void * area = bfd_alloc (abfd, size);
4380
252b5132
RH		 4381 if (!area)
4382 return (NULL);
dc810e39
AM		 4383 if (bfd_seek (abfd, where, SEEK_SET) != 0
4384 || bfd_bread (area, size, abfd) != size)
252b5132
RH		 4385 return (NULL);
4386 return (area);
7920ce38 4387}
252b5132
RH		 4388
4389/*
4390SUBSUBSECTION
4391 Reading linenumbers
4392
4393 Creating the linenumber table is done by reading in the entire
4394 coff linenumber table, and creating another table for internal use.
4395
4396 A coff linenumber table is structured so that each function
4397 is marked as having a line number of 0. Each line within the
4398 function is an offset from the first line in the function. The
4399 base of the line number information for the table is stored in
4400 the symbol associated with the function.
4401
00692651
ILT		 4402 Note: The PE format uses line number 0 for a flag indicating a
4403 new source file.
4404
252b5132
RH		 4405 The information is copied from the external to the internal
4406 table, and each symbol which marks a function is marked by
4407 pointing its...
4408
4409 How does this work ?
252b5132
RH		 4410*/
4411
e708816d
NC		 4412static int
4413coff_sort_func_alent (const void * arg1, const void * arg2)
4414{
4415 const alent *al1 = *(const alent **) arg1;
4416 const alent *al2 = *(const alent **) arg2;
4417 const coff_symbol_type *s1 = (const coff_symbol_type *) (al1->u.sym);
4418 const coff_symbol_type *s2 = (const coff_symbol_type *) (al2->u.sym);
4419
4420 if (s1->symbol.value < s2->symbol.value)
4421 return -1;
4422 else if (s1->symbol.value > s2->symbol.value)
4423 return 1;
4424
4425 return 0;
4426}
4427
b34976b6 4428static bfd_boolean
7920ce38 4429coff_slurp_line_table (bfd *abfd, asection *asect)
252b5132
RH		 4430{
4431 LINENO *native_lineno;
4432 alent *lineno_cache;
dc810e39 4433 bfd_size_type amt;
e708816d
NC		 4434 unsigned int counter;
4435 alent *cache_ptr;
4436 bfd_vma prev_offset = 0;
4437 int ordered = 1;
4438 unsigned int nbr_func;
4439 LINENO *src;
252b5132 4440
7920ce38 4441 BFD_ASSERT (asect->lineno == NULL);
252b5132 4442
46f2f11d
AM		 4443 amt = ((bfd_size_type) asect->lineno_count + 1) * sizeof (alent);
4444 lineno_cache = bfd_alloc (abfd, amt);
4445 if (lineno_cache == NULL)
4446 return FALSE;
4447
dc810e39
AM		 4448 amt = (bfd_size_type) bfd_coff_linesz (abfd) * asect->lineno_count;
4449 native_lineno = (LINENO *) buy_and_read (abfd, asect->line_filepos, amt);
14abcef9
NC		 4450 if (native_lineno == NULL)
4451 {
4452 (*_bfd_error_handler)
46f2f11d
AM		 4453 (_("%B: warning: line number table read failed"), abfd);
4454 bfd_release (abfd, lineno_cache);
14abcef9
NC		 4455 return FALSE;
4456 }
e708816d 4457
e708816d 4458 cache_ptr = lineno_cache;
46f2f11d 4459 asect->lineno = lineno_cache;
e708816d
NC		 4460 src = native_lineno;
4461 nbr_func = 0;
4462
4463 for (counter = 0; counter < asect->lineno_count; counter++)
252b5132 4464 {
e708816d 4465 struct internal_lineno dst;
252b5132 4466
e708816d
NC		 4467 bfd_coff_swap_lineno_in (abfd, src, &dst);
4468 cache_ptr->line_number = dst.l_lnno;
4469
4470 if (cache_ptr->line_number == 0)
252b5132 4471 {
e708816d
NC		 4472 bfd_boolean warned;
4473 bfd_signed_vma symndx;
4474 coff_symbol_type *sym;
4475
4476 nbr_func++;
4477 warned = FALSE;
4478 symndx = dst.l_addr.l_symndx;
4479 if (symndx < 0
4480 || (bfd_vma) symndx >= obj_raw_syment_count (abfd))
4481 {
4482 (*_bfd_error_handler)
4483 (_("%B: warning: illegal symbol index %ld in line numbers"),
4484 abfd, dst.l_addr.l_symndx);
4485 symndx = 0;
4486 warned = TRUE;
4487 }
ed781d5d 4488
e708816d
NC		 4489 /* FIXME: We should not be casting between ints and
4490 pointers like this. */
4491 sym = ((coff_symbol_type *)
4492 ((symndx + obj_raw_syments (abfd))
4493 ->u.syment._n._n_n._n_zeroes));
4494 cache_ptr->u.sym = (asymbol *) sym;
4495 if (sym->lineno != NULL && ! warned)
4496 (*_bfd_error_handler)
4497 (_("%B: warning: duplicate line number information for `%s'"),
4498 abfd, bfd_asymbol_name (&sym->symbol));
4499
4500 sym->lineno = cache_ptr;
4501 if (sym->symbol.value < prev_offset)
4502 ordered = 0;
4503 prev_offset = sym->symbol.value;
4504 }
4505 else
4506 cache_ptr->u.offset = dst.l_addr.l_paddr
4507 - bfd_section_vma (abfd, asect);
4508
4509 cache_ptr++;
4510 src++;
4511 }
4512 cache_ptr->line_number = 0;
46f2f11d 4513 bfd_release (abfd, native_lineno);
e708816d
NC		 4514
4515 /* On some systems (eg AIX5.3) the lineno table may not be sorted. */
4516 if (!ordered)
4517 {
4518 /* Sort the table. */
4519 alent **func_table;
4520 alent *n_lineno_cache;
4521
4522 /* Create a table of functions. */
46f2f11d 4523 func_table = bfd_alloc (abfd, nbr_func * sizeof (alent *));
e708816d
NC		 4524 if (func_table != NULL)
4525 {
4526 alent **p = func_table;
4527 unsigned int i;
4528
4529 for (i = 0; i < counter; i++)
4530 if (lineno_cache[i].line_number == 0)
4531 *p++ = &lineno_cache[i];
252b5132 4532
e708816d
NC		 4533 /* Sort by functions. */
4534 qsort (func_table, nbr_func, sizeof (alent *), coff_sort_func_alent);
4535
4536 /* Create the new sorted table. */
46f2f11d 4537 amt = ((bfd_size_type) asect->lineno_count + 1) * sizeof (alent);
e708816d
NC		 4538 n_lineno_cache = bfd_alloc (abfd, amt);
4539 if (n_lineno_cache != NULL)
252b5132 4540 {
e708816d
NC		 4541 alent *n_cache_ptr = n_lineno_cache;
4542
4543 for (i = 0; i < nbr_func; i++)
252b5132 4544 {
e708816d
NC		 4545 coff_symbol_type *sym;
4546 alent *old_ptr = func_table[i];
4547
4548 /* Copy the function entry and update it. */
4549 *n_cache_ptr = *old_ptr;
4550 sym = (coff_symbol_type *)n_cache_ptr->u.sym;
4551 sym->lineno = n_cache_ptr;
4552 n_cache_ptr++;
4553 old_ptr++;
4554
4555 /* Copy the line number entries. */
4556 while (old_ptr->line_number != 0)
4557 *n_cache_ptr++ = *old_ptr++;
252b5132 4558 }
e708816d 4559 n_cache_ptr->line_number = 0;
46f2f11d 4560 memcpy (lineno_cache, n_lineno_cache, amt);
252b5132 4561 }
46f2f11d 4562 bfd_release (abfd, func_table);
252b5132 4563 }
252b5132 4564 }
e708816d 4565
b34976b6 4566 return TRUE;
252b5132
RH		 4567}
4568
00692651
ILT		 4569/* Slurp in the symbol table, converting it to generic form. Note
4570 that if coff_relocate_section is defined, the linker will read
4571 symbols via coff_link_add_symbols, rather than via this routine. */
4572
b34976b6 4573static bfd_boolean
7920ce38 4574coff_slurp_symbol_table (bfd * abfd)
252b5132
RH		 4575{
4576 combined_entry_type *native_symbols;
4577 coff_symbol_type *cached_area;
4578 unsigned int *table_ptr;
dc810e39 4579 bfd_size_type amt;
252b5132
RH		 4580 unsigned int number_of_symbols = 0;
4581
4582 if (obj_symbols (abfd))
b34976b6 4583 return TRUE;
252b5132 4584
ed781d5d 4585 /* Read in the symbol table. */
252b5132 4586 if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL)
ed781d5d 4587 return FALSE;
252b5132 4588
ed781d5d 4589 /* Allocate enough room for all the symbols in cached form. */
dc810e39
AM		 4590 amt = obj_raw_syment_count (abfd);
4591 amt *= sizeof (coff_symbol_type);
7920ce38 4592 cached_area = bfd_alloc (abfd, amt);
252b5132 4593 if (cached_area == NULL)
b34976b6 4594 return FALSE;
dc810e39
AM		 4595
4596 amt = obj_raw_syment_count (abfd);
4597 amt *= sizeof (unsigned int);
7920ce38 4598 table_ptr = bfd_alloc (abfd, amt);
252b5132
RH		 4599
4600 if (table_ptr == NULL)
b34976b6 4601 return FALSE;
252b5132
RH		 4602 else
4603 {
4604 coff_symbol_type *dst = cached_area;
4605 unsigned int last_native_index = obj_raw_syment_count (abfd);
4606 unsigned int this_index = 0;
ed781d5d 4607
252b5132
RH		 4608 while (this_index < last_native_index)
4609 {
4610 combined_entry_type *src = native_symbols + this_index;
4611 table_ptr[this_index] = number_of_symbols;
4612 dst->symbol.the_bfd = abfd;
4613
4614 dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset);
4615 /* We use the native name field to point to the cached field. */
d2df793a 4616 src->u.syment._n._n_n._n_zeroes = (bfd_hostptr_t) dst;
252b5132
RH		 4617 dst->symbol.section = coff_section_from_bfd_index (abfd,
4618 src->u.syment.n_scnum);
4619 dst->symbol.flags = 0;
b34976b6 4620 dst->done_lineno = FALSE;
252b5132
RH		 4621
4622 switch (src->u.syment.n_sclass)
4623 {
4624#ifdef I960
4625 case C_LEAFEXT:
ed781d5d 4626 /* Fall through to next case. */
252b5132
RH		 4627#endif
4628
4629 case C_EXT:
4630 case C_WEAKEXT:
4631#if defined ARM
46f2f11d
AM		 4632 case C_THUMBEXT:
4633 case C_THUMBEXTFUNC:
252b5132
RH		 4634#endif
4635#ifdef RS6000COFF_C
4636 case C_HIDEXT:
4637#endif
4638#ifdef C_SYSTEM
ed781d5d 4639 case C_SYSTEM: /* System Wide variable. */
252b5132
RH		 4640#endif
4641#ifdef COFF_WITH_PE
46f2f11d
AM		 4642 /* In PE, 0x68 (104) denotes a section symbol. */
4643 case C_SECTION:
5d54c628 4644 /* In PE, 0x69 (105) denotes a weak external symbol. */
252b5132
RH		 4645 case C_NT_WEAK:
4646#endif
5d54c628 4647 switch (coff_classify_symbol (abfd, &src->u.syment))
252b5132 4648 {
5d54c628 4649 case COFF_SYMBOL_GLOBAL:
252b5132 4650 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
252b5132
RH		 4651#if defined COFF_WITH_PE
4652 /* PE sets the symbol to a value relative to the
46f2f11d 4653 start of the section. */
252b5132
RH		 4654 dst->symbol.value = src->u.syment.n_value;
4655#else
4656 dst->symbol.value = (src->u.syment.n_value
4657 - dst->symbol.section->vma);
4658#endif
252b5132 4659 if (ISFCN ((src->u.syment.n_type)))
7920ce38
NC		 4660 /* A function ext does not go at the end of a
4661 file. */
4662 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
5d54c628
ILT		 4663 break;
4664
4665 case COFF_SYMBOL_COMMON:
4666 dst->symbol.section = bfd_com_section_ptr;
4667 dst->symbol.value = src->u.syment.n_value;
4668 break;
4669
4670 case COFF_SYMBOL_UNDEFINED:
4671 dst->symbol.section = bfd_und_section_ptr;
4672 dst->symbol.value = 0;
e60b52c6 4673 break;
5d54c628
ILT		 4674
4675 case COFF_SYMBOL_PE_SECTION:
4676 dst->symbol.flags |= BSF_EXPORT | BSF_SECTION_SYM;
4677 dst->symbol.value = 0;
4678 break;
4679
4680 case COFF_SYMBOL_LOCAL:
4681 dst->symbol.flags = BSF_LOCAL;
4682#if defined COFF_WITH_PE
4683 /* PE sets the symbol to a value relative to the
46f2f11d 4684 start of the section. */
5d54c628
ILT		 4685 dst->symbol.value = src->u.syment.n_value;
4686#else
4687 dst->symbol.value = (src->u.syment.n_value
4688 - dst->symbol.section->vma);
4689#endif
4690 if (ISFCN ((src->u.syment.n_type)))
4691 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4692 break;
252b5132
RH		 4693 }
4694
4695#ifdef RS6000COFF_C
252b5132
RH		 4696 /* A symbol with a csect entry should not go at the end. */
4697 if (src->u.syment.n_numaux > 0)
4698 dst->symbol.flags |= BSF_NOT_AT_END;
4699#endif
4700
4701#ifdef COFF_WITH_PE
4702 if (src->u.syment.n_sclass == C_NT_WEAK)
a181be0a
NC		 4703 dst->symbol.flags |= BSF_WEAK;
4704
ec0ef80e
DD		 4705 if (src->u.syment.n_sclass == C_SECTION
4706 && src->u.syment.n_scnum > 0)
eb1e0e80 4707 dst->symbol.flags = BSF_LOCAL;
252b5132 4708#endif
252b5132 4709 if (src->u.syment.n_sclass == C_WEAKEXT)
a181be0a 4710 dst->symbol.flags |= BSF_WEAK;
252b5132
RH		 4711
4712 break;
4713
ed781d5d 4714 case C_STAT: /* Static. */
252b5132 4715#ifdef I960
ed781d5d 4716 case C_LEAFSTAT: /* Static leaf procedure. */
252b5132 4717#endif
e60b52c6 4718#if defined ARM
46f2f11d
AM		 4719 case C_THUMBSTAT: /* Thumb static. */
4720 case C_THUMBLABEL: /* Thumb label. */
4721 case C_THUMBSTATFUNC:/* Thumb static function. */
252b5132 4722#endif
ed781d5d 4723 case C_LABEL: /* Label. */
00692651 4724 if (src->u.syment.n_scnum == N_DEBUG)
252b5132
RH		 4725 dst->symbol.flags = BSF_DEBUGGING;
4726 else
4727 dst->symbol.flags = BSF_LOCAL;
4728
4729 /* Base the value as an index from the base of the
4730 section, if there is one. */
4731 if (dst->symbol.section)
4732 {
4733#if defined COFF_WITH_PE
4734 /* PE sets the symbol to a value relative to the
46f2f11d 4735 start of the section. */
252b5132
RH		 4736 dst->symbol.value = src->u.syment.n_value;
4737#else
4738 dst->symbol.value = (src->u.syment.n_value
4739 - dst->symbol.section->vma);
4740#endif
4741 }
4742 else
4743 dst->symbol.value = src->u.syment.n_value;
4744 break;
4745
ed781d5d
NC		 4746 case C_MOS: /* Member of structure. */
4747 case C_EOS: /* End of structure. */
ed781d5d
NC		 4748 case C_REGPARM: /* Register parameter. */
4749 case C_REG: /* register variable. */
46f2f11d 4750 /* C_AUTOARG conflicts with TI COFF C_UEXT. */
81635ce4 4751#if !defined (TIC80COFF) && !defined (TICOFF)
252b5132 4752#ifdef C_AUTOARG
ed781d5d 4753 case C_AUTOARG: /* 960-specific storage class. */
252b5132
RH		 4754#endif
4755#endif
ed781d5d 4756 case C_TPDEF: /* Type definition. */
252b5132 4757 case C_ARG:
ed781d5d
NC		 4758 case C_AUTO: /* Automatic variable. */
4759 case C_FIELD: /* Bit field. */
4760 case C_ENTAG: /* Enumeration tag. */
4761 case C_MOE: /* Member of enumeration. */
4762 case C_MOU: /* Member of union. */
4763 case C_UNTAG: /* Union tag. */
252b5132
RH		 4764 dst->symbol.flags = BSF_DEBUGGING;
4765 dst->symbol.value = (src->u.syment.n_value);
4766 break;
4767
ed781d5d
NC		 4768 case C_FILE: /* File name. */
4769 case C_STRTAG: /* Structure tag. */
252b5132
RH		 4770#ifdef RS6000COFF_C
4771 case C_GSYM:
4772 case C_LSYM:
4773 case C_PSYM:
4774 case C_RSYM:
4775 case C_RPSYM:
4776 case C_STSYM:
f9f3cf65 4777 case C_TCSYM:
252b5132 4778 case C_BCOMM:
f9f3cf65 4779 case C_ECOML:
252b5132
RH		 4780 case C_ECOMM:
4781 case C_DECL:
4782 case C_ENTRY:
4783 case C_FUN:
4784 case C_ESTAT:
4785#endif
4786 dst->symbol.flags = BSF_DEBUGGING;
4787 dst->symbol.value = (src->u.syment.n_value);
4788 break;
4789
4790#ifdef RS6000COFF_C
ed781d5d
NC		 4791 case C_BINCL: /* Beginning of include file. */
4792 case C_EINCL: /* Ending of include file. */
252b5132 4793 /* The value is actually a pointer into the line numbers
46f2f11d
AM		 4794 of the file. We locate the line number entry, and
4795 set the section to the section which contains it, and
4796 the value to the index in that section. */
252b5132
RH		 4797 {
4798 asection *sec;
4799
4800 dst->symbol.flags = BSF_DEBUGGING;
4801 for (sec = abfd->sections; sec != NULL; sec = sec->next)
4802 if (sec->line_filepos <= (file_ptr) src->u.syment.n_value
4803 && ((file_ptr) (sec->line_filepos
6b3b007b 4804 + sec->lineno_count * bfd_coff_linesz (abfd))
252b5132
RH		 4805 > (file_ptr) src->u.syment.n_value))
4806 break;
4807 if (sec == NULL)
4808 dst->symbol.value = 0;
4809 else
4810 {
4811 dst->symbol.section = sec;
4812 dst->symbol.value = ((src->u.syment.n_value
4813 - sec->line_filepos)
6b3b007b 4814 / bfd_coff_linesz (abfd));
252b5132
RH		 4815 src->fix_line = 1;
4816 }
4817 }
4818 break;
4819
4820 case C_BSTAT:
4821 dst->symbol.flags = BSF_DEBUGGING;
4822
4823 /* The value is actually a symbol index. Save a pointer
4824 to the symbol instead of the index. FIXME: This
4825 should use a union. */
4826 src->u.syment.n_value =
4827 (long) (native_symbols + src->u.syment.n_value);
4828 dst->symbol.value = src->u.syment.n_value;
4829 src->fix_value = 1;
4830 break;
4831#endif
4832
ed781d5d
NC		 4833 case C_BLOCK: /* ".bb" or ".eb". */
4834 case C_FCN: /* ".bf" or ".ef" (or PE ".lf"). */
4835 case C_EFCN: /* Physical end of function. */
252b5132
RH		 4836#if defined COFF_WITH_PE
4837 /* PE sets the symbol to a value relative to the start
4838 of the section. */
4839 dst->symbol.value = src->u.syment.n_value;
d510f9a6
ILT		 4840 if (strcmp (dst->symbol.name, ".bf") != 0)
4841 {
4842 /* PE uses funny values for .ef and .lf; don't
46f2f11d 4843 relocate them. */
d510f9a6
ILT		 4844 dst->symbol.flags = BSF_DEBUGGING;
4845 }
4846 else
4847 dst->symbol.flags = BSF_DEBUGGING | BSF_DEBUGGING_RELOC;
252b5132
RH		 4848#else
4849 /* Base the value as an index from the base of the
4850 section. */
d510f9a6 4851 dst->symbol.flags = BSF_LOCAL;
252b5132
RH		 4852 dst->symbol.value = (src->u.syment.n_value
4853 - dst->symbol.section->vma);
4854#endif
4855 break;
4856
ed781d5d 4857 case C_STATLAB: /* Static load time label. */
46f2f11d
AM		 4858 dst->symbol.value = src->u.syment.n_value;
4859 dst->symbol.flags = BSF_GLOBAL;
4860 break;
34cbe64e 4861
252b5132 4862 case C_NULL:
00692651 4863 /* PE DLLs sometimes have zeroed out symbols for some
46f2f11d 4864 reason. Just ignore them without a warning. */
00692651
ILT		 4865 if (src->u.syment.n_type == 0
4866 && src->u.syment.n_value == 0
4867 && src->u.syment.n_scnum == 0)
4868 break;
4869 /* Fall through. */
ed781d5d
NC		 4870 case C_EXTDEF: /* External definition. */
4871 case C_ULABEL: /* Undefined label. */
4872 case C_USTATIC: /* Undefined static. */
252b5132 4873#ifndef COFF_WITH_PE
46f2f11d
AM		 4874 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4875 class to represent a section symbol. */
ed781d5d 4876 case C_LINE: /* line # reformatted as symbol table entry. */
252b5132 4877 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
ed781d5d 4878 case C_ALIAS: /* Duplicate tag. */
252b5132 4879#endif
ed781d5d 4880 /* New storage classes for TI COFF. */
81635ce4 4881#if defined(TIC80COFF) || defined(TICOFF)
ed781d5d 4882 case C_UEXT: /* Tentative external definition. */
252b5132 4883#endif
ed781d5d
NC		 4884 case C_EXTLAB: /* External load time label. */
4885 case C_HIDDEN: /* Ext symbol in dmert public lib. */
252b5132
RH		 4886 default:
4887 (*_bfd_error_handler)
d003868e
AM		 4888 (_("%B: Unrecognized storage class %d for %s symbol `%s'"),
4889 abfd, src->u.syment.n_sclass,
252b5132
RH		 4890 dst->symbol.section->name, dst->symbol.name);
4891 dst->symbol.flags = BSF_DEBUGGING;
4892 dst->symbol.value = (src->u.syment.n_value);
4893 break;
4894 }
4895
252b5132
RH		 4896 dst->native = src;
4897
4898 dst->symbol.udata.i = 0;
7920ce38 4899 dst->lineno = NULL;
252b5132
RH		 4900 this_index += (src->u.syment.n_numaux) + 1;
4901 dst++;
4902 number_of_symbols++;
ed781d5d
NC		 4903 }
4904 }
252b5132
RH		 4905
4906 obj_symbols (abfd) = cached_area;
4907 obj_raw_syments (abfd) = native_symbols;
4908
4909 bfd_get_symcount (abfd) = number_of_symbols;
4910 obj_convert (abfd) = table_ptr;
ed781d5d 4911 /* Slurp the line tables for each section too. */
252b5132
RH		 4912 {
4913 asection *p;
ed781d5d 4914
252b5132
RH		 4915 p = abfd->sections;
4916 while (p)
4917 {
4918 coff_slurp_line_table (abfd, p);
4919 p = p->next;
4920 }
4921 }
ed781d5d 4922
b34976b6 4923 return TRUE;
7920ce38 4924}
252b5132 4925
5d54c628
ILT		 4926/* Classify a COFF symbol. A couple of targets have globally visible
4927 symbols which are not class C_EXT, and this handles those. It also
4928 recognizes some special PE cases. */
252b5132 4929
5d54c628 4930static enum coff_symbol_classification
7920ce38
NC		 4931coff_classify_symbol (bfd *abfd,
4932 struct internal_syment *syment)
5d54c628
ILT		 4933{
4934 /* FIXME: This partially duplicates the switch in
4935 coff_slurp_symbol_table. */
4936 switch (syment->n_sclass)
4937 {
4938 case C_EXT:
4939 case C_WEAKEXT:
252b5132 4940#ifdef I960
5d54c628 4941 case C_LEAFEXT:
252b5132 4942#endif
5d54c628
ILT		 4943#ifdef ARM
4944 case C_THUMBEXT:
4945 case C_THUMBEXTFUNC:
252b5132 4946#endif
5d54c628
ILT		 4947#ifdef C_SYSTEM
4948 case C_SYSTEM:
252b5132 4949#endif
5d54c628
ILT		 4950#ifdef COFF_WITH_PE
4951 case C_NT_WEAK:
4952#endif
4953 if (syment->n_scnum == 0)
4954 {
4955 if (syment->n_value == 0)
4956 return COFF_SYMBOL_UNDEFINED;
4957 else
4958 return COFF_SYMBOL_COMMON;
4959 }
4960 return COFF_SYMBOL_GLOBAL;
4961
4962 default:
4963 break;
4964 }
252b5132 4965
5d54c628
ILT		 4966#ifdef COFF_WITH_PE
4967 if (syment->n_sclass == C_STAT)
4968 {
4969 if (syment->n_scnum == 0)
7920ce38
NC		 4970 /* The Microsoft compiler sometimes generates these if a
4971 small static function is inlined every time it is used.
4972 The function is discarded, but the symbol table entry
4973 remains. */
4974 return COFF_SYMBOL_LOCAL;
252b5132 4975
0717ebb7 4976#ifdef STRICT_PE_FORMAT
bd826630 4977 /* This is correct for Microsoft generated objects, but it
46f2f11d 4978 breaks gas generated objects. */
5d54c628
ILT		 4979 if (syment->n_value == 0)
4980 {
4981 asection *sec;
4982 char buf[SYMNMLEN + 1];
4983
4984 sec = coff_section_from_bfd_index (abfd, syment->n_scnum);
4985 if (sec != NULL
4986 && (strcmp (bfd_get_section_name (abfd, sec),
4987 _bfd_coff_internal_syment_name (abfd, syment, buf))
4988 == 0))
4989 return COFF_SYMBOL_PE_SECTION;
4990 }
bd826630 4991#endif
252b5132 4992
5d54c628
ILT		 4993 return COFF_SYMBOL_LOCAL;
4994 }
252b5132 4995
5d54c628
ILT		 4996 if (syment->n_sclass == C_SECTION)
4997 {
4998 /* In some cases in a DLL generated by the Microsoft linker, the
46f2f11d
AM		 4999 n_value field will contain garbage. FIXME: This should
5000 probably be handled by the swapping function instead. */
5d54c628
ILT		 5001 syment->n_value = 0;
5002 if (syment->n_scnum == 0)
5003 return COFF_SYMBOL_UNDEFINED;
5004 return COFF_SYMBOL_PE_SECTION;
5005 }
5006#endif /* COFF_WITH_PE */
252b5132 5007
5d54c628 5008 /* If it is not a global symbol, we presume it is a local symbol. */
5d54c628
ILT		 5009 if (syment->n_scnum == 0)
5010 {
5011 char buf[SYMNMLEN + 1];
252b5132 5012
5d54c628 5013 (*_bfd_error_handler)
d003868e
AM		 5014 (_("warning: %B: local symbol `%s' has no section"),
5015 abfd, _bfd_coff_internal_syment_name (abfd, syment, buf));
5d54c628 5016 }
252b5132 5017
5d54c628
ILT		 5018 return COFF_SYMBOL_LOCAL;
5019}
252b5132
RH		 5020
5021/*
5022SUBSUBSECTION
5023 Reading relocations
5024
5025 Coff relocations are easily transformed into the internal BFD form
5026 (@code{arelent}).
5027
5028 Reading a coff relocation table is done in the following stages:
5029
5030 o Read the entire coff relocation table into memory.
5031
5032 o Process each relocation in turn; first swap it from the
5033 external to the internal form.
5034
5035 o Turn the symbol referenced in the relocation's symbol index
5036 into a pointer into the canonical symbol table.
5037 This table is the same as the one returned by a call to
5038 @code{bfd_canonicalize_symtab}. The back end will call that
5039 routine and save the result if a canonicalization hasn't been done.
5040
5041 o The reloc index is turned into a pointer to a howto
5042 structure, in a back end specific way. For instance, the 386
5043 and 960 use the @code{r_type} to directly produce an index
5044 into a howto table vector; the 88k subtracts a number from the
5045 @code{r_type} field and creates an addend field.
252b5132
RH		 5046*/
5047
5048#ifndef CALC_ADDEND
46f2f11d
AM		 5049#define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
5050 { \
5051 coff_symbol_type *coffsym = NULL; \
5052 \
5053 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
5054 coffsym = (obj_symbols (abfd) \
5055 + (cache_ptr->sym_ptr_ptr - symbols)); \
5056 else if (ptr) \
5057 coffsym = coff_symbol_from (abfd, ptr); \
5058 if (coffsym != NULL \
5059 && coffsym->native->u.syment.n_scnum == 0) \
5060 cache_ptr->addend = 0; \
5061 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
5062 && ptr->section != NULL) \
5063 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
5064 else \
5065 cache_ptr->addend = 0; \
252b5132
RH		 5066 }
5067#endif
5068
b34976b6 5069static bfd_boolean
7920ce38 5070coff_slurp_reloc_table (bfd * abfd, sec_ptr asect, asymbol ** symbols)
252b5132
RH		 5071{
5072 RELOC *native_relocs;
5073 arelent *reloc_cache;
5074 arelent *cache_ptr;
252b5132 5075 unsigned int idx;
dc810e39 5076 bfd_size_type amt;
252b5132
RH		 5077
5078 if (asect->relocation)
b34976b6 5079 return TRUE;
252b5132 5080 if (asect->reloc_count == 0)
b34976b6 5081 return TRUE;
252b5132 5082 if (asect->flags & SEC_CONSTRUCTOR)
b34976b6 5083 return TRUE;
252b5132 5084 if (!coff_slurp_symbol_table (abfd))
b34976b6 5085 return FALSE;
7920ce38 5086
dc810e39
AM		 5087 amt = (bfd_size_type) bfd_coff_relsz (abfd) * asect->reloc_count;
5088 native_relocs = (RELOC *) buy_and_read (abfd, asect->rel_filepos, amt);
5089 amt = (bfd_size_type) asect->reloc_count * sizeof (arelent);
7920ce38 5090 reloc_cache = bfd_alloc (abfd, amt);
252b5132 5091
a50b2160 5092 if (reloc_cache == NULL || native_relocs == NULL)
b34976b6 5093 return FALSE;
252b5132 5094
252b5132
RH		 5095 for (idx = 0; idx < asect->reloc_count; idx++)
5096 {
5097 struct internal_reloc dst;
5098 struct external_reloc *src;
5099#ifndef RELOC_PROCESSING
5100 asymbol *ptr;
5101#endif
5102
5103 cache_ptr = reloc_cache + idx;
5104 src = native_relocs + idx;
5105
40b1c6c5 5106 dst.r_offset = 0;
252b5132
RH		 5107 coff_swap_reloc_in (abfd, src, &dst);
5108
5109#ifdef RELOC_PROCESSING
5110 RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
5111#else
5112 cache_ptr->address = dst.r_vaddr;
5113
5114 if (dst.r_symndx != -1)
5115 {
5116 if (dst.r_symndx < 0 || dst.r_symndx >= obj_conv_table_size (abfd))
5117 {
5118 (*_bfd_error_handler)
d003868e
AM		 5119 (_("%B: warning: illegal symbol index %ld in relocs"),
5120 abfd, dst.r_symndx);
252b5132
RH		 5121 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
5122 ptr = NULL;
5123 }
5124 else
5125 {
5126 cache_ptr->sym_ptr_ptr = (symbols
5127 + obj_convert (abfd)[dst.r_symndx]);
5128 ptr = *(cache_ptr->sym_ptr_ptr);
5129 }
5130 }
5131 else
5132 {
5133 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
5134 ptr = NULL;
5135 }
5136
5137 /* The symbols definitions that we have read in have been
5138 relocated as if their sections started at 0. But the offsets
5139 refering to the symbols in the raw data have not been
5140 modified, so we have to have a negative addend to compensate.
5141
ed781d5d 5142 Note that symbols which used to be common must be left alone. */
252b5132 5143
ed781d5d 5144 /* Calculate any reloc addend by looking at the symbol. */
252b5132
RH		 5145 CALC_ADDEND (abfd, ptr, dst, cache_ptr);
5146
5147 cache_ptr->address -= asect->vma;
7920ce38 5148 /* !! cache_ptr->section = NULL;*/
252b5132 5149
ed781d5d 5150 /* Fill in the cache_ptr->howto field from dst.r_type. */
252b5132
RH		 5151 RTYPE2HOWTO (cache_ptr, &dst);
5152#endif /* RELOC_PROCESSING */
5153
5154 if (cache_ptr->howto == NULL)
5155 {
5156 (*_bfd_error_handler)
d003868e
AM		 5157 (_("%B: illegal relocation type %d at address 0x%lx"),
5158 abfd, dst.r_type, (long) dst.r_vaddr);
252b5132 5159 bfd_set_error (bfd_error_bad_value);
b34976b6 5160 return FALSE;
252b5132
RH		 5161 }
5162 }
5163
5164 asect->relocation = reloc_cache;
b34976b6 5165 return TRUE;
252b5132
RH		 5166}
5167
5168#ifndef coff_rtype_to_howto
5169#ifdef RTYPE2HOWTO
5170
5171/* Get the howto structure for a reloc. This is only used if the file
5172 including this one defines coff_relocate_section to be
5173 _bfd_coff_generic_relocate_section, so it is OK if it does not
5174 always work. It is the responsibility of the including file to
5175 make sure it is reasonable if it is needed. */
5176
252b5132 5177static reloc_howto_type *
7920ce38
NC		 5178coff_rtype_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
5179 asection *sec ATTRIBUTE_UNUSED,
5180 struct internal_reloc *rel,
5181 struct coff_link_hash_entry *h ATTRIBUTE_UNUSED,
5182 struct internal_syment *sym ATTRIBUTE_UNUSED,
5183 bfd_vma *addendp ATTRIBUTE_UNUSED)
252b5132
RH		 5184{
5185 arelent genrel;
5186
964597d0 5187 genrel.howto = NULL;
252b5132
RH		 5188 RTYPE2HOWTO (&genrel, rel);
5189 return genrel.howto;
5190}
5191
5192#else /* ! defined (RTYPE2HOWTO) */
5193
5194#define coff_rtype_to_howto NULL
5195
5196#endif /* ! defined (RTYPE2HOWTO) */
5197#endif /* ! defined (coff_rtype_to_howto) */
5198
5199/* This is stupid. This function should be a boolean predicate. */
7920ce38 5200
252b5132 5201static long
7920ce38
NC		 5202coff_canonicalize_reloc (bfd * abfd,
5203 sec_ptr section,
5204 arelent ** relptr,
5205 asymbol ** symbols)
252b5132
RH		 5206{
5207 arelent *tblptr = section->relocation;
5208 unsigned int count = 0;
5209
252b5132
RH		 5210 if (section->flags & SEC_CONSTRUCTOR)
5211 {
ed781d5d
NC		 5212 /* This section has relocs made up by us, they are not in the
5213 file, so take them out of their chain and place them into
5214 the data area provided. */
252b5132 5215 arelent_chain *chain = section->constructor_chain;
ed781d5d 5216
252b5132
RH		 5217 for (count = 0; count < section->reloc_count; count++)
5218 {
5219 *relptr++ = &chain->relent;
5220 chain = chain->next;
5221 }
252b5132
RH		 5222 }
5223 else
5224 {
5225 if (! coff_slurp_reloc_table (abfd, section, symbols))
5226 return -1;
5227
5228 tblptr = section->relocation;
5229
5230 for (; count++ < section->reloc_count;)
5231 *relptr++ = tblptr++;
252b5132
RH		 5232 }
5233 *relptr = 0;
5234 return section->reloc_count;
5235}
5236
252b5132
RH		 5237#ifndef coff_reloc16_estimate
5238#define coff_reloc16_estimate dummy_reloc16_estimate
5239
252b5132 5240static int
7920ce38
NC		 5241dummy_reloc16_estimate (bfd *abfd ATTRIBUTE_UNUSED,
5242 asection *input_section ATTRIBUTE_UNUSED,
5243 arelent *reloc ATTRIBUTE_UNUSED,
5244 unsigned int shrink ATTRIBUTE_UNUSED,
5245 struct bfd_link_info *link_info ATTRIBUTE_UNUSED)
252b5132
RH		 5246{
5247 abort ();
00692651 5248 return 0;
252b5132
RH		 5249}
5250
5251#endif
5252
5253#ifndef coff_reloc16_extra_cases
5254
5255#define coff_reloc16_extra_cases dummy_reloc16_extra_cases
5256
5257/* This works even if abort is not declared in any header file. */
5258
252b5132 5259static void
7920ce38
NC		 5260dummy_reloc16_extra_cases (bfd *abfd ATTRIBUTE_UNUSED,
5261 struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
5262 struct bfd_link_order *link_order ATTRIBUTE_UNUSED,
5263 arelent *reloc ATTRIBUTE_UNUSED,
5264 bfd_byte *data ATTRIBUTE_UNUSED,
5265 unsigned int *src_ptr ATTRIBUTE_UNUSED,
5266 unsigned int *dst_ptr ATTRIBUTE_UNUSED)
252b5132
RH		 5267{
5268 abort ();
5269}
5270#endif
5271
e2d34d7d
DJ		 5272#ifndef coff_bfd_link_hash_table_free
5273#define coff_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
5274#endif
5275
252b5132
RH		 5276/* If coff_relocate_section is defined, we can use the optimized COFF
5277 backend linker. Otherwise we must continue to use the old linker. */
7920ce38 5278
252b5132 5279#ifdef coff_relocate_section
7920ce38 5280
252b5132
RH		 5281#ifndef coff_bfd_link_hash_table_create
5282#define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
5283#endif
5284#ifndef coff_bfd_link_add_symbols
5285#define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
5286#endif
5287#ifndef coff_bfd_final_link
5288#define coff_bfd_final_link _bfd_coff_final_link
5289#endif
7920ce38 5290
252b5132 5291#else /* ! defined (coff_relocate_section) */
7920ce38 5292
252b5132
RH		 5293#define coff_relocate_section NULL
5294#ifndef coff_bfd_link_hash_table_create
5295#define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
5296#endif
5297#ifndef coff_bfd_link_add_symbols
5298#define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
5299#endif
5300#define coff_bfd_final_link _bfd_generic_final_link
7920ce38 5301
252b5132
RH		 5302#endif /* ! defined (coff_relocate_section) */
5303
7920ce38 5304#define coff_bfd_link_just_syms _bfd_generic_link_just_syms
252b5132
RH		 5305#define coff_bfd_link_split_section _bfd_generic_link_split_section
5306
5307#ifndef coff_start_final_link
5308#define coff_start_final_link NULL
5309#endif
5310
5311#ifndef coff_adjust_symndx
5312#define coff_adjust_symndx NULL
5313#endif
5314
5315#ifndef coff_link_add_one_symbol
5316#define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
5317#endif
5318
5319#ifndef coff_link_output_has_begun
5320
b34976b6 5321static bfd_boolean
7920ce38
NC		 5322coff_link_output_has_begun (bfd * abfd,
5323 struct coff_final_link_info * info ATTRIBUTE_UNUSED)
252b5132
RH		 5324{
5325 return abfd->output_has_begun;
5326}
5327#endif
5328
5329#ifndef coff_final_link_postscript
5330
b34976b6 5331static bfd_boolean
7920ce38
NC		 5332coff_final_link_postscript (bfd * abfd ATTRIBUTE_UNUSED,
5333 struct coff_final_link_info * pfinfo ATTRIBUTE_UNUSED)
252b5132 5334{
b34976b6 5335 return TRUE;
252b5132
RH		 5336}
5337#endif
5338
5339#ifndef coff_SWAP_aux_in
5340#define coff_SWAP_aux_in coff_swap_aux_in
5341#endif
5342#ifndef coff_SWAP_sym_in
5343#define coff_SWAP_sym_in coff_swap_sym_in
5344#endif
5345#ifndef coff_SWAP_lineno_in
5346#define coff_SWAP_lineno_in coff_swap_lineno_in
5347#endif
5348#ifndef coff_SWAP_aux_out
5349#define coff_SWAP_aux_out coff_swap_aux_out
5350#endif
5351#ifndef coff_SWAP_sym_out
5352#define coff_SWAP_sym_out coff_swap_sym_out
5353#endif
5354#ifndef coff_SWAP_lineno_out
5355#define coff_SWAP_lineno_out coff_swap_lineno_out
5356#endif
5357#ifndef coff_SWAP_reloc_out
5358#define coff_SWAP_reloc_out coff_swap_reloc_out
5359#endif
5360#ifndef coff_SWAP_filehdr_out
5361#define coff_SWAP_filehdr_out coff_swap_filehdr_out
5362#endif
5363#ifndef coff_SWAP_aouthdr_out
5364#define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5365#endif
5366#ifndef coff_SWAP_scnhdr_out
5367#define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5368#endif
5369#ifndef coff_SWAP_reloc_in
5370#define coff_SWAP_reloc_in coff_swap_reloc_in
5371#endif
5372#ifndef coff_SWAP_filehdr_in
5373#define coff_SWAP_filehdr_in coff_swap_filehdr_in
5374#endif
5375#ifndef coff_SWAP_aouthdr_in
5376#define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5377#endif
5378#ifndef coff_SWAP_scnhdr_in
5379#define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5380#endif
5381
88183869 5382static bfd_coff_backend_data bfd_coff_std_swap_table ATTRIBUTE_UNUSED =
252b5132
RH		 5383{
5384 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5385 coff_SWAP_aux_out, coff_SWAP_sym_out,
5386 coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5387 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5388 coff_SWAP_scnhdr_out,
692b7d62 5389 FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
252b5132 5390#ifdef COFF_LONG_FILENAMES
b34976b6 5391 TRUE,
252b5132 5392#else
b34976b6 5393 FALSE,
252b5132 5394#endif
88183869 5395 COFF_DEFAULT_LONG_SECTION_NAMES,
a022216b 5396 COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
7f6d05e8 5397#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
b34976b6 5398 TRUE,
7f6d05e8 5399#else
b34976b6 5400 FALSE,
7f6d05e8
CP		 5401#endif
5402#ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5403 4,
5404#else
5405 2,
5406#endif
252b5132
RH		 5407 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5408 coff_SWAP_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook,
5409 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5410 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5411 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5d54c628 5412 coff_classify_symbol, coff_compute_section_file_positions,
252b5132
RH		 5413 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5414 coff_adjust_symndx, coff_link_add_one_symbol,
2b5c217d
NC		 5415 coff_link_output_has_begun, coff_final_link_postscript,
5416 bfd_pe_print_pdata
252b5132
RH		 5417};
5418
5a5b9651
SS		 5419#ifdef TICOFF
5420/* COFF0 differs in file/section header size and relocation entry size. */
7920ce38 5421
88183869 5422static bfd_coff_backend_data ticoff0_swap_table =
5a5b9651
SS		 5423{
5424 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5425 coff_SWAP_aux_out, coff_SWAP_sym_out,
5426 coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5427 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5428 coff_SWAP_scnhdr_out,
5429 FILHSZ_V0, AOUTSZ, SCNHSZ_V01, SYMESZ, AUXESZ, RELSZ_V0, LINESZ, FILNMLEN,
5430#ifdef COFF_LONG_FILENAMES
5431 TRUE,
5432#else
5433 FALSE,
5434#endif
88183869 5435 COFF_DEFAULT_LONG_SECTION_NAMES,
5a5b9651
SS		 5436 COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5437#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5438 TRUE,
5439#else
5440 FALSE,
5441#endif
5442#ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5443 4,
5444#else
5445 2,
5446#endif
5447 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5448 coff_SWAP_reloc_in, ticoff0_bad_format_hook, coff_set_arch_mach_hook,
5449 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5450 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5451 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5452 coff_classify_symbol, coff_compute_section_file_positions,
5453 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5454 coff_adjust_symndx, coff_link_add_one_symbol,
2b5c217d
NC		 5455 coff_link_output_has_begun, coff_final_link_postscript,
5456 bfd_pe_print_pdata
5a5b9651
SS		 5457};
5458#endif
5459
5460#ifdef TICOFF
5461/* COFF1 differs in section header size. */
7920ce38 5462
88183869 5463static bfd_coff_backend_data ticoff1_swap_table =
5a5b9651
SS		 5464{
5465 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5466 coff_SWAP_aux_out, coff_SWAP_sym_out,
5467 coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5468 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5469 coff_SWAP_scnhdr_out,
5470 FILHSZ, AOUTSZ, SCNHSZ_V01, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
5471#ifdef COFF_LONG_FILENAMES
5472 TRUE,
5473#else
5474 FALSE,
5475#endif
88183869 5476 COFF_DEFAULT_LONG_SECTION_NAMES,
5a5b9651
SS		 5477 COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5478#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5479 TRUE,
5480#else
5481 FALSE,
5482#endif
5483#ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5484 4,
5485#else
5486 2,
5487#endif
5488 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5489 coff_SWAP_reloc_in, ticoff1_bad_format_hook, coff_set_arch_mach_hook,
5490 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5491 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5492 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5493 coff_classify_symbol, coff_compute_section_file_positions,
5494 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5495 coff_adjust_symndx, coff_link_add_one_symbol,
2b5c217d
NC		 5496 coff_link_output_has_begun, coff_final_link_postscript,
5497 bfd_pe_print_pdata /* huh */
5a5b9651
SS		 5498};
5499#endif
5500
252b5132 5501#ifndef coff_close_and_cleanup
46f2f11d 5502#define coff_close_and_cleanup _bfd_generic_close_and_cleanup
252b5132
RH		 5503#endif
5504
5505#ifndef coff_bfd_free_cached_info
46f2f11d 5506#define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
252b5132
RH		 5507#endif
5508
5509#ifndef coff_get_section_contents
46f2f11d 5510#define coff_get_section_contents _bfd_generic_get_section_contents
252b5132
RH		 5511#endif
5512
5513#ifndef coff_bfd_copy_private_symbol_data
5514#define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5515#endif
5516
80fccad2
BW		 5517#ifndef coff_bfd_copy_private_header_data
5518#define coff_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data
5519#endif
5520
252b5132
RH		 5521#ifndef coff_bfd_copy_private_section_data
5522#define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5523#endif
5524
e60b52c6 5525#ifndef coff_bfd_copy_private_bfd_data
252b5132
RH		 5526#define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5527#endif
5528
5529#ifndef coff_bfd_merge_private_bfd_data
5530#define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5531#endif
5532
5533#ifndef coff_bfd_set_private_flags
46f2f11d 5534#define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
252b5132
RH		 5535#endif
5536
e60b52c6 5537#ifndef coff_bfd_print_private_bfd_data
252b5132
RH		 5538#define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5539#endif
5540
5541#ifndef coff_bfd_is_local_label_name
5542#define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5543#endif
5544
3c9458e9
NC		 5545#ifndef coff_bfd_is_target_special_symbol
5546#define coff_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
5547#endif
5548
252b5132
RH		 5549#ifndef coff_read_minisymbols
5550#define coff_read_minisymbols _bfd_generic_read_minisymbols
5551#endif
5552
5553#ifndef coff_minisymbol_to_symbol
5554#define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5555#endif
5556
5557/* The reloc lookup routine must be supplied by each individual COFF
5558 backend. */
5559#ifndef coff_bfd_reloc_type_lookup
5560#define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5561#endif
157090f7
AM		 5562#ifndef coff_bfd_reloc_name_lookup
5563#define coff_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
5564#endif
252b5132
RH		 5565
5566#ifndef coff_bfd_get_relocated_section_contents
5567#define coff_bfd_get_relocated_section_contents \
5568 bfd_generic_get_relocated_section_contents
5569#endif
5570
5571#ifndef coff_bfd_relax_section
5572#define coff_bfd_relax_section bfd_generic_relax_section
5573#endif
5574
5575#ifndef coff_bfd_gc_sections
5576#define coff_bfd_gc_sections bfd_generic_gc_sections
5577#endif
c3c89269 5578
8550eb6e
JJ		 5579#ifndef coff_bfd_merge_sections
5580#define coff_bfd_merge_sections bfd_generic_merge_sections
5581#endif
5582
72adc230
AM		 5583#ifndef coff_bfd_is_group_section
5584#define coff_bfd_is_group_section bfd_generic_is_group_section
5585#endif
5586
e61463e1
AM		 5587#ifndef coff_bfd_discard_group
5588#define coff_bfd_discard_group bfd_generic_discard_group
5589#endif
5590
082b7297
L		 5591#ifndef coff_section_already_linked
5592#define coff_section_already_linked \
5593 _bfd_generic_section_already_linked
5594#endif
5595
3fa78519 5596#define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
4c117b10
ILT		 5597const bfd_target VAR = \
5598{ \
5599 NAME , \
5600 bfd_target_coff_flavour, \
7920ce38
NC		 5601 BFD_ENDIAN_BIG, /* Data byte order is big. */ \
5602 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
4c117b10
ILT		 5603 /* object flags */ \
5604 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5605 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5606 /* section flags */ \
5607 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
7920ce38
NC		 5608 UNDER, /* Leading symbol underscore. */ \
5609 '/', /* AR_pad_char. */ \
5610 15, /* AR_max_namelen. */ \
46f2f11d 5611 \
4c117b10
ILT		 5612 /* Data conversion functions. */ \
5613 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5614 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5615 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
46f2f11d 5616 \
4c117b10
ILT		 5617 /* Header conversion functions. */ \
5618 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5619 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5620 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5621 \
7920ce38 5622 /* bfd_check_format. */ \
4c117b10
ILT		 5623 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5624 _bfd_dummy_target }, \
7920ce38 5625 /* bfd_set_format. */ \
4c117b10 5626 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
7920ce38 5627 /* bfd_write_contents. */ \
4c117b10
ILT		 5628 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5629 bfd_false }, \
5630 \
5631 BFD_JUMP_TABLE_GENERIC (coff), \
5632 BFD_JUMP_TABLE_COPY (coff), \
5633 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5634 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5635 BFD_JUMP_TABLE_SYMBOLS (coff), \
5636 BFD_JUMP_TABLE_RELOCS (coff), \
5637 BFD_JUMP_TABLE_WRITE (coff), \
5638 BFD_JUMP_TABLE_LINK (coff), \
5639 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
46f2f11d 5640 \
4c117b10 5641 ALTERNATIVE, \
46f2f11d 5642 \
3fa78519 5643 SWAP_TABLE \
c3c89269
NC		 5644};
5645
3fa78519
SS		 5646#define CREATE_BIGHDR_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
5647const bfd_target VAR = \
5648{ \
5649 NAME , \
5650 bfd_target_coff_flavour, \
7920ce38
NC		 5651 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
5652 BFD_ENDIAN_BIG, /* Header byte order is big. */ \
3fa78519
SS		 5653 /* object flags */ \
5654 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5655 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5656 /* section flags */ \
5657 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
7920ce38
NC		 5658 UNDER, /* Leading symbol underscore. */ \
5659 '/', /* AR_pad_char. */ \
5660 15, /* AR_max_namelen. */ \
46f2f11d 5661 \
3fa78519
SS		 5662 /* Data conversion functions. */ \
5663 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5664 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5665 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
46f2f11d 5666 \
3fa78519
SS		 5667 /* Header conversion functions. */ \
5668 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5669 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5670 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5671 \
7920ce38 5672 /* bfd_check_format. */ \
3fa78519
SS		 5673 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5674 _bfd_dummy_target }, \
7920ce38 5675 /* bfd_set_format. */ \
3fa78519 5676 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
7920ce38 5677 /* bfd_write_contents. */ \
3fa78519
SS		 5678 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5679 bfd_false }, \
5680 \
5681 BFD_JUMP_TABLE_GENERIC (coff), \
5682 BFD_JUMP_TABLE_COPY (coff), \
5683 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5684 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5685 BFD_JUMP_TABLE_SYMBOLS (coff), \
5686 BFD_JUMP_TABLE_RELOCS (coff), \
5687 BFD_JUMP_TABLE_WRITE (coff), \
5688 BFD_JUMP_TABLE_LINK (coff), \
5689 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
46f2f11d 5690 \
3fa78519 5691 ALTERNATIVE, \
46f2f11d 5692 \
3fa78519
SS		 5693 SWAP_TABLE \
5694};
5695
5696#define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE, SWAP_TABLE) \
4c117b10
ILT		 5697const bfd_target VAR = \
5698{ \
5699 NAME , \
5700 bfd_target_coff_flavour, \
7920ce38
NC		 5701 BFD_ENDIAN_LITTLE, /* Data byte order is little. */ \
5702 BFD_ENDIAN_LITTLE, /* Header byte order is little. */ \
4c117b10
ILT		 5703 /* object flags */ \
5704 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5705 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5706 /* section flags */ \
5707 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
7920ce38
NC		 5708 UNDER, /* Leading symbol underscore. */ \
5709 '/', /* AR_pad_char. */ \
5710 15, /* AR_max_namelen. */ \
4c117b10
ILT		 5711 \
5712 /* Data conversion functions. */ \
5713 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5714 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5715 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5716 /* Header conversion functions. */ \
5717 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5718 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5719 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
7920ce38 5720 /* bfd_check_format. */ \
4c117b10
ILT		 5721 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5722 _bfd_dummy_target }, \
7920ce38 5723 /* bfd_set_format. */ \
4c117b10 5724 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
7920ce38 5725 /* bfd_write_contents. */ \
4c117b10
ILT		 5726 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5727 bfd_false }, \
5728 \
5729 BFD_JUMP_TABLE_GENERIC (coff), \
5730 BFD_JUMP_TABLE_COPY (coff), \
5731 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5732 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5733 BFD_JUMP_TABLE_SYMBOLS (coff), \
5734 BFD_JUMP_TABLE_RELOCS (coff), \
5735 BFD_JUMP_TABLE_WRITE (coff), \
5736 BFD_JUMP_TABLE_LINK (coff), \
5737 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5738 \
5739 ALTERNATIVE, \
46f2f11d 5740 \
3fa78519 5741 SWAP_TABLE \
c3c89269 5742};
A mirror of the official binutils-gdb repository