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