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