projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* Makefile.am: Rename .dep* files to DEP*. Change DEP variable to
[deliverable/binutils-gdb.git] / bfd / coffcode.h
CommitLineData
252b5132 1/* Support for the generic parts of most COFF variants, for BFD.
5f771d47 2 Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 98, 1999
252b5132
RH		 3 Free Software Foundation, Inc.
4 Written by Cygnus Support.
5
6This file is part of BFD, the Binary File Descriptor library.
7
8This program is free software; you can redistribute it and/or modify
9it under the terms of the GNU General Public License as published by
10the Free Software Foundation; either version 2 of the License, or
11(at your option) any later version.
12
13This program is distributed in the hope that it will be useful,
14but WITHOUT ANY WARRANTY; without even the implied warranty of
15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16GNU General Public License for more details.
17
18You should have received a copy of the GNU General Public License
19along with this program; if not, write to the Free Software
20Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21
22/*
23Most of this hacked by Steve Chamberlain,
24 sac@cygnus.com
25*/
26/*
27
28SECTION
29 coff backends
30
31 BFD supports a number of different flavours of coff format.
32 The major differences between formats are the sizes and
33 alignments of fields in structures on disk, and the occasional
34 extra field.
35
36 Coff in all its varieties is implemented with a few common
37 files and a number of implementation specific files. For
38 example, The 88k bcs coff format is implemented in the file
39 @file{coff-m88k.c}. This file @code{#include}s
40 @file{coff/m88k.h} which defines the external structure of the
41 coff format for the 88k, and @file{coff/internal.h} which
42 defines the internal structure. @file{coff-m88k.c} also
43 defines the relocations used by the 88k format
44 @xref{Relocations}.
45
46 The Intel i960 processor version of coff is implemented in
47 @file{coff-i960.c}. This file has the same structure as
48 @file{coff-m88k.c}, except that it includes @file{coff/i960.h}
49 rather than @file{coff-m88k.h}.
50
51SUBSECTION
52 Porting to a new version of coff
53
54 The recommended method is to select from the existing
55 implementations the version of coff which is most like the one
56 you want to use. For example, we'll say that i386 coff is
57 the one you select, and that your coff flavour is called foo.
58 Copy @file{i386coff.c} to @file{foocoff.c}, copy
59 @file{../include/coff/i386.h} to @file{../include/coff/foo.h},
60 and add the lines to @file{targets.c} and @file{Makefile.in}
61 so that your new back end is used. Alter the shapes of the
62 structures in @file{../include/coff/foo.h} so that they match
63 what you need. You will probably also have to add
64 @code{#ifdef}s to the code in @file{coff/internal.h} and
65 @file{coffcode.h} if your version of coff is too wild.
66
67 You can verify that your new BFD backend works quite simply by
68 building @file{objdump} from the @file{binutils} directory,
69 and making sure that its version of what's going on and your
70 host system's idea (assuming it has the pretty standard coff
71 dump utility, usually called @code{att-dump} or just
72 @code{dump}) are the same. Then clean up your code, and send
73 what you've done to Cygnus. Then your stuff will be in the
74 next release, and you won't have to keep integrating it.
75
76SUBSECTION
77 How the coff backend works
78
79SUBSUBSECTION
80 File layout
81
82 The Coff backend is split into generic routines that are
83 applicable to any Coff target and routines that are specific
84 to a particular target. The target-specific routines are
85 further split into ones which are basically the same for all
86 Coff targets except that they use the external symbol format
87 or use different values for certain constants.
88
89 The generic routines are in @file{coffgen.c}. These routines
90 work for any Coff target. They use some hooks into the target
91 specific code; the hooks are in a @code{bfd_coff_backend_data}
92 structure, one of which exists for each target.
93
94 The essentially similar target-specific routines are in
95 @file{coffcode.h}. This header file includes executable C code.
96 The various Coff targets first include the appropriate Coff
97 header file, make any special defines that are needed, and
98 then include @file{coffcode.h}.
99
100 Some of the Coff targets then also have additional routines in
101 the target source file itself.
102
103 For example, @file{coff-i960.c} includes
104 @file{coff/internal.h} and @file{coff/i960.h}. It then
105 defines a few constants, such as @code{I960}, and includes
106 @file{coffcode.h}. Since the i960 has complex relocation
107 types, @file{coff-i960.c} also includes some code to
108 manipulate the i960 relocs. This code is not in
109 @file{coffcode.h} because it would not be used by any other
110 target.
111
112SUBSUBSECTION
113 Bit twiddling
114
115 Each flavour of coff supported in BFD has its own header file
116 describing the external layout of the structures. There is also
117 an internal description of the coff layout, in
118 @file{coff/internal.h}. A major function of the
119 coff backend is swapping the bytes and twiddling the bits to
120 translate the external form of the structures into the normal
121 internal form. This is all performed in the
122 @code{bfd_swap}_@i{thing}_@i{direction} routines. Some
123 elements are different sizes between different versions of
124 coff; it is the duty of the coff version specific include file
125 to override the definitions of various packing routines in
126 @file{coffcode.h}. E.g., the size of line number entry in coff is
127 sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
128 @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
129 correct one. No doubt, some day someone will find a version of
130 coff which has a varying field size not catered to at the
131 moment. To port BFD, that person will have to add more @code{#defines}.
132 Three of the bit twiddling routines are exported to
133 @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
134 and @code{coff_swap_linno_in}. @code{GDB} reads the symbol
135 table on its own, but uses BFD to fix things up. More of the
136 bit twiddlers are exported for @code{gas};
137 @code{coff_swap_aux_out}, @code{coff_swap_sym_out},
138 @code{coff_swap_lineno_out}, @code{coff_swap_reloc_out},
139 @code{coff_swap_filehdr_out}, @code{coff_swap_aouthdr_out},
140 @code{coff_swap_scnhdr_out}. @code{Gas} currently keeps track
141 of all the symbol table and reloc drudgery itself, thereby
142 saving the internal BFD overhead, but uses BFD to swap things
143 on the way out, making cross ports much safer. Doing so also
144 allows BFD (and thus the linker) to use the same header files
145 as @code{gas}, which makes one avenue to disaster disappear.
146
147SUBSUBSECTION
148 Symbol reading
149
150 The simple canonical form for symbols used by BFD is not rich
151 enough to keep all the information available in a coff symbol
152 table. The back end gets around this problem by keeping the original
153 symbol table around, "behind the scenes".
154
155 When a symbol table is requested (through a call to
156 @code{bfd_canonicalize_symtab}), a request gets through to
157 @code{coff_get_normalized_symtab}. This reads the symbol table from
158 the coff file and swaps all the structures inside into the
159 internal form. It also fixes up all the pointers in the table
160 (represented in the file by offsets from the first symbol in
161 the table) into physical pointers to elements in the new
162 internal table. This involves some work since the meanings of
163 fields change depending upon context: a field that is a
164 pointer to another structure in the symbol table at one moment
165 may be the size in bytes of a structure at the next. Another
166 pass is made over the table. All symbols which mark file names
167 (<<C_FILE>> symbols) are modified so that the internal
168 string points to the value in the auxent (the real filename)
169 rather than the normal text associated with the symbol
170 (@code{".file"}).
171
172 At this time the symbol names are moved around. Coff stores
173 all symbols less than nine characters long physically
174 within the symbol table; longer strings are kept at the end of
175 the file in the string table. This pass moves all strings
176 into memory and replaces them with pointers to the strings.
177
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
189SUBSUBSECTION
190 Symbol writing
191
192 Writing a symbol to a coff file which didn't come from a coff
193 file will lose any debugging information. The @code{asymbol}
194 structure remembers the BFD from which the symbol was taken, and on
195 output the back end makes sure that the same destination target as
196 source target is present.
197
198 When the symbols have come from a coff file then all the
199 debugging information is preserved.
200
201 Symbol tables are provided for writing to the back end in a
202 vector of pointers to pointers. This allows applications like
203 the linker to accumulate and output large symbol tables
204 without having to do too much byte copying.
205
206 This function runs through the provided symbol table and
207 patches each symbol marked as a file place holder
208 (@code{C_FILE}) to point to the next file place holder in the
209 list. It also marks each @code{offset} field in the list with
210 the offset from the first symbol of the current symbol.
211
212 Another function of this procedure is to turn the canonical
213 value form of BFD into the form used by coff. Internally, BFD
214 expects symbol values to be offsets from a section base; so a
215 symbol physically at 0x120, but in a section starting at
216 0x100, would have the value 0x20. Coff expects symbols to
217 contain their final value, so symbols have their values
218 changed at this point to reflect their sum with their owning
219 section. This transformation uses the
220 <<output_section>> field of the @code{asymbol}'s
221 @code{asection} @xref{Sections}.
222
223 o <<coff_mangle_symbols>>
224
225 This routine runs though the provided symbol table and uses
226 the offsets generated by the previous pass and the pointers
227 generated when the symbol table was read in to create the
228 structured hierachy 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/*
240INTERNAL_DEFINITION
241 coff_symbol_type
242
243DESCRIPTION
244 The hidden information for an <<asymbol>> is described in a
245 <<combined_entry_type>>:
246
247CODE_FRAGMENT
248.
249.typedef struct coff_ptr_struct
250.{
251.
252. {* Remembers the offset from the first symbol in the file for
253. this symbol. Generated by coff_renumber_symbols. *}
254.unsigned int offset;
255.
256. {* Should the value of this symbol be renumbered. Used for
257. XCOFF C_BSTAT symbols. Set by coff_slurp_symbol_table. *}
258.unsigned int fix_value : 1;
259.
260. {* Should the tag field of this symbol be renumbered.
261. Created by coff_pointerize_aux. *}
262.unsigned int fix_tag : 1;
263.
264. {* Should the endidx field of this symbol be renumbered.
265. Created by coff_pointerize_aux. *}
266.unsigned int fix_end : 1;
267.
268. {* Should the x_csect.x_scnlen field be renumbered.
269. Created by coff_pointerize_aux. *}
270.unsigned int fix_scnlen : 1;
271.
272. {* Fix up an XCOFF C_BINCL/C_EINCL symbol. The value is the
273. index into the line number entries. Set by
274. coff_slurp_symbol_table. *}
275.unsigned int fix_line : 1;
276.
277. {* The container for the symbol structure as read and translated
278. from the file. *}
279.
280.union {
281. union internal_auxent auxent;
282. struct internal_syment syment;
283. } u;
284.} combined_entry_type;
285.
286.
287.{* Each canonical asymbol really looks like this: *}
288.
289.typedef struct coff_symbol_struct
290.{
291. {* The actual symbol which the rest of BFD works with *}
292.asymbol symbol;
293.
294. {* A pointer to the hidden information for this symbol *}
295.combined_entry_type *native;
296.
297. {* A pointer to the linenumber information for this symbol *}
298.struct lineno_cache_entry *lineno;
299.
300. {* Have the line numbers been relocated yet ? *}
301.boolean done_lineno;
302.} coff_symbol_type;
303
304
305*/
306
307#ifdef COFF_WITH_PE
308#include "peicode.h"
309#else
310#include "coffswap.h"
311#endif
312
313#define STRING_SIZE_SIZE (4)
314
315static long sec_to_styp_flags PARAMS ((const char *, flagword));
316static flagword styp_to_sec_flags PARAMS ((bfd *, PTR, const char *));
317static boolean coff_bad_format_hook PARAMS ((bfd *, PTR));
318static boolean coff_new_section_hook PARAMS ((bfd *, asection *));
319static boolean coff_set_arch_mach_hook PARAMS ((bfd *, PTR));
320static boolean coff_write_relocs PARAMS ((bfd *, int));
321static boolean coff_set_flags
322 PARAMS ((bfd *, unsigned int *, unsigned short *));
323static boolean coff_set_arch_mach
324 PARAMS ((bfd *, enum bfd_architecture, unsigned long));
325static boolean coff_compute_section_file_positions PARAMS ((bfd *));
326static boolean coff_write_object_contents PARAMS ((bfd *));
327static boolean coff_set_section_contents
328 PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type));
329static PTR buy_and_read PARAMS ((bfd *, file_ptr, int, size_t));
330static boolean coff_slurp_line_table PARAMS ((bfd *, asection *));
331static boolean coff_slurp_symbol_table PARAMS ((bfd *));
5d54c628
ILT		 332static enum coff_symbol_classification coff_classify_symbol
333 PARAMS ((bfd *, struct internal_syment *));
252b5132
RH		 334static boolean coff_slurp_reloc_table PARAMS ((bfd *, asection *, asymbol **));
335static long coff_canonicalize_reloc
336 PARAMS ((bfd *, asection *, arelent **, asymbol **));
337#ifndef coff_mkobject_hook
338static PTR coff_mkobject_hook PARAMS ((bfd *, PTR, PTR));
339#endif
340\f
341/* void warning(); */
342
343/*
344 * Return a word with STYP_* (scnhdr.s_flags) flags set to represent the
345 * incoming SEC_* flags. The inverse of this function is styp_to_sec_flags().
346 * NOTE: If you add to/change this routine, you should mirror the changes
347 * in styp_to_sec_flags().
348 */
349static long
350sec_to_styp_flags (sec_name, sec_flags)
351 CONST char *sec_name;
352 flagword sec_flags;
353{
354 long styp_flags = 0;
355
356 if (!strcmp (sec_name, _TEXT))
357 {
358 styp_flags = STYP_TEXT;
359 }
360 else if (!strcmp (sec_name, _DATA))
361 {
362 styp_flags = STYP_DATA;
363 }
364 else if (!strcmp (sec_name, _BSS))
365 {
366 styp_flags = STYP_BSS;
367#ifdef _COMMENT
368 }
369 else if (!strcmp (sec_name, _COMMENT))
370 {
371 styp_flags = STYP_INFO;
372#endif /* _COMMENT */
373#ifdef _LIB
374 }
375 else if (!strcmp (sec_name, _LIB))
376 {
377 styp_flags = STYP_LIB;
378#endif /* _LIB */
379#ifdef _LIT
380 }
381 else if (!strcmp (sec_name, _LIT))
382 {
383 styp_flags = STYP_LIT;
384#endif /* _LIT */
385 }
386 else if (!strcmp (sec_name, ".debug"))
387 {
388#ifdef STYP_DEBUG
389 styp_flags = STYP_DEBUG;
390#else
391 styp_flags = STYP_INFO;
392#endif
393 }
394 else if (!strncmp (sec_name, ".stab", 5))
395 {
396 styp_flags = STYP_INFO;
397 }
398#ifdef COFF_WITH_PE
399 else if (!strcmp (sec_name, ".edata"))
400 {
401 styp_flags = STYP_DATA;
402 }
403#endif
404#ifdef RS6000COFF_C
405 else if (!strcmp (sec_name, _PAD))
406 {
407 styp_flags = STYP_PAD;
408 }
409 else if (!strcmp (sec_name, _LOADER))
410 {
411 styp_flags = STYP_LOADER;
412 }
413#endif
414 /* Try and figure out what it should be */
415 else if (sec_flags & SEC_CODE)
416 {
417 styp_flags = STYP_TEXT;
418 }
419 else if (sec_flags & SEC_DATA)
420 {
421 styp_flags = STYP_DATA;
422 }
423 else if (sec_flags & SEC_READONLY)
424 {
425#ifdef STYP_LIT /* 29k readonly text/data section */
426 styp_flags = STYP_LIT;
427#else
428 styp_flags = STYP_TEXT;
429#endif /* STYP_LIT */
430 }
431 else if (sec_flags & SEC_LOAD)
432 {
433 styp_flags = STYP_TEXT;
434 }
435 else if (sec_flags & SEC_ALLOC)
436 {
437 styp_flags = STYP_BSS;
438 }
439
440#ifdef STYP_NOLOAD
441 if ((sec_flags & (SEC_NEVER_LOAD | SEC_COFF_SHARED_LIBRARY)) != 0)
442 styp_flags |= STYP_NOLOAD;
443#endif
444
445#ifdef COFF_WITH_PE
446 if (sec_flags & SEC_LINK_ONCE)
447 styp_flags |= IMAGE_SCN_LNK_COMDAT;
bd826630
ILT		 448 if (sec_flags & SEC_SHARED)
449 styp_flags |= IMAGE_SCN_MEM_SHARED;
252b5132
RH		 450#endif
451
452 return (styp_flags);
453}
454/*
455 * Return a word with SEC_* flags set to represent the incoming
456 * STYP_* flags (from scnhdr.s_flags). The inverse of this
457 * function is sec_to_styp_flags().
458 * NOTE: If you add to/change this routine, you should mirror the changes
459 * in sec_to_styp_flags().
460 */
461static flagword
462styp_to_sec_flags (abfd, hdr, name)
5f771d47 463 bfd *abfd ATTRIBUTE_UNUSED;
252b5132
RH		 464 PTR hdr;
465 const char *name;
466{
467 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
468 long styp_flags = internal_s->s_flags;
469 flagword sec_flags = 0;
470
471#ifdef STYP_NOLOAD
472 if (styp_flags & STYP_NOLOAD)
473 {
474 sec_flags |= SEC_NEVER_LOAD;
475 }
476#endif /* STYP_NOLOAD */
477
478 /* For 386 COFF, at least, an unloadable text or data section is
479 actually a shared library section. */
480 if (styp_flags & STYP_TEXT)
481 {
482 if (sec_flags & SEC_NEVER_LOAD)
483 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
484 else
485 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
486 }
487 else if (styp_flags & STYP_DATA)
488 {
489 if (sec_flags & SEC_NEVER_LOAD)
490 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
491 else
492 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
493 }
494 else if (styp_flags & STYP_BSS)
495 {
496#ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
497 if (sec_flags & SEC_NEVER_LOAD)
498 sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
499 else
500#endif
501 sec_flags |= SEC_ALLOC;
502 }
503 else if (styp_flags & STYP_INFO)
504 {
505 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
506 defined. coff_compute_section_file_positions uses
507 COFF_PAGE_SIZE to ensure that the low order bits of the
508 section VMA and the file offset match. If we don't know
509 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
510 and demand page loading of the file will fail. */
511#if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
512 sec_flags |= SEC_DEBUGGING;
513#endif
514 }
515 else if (styp_flags & STYP_PAD)
516 {
517 sec_flags = 0;
518 }
519 else if (strcmp (name, _TEXT) == 0)
520 {
521 if (sec_flags & SEC_NEVER_LOAD)
522 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
523 else
524 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
525 }
526 else if (strcmp (name, _DATA) == 0)
527 {
528 if (sec_flags & SEC_NEVER_LOAD)
529 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
530 else
531 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
532 }
533 else if (strcmp (name, _BSS) == 0)
534 {
535#ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
536 if (sec_flags & SEC_NEVER_LOAD)
537 sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
538 else
539#endif
540 sec_flags |= SEC_ALLOC;
541 }
542 else if (strcmp (name, ".debug") == 0
543#ifdef _COMMENT
544 || strcmp (name, _COMMENT) == 0
545#endif
546 || strncmp (name, ".stab", 5) == 0)
547 {
548#ifdef COFF_PAGE_SIZE
549 sec_flags |= SEC_DEBUGGING;
550#endif
551 }
552#ifdef _LIB
553 else if (strcmp (name, _LIB) == 0)
554 ;
555#endif
556#ifdef _LIT
557 else if (strcmp (name, _LIT) == 0)
558 {
559 sec_flags = SEC_LOAD | SEC_ALLOC | SEC_READONLY;
560 }
561#endif
562 else
563 {
564 sec_flags |= SEC_ALLOC | SEC_LOAD;
565 }
566
567#ifdef STYP_LIT /* A29k readonly text/data section type */
568 if ((styp_flags & STYP_LIT) == STYP_LIT)
569 {
570 sec_flags = (SEC_LOAD | SEC_ALLOC | SEC_READONLY);
571 }
572#endif /* STYP_LIT */
573#ifdef STYP_OTHER_LOAD /* Other loaded sections */
574 if (styp_flags & STYP_OTHER_LOAD)
575 {
576 sec_flags = (SEC_LOAD | SEC_ALLOC);
577 }
578#endif /* STYP_SDATA */
579
580#ifdef COFF_WITH_PE
581 if (styp_flags & IMAGE_SCN_LNK_REMOVE)
582 sec_flags |= SEC_EXCLUDE;
583
bd826630
ILT		 584 if (styp_flags & IMAGE_SCN_MEM_SHARED)
585 sec_flags |= SEC_SHARED;
586
252b5132
RH		 587 if (styp_flags & IMAGE_SCN_LNK_COMDAT)
588 {
589 sec_flags |= SEC_LINK_ONCE;
590
591 /* Unfortunately, the PE format stores essential information in
592 the symbol table, of all places. We need to extract that
593 information now, so that objdump and the linker will know how
594 to handle the section without worrying about the symbols. We
595 can't call slurp_symtab, because the linker doesn't want the
596 swapped symbols. */
597
ec0ef80e
DD		 598 /* COMDAT sections are special. The first symbol is the section
599 symbol, which tells what kind of COMDAT section it is. The
600 *second* symbol is the "comdat symbol" - the one with the
601 unique name. GNU uses the section symbol for the unique
602 name; MS uses ".text" for every comdat section. Sigh. - DJ */
603
252b5132
RH		 604 if (_bfd_coff_get_external_symbols (abfd))
605 {
606 bfd_byte *esym, *esymend;
607
608 esym = (bfd_byte *) obj_coff_external_syms (abfd);
609 esymend = esym + obj_raw_syment_count (abfd) * SYMESZ;
610
611 while (esym < esymend)
612 {
613 struct internal_syment isym;
614
615 bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &isym);
616
617 if (sizeof (internal_s->s_name) > SYMNMLEN)
618 {
619 /* This case implies that the matching symbol name
620 will be in the string table. */
621 abort ();
622 }
623
624 if (isym.n_sclass == C_STAT
625 && isym.n_type == T_NULL
626 && isym.n_numaux == 1)
627 {
628 char buf[SYMNMLEN + 1];
629 const char *symname;
630
631 symname = _bfd_coff_internal_syment_name (abfd, &isym, buf);
632 if (symname == NULL)
633 abort ();
634
635 if (strcmp (name, symname) == 0)
636 {
637 union internal_auxent aux;
638
639 /* This is the section symbol. */
640
641 bfd_coff_swap_aux_in (abfd, (PTR) (esym + SYMESZ),
642 isym.n_type, isym.n_sclass,
643 0, isym.n_numaux, (PTR) &aux);
644
ec0ef80e
DD		 645 /* FIXME: Microsoft uses NODUPLICATES and
646 ASSOCIATIVE, but gnu uses ANY and SAME_SIZE.
647 Unfortunately, gnu doesn't do the comdat
648 symbols right. So, until we can fix it to do
649 the right thing, we are temporarily disabling
650 comdats for the MS types (they're used in
651 DLLs and C++, but we don't support *their*
652 C++ libraries anyway - DJ */
653
252b5132
RH		 654 switch (aux.x_scn.x_comdat)
655 {
656 case IMAGE_COMDAT_SELECT_NODUPLICATES:
ec0ef80e 657#if 0
252b5132 658 sec_flags |= SEC_LINK_DUPLICATES_ONE_ONLY;
ec0ef80e
DD		 659#else
660 sec_flags &= ~SEC_LINK_ONCE;
661#endif
252b5132
RH		 662 break;
663
664 default:
665 case IMAGE_COMDAT_SELECT_ANY:
666 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
667 break;
668
669 case IMAGE_COMDAT_SELECT_SAME_SIZE:
670 sec_flags |= SEC_LINK_DUPLICATES_SAME_SIZE;
671 break;
672
673 case IMAGE_COMDAT_SELECT_EXACT_MATCH:
674 sec_flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS;
675 break;
676
677 case IMAGE_COMDAT_SELECT_ASSOCIATIVE:
ec0ef80e 678#if 0
252b5132
RH		 679 /* FIXME: This is not currently implemented. */
680 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
ec0ef80e
DD		 681#else
682 sec_flags &= ~SEC_LINK_ONCE;
683#endif
252b5132
RH		 684 break;
685 }
686
687 break;
688 }
689 }
690
691 esym += (isym.n_numaux + 1) * SYMESZ;
692 }
693 }
694 }
695#endif
696
242eabea
ILT		 697#if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
698 /* As a GNU extension, if the name begins with .gnu.linkonce, we
699 only link a single copy of the section. This is used to support
700 g++. g++ will emit each template expansion in its own section.
701 The symbols will be defined as weak, so that multiple definitions
702 are permitted. The GNU linker extension is to actually discard
703 all but one of the sections. */
704 if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
705 sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
706#endif
707
252b5132
RH		 708 return (sec_flags);
709}
710
711#define get_index(symbol) ((symbol)->udata.i)
712
713/*
714INTERNAL_DEFINITION
715 bfd_coff_backend_data
716
717CODE_FRAGMENT
718
5d54c628
ILT		 719.{* COFF symbol classifications. *}
720.
721.enum coff_symbol_classification
722.{
723. {* Global symbol. *}
724. COFF_SYMBOL_GLOBAL,
725. {* Common symbol. *}
726. COFF_SYMBOL_COMMON,
727. {* Undefined symbol. *}
728. COFF_SYMBOL_UNDEFINED,
729. {* Local symbol. *}
730. COFF_SYMBOL_LOCAL,
731. {* PE section symbol. *}
732. COFF_SYMBOL_PE_SECTION
733.};
734.
252b5132
RH		 735Special entry points for gdb to swap in coff symbol table parts:
736.typedef struct
737.{
738. void (*_bfd_coff_swap_aux_in) PARAMS ((
739. bfd *abfd,
740. PTR ext,
741. int type,
742. int class,
743. int indaux,
744. int numaux,
745. PTR in));
746.
747. void (*_bfd_coff_swap_sym_in) PARAMS ((
748. bfd *abfd ,
749. PTR ext,
750. PTR in));
751.
752. void (*_bfd_coff_swap_lineno_in) PARAMS ((
753. bfd *abfd,
754. PTR ext,
755. PTR in));
756.
757
758Special entry points for gas to swap out coff parts:
759
760. unsigned int (*_bfd_coff_swap_aux_out) PARAMS ((
761. bfd *abfd,
762. PTR in,
763. int type,
764. int class,
765. int indaux,
766. int numaux,
767. PTR ext));
768.
769. unsigned int (*_bfd_coff_swap_sym_out) PARAMS ((
770. bfd *abfd,
771. PTR in,
772. PTR ext));
773.
774. unsigned int (*_bfd_coff_swap_lineno_out) PARAMS ((
775. bfd *abfd,
776. PTR in,
777. PTR ext));
778.
779. unsigned int (*_bfd_coff_swap_reloc_out) PARAMS ((
780. bfd *abfd,
781. PTR src,
782. PTR dst));
783.
784. unsigned int (*_bfd_coff_swap_filehdr_out) PARAMS ((
785. bfd *abfd,
786. PTR in,
787. PTR out));
788.
789. unsigned int (*_bfd_coff_swap_aouthdr_out) PARAMS ((
790. bfd *abfd,
791. PTR in,
792. PTR out));
793.
794. unsigned int (*_bfd_coff_swap_scnhdr_out) PARAMS ((
795. bfd *abfd,
796. PTR in,
797. PTR out));
798.
799
800Special entry points for generic COFF routines to call target
801dependent COFF routines:
802
803. unsigned int _bfd_filhsz;
804. unsigned int _bfd_aoutsz;
805. unsigned int _bfd_scnhsz;
806. unsigned int _bfd_symesz;
807. unsigned int _bfd_auxesz;
808. unsigned int _bfd_relsz;
809. unsigned int _bfd_linesz;
810. boolean _bfd_coff_long_filenames;
811. boolean _bfd_coff_long_section_names;
812. unsigned int _bfd_coff_default_section_alignment_power;
813. void (*_bfd_coff_swap_filehdr_in) PARAMS ((
814. bfd *abfd,
815. PTR ext,
816. PTR in));
817. void (*_bfd_coff_swap_aouthdr_in) PARAMS ((
818. bfd *abfd,
819. PTR ext,
820. PTR in));
821. void (*_bfd_coff_swap_scnhdr_in) PARAMS ((
822. bfd *abfd,
823. PTR ext,
824. PTR in));
825. void (*_bfd_coff_swap_reloc_in) PARAMS ((
826. bfd *abfd,
827. PTR ext,
828. PTR in));
829. boolean (*_bfd_coff_bad_format_hook) PARAMS ((
830. bfd *abfd,
831. PTR internal_filehdr));
832. boolean (*_bfd_coff_set_arch_mach_hook) PARAMS ((
833. bfd *abfd,
834. PTR internal_filehdr));
835. PTR (*_bfd_coff_mkobject_hook) PARAMS ((
836. bfd *abfd,
837. PTR internal_filehdr,
838. PTR internal_aouthdr));
839. flagword (*_bfd_styp_to_sec_flags_hook) PARAMS ((
840. bfd *abfd,
841. PTR internal_scnhdr,
842. const char *name));
843. void (*_bfd_set_alignment_hook) PARAMS ((
844. bfd *abfd,
845. asection *sec,
846. PTR internal_scnhdr));
847. boolean (*_bfd_coff_slurp_symbol_table) PARAMS ((
848. bfd *abfd));
849. boolean (*_bfd_coff_symname_in_debug) PARAMS ((
850. bfd *abfd,
851. struct internal_syment *sym));
852. boolean (*_bfd_coff_pointerize_aux_hook) PARAMS ((
853. bfd *abfd,
854. combined_entry_type *table_base,
855. combined_entry_type *symbol,
856. unsigned int indaux,
857. combined_entry_type *aux));
858. boolean (*_bfd_coff_print_aux) PARAMS ((
859. bfd *abfd,
860. FILE *file,
861. combined_entry_type *table_base,
862. combined_entry_type *symbol,
863. combined_entry_type *aux,
864. unsigned int indaux));
865. void (*_bfd_coff_reloc16_extra_cases) PARAMS ((
866. bfd *abfd,
867. struct bfd_link_info *link_info,
868. struct bfd_link_order *link_order,
869. arelent *reloc,
870. bfd_byte *data,
871. unsigned int *src_ptr,
872. unsigned int *dst_ptr));
873. int (*_bfd_coff_reloc16_estimate) PARAMS ((
874. bfd *abfd,
875. asection *input_section,
876. arelent *r,
877. unsigned int shrink,
878. struct bfd_link_info *link_info));
5d54c628 879. enum coff_symbol_classification (*_bfd_coff_classify_symbol) PARAMS ((
252b5132
RH		 880. bfd *abfd,
881. struct internal_syment *));
882. boolean (*_bfd_coff_compute_section_file_positions) PARAMS ((
883. bfd *abfd));
884. boolean (*_bfd_coff_start_final_link) PARAMS ((
885. bfd *output_bfd,
886. struct bfd_link_info *info));
887. boolean (*_bfd_coff_relocate_section) PARAMS ((
888. bfd *output_bfd,
889. struct bfd_link_info *info,
890. bfd *input_bfd,
891. asection *input_section,
892. bfd_byte *contents,
893. struct internal_reloc *relocs,
894. struct internal_syment *syms,
895. asection **sections));
896. reloc_howto_type *(*_bfd_coff_rtype_to_howto) PARAMS ((
897. bfd *abfd,
898. asection *sec,
899. struct internal_reloc *rel,
900. struct coff_link_hash_entry *h,
901. struct internal_syment *sym,
902. bfd_vma *addendp));
903. boolean (*_bfd_coff_adjust_symndx) PARAMS ((
904. bfd *obfd,
905. struct bfd_link_info *info,
906. bfd *ibfd,
907. asection *sec,
908. struct internal_reloc *reloc,
909. boolean *adjustedp));
910. boolean (*_bfd_coff_link_add_one_symbol) PARAMS ((
911. struct bfd_link_info *info,
912. bfd *abfd,
913. const char *name,
914. flagword flags,
915. asection *section,
916. bfd_vma value,
917. const char *string,
918. boolean copy,
919. boolean collect,
920. struct bfd_link_hash_entry **hashp));
921.
922. boolean (*_bfd_coff_link_output_has_begun) PARAMS ((
923. bfd * abfd,
924. struct coff_final_link_info * pfinfo));
925. boolean (*_bfd_coff_final_link_postscript) PARAMS ((
926. bfd * abfd,
927. struct coff_final_link_info * pfinfo));
928.
929.} bfd_coff_backend_data;
930.
931.#define coff_backend_info(abfd) ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
932.
933.#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
934. ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
935.
936.#define bfd_coff_swap_sym_in(a,e,i) \
937. ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
938.
939.#define bfd_coff_swap_lineno_in(a,e,i) \
940. ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
941.
942.#define bfd_coff_swap_reloc_out(abfd, i, o) \
943. ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
944.
945.#define bfd_coff_swap_lineno_out(abfd, i, o) \
946. ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
947.
948.#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
949. ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
950.
951.#define bfd_coff_swap_sym_out(abfd, i,o) \
952. ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
953.
954.#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
955. ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
956.
957.#define bfd_coff_swap_filehdr_out(abfd, i,o) \
958. ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
959.
960.#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
961. ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
962.
963.#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
964.#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
965.#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
966.#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
967.#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
968.#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
969.#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
970.#define bfd_coff_long_filenames(abfd) (coff_backend_info (abfd)->_bfd_coff_long_filenames)
971.#define bfd_coff_long_section_names(abfd) \
972. (coff_backend_info (abfd)->_bfd_coff_long_section_names)
973.#define bfd_coff_default_section_alignment_power(abfd) \
974. (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
975.#define bfd_coff_swap_filehdr_in(abfd, i,o) \
976. ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
977.
978.#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
979. ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
980.
981.#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
982. ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
983.
984.#define bfd_coff_swap_reloc_in(abfd, i, o) \
985. ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
986.
987.#define bfd_coff_bad_format_hook(abfd, filehdr) \
988. ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
989.
990.#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
991. ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
992.#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
993. ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook) (abfd, filehdr, aouthdr))
994.
995.#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name)\
996. ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook) (abfd, scnhdr, name))
997.
998.#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
999. ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1000.
1001.#define bfd_coff_slurp_symbol_table(abfd)\
1002. ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1003.
1004.#define bfd_coff_symname_in_debug(abfd, sym)\
1005. ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1006.
1007.#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1008. ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1009. (abfd, file, base, symbol, aux, indaux))
1010.
1011.#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)\
1012. ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1013. (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1014.
1015.#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1016. ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1017. (abfd, section, reloc, shrink, link_info))
1018.
5d54c628
ILT		 1019.#define bfd_coff_classify_symbol(abfd, sym)\
1020. ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
252b5132
RH		 1021. (abfd, sym))
1022.
1023.#define bfd_coff_compute_section_file_positions(abfd)\
1024. ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1025. (abfd))
1026.
1027.#define bfd_coff_start_final_link(obfd, info)\
1028. ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1029. (obfd, info))
1030.#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1031. ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1032. (obfd, info, ibfd, o, con, rel, isyms, secs))
1033.#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1034. ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1035. (abfd, sec, rel, h, sym, addendp))
1036.#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1037. ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1038. (obfd, info, ibfd, sec, rel, adjustedp))
1039.#define bfd_coff_link_add_one_symbol(info,abfd,name,flags,section,value,string,cp,coll,hashp)\
1040. ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1041. (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1042.
1043.#define bfd_coff_link_output_has_begun(a,p) \
1044. ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a,p))
1045.#define bfd_coff_final_link_postscript(a,p) \
1046. ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a,p))
1047.
1048*/
1049
1050/* See whether the magic number matches. */
1051
1052static boolean
1053coff_bad_format_hook (abfd, filehdr)
5f771d47 1054 bfd * abfd ATTRIBUTE_UNUSED;
252b5132
RH		 1055 PTR filehdr;
1056{
1057 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1058
1059 if (BADMAG (*internal_f))
1060 return false;
1061
1062 /* if the optional header is NULL or not the correct size then
1063 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1064 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1065 optional header is of a different size.
1066
1067 But the mips keeps extra stuff in it's opthdr, so dont check
1068 when doing that
1069 */
1070
1071#if defined(M88) || defined(I960)
1072 if (internal_f->f_opthdr != 0 && AOUTSZ != internal_f->f_opthdr)
1073 return false;
1074#endif
1075
1076 return true;
1077}
1078
1079/*
1080 initialize a section structure with information peculiar to this
1081 particular implementation of coff
1082*/
1083
1084static boolean
1085coff_new_section_hook (abfd, section)
1086 bfd * abfd;
1087 asection * section;
1088{
1089 combined_entry_type *native;
1090
1091 section->alignment_power = COFF_DEFAULT_SECTION_ALIGNMENT_POWER;
1092
1093#ifdef RS6000COFF_C
1094 if (xcoff_data (abfd)->text_align_power != 0
1095 && strcmp (bfd_get_section_name (abfd, section), ".text") == 0)
1096 section->alignment_power = xcoff_data (abfd)->text_align_power;
1097 if (xcoff_data (abfd)->data_align_power != 0
1098 && strcmp (bfd_get_section_name (abfd, section), ".data") == 0)
1099 section->alignment_power = xcoff_data (abfd)->data_align_power;
1100#endif
1101
1102 /* Allocate aux records for section symbols, to store size and
1103 related info.
1104
1105 @@ The 10 is a guess at a plausible maximum number of aux entries
1106 (but shouldn't be a constant). */
1107 native = ((combined_entry_type *)
1108 bfd_zalloc (abfd, sizeof (combined_entry_type) * 10));
1109 if (native == NULL)
1110 return false;
1111
1112 /* We don't need to set up n_name, n_value, or n_scnum in the native
1113 symbol information, since they'll be overriden by the BFD symbol
1114 anyhow. However, we do need to set the type and storage class,
1115 in case this symbol winds up getting written out. The value 0
1116 for n_numaux is already correct. */
1117
1118 native->u.syment.n_type = T_NULL;
1119 native->u.syment.n_sclass = C_STAT;
1120
1121 coffsymbol (section->symbol)->native = native;
1122
1123 /* The .stab section must be aligned to 2**2 at most, because
1124 otherwise there may be gaps in the section which gdb will not
1125 know how to interpret. Examining the section name is a hack, but
1126 that is also how gdb locates the section.
1127 We need to handle the .ctors and .dtors sections similarly, to
1128 avoid introducing null words in the tables. */
1129 if (COFF_DEFAULT_SECTION_ALIGNMENT_POWER > 2
1130 && (strncmp (section->name, ".stab", 5) == 0
1131 || strcmp (section->name, ".ctors") == 0
1132 || strcmp (section->name, ".dtors") == 0))
1133 section->alignment_power = 2;
1134
1135 /* Similarly, the .stabstr section must be aligned to 2**0 at most. */
1136 if (COFF_DEFAULT_SECTION_ALIGNMENT_POWER > 0
1137 && strncmp (section->name, ".stabstr", 8) == 0)
1138 section->alignment_power = 0;
1139
1140 return true;
1141}
1142
1143#ifdef COFF_ALIGN_IN_SECTION_HEADER
1144
1145/* Set the alignment of a BFD section. */
1146
1147static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1148
1149static void
1150coff_set_alignment_hook (abfd, section, scnhdr)
5f771d47 1151 bfd * abfd ATTRIBUTE_UNUSED;
252b5132
RH		 1152 asection * section;
1153 PTR scnhdr;
1154{
1155 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1156 unsigned int i;
1157
1158#ifdef I960
1159 /* Extract ALIGN from 2**ALIGN stored in section header */
1160 for (i = 0; i < 32; i++)
1161 if ((1 << i) >= hdr->s_align)
1162 break;
1163#endif
1164#ifdef TIC80COFF
1165 /* TI tools hijack bits 8-11 for the alignment */
1166 i = (hdr->s_flags >> 8) & 0xF ;
1167#endif
1168 section->alignment_power = i;
1169}
1170
1171#else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1172#ifdef COFF_WITH_PE
1173
1174/* a couple of macros to help setting the alignment power field */
1175#define ALIGN_SET(field,x,y) \
1176 if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x )\
1177 {\
1178 section->alignment_power = y;\
1179 }
1180
1181#define ELIFALIGN_SET(field,x,y) \
1182 else if (( (field) & IMAGE_SCN_ALIGN_64BYTES) == x ) \
1183 {\
1184 section->alignment_power = y;\
1185 }
1186
1187static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1188
1189static void
1190coff_set_alignment_hook (abfd, section, scnhdr)
5f771d47 1191 bfd * abfd ATTRIBUTE_UNUSED;
252b5132
RH		 1192 asection * section;
1193 PTR scnhdr;
1194{
1195 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1196
1197 ALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_64BYTES, 6)
1198 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_32BYTES, 5)
1199 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_16BYTES, 4)
1200 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_8BYTES, 3)
1201 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_4BYTES, 2)
1202 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_2BYTES, 1)
1203 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_1BYTES, 0)
1204
1205#ifdef POWERPC_LE_PE
1206 if (strcmp (section->name, ".idata$2") == 0)
1207 {
1208 section->alignment_power = 0;
1209 }
1210 else if (strcmp (section->name, ".idata$3") == 0)
1211 {
1212 section->alignment_power = 0;
1213 }
1214 else if (strcmp (section->name, ".idata$4") == 0)
1215 {
1216 section->alignment_power = 2;
1217 }
1218 else if (strcmp (section->name, ".idata$5") == 0)
1219 {
1220 section->alignment_power = 2;
1221 }
1222 else if (strcmp (section->name, ".idata$6") == 0)
1223 {
1224 section->alignment_power = 1;
1225 }
1226 else if (strcmp (section->name, ".reloc") == 0)
1227 {
1228 section->alignment_power = 1;
1229 }
1230 else if (strncmp (section->name, ".stab", 5) == 0)
1231 {
1232 section->alignment_power = 2;
1233 }
1234#endif
1235
1236#ifdef COFF_IMAGE_WITH_PE
1237 /* In a PE image file, the s_paddr field holds the virtual size of a
1238 section, while the s_size field holds the raw size. */
1239 if (hdr->s_paddr != 0)
1240 {
1241 if (coff_section_data (abfd, section) == NULL)
1242 {
1243 section->used_by_bfd =
1244 (PTR) bfd_zalloc (abfd, sizeof (struct coff_section_tdata));
1245 if (section->used_by_bfd == NULL)
1246 {
1247 /* FIXME: Return error. */
1248 abort ();
1249 }
1250 }
1251 if (pei_section_data (abfd, section) == NULL)
1252 {
1253 coff_section_data (abfd, section)->tdata =
1254 (PTR) bfd_zalloc (abfd, sizeof (struct pei_section_tdata));
1255 if (coff_section_data (abfd, section)->tdata == NULL)
1256 {
1257 /* FIXME: Return error. */
1258 abort ();
1259 }
1260 }
1261 pei_section_data (abfd, section)->virt_size = hdr->s_paddr;
1262 }
1263#endif
1264
9d8cefa9
RH		 1265#ifdef COFF_WITH_PE
1266 section->lma = hdr->s_vaddr;
1267#endif
252b5132
RH		 1268}
1269#undef ALIGN_SET
1270#undef ELIFALIGN_SET
1271
1272#else /* ! COFF_WITH_PE */
1273#ifdef RS6000COFF_C
1274
1275/* We grossly abuse this function to handle XCOFF overflow headers.
1276 When we see one, we correct the reloc and line number counts in the
1277 real header, and remove the section we just created. */
1278
1279static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1280
1281static void
1282coff_set_alignment_hook (abfd, section, scnhdr)
1283 bfd *abfd;
1284 asection *section;
1285 PTR scnhdr;
1286{
1287 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1288 asection *real_sec;
1289 asection **ps;
1290
1291 if ((hdr->s_flags & STYP_OVRFLO) == 0)
1292 return;
1293
1294 real_sec = coff_section_from_bfd_index (abfd, hdr->s_nreloc);
1295 if (real_sec == NULL)
1296 return;
1297
1298 real_sec->reloc_count = hdr->s_paddr;
1299 real_sec->lineno_count = hdr->s_vaddr;
1300
1301 for (ps = &abfd->sections; *ps != NULL; ps = &(*ps)->next)
1302 {
1303 if (*ps == section)
1304 {
1305 *ps = (*ps)->next;
1306 --abfd->section_count;
1307 break;
1308 }
1309 }
1310}
1311
1312#else /* ! RS6000COFF_C */
1313
1314#define coff_set_alignment_hook \
1315 ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
1316
1317#endif /* ! RS6000COFF_C */
1318#endif /* ! COFF_WITH_PE */
1319#endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1320
1321#ifndef coff_mkobject
1322
1323static boolean coff_mkobject PARAMS ((bfd *));
1324
1325static boolean
1326coff_mkobject (abfd)
1327 bfd * abfd;
1328{
1329 coff_data_type *coff;
1330
1331 abfd->tdata.coff_obj_data = (struct coff_tdata *) bfd_zalloc (abfd, sizeof (coff_data_type));
1332 if (abfd->tdata.coff_obj_data == 0)
1333 return false;
1334 coff = coff_data (abfd);
1335 coff->symbols = (coff_symbol_type *) NULL;
1336 coff->conversion_table = (unsigned int *) NULL;
1337 coff->raw_syments = (struct coff_ptr_struct *) NULL;
1338 coff->relocbase = 0;
1339 coff->local_toc_sym_map = 0;
1340
1341/* make_abs_section(abfd);*/
1342
1343 return true;
1344}
1345#endif
1346
1347/* Create the COFF backend specific information. */
1348#ifndef coff_mkobject_hook
1349static PTR
1350coff_mkobject_hook (abfd, filehdr, aouthdr)
1351 bfd * abfd;
1352 PTR filehdr;
5f771d47 1353 PTR aouthdr ATTRIBUTE_UNUSED;
252b5132
RH		 1354{
1355 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1356 coff_data_type *coff;
1357
1358 if (coff_mkobject (abfd) == false)
1359 return NULL;
1360
1361 coff = coff_data (abfd);
1362
1363 coff->sym_filepos = internal_f->f_symptr;
1364
1365 /* These members communicate important constants about the symbol
1366 table to GDB's symbol-reading code. These `constants'
1367 unfortunately vary among coff implementations... */
1368 coff->local_n_btmask = N_BTMASK;
1369 coff->local_n_btshft = N_BTSHFT;
1370 coff->local_n_tmask = N_TMASK;
1371 coff->local_n_tshift = N_TSHIFT;
1372 coff->local_symesz = SYMESZ;
1373 coff->local_auxesz = AUXESZ;
1374 coff->local_linesz = LINESZ;
1375
1376 obj_raw_syment_count (abfd) =
1377 obj_conv_table_size (abfd) =
1378 internal_f->f_nsyms;
1379
1380#ifdef RS6000COFF_C
1381 if ((internal_f->f_flags & F_SHROBJ) != 0)
1382 abfd->flags |= DYNAMIC;
1383 if (aouthdr != NULL && internal_f->f_opthdr >= AOUTSZ)
1384 {
1385 struct internal_aouthdr *internal_a =
1386 (struct internal_aouthdr *) aouthdr;
1387 struct xcoff_tdata *xcoff;
1388
1389 xcoff = xcoff_data (abfd);
1390 xcoff->full_aouthdr = true;
1391 xcoff->toc = internal_a->o_toc;
1392 xcoff->sntoc = internal_a->o_sntoc;
1393 xcoff->snentry = internal_a->o_snentry;
1394 xcoff->text_align_power = internal_a->o_algntext;
1395 xcoff->data_align_power = internal_a->o_algndata;
1396 xcoff->modtype = internal_a->o_modtype;
1397 xcoff->cputype = internal_a->o_cputype;
1398 xcoff->maxdata = internal_a->o_maxdata;
1399 xcoff->maxstack = internal_a->o_maxstack;
1400 }
1401#endif
1402
1403#ifdef ARM
1404 /* Set the flags field from the COFF header read in */
1405 if (! _bfd_coff_arm_set_private_flags (abfd, internal_f->f_flags))
1406 coff->flags = 0;
1407#endif
1408
1409 return (PTR) coff;
1410}
1411#endif
1412
1413/* Determine the machine architecture and type. FIXME: This is target
1414 dependent because the magic numbers are defined in the target
1415 dependent header files. But there is no particular need for this.
1416 If the magic numbers were moved to a separate file, this function
1417 would be target independent and would also be much more successful
1418 at linking together COFF files for different architectures. */
1419
1420static boolean
1421coff_set_arch_mach_hook (abfd, filehdr)
1422 bfd *abfd;
1423 PTR filehdr;
1424{
1425 long machine;
1426 enum bfd_architecture arch;
1427 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1428
1429 machine = 0;
1430 switch (internal_f->f_magic)
1431 {
1432#ifdef PPCMAGIC
1433 case PPCMAGIC:
1434 arch = bfd_arch_powerpc;
1435 machine = 0; /* what does this mean? (krk) */
1436 break;
1437#endif
1438#ifdef I386MAGIC
1439 case I386MAGIC:
1440 case I386PTXMAGIC:
1441 case I386AIXMAGIC: /* Danbury PS/2 AIX C Compiler */
1442 case LYNXCOFFMAGIC: /* shadows the m68k Lynx number below, sigh */
1443 arch = bfd_arch_i386;
1444 machine = 0;
1445 break;
1446#endif
1447#ifdef A29K_MAGIC_BIG
1448 case A29K_MAGIC_BIG:
1449 case A29K_MAGIC_LITTLE:
1450 arch = bfd_arch_a29k;
1451 machine = 0;
1452 break;
1453#endif
1454#ifdef ARMMAGIC
1455 case ARMMAGIC:
1456 arch = bfd_arch_arm;
1457 switch (internal_f->f_flags & F_ARM_ARCHITECTURE_MASK)
1458 {
948221a8
NC		 1459 case F_ARM_2: machine = bfd_mach_arm_2; break;
1460 case F_ARM_2a: machine = bfd_mach_arm_2a; break;
1461 case F_ARM_3: machine = bfd_mach_arm_3; break;
1462 default:
1463 case F_ARM_3M: machine = bfd_mach_arm_3M; break;
1464 case F_ARM_4: machine = bfd_mach_arm_4; break;
1465 case F_ARM_4T: machine = bfd_mach_arm_4T; break;
478d07d6 1466 case F_ARM_5: machine = bfd_mach_arm_5; break;
252b5132
RH		 1467 }
1468 break;
1469#endif
1470#ifdef MC68MAGIC
1471 case MC68MAGIC:
1472 case M68MAGIC:
1473#ifdef MC68KBCSMAGIC
1474 case MC68KBCSMAGIC:
1475#endif
1476#ifdef APOLLOM68KMAGIC
1477 case APOLLOM68KMAGIC:
1478#endif
1479#ifdef LYNXCOFFMAGIC
1480 case LYNXCOFFMAGIC:
1481#endif
1482 arch = bfd_arch_m68k;
1483 machine = bfd_mach_m68020;
1484 break;
1485#endif
1486#ifdef MC88MAGIC
1487 case MC88MAGIC:
1488 case MC88DMAGIC:
1489 case MC88OMAGIC:
1490 arch = bfd_arch_m88k;
1491 machine = 88100;
1492 break;
1493#endif
1494#ifdef Z8KMAGIC
1495 case Z8KMAGIC:
1496 arch = bfd_arch_z8k;
1497 switch (internal_f->f_flags & F_MACHMASK)
1498 {
1499 case F_Z8001:
1500 machine = bfd_mach_z8001;
1501 break;
1502 case F_Z8002:
1503 machine = bfd_mach_z8002;
1504 break;
1505 default:
1506 return false;
1507 }
1508 break;
1509#endif
1510#ifdef I860
1511 case I860MAGIC:
1512 arch = bfd_arch_i860;
1513 break;
1514#endif
1515#ifdef I960
1516#ifdef I960ROMAGIC
1517 case I960ROMAGIC:
1518 case I960RWMAGIC:
1519 arch = bfd_arch_i960;
1520 switch (F_I960TYPE & internal_f->f_flags)
1521 {
1522 default:
1523 case F_I960CORE:
1524 machine = bfd_mach_i960_core;
1525 break;
1526 case F_I960KB:
1527 machine = bfd_mach_i960_kb_sb;
1528 break;
1529 case F_I960MC:
1530 machine = bfd_mach_i960_mc;
1531 break;
1532 case F_I960XA:
1533 machine = bfd_mach_i960_xa;
1534 break;
1535 case F_I960CA:
1536 machine = bfd_mach_i960_ca;
1537 break;
1538 case F_I960KA:
1539 machine = bfd_mach_i960_ka_sa;
1540 break;
1541 case F_I960JX:
1542 machine = bfd_mach_i960_jx;
1543 break;
1544 case F_I960HX:
1545 machine = bfd_mach_i960_hx;
1546 break;
1547 }
1548 break;
1549#endif
1550#endif
1551
1552#ifdef RS6000COFF_C
1553 case U802ROMAGIC:
1554 case U802WRMAGIC:
1555 case U802TOCMAGIC:
1556 {
1557 int cputype;
1558
1559 if (xcoff_data (abfd)->cputype != -1)
1560 cputype = xcoff_data (abfd)->cputype & 0xff;
1561 else
1562 {
1563 /* We did not get a value from the a.out header. If the
1564 file has not been stripped, we may be able to get the
1565 architecture information from the first symbol, if it
1566 is a .file symbol. */
1567 if (obj_raw_syment_count (abfd) == 0)
1568 cputype = 0;
1569 else
1570 {
1571 bfd_byte buf[SYMESZ];
1572 struct internal_syment sym;
1573
1574 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
1575 || bfd_read (buf, 1, SYMESZ, abfd) != SYMESZ)
1576 return false;
1577 coff_swap_sym_in (abfd, (PTR) buf, (PTR) &sym);
1578 if (sym.n_sclass == C_FILE)
1579 cputype = sym.n_type & 0xff;
1580 else
1581 cputype = 0;
1582 }
1583 }
1584
1585 /* FIXME: We don't handle all cases here. */
1586 switch (cputype)
1587 {
1588 default:
1589 case 0:
1590#ifdef POWERMAC
1591 /* PowerPC Macs use the same magic numbers as RS/6000
1592 (because that's how they were bootstrapped originally),
1593 but they are always PowerPC architecture. */
1594 arch = bfd_arch_powerpc;
1595 machine = 0;
1596#else
1597 arch = bfd_arch_rs6000;
1598 machine = 6000;
1599#endif /* POWERMAC */
1600 break;
1601
1602 case 1:
1603 arch = bfd_arch_powerpc;
1604 machine = 601;
1605 break;
1606 case 2: /* 64 bit PowerPC */
1607 arch = bfd_arch_powerpc;
1608 machine = 620;
1609 break;
1610 case 3:
1611 arch = bfd_arch_powerpc;
1612 machine = 0;
1613 break;
1614 case 4:
1615 arch = bfd_arch_rs6000;
1616 machine = 6000;
1617 break;
1618 }
1619 }
1620 break;
1621#endif
1622
1623#ifdef WE32KMAGIC
1624 case WE32KMAGIC:
1625 arch = bfd_arch_we32k;
1626 machine = 0;
1627 break;
1628#endif
1629
1630#ifdef H8300MAGIC
1631 case H8300MAGIC:
1632 arch = bfd_arch_h8300;
1633 machine = bfd_mach_h8300;
1634 /* !! FIXME this probably isn't the right place for this */
1635 abfd->flags |= BFD_IS_RELAXABLE;
1636 break;
1637#endif
1638
1639#ifdef H8300HMAGIC
1640 case H8300HMAGIC:
1641 arch = bfd_arch_h8300;
1642 machine = bfd_mach_h8300h;
1643 /* !! FIXME this probably isn't the right place for this */
1644 abfd->flags |= BFD_IS_RELAXABLE;
1645 break;
1646#endif
1647
1648#ifdef H8300SMAGIC
1649 case H8300SMAGIC:
1650 arch = bfd_arch_h8300;
1651 machine = bfd_mach_h8300s;
1652 /* !! FIXME this probably isn't the right place for this */
1653 abfd->flags |= BFD_IS_RELAXABLE;
1654 break;
1655#endif
1656
1657#ifdef SH_ARCH_MAGIC_BIG
1658 case SH_ARCH_MAGIC_BIG:
1659 case SH_ARCH_MAGIC_LITTLE:
1660 arch = bfd_arch_sh;
1661 machine = 0;
1662 break;
1663#endif
1664
1665#ifdef H8500MAGIC
1666 case H8500MAGIC:
1667 arch = bfd_arch_h8500;
1668 machine = 0;
1669 break;
1670#endif
1671
1672#ifdef SPARCMAGIC
1673 case SPARCMAGIC:
1674#ifdef LYNXCOFFMAGIC
1675 case LYNXCOFFMAGIC:
1676#endif
1677 arch = bfd_arch_sparc;
1678 machine = 0;
1679 break;
1680#endif
1681
1682#ifdef TIC30MAGIC
1683 case TIC30MAGIC:
1684 arch = bfd_arch_tic30;
1685 break;
1686#endif
1687
1688#ifdef TIC80_ARCH_MAGIC
1689 case TIC80_ARCH_MAGIC:
1690 arch = bfd_arch_tic80;
1691 break;
1692#endif
1693
1694#ifdef MCOREMAGIC
1695 case MCOREMAGIC:
1696 arch = bfd_arch_mcore;
1697 break;
1698#endif
1699 default: /* Unreadable input file type */
1700 arch = bfd_arch_obscure;
1701 break;
1702 }
1703
1704 bfd_default_set_arch_mach (abfd, arch, machine);
1705 return true;
1706}
1707
1708#ifdef SYMNAME_IN_DEBUG
1709
1710static boolean symname_in_debug_hook
1711 PARAMS ((bfd *, struct internal_syment *));
1712
1713static boolean
1714symname_in_debug_hook (abfd, sym)
5f771d47 1715 bfd * abfd ATTRIBUTE_UNUSED;
252b5132
RH		 1716 struct internal_syment *sym;
1717{
1718 return SYMNAME_IN_DEBUG (sym) ? true : false;
1719}
1720
1721#else
1722
1723#define symname_in_debug_hook \
1724 (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
1725
1726#endif
1727
1728#ifdef RS6000COFF_C
1729
1730/* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */
1731
1732static boolean coff_pointerize_aux_hook
1733 PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
1734 unsigned int, combined_entry_type *));
1735
1736/*ARGSUSED*/
1737static boolean
1738coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux)
5f771d47 1739 bfd *abfd ATTRIBUTE_UNUSED;
252b5132
RH		 1740 combined_entry_type *table_base;
1741 combined_entry_type *symbol;
1742 unsigned int indaux;
1743 combined_entry_type *aux;
1744{
1745 int class = symbol->u.syment.n_sclass;
1746
1747 if ((class == C_EXT || class == C_HIDEXT)
1748 && indaux + 1 == symbol->u.syment.n_numaux)
1749 {
1750 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD)
1751 {
1752 aux->u.auxent.x_csect.x_scnlen.p =
1753 table_base + aux->u.auxent.x_csect.x_scnlen.l;
1754 aux->fix_scnlen = 1;
1755 }
1756
1757 /* Return true to indicate that the caller should not do any
1758 further work on this auxent. */
1759 return true;
1760 }
1761
1762 /* Return false to indicate that this auxent should be handled by
1763 the caller. */
1764 return false;
1765}
1766
1767#else
1768#ifdef I960
1769
1770/* We don't want to pointerize bal entries. */
1771
1772static boolean coff_pointerize_aux_hook
1773 PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
1774 unsigned int, combined_entry_type *));
1775
1776/*ARGSUSED*/
1777static boolean
1778coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux)
5f771d47
ILT		 1779 bfd *abfd ATTRIBUTE_UNUSED;
1780 combined_entry_type *table_base ATTRIBUTE_UNUSED;
252b5132
RH		 1781 combined_entry_type *symbol;
1782 unsigned int indaux;
5f771d47 1783 combined_entry_type *aux ATTRIBUTE_UNUSED;
252b5132
RH		 1784{
1785 /* Return true if we don't want to pointerize this aux entry, which
1786 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
1787 return (indaux == 1
1788 && (symbol->u.syment.n_sclass == C_LEAFPROC
1789 || symbol->u.syment.n_sclass == C_LEAFSTAT
1790 || symbol->u.syment.n_sclass == C_LEAFEXT));
1791}
1792
1793#else /* ! I960 */
1794
1795#define coff_pointerize_aux_hook 0
1796
1797#endif /* ! I960 */
1798#endif /* ! RS6000COFF_C */
1799
1800/* Print an aux entry. This returns true if it has printed it. */
1801
1802static boolean coff_print_aux
1803 PARAMS ((bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1804 combined_entry_type *, unsigned int));
1805
1806static boolean
1807coff_print_aux (abfd, file, table_base, symbol, aux, indaux)
5f771d47
ILT		 1808 bfd *abfd ATTRIBUTE_UNUSED;
1809 FILE *file ATTRIBUTE_UNUSED;
1810 combined_entry_type *table_base ATTRIBUTE_UNUSED;
1811 combined_entry_type *symbol ATTRIBUTE_UNUSED;
1812 combined_entry_type *aux ATTRIBUTE_UNUSED;
1813 unsigned int indaux ATTRIBUTE_UNUSED;
252b5132
RH		 1814{
1815#ifdef RS6000COFF_C
1816 if ((symbol->u.syment.n_sclass == C_EXT
1817 || symbol->u.syment.n_sclass == C_HIDEXT)
1818 && indaux + 1 == symbol->u.syment.n_numaux)
1819 {
1820 /* This is a csect entry. */
1821 fprintf (file, "AUX ");
1822 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) != XTY_LD)
1823 {
1824 BFD_ASSERT (! aux->fix_scnlen);
1825 fprintf (file, "val %5ld", aux->u.auxent.x_csect.x_scnlen.l);
1826 }
1827 else
1828 {
1829 fprintf (file, "indx ");
1830 if (! aux->fix_scnlen)
1831 fprintf (file, "%4ld", aux->u.auxent.x_csect.x_scnlen.l);
1832 else
1833 fprintf (file, "%4ld",
1834 (long) (aux->u.auxent.x_csect.x_scnlen.p - table_base));
1835 }
1836 fprintf (file,
1837 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
1838 aux->u.auxent.x_csect.x_parmhash,
1839 (unsigned int) aux->u.auxent.x_csect.x_snhash,
1840 SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp),
1841 SMTYP_ALIGN (aux->u.auxent.x_csect.x_smtyp),
1842 (unsigned int) aux->u.auxent.x_csect.x_smclas,
1843 aux->u.auxent.x_csect.x_stab,
1844 (unsigned int) aux->u.auxent.x_csect.x_snstab);
1845 return true;
1846 }
1847#endif
1848
1849 /* Return false to indicate that no special action was taken. */
1850 return false;
1851}
1852
1853/*
1854SUBSUBSECTION
1855 Writing relocations
1856
1857 To write relocations, the back end steps though the
1858 canonical relocation table and create an
1859 @code{internal_reloc}. The symbol index to use is removed from
1860 the @code{offset} field in the symbol table supplied. The
1861 address comes directly from the sum of the section base
1862 address and the relocation offset; the type is dug directly
1863 from the howto field. Then the @code{internal_reloc} is
1864 swapped into the shape of an @code{external_reloc} and written
1865 out to disk.
1866
1867*/
1868
1869#ifdef TARG_AUX
1870
1871static int compare_arelent_ptr PARAMS ((const PTR, const PTR));
1872
1873/* AUX's ld wants relocations to be sorted */
1874static int
1875compare_arelent_ptr (x, y)
1876 const PTR x;
1877 const PTR y;
1878{
1879 const arelent **a = (const arelent **) x;
1880 const arelent **b = (const arelent **) y;
1881 bfd_size_type aadr = (*a)->address;
1882 bfd_size_type badr = (*b)->address;
1883
1884 return (aadr < badr ? -1 : badr < aadr ? 1 : 0);
1885}
1886
1887#endif /* TARG_AUX */
1888
1889static boolean
1890coff_write_relocs (abfd, first_undef)
1891 bfd * abfd;
1892 int first_undef;
1893{
1894 asection *s;
1895
1896 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
1897 {
1898 unsigned int i;
1899 struct external_reloc dst;
1900 arelent **p;
1901
1902#ifndef TARG_AUX
1903 p = s->orelocation;
1904#else
1905 /* sort relocations before we write them out */
1906 p = (arelent **) bfd_malloc (s->reloc_count * sizeof (arelent *));
1907 if (p == NULL && s->reloc_count > 0)
1908 return false;
1909 memcpy (p, s->orelocation, s->reloc_count * sizeof (arelent *));
1910 qsort (p, s->reloc_count, sizeof (arelent *), compare_arelent_ptr);
1911#endif
1912
1913 if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0)
1914 return false;
1915 for (i = 0; i < s->reloc_count; i++)
1916 {
1917 struct internal_reloc n;
1918 arelent *q = p[i];
1919 memset ((PTR) & n, 0, sizeof (n));
1920
1921 /* Now we've renumbered the symbols we know where the
1922 undefined symbols live in the table. Check the reloc
1923 entries for symbols who's output bfd isn't the right one.
1924 This is because the symbol was undefined (which means
1925 that all the pointers are never made to point to the same
1926 place). This is a bad thing,'cause the symbols attached
1927 to the output bfd are indexed, so that the relocation
1928 entries know which symbol index they point to. So we
1929 have to look up the output symbol here. */
1930
1931 if (q->sym_ptr_ptr[0]->the_bfd != abfd)
1932 {
1933 int i;
1934 const char *sname = q->sym_ptr_ptr[0]->name;
1935 asymbol **outsyms = abfd->outsymbols;
1936 for (i = first_undef; outsyms[i]; i++)
1937 {
1938 const char *intable = outsyms[i]->name;
1939 if (strcmp (intable, sname) == 0) {
1940 /* got a hit, so repoint the reloc */
1941 q->sym_ptr_ptr = outsyms + i;
1942 break;
1943 }
1944 }
1945 }
1946
1947 n.r_vaddr = q->address + s->vma;
1948
1949#ifdef R_IHCONST
1950 /* The 29k const/consth reloc pair is a real kludge. The consth
1951 part doesn't have a symbol; it has an offset. So rebuilt
1952 that here. */
1953 if (q->howto->type == R_IHCONST)
1954 n.r_symndx = q->addend;
1955 else
1956#endif
1957 if (q->sym_ptr_ptr)
1958 {
1959 if (q->sym_ptr_ptr == bfd_abs_section_ptr->symbol_ptr_ptr)
1960 /* This is a relocation relative to the absolute symbol. */
1961 n.r_symndx = -1;
1962 else
1963 {
1964 n.r_symndx = get_index ((*(q->sym_ptr_ptr)));
1965 /* Take notice if the symbol reloc points to a symbol
1966 we don't have in our symbol table. What should we
1967 do for this?? */
1968 if (n.r_symndx > obj_conv_table_size (abfd))
1969 abort ();
1970 }
1971 }
1972
1973#ifdef SWAP_OUT_RELOC_OFFSET
1974 n.r_offset = q->addend;
1975#endif
1976
1977#ifdef SELECT_RELOC
1978 /* Work out reloc type from what is required */
1979 SELECT_RELOC (n, q->howto);
1980#else
1981 n.r_type = q->howto->type;
1982#endif
1983 coff_swap_reloc_out (abfd, &n, &dst);
1984 if (bfd_write ((PTR) & dst, 1, RELSZ, abfd) != RELSZ)
1985 return false;
1986 }
1987
1988#ifdef TARG_AUX
1989 if (p != NULL)
1990 free (p);
1991#endif
1992 }
1993
1994 return true;
1995}
1996
1997/* Set flags and magic number of a coff file from architecture and machine
1998 type. Result is true if we can represent the arch&type, false if not. */
1999
2000static boolean
2001coff_set_flags (abfd, magicp, flagsp)
2002 bfd * abfd;
5f771d47
ILT		 2003 unsigned int *magicp ATTRIBUTE_UNUSED;
2004 unsigned short *flagsp ATTRIBUTE_UNUSED;
252b5132
RH		 2005{
2006 switch (bfd_get_arch (abfd))
2007 {
2008#ifdef Z8KMAGIC
2009 case bfd_arch_z8k:
2010 *magicp = Z8KMAGIC;
2011 switch (bfd_get_mach (abfd))
2012 {
2013 case bfd_mach_z8001:
2014 *flagsp = F_Z8001;
2015 break;
2016 case bfd_mach_z8002:
2017 *flagsp = F_Z8002;
2018 break;
2019 default:
2020 return false;
2021 }
2022 return true;
2023#endif
2024#ifdef I960ROMAGIC
2025
2026 case bfd_arch_i960:
2027
2028 {
2029 unsigned flags;
2030 *magicp = I960ROMAGIC;
2031 /*
2032 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
2033 I960RWMAGIC); FIXME???
2034 */
2035 switch (bfd_get_mach (abfd))
2036 {
2037 case bfd_mach_i960_core:
2038 flags = F_I960CORE;
2039 break;
2040 case bfd_mach_i960_kb_sb:
2041 flags = F_I960KB;
2042 break;
2043 case bfd_mach_i960_mc:
2044 flags = F_I960MC;
2045 break;
2046 case bfd_mach_i960_xa:
2047 flags = F_I960XA;
2048 break;
2049 case bfd_mach_i960_ca:
2050 flags = F_I960CA;
2051 break;
2052 case bfd_mach_i960_ka_sa:
2053 flags = F_I960KA;
2054 break;
2055 case bfd_mach_i960_jx:
2056 flags = F_I960JX;
2057 break;
2058 case bfd_mach_i960_hx:
2059 flags = F_I960HX;
2060 break;
2061 default:
2062 return false;
2063 }
2064 *flagsp = flags;
2065 return true;
2066 }
2067 break;
2068#endif
2069
2070#ifdef TIC30MAGIC
2071 case bfd_arch_tic30:
2072 *magicp = TIC30MAGIC;
2073 return true;
2074#endif
2075#ifdef TIC80_ARCH_MAGIC
2076 case bfd_arch_tic80:
2077 *magicp = TIC80_ARCH_MAGIC;
2078 return true;
2079#endif
2080#ifdef ARMMAGIC
2081 case bfd_arch_arm:
2082 * magicp = ARMMAGIC;
2083 * flagsp = 0;
2084 if (APCS_SET (abfd))
2085 {
2086 if (APCS_26_FLAG (abfd))
2087 * flagsp |= F_APCS26;
2088
2089 if (APCS_FLOAT_FLAG (abfd))
2090 * flagsp |= F_APCS_FLOAT;
2091
2092 if (PIC_FLAG (abfd))
948221a8 2093 * flagsp |= F_PIC;
252b5132
RH		 2094 }
2095 if (INTERWORK_SET (abfd) && INTERWORK_FLAG (abfd))
2096 * flagsp |= F_INTERWORK;
2097 switch (bfd_get_mach (abfd))
2098 {
2099 case bfd_mach_arm_2: * flagsp |= F_ARM_2; break;
2100 case bfd_mach_arm_2a: * flagsp |= F_ARM_2a; break;
2101 case bfd_mach_arm_3: * flagsp |= F_ARM_3; break;
2102 case bfd_mach_arm_3M: * flagsp |= F_ARM_3M; break;
2103 case bfd_mach_arm_4: * flagsp |= F_ARM_4; break;
2104 case bfd_mach_arm_4T: * flagsp |= F_ARM_4T; break;
478d07d6
NC		 2105 case bfd_mach_arm_5: * flagsp |= F_ARM_5; break;
2106 case bfd_mach_arm_5T: * flagsp |= F_ARM_5; break; /* XXX - we do not have an F_ARM_5T */
252b5132
RH		 2107 }
2108 return true;
2109#endif
2110#ifdef PPCMAGIC
2111 case bfd_arch_powerpc:
2112 *magicp = PPCMAGIC;
2113 return true;
2114 break;
2115#endif
2116#ifdef I386MAGIC
2117 case bfd_arch_i386:
2118 *magicp = I386MAGIC;
2119#ifdef LYNXOS
2120 /* Just overwrite the usual value if we're doing Lynx. */
2121 *magicp = LYNXCOFFMAGIC;
2122#endif
2123 return true;
2124 break;
2125#endif
2126#ifdef I860MAGIC
2127 case bfd_arch_i860:
2128 *magicp = I860MAGIC;
2129 return true;
2130 break;
2131#endif
2132#ifdef MC68MAGIC
2133 case bfd_arch_m68k:
2134#ifdef APOLLOM68KMAGIC
2135 *magicp = APOLLO_COFF_VERSION_NUMBER;
2136#else
2137 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2138#ifdef NAMES_HAVE_UNDERSCORE
2139 *magicp = MC68KBCSMAGIC;
2140#else
2141 *magicp = MC68MAGIC;
2142#endif
2143#endif
2144#ifdef LYNXOS
2145 /* Just overwrite the usual value if we're doing Lynx. */
2146 *magicp = LYNXCOFFMAGIC;
2147#endif
2148 return true;
2149 break;
2150#endif
2151
2152#ifdef MC88MAGIC
2153 case bfd_arch_m88k:
2154 *magicp = MC88OMAGIC;
2155 return true;
2156 break;
2157#endif
2158#ifdef H8300MAGIC
2159 case bfd_arch_h8300:
2160 switch (bfd_get_mach (abfd))
2161 {
2162 case bfd_mach_h8300:
2163 *magicp = H8300MAGIC;
2164 return true;
2165 case bfd_mach_h8300h:
2166 *magicp = H8300HMAGIC;
2167 return true;
2168 case bfd_mach_h8300s:
2169 *magicp = H8300SMAGIC;
2170 return true;
2171 }
2172 break;
2173#endif
2174
2175#ifdef SH_ARCH_MAGIC_BIG
2176 case bfd_arch_sh:
2177 if (bfd_big_endian (abfd))
2178 *magicp = SH_ARCH_MAGIC_BIG;
2179 else
2180 *magicp = SH_ARCH_MAGIC_LITTLE;
2181 return true;
2182 break;
2183#endif
2184
2185#ifdef SPARCMAGIC
2186 case bfd_arch_sparc:
2187 *magicp = SPARCMAGIC;
2188#ifdef LYNXOS
2189 /* Just overwrite the usual value if we're doing Lynx. */
2190 *magicp = LYNXCOFFMAGIC;
2191#endif
2192 return true;
2193 break;
2194#endif
2195
2196#ifdef H8500MAGIC
2197 case bfd_arch_h8500:
2198 *magicp = H8500MAGIC;
2199 return true;
2200 break;
2201#endif
2202#ifdef A29K_MAGIC_BIG
2203 case bfd_arch_a29k:
2204 if (bfd_big_endian (abfd))
2205 *magicp = A29K_MAGIC_BIG;
2206 else
2207 *magicp = A29K_MAGIC_LITTLE;
2208 return true;
2209 break;
2210#endif
2211
2212#ifdef WE32KMAGIC
2213 case bfd_arch_we32k:
2214 *magicp = WE32KMAGIC;
2215 return true;
2216 break;
2217#endif
2218
2219#ifdef U802TOCMAGIC
2220 case bfd_arch_rs6000:
2221#ifndef PPCMAGIC
2222 case bfd_arch_powerpc:
2223#endif
2224 *magicp = U802TOCMAGIC;
2225 return true;
2226 break;
2227#endif
2228
2229#ifdef MCOREMAGIC
2230 case bfd_arch_mcore:
2231 * magicp = MCOREMAGIC;
2232 return true;
2233#endif
2234
2235 default: /* Unknown architecture */
2236 /* return false; -- fall through to "return false" below, to avoid
2237 "statement never reached" errors on the one below. */
2238 break;
2239 }
2240
2241 return false;
2242}
2243
2244
2245static boolean
2246coff_set_arch_mach (abfd, arch, machine)
2247 bfd * abfd;
2248 enum bfd_architecture arch;
2249 unsigned long machine;
2250{
2251 unsigned dummy1;
2252 unsigned short dummy2;
2253
2254 if (! bfd_default_set_arch_mach (abfd, arch, machine))
2255 return false;
2256
2257 if (arch != bfd_arch_unknown &&
2258 coff_set_flags (abfd, &dummy1, &dummy2) != true)
2259 return false; /* We can't represent this type */
2260
2261 return true; /* We're easy ... */
2262}
2263
2264
2265/* Calculate the file position for each section. */
2266
2267#ifndef I960
2268#define ALIGN_SECTIONS_IN_FILE
2269#endif
2270#ifdef TIC80COFF
2271#undef ALIGN_SECTIONS_IN_FILE
2272#endif
2273
2274static boolean
2275coff_compute_section_file_positions (abfd)
2276 bfd * abfd;
2277{
2278 asection *current;
2279 asection *previous = (asection *) NULL;
2280 file_ptr sofar = FILHSZ;
2281 boolean align_adjust;
2282 unsigned int count;
2283#ifdef ALIGN_SECTIONS_IN_FILE
2284 file_ptr old_sofar;
2285#endif
2286
2287#ifdef RS6000COFF_C
2288 /* On XCOFF, if we have symbols, set up the .debug section. */
2289 if (bfd_get_symcount (abfd) > 0)
2290 {
2291 bfd_size_type sz;
2292 bfd_size_type i, symcount;
2293 asymbol **symp;
2294
2295 sz = 0;
2296 symcount = bfd_get_symcount (abfd);
2297 for (symp = abfd->outsymbols, i = 0; i < symcount; symp++, i++)
2298 {
2299 coff_symbol_type *cf;
2300
2301 cf = coff_symbol_from (abfd, *symp);
2302 if (cf != NULL
2303 && cf->native != NULL
2304 && SYMNAME_IN_DEBUG (&cf->native->u.syment))
2305 {
2306 size_t len;
2307
2308 len = strlen (bfd_asymbol_name (*symp));
2309 if (len > SYMNMLEN)
2310 sz += len + 3;
2311 }
2312 }
2313 if (sz > 0)
2314 {
2315 asection *dsec;
2316
2317 dsec = bfd_make_section_old_way (abfd, ".debug");
2318 if (dsec == NULL)
2319 abort ();
2320 dsec->_raw_size = sz;
2321 dsec->flags |= SEC_HAS_CONTENTS;
2322 }
2323 }
2324#endif
2325
2326#ifdef COFF_IMAGE_WITH_PE
2327 int page_size;
2328 if (coff_data (abfd)->link_info)
2329 {
2330 page_size = pe_data (abfd)->pe_opthdr.FileAlignment;
2331 }
2332 else
2333 page_size = PE_DEF_FILE_ALIGNMENT;
2334#else
2335#ifdef COFF_PAGE_SIZE
2336 int page_size = COFF_PAGE_SIZE;
2337#endif
2338#endif
2339
2340 if (bfd_get_start_address (abfd))
2341 {
2342 /* A start address may have been added to the original file. In this
2343 case it will need an optional header to record it. */
2344 abfd->flags |= EXEC_P;
2345 }
2346
2347 if (abfd->flags & EXEC_P)
2348 sofar += AOUTSZ;
2349#ifdef RS6000COFF_C
2350 else if (xcoff_data (abfd)->full_aouthdr)
2351 sofar += AOUTSZ;
2352 else
2353 sofar += SMALL_AOUTSZ;
2354#endif
2355
2356 sofar += abfd->section_count * SCNHSZ;
2357
2358#ifdef RS6000COFF_C
2359 /* XCOFF handles overflows in the reloc and line number count fields
2360 by allocating a new section header to hold the correct counts. */
2361 for (current = abfd->sections; current != NULL; current = current->next)
2362 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
2363 sofar += SCNHSZ;
2364#endif
2365
2366 align_adjust = false;
2367 for (current = abfd->sections, count = 1;
2368 current != (asection *) NULL;
2369 current = current->next, ++count)
2370 {
2371#ifdef COFF_IMAGE_WITH_PE
2372 /* The NT loader does not want empty section headers, so we omit
2373 them. We don't actually remove the section from the BFD,
2374 although we probably should. This matches code in
2375 coff_write_object_contents. */
2376 if (current->_raw_size == 0)
2377 {
2378 current->target_index = -1;
2379 --count;
2380 continue;
2381 }
2382#endif
2383
2384 current->target_index = count;
2385
2386 /* Only deal with sections which have contents */
2387 if (!(current->flags & SEC_HAS_CONTENTS))
2388 continue;
2389
2390 /* Align the sections in the file to the same boundary on
2391 which they are aligned in virtual memory. I960 doesn't
2392 do this (FIXME) so we can stay in sync with Intel. 960
2393 doesn't yet page from files... */
2394#ifdef ALIGN_SECTIONS_IN_FILE
2395 if ((abfd->flags & EXEC_P) != 0)
2396 {
2397 /* make sure this section is aligned on the right boundary - by
2398 padding the previous section up if necessary */
2399
2400 old_sofar = sofar;
2401 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
2402 if (previous != (asection *) NULL)
2403 {
2404 previous->_raw_size += sofar - old_sofar;
2405 }
2406 }
2407
2408#endif
2409
2410 /* In demand paged files the low order bits of the file offset
2411 must match the low order bits of the virtual address. */
2412#ifdef COFF_PAGE_SIZE
2413 if ((abfd->flags & D_PAGED) != 0
2414 && (current->flags & SEC_ALLOC) != 0)
2415 sofar += (current->vma - sofar) % page_size;
2416#endif
2417 current->filepos = sofar;
2418
2419#ifdef COFF_IMAGE_WITH_PE
2420 /* With PE we have to pad each section to be a multiple of its
2421 page size too, and remember both sizes. */
2422
2423 if (coff_section_data (abfd, current) == NULL)
2424 {
2425 current->used_by_bfd =
2426 (PTR) bfd_zalloc (abfd, sizeof (struct coff_section_tdata));
2427 if (current->used_by_bfd == NULL)
2428 return false;
2429 }
2430 if (pei_section_data (abfd, current) == NULL)
2431 {
2432 coff_section_data (abfd, current)->tdata =
2433 (PTR) bfd_zalloc (abfd, sizeof (struct pei_section_tdata));
2434 if (coff_section_data (abfd, current)->tdata == NULL)
2435 return false;
2436 }
2437 if (pei_section_data (abfd, current)->virt_size == 0)
2438 pei_section_data (abfd, current)->virt_size = current->_raw_size;
2439
2440 current->_raw_size = (current->_raw_size + page_size -1) & -page_size;
2441#endif
2442
2443 sofar += current->_raw_size;
2444
2445#ifdef ALIGN_SECTIONS_IN_FILE
2446 /* make sure that this section is of the right size too */
2447 if ((abfd->flags & EXEC_P) == 0)
2448 {
2449 bfd_size_type old_size;
2450
2451 old_size = current->_raw_size;
2452 current->_raw_size = BFD_ALIGN (current->_raw_size,
2453 1 << current->alignment_power);
2454 align_adjust = current->_raw_size != old_size;
2455 sofar += current->_raw_size - old_size;
2456 }
2457 else
2458 {
2459 old_sofar = sofar;
2460 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
2461 align_adjust = sofar != old_sofar;
2462 current->_raw_size += sofar - old_sofar;
2463 }
2464#endif
2465
2466#ifdef COFF_IMAGE_WITH_PE
2467 /* For PE we need to make sure we pad out to the aligned
2468 _raw_size, in case the caller only writes out data to the
2469 unaligned _raw_size. */
2470 if (pei_section_data (abfd, current)->virt_size < current->_raw_size)
2471 align_adjust = true;
2472#endif
2473
2474#ifdef _LIB
2475 /* Force .lib sections to start at zero. The vma is then
2476 incremented in coff_set_section_contents. This is right for
2477 SVR3.2. */
2478 if (strcmp (current->name, _LIB) == 0)
2479 bfd_set_section_vma (abfd, current, 0);
2480#endif
2481
2482 previous = current;
2483 }
2484
2485 /* It is now safe to write to the output file. If we needed an
2486 alignment adjustment for the last section, then make sure that
2487 there is a byte at offset sofar. If there are no symbols and no
2488 relocs, then nothing follows the last section. If we don't force
2489 the last byte out, then the file may appear to be truncated. */
2490 if (align_adjust)
2491 {
2492 bfd_byte b;
2493
2494 b = 0;
2495 if (bfd_seek (abfd, sofar - 1, SEEK_SET) != 0
2496 || bfd_write (&b, 1, 1, abfd) != 1)
2497 return false;
2498 }
2499
2500 /* Make sure the relocations are aligned. We don't need to make
2501 sure that this byte exists, because it will only matter if there
2502 really are relocs. */
2503 sofar = BFD_ALIGN (sofar, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER);
2504
2505 obj_relocbase (abfd) = sofar;
2506 abfd->output_has_begun = true;
2507
2508 return true;
2509}
2510
2511#if 0
2512
2513/* This can never work, because it is called too late--after the
2514 section positions have been set. I can't figure out what it is
2515 for, so I am going to disable it--Ian Taylor 20 March 1996. */
2516
2517/* If .file, .text, .data, .bss symbols are missing, add them. */
2518/* @@ Should we only be adding missing symbols, or overriding the aux
2519 values for existing section symbols? */
2520static boolean
2521coff_add_missing_symbols (abfd)
2522 bfd *abfd;
2523{
2524 unsigned int nsyms = bfd_get_symcount (abfd);
2525 asymbol **sympp = abfd->outsymbols;
2526 asymbol **sympp2;
2527 unsigned int i;
2528 int need_text = 1, need_data = 1, need_bss = 1, need_file = 1;
2529
2530 for (i = 0; i < nsyms; i++)
2531 {
2532 coff_symbol_type *csym = coff_symbol_from (abfd, sympp[i]);
2533 CONST char *name;
2534 if (csym)
2535 {
2536 /* only do this if there is a coff representation of the input
2537 symbol */
2538 if (csym->native && csym->native->u.syment.n_sclass == C_FILE)
2539 {
2540 need_file = 0;
2541 continue;
2542 }
2543 name = csym->symbol.name;
2544 if (!name)
2545 continue;
2546 if (!strcmp (name, _TEXT))
2547 need_text = 0;
2548#ifdef APOLLO_M68
2549 else if (!strcmp (name, ".wtext"))
2550 need_text = 0;
2551#endif
2552 else if (!strcmp (name, _DATA))
2553 need_data = 0;
2554 else if (!strcmp (name, _BSS))
2555 need_bss = 0;
2556 }
2557 }
2558 /* Now i == bfd_get_symcount (abfd). */
2559 /* @@ For now, don't deal with .file symbol. */
2560 need_file = 0;
2561
2562 if (!need_text && !need_data && !need_bss && !need_file)
2563 return true;
2564 nsyms += need_text + need_data + need_bss + need_file;
2565 sympp2 = (asymbol **) bfd_alloc (abfd, nsyms * sizeof (asymbol *));
2566 if (!sympp2)
2567 return false;
2568 memcpy (sympp2, sympp, i * sizeof (asymbol *));
2569 if (need_file)
2570 {
2571 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
2572 abort ();
2573 }
2574 if (need_text)
2575 sympp2[i++] = coff_section_symbol (abfd, _TEXT);
2576 if (need_data)
2577 sympp2[i++] = coff_section_symbol (abfd, _DATA);
2578 if (need_bss)
2579 sympp2[i++] = coff_section_symbol (abfd, _BSS);
2580 BFD_ASSERT (i == nsyms);
2581 bfd_set_symtab (abfd, sympp2, nsyms);
2582 return true;
2583}
2584
2585#endif /* 0 */
2586
2587/* SUPPRESS 558 */
2588/* SUPPRESS 529 */
2589static boolean
2590coff_write_object_contents (abfd)
2591 bfd * abfd;
2592{
2593 asection *current;
2594 boolean hasrelocs = false;
2595 boolean haslinno = false;
2596 file_ptr scn_base;
2597 file_ptr reloc_base;
2598 file_ptr lineno_base;
2599 file_ptr sym_base;
2600 unsigned long reloc_size = 0;
2601 unsigned long lnno_size = 0;
2602 boolean long_section_names;
2603 asection *text_sec = NULL;
2604 asection *data_sec = NULL;
2605 asection *bss_sec = NULL;
2606 struct internal_filehdr internal_f;
2607 struct internal_aouthdr internal_a;
2608#ifdef COFF_LONG_SECTION_NAMES
2609 size_t string_size = STRING_SIZE_SIZE;
2610#endif
2611
2612 bfd_set_error (bfd_error_system_call);
2613
2614 /* Make a pass through the symbol table to count line number entries and
2615 put them into the correct asections */
2616
2617 lnno_size = coff_count_linenumbers (abfd) * LINESZ;
2618
2619 if (abfd->output_has_begun == false)
2620 {
2621 if (! coff_compute_section_file_positions (abfd))
2622 return false;
2623 }
2624
2625 reloc_base = obj_relocbase (abfd);
2626
2627 /* Work out the size of the reloc and linno areas */
2628
2629 for (current = abfd->sections; current != NULL; current =
2630 current->next)
2631 reloc_size += current->reloc_count * RELSZ;
2632
2633 lineno_base = reloc_base + reloc_size;
2634 sym_base = lineno_base + lnno_size;
2635
2636 /* Indicate in each section->line_filepos its actual file address */
2637 for (current = abfd->sections; current != NULL; current =
2638 current->next)
2639 {
2640 if (current->lineno_count)
2641 {
2642 current->line_filepos = lineno_base;
2643 current->moving_line_filepos = lineno_base;
2644 lineno_base += current->lineno_count * LINESZ;
2645 }
2646 else
2647 {
2648 current->line_filepos = 0;
2649 }
2650 if (current->reloc_count)
2651 {
2652 current->rel_filepos = reloc_base;
2653 reloc_base += current->reloc_count * RELSZ;
2654 }
2655 else
2656 {
2657 current->rel_filepos = 0;
2658 }
2659 }
2660
2661 /* Write section headers to the file. */
2662 internal_f.f_nscns = 0;
2663
2664 if ((abfd->flags & EXEC_P) != 0)
2665 scn_base = FILHSZ + AOUTSZ;
2666 else
2667 {
2668 scn_base = FILHSZ;
2669#ifdef RS6000COFF_C
2670 if (xcoff_data (abfd)->full_aouthdr)
2671 scn_base += AOUTSZ;
2672 else
2673 scn_base += SMALL_AOUTSZ;
2674#endif
2675 }
2676
2677 if (bfd_seek (abfd, scn_base, SEEK_SET) != 0)
2678 return false;
2679
2680 long_section_names = false;
2681 for (current = abfd->sections;
2682 current != NULL;
2683 current = current->next)
2684 {
2685 struct internal_scnhdr section;
2686
2687#ifdef COFF_WITH_PE
2688 /* If we've got a .reloc section, remember. */
2689
2690#ifdef COFF_IMAGE_WITH_PE
2691 if (strcmp (current->name, ".reloc") == 0)
2692 {
2693 pe_data (abfd)->has_reloc_section = 1;
2694 }
2695#endif
2696
2697#endif
2698 internal_f.f_nscns++;
2699
2700 strncpy (section.s_name, current->name, SCNNMLEN);
2701
2702#ifdef COFF_LONG_SECTION_NAMES
2703 /* Handle long section names as in PE. This must be compatible
2704 with the code in coff_write_symbols. */
2705 {
2706 size_t len;
2707
2708 len = strlen (current->name);
2709 if (len > SCNNMLEN)
2710 {
2711 memset (section.s_name, 0, SCNNMLEN);
2712 sprintf (section.s_name, "/%lu", (unsigned long) string_size);
2713 string_size += len + 1;
2714 long_section_names = true;
2715 }
2716 }
2717#endif
2718
2719#ifdef _LIB
2720 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
2721 Ian Taylor <ian@cygnus.com>. */
2722 if (strcmp (current->name, _LIB) == 0)
2723 section.s_vaddr = 0;
2724 else
2725#endif
2726 section.s_vaddr = current->vma;
2727 section.s_paddr = current->lma;
2728 section.s_size = current->_raw_size;
2729
2730#ifdef COFF_WITH_PE
2731 section.s_paddr = 0;
2732#endif
2733#ifdef COFF_IMAGE_WITH_PE
2734 /* Reminder: s_paddr holds the virtual size of the section. */
2735 if (coff_section_data (abfd, current) != NULL
2736 && pei_section_data (abfd, current) != NULL)
2737 section.s_paddr = pei_section_data (abfd, current)->virt_size;
2738 else
2739 section.s_paddr = 0;
2740#endif
2741
2742 /*
2743 If this section has no size or is unloadable then the scnptr
2744 will be 0 too
2745 */
2746 if (current->_raw_size == 0 ||
2747 (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2748 {
2749 section.s_scnptr = 0;
2750 }
2751 else
2752 {
2753 section.s_scnptr = current->filepos;
2754 }
2755 section.s_relptr = current->rel_filepos;
2756 section.s_lnnoptr = current->line_filepos;
2757 section.s_nreloc = current->reloc_count;
2758 section.s_nlnno = current->lineno_count;
2759 if (current->reloc_count != 0)
2760 hasrelocs = true;
2761 if (current->lineno_count != 0)
2762 haslinno = true;
2763
2764#ifdef RS6000COFF_C
2765 /* Indicate the use of an XCOFF overflow section header. */
2766 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
2767 {
2768 section.s_nreloc = 0xffff;
2769 section.s_nlnno = 0xffff;
2770 }
2771#endif
2772
2773 section.s_flags = sec_to_styp_flags (current->name, current->flags);
2774
2775 if (!strcmp (current->name, _TEXT))
2776 {
2777 text_sec = current;
2778 }
2779 else if (!strcmp (current->name, _DATA))
2780 {
2781 data_sec = current;
2782 }
2783 else if (!strcmp (current->name, _BSS))
2784 {
2785 bss_sec = current;
2786 }
2787
2788#ifdef I960
2789 section.s_align = (current->alignment_power
2790 ? 1 << current->alignment_power
2791 : 0);
2792#else
2793#ifdef TIC80COFF
2794 section.s_flags |= (current->alignment_power & 0xF) << 8;
2795#endif
2796#endif
2797
2798#ifdef COFF_IMAGE_WITH_PE
2799 /* suppress output of the sections if they are null. ld includes
2800 the bss and data sections even if there is no size assigned
2801 to them. NT loader doesn't like it if these section headers are
2802 included if the sections themselves are not needed */
2803 if (section.s_size == 0)
2804 internal_f.f_nscns--;
2805 else
2806#endif
2807 {
2808 SCNHDR buff;
2809 if (coff_swap_scnhdr_out (abfd, &section, &buff) == 0
2810 || bfd_write ((PTR) (&buff), 1, SCNHSZ, abfd) != SCNHSZ)
2811 return false;
2812 }
2813
2814#ifdef COFF_WITH_PE
2815 /* PE stores COMDAT section information in the symbol table. If
2816 this section is supposed to have some COMDAT info, track down
2817 the symbol in the symbol table and modify it. */
2818 if ((current->flags & SEC_LINK_ONCE) != 0)
2819 {
2820 unsigned int i, count;
2821 asymbol **psym;
2822 coff_symbol_type *csym = NULL;
2823 asymbol **psymsec;
2824
2825 psymsec = NULL;
2826 count = bfd_get_symcount (abfd);
2827 for (i = 0, psym = abfd->outsymbols; i < count; i++, psym++)
2828 {
2829 if ((*psym)->section != current)
2830 continue;
2831
2832 /* Remember the location of the first symbol in this
2833 section. */
2834 if (psymsec == NULL)
2835 psymsec = psym;
2836
2837 /* See if this is the section symbol. */
2838 if (strcmp ((*psym)->name, current->name) == 0)
2839 {
2840 csym = coff_symbol_from (abfd, *psym);
2841 if (csym == NULL
2842 || csym->native == NULL
2843 || csym->native->u.syment.n_numaux < 1
2844 || csym->native->u.syment.n_sclass != C_STAT
2845 || csym->native->u.syment.n_type != T_NULL)
2846 continue;
2847
2848 /* Here *PSYM is the section symbol for CURRENT. */
2849
2850 break;
2851 }
2852 }
2853
2854 /* Did we find it?
2855 Note that we might not if we're converting the file from
2856 some other object file format. */
2857 if (i < count)
2858 {
2859 combined_entry_type *aux;
2860
2861 /* We don't touch the x_checksum field. The
2862 x_associated field is not currently supported. */
2863
2864 aux = csym->native + 1;
2865 switch (current->flags & SEC_LINK_DUPLICATES)
2866 {
2867 case SEC_LINK_DUPLICATES_DISCARD:
2868 aux->u.auxent.x_scn.x_comdat = IMAGE_COMDAT_SELECT_ANY;
2869 break;
2870
2871 case SEC_LINK_DUPLICATES_ONE_ONLY:
2872 aux->u.auxent.x_scn.x_comdat =
2873 IMAGE_COMDAT_SELECT_NODUPLICATES;
2874 break;
2875
2876 case SEC_LINK_DUPLICATES_SAME_SIZE:
2877 aux->u.auxent.x_scn.x_comdat =
2878 IMAGE_COMDAT_SELECT_SAME_SIZE;
2879 break;
2880
2881 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
2882 aux->u.auxent.x_scn.x_comdat =
2883 IMAGE_COMDAT_SELECT_EXACT_MATCH;
2884 break;
2885 }
2886
2887 /* The COMDAT symbol must be the first symbol from this
2888 section in the symbol table. In order to make this
2889 work, we move the COMDAT symbol before the first
2890 symbol we found in the search above. It's OK to
2891 rearrange the symbol table at this point, because
2892 coff_renumber_symbols is going to rearrange it
2893 further and fix up all the aux entries. */
2894 if (psym != psymsec)
2895 {
2896 asymbol *hold;
2897 asymbol **pcopy;
2898
2899 hold = *psym;
2900 for (pcopy = psym; pcopy > psymsec; pcopy--)
2901 pcopy[0] = pcopy[-1];
2902 *psymsec = hold;
2903 }
2904 }
2905 }
2906#endif /* COFF_WITH_PE */
2907 }
2908
2909#ifdef RS6000COFF_C
2910 /* XCOFF handles overflows in the reloc and line number count fields
2911 by creating a new section header to hold the correct values. */
2912 for (current = abfd->sections; current != NULL; current = current->next)
2913 {
2914 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
2915 {
2916 struct internal_scnhdr scnhdr;
2917 SCNHDR buff;
2918
2919 internal_f.f_nscns++;
2920 strncpy (&(scnhdr.s_name[0]), current->name, 8);
2921 scnhdr.s_paddr = current->reloc_count;
2922 scnhdr.s_vaddr = current->lineno_count;
2923 scnhdr.s_size = 0;
2924 scnhdr.s_scnptr = 0;
2925 scnhdr.s_relptr = current->rel_filepos;
2926 scnhdr.s_lnnoptr = current->line_filepos;
2927 scnhdr.s_nreloc = current->target_index;
2928 scnhdr.s_nlnno = current->target_index;
2929 scnhdr.s_flags = STYP_OVRFLO;
2930 if (coff_swap_scnhdr_out (abfd, &scnhdr, &buff) == 0
2931 || bfd_write ((PTR) &buff, 1, SCNHSZ, abfd) != SCNHSZ)
2932 return false;
2933 }
2934 }
2935#endif
2936
2937 /* OK, now set up the filehdr... */
2938
2939 /* Don't include the internal abs section in the section count */
2940
2941 /*
2942 We will NOT put a fucking timestamp in the header here. Every time you
2943 put it back, I will come in and take it out again. I'm sorry. This
2944 field does not belong here. We fill it with a 0 so it compares the
2945 same but is not a reasonable time. -- gnu@cygnus.com
2946 */
2947 internal_f.f_timdat = 0;
2948
2949 internal_f.f_flags = 0;
2950
2951 if (abfd->flags & EXEC_P)
2952 internal_f.f_opthdr = AOUTSZ;
2953 else
2954 {
2955 internal_f.f_opthdr = 0;
2956#ifdef RS6000COFF_C
2957 if (xcoff_data (abfd)->full_aouthdr)
2958 internal_f.f_opthdr = AOUTSZ;
2959 else
2960 internal_f.f_opthdr = SMALL_AOUTSZ;
2961#endif
2962 }
2963
2964 if (!hasrelocs)
2965 internal_f.f_flags |= F_RELFLG;
2966 if (!haslinno)
2967 internal_f.f_flags |= F_LNNO;
2968 if (abfd->flags & EXEC_P)
2969 internal_f.f_flags |= F_EXEC;
2970
2971 /* FIXME: this is wrong for PPC_PE! */
2972 if (bfd_little_endian (abfd))
2973 internal_f.f_flags |= F_AR32WR;
2974 else
2975 internal_f.f_flags |= F_AR32W;
2976
2977#ifdef TIC80_TARGET_ID
2978 internal_f.f_target_id = TIC80_TARGET_ID;
2979#endif
2980
2981 /*
2982 FIXME, should do something about the other byte orders and
2983 architectures.
2984 */
2985
2986#ifdef RS6000COFF_C
2987 if ((abfd->flags & DYNAMIC) != 0)
2988 internal_f.f_flags |= F_SHROBJ;
2989 if (bfd_get_section_by_name (abfd, _LOADER) != NULL)
2990 internal_f.f_flags |= F_DYNLOAD;
2991#endif
2992
2993 memset (&internal_a, 0, sizeof internal_a);
2994
2995 /* Set up architecture-dependent stuff */
2996
2997 {
2998 unsigned int magic = 0;
2999 unsigned short flags = 0;
3000 coff_set_flags (abfd, &magic, &flags);
3001 internal_f.f_magic = magic;
3002 internal_f.f_flags |= flags;
3003 /* ...and the "opt"hdr... */
3004
3005#ifdef A29K
3006#ifdef ULTRA3 /* NYU's machine */
3007 /* FIXME: This is a bogus check. I really want to see if there
3008 * is a .shbss or a .shdata section, if so then set the magic
3009 * number to indicate a shared data executable.
3010 */
3011 if (internal_f.f_nscns >= 7)
3012 internal_a.magic = SHMAGIC; /* Shared magic */
3013 else
3014#endif /* ULTRA3 */
3015 internal_a.magic = NMAGIC; /* Assume separate i/d */
3016#define __A_MAGIC_SET__
3017#endif /* A29K */
3018#ifdef TIC80COFF
3019 internal_a.magic = TIC80_ARCH_MAGIC;
3020#define __A_MAGIC_SET__
3021#endif /* TIC80 */
3022#ifdef I860
3023 /* FIXME: What are the a.out magic numbers for the i860? */
3024 internal_a.magic = 0;
3025#define __A_MAGIC_SET__
3026#endif /* I860 */
3027#ifdef I960
3028 internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
3029#define __A_MAGIC_SET__
3030#endif /* I960 */
3031#if M88
3032#define __A_MAGIC_SET__
3033 internal_a.magic = PAGEMAGICBCS;
3034#endif /* M88 */
3035
3036#if APOLLO_M68
3037#define __A_MAGIC_SET__
3038 internal_a.magic = APOLLO_COFF_VERSION_NUMBER;
3039#endif
3040
3041#if defined(M68) || defined(WE32K) || defined(M68K)
3042#define __A_MAGIC_SET__
3043#if defined(LYNXOS)
3044 internal_a.magic = LYNXCOFFMAGIC;
3045#else
3046#if defined(TARG_AUX)
3047 internal_a.magic = (abfd->flags & D_PAGED ? PAGEMAGICPEXECPAGED :
3048 abfd->flags & WP_TEXT ? PAGEMAGICPEXECSWAPPED :
3049 PAGEMAGICEXECSWAPPED);
3050#else
3051#if defined (PAGEMAGICPEXECPAGED)
3052 internal_a.magic = PAGEMAGICPEXECPAGED;
3053#endif
3054#endif /* TARG_AUX */
3055#endif /* LYNXOS */
3056#endif /* M68 || WE32K || M68K */
3057
3058#if defined(ARM)
3059#define __A_MAGIC_SET__
3060 internal_a.magic = ZMAGIC;
3061#endif
3062
3063#if defined(PPC_PE)
3064#define __A_MAGIC_SET__
3065 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
3066#endif
3067
3068#if defined MCORE_PE
3069#define __A_MAGIC_SET__
3070 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
3071#endif
3072
3073#if defined(I386)
3074#define __A_MAGIC_SET__
3075#if defined(LYNXOS)
3076 internal_a.magic = LYNXCOFFMAGIC;
3077#else /* LYNXOS */
3078 internal_a.magic = ZMAGIC;
3079#endif /* LYNXOS */
3080#endif /* I386 */
3081
3082#if defined(SPARC)
3083#define __A_MAGIC_SET__
3084#if defined(LYNXOS)
3085 internal_a.magic = LYNXCOFFMAGIC;
3086#endif /* LYNXOS */
3087#endif /* SPARC */
3088
3089#ifdef RS6000COFF_C
3090#define __A_MAGIC_SET__
3091 internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC :
3092 (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC :
3093 RS6K_AOUTHDR_OMAGIC;
3094#endif
3095
3096#ifndef __A_MAGIC_SET__
3097#include "Your aouthdr magic number is not being set!"
3098#else
3099#undef __A_MAGIC_SET__
3100#endif
3101 }
3102
3103 /* FIXME: Does anybody ever set this to another value? */
3104 internal_a.vstamp = 0;
3105
3106 /* Now should write relocs, strings, syms */
3107 obj_sym_filepos (abfd) = sym_base;
3108
3109 if (bfd_get_symcount (abfd) != 0)
3110 {
3111 int firstundef;
3112#if 0
3113 if (!coff_add_missing_symbols (abfd))
3114 return false;
3115#endif
3116 if (!coff_renumber_symbols (abfd, &firstundef))
3117 return false;
3118 coff_mangle_symbols (abfd);
3119 if (! coff_write_symbols (abfd))
3120 return false;
3121 if (! coff_write_linenumbers (abfd))
3122 return false;
3123 if (! coff_write_relocs (abfd, firstundef))
3124 return false;
3125 }
3126#ifdef COFF_LONG_SECTION_NAMES
3127 else if (long_section_names)
3128 {
3129 /* If we have long section names we have to write out the string
3130 table even if there are no symbols. */
3131 if (! coff_write_symbols (abfd))
3132 return false;
3133 }
3134#endif
3135#ifdef COFF_IMAGE_WITH_PE
3136#ifdef PPC_PE
3137 else if ((abfd->flags & EXEC_P) != 0)
3138 {
3139 bfd_byte b;
3140
3141 /* PowerPC PE appears to require that all executable files be
3142 rounded up to the page size. */
3143 b = 0;
3144 if (bfd_seek (abfd,
3145 BFD_ALIGN (sym_base, COFF_PAGE_SIZE) - 1,
3146 SEEK_SET) != 0
3147 || bfd_write (&b, 1, 1, abfd) != 1)
3148 return false;
3149 }
3150#endif
3151#endif
3152
3153 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
3154 backend linker, and obj_raw_syment_count is not valid until after
3155 coff_write_symbols is called. */
3156 if (obj_raw_syment_count (abfd) != 0)
3157 {
3158 internal_f.f_symptr = sym_base;
3159#ifdef RS6000COFF_C
3160 /* AIX appears to require that F_RELFLG not be set if there are
3161 local symbols but no relocations. */
3162 internal_f.f_flags &=~ F_RELFLG;
3163#endif
3164 }
3165 else
3166 {
3167 if (long_section_names)
3168 internal_f.f_symptr = sym_base;
3169 else
3170 internal_f.f_symptr = 0;
3171 internal_f.f_flags |= F_LSYMS;
3172 }
3173
3174 if (text_sec)
3175 {
3176 internal_a.tsize = bfd_get_section_size_before_reloc (text_sec);
3177 internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
3178 }
3179 if (data_sec)
3180 {
3181 internal_a.dsize = bfd_get_section_size_before_reloc (data_sec);
3182 internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
3183 }
3184 if (bss_sec)
3185 {
3186 internal_a.bsize = bfd_get_section_size_before_reloc (bss_sec);
3187 if (internal_a.bsize && bss_sec->vma < internal_a.data_start)
3188 internal_a.data_start = bss_sec->vma;
3189 }
3190
3191 internal_a.entry = bfd_get_start_address (abfd);
3192 internal_f.f_nsyms = obj_raw_syment_count (abfd);
3193
3194#ifdef RS6000COFF_C
3195 if (xcoff_data (abfd)->full_aouthdr)
3196 {
3197 bfd_vma toc;
3198 asection *loader_sec;
3199
3200 internal_a.vstamp = 1;
3201
3202 internal_a.o_snentry = xcoff_data (abfd)->snentry;
3203 if (internal_a.o_snentry == 0)
3204 internal_a.entry = (bfd_vma) -1;
3205
3206 if (text_sec != NULL)
3207 {
3208 internal_a.o_sntext = text_sec->target_index;
3209 internal_a.o_algntext = bfd_get_section_alignment (abfd, text_sec);
3210 }
3211 else
3212 {
3213 internal_a.o_sntext = 0;
3214 internal_a.o_algntext = 0;
3215 }
3216 if (data_sec != NULL)
3217 {
3218 internal_a.o_sndata = data_sec->target_index;
3219 internal_a.o_algndata = bfd_get_section_alignment (abfd, data_sec);
3220 }
3221 else
3222 {
3223 internal_a.o_sndata = 0;
3224 internal_a.o_algndata = 0;
3225 }
3226 loader_sec = bfd_get_section_by_name (abfd, ".loader");
3227 if (loader_sec != NULL)
3228 internal_a.o_snloader = loader_sec->target_index;
3229 else
3230 internal_a.o_snloader = 0;
3231 if (bss_sec != NULL)
3232 internal_a.o_snbss = bss_sec->target_index;
3233 else
3234 internal_a.o_snbss = 0;
3235
3236 toc = xcoff_data (abfd)->toc;
3237 internal_a.o_toc = toc;
3238 internal_a.o_sntoc = xcoff_data (abfd)->sntoc;
3239
3240 internal_a.o_modtype = xcoff_data (abfd)->modtype;
3241 if (xcoff_data (abfd)->cputype != -1)
3242 internal_a.o_cputype = xcoff_data (abfd)->cputype;
3243 else
3244 {
3245 switch (bfd_get_arch (abfd))
3246 {
3247 case bfd_arch_rs6000:
3248 internal_a.o_cputype = 4;
3249 break;
3250 case bfd_arch_powerpc:
3251 if (bfd_get_mach (abfd) == 0)
3252 internal_a.o_cputype = 3;
3253 else
3254 internal_a.o_cputype = 1;
3255 break;
3256 default:
3257 abort ();
3258 }
3259 }
3260 internal_a.o_maxstack = xcoff_data (abfd)->maxstack;
3261 internal_a.o_maxdata = xcoff_data (abfd)->maxdata;
3262 }
3263#endif
3264
3265 /* now write them */
3266 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
3267 return false;
3268 {
3269 char buff[FILHSZ];
3270 coff_swap_filehdr_out (abfd, (PTR) & internal_f, (PTR) buff);
3271 if (bfd_write ((PTR) buff, 1, FILHSZ, abfd) != FILHSZ)
3272 return false;
3273 }
3274 if (abfd->flags & EXEC_P)
3275 {
3276 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
3277 include/coff/pe.h sets AOUTSZ == sizeof(PEAOUTHDR)) */
3278 char buff[AOUTSZ];
3279 coff_swap_aouthdr_out (abfd, (PTR) & internal_a, (PTR) buff);
3280 if (bfd_write ((PTR) buff, 1, AOUTSZ, abfd) != AOUTSZ)
3281 return false;
3282 }
3283#ifdef RS6000COFF_C
3284 else
3285 {
3286 AOUTHDR buff;
3287 size_t size;
3288
3289 /* XCOFF seems to always write at least a small a.out header. */
3290 coff_swap_aouthdr_out (abfd, (PTR) &internal_a, (PTR) &buff);
3291 if (xcoff_data (abfd)->full_aouthdr)
3292 size = AOUTSZ;
3293 else
3294 size = SMALL_AOUTSZ;
3295 if (bfd_write ((PTR) &buff, 1, size, abfd) != size)
3296 return false;
3297 }
3298#endif
3299
3300 return true;
3301}
3302
3303static boolean
3304coff_set_section_contents (abfd, section, location, offset, count)
3305 bfd * abfd;
3306 sec_ptr section;
3307 PTR location;
3308 file_ptr offset;
3309 bfd_size_type count;
3310{
3311 if (abfd->output_has_begun == false) /* set by bfd.c handler */
3312 {
3313 if (! coff_compute_section_file_positions (abfd))
3314 return false;
3315 }
3316
3317#if defined(_LIB) && !defined(TARG_AUX)
3318
3319 /* The physical address field of a .lib section is used to hold the
3320 number of shared libraries in the section. This code counts the
3321 number of sections being written, and increments the lma field
3322 with the number.
3323
3324 I have found no documentation on the contents of this section.
3325 Experimentation indicates that the section contains zero or more
3326 records, each of which has the following structure:
3327
3328 - a (four byte) word holding the length of this record, in words,
3329 - a word that always seems to be set to "2",
3330 - the path to a shared library, null-terminated and then padded
3331 to a whole word boundary.
3332
3333 bfd_assert calls have been added to alert if an attempt is made
3334 to write a section which doesn't follow these assumptions. The
3335 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
3336 <robertl@arnet.com> (Thanks!).
3337
3338 Gvran Uddeborg <gvran@uddeborg.pp.se> */
3339
3340 if (strcmp (section->name, _LIB) == 0)
3341 {
3342 bfd_byte *rec, *recend;
3343
3344 rec = (bfd_byte *) location;
3345 recend = rec + count;
3346 while (rec < recend)
3347 {
3348 ++section->lma;
3349 rec += bfd_get_32 (abfd, rec) * 4;
3350 }
3351
3352 BFD_ASSERT (rec == recend);
3353 }
3354
3355#endif
3356
3357 /* Don't write out bss sections - one way to do this is to
3358 see if the filepos has not been set. */
3359 if (section->filepos == 0)
3360 return true;
3361
3362 if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) != 0)
3363 return false;
3364
3365 if (count != 0)
3366 {
3367 return (bfd_write (location, 1, count, abfd) == count) ? true : false;
3368 }
3369 return true;
3370}
3371#if 0
3372static boolean
3373coff_close_and_cleanup (abfd)
3374 bfd *abfd;
3375{
3376 if (!bfd_read_p (abfd))
3377 switch (abfd->format)
3378 {
3379 case bfd_archive:
3380 if (!_bfd_write_archive_contents (abfd))
3381 return false;
3382 break;
3383 case bfd_object:
3384 if (!coff_write_object_contents (abfd))
3385 return false;
3386 break;
3387 default:
3388 bfd_set_error (bfd_error_invalid_operation);
3389 return false;
3390 }
3391
3392 /* We depend on bfd_close to free all the memory on the objalloc. */
3393 return true;
3394}
3395
3396#endif
3397
3398static PTR
3399buy_and_read (abfd, where, seek_direction, size)
3400 bfd *abfd;
3401 file_ptr where;
3402 int seek_direction;
3403 size_t size;
3404{
3405 PTR area = (PTR) bfd_alloc (abfd, size);
3406 if (!area)
3407 return (NULL);
3408 if (bfd_seek (abfd, where, seek_direction) != 0
3409 || bfd_read (area, 1, size, abfd) != size)
3410 return (NULL);
3411 return (area);
3412} /* buy_and_read() */
3413
3414/*
3415SUBSUBSECTION
3416 Reading linenumbers
3417
3418 Creating the linenumber table is done by reading in the entire
3419 coff linenumber table, and creating another table for internal use.
3420
3421 A coff linenumber table is structured so that each function
3422 is marked as having a line number of 0. Each line within the
3423 function is an offset from the first line in the function. The
3424 base of the line number information for the table is stored in
3425 the symbol associated with the function.
3426
3427 The information is copied from the external to the internal
3428 table, and each symbol which marks a function is marked by
3429 pointing its...
3430
3431 How does this work ?
3432
3433*/
3434
3435static boolean
3436coff_slurp_line_table (abfd, asect)
3437 bfd *abfd;
3438 asection *asect;
3439{
3440 LINENO *native_lineno;
3441 alent *lineno_cache;
3442
3443 BFD_ASSERT (asect->lineno == (alent *) NULL);
3444
3445 native_lineno = (LINENO *) buy_and_read (abfd,
3446 asect->line_filepos,
3447 SEEK_SET,
3448 (size_t) (LINESZ *
3449 asect->lineno_count));
3450 lineno_cache =
3451 (alent *) bfd_alloc (abfd, (size_t) ((asect->lineno_count + 1) * sizeof (alent)));
3452 if (lineno_cache == NULL)
3453 return false;
3454 else
3455 {
3456 unsigned int counter = 0;
3457 alent *cache_ptr = lineno_cache;
3458 LINENO *src = native_lineno;
3459
3460 while (counter < asect->lineno_count)
3461 {
3462 struct internal_lineno dst;
3463 coff_swap_lineno_in (abfd, src, &dst);
3464 cache_ptr->line_number = dst.l_lnno;
3465
3466 if (cache_ptr->line_number == 0)
3467 {
3468 boolean warned;
3469 long symndx;
3470 coff_symbol_type *sym;
3471
3472 warned = false;
3473 symndx = dst.l_addr.l_symndx;
3474 if (symndx < 0
3475 || (unsigned long) symndx >= obj_raw_syment_count (abfd))
3476 {
3477 (*_bfd_error_handler)
3478 (_("%s: warning: illegal symbol index %ld in line numbers"),
3479 bfd_get_filename (abfd), dst.l_addr.l_symndx);
3480 symndx = 0;
3481 warned = true;
3482 }
3483 /* FIXME: We should not be casting between ints and
3484 pointers like this. */
3485 sym = ((coff_symbol_type *)
3486 ((symndx + obj_raw_syments (abfd))
3487 ->u.syment._n._n_n._n_zeroes));
3488 cache_ptr->u.sym = (asymbol *) sym;
3489 if (sym->lineno != NULL && ! warned)
3490 {
3491 (*_bfd_error_handler)
3492 (_("%s: warning: duplicate line number information for `%s'"),
3493 bfd_get_filename (abfd),
3494 bfd_asymbol_name (&sym->symbol));
3495 }
3496 sym->lineno = cache_ptr;
3497 }
3498 else
3499 {
3500 cache_ptr->u.offset = dst.l_addr.l_paddr
3501 - bfd_section_vma (abfd, asect);
3502 } /* If no linenumber expect a symbol index */
3503
3504 cache_ptr++;
3505 src++;
3506 counter++;
3507 }
3508 cache_ptr->line_number = 0;
3509
3510 }
3511 asect->lineno = lineno_cache;
3512 /* FIXME, free native_lineno here, or use alloca or something. */
3513 return true;
3514}
3515
3516static boolean
3517coff_slurp_symbol_table (abfd)
3518 bfd * abfd;
3519{
3520 combined_entry_type *native_symbols;
3521 coff_symbol_type *cached_area;
3522 unsigned int *table_ptr;
3523
3524 unsigned int number_of_symbols = 0;
3525
3526 if (obj_symbols (abfd))
3527 return true;
3528
3529 /* Read in the symbol table */
3530 if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL)
3531 {
3532 return (false);
3533 } /* on error */
3534
3535 /* Allocate enough room for all the symbols in cached form */
3536 cached_area = ((coff_symbol_type *)
3537 bfd_alloc (abfd,
3538 (obj_raw_syment_count (abfd)
3539 * sizeof (coff_symbol_type))));
3540
3541 if (cached_area == NULL)
3542 return false;
3543 table_ptr = ((unsigned int *)
3544 bfd_alloc (abfd,
3545 (obj_raw_syment_count (abfd)
3546 * sizeof (unsigned int))));
3547
3548 if (table_ptr == NULL)
3549 return false;
3550 else
3551 {
3552 coff_symbol_type *dst = cached_area;
3553 unsigned int last_native_index = obj_raw_syment_count (abfd);
3554 unsigned int this_index = 0;
3555 while (this_index < last_native_index)
3556 {
3557 combined_entry_type *src = native_symbols + this_index;
3558 table_ptr[this_index] = number_of_symbols;
3559 dst->symbol.the_bfd = abfd;
3560
3561 dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset);
3562 /* We use the native name field to point to the cached field. */
3563 src->u.syment._n._n_n._n_zeroes = (long) dst;
3564 dst->symbol.section = coff_section_from_bfd_index (abfd,
3565 src->u.syment.n_scnum);
3566 dst->symbol.flags = 0;
3567 dst->done_lineno = false;
3568
3569 switch (src->u.syment.n_sclass)
3570 {
3571#ifdef I960
3572 case C_LEAFEXT:
3573#if 0
3574 dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
3575 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
3576 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
3577#endif
3578 /* Fall through to next case */
3579
3580#endif
3581
3582 case C_EXT:
3583 case C_WEAKEXT:
3584#if defined ARM
3585 case C_THUMBEXT:
3586 case C_THUMBEXTFUNC:
3587#endif
3588#ifdef RS6000COFF_C
3589 case C_HIDEXT:
3590#endif
3591#ifdef C_SYSTEM
3592 case C_SYSTEM: /* System Wide variable */
3593#endif
3594#ifdef COFF_WITH_PE
5d54c628 3595 /* In PE, 0x68 (104) denotes a section symbol */
252b5132 3596 case C_SECTION:
5d54c628 3597 /* In PE, 0x69 (105) denotes a weak external symbol. */
252b5132
RH		 3598 case C_NT_WEAK:
3599#endif
5d54c628 3600 switch (coff_classify_symbol (abfd, &src->u.syment))
252b5132 3601 {
5d54c628 3602 case COFF_SYMBOL_GLOBAL:
252b5132 3603 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
252b5132
RH		 3604#if defined COFF_WITH_PE
3605 /* PE sets the symbol to a value relative to the
3606 start of the section. */
3607 dst->symbol.value = src->u.syment.n_value;
3608#else
3609 dst->symbol.value = (src->u.syment.n_value
3610 - dst->symbol.section->vma);
3611#endif
252b5132
RH		 3612 if (ISFCN ((src->u.syment.n_type)))
3613 {
3614 /* A function ext does not go at the end of a
3615 file. */
3616 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
3617 }
5d54c628
ILT		 3618 break;
3619
3620 case COFF_SYMBOL_COMMON:
3621 dst->symbol.section = bfd_com_section_ptr;
3622 dst->symbol.value = src->u.syment.n_value;
3623 break;
3624
3625 case COFF_SYMBOL_UNDEFINED:
3626 dst->symbol.section = bfd_und_section_ptr;
3627 dst->symbol.value = 0;
3628 break;
3629
3630 case COFF_SYMBOL_PE_SECTION:
3631 dst->symbol.flags |= BSF_EXPORT | BSF_SECTION_SYM;
3632 dst->symbol.value = 0;
3633 break;
3634
3635 case COFF_SYMBOL_LOCAL:
3636 dst->symbol.flags = BSF_LOCAL;
3637#if defined COFF_WITH_PE
3638 /* PE sets the symbol to a value relative to the
3639 start of the section. */
3640 dst->symbol.value = src->u.syment.n_value;
3641#else
3642 dst->symbol.value = (src->u.syment.n_value
3643 - dst->symbol.section->vma);
3644#endif
3645 if (ISFCN ((src->u.syment.n_type)))
3646 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
3647 break;
252b5132
RH		 3648 }
3649
3650#ifdef RS6000COFF_C
252b5132
RH		 3651 /* A symbol with a csect entry should not go at the end. */
3652 if (src->u.syment.n_numaux > 0)
3653 dst->symbol.flags |= BSF_NOT_AT_END;
3654#endif
3655
3656#ifdef COFF_WITH_PE
3657 if (src->u.syment.n_sclass == C_NT_WEAK)
3658 dst->symbol.flags = BSF_WEAK;
ec0ef80e
DD		 3659 if (src->u.syment.n_sclass == C_SECTION
3660 && src->u.syment.n_scnum > 0)
3661 {
3662 dst->symbol.flags = BSF_LOCAL;
3663 }
252b5132
RH		 3664#endif
3665
3666 if (src->u.syment.n_sclass == C_WEAKEXT)
3667 dst->symbol.flags = BSF_WEAK;
3668
3669 break;
3670
3671 case C_STAT: /* static */
3672#ifdef I960
3673 case C_LEAFSTAT: /* static leaf procedure */
3674#endif
3675#if defined ARM
3676 case C_THUMBSTAT: /* Thumb static */
3677 case C_THUMBLABEL: /* Thumb label */
3678 case C_THUMBSTATFUNC:/* Thumb static function */
3679#endif
3680 case C_LABEL: /* label */
3681 if (src->u.syment.n_scnum == -2)
3682 dst->symbol.flags = BSF_DEBUGGING;
3683 else
3684 dst->symbol.flags = BSF_LOCAL;
3685
3686 /* Base the value as an index from the base of the
3687 section, if there is one. */
3688 if (dst->symbol.section)
3689 {
3690#if defined COFF_WITH_PE
3691 /* PE sets the symbol to a value relative to the
3692 start of the section. */
3693 dst->symbol.value = src->u.syment.n_value;
3694#else
3695 dst->symbol.value = (src->u.syment.n_value
3696 - dst->symbol.section->vma);
3697#endif
3698 }
3699 else
3700 dst->symbol.value = src->u.syment.n_value;
3701 break;
3702
3703 case C_MOS: /* member of structure */
3704 case C_EOS: /* end of structure */
3705#ifdef NOTDEF /* C_AUTOARG has the same value */
3706#ifdef C_GLBLREG
3707 case C_GLBLREG: /* A29k-specific storage class */
3708#endif
3709#endif
3710 case C_REGPARM: /* register parameter */
3711 case C_REG: /* register variable */
3712#ifndef TIC80COFF
3713#ifdef C_AUTOARG
3714 case C_AUTOARG: /* 960-specific storage class */
3715#endif
3716#endif
3717 case C_TPDEF: /* type definition */
3718 case C_ARG:
3719 case C_AUTO: /* automatic variable */
3720 case C_FIELD: /* bit field */
3721 case C_ENTAG: /* enumeration tag */
3722 case C_MOE: /* member of enumeration */
3723 case C_MOU: /* member of union */
3724 case C_UNTAG: /* union tag */
3725 dst->symbol.flags = BSF_DEBUGGING;
3726 dst->symbol.value = (src->u.syment.n_value);
3727 break;
3728
3729 case C_FILE: /* file name */
3730 case C_STRTAG: /* structure tag */
3731#ifdef RS6000COFF_C
3732 case C_GSYM:
3733 case C_LSYM:
3734 case C_PSYM:
3735 case C_RSYM:
3736 case C_RPSYM:
3737 case C_STSYM:
3738 case C_BCOMM:
3739 case C_ECOMM:
3740 case C_DECL:
3741 case C_ENTRY:
3742 case C_FUN:
3743 case C_ESTAT:
3744#endif
3745 dst->symbol.flags = BSF_DEBUGGING;
3746 dst->symbol.value = (src->u.syment.n_value);
3747 break;
3748
3749#ifdef RS6000COFF_C
3750 case C_BINCL: /* beginning of include file */
3751 case C_EINCL: /* ending of include file */
3752 /* The value is actually a pointer into the line numbers
3753 of the file. We locate the line number entry, and
3754 set the section to the section which contains it, and
3755 the value to the index in that section. */
3756 {
3757 asection *sec;
3758
3759 dst->symbol.flags = BSF_DEBUGGING;
3760 for (sec = abfd->sections; sec != NULL; sec = sec->next)
3761 if (sec->line_filepos <= (file_ptr) src->u.syment.n_value
3762 && ((file_ptr) (sec->line_filepos
3763 + sec->lineno_count * LINESZ)
3764 > (file_ptr) src->u.syment.n_value))
3765 break;
3766 if (sec == NULL)
3767 dst->symbol.value = 0;
3768 else
3769 {
3770 dst->symbol.section = sec;
3771 dst->symbol.value = ((src->u.syment.n_value
3772 - sec->line_filepos)
3773 / LINESZ);
3774 src->fix_line = 1;
3775 }
3776 }
3777 break;
3778
3779 case C_BSTAT:
3780 dst->symbol.flags = BSF_DEBUGGING;
3781
3782 /* The value is actually a symbol index. Save a pointer
3783 to the symbol instead of the index. FIXME: This
3784 should use a union. */
3785 src->u.syment.n_value =
3786 (long) (native_symbols + src->u.syment.n_value);
3787 dst->symbol.value = src->u.syment.n_value;
3788 src->fix_value = 1;
3789 break;
3790#endif
3791
3792 case C_BLOCK: /* ".bb" or ".eb" */
3793 case C_FCN: /* ".bf" or ".ef" */
3794 case C_EFCN: /* physical end of function */
3795 dst->symbol.flags = BSF_LOCAL;
3796#if defined COFF_WITH_PE
3797 /* PE sets the symbol to a value relative to the start
3798 of the section. */
3799 dst->symbol.value = src->u.syment.n_value;
3800#else
3801 /* Base the value as an index from the base of the
3802 section. */
3803 dst->symbol.value = (src->u.syment.n_value
3804 - dst->symbol.section->vma);
3805#endif
3806 break;
3807
3808 case C_NULL:
3809 case C_EXTDEF: /* external definition */
3810 case C_ULABEL: /* undefined label */
3811 case C_USTATIC: /* undefined static */
3812#ifndef COFF_WITH_PE
3813 /* C_LINE in regular coff is 0x68. NT has taken over this storage
3814 class to represent a section symbol */
3815 case C_LINE: /* line # reformatted as symbol table entry */
3816 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
3817 case C_ALIAS: /* duplicate tag */
3818#endif
3819 /* New storage classes for TIc80 */
3820#ifdef TIC80COFF
3821 case C_UEXT: /* Tentative external definition */
3822#endif
3823 case C_STATLAB: /* Static load time label */
3824 case C_EXTLAB: /* External load time label */
3825 case C_HIDDEN: /* ext symbol in dmert public lib */
3826 default:
3827 (*_bfd_error_handler)
3828 (_("%s: Unrecognized storage class %d for %s symbol `%s'"),
3829 bfd_get_filename (abfd), src->u.syment.n_sclass,
3830 dst->symbol.section->name, dst->symbol.name);
3831 dst->symbol.flags = BSF_DEBUGGING;
3832 dst->symbol.value = (src->u.syment.n_value);
3833 break;
3834 }
3835
3836/* BFD_ASSERT(dst->symbol.flags != 0);*/
3837
3838 dst->native = src;
3839
3840 dst->symbol.udata.i = 0;
3841 dst->lineno = (alent *) NULL;
3842 this_index += (src->u.syment.n_numaux) + 1;
3843 dst++;
3844 number_of_symbols++;
3845 } /* walk the native symtab */
3846 } /* bfdize the native symtab */
3847
3848 obj_symbols (abfd) = cached_area;
3849 obj_raw_syments (abfd) = native_symbols;
3850
3851 bfd_get_symcount (abfd) = number_of_symbols;
3852 obj_convert (abfd) = table_ptr;
3853 /* Slurp the line tables for each section too */
3854 {
3855 asection *p;
3856 p = abfd->sections;
3857 while (p)
3858 {
3859 coff_slurp_line_table (abfd, p);
3860 p = p->next;
3861 }
3862 }
3863 return true;
3864} /* coff_slurp_symbol_table() */
3865
5d54c628
ILT		 3866/* Classify a COFF symbol. A couple of targets have globally visible
3867 symbols which are not class C_EXT, and this handles those. It also
3868 recognizes some special PE cases. */
252b5132 3869
5d54c628
ILT		 3870static enum coff_symbol_classification
3871coff_classify_symbol (abfd, syment)
3872 bfd *abfd;
3873 struct internal_syment *syment;
3874{
3875 /* FIXME: This partially duplicates the switch in
3876 coff_slurp_symbol_table. */
3877 switch (syment->n_sclass)
3878 {
3879 case C_EXT:
3880 case C_WEAKEXT:
252b5132 3881#ifdef I960
5d54c628 3882 case C_LEAFEXT:
252b5132 3883#endif
5d54c628
ILT		 3884#ifdef ARM
3885 case C_THUMBEXT:
3886 case C_THUMBEXTFUNC:
252b5132 3887#endif
5d54c628
ILT		 3888#ifdef C_SYSTEM
3889 case C_SYSTEM:
252b5132 3890#endif
5d54c628
ILT		 3891#ifdef COFF_WITH_PE
3892 case C_NT_WEAK:
3893#endif
3894 if (syment->n_scnum == 0)
3895 {
3896 if (syment->n_value == 0)
3897 return COFF_SYMBOL_UNDEFINED;
3898 else
3899 return COFF_SYMBOL_COMMON;
3900 }
3901 return COFF_SYMBOL_GLOBAL;
3902
3903 default:
3904 break;
3905 }
252b5132 3906
5d54c628
ILT		 3907#ifdef COFF_WITH_PE
3908 if (syment->n_sclass == C_STAT)
3909 {
3910 if (syment->n_scnum == 0)
3911 {
3912 /* The Microsoft compiler sometimes generates these if a
3913 small static function is inlined every time it is used.
3914 The function is discarded, but the symbol table entry
3915 remains. */
3916 return COFF_SYMBOL_LOCAL;
3917 }
252b5132 3918
bd826630
ILT		 3919#if 0
3920 /* This is correct for Microsoft generated objects, but it
3921 breaks gas generated objects. */
3922
5d54c628
ILT		 3923 if (syment->n_value == 0)
3924 {
3925 asection *sec;
3926 char buf[SYMNMLEN + 1];
3927
3928 sec = coff_section_from_bfd_index (abfd, syment->n_scnum);
3929 if (sec != NULL
3930 && (strcmp (bfd_get_section_name (abfd, sec),
3931 _bfd_coff_internal_syment_name (abfd, syment, buf))
3932 == 0))
3933 return COFF_SYMBOL_PE_SECTION;
3934 }
bd826630 3935#endif
252b5132 3936
5d54c628
ILT		 3937 return COFF_SYMBOL_LOCAL;
3938 }
252b5132 3939
5d54c628
ILT		 3940 if (syment->n_sclass == C_SECTION)
3941 {
3942 /* In some cases in a DLL generated by the Microsoft linker, the
3943 n_value field will contain garbage. FIXME: This should
3944 probably be handled by the swapping function instead. */
3945 syment->n_value = 0;
3946 if (syment->n_scnum == 0)
3947 return COFF_SYMBOL_UNDEFINED;
3948 return COFF_SYMBOL_PE_SECTION;
3949 }
3950#endif /* COFF_WITH_PE */
252b5132 3951
5d54c628 3952 /* If it is not a global symbol, we presume it is a local symbol. */
252b5132 3953
5d54c628
ILT		 3954 if (syment->n_scnum == 0)
3955 {
3956 char buf[SYMNMLEN + 1];
252b5132 3957
5d54c628
ILT		 3958 (*_bfd_error_handler)
3959 (_("warning: %s: local symbol `%s' has no section"),
3960 bfd_get_filename (abfd),
3961 _bfd_coff_internal_syment_name (abfd, syment, buf));
3962 }
252b5132 3963
5d54c628
ILT		 3964 return COFF_SYMBOL_LOCAL;
3965}
252b5132
RH		 3966
3967/*
3968SUBSUBSECTION
3969 Reading relocations
3970
3971 Coff relocations are easily transformed into the internal BFD form
3972 (@code{arelent}).
3973
3974 Reading a coff relocation table is done in the following stages:
3975
3976 o Read the entire coff relocation table into memory.
3977
3978 o Process each relocation in turn; first swap it from the
3979 external to the internal form.
3980
3981 o Turn the symbol referenced in the relocation's symbol index
3982 into a pointer into the canonical symbol table.
3983 This table is the same as the one returned by a call to
3984 @code{bfd_canonicalize_symtab}. The back end will call that
3985 routine and save the result if a canonicalization hasn't been done.
3986
3987 o The reloc index is turned into a pointer to a howto
3988 structure, in a back end specific way. For instance, the 386
3989 and 960 use the @code{r_type} to directly produce an index
3990 into a howto table vector; the 88k subtracts a number from the
3991 @code{r_type} field and creates an addend field.
3992
3993
3994*/
3995
3996#ifndef CALC_ADDEND
3997#define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
3998 { \
3999 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \
4000 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
4001 coffsym = (obj_symbols (abfd) \
4002 + (cache_ptr->sym_ptr_ptr - symbols)); \
4003 else if (ptr) \
4004 coffsym = coff_symbol_from (abfd, ptr); \
4005 if (coffsym != (coff_symbol_type *) NULL \
4006 && coffsym->native->u.syment.n_scnum == 0) \
4007 cache_ptr->addend = 0; \
4008 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
4009 && ptr->section != (asection *) NULL) \
4010 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
4011 else \
4012 cache_ptr->addend = 0; \
4013 }
4014#endif
4015
4016static boolean
4017coff_slurp_reloc_table (abfd, asect, symbols)
4018 bfd * abfd;
4019 sec_ptr asect;
4020 asymbol ** symbols;
4021{
4022 RELOC *native_relocs;
4023 arelent *reloc_cache;
4024 arelent *cache_ptr;
4025
4026 unsigned int idx;
4027
4028 if (asect->relocation)
4029 return true;
4030 if (asect->reloc_count == 0)
4031 return true;
4032 if (asect->flags & SEC_CONSTRUCTOR)
4033 return true;
4034 if (!coff_slurp_symbol_table (abfd))
4035 return false;
4036 native_relocs =
4037 (RELOC *) buy_and_read (abfd,
4038 asect->rel_filepos,
4039 SEEK_SET,
4040 (size_t) (RELSZ *
4041 asect->reloc_count));
4042 reloc_cache = (arelent *)
4043 bfd_alloc (abfd, (size_t) (asect->reloc_count * sizeof (arelent)));
4044
4045 if (reloc_cache == NULL)
4046 return false;
4047
4048
4049 for (idx = 0; idx < asect->reloc_count; idx++)
4050 {
4051 struct internal_reloc dst;
4052 struct external_reloc *src;
4053#ifndef RELOC_PROCESSING
4054 asymbol *ptr;
4055#endif
4056
4057 cache_ptr = reloc_cache + idx;
4058 src = native_relocs + idx;
4059
4060 coff_swap_reloc_in (abfd, src, &dst);
4061
4062#ifdef RELOC_PROCESSING
4063 RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
4064#else
4065 cache_ptr->address = dst.r_vaddr;
4066
4067 if (dst.r_symndx != -1)
4068 {
4069 if (dst.r_symndx < 0 || dst.r_symndx >= obj_conv_table_size (abfd))
4070 {
4071 (*_bfd_error_handler)
4072 (_("%s: warning: illegal symbol index %ld in relocs"),
4073 bfd_get_filename (abfd), dst.r_symndx);
4074 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
4075 ptr = NULL;
4076 }
4077 else
4078 {
4079 cache_ptr->sym_ptr_ptr = (symbols
4080 + obj_convert (abfd)[dst.r_symndx]);
4081 ptr = *(cache_ptr->sym_ptr_ptr);
4082 }
4083 }
4084 else
4085 {
4086 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
4087 ptr = NULL;
4088 }
4089
4090 /* The symbols definitions that we have read in have been
4091 relocated as if their sections started at 0. But the offsets
4092 refering to the symbols in the raw data have not been
4093 modified, so we have to have a negative addend to compensate.
4094
4095 Note that symbols which used to be common must be left alone */
4096
4097 /* Calculate any reloc addend by looking at the symbol */
4098 CALC_ADDEND (abfd, ptr, dst, cache_ptr);
4099
4100 cache_ptr->address -= asect->vma;
4101/* !! cache_ptr->section = (asection *) NULL;*/
4102
4103 /* Fill in the cache_ptr->howto field from dst.r_type */
4104 RTYPE2HOWTO (cache_ptr, &dst);
4105#endif /* RELOC_PROCESSING */
4106
4107 if (cache_ptr->howto == NULL)
4108 {
4109 (*_bfd_error_handler)
4110 (_("%s: illegal relocation type %d at address 0x%lx"),
4111 bfd_get_filename (abfd), dst.r_type, (long) dst.r_vaddr);
4112 bfd_set_error (bfd_error_bad_value);
4113 return false;
4114 }
4115 }
4116
4117 asect->relocation = reloc_cache;
4118 return true;
4119}
4120
4121#ifndef coff_rtype_to_howto
4122#ifdef RTYPE2HOWTO
4123
4124/* Get the howto structure for a reloc. This is only used if the file
4125 including this one defines coff_relocate_section to be
4126 _bfd_coff_generic_relocate_section, so it is OK if it does not
4127 always work. It is the responsibility of the including file to
4128 make sure it is reasonable if it is needed. */
4129
4130static reloc_howto_type *coff_rtype_to_howto
4131 PARAMS ((bfd *, asection *, struct internal_reloc *,
4132 struct coff_link_hash_entry *, struct internal_syment *,
4133 bfd_vma *));
4134
4135/*ARGSUSED*/
4136static reloc_howto_type *
4137coff_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
5f771d47
ILT		 4138 bfd *abfd ATTRIBUTE_UNUSED;
4139 asection *sec ATTRIBUTE_UNUSED;
252b5132 4140 struct internal_reloc *rel;
5f771d47
ILT		 4141 struct coff_link_hash_entry *h ATTRIBUTE_UNUSED;
4142 struct internal_syment *sym ATTRIBUTE_UNUSED;
4143 bfd_vma *addendp ATTRIBUTE_UNUSED;
252b5132
RH		 4144{
4145 arelent genrel;
4146
4147 RTYPE2HOWTO (&genrel, rel);
4148 return genrel.howto;
4149}
4150
4151#else /* ! defined (RTYPE2HOWTO) */
4152
4153#define coff_rtype_to_howto NULL
4154
4155#endif /* ! defined (RTYPE2HOWTO) */
4156#endif /* ! defined (coff_rtype_to_howto) */
4157
4158/* This is stupid. This function should be a boolean predicate. */
4159static long
4160coff_canonicalize_reloc (abfd, section, relptr, symbols)
4161 bfd * abfd;
4162 sec_ptr section;
4163 arelent ** relptr;
4164 asymbol ** symbols;
4165{
4166 arelent *tblptr = section->relocation;
4167 unsigned int count = 0;
4168
4169
4170 if (section->flags & SEC_CONSTRUCTOR)
4171 {
4172 /* this section has relocs made up by us, they are not in the
4173 file, so take them out of their chain and place them into
4174 the data area provided */
4175 arelent_chain *chain = section->constructor_chain;
4176 for (count = 0; count < section->reloc_count; count++)
4177 {
4178 *relptr++ = &chain->relent;
4179 chain = chain->next;
4180 }
4181
4182 }
4183 else
4184 {
4185 if (! coff_slurp_reloc_table (abfd, section, symbols))
4186 return -1;
4187
4188 tblptr = section->relocation;
4189
4190 for (; count++ < section->reloc_count;)
4191 *relptr++ = tblptr++;
4192
4193
4194 }
4195 *relptr = 0;
4196 return section->reloc_count;
4197}
4198
4199#ifdef GNU960
4200file_ptr
4201coff_sym_filepos (abfd)
4202 bfd *abfd;
4203{
4204 return obj_sym_filepos (abfd);
4205}
4206#endif
4207
4208#ifndef coff_reloc16_estimate
4209#define coff_reloc16_estimate dummy_reloc16_estimate
4210
4211static int dummy_reloc16_estimate
4212 PARAMS ((bfd *, asection *, arelent *, unsigned int,
4213 struct bfd_link_info *));
4214
4215static int
4216dummy_reloc16_estimate (abfd, input_section, reloc, shrink, link_info)
5f771d47
ILT		 4217 bfd *abfd ATTRIBUTE_UNUSED;
4218 asection *input_section ATTRIBUTE_UNUSED;
4219 arelent *reloc ATTRIBUTE_UNUSED;
4220 unsigned int shrink ATTRIBUTE_UNUSED;
4221 struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
252b5132
RH		 4222{
4223 abort ();
4224}
4225
4226#endif
4227
4228#ifndef coff_reloc16_extra_cases
4229
4230#define coff_reloc16_extra_cases dummy_reloc16_extra_cases
4231
4232/* This works even if abort is not declared in any header file. */
4233
4234static void dummy_reloc16_extra_cases
4235 PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
4236 bfd_byte *, unsigned int *, unsigned int *));
4237
4238static void
4239dummy_reloc16_extra_cases (abfd, link_info, link_order, reloc, data, src_ptr,
4240 dst_ptr)
5f771d47
ILT		 4241 bfd *abfd ATTRIBUTE_UNUSED;
4242 struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
4243 struct bfd_link_order *link_order ATTRIBUTE_UNUSED;
4244 arelent *reloc ATTRIBUTE_UNUSED;
4245 bfd_byte *data ATTRIBUTE_UNUSED;
4246 unsigned int *src_ptr ATTRIBUTE_UNUSED;
4247 unsigned int *dst_ptr ATTRIBUTE_UNUSED;
252b5132
RH		 4248{
4249 abort ();
4250}
4251#endif
4252
4253/* If coff_relocate_section is defined, we can use the optimized COFF
4254 backend linker. Otherwise we must continue to use the old linker. */
4255#ifdef coff_relocate_section
4256#ifndef coff_bfd_link_hash_table_create
4257#define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
4258#endif
4259#ifndef coff_bfd_link_add_symbols
4260#define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
4261#endif
4262#ifndef coff_bfd_final_link
4263#define coff_bfd_final_link _bfd_coff_final_link
4264#endif
4265#else /* ! defined (coff_relocate_section) */
4266#define coff_relocate_section NULL
4267#ifndef coff_bfd_link_hash_table_create
4268#define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
4269#endif
4270#ifndef coff_bfd_link_add_symbols
4271#define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
4272#endif
4273#define coff_bfd_final_link _bfd_generic_final_link
4274#endif /* ! defined (coff_relocate_section) */
4275
4276#define coff_bfd_link_split_section _bfd_generic_link_split_section
4277
4278#ifndef coff_start_final_link
4279#define coff_start_final_link NULL
4280#endif
4281
4282#ifndef coff_adjust_symndx
4283#define coff_adjust_symndx NULL
4284#endif
4285
4286#ifndef coff_link_add_one_symbol
4287#define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
4288#endif
4289
4290#ifndef coff_link_output_has_begun
4291
4292static boolean coff_link_output_has_begun
4293 PARAMS ((bfd *, struct coff_final_link_info *));
4294
4295static boolean
4296coff_link_output_has_begun (abfd, info)
4297 bfd * abfd;
5f771d47 4298 struct coff_final_link_info * info ATTRIBUTE_UNUSED;
252b5132
RH		 4299{
4300 return abfd->output_has_begun;
4301}
4302#endif
4303
4304#ifndef coff_final_link_postscript
4305
4306static boolean coff_final_link_postscript
4307 PARAMS ((bfd *, struct coff_final_link_info *));
4308
4309static boolean
4310coff_final_link_postscript (abfd, pfinfo)
5f771d47
ILT		 4311 bfd * abfd ATTRIBUTE_UNUSED;
4312 struct coff_final_link_info * pfinfo ATTRIBUTE_UNUSED;
252b5132
RH		 4313{
4314 return true;
4315}
4316#endif
4317
4318#ifndef coff_SWAP_aux_in
4319#define coff_SWAP_aux_in coff_swap_aux_in
4320#endif
4321#ifndef coff_SWAP_sym_in
4322#define coff_SWAP_sym_in coff_swap_sym_in
4323#endif
4324#ifndef coff_SWAP_lineno_in
4325#define coff_SWAP_lineno_in coff_swap_lineno_in
4326#endif
4327#ifndef coff_SWAP_aux_out
4328#define coff_SWAP_aux_out coff_swap_aux_out
4329#endif
4330#ifndef coff_SWAP_sym_out
4331#define coff_SWAP_sym_out coff_swap_sym_out
4332#endif
4333#ifndef coff_SWAP_lineno_out
4334#define coff_SWAP_lineno_out coff_swap_lineno_out
4335#endif
4336#ifndef coff_SWAP_reloc_out
4337#define coff_SWAP_reloc_out coff_swap_reloc_out
4338#endif
4339#ifndef coff_SWAP_filehdr_out
4340#define coff_SWAP_filehdr_out coff_swap_filehdr_out
4341#endif
4342#ifndef coff_SWAP_aouthdr_out
4343#define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
4344#endif
4345#ifndef coff_SWAP_scnhdr_out
4346#define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
4347#endif
4348#ifndef coff_SWAP_reloc_in
4349#define coff_SWAP_reloc_in coff_swap_reloc_in
4350#endif
4351#ifndef coff_SWAP_filehdr_in
4352#define coff_SWAP_filehdr_in coff_swap_filehdr_in
4353#endif
4354#ifndef coff_SWAP_aouthdr_in
4355#define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
4356#endif
4357#ifndef coff_SWAP_scnhdr_in
4358#define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
4359#endif
4360
4361
4362
4363static CONST bfd_coff_backend_data bfd_coff_std_swap_table =
4364{
4365 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
4366 coff_SWAP_aux_out, coff_SWAP_sym_out,
4367 coff_SWAP_lineno_out, coff_SWAP_reloc_out,
4368 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
4369 coff_SWAP_scnhdr_out,
4370 FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ,
4371#ifdef COFF_LONG_FILENAMES
4372 true,
4373#else
4374 false,
4375#endif
4376#ifdef COFF_LONG_SECTION_NAMES
4377 true,
4378#else
4379 false,
4380#endif
4381 COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
4382 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
4383 coff_SWAP_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook,
4384 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
4385 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
4386 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5d54c628 4387 coff_classify_symbol, coff_compute_section_file_positions,
252b5132
RH		 4388 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
4389 coff_adjust_symndx, coff_link_add_one_symbol,
4390 coff_link_output_has_begun, coff_final_link_postscript
4391};
4392
4393#ifndef coff_close_and_cleanup
4394#define coff_close_and_cleanup _bfd_generic_close_and_cleanup
4395#endif
4396
4397#ifndef coff_bfd_free_cached_info
4398#define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
4399#endif
4400
4401#ifndef coff_get_section_contents
4402#define coff_get_section_contents _bfd_generic_get_section_contents
4403#endif
4404
4405#ifndef coff_bfd_copy_private_symbol_data
4406#define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
4407#endif
4408
4409#ifndef coff_bfd_copy_private_section_data
4410#define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
4411#endif
4412
4413#ifndef coff_bfd_copy_private_bfd_data
4414#define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
4415#endif
4416
4417#ifndef coff_bfd_merge_private_bfd_data
4418#define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
4419#endif
4420
4421#ifndef coff_bfd_set_private_flags
4422#define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
4423#endif
4424
4425#ifndef coff_bfd_print_private_bfd_data
4426#define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
4427#endif
4428
4429#ifndef coff_bfd_is_local_label_name
4430#define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
4431#endif
4432
4433#ifndef coff_read_minisymbols
4434#define coff_read_minisymbols _bfd_generic_read_minisymbols
4435#endif
4436
4437#ifndef coff_minisymbol_to_symbol
4438#define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
4439#endif
4440
4441/* The reloc lookup routine must be supplied by each individual COFF
4442 backend. */
4443#ifndef coff_bfd_reloc_type_lookup
4444#define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
4445#endif
4446
4447#ifndef coff_bfd_get_relocated_section_contents
4448#define coff_bfd_get_relocated_section_contents \
4449 bfd_generic_get_relocated_section_contents
4450#endif
4451
4452#ifndef coff_bfd_relax_section
4453#define coff_bfd_relax_section bfd_generic_relax_section
4454#endif
4455
4456#ifndef coff_bfd_gc_sections
4457#define coff_bfd_gc_sections bfd_generic_gc_sections
4458#endif
c3c89269
NC		 4459
4460#define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
4461const bfd_target VAR = \
4462{ \
4463 NAME , \
4464 bfd_target_coff_flavour, \
4465 BFD_ENDIAN_BIG, /* data byte order is big */ \
4466 BFD_ENDIAN_BIG, /* header byte order is big */ \
4467 /* object flags */ \
4468 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
4469 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
4470 /* section flags */ \
4471 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS), \
4472 UNDER, /* leading symbol underscore */ \
4473 '/', /* ar_pad_char */ \
4474 15, /* ar_max_namelen */ \
4475 \
4476 /* Data conversion functions. */ \
4477 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
4478 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
4479 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
4480 \
4481 /* Header conversion functions. */ \
4482 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
4483 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
4484 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
4485 \
4486 /* bfd_check_format */ \
4487 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, _bfd_dummy_target }, \
4488 /* bfd_set_format */ \
4489 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
4490 /* bfd_write_contents */ \
4491 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, bfd_false }, \
4492 \
4493 BFD_JUMP_TABLE_GENERIC (coff), \
4494 BFD_JUMP_TABLE_COPY (coff), \
4495 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
4496 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
4497 BFD_JUMP_TABLE_SYMBOLS (coff), \
4498 BFD_JUMP_TABLE_RELOCS (coff), \
4499 BFD_JUMP_TABLE_WRITE (coff), \
4500 BFD_JUMP_TABLE_LINK (coff), \
4501 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
4502 \
4503 ALTERNATIVE, \
4504 \
4505 COFF_SWAP_TABLE \
4506};
4507
4508#define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
4509const bfd_target VAR = \
4510{ \
4511 NAME , \
4512 bfd_target_coff_flavour, \
4513 BFD_ENDIAN_LITTLE, /* data byte order is little */ \
4514 BFD_ENDIAN_LITTLE, /* header byte order is little */ \
4515 /* object flags */ \
4516 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
4517 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
4518 /* section flags */ \
4519 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS), \
4520 UNDER, /* leading symbol underscore */ \
4521 '/', /* ar_pad_char */ \
4522 15, /* ar_max_namelen */ \
4523 \
4524 /* Data conversion functions. */ \
4525 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
4526 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
4527 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
4528 /* Header conversion functions. */ \
4529 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
4530 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
4531 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
4532 /* bfd_check_format */ \
4533 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, _bfd_dummy_target }, \
4534 /* bfd_set_format */ \
4535 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
4536 /* bfd_write_contents */ \
4537 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, bfd_false }, \
4538 \
4539 BFD_JUMP_TABLE_GENERIC (coff), \
4540 BFD_JUMP_TABLE_COPY (coff), \
4541 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
4542 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
4543 BFD_JUMP_TABLE_SYMBOLS (coff), \
4544 BFD_JUMP_TABLE_RELOCS (coff), \
4545 BFD_JUMP_TABLE_WRITE (coff), \
4546 BFD_JUMP_TABLE_LINK (coff), \
4547 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
4548 \
4549 ALTERNATIVE, \
4550 \
4551 COFF_SWAP_TABLE \
4552};
GDB Binutils - Deliverables
This page took 0.224517 seconds and 4 git commands to generate.