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