projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Renumber cpu flag bits to avoid collision with PE 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 {
1422 case F_ARM_2: machine = bfd_mach_arm_2; break;
1423 case F_ARM_3: machine = bfd_mach_arm_3; break;
1424 default:
1425 case F_ARM_4: machine = bfd_mach_arm_4; break;
1426 case F_ARM_4T: machine = bfd_mach_arm_4T; break;
1427 }
1428 break;
1429#endif
1430#ifdef MC68MAGIC
1431 case MC68MAGIC:
1432 case M68MAGIC:
1433#ifdef MC68KBCSMAGIC
1434 case MC68KBCSMAGIC:
1435#endif
1436#ifdef APOLLOM68KMAGIC
1437 case APOLLOM68KMAGIC:
1438#endif
1439#ifdef LYNXCOFFMAGIC
1440 case LYNXCOFFMAGIC:
1441#endif
1442 arch = bfd_arch_m68k;
1443 machine = bfd_mach_m68020;
1444 break;
1445#endif
1446#ifdef MC88MAGIC
1447 case MC88MAGIC:
1448 case MC88DMAGIC:
1449 case MC88OMAGIC:
1450 arch = bfd_arch_m88k;
1451 machine = 88100;
1452 break;
1453#endif
1454#ifdef Z8KMAGIC
1455 case Z8KMAGIC:
1456 arch = bfd_arch_z8k;
1457 switch (internal_f->f_flags & F_MACHMASK)
1458 {
1459 case F_Z8001:
1460 machine = bfd_mach_z8001;
1461 break;
1462 case F_Z8002:
1463 machine = bfd_mach_z8002;
1464 break;
1465 default:
1466 return false;
1467 }
1468 break;
1469#endif
1470#ifdef I860
1471 case I860MAGIC:
1472 arch = bfd_arch_i860;
1473 break;
1474#endif
1475#ifdef I960
1476#ifdef I960ROMAGIC
1477 case I960ROMAGIC:
1478 case I960RWMAGIC:
1479 arch = bfd_arch_i960;
1480 switch (F_I960TYPE & internal_f->f_flags)
1481 {
1482 default:
1483 case F_I960CORE:
1484 machine = bfd_mach_i960_core;
1485 break;
1486 case F_I960KB:
1487 machine = bfd_mach_i960_kb_sb;
1488 break;
1489 case F_I960MC:
1490 machine = bfd_mach_i960_mc;
1491 break;
1492 case F_I960XA:
1493 machine = bfd_mach_i960_xa;
1494 break;
1495 case F_I960CA:
1496 machine = bfd_mach_i960_ca;
1497 break;
1498 case F_I960KA:
1499 machine = bfd_mach_i960_ka_sa;
1500 break;
1501 case F_I960JX:
1502 machine = bfd_mach_i960_jx;
1503 break;
1504 case F_I960HX:
1505 machine = bfd_mach_i960_hx;
1506 break;
1507 }
1508 break;
1509#endif
1510#endif
1511
1512#ifdef RS6000COFF_C
1513 case U802ROMAGIC:
1514 case U802WRMAGIC:
1515 case U802TOCMAGIC:
1516 {
1517 int cputype;
1518
1519 if (xcoff_data (abfd)->cputype != -1)
1520 cputype = xcoff_data (abfd)->cputype & 0xff;
1521 else
1522 {
1523 /* We did not get a value from the a.out header. If the
1524 file has not been stripped, we may be able to get the
1525 architecture information from the first symbol, if it
1526 is a .file symbol. */
1527 if (obj_raw_syment_count (abfd) == 0)
1528 cputype = 0;
1529 else
1530 {
1531 bfd_byte buf[SYMESZ];
1532 struct internal_syment sym;
1533
1534 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
1535 || bfd_read (buf, 1, SYMESZ, abfd) != SYMESZ)
1536 return false;
1537 coff_swap_sym_in (abfd, (PTR) buf, (PTR) &sym);
1538 if (sym.n_sclass == C_FILE)
1539 cputype = sym.n_type & 0xff;
1540 else
1541 cputype = 0;
1542 }
1543 }
1544
1545 /* FIXME: We don't handle all cases here. */
1546 switch (cputype)
1547 {
1548 default:
1549 case 0:
1550#ifdef POWERMAC
1551 /* PowerPC Macs use the same magic numbers as RS/6000
1552 (because that's how they were bootstrapped originally),
1553 but they are always PowerPC architecture. */
1554 arch = bfd_arch_powerpc;
1555 machine = 0;
1556#else
1557 arch = bfd_arch_rs6000;
1558 machine = 6000;
1559#endif /* POWERMAC */
1560 break;
1561
1562 case 1:
1563 arch = bfd_arch_powerpc;
1564 machine = 601;
1565 break;
1566 case 2: /* 64 bit PowerPC */
1567 arch = bfd_arch_powerpc;
1568 machine = 620;
1569 break;
1570 case 3:
1571 arch = bfd_arch_powerpc;
1572 machine = 0;
1573 break;
1574 case 4:
1575 arch = bfd_arch_rs6000;
1576 machine = 6000;
1577 break;
1578 }
1579 }
1580 break;
1581#endif
1582
1583#ifdef WE32KMAGIC
1584 case WE32KMAGIC:
1585 arch = bfd_arch_we32k;
1586 machine = 0;
1587 break;
1588#endif
1589
1590#ifdef H8300MAGIC
1591 case H8300MAGIC:
1592 arch = bfd_arch_h8300;
1593 machine = bfd_mach_h8300;
1594 /* !! FIXME this probably isn't the right place for this */
1595 abfd->flags |= BFD_IS_RELAXABLE;
1596 break;
1597#endif
1598
1599#ifdef H8300HMAGIC
1600 case H8300HMAGIC:
1601 arch = bfd_arch_h8300;
1602 machine = bfd_mach_h8300h;
1603 /* !! FIXME this probably isn't the right place for this */
1604 abfd->flags |= BFD_IS_RELAXABLE;
1605 break;
1606#endif
1607
1608#ifdef H8300SMAGIC
1609 case H8300SMAGIC:
1610 arch = bfd_arch_h8300;
1611 machine = bfd_mach_h8300s;
1612 /* !! FIXME this probably isn't the right place for this */
1613 abfd->flags |= BFD_IS_RELAXABLE;
1614 break;
1615#endif
1616
1617#ifdef SH_ARCH_MAGIC_BIG
1618 case SH_ARCH_MAGIC_BIG:
1619 case SH_ARCH_MAGIC_LITTLE:
1620 arch = bfd_arch_sh;
1621 machine = 0;
1622 break;
1623#endif
1624
1625#ifdef H8500MAGIC
1626 case H8500MAGIC:
1627 arch = bfd_arch_h8500;
1628 machine = 0;
1629 break;
1630#endif
1631
1632#ifdef SPARCMAGIC
1633 case SPARCMAGIC:
1634#ifdef LYNXCOFFMAGIC
1635 case LYNXCOFFMAGIC:
1636#endif
1637 arch = bfd_arch_sparc;
1638 machine = 0;
1639 break;
1640#endif
1641
1642#ifdef TIC30MAGIC
1643 case TIC30MAGIC:
1644 arch = bfd_arch_tic30;
1645 break;
1646#endif
1647
1648#ifdef TIC80_ARCH_MAGIC
1649 case TIC80_ARCH_MAGIC:
1650 arch = bfd_arch_tic80;
1651 break;
1652#endif
1653
1654#ifdef MCOREMAGIC
1655 case MCOREMAGIC:
1656 arch = bfd_arch_mcore;
1657 break;
1658#endif
1659 default: /* Unreadable input file type */
1660 arch = bfd_arch_obscure;
1661 break;
1662 }
1663
1664 bfd_default_set_arch_mach (abfd, arch, machine);
1665 return true;
1666}
1667
1668#ifdef SYMNAME_IN_DEBUG
1669
1670static boolean symname_in_debug_hook
1671 PARAMS ((bfd *, struct internal_syment *));
1672
1673static boolean
1674symname_in_debug_hook (abfd, sym)
1675 bfd * abfd;
1676 struct internal_syment *sym;
1677{
1678 return SYMNAME_IN_DEBUG (sym) ? true : false;
1679}
1680
1681#else
1682
1683#define symname_in_debug_hook \
1684 (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
1685
1686#endif
1687
1688#ifdef RS6000COFF_C
1689
1690/* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */
1691
1692static boolean coff_pointerize_aux_hook
1693 PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
1694 unsigned int, combined_entry_type *));
1695
1696/*ARGSUSED*/
1697static boolean
1698coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux)
1699 bfd *abfd;
1700 combined_entry_type *table_base;
1701 combined_entry_type *symbol;
1702 unsigned int indaux;
1703 combined_entry_type *aux;
1704{
1705 int class = symbol->u.syment.n_sclass;
1706
1707 if ((class == C_EXT || class == C_HIDEXT)
1708 && indaux + 1 == symbol->u.syment.n_numaux)
1709 {
1710 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD)
1711 {
1712 aux->u.auxent.x_csect.x_scnlen.p =
1713 table_base + aux->u.auxent.x_csect.x_scnlen.l;
1714 aux->fix_scnlen = 1;
1715 }
1716
1717 /* Return true to indicate that the caller should not do any
1718 further work on this auxent. */
1719 return true;
1720 }
1721
1722 /* Return false to indicate that this auxent should be handled by
1723 the caller. */
1724 return false;
1725}
1726
1727#else
1728#ifdef I960
1729
1730/* We don't want to pointerize bal entries. */
1731
1732static boolean coff_pointerize_aux_hook
1733 PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
1734 unsigned int, combined_entry_type *));
1735
1736/*ARGSUSED*/
1737static boolean
1738coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux)
1739 bfd *abfd;
1740 combined_entry_type *table_base;
1741 combined_entry_type *symbol;
1742 unsigned int indaux;
1743 combined_entry_type *aux;
1744{
1745 /* Return true if we don't want to pointerize this aux entry, which
1746 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
1747 return (indaux == 1
1748 && (symbol->u.syment.n_sclass == C_LEAFPROC
1749 || symbol->u.syment.n_sclass == C_LEAFSTAT
1750 || symbol->u.syment.n_sclass == C_LEAFEXT));
1751}
1752
1753#else /* ! I960 */
1754
1755#define coff_pointerize_aux_hook 0
1756
1757#endif /* ! I960 */
1758#endif /* ! RS6000COFF_C */
1759
1760/* Print an aux entry. This returns true if it has printed it. */
1761
1762static boolean coff_print_aux
1763 PARAMS ((bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1764 combined_entry_type *, unsigned int));
1765
1766static boolean
1767coff_print_aux (abfd, file, table_base, symbol, aux, indaux)
1768 bfd *abfd;
1769 FILE *file;
1770 combined_entry_type *table_base;
1771 combined_entry_type *symbol;
1772 combined_entry_type *aux;
1773 unsigned int indaux;
1774{
1775#ifdef RS6000COFF_C
1776 if ((symbol->u.syment.n_sclass == C_EXT
1777 || symbol->u.syment.n_sclass == C_HIDEXT)
1778 && indaux + 1 == symbol->u.syment.n_numaux)
1779 {
1780 /* This is a csect entry. */
1781 fprintf (file, "AUX ");
1782 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) != XTY_LD)
1783 {
1784 BFD_ASSERT (! aux->fix_scnlen);
1785 fprintf (file, "val %5ld", aux->u.auxent.x_csect.x_scnlen.l);
1786 }
1787 else
1788 {
1789 fprintf (file, "indx ");
1790 if (! aux->fix_scnlen)
1791 fprintf (file, "%4ld", aux->u.auxent.x_csect.x_scnlen.l);
1792 else
1793 fprintf (file, "%4ld",
1794 (long) (aux->u.auxent.x_csect.x_scnlen.p - table_base));
1795 }
1796 fprintf (file,
1797 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
1798 aux->u.auxent.x_csect.x_parmhash,
1799 (unsigned int) aux->u.auxent.x_csect.x_snhash,
1800 SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp),
1801 SMTYP_ALIGN (aux->u.auxent.x_csect.x_smtyp),
1802 (unsigned int) aux->u.auxent.x_csect.x_smclas,
1803 aux->u.auxent.x_csect.x_stab,
1804 (unsigned int) aux->u.auxent.x_csect.x_snstab);
1805 return true;
1806 }
1807#endif
1808
1809 /* Return false to indicate that no special action was taken. */
1810 return false;
1811}
1812
1813/*
1814SUBSUBSECTION
1815 Writing relocations
1816
1817 To write relocations, the back end steps though the
1818 canonical relocation table and create an
1819 @code{internal_reloc}. The symbol index to use is removed from
1820 the @code{offset} field in the symbol table supplied. The
1821 address comes directly from the sum of the section base
1822 address and the relocation offset; the type is dug directly
1823 from the howto field. Then the @code{internal_reloc} is
1824 swapped into the shape of an @code{external_reloc} and written
1825 out to disk.
1826
1827*/
1828
1829#ifdef TARG_AUX
1830
1831static int compare_arelent_ptr PARAMS ((const PTR, const PTR));
1832
1833/* AUX's ld wants relocations to be sorted */
1834static int
1835compare_arelent_ptr (x, y)
1836 const PTR x;
1837 const PTR y;
1838{
1839 const arelent **a = (const arelent **) x;
1840 const arelent **b = (const arelent **) y;
1841 bfd_size_type aadr = (*a)->address;
1842 bfd_size_type badr = (*b)->address;
1843
1844 return (aadr < badr ? -1 : badr < aadr ? 1 : 0);
1845}
1846
1847#endif /* TARG_AUX */
1848
1849static boolean
1850coff_write_relocs (abfd, first_undef)
1851 bfd * abfd;
1852 int first_undef;
1853{
1854 asection *s;
1855
1856 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
1857 {
1858 unsigned int i;
1859 struct external_reloc dst;
1860 arelent **p;
1861
1862#ifndef TARG_AUX
1863 p = s->orelocation;
1864#else
1865 /* sort relocations before we write them out */
1866 p = (arelent **) bfd_malloc (s->reloc_count * sizeof (arelent *));
1867 if (p == NULL && s->reloc_count > 0)
1868 return false;
1869 memcpy (p, s->orelocation, s->reloc_count * sizeof (arelent *));
1870 qsort (p, s->reloc_count, sizeof (arelent *), compare_arelent_ptr);
1871#endif
1872
1873 if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0)
1874 return false;
1875 for (i = 0; i < s->reloc_count; i++)
1876 {
1877 struct internal_reloc n;
1878 arelent *q = p[i];
1879 memset ((PTR) & n, 0, sizeof (n));
1880
1881 /* Now we've renumbered the symbols we know where the
1882 undefined symbols live in the table. Check the reloc
1883 entries for symbols who's output bfd isn't the right one.
1884 This is because the symbol was undefined (which means
1885 that all the pointers are never made to point to the same
1886 place). This is a bad thing,'cause the symbols attached
1887 to the output bfd are indexed, so that the relocation
1888 entries know which symbol index they point to. So we
1889 have to look up the output symbol here. */
1890
1891 if (q->sym_ptr_ptr[0]->the_bfd != abfd)
1892 {
1893 int i;
1894 const char *sname = q->sym_ptr_ptr[0]->name;
1895 asymbol **outsyms = abfd->outsymbols;
1896 for (i = first_undef; outsyms[i]; i++)
1897 {
1898 const char *intable = outsyms[i]->name;
1899 if (strcmp (intable, sname) == 0) {
1900 /* got a hit, so repoint the reloc */
1901 q->sym_ptr_ptr = outsyms + i;
1902 break;
1903 }
1904 }
1905 }
1906
1907 n.r_vaddr = q->address + s->vma;
1908
1909#ifdef R_IHCONST
1910 /* The 29k const/consth reloc pair is a real kludge. The consth
1911 part doesn't have a symbol; it has an offset. So rebuilt
1912 that here. */
1913 if (q->howto->type == R_IHCONST)
1914 n.r_symndx = q->addend;
1915 else
1916#endif
1917 if (q->sym_ptr_ptr)
1918 {
1919 if (q->sym_ptr_ptr == bfd_abs_section_ptr->symbol_ptr_ptr)
1920 /* This is a relocation relative to the absolute symbol. */
1921 n.r_symndx = -1;
1922 else
1923 {
1924 n.r_symndx = get_index ((*(q->sym_ptr_ptr)));
1925 /* Take notice if the symbol reloc points to a symbol
1926 we don't have in our symbol table. What should we
1927 do for this?? */
1928 if (n.r_symndx > obj_conv_table_size (abfd))
1929 abort ();
1930 }
1931 }
1932
1933#ifdef SWAP_OUT_RELOC_OFFSET
1934 n.r_offset = q->addend;
1935#endif
1936
1937#ifdef SELECT_RELOC
1938 /* Work out reloc type from what is required */
1939 SELECT_RELOC (n, q->howto);
1940#else
1941 n.r_type = q->howto->type;
1942#endif
1943 coff_swap_reloc_out (abfd, &n, &dst);
1944 if (bfd_write ((PTR) & dst, 1, RELSZ, abfd) != RELSZ)
1945 return false;
1946 }
1947
1948#ifdef TARG_AUX
1949 if (p != NULL)
1950 free (p);
1951#endif
1952 }
1953
1954 return true;
1955}
1956
1957/* Set flags and magic number of a coff file from architecture and machine
1958 type. Result is true if we can represent the arch&type, false if not. */
1959
1960static boolean
1961coff_set_flags (abfd, magicp, flagsp)
1962 bfd * abfd;
1963 unsigned int *magicp;
1964 unsigned short *flagsp;
1965{
1966 switch (bfd_get_arch (abfd))
1967 {
1968#ifdef Z8KMAGIC
1969 case bfd_arch_z8k:
1970 *magicp = Z8KMAGIC;
1971 switch (bfd_get_mach (abfd))
1972 {
1973 case bfd_mach_z8001:
1974 *flagsp = F_Z8001;
1975 break;
1976 case bfd_mach_z8002:
1977 *flagsp = F_Z8002;
1978 break;
1979 default:
1980 return false;
1981 }
1982 return true;
1983#endif
1984#ifdef I960ROMAGIC
1985
1986 case bfd_arch_i960:
1987
1988 {
1989 unsigned flags;
1990 *magicp = I960ROMAGIC;
1991 /*
1992 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
1993 I960RWMAGIC); FIXME???
1994 */
1995 switch (bfd_get_mach (abfd))
1996 {
1997 case bfd_mach_i960_core:
1998 flags = F_I960CORE;
1999 break;
2000 case bfd_mach_i960_kb_sb:
2001 flags = F_I960KB;
2002 break;
2003 case bfd_mach_i960_mc:
2004 flags = F_I960MC;
2005 break;
2006 case bfd_mach_i960_xa:
2007 flags = F_I960XA;
2008 break;
2009 case bfd_mach_i960_ca:
2010 flags = F_I960CA;
2011 break;
2012 case bfd_mach_i960_ka_sa:
2013 flags = F_I960KA;
2014 break;
2015 case bfd_mach_i960_jx:
2016 flags = F_I960JX;
2017 break;
2018 case bfd_mach_i960_hx:
2019 flags = F_I960HX;
2020 break;
2021 default:
2022 return false;
2023 }
2024 *flagsp = flags;
2025 return true;
2026 }
2027 break;
2028#endif
2029
2030#ifdef TIC30MAGIC
2031 case bfd_arch_tic30:
2032 *magicp = TIC30MAGIC;
2033 return true;
2034#endif
2035#ifdef TIC80_ARCH_MAGIC
2036 case bfd_arch_tic80:
2037 *magicp = TIC80_ARCH_MAGIC;
2038 return true;
2039#endif
2040#ifdef ARMMAGIC
2041 case bfd_arch_arm:
2042 * magicp = ARMMAGIC;
2043 * flagsp = 0;
2044 if (APCS_SET (abfd))
2045 {
2046 if (APCS_26_FLAG (abfd))
2047 * flagsp |= F_APCS26;
2048
2049 if (APCS_FLOAT_FLAG (abfd))
2050 * flagsp |= F_APCS_FLOAT;
2051
2052 if (PIC_FLAG (abfd))
2053 * flagsp |= F_PIC_INT;
2054 }
2055 if (INTERWORK_SET (abfd) && INTERWORK_FLAG (abfd))
2056 * flagsp |= F_INTERWORK;
2057 switch (bfd_get_mach (abfd))
2058 {
2059 case bfd_mach_arm_2: * flagsp |= F_ARM_2; break;
2060 case bfd_mach_arm_2a: * flagsp |= F_ARM_2a; break;
2061 case bfd_mach_arm_3: * flagsp |= F_ARM_3; break;
2062 case bfd_mach_arm_3M: * flagsp |= F_ARM_3M; break;
2063 case bfd_mach_arm_4: * flagsp |= F_ARM_4; break;
2064 case bfd_mach_arm_4T: * flagsp |= F_ARM_4T; break;
2065 }
2066 return true;
2067#endif
2068#ifdef PPCMAGIC
2069 case bfd_arch_powerpc:
2070 *magicp = PPCMAGIC;
2071 return true;
2072 break;
2073#endif
2074#ifdef I386MAGIC
2075 case bfd_arch_i386:
2076 *magicp = I386MAGIC;
2077#ifdef LYNXOS
2078 /* Just overwrite the usual value if we're doing Lynx. */
2079 *magicp = LYNXCOFFMAGIC;
2080#endif
2081 return true;
2082 break;
2083#endif
2084#ifdef I860MAGIC
2085 case bfd_arch_i860:
2086 *magicp = I860MAGIC;
2087 return true;
2088 break;
2089#endif
2090#ifdef MC68MAGIC
2091 case bfd_arch_m68k:
2092#ifdef APOLLOM68KMAGIC
2093 *magicp = APOLLO_COFF_VERSION_NUMBER;
2094#else
2095 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2096#ifdef NAMES_HAVE_UNDERSCORE
2097 *magicp = MC68KBCSMAGIC;
2098#else
2099 *magicp = MC68MAGIC;
2100#endif
2101#endif
2102#ifdef LYNXOS
2103 /* Just overwrite the usual value if we're doing Lynx. */
2104 *magicp = LYNXCOFFMAGIC;
2105#endif
2106 return true;
2107 break;
2108#endif
2109
2110#ifdef MC88MAGIC
2111 case bfd_arch_m88k:
2112 *magicp = MC88OMAGIC;
2113 return true;
2114 break;
2115#endif
2116#ifdef H8300MAGIC
2117 case bfd_arch_h8300:
2118 switch (bfd_get_mach (abfd))
2119 {
2120 case bfd_mach_h8300:
2121 *magicp = H8300MAGIC;
2122 return true;
2123 case bfd_mach_h8300h:
2124 *magicp = H8300HMAGIC;
2125 return true;
2126 case bfd_mach_h8300s:
2127 *magicp = H8300SMAGIC;
2128 return true;
2129 }
2130 break;
2131#endif
2132
2133#ifdef SH_ARCH_MAGIC_BIG
2134 case bfd_arch_sh:
2135 if (bfd_big_endian (abfd))
2136 *magicp = SH_ARCH_MAGIC_BIG;
2137 else
2138 *magicp = SH_ARCH_MAGIC_LITTLE;
2139 return true;
2140 break;
2141#endif
2142
2143#ifdef SPARCMAGIC
2144 case bfd_arch_sparc:
2145 *magicp = SPARCMAGIC;
2146#ifdef LYNXOS
2147 /* Just overwrite the usual value if we're doing Lynx. */
2148 *magicp = LYNXCOFFMAGIC;
2149#endif
2150 return true;
2151 break;
2152#endif
2153
2154#ifdef H8500MAGIC
2155 case bfd_arch_h8500:
2156 *magicp = H8500MAGIC;
2157 return true;
2158 break;
2159#endif
2160#ifdef A29K_MAGIC_BIG
2161 case bfd_arch_a29k:
2162 if (bfd_big_endian (abfd))
2163 *magicp = A29K_MAGIC_BIG;
2164 else
2165 *magicp = A29K_MAGIC_LITTLE;
2166 return true;
2167 break;
2168#endif
2169
2170#ifdef WE32KMAGIC
2171 case bfd_arch_we32k:
2172 *magicp = WE32KMAGIC;
2173 return true;
2174 break;
2175#endif
2176
2177#ifdef U802TOCMAGIC
2178 case bfd_arch_rs6000:
2179#ifndef PPCMAGIC
2180 case bfd_arch_powerpc:
2181#endif
2182 *magicp = U802TOCMAGIC;
2183 return true;
2184 break;
2185#endif
2186
2187#ifdef MCOREMAGIC
2188 case bfd_arch_mcore:
2189 * magicp = MCOREMAGIC;
2190 return true;
2191#endif
2192
2193 default: /* Unknown architecture */
2194 /* return false; -- fall through to "return false" below, to avoid
2195 "statement never reached" errors on the one below. */
2196 break;
2197 }
2198
2199 return false;
2200}
2201
2202
2203static boolean
2204coff_set_arch_mach (abfd, arch, machine)
2205 bfd * abfd;
2206 enum bfd_architecture arch;
2207 unsigned long machine;
2208{
2209 unsigned dummy1;
2210 unsigned short dummy2;
2211
2212 if (! bfd_default_set_arch_mach (abfd, arch, machine))
2213 return false;
2214
2215 if (arch != bfd_arch_unknown &&
2216 coff_set_flags (abfd, &dummy1, &dummy2) != true)
2217 return false; /* We can't represent this type */
2218
2219 return true; /* We're easy ... */
2220}
2221
2222
2223/* Calculate the file position for each section. */
2224
2225#ifndef I960
2226#define ALIGN_SECTIONS_IN_FILE
2227#endif
2228#ifdef TIC80COFF
2229#undef ALIGN_SECTIONS_IN_FILE
2230#endif
2231
2232static boolean
2233coff_compute_section_file_positions (abfd)
2234 bfd * abfd;
2235{
2236 asection *current;
2237 asection *previous = (asection *) NULL;
2238 file_ptr sofar = FILHSZ;
2239 boolean align_adjust;
2240 unsigned int count;
2241#ifdef ALIGN_SECTIONS_IN_FILE
2242 file_ptr old_sofar;
2243#endif
2244
2245#ifdef RS6000COFF_C
2246 /* On XCOFF, if we have symbols, set up the .debug section. */
2247 if (bfd_get_symcount (abfd) > 0)
2248 {
2249 bfd_size_type sz;
2250 bfd_size_type i, symcount;
2251 asymbol **symp;
2252
2253 sz = 0;
2254 symcount = bfd_get_symcount (abfd);
2255 for (symp = abfd->outsymbols, i = 0; i < symcount; symp++, i++)
2256 {
2257 coff_symbol_type *cf;
2258
2259 cf = coff_symbol_from (abfd, *symp);
2260 if (cf != NULL
2261 && cf->native != NULL
2262 && SYMNAME_IN_DEBUG (&cf->native->u.syment))
2263 {
2264 size_t len;
2265
2266 len = strlen (bfd_asymbol_name (*symp));
2267 if (len > SYMNMLEN)
2268 sz += len + 3;
2269 }
2270 }
2271 if (sz > 0)
2272 {
2273 asection *dsec;
2274
2275 dsec = bfd_make_section_old_way (abfd, ".debug");
2276 if (dsec == NULL)
2277 abort ();
2278 dsec->_raw_size = sz;
2279 dsec->flags |= SEC_HAS_CONTENTS;
2280 }
2281 }
2282#endif
2283
2284#ifdef COFF_IMAGE_WITH_PE
2285 int page_size;
2286 if (coff_data (abfd)->link_info)
2287 {
2288 page_size = pe_data (abfd)->pe_opthdr.FileAlignment;
2289 }
2290 else
2291 page_size = PE_DEF_FILE_ALIGNMENT;
2292#else
2293#ifdef COFF_PAGE_SIZE
2294 int page_size = COFF_PAGE_SIZE;
2295#endif
2296#endif
2297
2298 if (bfd_get_start_address (abfd))
2299 {
2300 /* A start address may have been added to the original file. In this
2301 case it will need an optional header to record it. */
2302 abfd->flags |= EXEC_P;
2303 }
2304
2305 if (abfd->flags & EXEC_P)
2306 sofar += AOUTSZ;
2307#ifdef RS6000COFF_C
2308 else if (xcoff_data (abfd)->full_aouthdr)
2309 sofar += AOUTSZ;
2310 else
2311 sofar += SMALL_AOUTSZ;
2312#endif
2313
2314 sofar += abfd->section_count * SCNHSZ;
2315
2316#ifdef RS6000COFF_C
2317 /* XCOFF handles overflows in the reloc and line number count fields
2318 by allocating a new section header to hold the correct counts. */
2319 for (current = abfd->sections; current != NULL; current = current->next)
2320 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
2321 sofar += SCNHSZ;
2322#endif
2323
2324 align_adjust = false;
2325 for (current = abfd->sections, count = 1;
2326 current != (asection *) NULL;
2327 current = current->next, ++count)
2328 {
2329#ifdef COFF_IMAGE_WITH_PE
2330 /* The NT loader does not want empty section headers, so we omit
2331 them. We don't actually remove the section from the BFD,
2332 although we probably should. This matches code in
2333 coff_write_object_contents. */
2334 if (current->_raw_size == 0)
2335 {
2336 current->target_index = -1;
2337 --count;
2338 continue;
2339 }
2340#endif
2341
2342 current->target_index = count;
2343
2344 /* Only deal with sections which have contents */
2345 if (!(current->flags & SEC_HAS_CONTENTS))
2346 continue;
2347
2348 /* Align the sections in the file to the same boundary on
2349 which they are aligned in virtual memory. I960 doesn't
2350 do this (FIXME) so we can stay in sync with Intel. 960
2351 doesn't yet page from files... */
2352#ifdef ALIGN_SECTIONS_IN_FILE
2353 if ((abfd->flags & EXEC_P) != 0)
2354 {
2355 /* make sure this section is aligned on the right boundary - by
2356 padding the previous section up if necessary */
2357
2358 old_sofar = sofar;
2359 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
2360 if (previous != (asection *) NULL)
2361 {
2362 previous->_raw_size += sofar - old_sofar;
2363 }
2364 }
2365
2366#endif
2367
2368 /* In demand paged files the low order bits of the file offset
2369 must match the low order bits of the virtual address. */
2370#ifdef COFF_PAGE_SIZE
2371 if ((abfd->flags & D_PAGED) != 0
2372 && (current->flags & SEC_ALLOC) != 0)
2373 sofar += (current->vma - sofar) % page_size;
2374#endif
2375 current->filepos = sofar;
2376
2377#ifdef COFF_IMAGE_WITH_PE
2378 /* With PE we have to pad each section to be a multiple of its
2379 page size too, and remember both sizes. */
2380
2381 if (coff_section_data (abfd, current) == NULL)
2382 {
2383 current->used_by_bfd =
2384 (PTR) bfd_zalloc (abfd, sizeof (struct coff_section_tdata));
2385 if (current->used_by_bfd == NULL)
2386 return false;
2387 }
2388 if (pei_section_data (abfd, current) == NULL)
2389 {
2390 coff_section_data (abfd, current)->tdata =
2391 (PTR) bfd_zalloc (abfd, sizeof (struct pei_section_tdata));
2392 if (coff_section_data (abfd, current)->tdata == NULL)
2393 return false;
2394 }
2395 if (pei_section_data (abfd, current)->virt_size == 0)
2396 pei_section_data (abfd, current)->virt_size = current->_raw_size;
2397
2398 current->_raw_size = (current->_raw_size + page_size -1) & -page_size;
2399#endif
2400
2401 sofar += current->_raw_size;
2402
2403#ifdef ALIGN_SECTIONS_IN_FILE
2404 /* make sure that this section is of the right size too */
2405 if ((abfd->flags & EXEC_P) == 0)
2406 {
2407 bfd_size_type old_size;
2408
2409 old_size = current->_raw_size;
2410 current->_raw_size = BFD_ALIGN (current->_raw_size,
2411 1 << current->alignment_power);
2412 align_adjust = current->_raw_size != old_size;
2413 sofar += current->_raw_size - old_size;
2414 }
2415 else
2416 {
2417 old_sofar = sofar;
2418 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
2419 align_adjust = sofar != old_sofar;
2420 current->_raw_size += sofar - old_sofar;
2421 }
2422#endif
2423
2424#ifdef COFF_IMAGE_WITH_PE
2425 /* For PE we need to make sure we pad out to the aligned
2426 _raw_size, in case the caller only writes out data to the
2427 unaligned _raw_size. */
2428 if (pei_section_data (abfd, current)->virt_size < current->_raw_size)
2429 align_adjust = true;
2430#endif
2431
2432#ifdef _LIB
2433 /* Force .lib sections to start at zero. The vma is then
2434 incremented in coff_set_section_contents. This is right for
2435 SVR3.2. */
2436 if (strcmp (current->name, _LIB) == 0)
2437 bfd_set_section_vma (abfd, current, 0);
2438#endif
2439
2440 previous = current;
2441 }
2442
2443 /* It is now safe to write to the output file. If we needed an
2444 alignment adjustment for the last section, then make sure that
2445 there is a byte at offset sofar. If there are no symbols and no
2446 relocs, then nothing follows the last section. If we don't force
2447 the last byte out, then the file may appear to be truncated. */
2448 if (align_adjust)
2449 {
2450 bfd_byte b;
2451
2452 b = 0;
2453 if (bfd_seek (abfd, sofar - 1, SEEK_SET) != 0
2454 || bfd_write (&b, 1, 1, abfd) != 1)
2455 return false;
2456 }
2457
2458 /* Make sure the relocations are aligned. We don't need to make
2459 sure that this byte exists, because it will only matter if there
2460 really are relocs. */
2461 sofar = BFD_ALIGN (sofar, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER);
2462
2463 obj_relocbase (abfd) = sofar;
2464 abfd->output_has_begun = true;
2465
2466 return true;
2467}
2468
2469#if 0
2470
2471/* This can never work, because it is called too late--after the
2472 section positions have been set. I can't figure out what it is
2473 for, so I am going to disable it--Ian Taylor 20 March 1996. */
2474
2475/* If .file, .text, .data, .bss symbols are missing, add them. */
2476/* @@ Should we only be adding missing symbols, or overriding the aux
2477 values for existing section symbols? */
2478static boolean
2479coff_add_missing_symbols (abfd)
2480 bfd *abfd;
2481{
2482 unsigned int nsyms = bfd_get_symcount (abfd);
2483 asymbol **sympp = abfd->outsymbols;
2484 asymbol **sympp2;
2485 unsigned int i;
2486 int need_text = 1, need_data = 1, need_bss = 1, need_file = 1;
2487
2488 for (i = 0; i < nsyms; i++)
2489 {
2490 coff_symbol_type *csym = coff_symbol_from (abfd, sympp[i]);
2491 CONST char *name;
2492 if (csym)
2493 {
2494 /* only do this if there is a coff representation of the input
2495 symbol */
2496 if (csym->native && csym->native->u.syment.n_sclass == C_FILE)
2497 {
2498 need_file = 0;
2499 continue;
2500 }
2501 name = csym->symbol.name;
2502 if (!name)
2503 continue;
2504 if (!strcmp (name, _TEXT))
2505 need_text = 0;
2506#ifdef APOLLO_M68
2507 else if (!strcmp (name, ".wtext"))
2508 need_text = 0;
2509#endif
2510 else if (!strcmp (name, _DATA))
2511 need_data = 0;
2512 else if (!strcmp (name, _BSS))
2513 need_bss = 0;
2514 }
2515 }
2516 /* Now i == bfd_get_symcount (abfd). */
2517 /* @@ For now, don't deal with .file symbol. */
2518 need_file = 0;
2519
2520 if (!need_text && !need_data && !need_bss && !need_file)
2521 return true;
2522 nsyms += need_text + need_data + need_bss + need_file;
2523 sympp2 = (asymbol **) bfd_alloc (abfd, nsyms * sizeof (asymbol *));
2524 if (!sympp2)
2525 return false;
2526 memcpy (sympp2, sympp, i * sizeof (asymbol *));
2527 if (need_file)
2528 {
2529 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
2530 abort ();
2531 }
2532 if (need_text)
2533 sympp2[i++] = coff_section_symbol (abfd, _TEXT);
2534 if (need_data)
2535 sympp2[i++] = coff_section_symbol (abfd, _DATA);
2536 if (need_bss)
2537 sympp2[i++] = coff_section_symbol (abfd, _BSS);
2538 BFD_ASSERT (i == nsyms);
2539 bfd_set_symtab (abfd, sympp2, nsyms);
2540 return true;
2541}
2542
2543#endif /* 0 */
2544
2545/* SUPPRESS 558 */
2546/* SUPPRESS 529 */
2547static boolean
2548coff_write_object_contents (abfd)
2549 bfd * abfd;
2550{
2551 asection *current;
2552 boolean hasrelocs = false;
2553 boolean haslinno = false;
2554 file_ptr scn_base;
2555 file_ptr reloc_base;
2556 file_ptr lineno_base;
2557 file_ptr sym_base;
2558 unsigned long reloc_size = 0;
2559 unsigned long lnno_size = 0;
2560 boolean long_section_names;
2561 asection *text_sec = NULL;
2562 asection *data_sec = NULL;
2563 asection *bss_sec = NULL;
2564 struct internal_filehdr internal_f;
2565 struct internal_aouthdr internal_a;
2566#ifdef COFF_LONG_SECTION_NAMES
2567 size_t string_size = STRING_SIZE_SIZE;
2568#endif
2569
2570 bfd_set_error (bfd_error_system_call);
2571
2572 /* Make a pass through the symbol table to count line number entries and
2573 put them into the correct asections */
2574
2575 lnno_size = coff_count_linenumbers (abfd) * LINESZ;
2576
2577 if (abfd->output_has_begun == false)
2578 {
2579 if (! coff_compute_section_file_positions (abfd))
2580 return false;
2581 }
2582
2583 reloc_base = obj_relocbase (abfd);
2584
2585 /* Work out the size of the reloc and linno areas */
2586
2587 for (current = abfd->sections; current != NULL; current =
2588 current->next)
2589 reloc_size += current->reloc_count * RELSZ;
2590
2591 lineno_base = reloc_base + reloc_size;
2592 sym_base = lineno_base + lnno_size;
2593
2594 /* Indicate in each section->line_filepos its actual file address */
2595 for (current = abfd->sections; current != NULL; current =
2596 current->next)
2597 {
2598 if (current->lineno_count)
2599 {
2600 current->line_filepos = lineno_base;
2601 current->moving_line_filepos = lineno_base;
2602 lineno_base += current->lineno_count * LINESZ;
2603 }
2604 else
2605 {
2606 current->line_filepos = 0;
2607 }
2608 if (current->reloc_count)
2609 {
2610 current->rel_filepos = reloc_base;
2611 reloc_base += current->reloc_count * RELSZ;
2612 }
2613 else
2614 {
2615 current->rel_filepos = 0;
2616 }
2617 }
2618
2619 /* Write section headers to the file. */
2620 internal_f.f_nscns = 0;
2621
2622 if ((abfd->flags & EXEC_P) != 0)
2623 scn_base = FILHSZ + AOUTSZ;
2624 else
2625 {
2626 scn_base = FILHSZ;
2627#ifdef RS6000COFF_C
2628 if (xcoff_data (abfd)->full_aouthdr)
2629 scn_base += AOUTSZ;
2630 else
2631 scn_base += SMALL_AOUTSZ;
2632#endif
2633 }
2634
2635 if (bfd_seek (abfd, scn_base, SEEK_SET) != 0)
2636 return false;
2637
2638 long_section_names = false;
2639 for (current = abfd->sections;
2640 current != NULL;
2641 current = current->next)
2642 {
2643 struct internal_scnhdr section;
2644
2645#ifdef COFF_WITH_PE
2646 /* If we've got a .reloc section, remember. */
2647
2648#ifdef COFF_IMAGE_WITH_PE
2649 if (strcmp (current->name, ".reloc") == 0)
2650 {
2651 pe_data (abfd)->has_reloc_section = 1;
2652 }
2653#endif
2654
2655#endif
2656 internal_f.f_nscns++;
2657
2658 strncpy (section.s_name, current->name, SCNNMLEN);
2659
2660#ifdef COFF_LONG_SECTION_NAMES
2661 /* Handle long section names as in PE. This must be compatible
2662 with the code in coff_write_symbols. */
2663 {
2664 size_t len;
2665
2666 len = strlen (current->name);
2667 if (len > SCNNMLEN)
2668 {
2669 memset (section.s_name, 0, SCNNMLEN);
2670 sprintf (section.s_name, "/%lu", (unsigned long) string_size);
2671 string_size += len + 1;
2672 long_section_names = true;
2673 }
2674 }
2675#endif
2676
2677#ifdef _LIB
2678 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
2679 Ian Taylor <ian@cygnus.com>. */
2680 if (strcmp (current->name, _LIB) == 0)
2681 section.s_vaddr = 0;
2682 else
2683#endif
2684 section.s_vaddr = current->vma;
2685 section.s_paddr = current->lma;
2686 section.s_size = current->_raw_size;
2687
2688#ifdef COFF_WITH_PE
2689 section.s_paddr = 0;
2690#endif
2691#ifdef COFF_IMAGE_WITH_PE
2692 /* Reminder: s_paddr holds the virtual size of the section. */
2693 if (coff_section_data (abfd, current) != NULL
2694 && pei_section_data (abfd, current) != NULL)
2695 section.s_paddr = pei_section_data (abfd, current)->virt_size;
2696 else
2697 section.s_paddr = 0;
2698#endif
2699
2700 /*
2701 If this section has no size or is unloadable then the scnptr
2702 will be 0 too
2703 */
2704 if (current->_raw_size == 0 ||
2705 (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2706 {
2707 section.s_scnptr = 0;
2708 }
2709 else
2710 {
2711 section.s_scnptr = current->filepos;
2712 }
2713 section.s_relptr = current->rel_filepos;
2714 section.s_lnnoptr = current->line_filepos;
2715 section.s_nreloc = current->reloc_count;
2716 section.s_nlnno = current->lineno_count;
2717 if (current->reloc_count != 0)
2718 hasrelocs = true;
2719 if (current->lineno_count != 0)
2720 haslinno = true;
2721
2722#ifdef RS6000COFF_C
2723 /* Indicate the use of an XCOFF overflow section header. */
2724 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
2725 {
2726 section.s_nreloc = 0xffff;
2727 section.s_nlnno = 0xffff;
2728 }
2729#endif
2730
2731 section.s_flags = sec_to_styp_flags (current->name, current->flags);
2732
2733 if (!strcmp (current->name, _TEXT))
2734 {
2735 text_sec = current;
2736 }
2737 else if (!strcmp (current->name, _DATA))
2738 {
2739 data_sec = current;
2740 }
2741 else if (!strcmp (current->name, _BSS))
2742 {
2743 bss_sec = current;
2744 }
2745
2746#ifdef I960
2747 section.s_align = (current->alignment_power
2748 ? 1 << current->alignment_power
2749 : 0);
2750#else
2751#ifdef TIC80COFF
2752 section.s_flags |= (current->alignment_power & 0xF) << 8;
2753#endif
2754#endif
2755
2756#ifdef COFF_IMAGE_WITH_PE
2757 /* suppress output of the sections if they are null. ld includes
2758 the bss and data sections even if there is no size assigned
2759 to them. NT loader doesn't like it if these section headers are
2760 included if the sections themselves are not needed */
2761 if (section.s_size == 0)
2762 internal_f.f_nscns--;
2763 else
2764#endif
2765 {
2766 SCNHDR buff;
2767 if (coff_swap_scnhdr_out (abfd, &section, &buff) == 0
2768 || bfd_write ((PTR) (&buff), 1, SCNHSZ, abfd) != SCNHSZ)
2769 return false;
2770 }
2771
2772#ifdef COFF_WITH_PE
2773 /* PE stores COMDAT section information in the symbol table. If
2774 this section is supposed to have some COMDAT info, track down
2775 the symbol in the symbol table and modify it. */
2776 if ((current->flags & SEC_LINK_ONCE) != 0)
2777 {
2778 unsigned int i, count;
2779 asymbol **psym;
2780 coff_symbol_type *csym = NULL;
2781 asymbol **psymsec;
2782
2783 psymsec = NULL;
2784 count = bfd_get_symcount (abfd);
2785 for (i = 0, psym = abfd->outsymbols; i < count; i++, psym++)
2786 {
2787 if ((*psym)->section != current)
2788 continue;
2789
2790 /* Remember the location of the first symbol in this
2791 section. */
2792 if (psymsec == NULL)
2793 psymsec = psym;
2794
2795 /* See if this is the section symbol. */
2796 if (strcmp ((*psym)->name, current->name) == 0)
2797 {
2798 csym = coff_symbol_from (abfd, *psym);
2799 if (csym == NULL
2800 || csym->native == NULL
2801 || csym->native->u.syment.n_numaux < 1
2802 || csym->native->u.syment.n_sclass != C_STAT
2803 || csym->native->u.syment.n_type != T_NULL)
2804 continue;
2805
2806 /* Here *PSYM is the section symbol for CURRENT. */
2807
2808 break;
2809 }
2810 }
2811
2812 /* Did we find it?
2813 Note that we might not if we're converting the file from
2814 some other object file format. */
2815 if (i < count)
2816 {
2817 combined_entry_type *aux;
2818
2819 /* We don't touch the x_checksum field. The
2820 x_associated field is not currently supported. */
2821
2822 aux = csym->native + 1;
2823 switch (current->flags & SEC_LINK_DUPLICATES)
2824 {
2825 case SEC_LINK_DUPLICATES_DISCARD:
2826 aux->u.auxent.x_scn.x_comdat = IMAGE_COMDAT_SELECT_ANY;
2827 break;
2828
2829 case SEC_LINK_DUPLICATES_ONE_ONLY:
2830 aux->u.auxent.x_scn.x_comdat =
2831 IMAGE_COMDAT_SELECT_NODUPLICATES;
2832 break;
2833
2834 case SEC_LINK_DUPLICATES_SAME_SIZE:
2835 aux->u.auxent.x_scn.x_comdat =
2836 IMAGE_COMDAT_SELECT_SAME_SIZE;
2837 break;
2838
2839 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
2840 aux->u.auxent.x_scn.x_comdat =
2841 IMAGE_COMDAT_SELECT_EXACT_MATCH;
2842 break;
2843 }
2844
2845 /* The COMDAT symbol must be the first symbol from this
2846 section in the symbol table. In order to make this
2847 work, we move the COMDAT symbol before the first
2848 symbol we found in the search above. It's OK to
2849 rearrange the symbol table at this point, because
2850 coff_renumber_symbols is going to rearrange it
2851 further and fix up all the aux entries. */
2852 if (psym != psymsec)
2853 {
2854 asymbol *hold;
2855 asymbol **pcopy;
2856
2857 hold = *psym;
2858 for (pcopy = psym; pcopy > psymsec; pcopy--)
2859 pcopy[0] = pcopy[-1];
2860 *psymsec = hold;
2861 }
2862 }
2863 }
2864#endif /* COFF_WITH_PE */
2865 }
2866
2867#ifdef RS6000COFF_C
2868 /* XCOFF handles overflows in the reloc and line number count fields
2869 by creating a new section header to hold the correct values. */
2870 for (current = abfd->sections; current != NULL; current = current->next)
2871 {
2872 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
2873 {
2874 struct internal_scnhdr scnhdr;
2875 SCNHDR buff;
2876
2877 internal_f.f_nscns++;
2878 strncpy (&(scnhdr.s_name[0]), current->name, 8);
2879 scnhdr.s_paddr = current->reloc_count;
2880 scnhdr.s_vaddr = current->lineno_count;
2881 scnhdr.s_size = 0;
2882 scnhdr.s_scnptr = 0;
2883 scnhdr.s_relptr = current->rel_filepos;
2884 scnhdr.s_lnnoptr = current->line_filepos;
2885 scnhdr.s_nreloc = current->target_index;
2886 scnhdr.s_nlnno = current->target_index;
2887 scnhdr.s_flags = STYP_OVRFLO;
2888 if (coff_swap_scnhdr_out (abfd, &scnhdr, &buff) == 0
2889 || bfd_write ((PTR) &buff, 1, SCNHSZ, abfd) != SCNHSZ)
2890 return false;
2891 }
2892 }
2893#endif
2894
2895 /* OK, now set up the filehdr... */
2896
2897 /* Don't include the internal abs section in the section count */
2898
2899 /*
2900 We will NOT put a fucking timestamp in the header here. Every time you
2901 put it back, I will come in and take it out again. I'm sorry. This
2902 field does not belong here. We fill it with a 0 so it compares the
2903 same but is not a reasonable time. -- gnu@cygnus.com
2904 */
2905 internal_f.f_timdat = 0;
2906
2907 internal_f.f_flags = 0;
2908
2909 if (abfd->flags & EXEC_P)
2910 internal_f.f_opthdr = AOUTSZ;
2911 else
2912 {
2913 internal_f.f_opthdr = 0;
2914#ifdef RS6000COFF_C
2915 if (xcoff_data (abfd)->full_aouthdr)
2916 internal_f.f_opthdr = AOUTSZ;
2917 else
2918 internal_f.f_opthdr = SMALL_AOUTSZ;
2919#endif
2920 }
2921
2922 if (!hasrelocs)
2923 internal_f.f_flags |= F_RELFLG;
2924 if (!haslinno)
2925 internal_f.f_flags |= F_LNNO;
2926 if (abfd->flags & EXEC_P)
2927 internal_f.f_flags |= F_EXEC;
2928
2929 /* FIXME: this is wrong for PPC_PE! */
2930 if (bfd_little_endian (abfd))
2931 internal_f.f_flags |= F_AR32WR;
2932 else
2933 internal_f.f_flags |= F_AR32W;
2934
2935#ifdef TIC80_TARGET_ID
2936 internal_f.f_target_id = TIC80_TARGET_ID;
2937#endif
2938
2939 /*
2940 FIXME, should do something about the other byte orders and
2941 architectures.
2942 */
2943
2944#ifdef RS6000COFF_C
2945 if ((abfd->flags & DYNAMIC) != 0)
2946 internal_f.f_flags |= F_SHROBJ;
2947 if (bfd_get_section_by_name (abfd, _LOADER) != NULL)
2948 internal_f.f_flags |= F_DYNLOAD;
2949#endif
2950
2951 memset (&internal_a, 0, sizeof internal_a);
2952
2953 /* Set up architecture-dependent stuff */
2954
2955 {
2956 unsigned int magic = 0;
2957 unsigned short flags = 0;
2958 coff_set_flags (abfd, &magic, &flags);
2959 internal_f.f_magic = magic;
2960 internal_f.f_flags |= flags;
2961 /* ...and the "opt"hdr... */
2962
2963#ifdef A29K
2964#ifdef ULTRA3 /* NYU's machine */
2965 /* FIXME: This is a bogus check. I really want to see if there
2966 * is a .shbss or a .shdata section, if so then set the magic
2967 * number to indicate a shared data executable.
2968 */
2969 if (internal_f.f_nscns >= 7)
2970 internal_a.magic = SHMAGIC; /* Shared magic */
2971 else
2972#endif /* ULTRA3 */
2973 internal_a.magic = NMAGIC; /* Assume separate i/d */
2974#define __A_MAGIC_SET__
2975#endif /* A29K */
2976#ifdef TIC80COFF
2977 internal_a.magic = TIC80_ARCH_MAGIC;
2978#define __A_MAGIC_SET__
2979#endif /* TIC80 */
2980#ifdef I860
2981 /* FIXME: What are the a.out magic numbers for the i860? */
2982 internal_a.magic = 0;
2983#define __A_MAGIC_SET__
2984#endif /* I860 */
2985#ifdef I960
2986 internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
2987#define __A_MAGIC_SET__
2988#endif /* I960 */
2989#if M88
2990#define __A_MAGIC_SET__
2991 internal_a.magic = PAGEMAGICBCS;
2992#endif /* M88 */
2993
2994#if APOLLO_M68
2995#define __A_MAGIC_SET__
2996 internal_a.magic = APOLLO_COFF_VERSION_NUMBER;
2997#endif
2998
2999#if defined(M68) || defined(WE32K) || defined(M68K)
3000#define __A_MAGIC_SET__
3001#if defined(LYNXOS)
3002 internal_a.magic = LYNXCOFFMAGIC;
3003#else
3004#if defined(TARG_AUX)
3005 internal_a.magic = (abfd->flags & D_PAGED ? PAGEMAGICPEXECPAGED :
3006 abfd->flags & WP_TEXT ? PAGEMAGICPEXECSWAPPED :
3007 PAGEMAGICEXECSWAPPED);
3008#else
3009#if defined (PAGEMAGICPEXECPAGED)
3010 internal_a.magic = PAGEMAGICPEXECPAGED;
3011#endif
3012#endif /* TARG_AUX */
3013#endif /* LYNXOS */
3014#endif /* M68 || WE32K || M68K */
3015
3016#if defined(ARM)
3017#define __A_MAGIC_SET__
3018 internal_a.magic = ZMAGIC;
3019#endif
3020
3021#if defined(PPC_PE)
3022#define __A_MAGIC_SET__
3023 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
3024#endif
3025
3026#if defined MCORE_PE
3027#define __A_MAGIC_SET__
3028 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
3029#endif
3030
3031#if defined(I386)
3032#define __A_MAGIC_SET__
3033#if defined(LYNXOS)
3034 internal_a.magic = LYNXCOFFMAGIC;
3035#else /* LYNXOS */
3036 internal_a.magic = ZMAGIC;
3037#endif /* LYNXOS */
3038#endif /* I386 */
3039
3040#if defined(SPARC)
3041#define __A_MAGIC_SET__
3042#if defined(LYNXOS)
3043 internal_a.magic = LYNXCOFFMAGIC;
3044#endif /* LYNXOS */
3045#endif /* SPARC */
3046
3047#ifdef RS6000COFF_C
3048#define __A_MAGIC_SET__
3049 internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC :
3050 (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC :
3051 RS6K_AOUTHDR_OMAGIC;
3052#endif
3053
3054#ifndef __A_MAGIC_SET__
3055#include "Your aouthdr magic number is not being set!"
3056#else
3057#undef __A_MAGIC_SET__
3058#endif
3059 }
3060
3061 /* FIXME: Does anybody ever set this to another value? */
3062 internal_a.vstamp = 0;
3063
3064 /* Now should write relocs, strings, syms */
3065 obj_sym_filepos (abfd) = sym_base;
3066
3067 if (bfd_get_symcount (abfd) != 0)
3068 {
3069 int firstundef;
3070#if 0
3071 if (!coff_add_missing_symbols (abfd))
3072 return false;
3073#endif
3074 if (!coff_renumber_symbols (abfd, &firstundef))
3075 return false;
3076 coff_mangle_symbols (abfd);
3077 if (! coff_write_symbols (abfd))
3078 return false;
3079 if (! coff_write_linenumbers (abfd))
3080 return false;
3081 if (! coff_write_relocs (abfd, firstundef))
3082 return false;
3083 }
3084#ifdef COFF_LONG_SECTION_NAMES
3085 else if (long_section_names)
3086 {
3087 /* If we have long section names we have to write out the string
3088 table even if there are no symbols. */
3089 if (! coff_write_symbols (abfd))
3090 return false;
3091 }
3092#endif
3093#ifdef COFF_IMAGE_WITH_PE
3094#ifdef PPC_PE
3095 else if ((abfd->flags & EXEC_P) != 0)
3096 {
3097 bfd_byte b;
3098
3099 /* PowerPC PE appears to require that all executable files be
3100 rounded up to the page size. */
3101 b = 0;
3102 if (bfd_seek (abfd,
3103 BFD_ALIGN (sym_base, COFF_PAGE_SIZE) - 1,
3104 SEEK_SET) != 0
3105 || bfd_write (&b, 1, 1, abfd) != 1)
3106 return false;
3107 }
3108#endif
3109#endif
3110
3111 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
3112 backend linker, and obj_raw_syment_count is not valid until after
3113 coff_write_symbols is called. */
3114 if (obj_raw_syment_count (abfd) != 0)
3115 {
3116 internal_f.f_symptr = sym_base;
3117#ifdef RS6000COFF_C
3118 /* AIX appears to require that F_RELFLG not be set if there are
3119 local symbols but no relocations. */
3120 internal_f.f_flags &=~ F_RELFLG;
3121#endif
3122 }
3123 else
3124 {
3125 if (long_section_names)
3126 internal_f.f_symptr = sym_base;
3127 else
3128 internal_f.f_symptr = 0;
3129 internal_f.f_flags |= F_LSYMS;
3130 }
3131
3132 if (text_sec)
3133 {
3134 internal_a.tsize = bfd_get_section_size_before_reloc (text_sec);
3135 internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
3136 }
3137 if (data_sec)
3138 {
3139 internal_a.dsize = bfd_get_section_size_before_reloc (data_sec);
3140 internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
3141 }
3142 if (bss_sec)
3143 {
3144 internal_a.bsize = bfd_get_section_size_before_reloc (bss_sec);
3145 if (internal_a.bsize && bss_sec->vma < internal_a.data_start)
3146 internal_a.data_start = bss_sec->vma;
3147 }
3148
3149 internal_a.entry = bfd_get_start_address (abfd);
3150 internal_f.f_nsyms = obj_raw_syment_count (abfd);
3151
3152#ifdef RS6000COFF_C
3153 if (xcoff_data (abfd)->full_aouthdr)
3154 {
3155 bfd_vma toc;
3156 asection *loader_sec;
3157
3158 internal_a.vstamp = 1;
3159
3160 internal_a.o_snentry = xcoff_data (abfd)->snentry;
3161 if (internal_a.o_snentry == 0)
3162 internal_a.entry = (bfd_vma) -1;
3163
3164 if (text_sec != NULL)
3165 {
3166 internal_a.o_sntext = text_sec->target_index;
3167 internal_a.o_algntext = bfd_get_section_alignment (abfd, text_sec);
3168 }
3169 else
3170 {
3171 internal_a.o_sntext = 0;
3172 internal_a.o_algntext = 0;
3173 }
3174 if (data_sec != NULL)
3175 {
3176 internal_a.o_sndata = data_sec->target_index;
3177 internal_a.o_algndata = bfd_get_section_alignment (abfd, data_sec);
3178 }
3179 else
3180 {
3181 internal_a.o_sndata = 0;
3182 internal_a.o_algndata = 0;
3183 }
3184 loader_sec = bfd_get_section_by_name (abfd, ".loader");
3185 if (loader_sec != NULL)
3186 internal_a.o_snloader = loader_sec->target_index;
3187 else
3188 internal_a.o_snloader = 0;
3189 if (bss_sec != NULL)
3190 internal_a.o_snbss = bss_sec->target_index;
3191 else
3192 internal_a.o_snbss = 0;
3193
3194 toc = xcoff_data (abfd)->toc;
3195 internal_a.o_toc = toc;
3196 internal_a.o_sntoc = xcoff_data (abfd)->sntoc;
3197
3198 internal_a.o_modtype = xcoff_data (abfd)->modtype;
3199 if (xcoff_data (abfd)->cputype != -1)
3200 internal_a.o_cputype = xcoff_data (abfd)->cputype;
3201 else
3202 {
3203 switch (bfd_get_arch (abfd))
3204 {
3205 case bfd_arch_rs6000:
3206 internal_a.o_cputype = 4;
3207 break;
3208 case bfd_arch_powerpc:
3209 if (bfd_get_mach (abfd) == 0)
3210 internal_a.o_cputype = 3;
3211 else
3212 internal_a.o_cputype = 1;
3213 break;
3214 default:
3215 abort ();
3216 }
3217 }
3218 internal_a.o_maxstack = xcoff_data (abfd)->maxstack;
3219 internal_a.o_maxdata = xcoff_data (abfd)->maxdata;
3220 }
3221#endif
3222
3223 /* now write them */
3224 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
3225 return false;
3226 {
3227 char buff[FILHSZ];
3228 coff_swap_filehdr_out (abfd, (PTR) & internal_f, (PTR) buff);
3229 if (bfd_write ((PTR) buff, 1, FILHSZ, abfd) != FILHSZ)
3230 return false;
3231 }
3232 if (abfd->flags & EXEC_P)
3233 {
3234 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
3235 include/coff/pe.h sets AOUTSZ == sizeof(PEAOUTHDR)) */
3236 char buff[AOUTSZ];
3237 coff_swap_aouthdr_out (abfd, (PTR) & internal_a, (PTR) buff);
3238 if (bfd_write ((PTR) buff, 1, AOUTSZ, abfd) != AOUTSZ)
3239 return false;
3240 }
3241#ifdef RS6000COFF_C
3242 else
3243 {
3244 AOUTHDR buff;
3245 size_t size;
3246
3247 /* XCOFF seems to always write at least a small a.out header. */
3248 coff_swap_aouthdr_out (abfd, (PTR) &internal_a, (PTR) &buff);
3249 if (xcoff_data (abfd)->full_aouthdr)
3250 size = AOUTSZ;
3251 else
3252 size = SMALL_AOUTSZ;
3253 if (bfd_write ((PTR) &buff, 1, size, abfd) != size)
3254 return false;
3255 }
3256#endif
3257
3258 return true;
3259}
3260
3261static boolean
3262coff_set_section_contents (abfd, section, location, offset, count)
3263 bfd * abfd;
3264 sec_ptr section;
3265 PTR location;
3266 file_ptr offset;
3267 bfd_size_type count;
3268{
3269 if (abfd->output_has_begun == false) /* set by bfd.c handler */
3270 {
3271 if (! coff_compute_section_file_positions (abfd))
3272 return false;
3273 }
3274
3275#if defined(_LIB) && !defined(TARG_AUX)
3276
3277 /* The physical address field of a .lib section is used to hold the
3278 number of shared libraries in the section. This code counts the
3279 number of sections being written, and increments the lma field
3280 with the number.
3281
3282 I have found no documentation on the contents of this section.
3283 Experimentation indicates that the section contains zero or more
3284 records, each of which has the following structure:
3285
3286 - a (four byte) word holding the length of this record, in words,
3287 - a word that always seems to be set to "2",
3288 - the path to a shared library, null-terminated and then padded
3289 to a whole word boundary.
3290
3291 bfd_assert calls have been added to alert if an attempt is made
3292 to write a section which doesn't follow these assumptions. The
3293 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
3294 <robertl@arnet.com> (Thanks!).
3295
3296 Gvran Uddeborg <gvran@uddeborg.pp.se> */
3297
3298 if (strcmp (section->name, _LIB) == 0)
3299 {
3300 bfd_byte *rec, *recend;
3301
3302 rec = (bfd_byte *) location;
3303 recend = rec + count;
3304 while (rec < recend)
3305 {
3306 ++section->lma;
3307 rec += bfd_get_32 (abfd, rec) * 4;
3308 }
3309
3310 BFD_ASSERT (rec == recend);
3311 }
3312
3313#endif
3314
3315 /* Don't write out bss sections - one way to do this is to
3316 see if the filepos has not been set. */
3317 if (section->filepos == 0)
3318 return true;
3319
3320 if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) != 0)
3321 return false;
3322
3323 if (count != 0)
3324 {
3325 return (bfd_write (location, 1, count, abfd) == count) ? true : false;
3326 }
3327 return true;
3328}
3329#if 0
3330static boolean
3331coff_close_and_cleanup (abfd)
3332 bfd *abfd;
3333{
3334 if (!bfd_read_p (abfd))
3335 switch (abfd->format)
3336 {
3337 case bfd_archive:
3338 if (!_bfd_write_archive_contents (abfd))
3339 return false;
3340 break;
3341 case bfd_object:
3342 if (!coff_write_object_contents (abfd))
3343 return false;
3344 break;
3345 default:
3346 bfd_set_error (bfd_error_invalid_operation);
3347 return false;
3348 }
3349
3350 /* We depend on bfd_close to free all the memory on the objalloc. */
3351 return true;
3352}
3353
3354#endif
3355
3356static PTR
3357buy_and_read (abfd, where, seek_direction, size)
3358 bfd *abfd;
3359 file_ptr where;
3360 int seek_direction;
3361 size_t size;
3362{
3363 PTR area = (PTR) bfd_alloc (abfd, size);
3364 if (!area)
3365 return (NULL);
3366 if (bfd_seek (abfd, where, seek_direction) != 0
3367 || bfd_read (area, 1, size, abfd) != size)
3368 return (NULL);
3369 return (area);
3370} /* buy_and_read() */
3371
3372/*
3373SUBSUBSECTION
3374 Reading linenumbers
3375
3376 Creating the linenumber table is done by reading in the entire
3377 coff linenumber table, and creating another table for internal use.
3378
3379 A coff linenumber table is structured so that each function
3380 is marked as having a line number of 0. Each line within the
3381 function is an offset from the first line in the function. The
3382 base of the line number information for the table is stored in
3383 the symbol associated with the function.
3384
3385 The information is copied from the external to the internal
3386 table, and each symbol which marks a function is marked by
3387 pointing its...
3388
3389 How does this work ?
3390
3391*/
3392
3393static boolean
3394coff_slurp_line_table (abfd, asect)
3395 bfd *abfd;
3396 asection *asect;
3397{
3398 LINENO *native_lineno;
3399 alent *lineno_cache;
3400
3401 BFD_ASSERT (asect->lineno == (alent *) NULL);
3402
3403 native_lineno = (LINENO *) buy_and_read (abfd,
3404 asect->line_filepos,
3405 SEEK_SET,
3406 (size_t) (LINESZ *
3407 asect->lineno_count));
3408 lineno_cache =
3409 (alent *) bfd_alloc (abfd, (size_t) ((asect->lineno_count + 1) * sizeof (alent)));
3410 if (lineno_cache == NULL)
3411 return false;
3412 else
3413 {
3414 unsigned int counter = 0;
3415 alent *cache_ptr = lineno_cache;
3416 LINENO *src = native_lineno;
3417
3418 while (counter < asect->lineno_count)
3419 {
3420 struct internal_lineno dst;
3421 coff_swap_lineno_in (abfd, src, &dst);
3422 cache_ptr->line_number = dst.l_lnno;
3423
3424 if (cache_ptr->line_number == 0)
3425 {
3426 boolean warned;
3427 long symndx;
3428 coff_symbol_type *sym;
3429
3430 warned = false;
3431 symndx = dst.l_addr.l_symndx;
3432 if (symndx < 0
3433 || (unsigned long) symndx >= obj_raw_syment_count (abfd))
3434 {
3435 (*_bfd_error_handler)
3436 (_("%s: warning: illegal symbol index %ld in line numbers"),
3437 bfd_get_filename (abfd), dst.l_addr.l_symndx);
3438 symndx = 0;
3439 warned = true;
3440 }
3441 /* FIXME: We should not be casting between ints and
3442 pointers like this. */
3443 sym = ((coff_symbol_type *)
3444 ((symndx + obj_raw_syments (abfd))
3445 ->u.syment._n._n_n._n_zeroes));
3446 cache_ptr->u.sym = (asymbol *) sym;
3447 if (sym->lineno != NULL && ! warned)
3448 {
3449 (*_bfd_error_handler)
3450 (_("%s: warning: duplicate line number information for `%s'"),
3451 bfd_get_filename (abfd),
3452 bfd_asymbol_name (&sym->symbol));
3453 }
3454 sym->lineno = cache_ptr;
3455 }
3456 else
3457 {
3458 cache_ptr->u.offset = dst.l_addr.l_paddr
3459 - bfd_section_vma (abfd, asect);
3460 } /* If no linenumber expect a symbol index */
3461
3462 cache_ptr++;
3463 src++;
3464 counter++;
3465 }
3466 cache_ptr->line_number = 0;
3467
3468 }
3469 asect->lineno = lineno_cache;
3470 /* FIXME, free native_lineno here, or use alloca or something. */
3471 return true;
3472}
3473
3474static boolean
3475coff_slurp_symbol_table (abfd)
3476 bfd * abfd;
3477{
3478 combined_entry_type *native_symbols;
3479 coff_symbol_type *cached_area;
3480 unsigned int *table_ptr;
3481
3482 unsigned int number_of_symbols = 0;
3483
3484 if (obj_symbols (abfd))
3485 return true;
3486
3487 /* Read in the symbol table */
3488 if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL)
3489 {
3490 return (false);
3491 } /* on error */
3492
3493 /* Allocate enough room for all the symbols in cached form */
3494 cached_area = ((coff_symbol_type *)
3495 bfd_alloc (abfd,
3496 (obj_raw_syment_count (abfd)
3497 * sizeof (coff_symbol_type))));
3498
3499 if (cached_area == NULL)
3500 return false;
3501 table_ptr = ((unsigned int *)
3502 bfd_alloc (abfd,
3503 (obj_raw_syment_count (abfd)
3504 * sizeof (unsigned int))));
3505
3506 if (table_ptr == NULL)
3507 return false;
3508 else
3509 {
3510 coff_symbol_type *dst = cached_area;
3511 unsigned int last_native_index = obj_raw_syment_count (abfd);
3512 unsigned int this_index = 0;
3513 while (this_index < last_native_index)
3514 {
3515 combined_entry_type *src = native_symbols + this_index;
3516 table_ptr[this_index] = number_of_symbols;
3517 dst->symbol.the_bfd = abfd;
3518
3519 dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset);
3520 /* We use the native name field to point to the cached field. */
3521 src->u.syment._n._n_n._n_zeroes = (long) dst;
3522 dst->symbol.section = coff_section_from_bfd_index (abfd,
3523 src->u.syment.n_scnum);
3524 dst->symbol.flags = 0;
3525 dst->done_lineno = false;
3526
3527 switch (src->u.syment.n_sclass)
3528 {
3529#ifdef I960
3530 case C_LEAFEXT:
3531#if 0
3532 dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
3533 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
3534 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
3535#endif
3536 /* Fall through to next case */
3537
3538#endif
3539
3540 case C_EXT:
3541 case C_WEAKEXT:
3542#if defined ARM
3543 case C_THUMBEXT:
3544 case C_THUMBEXTFUNC:
3545#endif
3546#ifdef RS6000COFF_C
3547 case C_HIDEXT:
3548#endif
3549#ifdef C_SYSTEM
3550 case C_SYSTEM: /* System Wide variable */
3551#endif
3552#ifdef COFF_WITH_PE
3553 /* PE uses storage class 0x68 to denote a section symbol */
3554 case C_SECTION:
3555 /* PE uses storage class 0x69 for a weak external symbol. */
3556 case C_NT_WEAK:
3557#endif
3558 if ((src->u.syment.n_scnum) == 0)
3559 {
3560 if ((src->u.syment.n_value) == 0)
3561 {
3562 dst->symbol.section = bfd_und_section_ptr;
3563 dst->symbol.value = 0;
3564 }
3565 else
3566 {
3567 dst->symbol.section = bfd_com_section_ptr;
3568 dst->symbol.value = (src->u.syment.n_value);
3569 }
3570 }
3571 else
3572 {
3573 /* Base the value as an index from the base of the
3574 section */
3575
3576 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
3577
3578#if defined COFF_WITH_PE
3579 /* PE sets the symbol to a value relative to the
3580 start of the section. */
3581 dst->symbol.value = src->u.syment.n_value;
3582#else
3583 dst->symbol.value = (src->u.syment.n_value
3584 - dst->symbol.section->vma);
3585#endif
3586
3587 if (ISFCN ((src->u.syment.n_type)))
3588 {
3589 /* A function ext does not go at the end of a
3590 file. */
3591 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
3592 }
3593 }
3594
3595#ifdef RS6000COFF_C
3596 /* A C_HIDEXT symbol is not global. */
3597 if (src->u.syment.n_sclass == C_HIDEXT)
3598 dst->symbol.flags = BSF_LOCAL;
3599 /* A symbol with a csect entry should not go at the end. */
3600 if (src->u.syment.n_numaux > 0)
3601 dst->symbol.flags |= BSF_NOT_AT_END;
3602#endif
3603
3604#ifdef COFF_WITH_PE
3605 if (src->u.syment.n_sclass == C_NT_WEAK)
3606 dst->symbol.flags = BSF_WEAK;
ec0ef80e
DD		 3607 if (src->u.syment.n_sclass == C_SECTION
3608 && src->u.syment.n_scnum > 0)
3609 {
3610 dst->symbol.flags = BSF_LOCAL;
3611 }
252b5132
RH		 3612#endif
3613
3614 if (src->u.syment.n_sclass == C_WEAKEXT)
3615 dst->symbol.flags = BSF_WEAK;
3616
3617 break;
3618
3619 case C_STAT: /* static */
3620#ifdef I960
3621 case C_LEAFSTAT: /* static leaf procedure */
3622#endif
3623#if defined ARM
3624 case C_THUMBSTAT: /* Thumb static */
3625 case C_THUMBLABEL: /* Thumb label */
3626 case C_THUMBSTATFUNC:/* Thumb static function */
3627#endif
3628 case C_LABEL: /* label */
3629 if (src->u.syment.n_scnum == -2)
3630 dst->symbol.flags = BSF_DEBUGGING;
3631 else
3632 dst->symbol.flags = BSF_LOCAL;
3633
3634 /* Base the value as an index from the base of the
3635 section, if there is one. */
3636 if (dst->symbol.section)
3637 {
3638#if defined COFF_WITH_PE
3639 /* PE sets the symbol to a value relative to the
3640 start of the section. */
3641 dst->symbol.value = src->u.syment.n_value;
3642#else
3643 dst->symbol.value = (src->u.syment.n_value
3644 - dst->symbol.section->vma);
3645#endif
3646 }
3647 else
3648 dst->symbol.value = src->u.syment.n_value;
3649 break;
3650
3651 case C_MOS: /* member of structure */
3652 case C_EOS: /* end of structure */
3653#ifdef NOTDEF /* C_AUTOARG has the same value */
3654#ifdef C_GLBLREG
3655 case C_GLBLREG: /* A29k-specific storage class */
3656#endif
3657#endif
3658 case C_REGPARM: /* register parameter */
3659 case C_REG: /* register variable */
3660#ifndef TIC80COFF
3661#ifdef C_AUTOARG
3662 case C_AUTOARG: /* 960-specific storage class */
3663#endif
3664#endif
3665 case C_TPDEF: /* type definition */
3666 case C_ARG:
3667 case C_AUTO: /* automatic variable */
3668 case C_FIELD: /* bit field */
3669 case C_ENTAG: /* enumeration tag */
3670 case C_MOE: /* member of enumeration */
3671 case C_MOU: /* member of union */
3672 case C_UNTAG: /* union tag */
3673 dst->symbol.flags = BSF_DEBUGGING;
3674 dst->symbol.value = (src->u.syment.n_value);
3675 break;
3676
3677 case C_FILE: /* file name */
3678 case C_STRTAG: /* structure tag */
3679#ifdef RS6000COFF_C
3680 case C_GSYM:
3681 case C_LSYM:
3682 case C_PSYM:
3683 case C_RSYM:
3684 case C_RPSYM:
3685 case C_STSYM:
3686 case C_BCOMM:
3687 case C_ECOMM:
3688 case C_DECL:
3689 case C_ENTRY:
3690 case C_FUN:
3691 case C_ESTAT:
3692#endif
3693 dst->symbol.flags = BSF_DEBUGGING;
3694 dst->symbol.value = (src->u.syment.n_value);
3695 break;
3696
3697#ifdef RS6000COFF_C
3698 case C_BINCL: /* beginning of include file */
3699 case C_EINCL: /* ending of include file */
3700 /* The value is actually a pointer into the line numbers
3701 of the file. We locate the line number entry, and
3702 set the section to the section which contains it, and
3703 the value to the index in that section. */
3704 {
3705 asection *sec;
3706
3707 dst->symbol.flags = BSF_DEBUGGING;
3708 for (sec = abfd->sections; sec != NULL; sec = sec->next)
3709 if (sec->line_filepos <= (file_ptr) src->u.syment.n_value
3710 && ((file_ptr) (sec->line_filepos
3711 + sec->lineno_count * LINESZ)
3712 > (file_ptr) src->u.syment.n_value))
3713 break;
3714 if (sec == NULL)
3715 dst->symbol.value = 0;
3716 else
3717 {
3718 dst->symbol.section = sec;
3719 dst->symbol.value = ((src->u.syment.n_value
3720 - sec->line_filepos)
3721 / LINESZ);
3722 src->fix_line = 1;
3723 }
3724 }
3725 break;
3726
3727 case C_BSTAT:
3728 dst->symbol.flags = BSF_DEBUGGING;
3729
3730 /* The value is actually a symbol index. Save a pointer
3731 to the symbol instead of the index. FIXME: This
3732 should use a union. */
3733 src->u.syment.n_value =
3734 (long) (native_symbols + src->u.syment.n_value);
3735 dst->symbol.value = src->u.syment.n_value;
3736 src->fix_value = 1;
3737 break;
3738#endif
3739
3740 case C_BLOCK: /* ".bb" or ".eb" */
3741 case C_FCN: /* ".bf" or ".ef" */
3742 case C_EFCN: /* physical end of function */
3743 dst->symbol.flags = BSF_LOCAL;
3744#if defined COFF_WITH_PE
3745 /* PE sets the symbol to a value relative to the start
3746 of the section. */
3747 dst->symbol.value = src->u.syment.n_value;
3748#else
3749 /* Base the value as an index from the base of the
3750 section. */
3751 dst->symbol.value = (src->u.syment.n_value
3752 - dst->symbol.section->vma);
3753#endif
3754 break;
3755
3756 case C_NULL:
3757 case C_EXTDEF: /* external definition */
3758 case C_ULABEL: /* undefined label */
3759 case C_USTATIC: /* undefined static */
3760#ifndef COFF_WITH_PE
3761 /* C_LINE in regular coff is 0x68. NT has taken over this storage
3762 class to represent a section symbol */
3763 case C_LINE: /* line # reformatted as symbol table entry */
3764 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
3765 case C_ALIAS: /* duplicate tag */
3766#endif
3767 /* New storage classes for TIc80 */
3768#ifdef TIC80COFF
3769 case C_UEXT: /* Tentative external definition */
3770#endif
3771 case C_STATLAB: /* Static load time label */
3772 case C_EXTLAB: /* External load time label */
3773 case C_HIDDEN: /* ext symbol in dmert public lib */
3774 default:
3775 (*_bfd_error_handler)
3776 (_("%s: Unrecognized storage class %d for %s symbol `%s'"),
3777 bfd_get_filename (abfd), src->u.syment.n_sclass,
3778 dst->symbol.section->name, dst->symbol.name);
3779 dst->symbol.flags = BSF_DEBUGGING;
3780 dst->symbol.value = (src->u.syment.n_value);
3781 break;
3782 }
3783
3784/* BFD_ASSERT(dst->symbol.flags != 0);*/
3785
3786 dst->native = src;
3787
3788 dst->symbol.udata.i = 0;
3789 dst->lineno = (alent *) NULL;
3790 this_index += (src->u.syment.n_numaux) + 1;
3791 dst++;
3792 number_of_symbols++;
3793 } /* walk the native symtab */
3794 } /* bfdize the native symtab */
3795
3796 obj_symbols (abfd) = cached_area;
3797 obj_raw_syments (abfd) = native_symbols;
3798
3799 bfd_get_symcount (abfd) = number_of_symbols;
3800 obj_convert (abfd) = table_ptr;
3801 /* Slurp the line tables for each section too */
3802 {
3803 asection *p;
3804 p = abfd->sections;
3805 while (p)
3806 {
3807 coff_slurp_line_table (abfd, p);
3808 p = p->next;
3809 }
3810 }
3811 return true;
3812} /* coff_slurp_symbol_table() */
3813
3814/* Check whether a symbol is globally visible. This is used by the
3815 COFF backend linker code in cofflink.c, since a couple of targets
3816 have globally visible symbols which are not class C_EXT. This
3817 function need not handle the case of n_class == C_EXT. */
3818
3819#undef OTHER_GLOBAL_CLASS
3820
3821#ifdef I960
3822#define OTHER_GLOBAL_CLASS C_LEAFEXT
3823#endif
3824
3825#ifdef COFFARM
3826#define OTHER_GLOBAL_CLASS C_THUMBEXT || syment->n_sclass == C_THUMBEXTFUNC
3827#else
3828#ifdef COFF_WITH_PE
3829#define OTHER_GLOBAL_CLASS C_SECTION
3830#endif
3831#endif
3832
3833#ifdef OTHER_GLOBAL_CLASS
3834
3835static boolean coff_sym_is_global PARAMS ((bfd *, struct internal_syment *));
3836
3837static boolean
3838coff_sym_is_global (abfd, syment)
3839 bfd * abfd;
3840 struct internal_syment * syment;
3841{
3842 return (syment->n_sclass == OTHER_GLOBAL_CLASS);
3843}
3844
3845#undef OTHER_GLOBAL_CLASS
3846
3847#else /* ! defined (OTHER_GLOBAL_CLASS) */
3848
3849/* sym_is_global should not be defined if it has nothing to do. */
3850
3851#define coff_sym_is_global 0
3852
3853#endif /* ! defined (OTHER_GLOBAL_CLASS) */
3854
3855/*
3856SUBSUBSECTION
3857 Reading relocations
3858
3859 Coff relocations are easily transformed into the internal BFD form
3860 (@code{arelent}).
3861
3862 Reading a coff relocation table is done in the following stages:
3863
3864 o Read the entire coff relocation table into memory.
3865
3866 o Process each relocation in turn; first swap it from the
3867 external to the internal form.
3868
3869 o Turn the symbol referenced in the relocation's symbol index
3870 into a pointer into the canonical symbol table.
3871 This table is the same as the one returned by a call to
3872 @code{bfd_canonicalize_symtab}. The back end will call that
3873 routine and save the result if a canonicalization hasn't been done.
3874
3875 o The reloc index is turned into a pointer to a howto
3876 structure, in a back end specific way. For instance, the 386
3877 and 960 use the @code{r_type} to directly produce an index
3878 into a howto table vector; the 88k subtracts a number from the
3879 @code{r_type} field and creates an addend field.
3880
3881
3882*/
3883
3884#ifndef CALC_ADDEND
3885#define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
3886 { \
3887 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \
3888 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
3889 coffsym = (obj_symbols (abfd) \
3890 + (cache_ptr->sym_ptr_ptr - symbols)); \
3891 else if (ptr) \
3892 coffsym = coff_symbol_from (abfd, ptr); \
3893 if (coffsym != (coff_symbol_type *) NULL \
3894 && coffsym->native->u.syment.n_scnum == 0) \
3895 cache_ptr->addend = 0; \
3896 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
3897 && ptr->section != (asection *) NULL) \
3898 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
3899 else \
3900 cache_ptr->addend = 0; \
3901 }
3902#endif
3903
3904static boolean
3905coff_slurp_reloc_table (abfd, asect, symbols)
3906 bfd * abfd;
3907 sec_ptr asect;
3908 asymbol ** symbols;
3909{
3910 RELOC *native_relocs;
3911 arelent *reloc_cache;
3912 arelent *cache_ptr;
3913
3914 unsigned int idx;
3915
3916 if (asect->relocation)
3917 return true;
3918 if (asect->reloc_count == 0)
3919 return true;
3920 if (asect->flags & SEC_CONSTRUCTOR)
3921 return true;
3922 if (!coff_slurp_symbol_table (abfd))
3923 return false;
3924 native_relocs =
3925 (RELOC *) buy_and_read (abfd,
3926 asect->rel_filepos,
3927 SEEK_SET,
3928 (size_t) (RELSZ *
3929 asect->reloc_count));
3930 reloc_cache = (arelent *)
3931 bfd_alloc (abfd, (size_t) (asect->reloc_count * sizeof (arelent)));
3932
3933 if (reloc_cache == NULL)
3934 return false;
3935
3936
3937 for (idx = 0; idx < asect->reloc_count; idx++)
3938 {
3939 struct internal_reloc dst;
3940 struct external_reloc *src;
3941#ifndef RELOC_PROCESSING
3942 asymbol *ptr;
3943#endif
3944
3945 cache_ptr = reloc_cache + idx;
3946 src = native_relocs + idx;
3947
3948 coff_swap_reloc_in (abfd, src, &dst);
3949
3950#ifdef RELOC_PROCESSING
3951 RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
3952#else
3953 cache_ptr->address = dst.r_vaddr;
3954
3955 if (dst.r_symndx != -1)
3956 {
3957 if (dst.r_symndx < 0 || dst.r_symndx >= obj_conv_table_size (abfd))
3958 {
3959 (*_bfd_error_handler)
3960 (_("%s: warning: illegal symbol index %ld in relocs"),
3961 bfd_get_filename (abfd), dst.r_symndx);
3962 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
3963 ptr = NULL;
3964 }
3965 else
3966 {
3967 cache_ptr->sym_ptr_ptr = (symbols
3968 + obj_convert (abfd)[dst.r_symndx]);
3969 ptr = *(cache_ptr->sym_ptr_ptr);
3970 }
3971 }
3972 else
3973 {
3974 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
3975 ptr = NULL;
3976 }
3977
3978 /* The symbols definitions that we have read in have been
3979 relocated as if their sections started at 0. But the offsets
3980 refering to the symbols in the raw data have not been
3981 modified, so we have to have a negative addend to compensate.
3982
3983 Note that symbols which used to be common must be left alone */
3984
3985 /* Calculate any reloc addend by looking at the symbol */
3986 CALC_ADDEND (abfd, ptr, dst, cache_ptr);
3987
3988 cache_ptr->address -= asect->vma;
3989/* !! cache_ptr->section = (asection *) NULL;*/
3990
3991 /* Fill in the cache_ptr->howto field from dst.r_type */
3992 RTYPE2HOWTO (cache_ptr, &dst);
3993#endif /* RELOC_PROCESSING */
3994
3995 if (cache_ptr->howto == NULL)
3996 {
3997 (*_bfd_error_handler)
3998 (_("%s: illegal relocation type %d at address 0x%lx"),
3999 bfd_get_filename (abfd), dst.r_type, (long) dst.r_vaddr);
4000 bfd_set_error (bfd_error_bad_value);
4001 return false;
4002 }
4003 }
4004
4005 asect->relocation = reloc_cache;
4006 return true;
4007}
4008
4009#ifndef coff_rtype_to_howto
4010#ifdef RTYPE2HOWTO
4011
4012/* Get the howto structure for a reloc. This is only used if the file
4013 including this one defines coff_relocate_section to be
4014 _bfd_coff_generic_relocate_section, so it is OK if it does not
4015 always work. It is the responsibility of the including file to
4016 make sure it is reasonable if it is needed. */
4017
4018static reloc_howto_type *coff_rtype_to_howto
4019 PARAMS ((bfd *, asection *, struct internal_reloc *,
4020 struct coff_link_hash_entry *, struct internal_syment *,
4021 bfd_vma *));
4022
4023/*ARGSUSED*/
4024static reloc_howto_type *
4025coff_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
4026 bfd *abfd;
4027 asection *sec;
4028 struct internal_reloc *rel;
4029 struct coff_link_hash_entry *h;
4030 struct internal_syment *sym;
4031 bfd_vma *addendp;
4032{
4033 arelent genrel;
4034
4035 RTYPE2HOWTO (&genrel, rel);
4036 return genrel.howto;
4037}
4038
4039#else /* ! defined (RTYPE2HOWTO) */
4040
4041#define coff_rtype_to_howto NULL
4042
4043#endif /* ! defined (RTYPE2HOWTO) */
4044#endif /* ! defined (coff_rtype_to_howto) */
4045
4046/* This is stupid. This function should be a boolean predicate. */
4047static long
4048coff_canonicalize_reloc (abfd, section, relptr, symbols)
4049 bfd * abfd;
4050 sec_ptr section;
4051 arelent ** relptr;
4052 asymbol ** symbols;
4053{
4054 arelent *tblptr = section->relocation;
4055 unsigned int count = 0;
4056
4057
4058 if (section->flags & SEC_CONSTRUCTOR)
4059 {
4060 /* this section has relocs made up by us, they are not in the
4061 file, so take them out of their chain and place them into
4062 the data area provided */
4063 arelent_chain *chain = section->constructor_chain;
4064 for (count = 0; count < section->reloc_count; count++)
4065 {
4066 *relptr++ = &chain->relent;
4067 chain = chain->next;
4068 }
4069
4070 }
4071 else
4072 {
4073 if (! coff_slurp_reloc_table (abfd, section, symbols))
4074 return -1;
4075
4076 tblptr = section->relocation;
4077
4078 for (; count++ < section->reloc_count;)
4079 *relptr++ = tblptr++;
4080
4081
4082 }
4083 *relptr = 0;
4084 return section->reloc_count;
4085}
4086
4087#ifdef GNU960
4088file_ptr
4089coff_sym_filepos (abfd)
4090 bfd *abfd;
4091{
4092 return obj_sym_filepos (abfd);
4093}
4094#endif
4095
4096#ifndef coff_reloc16_estimate
4097#define coff_reloc16_estimate dummy_reloc16_estimate
4098
4099static int dummy_reloc16_estimate
4100 PARAMS ((bfd *, asection *, arelent *, unsigned int,
4101 struct bfd_link_info *));
4102
4103static int
4104dummy_reloc16_estimate (abfd, input_section, reloc, shrink, link_info)
4105 bfd *abfd;
4106 asection *input_section;
4107 arelent *reloc;
4108 unsigned int shrink;
4109 struct bfd_link_info *link_info;
4110{
4111 abort ();
4112}
4113
4114#endif
4115
4116#ifndef coff_reloc16_extra_cases
4117
4118#define coff_reloc16_extra_cases dummy_reloc16_extra_cases
4119
4120/* This works even if abort is not declared in any header file. */
4121
4122static void dummy_reloc16_extra_cases
4123 PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
4124 bfd_byte *, unsigned int *, unsigned int *));
4125
4126static void
4127dummy_reloc16_extra_cases (abfd, link_info, link_order, reloc, data, src_ptr,
4128 dst_ptr)
4129 bfd *abfd;
4130 struct bfd_link_info *link_info;
4131 struct bfd_link_order *link_order;
4132 arelent *reloc;
4133 bfd_byte *data;
4134 unsigned int *src_ptr;
4135 unsigned int *dst_ptr;
4136{
4137 abort ();
4138}
4139#endif
4140
4141/* If coff_relocate_section is defined, we can use the optimized COFF
4142 backend linker. Otherwise we must continue to use the old linker. */
4143#ifdef coff_relocate_section
4144#ifndef coff_bfd_link_hash_table_create
4145#define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
4146#endif
4147#ifndef coff_bfd_link_add_symbols
4148#define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
4149#endif
4150#ifndef coff_bfd_final_link
4151#define coff_bfd_final_link _bfd_coff_final_link
4152#endif
4153#else /* ! defined (coff_relocate_section) */
4154#define coff_relocate_section NULL
4155#ifndef coff_bfd_link_hash_table_create
4156#define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
4157#endif
4158#ifndef coff_bfd_link_add_symbols
4159#define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
4160#endif
4161#define coff_bfd_final_link _bfd_generic_final_link
4162#endif /* ! defined (coff_relocate_section) */
4163
4164#define coff_bfd_link_split_section _bfd_generic_link_split_section
4165
4166#ifndef coff_start_final_link
4167#define coff_start_final_link NULL
4168#endif
4169
4170#ifndef coff_adjust_symndx
4171#define coff_adjust_symndx NULL
4172#endif
4173
4174#ifndef coff_link_add_one_symbol
4175#define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
4176#endif
4177
4178#ifndef coff_link_output_has_begun
4179
4180static boolean coff_link_output_has_begun
4181 PARAMS ((bfd *, struct coff_final_link_info *));
4182
4183static boolean
4184coff_link_output_has_begun (abfd, info)
4185 bfd * abfd;
4186 struct coff_final_link_info * info;
4187{
4188 return abfd->output_has_begun;
4189}
4190#endif
4191
4192#ifndef coff_final_link_postscript
4193
4194static boolean coff_final_link_postscript
4195 PARAMS ((bfd *, struct coff_final_link_info *));
4196
4197static boolean
4198coff_final_link_postscript (abfd, pfinfo)
4199 bfd * abfd;
4200 struct coff_final_link_info * pfinfo;
4201{
4202 return true;
4203}
4204#endif
4205
4206#ifndef coff_SWAP_aux_in
4207#define coff_SWAP_aux_in coff_swap_aux_in
4208#endif
4209#ifndef coff_SWAP_sym_in
4210#define coff_SWAP_sym_in coff_swap_sym_in
4211#endif
4212#ifndef coff_SWAP_lineno_in
4213#define coff_SWAP_lineno_in coff_swap_lineno_in
4214#endif
4215#ifndef coff_SWAP_aux_out
4216#define coff_SWAP_aux_out coff_swap_aux_out
4217#endif
4218#ifndef coff_SWAP_sym_out
4219#define coff_SWAP_sym_out coff_swap_sym_out
4220#endif
4221#ifndef coff_SWAP_lineno_out
4222#define coff_SWAP_lineno_out coff_swap_lineno_out
4223#endif
4224#ifndef coff_SWAP_reloc_out
4225#define coff_SWAP_reloc_out coff_swap_reloc_out
4226#endif
4227#ifndef coff_SWAP_filehdr_out
4228#define coff_SWAP_filehdr_out coff_swap_filehdr_out
4229#endif
4230#ifndef coff_SWAP_aouthdr_out
4231#define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
4232#endif
4233#ifndef coff_SWAP_scnhdr_out
4234#define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
4235#endif
4236#ifndef coff_SWAP_reloc_in
4237#define coff_SWAP_reloc_in coff_swap_reloc_in
4238#endif
4239#ifndef coff_SWAP_filehdr_in
4240#define coff_SWAP_filehdr_in coff_swap_filehdr_in
4241#endif
4242#ifndef coff_SWAP_aouthdr_in
4243#define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
4244#endif
4245#ifndef coff_SWAP_scnhdr_in
4246#define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
4247#endif
4248
4249
4250
4251static CONST bfd_coff_backend_data bfd_coff_std_swap_table =
4252{
4253 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
4254 coff_SWAP_aux_out, coff_SWAP_sym_out,
4255 coff_SWAP_lineno_out, coff_SWAP_reloc_out,
4256 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
4257 coff_SWAP_scnhdr_out,
4258 FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ,
4259#ifdef COFF_LONG_FILENAMES
4260 true,
4261#else
4262 false,
4263#endif
4264#ifdef COFF_LONG_SECTION_NAMES
4265 true,
4266#else
4267 false,
4268#endif
4269 COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
4270 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
4271 coff_SWAP_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook,
4272 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
4273 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
4274 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
4275 coff_sym_is_global, coff_compute_section_file_positions,
4276 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
4277 coff_adjust_symndx, coff_link_add_one_symbol,
4278 coff_link_output_has_begun, coff_final_link_postscript
4279};
4280
4281#ifndef coff_close_and_cleanup
4282#define coff_close_and_cleanup _bfd_generic_close_and_cleanup
4283#endif
4284
4285#ifndef coff_bfd_free_cached_info
4286#define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
4287#endif
4288
4289#ifndef coff_get_section_contents
4290#define coff_get_section_contents _bfd_generic_get_section_contents
4291#endif
4292
4293#ifndef coff_bfd_copy_private_symbol_data
4294#define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
4295#endif
4296
4297#ifndef coff_bfd_copy_private_section_data
4298#define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
4299#endif
4300
4301#ifndef coff_bfd_copy_private_bfd_data
4302#define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
4303#endif
4304
4305#ifndef coff_bfd_merge_private_bfd_data
4306#define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
4307#endif
4308
4309#ifndef coff_bfd_set_private_flags
4310#define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
4311#endif
4312
4313#ifndef coff_bfd_print_private_bfd_data
4314#define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
4315#endif
4316
4317#ifndef coff_bfd_is_local_label_name
4318#define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
4319#endif
4320
4321#ifndef coff_read_minisymbols
4322#define coff_read_minisymbols _bfd_generic_read_minisymbols
4323#endif
4324
4325#ifndef coff_minisymbol_to_symbol
4326#define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
4327#endif
4328
4329/* The reloc lookup routine must be supplied by each individual COFF
4330 backend. */
4331#ifndef coff_bfd_reloc_type_lookup
4332#define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
4333#endif
4334
4335#ifndef coff_bfd_get_relocated_section_contents
4336#define coff_bfd_get_relocated_section_contents \
4337 bfd_generic_get_relocated_section_contents
4338#endif
4339
4340#ifndef coff_bfd_relax_section
4341#define coff_bfd_relax_section bfd_generic_relax_section
4342#endif
4343
4344#ifndef coff_bfd_gc_sections
4345#define coff_bfd_gc_sections bfd_generic_gc_sections
4346#endif
GDB Binutils - Deliverables
This page took 0.201362 seconds and 4 git commands to generate.