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