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