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