]> Git Repo - binutils.git/blame - bfd/coffcode.h
projects / binutils.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Improve verbose message
[binutils.git] / bfd / coffcode.h
CommitLineData
252b5132 1/* Support for the generic parts of most COFF variants, for BFD.
17505c5c 2 Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000
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 [email protected]
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}
00692651 134 and @code{coff_swap_lineno_in}. @code{GDB} reads the symbol
252b5132
RH		 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));
41733515
ILT		 316static flagword styp_to_sec_flags
317 PARAMS ((bfd *, PTR, const char *, asection *));
252b5132 318static boolean coff_bad_format_hook PARAMS ((bfd *, PTR));
5dccc1dd
ILT		 319static void coff_set_custom_section_alignment
320 PARAMS ((bfd *, asection *, const struct coff_section_alignment_entry *,
8a1ad8e7 321 const unsigned int));
252b5132
RH		 322static boolean coff_new_section_hook PARAMS ((bfd *, asection *));
323static boolean coff_set_arch_mach_hook PARAMS ((bfd *, PTR));
324static boolean coff_write_relocs PARAMS ((bfd *, int));
325static boolean coff_set_flags
326 PARAMS ((bfd *, unsigned int *, unsigned short *));
327static boolean coff_set_arch_mach
328 PARAMS ((bfd *, enum bfd_architecture, unsigned long));
329static boolean coff_compute_section_file_positions PARAMS ((bfd *));
330static boolean coff_write_object_contents PARAMS ((bfd *));
331static boolean coff_set_section_contents
332 PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type));
333static PTR buy_and_read PARAMS ((bfd *, file_ptr, int, size_t));
334static boolean coff_slurp_line_table PARAMS ((bfd *, asection *));
335static boolean coff_slurp_symbol_table PARAMS ((bfd *));
5d54c628
ILT		 336static enum coff_symbol_classification coff_classify_symbol
337 PARAMS ((bfd *, struct internal_syment *));
252b5132
RH		 338static boolean coff_slurp_reloc_table PARAMS ((bfd *, asection *, asymbol **));
339static long coff_canonicalize_reloc
340 PARAMS ((bfd *, asection *, arelent **, asymbol **));
341#ifndef coff_mkobject_hook
342static PTR coff_mkobject_hook PARAMS ((bfd *, PTR, PTR));
343#endif
344\f
345/* void warning(); */
346
41733515
ILT		 347/* Return a word with STYP_* (scnhdr.s_flags) flags set to represent
348 the incoming SEC_* flags. The inverse of this function is
349 styp_to_sec_flags(). NOTE: If you add to/change this routine, you
350 should probably mirror the changes in styp_to_sec_flags(). */
351
352#ifndef COFF_WITH_PE
353
252b5132
RH		 354static long
355sec_to_styp_flags (sec_name, sec_flags)
356 CONST char *sec_name;
357 flagword sec_flags;
358{
359 long styp_flags = 0;
360
361 if (!strcmp (sec_name, _TEXT))
362 {
363 styp_flags = STYP_TEXT;
364 }
365 else if (!strcmp (sec_name, _DATA))
366 {
367 styp_flags = STYP_DATA;
368 }
369 else if (!strcmp (sec_name, _BSS))
370 {
371 styp_flags = STYP_BSS;
372#ifdef _COMMENT
373 }
374 else if (!strcmp (sec_name, _COMMENT))
375 {
376 styp_flags = STYP_INFO;
377#endif /* _COMMENT */
378#ifdef _LIB
379 }
380 else if (!strcmp (sec_name, _LIB))
381 {
382 styp_flags = STYP_LIB;
383#endif /* _LIB */
384#ifdef _LIT
385 }
386 else if (!strcmp (sec_name, _LIT))
387 {
388 styp_flags = STYP_LIT;
389#endif /* _LIT */
390 }
391 else if (!strcmp (sec_name, ".debug"))
392 {
393#ifdef STYP_DEBUG
394 styp_flags = STYP_DEBUG;
395#else
396 styp_flags = STYP_INFO;
397#endif
398 }
399 else if (!strncmp (sec_name, ".stab", 5))
400 {
81635ce4
TW		 401#ifdef COFF_ALIGN_IN_S_FLAGS
402 styp_flags = STYP_DSECT;
403#else
252b5132 404 styp_flags = STYP_INFO;
81635ce4 405#endif
252b5132 406 }
252b5132
RH		 407#ifdef RS6000COFF_C
408 else if (!strcmp (sec_name, _PAD))
409 {
410 styp_flags = STYP_PAD;
411 }
412 else if (!strcmp (sec_name, _LOADER))
413 {
414 styp_flags = STYP_LOADER;
415 }
416#endif
417 /* Try and figure out what it should be */
418 else if (sec_flags & SEC_CODE)
419 {
420 styp_flags = STYP_TEXT;
421 }
422 else if (sec_flags & SEC_DATA)
423 {
424 styp_flags = STYP_DATA;
425 }
426 else if (sec_flags & SEC_READONLY)
427 {
428#ifdef STYP_LIT /* 29k readonly text/data section */
429 styp_flags = STYP_LIT;
430#else
431 styp_flags = STYP_TEXT;
432#endif /* STYP_LIT */
433 }
434 else if (sec_flags & SEC_LOAD)
435 {
436 styp_flags = STYP_TEXT;
437 }
438 else if (sec_flags & SEC_ALLOC)
439 {
440 styp_flags = STYP_BSS;
441 }
442
34cbe64e
TW		 443#ifdef STYP_CLINK
444 if (sec_flags & SEC_CLINK)
445 styp_flags |= STYP_CLINK;
446#endif
447
448#ifdef STYP_BLOCK
449 if (sec_flags & SEC_BLOCK)
450 styp_flags |= STYP_BLOCK;
451#endif
452
252b5132
RH		 453#ifdef STYP_NOLOAD
454 if ((sec_flags & (SEC_NEVER_LOAD | SEC_COFF_SHARED_LIBRARY)) != 0)
455 styp_flags |= STYP_NOLOAD;
456#endif
457
41733515
ILT		 458 return styp_flags;
459}
460
461#else /* COFF_WITH_PE */
462
463/* The PE version; see above for the general comments. The non-PE
464 case seems to be more guessing, and breaks PE format; specifically,
465 .rdata is readonly, but it sure ain't text. Really, all this
466 should be set up properly in gas (or whatever assembler is in use),
467 and honor whatever objcopy/strip, etc. sent us as input. */
468
469static long
470sec_to_styp_flags (sec_name, sec_flags)
471 const char *sec_name ATTRIBUTE_UNUSED;
472 flagword sec_flags;
473{
474 long styp_flags = 0;
475
476 /* caution: there are at least three groups of symbols that have
477 very similar bits and meanings: IMAGE_SCN*, SEC_*, and STYP_*.
478 SEC_* are the BFD internal flags, used for generic BFD
479 information. STYP_* are the COFF section flags which appear in
480 COFF files. IMAGE_SCN_* are the PE section flags which appear in
481 PE files. The STYP_* flags and the IMAGE_SCN_* flags overlap,
482 but there are more IMAGE_SCN_* flags. */
483
484 /* skip LOAD */
485 /* READONLY later */
486 /* skip RELOC */
487 if ((sec_flags & SEC_CODE) != 0)
488 styp_flags |= IMAGE_SCN_CNT_CODE;
489 if ((sec_flags & SEC_DATA) != 0)
490 styp_flags |= IMAGE_SCN_CNT_INITIALIZED_DATA;
491 if ((sec_flags & SEC_ALLOC) != 0 && (sec_flags & SEC_LOAD) == 0)
492 styp_flags |= IMAGE_SCN_CNT_UNINITIALIZED_DATA; /* ==STYP_BSS */
493 /* skip ROM */
494 /* skip CONSTRUCTOR */
495 /* skip CONTENTS */
496#ifdef STYP_NOLOAD
497 if ((sec_flags & (SEC_NEVER_LOAD | SEC_COFF_SHARED_LIBRARY)) != 0)
498 styp_flags |= STYP_NOLOAD;
499#endif
500 if ((sec_flags & SEC_IS_COMMON) != 0)
252b5132 501 styp_flags |= IMAGE_SCN_LNK_COMDAT;
41733515
ILT		 502 if ((sec_flags & SEC_DEBUGGING) != 0)
503 styp_flags |= IMAGE_SCN_MEM_DISCARDABLE;
504 if ((sec_flags & SEC_EXCLUDE) != 0)
505 styp_flags |= IMAGE_SCN_LNK_REMOVE;
506 if ((sec_flags & SEC_NEVER_LOAD) != 0)
507 styp_flags |= IMAGE_SCN_LNK_REMOVE;
508 /* skip IN_MEMORY */
509 /* skip SORT */
510 if (sec_flags & SEC_LINK_ONCE)
511 styp_flags |= IMAGE_SCN_LNK_COMDAT;
512 /* skip LINK_DUPLICATES */
513 /* skip LINKER_CREATED */
514
515 /* For now, the read/write bits are mapped onto SEC_READONLY, even
516 though the semantics don't quite match. The bits from the input
517 are retained in pei_section_data(abfd, section)->pe_flags */
518
519 styp_flags |= IMAGE_SCN_MEM_READ; /* always readable. */
520 if ((sec_flags & SEC_READONLY) == 0)
521 styp_flags |= IMAGE_SCN_MEM_WRITE; /* Invert READONLY for write */
522 if (sec_flags & SEC_CODE)
523 styp_flags |= IMAGE_SCN_MEM_EXECUTE; /* CODE->EXECUTE */
bd826630 524 if (sec_flags & SEC_SHARED)
41733515 525 styp_flags |= IMAGE_SCN_MEM_SHARED; /* Shared remains meaningful */
252b5132 526
41733515 527 return styp_flags;
252b5132 528}
41733515
ILT		 529
530#endif /* COFF_WITH_PE */
531
532/* Return a word with SEC_* flags set to represent the incoming STYP_*
533 flags (from scnhdr.s_flags). The inverse of this function is
534 sec_to_styp_flags(). NOTE: If you add to/change this routine, you
535 should probably mirror the changes in sec_to_styp_flags(). */
536
537#ifndef COFF_WITH_PE
538
252b5132 539static flagword
41733515 540styp_to_sec_flags (abfd, hdr, name, section)
5f771d47 541 bfd *abfd ATTRIBUTE_UNUSED;
252b5132
RH		 542 PTR hdr;
543 const char *name;
41733515 544 asection *section ATTRIBUTE_UNUSED;
252b5132
RH		 545{
546 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
547 long styp_flags = internal_s->s_flags;
548 flagword sec_flags = 0;
549
34cbe64e
TW		 550#ifdef STYP_BLOCK
551 if (styp_flags & STYP_BLOCK)
552 sec_flags |= SEC_BLOCK;
553#endif
554
555#ifdef STYP_CLINK
556 if (styp_flags & STYP_CLINK)
557 sec_flags |= SEC_CLINK;
558#endif
559
252b5132
RH		 560#ifdef STYP_NOLOAD
561 if (styp_flags & STYP_NOLOAD)
562 {
563 sec_flags |= SEC_NEVER_LOAD;
564 }
565#endif /* STYP_NOLOAD */
566
567 /* For 386 COFF, at least, an unloadable text or data section is
568 actually a shared library section. */
569 if (styp_flags & STYP_TEXT)
570 {
571 if (sec_flags & SEC_NEVER_LOAD)
572 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
573 else
574 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
575 }
576 else if (styp_flags & STYP_DATA)
577 {
578 if (sec_flags & SEC_NEVER_LOAD)
579 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
580 else
581 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
582 }
583 else if (styp_flags & STYP_BSS)
584 {
585#ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
586 if (sec_flags & SEC_NEVER_LOAD)
587 sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
588 else
589#endif
590 sec_flags |= SEC_ALLOC;
591 }
592 else if (styp_flags & STYP_INFO)
593 {
594 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
595 defined. coff_compute_section_file_positions uses
596 COFF_PAGE_SIZE to ensure that the low order bits of the
597 section VMA and the file offset match. If we don't know
598 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
599 and demand page loading of the file will fail. */
600#if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
601 sec_flags |= SEC_DEBUGGING;
602#endif
603 }
604 else if (styp_flags & STYP_PAD)
605 {
606 sec_flags = 0;
607 }
608 else if (strcmp (name, _TEXT) == 0)
609 {
610 if (sec_flags & SEC_NEVER_LOAD)
611 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
612 else
613 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
614 }
615 else if (strcmp (name, _DATA) == 0)
616 {
617 if (sec_flags & SEC_NEVER_LOAD)
618 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
619 else
620 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
621 }
622 else if (strcmp (name, _BSS) == 0)
623 {
624#ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
625 if (sec_flags & SEC_NEVER_LOAD)
626 sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
627 else
628#endif
629 sec_flags |= SEC_ALLOC;
630 }
631 else if (strcmp (name, ".debug") == 0
632#ifdef _COMMENT
633 || strcmp (name, _COMMENT) == 0
634#endif
635 || strncmp (name, ".stab", 5) == 0)
636 {
637#ifdef COFF_PAGE_SIZE
638 sec_flags |= SEC_DEBUGGING;
639#endif
640 }
641#ifdef _LIB
642 else if (strcmp (name, _LIB) == 0)
643 ;
644#endif
645#ifdef _LIT
646 else if (strcmp (name, _LIT) == 0)
647 {
648 sec_flags = SEC_LOAD | SEC_ALLOC | SEC_READONLY;
649 }
650#endif
651 else
652 {
653 sec_flags |= SEC_ALLOC | SEC_LOAD;
654 }
655
656#ifdef STYP_LIT /* A29k readonly text/data section type */
657 if ((styp_flags & STYP_LIT) == STYP_LIT)
658 {
659 sec_flags = (SEC_LOAD | SEC_ALLOC | SEC_READONLY);
660 }
661#endif /* STYP_LIT */
662#ifdef STYP_OTHER_LOAD /* Other loaded sections */
663 if (styp_flags & STYP_OTHER_LOAD)
664 {
665 sec_flags = (SEC_LOAD | SEC_ALLOC);
666 }
667#endif /* STYP_SDATA */
668
41733515
ILT		 669#if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
670 /* As a GNU extension, if the name begins with .gnu.linkonce, we
671 only link a single copy of the section. This is used to support
672 g++. g++ will emit each template expansion in its own section.
673 The symbols will be defined as weak, so that multiple definitions
674 are permitted. The GNU linker extension is to actually discard
675 all but one of the sections. */
676 if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
677 sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
678#endif
679
680 return sec_flags;
681}
682
683#else /* COFF_WITH_PE */
684
685/* The PE version; see above for the general comments.
686
687 Since to set the SEC_LINK_ONCE and associated flags, we have to
688 look at the symbol table anyway, we return the symbol table index
689 of the symbol being used as the COMDAT symbol. This is admittedly
690 ugly, but there's really nowhere else that we have access to the
691 required information. FIXME: Is the COMDAT symbol index used for
692 any purpose other than objdump? */
693
694static flagword
695styp_to_sec_flags (abfd, hdr, name, section)
696 bfd *abfd ATTRIBUTE_UNUSED;
697 PTR hdr;
698 const char *name;
699 asection *section;
700{
701 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
702 long styp_flags = internal_s->s_flags;
703 flagword sec_flags = 0;
704
705 if (styp_flags & STYP_DSECT)
706 abort (); /* Don't know what to do */
707#ifdef SEC_NEVER_LOAD
708 if (styp_flags & STYP_NOLOAD)
709 sec_flags |= SEC_NEVER_LOAD;
710#endif
711 if (styp_flags & STYP_GROUP)
712 abort (); /* Don't know what to do */
713 /* skip IMAGE_SCN_TYPE_NO_PAD */
714 if (styp_flags & STYP_COPY)
715 abort (); /* Don't know what to do */
716 if (styp_flags & IMAGE_SCN_CNT_CODE)
717 sec_flags |= SEC_CODE | SEC_ALLOC | SEC_LOAD;
718 if (styp_flags & IMAGE_SCN_CNT_INITIALIZED_DATA)
719 sec_flags |= SEC_DATA | SEC_ALLOC | SEC_LOAD;
720 if (styp_flags & IMAGE_SCN_CNT_UNINITIALIZED_DATA)
721 sec_flags |= SEC_ALLOC;
722 if (styp_flags & IMAGE_SCN_LNK_OTHER)
723 abort (); /* Don't know what to do */
724 if (styp_flags & IMAGE_SCN_LNK_INFO)
725 {
726 /* We mark these as SEC_DEBUGGING, but only if COFF_PAGE_SIZE is
727 defined. coff_compute_section_file_positions uses
728 COFF_PAGE_SIZE to ensure that the low order bits of the
729 section VMA and the file offset match. If we don't know
730 COFF_PAGE_SIZE, we can't ensure the correct correspondence,
731 and demand page loading of the file will fail. */
732#ifdef COFF_PAGE_SIZE
733 sec_flags |= SEC_DEBUGGING;
734#endif
735 }
736 if (styp_flags & STYP_OVER)
737 abort (); /* Don't know what to do */
252b5132
RH		 738 if (styp_flags & IMAGE_SCN_LNK_REMOVE)
739 sec_flags |= SEC_EXCLUDE;
740
bd826630
ILT		 741 if (styp_flags & IMAGE_SCN_MEM_SHARED)
742 sec_flags |= SEC_SHARED;
41733515
ILT		 743 /* COMDAT: see below */
744 if (styp_flags & IMAGE_SCN_MEM_DISCARDABLE)
745 sec_flags |= SEC_DEBUGGING;
746 if (styp_flags & IMAGE_SCN_MEM_NOT_CACHED)
747 abort ();/* Don't know what to do */
748 if (styp_flags & IMAGE_SCN_MEM_NOT_PAGED)
749 abort (); /* Don't know what to do */
750
751 /* We infer from the distinct read/write/execute bits the settings
752 of some of the bfd flags; the actual values, should we need them,
753 are also in pei_section_data (abfd, section)->pe_flags. */
754
755 if (styp_flags & IMAGE_SCN_MEM_EXECUTE)
756 sec_flags |= SEC_CODE; /* Probably redundant */
757 /* IMAGE_SCN_MEM_READ is simply ignored, assuming it always to be true. */
758 if ((styp_flags & IMAGE_SCN_MEM_WRITE) == 0)
759 sec_flags |= SEC_READONLY;
760
761 /* COMDAT gets very special treatment. */
252b5132
RH		 762 if (styp_flags & IMAGE_SCN_LNK_COMDAT)
763 {
764 sec_flags |= SEC_LINK_ONCE;
765
766 /* Unfortunately, the PE format stores essential information in
767 the symbol table, of all places. We need to extract that
768 information now, so that objdump and the linker will know how
769 to handle the section without worrying about the symbols. We
770 can't call slurp_symtab, because the linker doesn't want the
771 swapped symbols. */
772
ec0ef80e
DD		 773 /* COMDAT sections are special. The first symbol is the section
774 symbol, which tells what kind of COMDAT section it is. The
41733515 775 second symbol is the "comdat symbol" - the one with the
ec0ef80e
DD		 776 unique name. GNU uses the section symbol for the unique
777 name; MS uses ".text" for every comdat section. Sigh. - DJ */
778
41733515
ILT		 779 /* This is not mirrored in sec_to_styp_flags(), but there
780 doesn't seem to be a need to, either, and it would at best be
781 rather messy. */
782
252b5132
RH		 783 if (_bfd_coff_get_external_symbols (abfd))
784 {
41733515 785 bfd_byte *esymstart, *esym, *esymend;
e5db213d 786 int seen_state = 0;
86033394 787 char *target_name = NULL;
252b5132 788
41733515 789 esymstart = esym = (bfd_byte *) obj_coff_external_syms (abfd);
6b3b007b 790 esymend = esym + obj_raw_syment_count (abfd) * bfd_coff_symesz (abfd);
252b5132
RH		 791
792 while (esym < esymend)
793 {
794 struct internal_syment isym;
41733515
ILT		 795 char buf[SYMNMLEN + 1];
796 const char *symname;
252b5132
RH		 797
798 bfd_coff_swap_sym_in (abfd, (PTR) esym, (PTR) &isym);
799
800 if (sizeof (internal_s->s_name) > SYMNMLEN)
801 {
802 /* This case implies that the matching symbol name
803 will be in the string table. */
804 abort ();
805 }
806
e5db213d 807 if (isym.n_scnum == section->target_index)
252b5132 808 {
e5db213d
ILT		 809 /* According to the MSVC documentation, the first
810 TWO entries with the section # are both of
811 interest to us. The first one is the "section
41733515 812 symbol" (section name). The second is the comdat
e5db213d
ILT		 813 symbol name. Here, we've found the first
814 qualifying entry; we distinguish it from the
815 second with a state flag.
252b5132 816
e5db213d
ILT		 817 In the case of gas-generated (at least until that
818 is fixed) .o files, it isn't necessarily the
819 second one. It may be some other later symbol.
41733515 820
e5db213d
ILT		 821 Since gas also doesn't follow MS conventions and
822 emits the section similar to .text$<name>, where
823 <something> is the name we're looking for, we
824 distinguish the two as follows:
41733515 825
e5db213d
ILT		 826 If the section name is simply a section name (no
827 $) we presume it's MS-generated, and look at
828 precisely the second symbol for the comdat name.
829 If the section name has a $, we assume it's
830 gas-generated, and look for <something> (whatever
831 follows the $) as the comdat symbol. */
252b5132 832
e5db213d
ILT		 833 /* All 3 branches use this */
834 symname = _bfd_coff_internal_syment_name (abfd, &isym, buf);
252b5132 835
e5db213d
ILT		 836 if (symname == NULL)
837 abort ();
ec0ef80e 838
e5db213d
ILT		 839 switch (seen_state)
840 {
841 case 0:
842 {
843 /* The first time we've seen the symbol. */
844 union internal_auxent aux;
845
846 seen_state = 1;
847
848 /* If it isn't the stuff we're expecting, die;
849 The MS documentation is vague, but it
850 appears that the second entry serves BOTH
851 as the comdat symbol and the defining
852 symbol record (either C_STAT or C_EXT,
853 possibly with an aux entry with debug
854 information if it's a function.) It
855 appears the only way to find the second one
856 is to count. (On Intel, they appear to be
857 adjacent, but on Alpha, they have been
858 found separated.)
859
860 Here, we think we've found the first one,
861 but there's some checking we can do to be
862 sure. */
863
864 if (! (isym.n_sclass == C_STAT
865 && isym.n_type == T_NULL
866 && isym.n_value == 0))
867 abort ();
868
869 /* FIXME LATER: MSVC generates section names
870 like .text for comdats. Gas generates
871 names like .text$foo__Fv (in the case of a
872 function). See comment above for more. */
873
874 if (strcmp (name, symname) != 0)
875 abort ();
876
877 /* This is the section symbol. */
878
6b3b007b 879 bfd_coff_swap_aux_in (abfd, (PTR) (esym + bfd_coff_symesz (abfd)),
e5db213d
ILT		 880 isym.n_type, isym.n_sclass,
881 0, isym.n_numaux, (PTR) &aux);
882
883 target_name = strchr (name, '$');
884 if (target_name != NULL)
885 {
886 /* Gas mode. */
887 seen_state = 2;
888 /* Skip the `$'. */
889 target_name += 1;
890 }
891
892 /* FIXME: Microsoft uses NODUPLICATES and
893 ASSOCIATIVE, but gnu uses ANY and
894 SAME_SIZE. Unfortunately, gnu doesn't do
895 the comdat symbols right. So, until we can
896 fix it to do the right thing, we are
897 temporarily disabling comdats for the MS
898 types (they're used in DLLs and C++, but we
899 don't support *their* C++ libraries anyway
900 - DJ. */
901
902 /* Cygwin does not follow the MS style, and
903 uses ANY and SAME_SIZE where NODUPLICATES
904 and ASSOCIATIVE should be used. For
905 Interix, we just do the right thing up
906 front. */
907
908 switch (aux.x_scn.x_comdat)
909 {
910 case IMAGE_COMDAT_SELECT_NODUPLICATES:
911#ifdef STRICT_PE_FORMAT
912 sec_flags |= SEC_LINK_DUPLICATES_ONE_ONLY;
ec0ef80e 913#else
e5db213d 914 sec_flags &= ~SEC_LINK_ONCE;
ec0ef80e 915#endif
e5db213d 916 break;
252b5132 917
e5db213d
ILT		 918 case IMAGE_COMDAT_SELECT_ANY:
919 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
920 break;
252b5132 921
e5db213d
ILT		 922 case IMAGE_COMDAT_SELECT_SAME_SIZE:
923 sec_flags |= SEC_LINK_DUPLICATES_SAME_SIZE;
924 break;
252b5132 925
e5db213d
ILT		 926 case IMAGE_COMDAT_SELECT_EXACT_MATCH:
927 /* Not yet fully implemented ??? */
928 sec_flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS;
929 break;
252b5132 930
e5db213d
ILT		 931 /* debug$S gets this case; other
932 implications ??? */
933
934 /* There may be no symbol... we'll search
935 the whole table... Is this the right
936 place to play this game? Or should we do
937 it when reading it in. */
938 case IMAGE_COMDAT_SELECT_ASSOCIATIVE:
0717ebb7 939#ifdef STRICT_PE_FORMAT
e5db213d
ILT		 940 /* FIXME: This is not currently implemented. */
941 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
ec0ef80e 942#else
e5db213d 943 sec_flags &= ~SEC_LINK_ONCE;
ec0ef80e 944#endif
e5db213d
ILT		 945 break;
946
947 default: /* 0 means "no symbol" */
948 /* debug$F gets this case; other
949 implications ??? */
950 sec_flags |= SEC_LINK_DUPLICATES_DISCARD;
951 break;
952 }
953 }
954 break;
41733515 955
e5db213d
ILT		 956 case 2:
957 /* Gas mode: the first matching on partial name. */
252b5132 958
e5db213d
ILT		 959#ifndef TARGET_UNDERSCORE
960#define TARGET_UNDERSCORE 0
961#endif
962 /* Is this the name we're looking for? */
963 if (strcmp (target_name,
964 symname + (TARGET_UNDERSCORE ? 1 : 0)) != 0)
965 {
966 /* Not the name we're looking for */
6b3b007b 967 esym += (isym.n_numaux + 1) * bfd_coff_symesz (abfd);
e5db213d
ILT		 968 continue;
969 }
970 /* Fall through. */
971 case 1:
972 /* MSVC mode: the lexically second symbol (or
973 drop through from the above). */
974 {
975 char *newname;
976
977 /* This must the the second symbol with the
978 section #. It is the actual symbol name.
979 Intel puts the two adjacent, but Alpha (at
980 least) spreads them out. */
981
982 section->comdat =
983 bfd_alloc (abfd, sizeof (struct bfd_comdat_info));
984 if (section->comdat == NULL)
985 abort ();
986 section->comdat->symbol =
6b3b007b 987 (esym - esymstart) / bfd_coff_symesz (abfd);
e5db213d
ILT		 988
989 newname = bfd_alloc (abfd, strlen (symname) + 1);
990 if (newname == NULL)
991 abort ();
992
993 strcpy (newname, symname);
994 section->comdat->name = newname;
995
996 }
997
998 goto breakloop;
252b5132
RH		 999 }
1000 }
1001
6b3b007b 1002 esym += (isym.n_numaux + 1) * bfd_coff_symesz (abfd);
252b5132 1003 }
e5db213d 1004 breakloop:
252b5132
RH		 1005 }
1006 }
252b5132 1007
242eabea
ILT		 1008#if defined (COFF_LONG_SECTION_NAMES) && defined (COFF_SUPPORT_GNU_LINKONCE)
1009 /* As a GNU extension, if the name begins with .gnu.linkonce, we
1010 only link a single copy of the section. This is used to support
1011 g++. g++ will emit each template expansion in its own section.
1012 The symbols will be defined as weak, so that multiple definitions
1013 are permitted. The GNU linker extension is to actually discard
1014 all but one of the sections. */
1015 if (strncmp (name, ".gnu.linkonce", sizeof ".gnu.linkonce" - 1) == 0)
1016 sec_flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
1017#endif
1018
41733515 1019 return sec_flags;
252b5132
RH		 1020}
1021
41733515
ILT		 1022#endif /* COFF_WITH_PE */
1023
252b5132
RH		 1024#define get_index(symbol) ((symbol)->udata.i)
1025
1026/*
1027INTERNAL_DEFINITION
1028 bfd_coff_backend_data
1029
1030CODE_FRAGMENT
1031
5d54c628
ILT		 1032.{* COFF symbol classifications. *}
1033.
1034.enum coff_symbol_classification
1035.{
1036. {* Global symbol. *}
1037. COFF_SYMBOL_GLOBAL,
1038. {* Common symbol. *}
1039. COFF_SYMBOL_COMMON,
1040. {* Undefined symbol. *}
1041. COFF_SYMBOL_UNDEFINED,
1042. {* Local symbol. *}
1043. COFF_SYMBOL_LOCAL,
1044. {* PE section symbol. *}
1045. COFF_SYMBOL_PE_SECTION
1046.};
1047.
252b5132
RH		 1048Special entry points for gdb to swap in coff symbol table parts:
1049.typedef struct
1050.{
1051. void (*_bfd_coff_swap_aux_in) PARAMS ((
1052. bfd *abfd,
1053. PTR ext,
1054. int type,
1055. int class,
1056. int indaux,
1057. int numaux,
1058. PTR in));
1059.
1060. void (*_bfd_coff_swap_sym_in) PARAMS ((
1061. bfd *abfd ,
1062. PTR ext,
1063. PTR in));
1064.
1065. void (*_bfd_coff_swap_lineno_in) PARAMS ((
1066. bfd *abfd,
1067. PTR ext,
1068. PTR in));
1069.
1070
1071Special entry points for gas to swap out coff parts:
1072
1073. unsigned int (*_bfd_coff_swap_aux_out) PARAMS ((
1074. bfd *abfd,
1075. PTR in,
1076. int type,
1077. int class,
1078. int indaux,
1079. int numaux,
1080. PTR ext));
1081.
1082. unsigned int (*_bfd_coff_swap_sym_out) PARAMS ((
1083. bfd *abfd,
1084. PTR in,
1085. PTR ext));
1086.
1087. unsigned int (*_bfd_coff_swap_lineno_out) PARAMS ((
1088. bfd *abfd,
1089. PTR in,
1090. PTR ext));
1091.
1092. unsigned int (*_bfd_coff_swap_reloc_out) PARAMS ((
1093. bfd *abfd,
1094. PTR src,
1095. PTR dst));
1096.
1097. unsigned int (*_bfd_coff_swap_filehdr_out) PARAMS ((
1098. bfd *abfd,
1099. PTR in,
1100. PTR out));
1101.
1102. unsigned int (*_bfd_coff_swap_aouthdr_out) PARAMS ((
1103. bfd *abfd,
1104. PTR in,
1105. PTR out));
1106.
1107. unsigned int (*_bfd_coff_swap_scnhdr_out) PARAMS ((
1108. bfd *abfd,
1109. PTR in,
1110. PTR out));
1111.
1112
1113Special entry points for generic COFF routines to call target
1114dependent COFF routines:
1115
1116. unsigned int _bfd_filhsz;
1117. unsigned int _bfd_aoutsz;
1118. unsigned int _bfd_scnhsz;
1119. unsigned int _bfd_symesz;
1120. unsigned int _bfd_auxesz;
1121. unsigned int _bfd_relsz;
1122. unsigned int _bfd_linesz;
692b7d62 1123. unsigned int _bfd_filnmlen;
252b5132
RH		 1124. boolean _bfd_coff_long_filenames;
1125. boolean _bfd_coff_long_section_names;
1126. unsigned int _bfd_coff_default_section_alignment_power;
2243c419
CP		 1127. boolean _bfd_coff_force_symnames_in_strings;
1128. unsigned int _bfd_coff_debug_string_prefix_length;
252b5132
RH		 1129. void (*_bfd_coff_swap_filehdr_in) PARAMS ((
1130. bfd *abfd,
1131. PTR ext,
1132. PTR in));
1133. void (*_bfd_coff_swap_aouthdr_in) PARAMS ((
1134. bfd *abfd,
1135. PTR ext,
1136. PTR in));
1137. void (*_bfd_coff_swap_scnhdr_in) PARAMS ((
1138. bfd *abfd,
1139. PTR ext,
1140. PTR in));
1141. void (*_bfd_coff_swap_reloc_in) PARAMS ((
1142. bfd *abfd,
1143. PTR ext,
1144. PTR in));
1145. boolean (*_bfd_coff_bad_format_hook) PARAMS ((
1146. bfd *abfd,
1147. PTR internal_filehdr));
1148. boolean (*_bfd_coff_set_arch_mach_hook) PARAMS ((
1149. bfd *abfd,
1150. PTR internal_filehdr));
1151. PTR (*_bfd_coff_mkobject_hook) PARAMS ((
1152. bfd *abfd,
1153. PTR internal_filehdr,
1154. PTR internal_aouthdr));
1155. flagword (*_bfd_styp_to_sec_flags_hook) PARAMS ((
1156. bfd *abfd,
1157. PTR internal_scnhdr,
41733515
ILT		 1158. const char *name,
1159. asection *section));
252b5132
RH		 1160. void (*_bfd_set_alignment_hook) PARAMS ((
1161. bfd *abfd,
1162. asection *sec,
1163. PTR internal_scnhdr));
1164. boolean (*_bfd_coff_slurp_symbol_table) PARAMS ((
1165. bfd *abfd));
1166. boolean (*_bfd_coff_symname_in_debug) PARAMS ((
1167. bfd *abfd,
1168. struct internal_syment *sym));
1169. boolean (*_bfd_coff_pointerize_aux_hook) PARAMS ((
1170. bfd *abfd,
1171. combined_entry_type *table_base,
1172. combined_entry_type *symbol,
1173. unsigned int indaux,
1174. combined_entry_type *aux));
1175. boolean (*_bfd_coff_print_aux) PARAMS ((
1176. bfd *abfd,
1177. FILE *file,
1178. combined_entry_type *table_base,
1179. combined_entry_type *symbol,
1180. combined_entry_type *aux,
1181. unsigned int indaux));
1182. void (*_bfd_coff_reloc16_extra_cases) PARAMS ((
1183. bfd *abfd,
1184. struct bfd_link_info *link_info,
1185. struct bfd_link_order *link_order,
1186. arelent *reloc,
1187. bfd_byte *data,
1188. unsigned int *src_ptr,
1189. unsigned int *dst_ptr));
1190. int (*_bfd_coff_reloc16_estimate) PARAMS ((
1191. bfd *abfd,
1192. asection *input_section,
1193. arelent *r,
1194. unsigned int shrink,
1195. struct bfd_link_info *link_info));
5d54c628 1196. enum coff_symbol_classification (*_bfd_coff_classify_symbol) PARAMS ((
252b5132
RH		 1197. bfd *abfd,
1198. struct internal_syment *));
1199. boolean (*_bfd_coff_compute_section_file_positions) PARAMS ((
1200. bfd *abfd));
1201. boolean (*_bfd_coff_start_final_link) PARAMS ((
1202. bfd *output_bfd,
1203. struct bfd_link_info *info));
1204. boolean (*_bfd_coff_relocate_section) PARAMS ((
1205. bfd *output_bfd,
1206. struct bfd_link_info *info,
1207. bfd *input_bfd,
1208. asection *input_section,
1209. bfd_byte *contents,
1210. struct internal_reloc *relocs,
1211. struct internal_syment *syms,
1212. asection **sections));
1213. reloc_howto_type *(*_bfd_coff_rtype_to_howto) PARAMS ((
1214. bfd *abfd,
1215. asection *sec,
1216. struct internal_reloc *rel,
1217. struct coff_link_hash_entry *h,
1218. struct internal_syment *sym,
1219. bfd_vma *addendp));
1220. boolean (*_bfd_coff_adjust_symndx) PARAMS ((
1221. bfd *obfd,
1222. struct bfd_link_info *info,
1223. bfd *ibfd,
1224. asection *sec,
1225. struct internal_reloc *reloc,
1226. boolean *adjustedp));
1227. boolean (*_bfd_coff_link_add_one_symbol) PARAMS ((
1228. struct bfd_link_info *info,
1229. bfd *abfd,
1230. const char *name,
1231. flagword flags,
1232. asection *section,
1233. bfd_vma value,
1234. const char *string,
1235. boolean copy,
1236. boolean collect,
1237. struct bfd_link_hash_entry **hashp));
1238.
1239. boolean (*_bfd_coff_link_output_has_begun) PARAMS ((
1240. bfd * abfd,
1241. struct coff_final_link_info * pfinfo));
1242. boolean (*_bfd_coff_final_link_postscript) PARAMS ((
1243. bfd * abfd,
1244. struct coff_final_link_info * pfinfo));
1245.
1246.} bfd_coff_backend_data;
1247.
1248.#define coff_backend_info(abfd) ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
1249.
1250.#define bfd_coff_swap_aux_in(a,e,t,c,ind,num,i) \
1251. ((coff_backend_info (a)->_bfd_coff_swap_aux_in) (a,e,t,c,ind,num,i))
1252.
1253.#define bfd_coff_swap_sym_in(a,e,i) \
1254. ((coff_backend_info (a)->_bfd_coff_swap_sym_in) (a,e,i))
1255.
1256.#define bfd_coff_swap_lineno_in(a,e,i) \
1257. ((coff_backend_info ( a)->_bfd_coff_swap_lineno_in) (a,e,i))
1258.
1259.#define bfd_coff_swap_reloc_out(abfd, i, o) \
1260. ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_out) (abfd, i, o))
1261.
1262.#define bfd_coff_swap_lineno_out(abfd, i, o) \
1263. ((coff_backend_info (abfd)->_bfd_coff_swap_lineno_out) (abfd, i, o))
1264.
1265.#define bfd_coff_swap_aux_out(a,i,t,c,ind,num,o) \
1266. ((coff_backend_info (a)->_bfd_coff_swap_aux_out) (a,i,t,c,ind,num,o))
1267.
1268.#define bfd_coff_swap_sym_out(abfd, i,o) \
1269. ((coff_backend_info (abfd)->_bfd_coff_swap_sym_out) (abfd, i, o))
1270.
1271.#define bfd_coff_swap_scnhdr_out(abfd, i,o) \
1272. ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_out) (abfd, i, o))
1273.
1274.#define bfd_coff_swap_filehdr_out(abfd, i,o) \
1275. ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_out) (abfd, i, o))
1276.
1277.#define bfd_coff_swap_aouthdr_out(abfd, i,o) \
1278. ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_out) (abfd, i, o))
1279.
1280.#define bfd_coff_filhsz(abfd) (coff_backend_info (abfd)->_bfd_filhsz)
1281.#define bfd_coff_aoutsz(abfd) (coff_backend_info (abfd)->_bfd_aoutsz)
1282.#define bfd_coff_scnhsz(abfd) (coff_backend_info (abfd)->_bfd_scnhsz)
1283.#define bfd_coff_symesz(abfd) (coff_backend_info (abfd)->_bfd_symesz)
1284.#define bfd_coff_auxesz(abfd) (coff_backend_info (abfd)->_bfd_auxesz)
1285.#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
1286.#define bfd_coff_linesz(abfd) (coff_backend_info (abfd)->_bfd_linesz)
692b7d62 1287.#define bfd_coff_filnmlen(abfd) (coff_backend_info (abfd)->_bfd_filnmlen)
252b5132
RH		 1288.#define bfd_coff_long_filenames(abfd) (coff_backend_info (abfd)->_bfd_coff_long_filenames)
1289.#define bfd_coff_long_section_names(abfd) \
1290. (coff_backend_info (abfd)->_bfd_coff_long_section_names)
1291.#define bfd_coff_default_section_alignment_power(abfd) \
1292. (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
1293.#define bfd_coff_swap_filehdr_in(abfd, i,o) \
1294. ((coff_backend_info (abfd)->_bfd_coff_swap_filehdr_in) (abfd, i, o))
1295.
1296.#define bfd_coff_swap_aouthdr_in(abfd, i,o) \
1297. ((coff_backend_info (abfd)->_bfd_coff_swap_aouthdr_in) (abfd, i, o))
1298.
1299.#define bfd_coff_swap_scnhdr_in(abfd, i,o) \
1300. ((coff_backend_info (abfd)->_bfd_coff_swap_scnhdr_in) (abfd, i, o))
1301.
1302.#define bfd_coff_swap_reloc_in(abfd, i, o) \
1303. ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
1304.
1305.#define bfd_coff_bad_format_hook(abfd, filehdr) \
1306. ((coff_backend_info (abfd)->_bfd_coff_bad_format_hook) (abfd, filehdr))
1307.
1308.#define bfd_coff_set_arch_mach_hook(abfd, filehdr)\
1309. ((coff_backend_info (abfd)->_bfd_coff_set_arch_mach_hook) (abfd, filehdr))
1310.#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
1311. ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook) (abfd, filehdr, aouthdr))
1312.
41733515
ILT		 1313.#define bfd_coff_styp_to_sec_flags_hook(abfd, scnhdr, name, section)\
1314. ((coff_backend_info (abfd)->_bfd_styp_to_sec_flags_hook)\
1315. (abfd, scnhdr, name, section))
252b5132
RH		 1316.
1317.#define bfd_coff_set_alignment_hook(abfd, sec, scnhdr)\
1318. ((coff_backend_info (abfd)->_bfd_set_alignment_hook) (abfd, sec, scnhdr))
1319.
1320.#define bfd_coff_slurp_symbol_table(abfd)\
1321. ((coff_backend_info (abfd)->_bfd_coff_slurp_symbol_table) (abfd))
1322.
1323.#define bfd_coff_symname_in_debug(abfd, sym)\
1324. ((coff_backend_info (abfd)->_bfd_coff_symname_in_debug) (abfd, sym))
1325.
2243c419
CP		 1326.#define bfd_coff_force_symnames_in_strings(abfd)\
1327. (coff_backend_info (abfd)->_bfd_coff_force_symnames_in_strings)
1328.
1329.#define bfd_coff_debug_string_prefix_length(abfd)\
1330. (coff_backend_info (abfd)->_bfd_coff_debug_string_prefix_length)
1331.
252b5132
RH		 1332.#define bfd_coff_print_aux(abfd, file, base, symbol, aux, indaux)\
1333. ((coff_backend_info (abfd)->_bfd_coff_print_aux)\
1334. (abfd, file, base, symbol, aux, indaux))
1335.
1336.#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)\
1337. ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
1338. (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
1339.
1340.#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
1341. ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
1342. (abfd, section, reloc, shrink, link_info))
1343.
5d54c628
ILT		 1344.#define bfd_coff_classify_symbol(abfd, sym)\
1345. ((coff_backend_info (abfd)->_bfd_coff_classify_symbol)\
252b5132
RH		 1346. (abfd, sym))
1347.
1348.#define bfd_coff_compute_section_file_positions(abfd)\
1349. ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
1350. (abfd))
1351.
1352.#define bfd_coff_start_final_link(obfd, info)\
1353. ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
1354. (obfd, info))
1355.#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
1356. ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
1357. (obfd, info, ibfd, o, con, rel, isyms, secs))
1358.#define bfd_coff_rtype_to_howto(abfd, sec, rel, h, sym, addendp)\
1359. ((coff_backend_info (abfd)->_bfd_coff_rtype_to_howto)\
1360. (abfd, sec, rel, h, sym, addendp))
1361.#define bfd_coff_adjust_symndx(obfd, info, ibfd, sec, rel, adjustedp)\
1362. ((coff_backend_info (abfd)->_bfd_coff_adjust_symndx)\
1363. (obfd, info, ibfd, sec, rel, adjustedp))
1364.#define bfd_coff_link_add_one_symbol(info,abfd,name,flags,section,value,string,cp,coll,hashp)\
1365. ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
1366. (info, abfd, name, flags, section, value, string, cp, coll, hashp))
1367.
1368.#define bfd_coff_link_output_has_begun(a,p) \
1369. ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a,p))
1370.#define bfd_coff_final_link_postscript(a,p) \
1371. ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a,p))
1372.
1373*/
1374
1375/* See whether the magic number matches. */
1376
1377static boolean
1378coff_bad_format_hook (abfd, filehdr)
5f771d47 1379 bfd * abfd ATTRIBUTE_UNUSED;
252b5132
RH		 1380 PTR filehdr;
1381{
1382 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1383
1384 if (BADMAG (*internal_f))
1385 return false;
1386
1387 /* if the optional header is NULL or not the correct size then
1388 quit; the only difference I can see between m88k dgux headers (MC88DMAGIC)
1389 and Intel 960 readwrite headers (I960WRMAGIC) is that the
1390 optional header is of a different size.
1391
1392 But the mips keeps extra stuff in it's opthdr, so dont check
1393 when doing that
1394 */
1395
1396#if defined(M88) || defined(I960)
6b3b007b 1397 if (internal_f->f_opthdr != 0 && bfd_coff_aoutsz (abfd) != internal_f->f_opthdr)
252b5132
RH		 1398 return false;
1399#endif
1400
1401 return true;
1402}
1403
5dccc1dd
ILT		 1404/* Check whether this section uses an alignment other than the
1405 default. */
1406
1407static void
1408coff_set_custom_section_alignment (abfd, section, alignment_table, table_size)
1409 bfd *abfd ATTRIBUTE_UNUSED;
1410 asection *section;
1411 const struct coff_section_alignment_entry *alignment_table;
1412 const unsigned int table_size;
1413{
1414 const unsigned int default_alignment = COFF_DEFAULT_SECTION_ALIGNMENT_POWER;
1415 unsigned int i;
1416
1417 for (i = 0; i < table_size; ++i)
1418 {
1419 const char *secname = bfd_get_section_name (abfd, section);
1420 if (alignment_table[i].comparison_length == (unsigned int) -1
1421 ? strcmp (alignment_table[i].name, secname) == 0
1422 : strncmp (alignment_table[i].name, secname,
1423 alignment_table[i].comparison_length) == 0)
1424 break;
1425 }
1426 if (i >= table_size)
1427 return;
1428
1429 if (alignment_table[i].default_alignment_min != COFF_ALIGNMENT_FIELD_EMPTY
1430 && default_alignment < alignment_table[i].default_alignment_min)
1431 return;
1432
1433 if (alignment_table[i].default_alignment_max != COFF_ALIGNMENT_FIELD_EMPTY
1434 && default_alignment > alignment_table[i].default_alignment_max)
1435 return;
1436
1437 section->alignment_power = alignment_table[i].alignment_power;
1438}
1439
1440/* Custom section alignment records. */
1441
1442static const struct coff_section_alignment_entry
1443coff_section_alignment_table[] =
1444{
1445#ifdef COFF_SECTION_ALIGNMENT_ENTRIES
1446 COFF_SECTION_ALIGNMENT_ENTRIES,
1447#endif
1448 /* There must not be any gaps between .stabstr sections. */
1449 { COFF_SECTION_NAME_PARTIAL_MATCH (".stabstr"),
1450 1, COFF_ALIGNMENT_FIELD_EMPTY, 0 },
1451 /* The .stab section must be aligned to 2**2 at most, to avoid gaps. */
1452 { COFF_SECTION_NAME_PARTIAL_MATCH (".stab"),
1453 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 },
1454 /* Similarly for the .ctors and .dtors sections. */
1455 { COFF_SECTION_NAME_EXACT_MATCH (".ctors"),
1456 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 },
1457 { COFF_SECTION_NAME_EXACT_MATCH (".dtors"),
1458 3, COFF_ALIGNMENT_FIELD_EMPTY, 2 }
1459};
1460
1461static const unsigned int coff_section_alignment_table_size =
1462 sizeof coff_section_alignment_table / sizeof coff_section_alignment_table[0];
1463
1464/* Initialize a section structure with information peculiar to this
1465 particular implementation of COFF. */
252b5132
RH		 1466
1467static boolean
1468coff_new_section_hook (abfd, section)
5dccc1dd
ILT		 1469 bfd *abfd;
1470 asection *section;
252b5132
RH		 1471{
1472 combined_entry_type *native;
1473
1474 section->alignment_power = COFF_DEFAULT_SECTION_ALIGNMENT_POWER;
1475
1476#ifdef RS6000COFF_C
1477 if (xcoff_data (abfd)->text_align_power != 0
1478 && strcmp (bfd_get_section_name (abfd, section), ".text") == 0)
1479 section->alignment_power = xcoff_data (abfd)->text_align_power;
1480 if (xcoff_data (abfd)->data_align_power != 0
1481 && strcmp (bfd_get_section_name (abfd, section), ".data") == 0)
1482 section->alignment_power = xcoff_data (abfd)->data_align_power;
1483#endif
1484
1485 /* Allocate aux records for section symbols, to store size and
1486 related info.
1487
1488 @@ The 10 is a guess at a plausible maximum number of aux entries
1489 (but shouldn't be a constant). */
1490 native = ((combined_entry_type *)
1491 bfd_zalloc (abfd, sizeof (combined_entry_type) * 10));
1492 if (native == NULL)
1493 return false;
1494
1495 /* We don't need to set up n_name, n_value, or n_scnum in the native
1496 symbol information, since they'll be overriden by the BFD symbol
1497 anyhow. However, we do need to set the type and storage class,
1498 in case this symbol winds up getting written out. The value 0
1499 for n_numaux is already correct. */
1500
1501 native->u.syment.n_type = T_NULL;
1502 native->u.syment.n_sclass = C_STAT;
1503
1504 coffsymbol (section->symbol)->native = native;
1505
5dccc1dd
ILT		 1506 coff_set_custom_section_alignment (abfd, section,
1507 coff_section_alignment_table,
1508 coff_section_alignment_table_size);
252b5132
RH		 1509
1510 return true;
1511}
1512
1513#ifdef COFF_ALIGN_IN_SECTION_HEADER
1514
1515/* Set the alignment of a BFD section. */
1516
1517static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1518
1519static void
1520coff_set_alignment_hook (abfd, section, scnhdr)
5f771d47 1521 bfd * abfd ATTRIBUTE_UNUSED;
252b5132
RH		 1522 asection * section;
1523 PTR scnhdr;
1524{
1525 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1526 unsigned int i;
1527
1528#ifdef I960
1529 /* Extract ALIGN from 2**ALIGN stored in section header */
1530 for (i = 0; i < 32; i++)
1531 if ((1 << i) >= hdr->s_align)
1532 break;
1533#endif
1534#ifdef TIC80COFF
81635ce4 1535 /* TI tools puts the alignment power in bits 8-11 */
252b5132 1536 i = (hdr->s_flags >> 8) & 0xF ;
81635ce4
TW		 1537#endif
1538#ifdef COFF_DECODE_ALIGNMENT
1539 i = COFF_DECODE_ALIGNMENT(hdr->s_flags);
252b5132
RH		 1540#endif
1541 section->alignment_power = i;
b9af77f5
TW		 1542
1543#ifdef coff_set_section_load_page
1544 coff_set_section_load_page (section, hdr->s_page);
1545#endif
252b5132
RH		 1546}
1547
1548#else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1549#ifdef COFF_WITH_PE
1550
1551/* a couple of macros to help setting the alignment power field */
1552#define ALIGN_SET(field,x,y) \
1553 if (((field) & IMAGE_SCN_ALIGN_64BYTES) == x )\
1554 {\
1555 section->alignment_power = y;\
1556 }
1557
1558#define ELIFALIGN_SET(field,x,y) \
1559 else if (( (field) & IMAGE_SCN_ALIGN_64BYTES) == x ) \
1560 {\
1561 section->alignment_power = y;\
1562 }
1563
1564static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1565
1566static void
1567coff_set_alignment_hook (abfd, section, scnhdr)
5f771d47 1568 bfd * abfd ATTRIBUTE_UNUSED;
252b5132
RH		 1569 asection * section;
1570 PTR scnhdr;
1571{
1572 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1573
1574 ALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_64BYTES, 6)
1575 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_32BYTES, 5)
1576 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_16BYTES, 4)
1577 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_8BYTES, 3)
1578 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_4BYTES, 2)
1579 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_2BYTES, 1)
1580 ELIFALIGN_SET (hdr->s_flags, IMAGE_SCN_ALIGN_1BYTES, 0)
1581
252b5132 1582 /* In a PE image file, the s_paddr field holds the virtual size of a
8d3ad4e1
ILT		 1583 section, while the s_size field holds the raw size. We also keep
1584 the original section flag value, since not every bit can be
1585 mapped onto a generic BFD section bit. */
1586 if (coff_section_data (abfd, section) == NULL)
252b5132 1587 {
8d3ad4e1
ILT		 1588 section->used_by_bfd =
1589 (PTR) bfd_zalloc (abfd, sizeof (struct coff_section_tdata));
1590 if (section->used_by_bfd == NULL)
252b5132 1591 {
8d3ad4e1
ILT		 1592 /* FIXME: Return error. */
1593 abort ();
252b5132 1594 }
8d3ad4e1
ILT		 1595 }
1596 if (pei_section_data (abfd, section) == NULL)
1597 {
1598 coff_section_data (abfd, section)->tdata =
1599 (PTR) bfd_zalloc (abfd, sizeof (struct pei_section_tdata));
1600 if (coff_section_data (abfd, section)->tdata == NULL)
252b5132 1601 {
8d3ad4e1
ILT		 1602 /* FIXME: Return error. */
1603 abort ();
252b5132 1604 }
252b5132 1605 }
8d3ad4e1
ILT		 1606 pei_section_data (abfd, section)->virt_size = hdr->s_paddr;
1607 pei_section_data (abfd, section)->pe_flags = hdr->s_flags;
252b5132 1608
9d8cefa9 1609 section->lma = hdr->s_vaddr;
252b5132
RH		 1610}
1611#undef ALIGN_SET
1612#undef ELIFALIGN_SET
1613
1614#else /* ! COFF_WITH_PE */
1615#ifdef RS6000COFF_C
1616
1617/* We grossly abuse this function to handle XCOFF overflow headers.
1618 When we see one, we correct the reloc and line number counts in the
1619 real header, and remove the section we just created. */
1620
1621static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1622
1623static void
1624coff_set_alignment_hook (abfd, section, scnhdr)
1625 bfd *abfd;
1626 asection *section;
1627 PTR scnhdr;
1628{
1629 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1630 asection *real_sec;
1631 asection **ps;
1632
1633 if ((hdr->s_flags & STYP_OVRFLO) == 0)
1634 return;
1635
1636 real_sec = coff_section_from_bfd_index (abfd, hdr->s_nreloc);
1637 if (real_sec == NULL)
1638 return;
1639
1640 real_sec->reloc_count = hdr->s_paddr;
1641 real_sec->lineno_count = hdr->s_vaddr;
1642
1643 for (ps = &abfd->sections; *ps != NULL; ps = &(*ps)->next)
1644 {
1645 if (*ps == section)
1646 {
1647 *ps = (*ps)->next;
1648 --abfd->section_count;
1649 break;
1650 }
1651 }
1652}
1653
1654#else /* ! RS6000COFF_C */
1655
1656#define coff_set_alignment_hook \
1657 ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
1658
1659#endif /* ! RS6000COFF_C */
1660#endif /* ! COFF_WITH_PE */
1661#endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1662
1663#ifndef coff_mkobject
1664
1665static boolean coff_mkobject PARAMS ((bfd *));
1666
1667static boolean
1668coff_mkobject (abfd)
1669 bfd * abfd;
1670{
1671 coff_data_type *coff;
1672
1673 abfd->tdata.coff_obj_data = (struct coff_tdata *) bfd_zalloc (abfd, sizeof (coff_data_type));
1674 if (abfd->tdata.coff_obj_data == 0)
1675 return false;
1676 coff = coff_data (abfd);
1677 coff->symbols = (coff_symbol_type *) NULL;
1678 coff->conversion_table = (unsigned int *) NULL;
1679 coff->raw_syments = (struct coff_ptr_struct *) NULL;
1680 coff->relocbase = 0;
1681 coff->local_toc_sym_map = 0;
1682
1683/* make_abs_section(abfd);*/
1684
1685 return true;
1686}
1687#endif
1688
1689/* Create the COFF backend specific information. */
1690#ifndef coff_mkobject_hook
1691static PTR
1692coff_mkobject_hook (abfd, filehdr, aouthdr)
1693 bfd * abfd;
1694 PTR filehdr;
5f771d47 1695 PTR aouthdr ATTRIBUTE_UNUSED;
252b5132
RH		 1696{
1697 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1698 coff_data_type *coff;
1699
1700 if (coff_mkobject (abfd) == false)
1701 return NULL;
1702
1703 coff = coff_data (abfd);
1704
1705 coff->sym_filepos = internal_f->f_symptr;
1706
1707 /* These members communicate important constants about the symbol
1708 table to GDB's symbol-reading code. These `constants'
1709 unfortunately vary among coff implementations... */
1710 coff->local_n_btmask = N_BTMASK;
1711 coff->local_n_btshft = N_BTSHFT;
1712 coff->local_n_tmask = N_TMASK;
1713 coff->local_n_tshift = N_TSHIFT;
6b3b007b
NC		 1714 coff->local_symesz = bfd_coff_symesz (abfd);
1715 coff->local_auxesz = bfd_coff_auxesz (abfd);
1716 coff->local_linesz = bfd_coff_linesz (abfd);
252b5132 1717
1135238b
ILT		 1718 coff->timestamp = internal_f->f_timdat;
1719
252b5132
RH		 1720 obj_raw_syment_count (abfd) =
1721 obj_conv_table_size (abfd) =
1722 internal_f->f_nsyms;
1723
1724#ifdef RS6000COFF_C
1725 if ((internal_f->f_flags & F_SHROBJ) != 0)
1726 abfd->flags |= DYNAMIC;
6b3b007b 1727 if (aouthdr != NULL && internal_f->f_opthdr >= bfd_coff_aoutsz (abfd))
252b5132
RH		 1728 {
1729 struct internal_aouthdr *internal_a =
1730 (struct internal_aouthdr *) aouthdr;
1731 struct xcoff_tdata *xcoff;
1732
1733 xcoff = xcoff_data (abfd);
a2fdf270
ND		 1734# ifdef U803XTOCMAGIC
1735 xcoff->xcoff64 = internal_f->f_magic == U803XTOCMAGIC;
1736# else
1737 xcoff->xcoff64 = 0;
1738# endif
252b5132
RH		 1739 xcoff->full_aouthdr = true;
1740 xcoff->toc = internal_a->o_toc;
1741 xcoff->sntoc = internal_a->o_sntoc;
1742 xcoff->snentry = internal_a->o_snentry;
1743 xcoff->text_align_power = internal_a->o_algntext;
1744 xcoff->data_align_power = internal_a->o_algndata;
1745 xcoff->modtype = internal_a->o_modtype;
1746 xcoff->cputype = internal_a->o_cputype;
1747 xcoff->maxdata = internal_a->o_maxdata;
1748 xcoff->maxstack = internal_a->o_maxstack;
1749 }
1750#endif
1751
1752#ifdef ARM
1753 /* Set the flags field from the COFF header read in */
1754 if (! _bfd_coff_arm_set_private_flags (abfd, internal_f->f_flags))
1755 coff->flags = 0;
1756#endif
1757
4cfec37b
ILT		 1758#ifdef COFF_WITH_PE
1759 /* FIXME: I'm not sure this is ever executed, since peicode.h
1760 defines coff_mkobject_hook. */
1761 if ((internal_f->f_flags & IMAGE_FILE_DEBUG_STRIPPED) == 0)
1762 abfd->flags |= HAS_DEBUG;
1763#endif
1764
252b5132
RH		 1765 return (PTR) coff;
1766}
1767#endif
1768
1769/* Determine the machine architecture and type. FIXME: This is target
1770 dependent because the magic numbers are defined in the target
1771 dependent header files. But there is no particular need for this.
1772 If the magic numbers were moved to a separate file, this function
1773 would be target independent and would also be much more successful
1774 at linking together COFF files for different architectures. */
1775
1776static boolean
1777coff_set_arch_mach_hook (abfd, filehdr)
1778 bfd *abfd;
1779 PTR filehdr;
1780{
1781 long machine;
1782 enum bfd_architecture arch;
1783 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1784
1785 machine = 0;
1786 switch (internal_f->f_magic)
1787 {
1788#ifdef PPCMAGIC
1789 case PPCMAGIC:
1790 arch = bfd_arch_powerpc;
1791 machine = 0; /* what does this mean? (krk) */
1792 break;
1793#endif
1794#ifdef I386MAGIC
1795 case I386MAGIC:
1796 case I386PTXMAGIC:
1797 case I386AIXMAGIC: /* Danbury PS/2 AIX C Compiler */
1798 case LYNXCOFFMAGIC: /* shadows the m68k Lynx number below, sigh */
1799 arch = bfd_arch_i386;
1800 machine = 0;
1801 break;
1802#endif
fac41780
JW		 1803#ifdef IA64MAGIC
1804 case IA64MAGIC:
1805 arch = bfd_arch_ia64;
1806 machine = 0;
1807 break;
1808#endif
252b5132
RH		 1809#ifdef A29K_MAGIC_BIG
1810 case A29K_MAGIC_BIG:
1811 case A29K_MAGIC_LITTLE:
1812 arch = bfd_arch_a29k;
1813 machine = 0;
1814 break;
1815#endif
1816#ifdef ARMMAGIC
1817 case ARMMAGIC:
17505c5c
NC		 1818 case ARMPEMAGIC:
1819 case THUMBPEMAGIC:
252b5132
RH		 1820 arch = bfd_arch_arm;
1821 switch (internal_f->f_flags & F_ARM_ARCHITECTURE_MASK)
1822 {
948221a8
NC		 1823 case F_ARM_2: machine = bfd_mach_arm_2; break;
1824 case F_ARM_2a: machine = bfd_mach_arm_2a; break;
1825 case F_ARM_3: machine = bfd_mach_arm_3; break;
1826 default:
1827 case F_ARM_3M: machine = bfd_mach_arm_3M; break;
1828 case F_ARM_4: machine = bfd_mach_arm_4; break;
1829 case F_ARM_4T: machine = bfd_mach_arm_4T; break;
478d07d6 1830 case F_ARM_5: machine = bfd_mach_arm_5; break;
252b5132
RH		 1831 }
1832 break;
1833#endif
1834#ifdef MC68MAGIC
1835 case MC68MAGIC:
1836 case M68MAGIC:
1837#ifdef MC68KBCSMAGIC
1838 case MC68KBCSMAGIC:
1839#endif
1840#ifdef APOLLOM68KMAGIC
1841 case APOLLOM68KMAGIC:
1842#endif
1843#ifdef LYNXCOFFMAGIC
1844 case LYNXCOFFMAGIC:
1845#endif
1846 arch = bfd_arch_m68k;
1847 machine = bfd_mach_m68020;
1848 break;
1849#endif
1850#ifdef MC88MAGIC
1851 case MC88MAGIC:
1852 case MC88DMAGIC:
1853 case MC88OMAGIC:
1854 arch = bfd_arch_m88k;
1855 machine = 88100;
1856 break;
1857#endif
1858#ifdef Z8KMAGIC
1859 case Z8KMAGIC:
1860 arch = bfd_arch_z8k;
1861 switch (internal_f->f_flags & F_MACHMASK)
1862 {
1863 case F_Z8001:
1864 machine = bfd_mach_z8001;
1865 break;
1866 case F_Z8002:
1867 machine = bfd_mach_z8002;
1868 break;
1869 default:
1870 return false;
1871 }
1872 break;
1873#endif
1874#ifdef I860
1875 case I860MAGIC:
1876 arch = bfd_arch_i860;
1877 break;
1878#endif
1879#ifdef I960
1880#ifdef I960ROMAGIC
1881 case I960ROMAGIC:
1882 case I960RWMAGIC:
1883 arch = bfd_arch_i960;
1884 switch (F_I960TYPE & internal_f->f_flags)
1885 {
1886 default:
1887 case F_I960CORE:
1888 machine = bfd_mach_i960_core;
1889 break;
1890 case F_I960KB:
1891 machine = bfd_mach_i960_kb_sb;
1892 break;
1893 case F_I960MC:
1894 machine = bfd_mach_i960_mc;
1895 break;
1896 case F_I960XA:
1897 machine = bfd_mach_i960_xa;
1898 break;
1899 case F_I960CA:
1900 machine = bfd_mach_i960_ca;
1901 break;
1902 case F_I960KA:
1903 machine = bfd_mach_i960_ka_sa;
1904 break;
1905 case F_I960JX:
1906 machine = bfd_mach_i960_jx;
1907 break;
1908 case F_I960HX:
1909 machine = bfd_mach_i960_hx;
1910 break;
1911 }
1912 break;
1913#endif
1914#endif
1915
1916#ifdef RS6000COFF_C
7f6d05e8 1917#ifdef XCOFF64
c6664dfb 1918 case U803XTOCMAGIC:
7f6d05e8 1919#else
252b5132
RH		 1920 case U802ROMAGIC:
1921 case U802WRMAGIC:
1922 case U802TOCMAGIC:
7f6d05e8 1923#endif
252b5132
RH		 1924 {
1925 int cputype;
1926
1927 if (xcoff_data (abfd)->cputype != -1)
1928 cputype = xcoff_data (abfd)->cputype & 0xff;
1929 else
1930 {
1931 /* We did not get a value from the a.out header. If the
1932 file has not been stripped, we may be able to get the
1933 architecture information from the first symbol, if it
1934 is a .file symbol. */
1935 if (obj_raw_syment_count (abfd) == 0)
1936 cputype = 0;
1937 else
1938 {
5ea1af0d 1939 bfd_byte *buf;
252b5132
RH		 1940 struct internal_syment sym;
1941
5ea1af0d 1942 buf = (bfd_byte *) bfd_malloc (bfd_coff_symesz (abfd));
252b5132 1943 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
5ea1af0d
GK		 1944 || (bfd_read (buf, 1, bfd_coff_symesz (abfd), abfd)
1945 != bfd_coff_symesz (abfd)))
1946 {
2fca4467 1947 free (buf);
5ea1af0d
GK		 1948 return false;
1949 }
7f6d05e8 1950 bfd_coff_swap_sym_in (abfd, (PTR) buf, (PTR) &sym);
252b5132
RH		 1951 if (sym.n_sclass == C_FILE)
1952 cputype = sym.n_type & 0xff;
1953 else
1954 cputype = 0;
2fca4467 1955 free (buf);
252b5132
RH		 1956 }
1957 }
1958
1959 /* FIXME: We don't handle all cases here. */
1960 switch (cputype)
1961 {
1962 default:
1963 case 0:
1964#ifdef POWERMAC
1965 /* PowerPC Macs use the same magic numbers as RS/6000
1966 (because that's how they were bootstrapped originally),
1967 but they are always PowerPC architecture. */
1968 arch = bfd_arch_powerpc;
87f33987 1969 machine = bfd_mach_ppc;
252b5132 1970#else
7f6d05e8 1971#ifdef XCOFF64
87f33987
ND		 1972 arch = bfd_arch_powerpc;
1973 machine = bfd_mach_ppc_620;
7f6d05e8 1974#else
87f33987
ND		 1975 arch = bfd_arch_rs6000;
1976 machine = bfd_mach_rs6k;
7f6d05e8 1977#endif
252b5132
RH		 1978#endif /* POWERMAC */
1979 break;
1980
1981 case 1:
1982 arch = bfd_arch_powerpc;
87f33987 1983 machine = bfd_mach_ppc_601;
252b5132
RH		 1984 break;
1985 case 2: /* 64 bit PowerPC */
1986 arch = bfd_arch_powerpc;
87f33987 1987 machine = bfd_mach_ppc_620;
252b5132
RH		 1988 break;
1989 case 3:
1990 arch = bfd_arch_powerpc;
87f33987 1991 machine = bfd_mach_ppc;
252b5132
RH		 1992 break;
1993 case 4:
1994 arch = bfd_arch_rs6000;
87f33987 1995 machine = bfd_mach_rs6k;
252b5132
RH		 1996 break;
1997 }
1998 }
1999 break;
2000#endif
2001
2002#ifdef WE32KMAGIC
2003 case WE32KMAGIC:
2004 arch = bfd_arch_we32k;
2005 machine = 0;
2006 break;
2007#endif
2008
2009#ifdef H8300MAGIC
2010 case H8300MAGIC:
2011 arch = bfd_arch_h8300;
2012 machine = bfd_mach_h8300;
2013 /* !! FIXME this probably isn't the right place for this */
2014 abfd->flags |= BFD_IS_RELAXABLE;
2015 break;
2016#endif
2017
2018#ifdef H8300HMAGIC
2019 case H8300HMAGIC:
2020 arch = bfd_arch_h8300;
2021 machine = bfd_mach_h8300h;
2022 /* !! FIXME this probably isn't the right place for this */
2023 abfd->flags |= BFD_IS_RELAXABLE;
2024 break;
2025#endif
2026
2027#ifdef H8300SMAGIC
2028 case H8300SMAGIC:
2029 arch = bfd_arch_h8300;
2030 machine = bfd_mach_h8300s;
2031 /* !! FIXME this probably isn't the right place for this */
2032 abfd->flags |= BFD_IS_RELAXABLE;
2033 break;
2034#endif
2035
2036#ifdef SH_ARCH_MAGIC_BIG
2037 case SH_ARCH_MAGIC_BIG:
2038 case SH_ARCH_MAGIC_LITTLE:
17505c5c
NC		 2039#ifdef COFF_WITH_PE
2040 case SH_ARCH_MAGIC_WINCE:
2041#endif
252b5132
RH		 2042 arch = bfd_arch_sh;
2043 machine = 0;
2044 break;
2045#endif
2046
17505c5c
NC		 2047#ifdef MIPS_ARCH_MAGIC_WINCE
2048 case MIPS_ARCH_MAGIC_WINCE:
2049 arch = bfd_arch_mips;
2050 machine = 0;
2051 break;
2052#endif
2053
252b5132
RH		 2054#ifdef H8500MAGIC
2055 case H8500MAGIC:
2056 arch = bfd_arch_h8500;
2057 machine = 0;
2058 break;
2059#endif
2060
2061#ifdef SPARCMAGIC
2062 case SPARCMAGIC:
2063#ifdef LYNXCOFFMAGIC
2064 case LYNXCOFFMAGIC:
2065#endif
2066 arch = bfd_arch_sparc;
2067 machine = 0;
2068 break;
2069#endif
2070
2071#ifdef TIC30MAGIC
2072 case TIC30MAGIC:
2073 arch = bfd_arch_tic30;
2074 break;
2075#endif
2076
81635ce4
TW		 2077#ifdef TICOFF0MAGIC
2078#ifdef TICOFF_TARGET_ARCH
2079 /* this TI COFF section should be used by all new TI COFF v0 targets */
2080 case TICOFF0MAGIC:
2081 arch = TICOFF_TARGET_ARCH;
2082 break;
2083#endif
2084#endif
2085
2086#ifdef TICOFF1MAGIC
2087 /* this TI COFF section should be used by all new TI COFF v1/2 targets */
2088 /* TI COFF1 and COFF2 use the target_id field to specify which arch */
2089 case TICOFF1MAGIC:
2090 case TICOFF2MAGIC:
2091 switch (internal_f->f_target_id)
2092 {
2093#ifdef TI_TARGET_ID
2094 case TI_TARGET_ID:
2095 arch = TICOFF_TARGET_ARCH;
2096 break;
2097#endif
2098 default:
4af1d5f6 2099 arch = bfd_arch_obscure;
81635ce4
TW		 2100 (*_bfd_error_handler)
2101 (_("Unrecognized TI COFF target id '0x%x'"),
2102 internal_f->f_target_id);
2103 break;
2104 }
2105 break;
2106#endif
2107
252b5132
RH		 2108#ifdef TIC80_ARCH_MAGIC
2109 case TIC80_ARCH_MAGIC:
2110 arch = bfd_arch_tic80;
2111 break;
2112#endif
2113
2114#ifdef MCOREMAGIC
2115 case MCOREMAGIC:
2116 arch = bfd_arch_mcore;
2117 break;
2118#endif
2119 default: /* Unreadable input file type */
2120 arch = bfd_arch_obscure;
2121 break;
2122 }
2123
2124 bfd_default_set_arch_mach (abfd, arch, machine);
2125 return true;
2126}
2127
2128#ifdef SYMNAME_IN_DEBUG
2129
2130static boolean symname_in_debug_hook
2131 PARAMS ((bfd *, struct internal_syment *));
2132
2133static boolean
2134symname_in_debug_hook (abfd, sym)
5f771d47 2135 bfd * abfd ATTRIBUTE_UNUSED;
252b5132
RH		 2136 struct internal_syment *sym;
2137{
2138 return SYMNAME_IN_DEBUG (sym) ? true : false;
2139}
2140
2141#else
2142
2143#define symname_in_debug_hook \
2144 (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
2145
2146#endif
2147
2148#ifdef RS6000COFF_C
2149
7f6d05e8
CP		 2150#ifdef XCOFF64
2151#define FORCE_SYMNAMES_IN_STRINGS
2152#endif
2153
252b5132
RH		 2154/* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */
2155
2156static boolean coff_pointerize_aux_hook
2157 PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
2158 unsigned int, combined_entry_type *));
2159
2160/*ARGSUSED*/
2161static boolean
2162coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux)
5f771d47 2163 bfd *abfd ATTRIBUTE_UNUSED;
252b5132
RH		 2164 combined_entry_type *table_base;
2165 combined_entry_type *symbol;
2166 unsigned int indaux;
2167 combined_entry_type *aux;
2168{
2169 int class = symbol->u.syment.n_sclass;
2170
2171 if ((class == C_EXT || class == C_HIDEXT)
2172 && indaux + 1 == symbol->u.syment.n_numaux)
2173 {
2174 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) == XTY_LD)
2175 {
2176 aux->u.auxent.x_csect.x_scnlen.p =
2177 table_base + aux->u.auxent.x_csect.x_scnlen.l;
2178 aux->fix_scnlen = 1;
2179 }
2180
2181 /* Return true to indicate that the caller should not do any
2182 further work on this auxent. */
2183 return true;
2184 }
2185
2186 /* Return false to indicate that this auxent should be handled by
2187 the caller. */
2188 return false;
2189}
2190
2191#else
2192#ifdef I960
2193
2194/* We don't want to pointerize bal entries. */
2195
2196static boolean coff_pointerize_aux_hook
2197 PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
2198 unsigned int, combined_entry_type *));
2199
2200/*ARGSUSED*/
2201static boolean
2202coff_pointerize_aux_hook (abfd, table_base, symbol, indaux, aux)
5f771d47
ILT		 2203 bfd *abfd ATTRIBUTE_UNUSED;
2204 combined_entry_type *table_base ATTRIBUTE_UNUSED;
252b5132
RH		 2205 combined_entry_type *symbol;
2206 unsigned int indaux;
5f771d47 2207 combined_entry_type *aux ATTRIBUTE_UNUSED;
252b5132
RH		 2208{
2209 /* Return true if we don't want to pointerize this aux entry, which
2210 is the case for the lastfirst aux entry for a C_LEAFPROC symbol. */
2211 return (indaux == 1
2212 && (symbol->u.syment.n_sclass == C_LEAFPROC
2213 || symbol->u.syment.n_sclass == C_LEAFSTAT
2214 || symbol->u.syment.n_sclass == C_LEAFEXT));
2215}
2216
2217#else /* ! I960 */
2218
2219#define coff_pointerize_aux_hook 0
2220
2221#endif /* ! I960 */
2222#endif /* ! RS6000COFF_C */
2223
2224/* Print an aux entry. This returns true if it has printed it. */
2225
2226static boolean coff_print_aux
2227 PARAMS ((bfd *, FILE *, combined_entry_type *, combined_entry_type *,
2228 combined_entry_type *, unsigned int));
2229
2230static boolean
2231coff_print_aux (abfd, file, table_base, symbol, aux, indaux)
5f771d47
ILT		 2232 bfd *abfd ATTRIBUTE_UNUSED;
2233 FILE *file ATTRIBUTE_UNUSED;
2234 combined_entry_type *table_base ATTRIBUTE_UNUSED;
2235 combined_entry_type *symbol ATTRIBUTE_UNUSED;
2236 combined_entry_type *aux ATTRIBUTE_UNUSED;
2237 unsigned int indaux ATTRIBUTE_UNUSED;
252b5132
RH		 2238{
2239#ifdef RS6000COFF_C
2240 if ((symbol->u.syment.n_sclass == C_EXT
2241 || symbol->u.syment.n_sclass == C_HIDEXT)
2242 && indaux + 1 == symbol->u.syment.n_numaux)
2243 {
2244 /* This is a csect entry. */
2245 fprintf (file, "AUX ");
2246 if (SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp) != XTY_LD)
2247 {
2248 BFD_ASSERT (! aux->fix_scnlen);
2249 fprintf (file, "val %5ld", aux->u.auxent.x_csect.x_scnlen.l);
2250 }
2251 else
2252 {
2253 fprintf (file, "indx ");
2254 if (! aux->fix_scnlen)
2255 fprintf (file, "%4ld", aux->u.auxent.x_csect.x_scnlen.l);
2256 else
2257 fprintf (file, "%4ld",
2258 (long) (aux->u.auxent.x_csect.x_scnlen.p - table_base));
2259 }
2260 fprintf (file,
2261 " prmhsh %ld snhsh %u typ %d algn %d clss %u stb %ld snstb %u",
2262 aux->u.auxent.x_csect.x_parmhash,
2263 (unsigned int) aux->u.auxent.x_csect.x_snhash,
2264 SMTYP_SMTYP (aux->u.auxent.x_csect.x_smtyp),
2265 SMTYP_ALIGN (aux->u.auxent.x_csect.x_smtyp),
2266 (unsigned int) aux->u.auxent.x_csect.x_smclas,
2267 aux->u.auxent.x_csect.x_stab,
2268 (unsigned int) aux->u.auxent.x_csect.x_snstab);
2269 return true;
2270 }
2271#endif
2272
2273 /* Return false to indicate that no special action was taken. */
2274 return false;
2275}
2276
2277/*
2278SUBSUBSECTION
2279 Writing relocations
2280
2281 To write relocations, the back end steps though the
2282 canonical relocation table and create an
2283 @code{internal_reloc}. The symbol index to use is removed from
2284 the @code{offset} field in the symbol table supplied. The
2285 address comes directly from the sum of the section base
2286 address and the relocation offset; the type is dug directly
2287 from the howto field. Then the @code{internal_reloc} is
2288 swapped into the shape of an @code{external_reloc} and written
2289 out to disk.
2290
2291*/
2292
2293#ifdef TARG_AUX
2294
2295static int compare_arelent_ptr PARAMS ((const PTR, const PTR));
2296
2297/* AUX's ld wants relocations to be sorted */
2298static int
2299compare_arelent_ptr (x, y)
2300 const PTR x;
2301 const PTR y;
2302{
2303 const arelent **a = (const arelent **) x;
2304 const arelent **b = (const arelent **) y;
2305 bfd_size_type aadr = (*a)->address;
2306 bfd_size_type badr = (*b)->address;
2307
2308 return (aadr < badr ? -1 : badr < aadr ? 1 : 0);
2309}
2310
2311#endif /* TARG_AUX */
2312
2313static boolean
2314coff_write_relocs (abfd, first_undef)
2315 bfd * abfd;
2316 int first_undef;
2317{
2318 asection *s;
2319
2320 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
2321 {
2322 unsigned int i;
2323 struct external_reloc dst;
2324 arelent **p;
2325
2326#ifndef TARG_AUX
2327 p = s->orelocation;
2328#else
2329 /* sort relocations before we write them out */
2330 p = (arelent **) bfd_malloc (s->reloc_count * sizeof (arelent *));
2331 if (p == NULL && s->reloc_count > 0)
2332 return false;
2333 memcpy (p, s->orelocation, s->reloc_count * sizeof (arelent *));
2334 qsort (p, s->reloc_count, sizeof (arelent *), compare_arelent_ptr);
2335#endif
2336
2337 if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0)
2338 return false;
2339 for (i = 0; i < s->reloc_count; i++)
2340 {
2341 struct internal_reloc n;
2342 arelent *q = p[i];
2343 memset ((PTR) & n, 0, sizeof (n));
2344
2345 /* Now we've renumbered the symbols we know where the
2346 undefined symbols live in the table. Check the reloc
2347 entries for symbols who's output bfd isn't the right one.
2348 This is because the symbol was undefined (which means
2349 that all the pointers are never made to point to the same
2350 place). This is a bad thing,'cause the symbols attached
2351 to the output bfd are indexed, so that the relocation
2352 entries know which symbol index they point to. So we
2353 have to look up the output symbol here. */
2354
2355 if (q->sym_ptr_ptr[0]->the_bfd != abfd)
2356 {
2357 int i;
2358 const char *sname = q->sym_ptr_ptr[0]->name;
2359 asymbol **outsyms = abfd->outsymbols;
2360 for (i = first_undef; outsyms[i]; i++)
2361 {
2362 const char *intable = outsyms[i]->name;
2363 if (strcmp (intable, sname) == 0) {
2364 /* got a hit, so repoint the reloc */
2365 q->sym_ptr_ptr = outsyms + i;
2366 break;
2367 }
2368 }
2369 }
2370
2371 n.r_vaddr = q->address + s->vma;
2372
2373#ifdef R_IHCONST
2374 /* The 29k const/consth reloc pair is a real kludge. The consth
2375 part doesn't have a symbol; it has an offset. So rebuilt
2376 that here. */
2377 if (q->howto->type == R_IHCONST)
2378 n.r_symndx = q->addend;
2379 else
2380#endif
2381 if (q->sym_ptr_ptr)
2382 {
6c784c9a
TW		 2383#ifdef SECTION_RELATIVE_ABSOLUTE_SYMBOL_P
2384 if (SECTION_RELATIVE_ABSOLUTE_SYMBOL_P (q,s))
2385#else
252b5132 2386 if (q->sym_ptr_ptr == bfd_abs_section_ptr->symbol_ptr_ptr)
6c784c9a 2387#endif
252b5132
RH		 2388 /* This is a relocation relative to the absolute symbol. */
2389 n.r_symndx = -1;
2390 else
2391 {
2392 n.r_symndx = get_index ((*(q->sym_ptr_ptr)));
2393 /* Take notice if the symbol reloc points to a symbol
2394 we don't have in our symbol table. What should we
2395 do for this?? */
2396 if (n.r_symndx > obj_conv_table_size (abfd))
2397 abort ();
2398 }
2399 }
2400
2401#ifdef SWAP_OUT_RELOC_OFFSET
2402 n.r_offset = q->addend;
2403#endif
2404
2405#ifdef SELECT_RELOC
2406 /* Work out reloc type from what is required */
2407 SELECT_RELOC (n, q->howto);
2408#else
2409 n.r_type = q->howto->type;
2410#endif
2411 coff_swap_reloc_out (abfd, &n, &dst);
6b3b007b
NC		 2412 if (bfd_write ((PTR) & dst, 1, bfd_coff_relsz (abfd), abfd)
2413 != bfd_coff_relsz (abfd))
252b5132
RH		 2414 return false;
2415 }
2416
2417#ifdef TARG_AUX
2418 if (p != NULL)
2419 free (p);
2420#endif
2421 }
2422
2423 return true;
2424}
2425
2426/* Set flags and magic number of a coff file from architecture and machine
2427 type. Result is true if we can represent the arch&type, false if not. */
2428
2429static boolean
2430coff_set_flags (abfd, magicp, flagsp)
2431 bfd * abfd;
5f771d47
ILT		 2432 unsigned int *magicp ATTRIBUTE_UNUSED;
2433 unsigned short *flagsp ATTRIBUTE_UNUSED;
252b5132
RH		 2434{
2435 switch (bfd_get_arch (abfd))
2436 {
2437#ifdef Z8KMAGIC
2438 case bfd_arch_z8k:
2439 *magicp = Z8KMAGIC;
2440 switch (bfd_get_mach (abfd))
2441 {
2442 case bfd_mach_z8001:
2443 *flagsp = F_Z8001;
2444 break;
2445 case bfd_mach_z8002:
2446 *flagsp = F_Z8002;
2447 break;
2448 default:
2449 return false;
2450 }
2451 return true;
2452#endif
2453#ifdef I960ROMAGIC
2454
2455 case bfd_arch_i960:
2456
2457 {
2458 unsigned flags;
2459 *magicp = I960ROMAGIC;
2460 /*
2461 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
2462 I960RWMAGIC); FIXME???
2463 */
2464 switch (bfd_get_mach (abfd))
2465 {
2466 case bfd_mach_i960_core:
2467 flags = F_I960CORE;
2468 break;
2469 case bfd_mach_i960_kb_sb:
2470 flags = F_I960KB;
2471 break;
2472 case bfd_mach_i960_mc:
2473 flags = F_I960MC;
2474 break;
2475 case bfd_mach_i960_xa:
2476 flags = F_I960XA;
2477 break;
2478 case bfd_mach_i960_ca:
2479 flags = F_I960CA;
2480 break;
2481 case bfd_mach_i960_ka_sa:
2482 flags = F_I960KA;
2483 break;
2484 case bfd_mach_i960_jx:
2485 flags = F_I960JX;
2486 break;
2487 case bfd_mach_i960_hx:
2488 flags = F_I960HX;
2489 break;
2490 default:
2491 return false;
2492 }
2493 *flagsp = flags;
2494 return true;
2495 }
2496 break;
2497#endif
2498
2499#ifdef TIC30MAGIC
2500 case bfd_arch_tic30:
2501 *magicp = TIC30MAGIC;
2502 return true;
2503#endif
81635ce4
TW		 2504
2505#ifdef TICOFF_DEFAULT_MAGIC
2506 case TICOFF_TARGET_ARCH:
2507 /* if there's no indication of which version we want, use the default */
2508 if (!abfd->xvec )
2509 *magicp = TICOFF_DEFAULT_MAGIC;
2510 else
2511 {
2512 /* we may want to output in a different COFF version */
2513 switch (abfd->xvec->name[4])
2514 {
2515 case '0':
2516 *magicp = TICOFF0MAGIC;
2517 break;
2518 case '1':
2519 *magicp = TICOFF1MAGIC;
2520 break;
2521 case '2':
2522 *magicp = TICOFF2MAGIC;
2523 break;
2524 default:
2525 return false;
2526 }
2527 }
2528 return true;
2529#endif
2530
252b5132
RH		 2531#ifdef TIC80_ARCH_MAGIC
2532 case bfd_arch_tic80:
2533 *magicp = TIC80_ARCH_MAGIC;
2534 return true;
2535#endif
2536#ifdef ARMMAGIC
2537 case bfd_arch_arm:
17505c5c
NC		 2538#ifdef ARM_WINCE
2539 * magicp = ARMPEMAGIC;
2540#else
252b5132 2541 * magicp = ARMMAGIC;
17505c5c 2542#endif
252b5132
RH		 2543 * flagsp = 0;
2544 if (APCS_SET (abfd))
2545 {
2546 if (APCS_26_FLAG (abfd))
2547 * flagsp |= F_APCS26;
2548
2549 if (APCS_FLOAT_FLAG (abfd))
2550 * flagsp |= F_APCS_FLOAT;
2551
2552 if (PIC_FLAG (abfd))
948221a8 2553 * flagsp |= F_PIC;
252b5132
RH		 2554 }
2555 if (INTERWORK_SET (abfd) && INTERWORK_FLAG (abfd))
2556 * flagsp |= F_INTERWORK;
2557 switch (bfd_get_mach (abfd))
2558 {
2559 case bfd_mach_arm_2: * flagsp |= F_ARM_2; break;
2560 case bfd_mach_arm_2a: * flagsp |= F_ARM_2a; break;
2561 case bfd_mach_arm_3: * flagsp |= F_ARM_3; break;
2562 case bfd_mach_arm_3M: * flagsp |= F_ARM_3M; break;
2563 case bfd_mach_arm_4: * flagsp |= F_ARM_4; break;
2564 case bfd_mach_arm_4T: * flagsp |= F_ARM_4T; break;
478d07d6
NC		 2565 case bfd_mach_arm_5: * flagsp |= F_ARM_5; break;
2566 case bfd_mach_arm_5T: * flagsp |= F_ARM_5; break; /* XXX - we do not have an F_ARM_5T */
252b5132
RH		 2567 }
2568 return true;
2569#endif
2570#ifdef PPCMAGIC
2571 case bfd_arch_powerpc:
2572 *magicp = PPCMAGIC;
2573 return true;
2574 break;
2575#endif
2576#ifdef I386MAGIC
2577 case bfd_arch_i386:
2578 *magicp = I386MAGIC;
2579#ifdef LYNXOS
2580 /* Just overwrite the usual value if we're doing Lynx. */
2581 *magicp = LYNXCOFFMAGIC;
2582#endif
2583 return true;
2584 break;
2585#endif
2586#ifdef I860MAGIC
2587 case bfd_arch_i860:
2588 *magicp = I860MAGIC;
2589 return true;
2590 break;
2591#endif
fac41780
JW		 2592#ifdef IA64MAGIC
2593 case bfd_arch_ia64:
2594 *magicp = IA64MAGIC;
2595 return true;
2596 break;
2597#endif
252b5132
RH		 2598#ifdef MC68MAGIC
2599 case bfd_arch_m68k:
2600#ifdef APOLLOM68KMAGIC
2601 *magicp = APOLLO_COFF_VERSION_NUMBER;
2602#else
2603 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2604#ifdef NAMES_HAVE_UNDERSCORE
2605 *magicp = MC68KBCSMAGIC;
2606#else
2607 *magicp = MC68MAGIC;
2608#endif
2609#endif
2610#ifdef LYNXOS
2611 /* Just overwrite the usual value if we're doing Lynx. */
2612 *magicp = LYNXCOFFMAGIC;
2613#endif
2614 return true;
2615 break;
2616#endif
2617
2618#ifdef MC88MAGIC
2619 case bfd_arch_m88k:
2620 *magicp = MC88OMAGIC;
2621 return true;
2622 break;
2623#endif
2624#ifdef H8300MAGIC
2625 case bfd_arch_h8300:
2626 switch (bfd_get_mach (abfd))
2627 {
2628 case bfd_mach_h8300:
2629 *magicp = H8300MAGIC;
2630 return true;
2631 case bfd_mach_h8300h:
2632 *magicp = H8300HMAGIC;
2633 return true;
2634 case bfd_mach_h8300s:
2635 *magicp = H8300SMAGIC;
2636 return true;
2637 }
2638 break;
2639#endif
2640
2641#ifdef SH_ARCH_MAGIC_BIG
2642 case bfd_arch_sh:
17505c5c
NC		 2643#ifdef COFF_IMAGE_WITH_PE
2644 *magicp = SH_ARCH_MAGIC_WINCE;
2645#else
252b5132
RH		 2646 if (bfd_big_endian (abfd))
2647 *magicp = SH_ARCH_MAGIC_BIG;
2648 else
2649 *magicp = SH_ARCH_MAGIC_LITTLE;
17505c5c
NC		 2650#endif
2651 return true;
2652 break;
2653#endif
2654
2655#ifdef MIPS_ARCH_MAGIC_WINCE
2656 case bfd_arch_mips:
2657 *magicp = MIPS_ARCH_MAGIC_WINCE;
252b5132
RH		 2658 return true;
2659 break;
2660#endif
2661
2662#ifdef SPARCMAGIC
2663 case bfd_arch_sparc:
2664 *magicp = SPARCMAGIC;
2665#ifdef LYNXOS
2666 /* Just overwrite the usual value if we're doing Lynx. */
2667 *magicp = LYNXCOFFMAGIC;
2668#endif
2669 return true;
2670 break;
2671#endif
2672
2673#ifdef H8500MAGIC
2674 case bfd_arch_h8500:
2675 *magicp = H8500MAGIC;
2676 return true;
2677 break;
2678#endif
2679#ifdef A29K_MAGIC_BIG
2680 case bfd_arch_a29k:
2681 if (bfd_big_endian (abfd))
2682 *magicp = A29K_MAGIC_BIG;
2683 else
2684 *magicp = A29K_MAGIC_LITTLE;
2685 return true;
2686 break;
2687#endif
2688
2689#ifdef WE32KMAGIC
2690 case bfd_arch_we32k:
2691 *magicp = WE32KMAGIC;
2692 return true;
2693 break;
2694#endif
2695
7f6d05e8 2696#ifdef RS6000COFF_C
252b5132
RH		 2697 case bfd_arch_rs6000:
2698#ifndef PPCMAGIC
2699 case bfd_arch_powerpc:
2700#endif
7f6d05e8 2701#ifdef XCOFF64
87f33987
ND		 2702 if (bfd_get_mach (abfd) == bfd_mach_ppc_620
2703 && !strncmp (abfd->xvec->name,"aix", 3))
c6664dfb 2704 *magicp = U803XTOCMAGIC;
7f6d05e8
CP		 2705 else
2706#else
2707 *magicp = U802TOCMAGIC;
2708#endif
252b5132
RH		 2709 return true;
2710 break;
2711#endif
2712
2713#ifdef MCOREMAGIC
2714 case bfd_arch_mcore:
2715 * magicp = MCOREMAGIC;
2716 return true;
2717#endif
2718
2719 default: /* Unknown architecture */
2720 /* return false; -- fall through to "return false" below, to avoid
2721 "statement never reached" errors on the one below. */
2722 break;
2723 }
2724
2725 return false;
2726}
2727
2728
2729static boolean
2730coff_set_arch_mach (abfd, arch, machine)
2731 bfd * abfd;
2732 enum bfd_architecture arch;
2733 unsigned long machine;
2734{
2735 unsigned dummy1;
2736 unsigned short dummy2;
2737
2738 if (! bfd_default_set_arch_mach (abfd, arch, machine))
2739 return false;
2740
2741 if (arch != bfd_arch_unknown &&
2742 coff_set_flags (abfd, &dummy1, &dummy2) != true)
2743 return false; /* We can't represent this type */
2744
2745 return true; /* We're easy ... */
2746}
2747
75cc7189
ILT		 2748#ifdef COFF_IMAGE_WITH_PE
2749
2750/* This is used to sort sections by VMA, as required by PE image
2751 files. */
2752
2753static int sort_by_secaddr PARAMS ((const PTR, const PTR));
2754
2755static int
2756sort_by_secaddr (arg1, arg2)
2757 const PTR arg1;
2758 const PTR arg2;
2759{
2760 const asection *a = *(const asection **) arg1;
2761 const asection *b = *(const asection **) arg2;
2762
2763 if (a->vma < b->vma)
2764 return -1;
2765 else if (a->vma > b->vma)
2766 return 1;
2767 else
2768 return 0;
2769}
2770
2771#endif /* COFF_IMAGE_WITH_PE */
252b5132
RH		 2772
2773/* Calculate the file position for each section. */
2774
2775#ifndef I960
2776#define ALIGN_SECTIONS_IN_FILE
2777#endif
81635ce4 2778#if defined(TIC80COFF) || defined(TICOFF)
252b5132
RH		 2779#undef ALIGN_SECTIONS_IN_FILE
2780#endif
2781
2782static boolean
2783coff_compute_section_file_positions (abfd)
2784 bfd * abfd;
2785{
2786 asection *current;
2787 asection *previous = (asection *) NULL;
6b3b007b 2788 file_ptr sofar = bfd_coff_filhsz (abfd);
252b5132 2789 boolean align_adjust;
252b5132
RH		 2790#ifdef ALIGN_SECTIONS_IN_FILE
2791 file_ptr old_sofar;
2792#endif
2793
2794#ifdef RS6000COFF_C
2795 /* On XCOFF, if we have symbols, set up the .debug section. */
2796 if (bfd_get_symcount (abfd) > 0)
2797 {
2798 bfd_size_type sz;
2799 bfd_size_type i, symcount;
2800 asymbol **symp;
2801
2802 sz = 0;
2803 symcount = bfd_get_symcount (abfd);
2804 for (symp = abfd->outsymbols, i = 0; i < symcount; symp++, i++)
2805 {
2806 coff_symbol_type *cf;
2807
2808 cf = coff_symbol_from (abfd, *symp);
2809 if (cf != NULL
2810 && cf->native != NULL
2811 && SYMNAME_IN_DEBUG (&cf->native->u.syment))
2812 {
2813 size_t len;
2814
2815 len = strlen (bfd_asymbol_name (*symp));
7f6d05e8
CP		 2816 if (len > SYMNMLEN || bfd_coff_force_symnames_in_strings (abfd))
2817 sz += len + 1 + bfd_coff_debug_string_prefix_length (abfd);
252b5132
RH		 2818 }
2819 }
2820 if (sz > 0)
2821 {
2822 asection *dsec;
2823
2824 dsec = bfd_make_section_old_way (abfd, ".debug");
2825 if (dsec == NULL)
2826 abort ();
2827 dsec->_raw_size = sz;
2828 dsec->flags |= SEC_HAS_CONTENTS;
2829 }
2830 }
2831#endif
2832
2833#ifdef COFF_IMAGE_WITH_PE
2834 int page_size;
2835 if (coff_data (abfd)->link_info)
2836 {
2837 page_size = pe_data (abfd)->pe_opthdr.FileAlignment;
2838 }
2839 else
2840 page_size = PE_DEF_FILE_ALIGNMENT;
2841#else
2842#ifdef COFF_PAGE_SIZE
2843 int page_size = COFF_PAGE_SIZE;
2844#endif
2845#endif
2846
2847 if (bfd_get_start_address (abfd))
2848 {
2849 /* A start address may have been added to the original file. In this
2850 case it will need an optional header to record it. */
2851 abfd->flags |= EXEC_P;
2852 }
2853
2854 if (abfd->flags & EXEC_P)
6b3b007b 2855 sofar += bfd_coff_aoutsz (abfd);
252b5132
RH		 2856#ifdef RS6000COFF_C
2857 else if (xcoff_data (abfd)->full_aouthdr)
6b3b007b 2858 sofar += bfd_coff_aoutsz (abfd);
252b5132
RH		 2859 else
2860 sofar += SMALL_AOUTSZ;
2861#endif
2862
6b3b007b 2863 sofar += abfd->section_count * bfd_coff_scnhsz (abfd);
252b5132
RH		 2864
2865#ifdef RS6000COFF_C
2866 /* XCOFF handles overflows in the reloc and line number count fields
2867 by allocating a new section header to hold the correct counts. */
2868 for (current = abfd->sections; current != NULL; current = current->next)
2869 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
6b3b007b 2870 sofar += bfd_coff_scnhsz (abfd);
252b5132
RH		 2871#endif
2872
75cc7189
ILT		 2873#ifdef COFF_IMAGE_WITH_PE
2874 {
2875 /* PE requires the sections to be in memory order when listed in
2876 the section headers. It also does not like empty loadable
2877 sections. The sections apparently do not have to be in the
2878 right order in the image file itself, but we do need to get the
2879 target_index values right. */
2880
2881 int count;
2882 asection **section_list;
2883 int i;
2884 int target_index;
2885
2886 count = 0;
2887 for (current = abfd->sections; current != NULL; current = current->next)
2888 ++count;
2889
2890 /* We allocate an extra cell to simplify the final loop. */
2891 section_list = bfd_malloc (sizeof (struct asection *) * (count + 1));
2892 if (section_list == NULL)
2893 return false;
2894
2895 i = 0;
2896 for (current = abfd->sections; current != NULL; current = current->next)
2897 {
2898 section_list[i] = current;
2899 ++i;
2900 }
2901 section_list[i] = NULL;
2902
2903 qsort (section_list, count, sizeof (asection *), sort_by_secaddr);
2904
2905 /* Rethread the linked list into sorted order; at the same time,
2906 assign target_index values. */
2907 target_index = 1;
2908 abfd->sections = section_list[0];
2909 for (i = 0; i < count; i++)
2910 {
2911 current = section_list[i];
2912 current->next = section_list[i + 1];
2913
2914 /* Later, if the section has zero size, we'll be throwing it
2915 away, so we don't want to number it now. Note that having
2916 a zero size and having real contents are different
2917 concepts: .bss has no contents, but (usually) non-zero
2918 size. */
2919 if (current->_raw_size == 0)
2920 {
2921 /* Discard. However, it still might have (valid) symbols
2922 in it, so arbitrarily set it to section 1 (indexing is
2923 1-based here; usually .text). __end__ and other
2924 contents of .endsection really have this happen.
2925 FIXME: This seems somewhat dubious. */
2926 current->target_index = 1;
2927 }
2928 else
2929 current->target_index = target_index++;
2930 }
2931
2fca4467 2932 free (section_list);
75cc7189
ILT		 2933 }
2934#else /* ! COFF_IMAGE_WITH_PE */
2935 {
2936 /* Set the target_index field. */
2937 int target_index;
2938
2939 target_index = 1;
2940 for (current = abfd->sections; current != NULL; current = current->next)
2941 current->target_index = target_index++;
2942 }
2943#endif /* ! COFF_IMAGE_WITH_PE */
2944
252b5132 2945 align_adjust = false;
75cc7189 2946 for (current = abfd->sections;
252b5132 2947 current != (asection *) NULL;
75cc7189 2948 current = current->next)
252b5132
RH		 2949 {
2950#ifdef COFF_IMAGE_WITH_PE
75cc7189
ILT		 2951 /* With PE we have to pad each section to be a multiple of its
2952 page size too, and remember both sizes. */
2953 if (coff_section_data (abfd, current) == NULL)
252b5132 2954 {
75cc7189
ILT		 2955 current->used_by_bfd =
2956 (PTR) bfd_zalloc (abfd, sizeof (struct coff_section_tdata));
2957 if (current->used_by_bfd == NULL)
2958 return false;
252b5132 2959 }
75cc7189
ILT		 2960 if (pei_section_data (abfd, current) == NULL)
2961 {
2962 coff_section_data (abfd, current)->tdata =
2963 (PTR) bfd_zalloc (abfd, sizeof (struct pei_section_tdata));
2964 if (coff_section_data (abfd, current)->tdata == NULL)
2965 return false;
2966 }
2967 if (pei_section_data (abfd, current)->virt_size == 0)
2968 pei_section_data (abfd, current)->virt_size = current->_raw_size;
252b5132
RH		 2969#endif
2970
75cc7189 2971 /* Only deal with sections which have contents. */
252b5132
RH		 2972 if (!(current->flags & SEC_HAS_CONTENTS))
2973 continue;
2974
75cc7189
ILT		 2975#ifdef COFF_IMAGE_WITH_PE
2976 /* Make sure we skip empty sections in a PE image. */
2977 if (current->_raw_size == 0)
2978 continue;
2979#endif
2980
252b5132
RH		 2981 /* Align the sections in the file to the same boundary on
2982 which they are aligned in virtual memory. I960 doesn't
2983 do this (FIXME) so we can stay in sync with Intel. 960
2984 doesn't yet page from files... */
2985#ifdef ALIGN_SECTIONS_IN_FILE
2986 if ((abfd->flags & EXEC_P) != 0)
2987 {
2988 /* make sure this section is aligned on the right boundary - by
2989 padding the previous section up if necessary */
2990
2991 old_sofar = sofar;
2992 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
2993 if (previous != (asection *) NULL)
2994 {
2995 previous->_raw_size += sofar - old_sofar;
2996 }
2997 }
2998
2999#endif
3000
3001 /* In demand paged files the low order bits of the file offset
3002 must match the low order bits of the virtual address. */
3003#ifdef COFF_PAGE_SIZE
3004 if ((abfd->flags & D_PAGED) != 0
3005 && (current->flags & SEC_ALLOC) != 0)
3006 sofar += (current->vma - sofar) % page_size;
3007#endif
3008 current->filepos = sofar;
3009
3010#ifdef COFF_IMAGE_WITH_PE
75cc7189 3011 /* Set the padded size. */
252b5132
RH		 3012 current->_raw_size = (current->_raw_size + page_size -1) & -page_size;
3013#endif
3014
3015 sofar += current->_raw_size;
3016
3017#ifdef ALIGN_SECTIONS_IN_FILE
3018 /* make sure that this section is of the right size too */
3019 if ((abfd->flags & EXEC_P) == 0)
3020 {
3021 bfd_size_type old_size;
3022
3023 old_size = current->_raw_size;
3024 current->_raw_size = BFD_ALIGN (current->_raw_size,
3025 1 << current->alignment_power);
3026 align_adjust = current->_raw_size != old_size;
3027 sofar += current->_raw_size - old_size;
3028 }
3029 else
3030 {
3031 old_sofar = sofar;
3032 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
3033 align_adjust = sofar != old_sofar;
3034 current->_raw_size += sofar - old_sofar;
3035 }
3036#endif
3037
3038#ifdef COFF_IMAGE_WITH_PE
3039 /* For PE we need to make sure we pad out to the aligned
3040 _raw_size, in case the caller only writes out data to the
3041 unaligned _raw_size. */
3042 if (pei_section_data (abfd, current)->virt_size < current->_raw_size)
3043 align_adjust = true;
3044#endif
3045
3046#ifdef _LIB
3047 /* Force .lib sections to start at zero. The vma is then
3048 incremented in coff_set_section_contents. This is right for
3049 SVR3.2. */
3050 if (strcmp (current->name, _LIB) == 0)
3051 bfd_set_section_vma (abfd, current, 0);
3052#endif
3053
3054 previous = current;
3055 }
3056
3057 /* It is now safe to write to the output file. If we needed an
3058 alignment adjustment for the last section, then make sure that
3059 there is a byte at offset sofar. If there are no symbols and no
3060 relocs, then nothing follows the last section. If we don't force
3061 the last byte out, then the file may appear to be truncated. */
3062 if (align_adjust)
3063 {
3064 bfd_byte b;
3065
3066 b = 0;
3067 if (bfd_seek (abfd, sofar - 1, SEEK_SET) != 0
3068 || bfd_write (&b, 1, 1, abfd) != 1)
3069 return false;
3070 }
3071
3072 /* Make sure the relocations are aligned. We don't need to make
3073 sure that this byte exists, because it will only matter if there
3074 really are relocs. */
3075 sofar = BFD_ALIGN (sofar, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER);
3076
3077 obj_relocbase (abfd) = sofar;
3078 abfd->output_has_begun = true;
3079
3080 return true;
3081}
3082
3083#if 0
3084
3085/* This can never work, because it is called too late--after the
3086 section positions have been set. I can't figure out what it is
3087 for, so I am going to disable it--Ian Taylor 20 March 1996. */
3088
3089/* If .file, .text, .data, .bss symbols are missing, add them. */
3090/* @@ Should we only be adding missing symbols, or overriding the aux
3091 values for existing section symbols? */
3092static boolean
3093coff_add_missing_symbols (abfd)
3094 bfd *abfd;
3095{
3096 unsigned int nsyms = bfd_get_symcount (abfd);
3097 asymbol **sympp = abfd->outsymbols;
3098 asymbol **sympp2;
3099 unsigned int i;
3100 int need_text = 1, need_data = 1, need_bss = 1, need_file = 1;
3101
3102 for (i = 0; i < nsyms; i++)
3103 {
3104 coff_symbol_type *csym = coff_symbol_from (abfd, sympp[i]);
3105 CONST char *name;
3106 if (csym)
3107 {
3108 /* only do this if there is a coff representation of the input
3109 symbol */
3110 if (csym->native && csym->native->u.syment.n_sclass == C_FILE)
3111 {
3112 need_file = 0;
3113 continue;
3114 }
3115 name = csym->symbol.name;
3116 if (!name)
3117 continue;
3118 if (!strcmp (name, _TEXT))
3119 need_text = 0;
3120#ifdef APOLLO_M68
3121 else if (!strcmp (name, ".wtext"))
3122 need_text = 0;
3123#endif
3124 else if (!strcmp (name, _DATA))
3125 need_data = 0;
3126 else if (!strcmp (name, _BSS))
3127 need_bss = 0;
3128 }
3129 }
3130 /* Now i == bfd_get_symcount (abfd). */
3131 /* @@ For now, don't deal with .file symbol. */
3132 need_file = 0;
3133
3134 if (!need_text && !need_data && !need_bss && !need_file)
3135 return true;
3136 nsyms += need_text + need_data + need_bss + need_file;
3137 sympp2 = (asymbol **) bfd_alloc (abfd, nsyms * sizeof (asymbol *));
3138 if (!sympp2)
3139 return false;
3140 memcpy (sympp2, sympp, i * sizeof (asymbol *));
3141 if (need_file)
3142 {
3143 /* @@ Generate fake .file symbol, in sympp2[i], and increment i. */
3144 abort ();
3145 }
3146 if (need_text)
3147 sympp2[i++] = coff_section_symbol (abfd, _TEXT);
3148 if (need_data)
3149 sympp2[i++] = coff_section_symbol (abfd, _DATA);
3150 if (need_bss)
3151 sympp2[i++] = coff_section_symbol (abfd, _BSS);
3152 BFD_ASSERT (i == nsyms);
3153 bfd_set_symtab (abfd, sympp2, nsyms);
3154 return true;
3155}
3156
3157#endif /* 0 */
3158
3159/* SUPPRESS 558 */
3160/* SUPPRESS 529 */
3161static boolean
3162coff_write_object_contents (abfd)
3163 bfd * abfd;
3164{
3165 asection *current;
3166 boolean hasrelocs = false;
3167 boolean haslinno = false;
4cfec37b 3168 boolean hasdebug = false;
252b5132
RH		 3169 file_ptr scn_base;
3170 file_ptr reloc_base;
3171 file_ptr lineno_base;
3172 file_ptr sym_base;
3173 unsigned long reloc_size = 0;
3174 unsigned long lnno_size = 0;
3175 boolean long_section_names;
3176 asection *text_sec = NULL;
3177 asection *data_sec = NULL;
3178 asection *bss_sec = NULL;
3179 struct internal_filehdr internal_f;
3180 struct internal_aouthdr internal_a;
3181#ifdef COFF_LONG_SECTION_NAMES
3182 size_t string_size = STRING_SIZE_SIZE;
3183#endif
3184
3185 bfd_set_error (bfd_error_system_call);
3186
3187 /* Make a pass through the symbol table to count line number entries and
3188 put them into the correct asections */
3189
6b3b007b 3190 lnno_size = coff_count_linenumbers (abfd) * bfd_coff_linesz (abfd);
252b5132
RH		 3191
3192 if (abfd->output_has_begun == false)
3193 {
3194 if (! coff_compute_section_file_positions (abfd))
3195 return false;
3196 }
3197
3198 reloc_base = obj_relocbase (abfd);
3199
3200 /* Work out the size of the reloc and linno areas */
3201
3202 for (current = abfd->sections; current != NULL; current =
3203 current->next)
6b3b007b 3204 reloc_size += current->reloc_count * bfd_coff_relsz (abfd);
252b5132
RH		 3205
3206 lineno_base = reloc_base + reloc_size;
3207 sym_base = lineno_base + lnno_size;
3208
3209 /* Indicate in each section->line_filepos its actual file address */
3210 for (current = abfd->sections; current != NULL; current =
3211 current->next)
3212 {
3213 if (current->lineno_count)
3214 {
3215 current->line_filepos = lineno_base;
3216 current->moving_line_filepos = lineno_base;
6b3b007b 3217 lineno_base += current->lineno_count * bfd_coff_linesz (abfd);
252b5132
RH		 3218 }
3219 else
3220 {
3221 current->line_filepos = 0;
3222 }
3223 if (current->reloc_count)
3224 {
3225 current->rel_filepos = reloc_base;
6b3b007b 3226 reloc_base += current->reloc_count * bfd_coff_relsz (abfd);
252b5132
RH		 3227 }
3228 else
3229 {
3230 current->rel_filepos = 0;
3231 }
3232 }
3233
3234 /* Write section headers to the file. */
3235 internal_f.f_nscns = 0;
3236
3237 if ((abfd->flags & EXEC_P) != 0)
6b3b007b 3238 scn_base = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
252b5132
RH		 3239 else
3240 {
6b3b007b 3241 scn_base = bfd_coff_filhsz (abfd);
252b5132
RH		 3242#ifdef RS6000COFF_C
3243 if (xcoff_data (abfd)->full_aouthdr)
6b3b007b 3244 scn_base += bfd_coff_aoutsz (abfd);
252b5132
RH		 3245 else
3246 scn_base += SMALL_AOUTSZ;
3247#endif
3248 }
3249
3250 if (bfd_seek (abfd, scn_base, SEEK_SET) != 0)
3251 return false;
3252
3253 long_section_names = false;
3254 for (current = abfd->sections;
3255 current != NULL;
3256 current = current->next)
3257 {
3258 struct internal_scnhdr section;
4cfec37b 3259 boolean is_reloc_section = false;
252b5132
RH		 3260
3261#ifdef COFF_IMAGE_WITH_PE
3262 if (strcmp (current->name, ".reloc") == 0)
3263 {
4cfec37b
ILT		 3264 is_reloc_section = true;
3265 hasrelocs = true;
252b5132
RH		 3266 pe_data (abfd)->has_reloc_section = 1;
3267 }
3268#endif
3269
252b5132
RH		 3270 internal_f.f_nscns++;
3271
3272 strncpy (section.s_name, current->name, SCNNMLEN);
3273
3274#ifdef COFF_LONG_SECTION_NAMES
3275 /* Handle long section names as in PE. This must be compatible
00692651 3276 with the code in coff_write_symbols and _bfd_coff_final_link. */
252b5132
RH		 3277 {
3278 size_t len;
3279
3280 len = strlen (current->name);
3281 if (len > SCNNMLEN)
3282 {
3283 memset (section.s_name, 0, SCNNMLEN);
3284 sprintf (section.s_name, "/%lu", (unsigned long) string_size);
3285 string_size += len + 1;
3286 long_section_names = true;
3287 }
3288 }
3289#endif
3290
3291#ifdef _LIB
3292 /* Always set s_vaddr of .lib to 0. This is right for SVR3.2
3293 Ian Taylor <[email protected]>. */
3294 if (strcmp (current->name, _LIB) == 0)
3295 section.s_vaddr = 0;
3296 else
3297#endif
3298 section.s_vaddr = current->vma;
3299 section.s_paddr = current->lma;
3300 section.s_size = current->_raw_size;
b9af77f5
TW		 3301#ifdef coff_get_section_load_page
3302 section.s_page = coff_get_section_load_page (current);
3303#endif
252b5132
RH		 3304
3305#ifdef COFF_WITH_PE
3306 section.s_paddr = 0;
3307#endif
3308#ifdef COFF_IMAGE_WITH_PE
3309 /* Reminder: s_paddr holds the virtual size of the section. */
3310 if (coff_section_data (abfd, current) != NULL
3311 && pei_section_data (abfd, current) != NULL)
3312 section.s_paddr = pei_section_data (abfd, current)->virt_size;
3313 else
3314 section.s_paddr = 0;
3315#endif
3316
3317 /*
3318 If this section has no size or is unloadable then the scnptr
3319 will be 0 too
3320 */
3321 if (current->_raw_size == 0 ||
3322 (current->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
3323 {
3324 section.s_scnptr = 0;
3325 }
3326 else
3327 {
3328 section.s_scnptr = current->filepos;
3329 }
3330 section.s_relptr = current->rel_filepos;
3331 section.s_lnnoptr = current->line_filepos;
3332 section.s_nreloc = current->reloc_count;
3333 section.s_nlnno = current->lineno_count;
79207490
ILT		 3334#ifndef COFF_IMAGE_WITH_PE
3335 /* In PEI, relocs come in the .reloc section. */
252b5132
RH		 3336 if (current->reloc_count != 0)
3337 hasrelocs = true;
79207490 3338#endif
252b5132
RH		 3339 if (current->lineno_count != 0)
3340 haslinno = true;
4cfec37b
ILT		 3341 if ((current->flags & SEC_DEBUGGING) != 0
3342 && ! is_reloc_section)
3343 hasdebug = true;
252b5132 3344
7f6d05e8
CP		 3345#ifdef RS6000COFF_C
3346#ifndef XCOFF64
252b5132
RH		 3347 /* Indicate the use of an XCOFF overflow section header. */
3348 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3349 {
3350 section.s_nreloc = 0xffff;
3351 section.s_nlnno = 0xffff;
3352 }
7f6d05e8 3353#endif
252b5132
RH		 3354#endif
3355
3356 section.s_flags = sec_to_styp_flags (current->name, current->flags);
3357
3358 if (!strcmp (current->name, _TEXT))
3359 {
3360 text_sec = current;
3361 }
3362 else if (!strcmp (current->name, _DATA))
3363 {
3364 data_sec = current;
3365 }
3366 else if (!strcmp (current->name, _BSS))
3367 {
3368 bss_sec = current;
3369 }
3370
3371#ifdef I960
3372 section.s_align = (current->alignment_power
3373 ? 1 << current->alignment_power
3374 : 0);
81635ce4
TW		 3375#endif
3376#ifdef TIC80COFF
3377 /* TI COFF puts the alignment power in bits 8-11 of the flags */
252b5132
RH		 3378 section.s_flags |= (current->alignment_power & 0xF) << 8;
3379#endif
81635ce4
TW		 3380#ifdef COFF_ENCODE_ALIGNMENT
3381 COFF_ENCODE_ALIGNMENT(section, current->alignment_power);
252b5132
RH		 3382#endif
3383
3384#ifdef COFF_IMAGE_WITH_PE
00692651
ILT		 3385 /* Suppress output of the sections if they are null. ld
3386 includes the bss and data sections even if there is no size
3387 assigned to them. NT loader doesn't like it if these section
3388 headers are included if the sections themselves are not
3389 needed. See also coff_compute_section_file_positions. */
252b5132
RH		 3390 if (section.s_size == 0)
3391 internal_f.f_nscns--;
3392 else
3393#endif
3394 {
3395 SCNHDR buff;
3396 if (coff_swap_scnhdr_out (abfd, &section, &buff) == 0
6b3b007b
NC		 3397 || bfd_write ((PTR) (&buff), 1, bfd_coff_scnhsz (abfd), abfd)
3398 != bfd_coff_scnhsz (abfd))
252b5132
RH		 3399 return false;
3400 }
3401
3402#ifdef COFF_WITH_PE
3403 /* PE stores COMDAT section information in the symbol table. If
3404 this section is supposed to have some COMDAT info, track down
3405 the symbol in the symbol table and modify it. */
3406 if ((current->flags & SEC_LINK_ONCE) != 0)
3407 {
3408 unsigned int i, count;
3409 asymbol **psym;
3410 coff_symbol_type *csym = NULL;
3411 asymbol **psymsec;
3412
3413 psymsec = NULL;
3414 count = bfd_get_symcount (abfd);
3415 for (i = 0, psym = abfd->outsymbols; i < count; i++, psym++)
3416 {
3417 if ((*psym)->section != current)
3418 continue;
3419
3420 /* Remember the location of the first symbol in this
3421 section. */
3422 if (psymsec == NULL)
3423 psymsec = psym;
3424
3425 /* See if this is the section symbol. */
3426 if (strcmp ((*psym)->name, current->name) == 0)
3427 {
3428 csym = coff_symbol_from (abfd, *psym);
3429 if (csym == NULL
3430 || csym->native == NULL
3431 || csym->native->u.syment.n_numaux < 1
3432 || csym->native->u.syment.n_sclass != C_STAT
3433 || csym->native->u.syment.n_type != T_NULL)
3434 continue;
3435
3436 /* Here *PSYM is the section symbol for CURRENT. */
3437
3438 break;
3439 }
3440 }
3441
3442 /* Did we find it?
3443 Note that we might not if we're converting the file from
3444 some other object file format. */
3445 if (i < count)
3446 {
3447 combined_entry_type *aux;
3448
3449 /* We don't touch the x_checksum field. The
3450 x_associated field is not currently supported. */
3451
3452 aux = csym->native + 1;
3453 switch (current->flags & SEC_LINK_DUPLICATES)
3454 {
3455 case SEC_LINK_DUPLICATES_DISCARD:
3456 aux->u.auxent.x_scn.x_comdat = IMAGE_COMDAT_SELECT_ANY;
3457 break;
3458
3459 case SEC_LINK_DUPLICATES_ONE_ONLY:
3460 aux->u.auxent.x_scn.x_comdat =
3461 IMAGE_COMDAT_SELECT_NODUPLICATES;
3462 break;
3463
3464 case SEC_LINK_DUPLICATES_SAME_SIZE:
3465 aux->u.auxent.x_scn.x_comdat =
3466 IMAGE_COMDAT_SELECT_SAME_SIZE;
3467 break;
3468
3469 case SEC_LINK_DUPLICATES_SAME_CONTENTS:
3470 aux->u.auxent.x_scn.x_comdat =
3471 IMAGE_COMDAT_SELECT_EXACT_MATCH;
3472 break;
3473 }
3474
3475 /* The COMDAT symbol must be the first symbol from this
3476 section in the symbol table. In order to make this
3477 work, we move the COMDAT symbol before the first
3478 symbol we found in the search above. It's OK to
3479 rearrange the symbol table at this point, because
3480 coff_renumber_symbols is going to rearrange it
3481 further and fix up all the aux entries. */
3482 if (psym != psymsec)
3483 {
3484 asymbol *hold;
3485 asymbol **pcopy;
3486
3487 hold = *psym;
3488 for (pcopy = psym; pcopy > psymsec; pcopy--)
3489 pcopy[0] = pcopy[-1];
3490 *psymsec = hold;
3491 }
3492 }
3493 }
3494#endif /* COFF_WITH_PE */
3495 }
3496
3497#ifdef RS6000COFF_C
3498 /* XCOFF handles overflows in the reloc and line number count fields
3499 by creating a new section header to hold the correct values. */
3500 for (current = abfd->sections; current != NULL; current = current->next)
3501 {
3502 if (current->reloc_count >= 0xffff || current->lineno_count >= 0xffff)
3503 {
3504 struct internal_scnhdr scnhdr;
3505 SCNHDR buff;
3506
3507 internal_f.f_nscns++;
3508 strncpy (&(scnhdr.s_name[0]), current->name, 8);
3509 scnhdr.s_paddr = current->reloc_count;
3510 scnhdr.s_vaddr = current->lineno_count;
3511 scnhdr.s_size = 0;
3512 scnhdr.s_scnptr = 0;
3513 scnhdr.s_relptr = current->rel_filepos;
3514 scnhdr.s_lnnoptr = current->line_filepos;
3515 scnhdr.s_nreloc = current->target_index;
3516 scnhdr.s_nlnno = current->target_index;
3517 scnhdr.s_flags = STYP_OVRFLO;
3518 if (coff_swap_scnhdr_out (abfd, &scnhdr, &buff) == 0
6b3b007b
NC		 3519 || bfd_write ((PTR) &buff, 1, bfd_coff_scnhsz (abfd), abfd)
3520 != bfd_coff_scnhsz (abfd))
252b5132
RH		 3521 return false;
3522 }
3523 }
3524#endif
3525
3526 /* OK, now set up the filehdr... */
3527
3528 /* Don't include the internal abs section in the section count */
3529
3530 /*
3531 We will NOT put a fucking timestamp in the header here. Every time you
3532 put it back, I will come in and take it out again. I'm sorry. This
3533 field does not belong here. We fill it with a 0 so it compares the
3534 same but is not a reasonable time. -- [email protected]
3535 */
3536 internal_f.f_timdat = 0;
3537
3538 internal_f.f_flags = 0;
3539
3540 if (abfd->flags & EXEC_P)
6b3b007b 3541 internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
252b5132
RH		 3542 else
3543 {
3544 internal_f.f_opthdr = 0;
3545#ifdef RS6000COFF_C
3546 if (xcoff_data (abfd)->full_aouthdr)
6b3b007b 3547 internal_f.f_opthdr = bfd_coff_aoutsz (abfd);
252b5132
RH		 3548 else
3549 internal_f.f_opthdr = SMALL_AOUTSZ;
3550#endif
3551 }
3552
3553 if (!hasrelocs)
3554 internal_f.f_flags |= F_RELFLG;
3555 if (!haslinno)
3556 internal_f.f_flags |= F_LNNO;
3557 if (abfd->flags & EXEC_P)
3558 internal_f.f_flags |= F_EXEC;
4cfec37b
ILT		 3559#ifdef COFF_IMAGE_WITH_PE
3560 if (! hasdebug)
3561 internal_f.f_flags |= IMAGE_FILE_DEBUG_STRIPPED;
3562#endif
252b5132 3563
8a1ad8e7 3564#ifndef COFF_WITH_PE
252b5132
RH		 3565 if (bfd_little_endian (abfd))
3566 internal_f.f_flags |= F_AR32WR;
3567 else
3568 internal_f.f_flags |= F_AR32W;
8a1ad8e7 3569#endif
252b5132 3570
81635ce4
TW		 3571#ifdef TI_TARGET_ID
3572 /* target id is used in TI COFF v1 and later; COFF0 won't use this field,
3573 but it doesn't hurt to set it internally */
3574 internal_f.f_target_id = TI_TARGET_ID;
3575#endif
252b5132
RH		 3576#ifdef TIC80_TARGET_ID
3577 internal_f.f_target_id = TIC80_TARGET_ID;
3578#endif
3579
3580 /*
3581 FIXME, should do something about the other byte orders and
3582 architectures.
3583 */
3584
3585#ifdef RS6000COFF_C
3586 if ((abfd->flags & DYNAMIC) != 0)
3587 internal_f.f_flags |= F_SHROBJ;
3588 if (bfd_get_section_by_name (abfd, _LOADER) != NULL)
3589 internal_f.f_flags |= F_DYNLOAD;
3590#endif
3591
3592 memset (&internal_a, 0, sizeof internal_a);
3593
3594 /* Set up architecture-dependent stuff */
3595
3596 {
3597 unsigned int magic = 0;
3598 unsigned short flags = 0;
3599 coff_set_flags (abfd, &magic, &flags);
3600 internal_f.f_magic = magic;
3601 internal_f.f_flags |= flags;
3602 /* ...and the "opt"hdr... */
3603
3604#ifdef A29K
3605#ifdef ULTRA3 /* NYU's machine */
3606 /* FIXME: This is a bogus check. I really want to see if there
3607 * is a .shbss or a .shdata section, if so then set the magic
3608 * number to indicate a shared data executable.
3609 */
3610 if (internal_f.f_nscns >= 7)
3611 internal_a.magic = SHMAGIC; /* Shared magic */
3612 else
3613#endif /* ULTRA3 */
3614 internal_a.magic = NMAGIC; /* Assume separate i/d */
3615#define __A_MAGIC_SET__
3616#endif /* A29K */
81635ce4
TW		 3617#ifdef TICOFF_AOUT_MAGIC
3618 internal_a.magic = TICOFF_AOUT_MAGIC;
3619#define __A_MAGIC_SET__
3620#endif
252b5132
RH		 3621#ifdef TIC80COFF
3622 internal_a.magic = TIC80_ARCH_MAGIC;
3623#define __A_MAGIC_SET__
3624#endif /* TIC80 */
3625#ifdef I860
3626 /* FIXME: What are the a.out magic numbers for the i860? */
3627 internal_a.magic = 0;
3628#define __A_MAGIC_SET__
3629#endif /* I860 */
3630#ifdef I960
3631 internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
3632#define __A_MAGIC_SET__
3633#endif /* I960 */
3634#if M88
3635#define __A_MAGIC_SET__
3636 internal_a.magic = PAGEMAGICBCS;
3637#endif /* M88 */
3638
3639#if APOLLO_M68
3640#define __A_MAGIC_SET__
3641 internal_a.magic = APOLLO_COFF_VERSION_NUMBER;
3642#endif
3643
3644#if defined(M68) || defined(WE32K) || defined(M68K)
3645#define __A_MAGIC_SET__
3646#if defined(LYNXOS)
3647 internal_a.magic = LYNXCOFFMAGIC;
3648#else
3649#if defined(TARG_AUX)
3650 internal_a.magic = (abfd->flags & D_PAGED ? PAGEMAGICPEXECPAGED :
3651 abfd->flags & WP_TEXT ? PAGEMAGICPEXECSWAPPED :
3652 PAGEMAGICEXECSWAPPED);
3653#else
3654#if defined (PAGEMAGICPEXECPAGED)
3655 internal_a.magic = PAGEMAGICPEXECPAGED;
3656#endif
3657#endif /* TARG_AUX */
3658#endif /* LYNXOS */
3659#endif /* M68 || WE32K || M68K */
3660
3661#if defined(ARM)
3662#define __A_MAGIC_SET__
3663 internal_a.magic = ZMAGIC;
3664#endif
3665
3666#if defined(PPC_PE)
3667#define __A_MAGIC_SET__
3668 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
3669#endif
3670
3671#if defined MCORE_PE
3672#define __A_MAGIC_SET__
3673 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
3674#endif
3675
3676#if defined(I386)
3677#define __A_MAGIC_SET__
3678#if defined(LYNXOS)
3679 internal_a.magic = LYNXCOFFMAGIC;
3680#else /* LYNXOS */
3681 internal_a.magic = ZMAGIC;
3682#endif /* LYNXOS */
3683#endif /* I386 */
3684
fac41780
JW		 3685#if defined(IA64)
3686#define __A_MAGIC_SET__
3687 internal_a.magic = ZMAGIC;
3688#endif /* IA64 */
3689
252b5132
RH		 3690#if defined(SPARC)
3691#define __A_MAGIC_SET__
3692#if defined(LYNXOS)
3693 internal_a.magic = LYNXCOFFMAGIC;
3694#endif /* LYNXOS */
3695#endif /* SPARC */
3696
3697#ifdef RS6000COFF_C
3698#define __A_MAGIC_SET__
3699 internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC :
3700 (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC :
3701 RS6K_AOUTHDR_OMAGIC;
3702#endif
3703
17505c5c
NC		 3704#if defined(SH) && defined(COFF_WITH_PE)
3705#define __A_MAGIC_SET__
3706 internal_a.magic = SH_PE_MAGIC;
3707#endif
3708
3709#if defined(MIPS) && defined(COFF_WITH_PE)
3710#define __A_MAGIC_SET__
3711 internal_a.magic = MIPS_PE_MAGIC;
3712#endif
3713
252b5132
RH		 3714#ifndef __A_MAGIC_SET__
3715#include "Your aouthdr magic number is not being set!"
3716#else
3717#undef __A_MAGIC_SET__
3718#endif
3719 }
3720
3721 /* FIXME: Does anybody ever set this to another value? */
3722 internal_a.vstamp = 0;
3723
3724 /* Now should write relocs, strings, syms */
3725 obj_sym_filepos (abfd) = sym_base;
3726
3727 if (bfd_get_symcount (abfd) != 0)
3728 {
3729 int firstundef;
3730#if 0
3731 if (!coff_add_missing_symbols (abfd))
3732 return false;
3733#endif
3734 if (!coff_renumber_symbols (abfd, &firstundef))
3735 return false;
3736 coff_mangle_symbols (abfd);
3737 if (! coff_write_symbols (abfd))
3738 return false;
3739 if (! coff_write_linenumbers (abfd))
3740 return false;
3741 if (! coff_write_relocs (abfd, firstundef))
3742 return false;
3743 }
3744#ifdef COFF_LONG_SECTION_NAMES
3745 else if (long_section_names)
3746 {
3747 /* If we have long section names we have to write out the string
3748 table even if there are no symbols. */
3749 if (! coff_write_symbols (abfd))
3750 return false;
3751 }
3752#endif
3753#ifdef COFF_IMAGE_WITH_PE
3754#ifdef PPC_PE
3755 else if ((abfd->flags & EXEC_P) != 0)
3756 {
3757 bfd_byte b;
3758
3759 /* PowerPC PE appears to require that all executable files be
3760 rounded up to the page size. */
3761 b = 0;
3762 if (bfd_seek (abfd,
3763 BFD_ALIGN (sym_base, COFF_PAGE_SIZE) - 1,
3764 SEEK_SET) != 0
3765 || bfd_write (&b, 1, 1, abfd) != 1)
3766 return false;
3767 }
3768#endif
3769#endif
3770
3771 /* If bfd_get_symcount (abfd) != 0, then we are not using the COFF
3772 backend linker, and obj_raw_syment_count is not valid until after
3773 coff_write_symbols is called. */
3774 if (obj_raw_syment_count (abfd) != 0)
3775 {
3776 internal_f.f_symptr = sym_base;
3777#ifdef RS6000COFF_C
3778 /* AIX appears to require that F_RELFLG not be set if there are
3779 local symbols but no relocations. */
3780 internal_f.f_flags &=~ F_RELFLG;
3781#endif
3782 }
3783 else
3784 {
3785 if (long_section_names)
3786 internal_f.f_symptr = sym_base;
3787 else
3788 internal_f.f_symptr = 0;
3789 internal_f.f_flags |= F_LSYMS;
3790 }
3791
3792 if (text_sec)
3793 {
3794 internal_a.tsize = bfd_get_section_size_before_reloc (text_sec);
3795 internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
3796 }
3797 if (data_sec)
3798 {
3799 internal_a.dsize = bfd_get_section_size_before_reloc (data_sec);
3800 internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
3801 }
3802 if (bss_sec)
3803 {
3804 internal_a.bsize = bfd_get_section_size_before_reloc (bss_sec);
3805 if (internal_a.bsize && bss_sec->vma < internal_a.data_start)
3806 internal_a.data_start = bss_sec->vma;
3807 }
3808
3809 internal_a.entry = bfd_get_start_address (abfd);
3810 internal_f.f_nsyms = obj_raw_syment_count (abfd);
3811
3812#ifdef RS6000COFF_C
3813 if (xcoff_data (abfd)->full_aouthdr)
3814 {
3815 bfd_vma toc;
3816 asection *loader_sec;
3817
3818 internal_a.vstamp = 1;
3819
3820 internal_a.o_snentry = xcoff_data (abfd)->snentry;
3821 if (internal_a.o_snentry == 0)
3822 internal_a.entry = (bfd_vma) -1;
3823
3824 if (text_sec != NULL)
3825 {
3826 internal_a.o_sntext = text_sec->target_index;
3827 internal_a.o_algntext = bfd_get_section_alignment (abfd, text_sec);
3828 }
3829 else
3830 {
3831 internal_a.o_sntext = 0;
3832 internal_a.o_algntext = 0;
3833 }
3834 if (data_sec != NULL)
3835 {
3836 internal_a.o_sndata = data_sec->target_index;
3837 internal_a.o_algndata = bfd_get_section_alignment (abfd, data_sec);
3838 }
3839 else
3840 {
3841 internal_a.o_sndata = 0;
3842 internal_a.o_algndata = 0;
3843 }
3844 loader_sec = bfd_get_section_by_name (abfd, ".loader");
3845 if (loader_sec != NULL)
3846 internal_a.o_snloader = loader_sec->target_index;
3847 else
3848 internal_a.o_snloader = 0;
3849 if (bss_sec != NULL)
3850 internal_a.o_snbss = bss_sec->target_index;
3851 else
3852 internal_a.o_snbss = 0;
3853
3854 toc = xcoff_data (abfd)->toc;
3855 internal_a.o_toc = toc;
3856 internal_a.o_sntoc = xcoff_data (abfd)->sntoc;
3857
3858 internal_a.o_modtype = xcoff_data (abfd)->modtype;
3859 if (xcoff_data (abfd)->cputype != -1)
3860 internal_a.o_cputype = xcoff_data (abfd)->cputype;
3861 else
3862 {
3863 switch (bfd_get_arch (abfd))
3864 {
3865 case bfd_arch_rs6000:
3866 internal_a.o_cputype = 4;
3867 break;
3868 case bfd_arch_powerpc:
3869 if (bfd_get_mach (abfd) == 0)
3870 internal_a.o_cputype = 3;
3871 else
3872 internal_a.o_cputype = 1;
3873 break;
3874 default:
3875 abort ();
3876 }
3877 }
3878 internal_a.o_maxstack = xcoff_data (abfd)->maxstack;
3879 internal_a.o_maxdata = xcoff_data (abfd)->maxdata;
3880 }
3881#endif
3882
3883 /* now write them */
3884 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
3885 return false;
b5f303f0 3886
252b5132 3887 {
b5f303f0
NC		 3888 char * buff;
3889 bfd_size_type amount;
3890
3891 buff = bfd_malloc (bfd_coff_filhsz (abfd));
3892 if (buff == NULL)
3893 return false;
3894
252b5132 3895 coff_swap_filehdr_out (abfd, (PTR) & internal_f, (PTR) buff);
b5f303f0
NC		 3896 amount = bfd_write ((PTR) buff, 1, bfd_coff_filhsz (abfd), abfd);
3897
2fca4467 3898 free (buff);
b5f303f0
NC		 3899
3900 if (amount != bfd_coff_filhsz (abfd))
252b5132
RH		 3901 return false;
3902 }
b5f303f0 3903
252b5132
RH		 3904 if (abfd->flags & EXEC_P)
3905 {
3906 /* Note that peicode.h fills in a PEAOUTHDR, not an AOUTHDR.
3907 include/coff/pe.h sets AOUTSZ == sizeof(PEAOUTHDR)) */
b5f303f0
NC		 3908 char * buff;
3909 bfd_size_type amount;
3910
3911 buff = bfd_malloc (bfd_coff_aoutsz (abfd));
3912 if (buff == NULL)
3913 return false;
3914
252b5132 3915 coff_swap_aouthdr_out (abfd, (PTR) & internal_a, (PTR) buff);
b5f303f0
NC		 3916 amount = bfd_write ((PTR) buff, 1, bfd_coff_aoutsz (abfd), abfd);
3917
2fca4467 3918 free (buff);
b5f303f0
NC		 3919
3920 if (amount != bfd_coff_aoutsz (abfd))
252b5132
RH		 3921 return false;
3922 }
3923#ifdef RS6000COFF_C
3924 else
3925 {
3926 AOUTHDR buff;
3927 size_t size;
3928
3929 /* XCOFF seems to always write at least a small a.out header. */
3930 coff_swap_aouthdr_out (abfd, (PTR) &internal_a, (PTR) &buff);
3931 if (xcoff_data (abfd)->full_aouthdr)
6b3b007b 3932 size = bfd_coff_aoutsz (abfd);
252b5132
RH		 3933 else
3934 size = SMALL_AOUTSZ;
3935 if (bfd_write ((PTR) &buff, 1, size, abfd) != size)
3936 return false;
3937 }
3938#endif
3939
3940 return true;
3941}
3942
3943static boolean
3944coff_set_section_contents (abfd, section, location, offset, count)
3945 bfd * abfd;
3946 sec_ptr section;
3947 PTR location;
3948 file_ptr offset;
3949 bfd_size_type count;
3950{
3951 if (abfd->output_has_begun == false) /* set by bfd.c handler */
3952 {
3953 if (! coff_compute_section_file_positions (abfd))
3954 return false;
3955 }
3956
3957#if defined(_LIB) && !defined(TARG_AUX)
3958
3959 /* The physical address field of a .lib section is used to hold the
3960 number of shared libraries in the section. This code counts the
3961 number of sections being written, and increments the lma field
3962 with the number.
3963
3964 I have found no documentation on the contents of this section.
3965 Experimentation indicates that the section contains zero or more
3966 records, each of which has the following structure:
3967
3968 - a (four byte) word holding the length of this record, in words,
3969 - a word that always seems to be set to "2",
3970 - the path to a shared library, null-terminated and then padded
3971 to a whole word boundary.
3972
3973 bfd_assert calls have been added to alert if an attempt is made
3974 to write a section which doesn't follow these assumptions. The
3975 code has been tested on ISC 4.1 by me, and on SCO by Robert Lipe
3976 <[email protected]> (Thanks!).
3977
3978 Gvran Uddeborg <[email protected]> */
3979
3980 if (strcmp (section->name, _LIB) == 0)
3981 {
3982 bfd_byte *rec, *recend;
3983
3984 rec = (bfd_byte *) location;
3985 recend = rec + count;
3986 while (rec < recend)
3987 {
3988 ++section->lma;
3989 rec += bfd_get_32 (abfd, rec) * 4;
3990 }
3991
3992 BFD_ASSERT (rec == recend);
3993 }
3994
3995#endif
3996
3997 /* Don't write out bss sections - one way to do this is to
3998 see if the filepos has not been set. */
3999 if (section->filepos == 0)
4000 return true;
4001
4002 if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) != 0)
4003 return false;
4004
4005 if (count != 0)
4006 {
4007 return (bfd_write (location, 1, count, abfd) == count) ? true : false;
4008 }
4009 return true;
4010}
4011#if 0
4012static boolean
4013coff_close_and_cleanup (abfd)
4014 bfd *abfd;
4015{
4016 if (!bfd_read_p (abfd))
4017 switch (abfd->format)
4018 {
4019 case bfd_archive:
4020 if (!_bfd_write_archive_contents (abfd))
4021 return false;
4022 break;
4023 case bfd_object:
4024 if (!coff_write_object_contents (abfd))
4025 return false;
4026 break;
4027 default:
4028 bfd_set_error (bfd_error_invalid_operation);
4029 return false;
4030 }
4031
4032 /* We depend on bfd_close to free all the memory on the objalloc. */
4033 return true;
4034}
4035
4036#endif
4037
4038static PTR
4039buy_and_read (abfd, where, seek_direction, size)
4040 bfd *abfd;
4041 file_ptr where;
4042 int seek_direction;
4043 size_t size;
4044{
4045 PTR area = (PTR) bfd_alloc (abfd, size);
4046 if (!area)
4047 return (NULL);
4048 if (bfd_seek (abfd, where, seek_direction) != 0
4049 || bfd_read (area, 1, size, abfd) != size)
4050 return (NULL);
4051 return (area);
4052} /* buy_and_read() */
4053
4054/*
4055SUBSUBSECTION
4056 Reading linenumbers
4057
4058 Creating the linenumber table is done by reading in the entire
4059 coff linenumber table, and creating another table for internal use.
4060
4061 A coff linenumber table is structured so that each function
4062 is marked as having a line number of 0. Each line within the
4063 function is an offset from the first line in the function. The
4064 base of the line number information for the table is stored in
4065 the symbol associated with the function.
4066
00692651
ILT		 4067 Note: The PE format uses line number 0 for a flag indicating a
4068 new source file.
4069
252b5132
RH		 4070 The information is copied from the external to the internal
4071 table, and each symbol which marks a function is marked by
4072 pointing its...
4073
4074 How does this work ?
4075
4076*/
4077
4078static boolean
4079coff_slurp_line_table (abfd, asect)
4080 bfd *abfd;
4081 asection *asect;
4082{
4083 LINENO *native_lineno;
4084 alent *lineno_cache;
4085
4086 BFD_ASSERT (asect->lineno == (alent *) NULL);
4087
4088 native_lineno = (LINENO *) buy_and_read (abfd,
4089 asect->line_filepos,
4090 SEEK_SET,
6b3b007b 4091 (size_t) (bfd_coff_linesz (abfd) *
252b5132
RH		 4092 asect->lineno_count));
4093 lineno_cache =
4094 (alent *) bfd_alloc (abfd, (size_t) ((asect->lineno_count + 1) * sizeof (alent)));
4095 if (lineno_cache == NULL)
4096 return false;
4097 else
4098 {
4099 unsigned int counter = 0;
4100 alent *cache_ptr = lineno_cache;
4101 LINENO *src = native_lineno;
4102
4103 while (counter < asect->lineno_count)
4104 {
4105 struct internal_lineno dst;
7f6d05e8 4106 bfd_coff_swap_lineno_in (abfd, src, &dst);
252b5132
RH		 4107 cache_ptr->line_number = dst.l_lnno;
4108
4109 if (cache_ptr->line_number == 0)
4110 {
4111 boolean warned;
4112 long symndx;
4113 coff_symbol_type *sym;
4114
4115 warned = false;
4116 symndx = dst.l_addr.l_symndx;
4117 if (symndx < 0
4118 || (unsigned long) symndx >= obj_raw_syment_count (abfd))
4119 {
4120 (*_bfd_error_handler)
4121 (_("%s: warning: illegal symbol index %ld in line numbers"),
4122 bfd_get_filename (abfd), dst.l_addr.l_symndx);
4123 symndx = 0;
4124 warned = true;
4125 }
4126 /* FIXME: We should not be casting between ints and
4127 pointers like this. */
4128 sym = ((coff_symbol_type *)
4129 ((symndx + obj_raw_syments (abfd))
4130 ->u.syment._n._n_n._n_zeroes));
4131 cache_ptr->u.sym = (asymbol *) sym;
4132 if (sym->lineno != NULL && ! warned)
4133 {
4134 (*_bfd_error_handler)
4135 (_("%s: warning: duplicate line number information for `%s'"),
4136 bfd_get_filename (abfd),
4137 bfd_asymbol_name (&sym->symbol));
4138 }
4139 sym->lineno = cache_ptr;
4140 }
4141 else
4142 {
4143 cache_ptr->u.offset = dst.l_addr.l_paddr
4144 - bfd_section_vma (abfd, asect);
4145 } /* If no linenumber expect a symbol index */
4146
4147 cache_ptr++;
4148 src++;
4149 counter++;
4150 }
4151 cache_ptr->line_number = 0;
4152
4153 }
4154 asect->lineno = lineno_cache;
4155 /* FIXME, free native_lineno here, or use alloca or something. */
4156 return true;
4157}
4158
00692651
ILT		 4159/* Slurp in the symbol table, converting it to generic form. Note
4160 that if coff_relocate_section is defined, the linker will read
4161 symbols via coff_link_add_symbols, rather than via this routine. */
4162
252b5132
RH		 4163static boolean
4164coff_slurp_symbol_table (abfd)
4165 bfd * abfd;
4166{
4167 combined_entry_type *native_symbols;
4168 coff_symbol_type *cached_area;
4169 unsigned int *table_ptr;
4170
4171 unsigned int number_of_symbols = 0;
4172
4173 if (obj_symbols (abfd))
4174 return true;
4175
4176 /* Read in the symbol table */
4177 if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL)
4178 {
4179 return (false);
4180 } /* on error */
4181
4182 /* Allocate enough room for all the symbols in cached form */
4183 cached_area = ((coff_symbol_type *)
4184 bfd_alloc (abfd,
4185 (obj_raw_syment_count (abfd)
4186 * sizeof (coff_symbol_type))));
4187
4188 if (cached_area == NULL)
4189 return false;
4190 table_ptr = ((unsigned int *)
4191 bfd_alloc (abfd,
4192 (obj_raw_syment_count (abfd)
4193 * sizeof (unsigned int))));
4194
4195 if (table_ptr == NULL)
4196 return false;
4197 else
4198 {
4199 coff_symbol_type *dst = cached_area;
4200 unsigned int last_native_index = obj_raw_syment_count (abfd);
4201 unsigned int this_index = 0;
4202 while (this_index < last_native_index)
4203 {
4204 combined_entry_type *src = native_symbols + this_index;
4205 table_ptr[this_index] = number_of_symbols;
4206 dst->symbol.the_bfd = abfd;
4207
4208 dst->symbol.name = (char *) (src->u.syment._n._n_n._n_offset);
4209 /* We use the native name field to point to the cached field. */
4210 src->u.syment._n._n_n._n_zeroes = (long) dst;
4211 dst->symbol.section = coff_section_from_bfd_index (abfd,
4212 src->u.syment.n_scnum);
4213 dst->symbol.flags = 0;
4214 dst->done_lineno = false;
4215
4216 switch (src->u.syment.n_sclass)
4217 {
4218#ifdef I960
4219 case C_LEAFEXT:
4220#if 0
4221 dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
4222 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
4223 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4224#endif
4225 /* Fall through to next case */
4226
4227#endif
4228
4229 case C_EXT:
4230 case C_WEAKEXT:
4231#if defined ARM
4232 case C_THUMBEXT:
4233 case C_THUMBEXTFUNC:
4234#endif
4235#ifdef RS6000COFF_C
4236 case C_HIDEXT:
4237#endif
4238#ifdef C_SYSTEM
4239 case C_SYSTEM: /* System Wide variable */
4240#endif
4241#ifdef COFF_WITH_PE
5d54c628 4242 /* In PE, 0x68 (104) denotes a section symbol */
252b5132 4243 case C_SECTION:
5d54c628 4244 /* In PE, 0x69 (105) denotes a weak external symbol. */
252b5132
RH		 4245 case C_NT_WEAK:
4246#endif
5d54c628 4247 switch (coff_classify_symbol (abfd, &src->u.syment))
252b5132 4248 {
5d54c628 4249 case COFF_SYMBOL_GLOBAL:
252b5132 4250 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
252b5132
RH		 4251#if defined COFF_WITH_PE
4252 /* PE sets the symbol to a value relative to the
4253 start of the section. */
4254 dst->symbol.value = src->u.syment.n_value;
4255#else
4256 dst->symbol.value = (src->u.syment.n_value
4257 - dst->symbol.section->vma);
4258#endif
252b5132
RH		 4259 if (ISFCN ((src->u.syment.n_type)))
4260 {
4261 /* A function ext does not go at the end of a
4262 file. */
4263 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4264 }
5d54c628
ILT		 4265 break;
4266
4267 case COFF_SYMBOL_COMMON:
4268 dst->symbol.section = bfd_com_section_ptr;
4269 dst->symbol.value = src->u.syment.n_value;
4270 break;
4271
4272 case COFF_SYMBOL_UNDEFINED:
4273 dst->symbol.section = bfd_und_section_ptr;
4274 dst->symbol.value = 0;
4275 break;
4276
4277 case COFF_SYMBOL_PE_SECTION:
4278 dst->symbol.flags |= BSF_EXPORT | BSF_SECTION_SYM;
4279 dst->symbol.value = 0;
4280 break;
4281
4282 case COFF_SYMBOL_LOCAL:
4283 dst->symbol.flags = BSF_LOCAL;
4284#if defined COFF_WITH_PE
4285 /* PE sets the symbol to a value relative to the
4286 start of the section. */
4287 dst->symbol.value = src->u.syment.n_value;
4288#else
4289 dst->symbol.value = (src->u.syment.n_value
4290 - dst->symbol.section->vma);
4291#endif
4292 if (ISFCN ((src->u.syment.n_type)))
4293 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
4294 break;
252b5132
RH		 4295 }
4296
4297#ifdef RS6000COFF_C
252b5132
RH		 4298 /* A symbol with a csect entry should not go at the end. */
4299 if (src->u.syment.n_numaux > 0)
4300 dst->symbol.flags |= BSF_NOT_AT_END;
4301#endif
4302
4303#ifdef COFF_WITH_PE
4304 if (src->u.syment.n_sclass == C_NT_WEAK)
4305 dst->symbol.flags = BSF_WEAK;
ec0ef80e
DD		 4306 if (src->u.syment.n_sclass == C_SECTION
4307 && src->u.syment.n_scnum > 0)
4308 {
4309 dst->symbol.flags = BSF_LOCAL;
4310 }
252b5132
RH		 4311#endif
4312
4313 if (src->u.syment.n_sclass == C_WEAKEXT)
4314 dst->symbol.flags = BSF_WEAK;
4315
4316 break;
4317
4318 case C_STAT: /* static */
4319#ifdef I960
4320 case C_LEAFSTAT: /* static leaf procedure */
4321#endif
4322#if defined ARM
4323 case C_THUMBSTAT: /* Thumb static */
4324 case C_THUMBLABEL: /* Thumb label */
4325 case C_THUMBSTATFUNC:/* Thumb static function */
4326#endif
4327 case C_LABEL: /* label */
00692651 4328 if (src->u.syment.n_scnum == N_DEBUG)
252b5132
RH		 4329 dst->symbol.flags = BSF_DEBUGGING;
4330 else
4331 dst->symbol.flags = BSF_LOCAL;
4332
4333 /* Base the value as an index from the base of the
4334 section, if there is one. */
4335 if (dst->symbol.section)
4336 {
4337#if defined COFF_WITH_PE
4338 /* PE sets the symbol to a value relative to the
4339 start of the section. */
4340 dst->symbol.value = src->u.syment.n_value;
4341#else
4342 dst->symbol.value = (src->u.syment.n_value
4343 - dst->symbol.section->vma);
4344#endif
4345 }
4346 else
4347 dst->symbol.value = src->u.syment.n_value;
4348 break;
4349
4350 case C_MOS: /* member of structure */
4351 case C_EOS: /* end of structure */
4352#ifdef NOTDEF /* C_AUTOARG has the same value */
4353#ifdef C_GLBLREG
4354 case C_GLBLREG: /* A29k-specific storage class */
4355#endif
4356#endif
4357 case C_REGPARM: /* register parameter */
4358 case C_REG: /* register variable */
81635ce4
TW		 4359 /* C_AUTOARG conflictes with TI COFF C_UEXT */
4360#if !defined (TIC80COFF) && !defined (TICOFF)
252b5132
RH		 4361#ifdef C_AUTOARG
4362 case C_AUTOARG: /* 960-specific storage class */
4363#endif
4364#endif
4365 case C_TPDEF: /* type definition */
4366 case C_ARG:
4367 case C_AUTO: /* automatic variable */
4368 case C_FIELD: /* bit field */
4369 case C_ENTAG: /* enumeration tag */
4370 case C_MOE: /* member of enumeration */
4371 case C_MOU: /* member of union */
4372 case C_UNTAG: /* union tag */
4373 dst->symbol.flags = BSF_DEBUGGING;
4374 dst->symbol.value = (src->u.syment.n_value);
4375 break;
4376
4377 case C_FILE: /* file name */
4378 case C_STRTAG: /* structure tag */
4379#ifdef RS6000COFF_C
4380 case C_GSYM:
4381 case C_LSYM:
4382 case C_PSYM:
4383 case C_RSYM:
4384 case C_RPSYM:
4385 case C_STSYM:
4386 case C_BCOMM:
4387 case C_ECOMM:
4388 case C_DECL:
4389 case C_ENTRY:
4390 case C_FUN:
4391 case C_ESTAT:
4392#endif
4393 dst->symbol.flags = BSF_DEBUGGING;
4394 dst->symbol.value = (src->u.syment.n_value);
4395 break;
4396
4397#ifdef RS6000COFF_C
4398 case C_BINCL: /* beginning of include file */
4399 case C_EINCL: /* ending of include file */
4400 /* The value is actually a pointer into the line numbers
4401 of the file. We locate the line number entry, and
4402 set the section to the section which contains it, and
4403 the value to the index in that section. */
4404 {
4405 asection *sec;
4406
4407 dst->symbol.flags = BSF_DEBUGGING;
4408 for (sec = abfd->sections; sec != NULL; sec = sec->next)
4409 if (sec->line_filepos <= (file_ptr) src->u.syment.n_value
4410 && ((file_ptr) (sec->line_filepos
6b3b007b 4411 + sec->lineno_count * bfd_coff_linesz (abfd))
252b5132
RH		 4412 > (file_ptr) src->u.syment.n_value))
4413 break;
4414 if (sec == NULL)
4415 dst->symbol.value = 0;
4416 else
4417 {
4418 dst->symbol.section = sec;
4419 dst->symbol.value = ((src->u.syment.n_value
4420 - sec->line_filepos)
6b3b007b 4421 / bfd_coff_linesz (abfd));
252b5132
RH		 4422 src->fix_line = 1;
4423 }
4424 }
4425 break;
4426
4427 case C_BSTAT:
4428 dst->symbol.flags = BSF_DEBUGGING;
4429
4430 /* The value is actually a symbol index. Save a pointer
4431 to the symbol instead of the index. FIXME: This
4432 should use a union. */
4433 src->u.syment.n_value =
4434 (long) (native_symbols + src->u.syment.n_value);
4435 dst->symbol.value = src->u.syment.n_value;
4436 src->fix_value = 1;
4437 break;
4438#endif
4439
4440 case C_BLOCK: /* ".bb" or ".eb" */
d510f9a6 4441 case C_FCN: /* ".bf" or ".ef" (or PE ".lf") */
252b5132 4442 case C_EFCN: /* physical end of function */
252b5132
RH		 4443#if defined COFF_WITH_PE
4444 /* PE sets the symbol to a value relative to the start
4445 of the section. */
4446 dst->symbol.value = src->u.syment.n_value;
d510f9a6
ILT		 4447 if (strcmp (dst->symbol.name, ".bf") != 0)
4448 {
4449 /* PE uses funny values for .ef and .lf; don't
4450 relocate them. */
4451 dst->symbol.flags = BSF_DEBUGGING;
4452 }
4453 else
4454 dst->symbol.flags = BSF_DEBUGGING | BSF_DEBUGGING_RELOC;
252b5132
RH		 4455#else
4456 /* Base the value as an index from the base of the
4457 section. */
d510f9a6 4458 dst->symbol.flags = BSF_LOCAL;
252b5132
RH		 4459 dst->symbol.value = (src->u.syment.n_value
4460 - dst->symbol.section->vma);
4461#endif
4462 break;
4463
34cbe64e
TW		 4464 case C_STATLAB: /* Static load time label */
4465 dst->symbol.value = src->u.syment.n_value;
4466 dst->symbol.flags = BSF_GLOBAL;
4467 break;
4468
252b5132 4469 case C_NULL:
00692651
ILT		 4470 /* PE DLLs sometimes have zeroed out symbols for some
4471 reason. Just ignore them without a warning. */
4472 if (src->u.syment.n_type == 0
4473 && src->u.syment.n_value == 0
4474 && src->u.syment.n_scnum == 0)
4475 break;
4476 /* Fall through. */
252b5132
RH		 4477 case C_EXTDEF: /* external definition */
4478 case C_ULABEL: /* undefined label */
4479 case C_USTATIC: /* undefined static */
4480#ifndef COFF_WITH_PE
4481 /* C_LINE in regular coff is 0x68. NT has taken over this storage
4482 class to represent a section symbol */
4483 case C_LINE: /* line # reformatted as symbol table entry */
4484 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
4485 case C_ALIAS: /* duplicate tag */
4486#endif
81635ce4
TW		 4487 /* New storage classes for TI COFF */
4488#if defined(TIC80COFF) || defined(TICOFF)
252b5132
RH		 4489 case C_UEXT: /* Tentative external definition */
4490#endif
252b5132
RH		 4491 case C_EXTLAB: /* External load time label */
4492 case C_HIDDEN: /* ext symbol in dmert public lib */
4493 default:
4494 (*_bfd_error_handler)
4495 (_("%s: Unrecognized storage class %d for %s symbol `%s'"),
4496 bfd_get_filename (abfd), src->u.syment.n_sclass,
4497 dst->symbol.section->name, dst->symbol.name);
4498 dst->symbol.flags = BSF_DEBUGGING;
4499 dst->symbol.value = (src->u.syment.n_value);
4500 break;
4501 }
4502
4503/* BFD_ASSERT(dst->symbol.flags != 0);*/
4504
4505 dst->native = src;
4506
4507 dst->symbol.udata.i = 0;
4508 dst->lineno = (alent *) NULL;
4509 this_index += (src->u.syment.n_numaux) + 1;
4510 dst++;
4511 number_of_symbols++;
4512 } /* walk the native symtab */
4513 } /* bfdize the native symtab */
4514
4515 obj_symbols (abfd) = cached_area;
4516 obj_raw_syments (abfd) = native_symbols;
4517
4518 bfd_get_symcount (abfd) = number_of_symbols;
4519 obj_convert (abfd) = table_ptr;
4520 /* Slurp the line tables for each section too */
4521 {
4522 asection *p;
4523 p = abfd->sections;
4524 while (p)
4525 {
4526 coff_slurp_line_table (abfd, p);
4527 p = p->next;
4528 }
4529 }
4530 return true;
4531} /* coff_slurp_symbol_table() */
4532
5d54c628
ILT		 4533/* Classify a COFF symbol. A couple of targets have globally visible
4534 symbols which are not class C_EXT, and this handles those. It also
4535 recognizes some special PE cases. */
252b5132 4536
5d54c628
ILT		 4537static enum coff_symbol_classification
4538coff_classify_symbol (abfd, syment)
4539 bfd *abfd;
4540 struct internal_syment *syment;
4541{
4542 /* FIXME: This partially duplicates the switch in
4543 coff_slurp_symbol_table. */
4544 switch (syment->n_sclass)
4545 {
4546 case C_EXT:
4547 case C_WEAKEXT:
252b5132 4548#ifdef I960
5d54c628 4549 case C_LEAFEXT:
252b5132 4550#endif
5d54c628
ILT		 4551#ifdef ARM
4552 case C_THUMBEXT:
4553 case C_THUMBEXTFUNC:
252b5132 4554#endif
5d54c628
ILT		 4555#ifdef C_SYSTEM
4556 case C_SYSTEM:
252b5132 4557#endif
5d54c628
ILT		 4558#ifdef COFF_WITH_PE
4559 case C_NT_WEAK:
4560#endif
4561 if (syment->n_scnum == 0)
4562 {
4563 if (syment->n_value == 0)
4564 return COFF_SYMBOL_UNDEFINED;
4565 else
4566 return COFF_SYMBOL_COMMON;
4567 }
4568 return COFF_SYMBOL_GLOBAL;
4569
4570 default:
4571 break;
4572 }
252b5132 4573
5d54c628
ILT		 4574#ifdef COFF_WITH_PE
4575 if (syment->n_sclass == C_STAT)
4576 {
4577 if (syment->n_scnum == 0)
4578 {
4579 /* The Microsoft compiler sometimes generates these if a
4580 small static function is inlined every time it is used.
4581 The function is discarded, but the symbol table entry
4582 remains. */
4583 return COFF_SYMBOL_LOCAL;
4584 }
252b5132 4585
0717ebb7 4586#ifdef STRICT_PE_FORMAT
bd826630
ILT		 4587 /* This is correct for Microsoft generated objects, but it
4588 breaks gas generated objects. */
4589
5d54c628
ILT		 4590 if (syment->n_value == 0)
4591 {
4592 asection *sec;
4593 char buf[SYMNMLEN + 1];
4594
4595 sec = coff_section_from_bfd_index (abfd, syment->n_scnum);
4596 if (sec != NULL
4597 && (strcmp (bfd_get_section_name (abfd, sec),
4598 _bfd_coff_internal_syment_name (abfd, syment, buf))
4599 == 0))
4600 return COFF_SYMBOL_PE_SECTION;
4601 }
bd826630 4602#endif
252b5132 4603
5d54c628
ILT		 4604 return COFF_SYMBOL_LOCAL;
4605 }
252b5132 4606
5d54c628
ILT		 4607 if (syment->n_sclass == C_SECTION)
4608 {
4609 /* In some cases in a DLL generated by the Microsoft linker, the
4610 n_value field will contain garbage. FIXME: This should
4611 probably be handled by the swapping function instead. */
4612 syment->n_value = 0;
4613 if (syment->n_scnum == 0)
4614 return COFF_SYMBOL_UNDEFINED;
4615 return COFF_SYMBOL_PE_SECTION;
4616 }
4617#endif /* COFF_WITH_PE */
252b5132 4618
5d54c628 4619 /* If it is not a global symbol, we presume it is a local symbol. */
252b5132 4620
5d54c628
ILT		 4621 if (syment->n_scnum == 0)
4622 {
4623 char buf[SYMNMLEN + 1];
252b5132 4624
5d54c628
ILT		 4625 (*_bfd_error_handler)
4626 (_("warning: %s: local symbol `%s' has no section"),
4627 bfd_get_filename (abfd),
4628 _bfd_coff_internal_syment_name (abfd, syment, buf));
4629 }
252b5132 4630
5d54c628
ILT		 4631 return COFF_SYMBOL_LOCAL;
4632}
252b5132
RH		 4633
4634/*
4635SUBSUBSECTION
4636 Reading relocations
4637
4638 Coff relocations are easily transformed into the internal BFD form
4639 (@code{arelent}).
4640
4641 Reading a coff relocation table is done in the following stages:
4642
4643 o Read the entire coff relocation table into memory.
4644
4645 o Process each relocation in turn; first swap it from the
4646 external to the internal form.
4647
4648 o Turn the symbol referenced in the relocation's symbol index
4649 into a pointer into the canonical symbol table.
4650 This table is the same as the one returned by a call to
4651 @code{bfd_canonicalize_symtab}. The back end will call that
4652 routine and save the result if a canonicalization hasn't been done.
4653
4654 o The reloc index is turned into a pointer to a howto
4655 structure, in a back end specific way. For instance, the 386
4656 and 960 use the @code{r_type} to directly produce an index
4657 into a howto table vector; the 88k subtracts a number from the
4658 @code{r_type} field and creates an addend field.
4659
4660
4661*/
4662
4663#ifndef CALC_ADDEND
4664#define CALC_ADDEND(abfd, ptr, reloc, cache_ptr) \
4665 { \
4666 coff_symbol_type *coffsym = (coff_symbol_type *) NULL; \
4667 if (ptr && bfd_asymbol_bfd (ptr) != abfd) \
4668 coffsym = (obj_symbols (abfd) \
4669 + (cache_ptr->sym_ptr_ptr - symbols)); \
4670 else if (ptr) \
4671 coffsym = coff_symbol_from (abfd, ptr); \
4672 if (coffsym != (coff_symbol_type *) NULL \
4673 && coffsym->native->u.syment.n_scnum == 0) \
4674 cache_ptr->addend = 0; \
4675 else if (ptr && bfd_asymbol_bfd (ptr) == abfd \
4676 && ptr->section != (asection *) NULL) \
4677 cache_ptr->addend = - (ptr->section->vma + ptr->value); \
4678 else \
4679 cache_ptr->addend = 0; \
4680 }
4681#endif
4682
4683static boolean
4684coff_slurp_reloc_table (abfd, asect, symbols)
4685 bfd * abfd;
4686 sec_ptr asect;
4687 asymbol ** symbols;
4688{
4689 RELOC *native_relocs;
4690 arelent *reloc_cache;
4691 arelent *cache_ptr;
4692
4693 unsigned int idx;
4694
4695 if (asect->relocation)
4696 return true;
4697 if (asect->reloc_count == 0)
4698 return true;
4699 if (asect->flags & SEC_CONSTRUCTOR)
4700 return true;
4701 if (!coff_slurp_symbol_table (abfd))
4702 return false;
4703 native_relocs =
4704 (RELOC *) buy_and_read (abfd,
4705 asect->rel_filepos,
4706 SEEK_SET,
6b3b007b 4707 (size_t) (bfd_coff_relsz (abfd) *
252b5132
RH		 4708 asect->reloc_count));
4709 reloc_cache = (arelent *)
4710 bfd_alloc (abfd, (size_t) (asect->reloc_count * sizeof (arelent)));
4711
4712 if (reloc_cache == NULL)
4713 return false;
4714
4715
4716 for (idx = 0; idx < asect->reloc_count; idx++)
4717 {
4718 struct internal_reloc dst;
4719 struct external_reloc *src;
4720#ifndef RELOC_PROCESSING
4721 asymbol *ptr;
4722#endif
4723
4724 cache_ptr = reloc_cache + idx;
4725 src = native_relocs + idx;
4726
4727 coff_swap_reloc_in (abfd, src, &dst);
4728
4729#ifdef RELOC_PROCESSING
4730 RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
4731#else
4732 cache_ptr->address = dst.r_vaddr;
4733
4734 if (dst.r_symndx != -1)
4735 {
4736 if (dst.r_symndx < 0 || dst.r_symndx >= obj_conv_table_size (abfd))
4737 {
4738 (*_bfd_error_handler)
4739 (_("%s: warning: illegal symbol index %ld in relocs"),
4740 bfd_get_filename (abfd), dst.r_symndx);
4741 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
4742 ptr = NULL;
4743 }
4744 else
4745 {
4746 cache_ptr->sym_ptr_ptr = (symbols
4747 + obj_convert (abfd)[dst.r_symndx]);
4748 ptr = *(cache_ptr->sym_ptr_ptr);
4749 }
4750 }
4751 else
4752 {
4753 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
4754 ptr = NULL;
4755 }
4756
4757 /* The symbols definitions that we have read in have been
4758 relocated as if their sections started at 0. But the offsets
4759 refering to the symbols in the raw data have not been
4760 modified, so we have to have a negative addend to compensate.
4761
4762 Note that symbols which used to be common must be left alone */
4763
4764 /* Calculate any reloc addend by looking at the symbol */
4765 CALC_ADDEND (abfd, ptr, dst, cache_ptr);
4766
4767 cache_ptr->address -= asect->vma;
4768/* !! cache_ptr->section = (asection *) NULL;*/
4769
4770 /* Fill in the cache_ptr->howto field from dst.r_type */
4771 RTYPE2HOWTO (cache_ptr, &dst);
4772#endif /* RELOC_PROCESSING */
4773
4774 if (cache_ptr->howto == NULL)
4775 {
4776 (*_bfd_error_handler)
4777 (_("%s: illegal relocation type %d at address 0x%lx"),
4778 bfd_get_filename (abfd), dst.r_type, (long) dst.r_vaddr);
4779 bfd_set_error (bfd_error_bad_value);
4780 return false;
4781 }
4782 }
4783
4784 asect->relocation = reloc_cache;
4785 return true;
4786}
4787
4788#ifndef coff_rtype_to_howto
4789#ifdef RTYPE2HOWTO
4790
4791/* Get the howto structure for a reloc. This is only used if the file
4792 including this one defines coff_relocate_section to be
4793 _bfd_coff_generic_relocate_section, so it is OK if it does not
4794 always work. It is the responsibility of the including file to
4795 make sure it is reasonable if it is needed. */
4796
4797static reloc_howto_type *coff_rtype_to_howto
4798 PARAMS ((bfd *, asection *, struct internal_reloc *,
4799 struct coff_link_hash_entry *, struct internal_syment *,
4800 bfd_vma *));
4801
4802/*ARGSUSED*/
4803static reloc_howto_type *
4804coff_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
5f771d47
ILT		 4805 bfd *abfd ATTRIBUTE_UNUSED;
4806 asection *sec ATTRIBUTE_UNUSED;
252b5132 4807 struct internal_reloc *rel;
5f771d47
ILT		 4808 struct coff_link_hash_entry *h ATTRIBUTE_UNUSED;
4809 struct internal_syment *sym ATTRIBUTE_UNUSED;
4810 bfd_vma *addendp ATTRIBUTE_UNUSED;
252b5132
RH		 4811{
4812 arelent genrel;
4813
4814 RTYPE2HOWTO (&genrel, rel);
4815 return genrel.howto;
4816}
4817
4818#else /* ! defined (RTYPE2HOWTO) */
4819
4820#define coff_rtype_to_howto NULL
4821
4822#endif /* ! defined (RTYPE2HOWTO) */
4823#endif /* ! defined (coff_rtype_to_howto) */
4824
4825/* This is stupid. This function should be a boolean predicate. */
4826static long
4827coff_canonicalize_reloc (abfd, section, relptr, symbols)
4828 bfd * abfd;
4829 sec_ptr section;
4830 arelent ** relptr;
4831 asymbol ** symbols;
4832{
4833 arelent *tblptr = section->relocation;
4834 unsigned int count = 0;
4835
4836
4837 if (section->flags & SEC_CONSTRUCTOR)
4838 {
4839 /* this section has relocs made up by us, they are not in the
4840 file, so take them out of their chain and place them into
4841 the data area provided */
4842 arelent_chain *chain = section->constructor_chain;
4843 for (count = 0; count < section->reloc_count; count++)
4844 {
4845 *relptr++ = &chain->relent;
4846 chain = chain->next;
4847 }
4848
4849 }
4850 else
4851 {
4852 if (! coff_slurp_reloc_table (abfd, section, symbols))
4853 return -1;
4854
4855 tblptr = section->relocation;
4856
4857 for (; count++ < section->reloc_count;)
4858 *relptr++ = tblptr++;
4859
4860
4861 }
4862 *relptr = 0;
4863 return section->reloc_count;
4864}
4865
4866#ifdef GNU960
4867file_ptr
4868coff_sym_filepos (abfd)
4869 bfd *abfd;
4870{
4871 return obj_sym_filepos (abfd);
4872}
4873#endif
4874
4875#ifndef coff_reloc16_estimate
4876#define coff_reloc16_estimate dummy_reloc16_estimate
4877
4878static int dummy_reloc16_estimate
4879 PARAMS ((bfd *, asection *, arelent *, unsigned int,
4880 struct bfd_link_info *));
4881
4882static int
4883dummy_reloc16_estimate (abfd, input_section, reloc, shrink, link_info)
5f771d47
ILT		 4884 bfd *abfd ATTRIBUTE_UNUSED;
4885 asection *input_section ATTRIBUTE_UNUSED;
4886 arelent *reloc ATTRIBUTE_UNUSED;
4887 unsigned int shrink ATTRIBUTE_UNUSED;
4888 struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
252b5132
RH		 4889{
4890 abort ();
00692651 4891 return 0;
252b5132
RH		 4892}
4893
4894#endif
4895
4896#ifndef coff_reloc16_extra_cases
4897
4898#define coff_reloc16_extra_cases dummy_reloc16_extra_cases
4899
4900/* This works even if abort is not declared in any header file. */
4901
4902static void dummy_reloc16_extra_cases
4903 PARAMS ((bfd *, struct bfd_link_info *, struct bfd_link_order *, arelent *,
4904 bfd_byte *, unsigned int *, unsigned int *));
4905
4906static void
4907dummy_reloc16_extra_cases (abfd, link_info, link_order, reloc, data, src_ptr,
4908 dst_ptr)
5f771d47
ILT		 4909 bfd *abfd ATTRIBUTE_UNUSED;
4910 struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
4911 struct bfd_link_order *link_order ATTRIBUTE_UNUSED;
4912 arelent *reloc ATTRIBUTE_UNUSED;
4913 bfd_byte *data ATTRIBUTE_UNUSED;
4914 unsigned int *src_ptr ATTRIBUTE_UNUSED;
4915 unsigned int *dst_ptr ATTRIBUTE_UNUSED;
252b5132
RH		 4916{
4917 abort ();
4918}
4919#endif
4920
4921/* If coff_relocate_section is defined, we can use the optimized COFF
4922 backend linker. Otherwise we must continue to use the old linker. */
4923#ifdef coff_relocate_section
4924#ifndef coff_bfd_link_hash_table_create
4925#define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
4926#endif
4927#ifndef coff_bfd_link_add_symbols
4928#define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
4929#endif
4930#ifndef coff_bfd_final_link
4931#define coff_bfd_final_link _bfd_coff_final_link
4932#endif
4933#else /* ! defined (coff_relocate_section) */
4934#define coff_relocate_section NULL
4935#ifndef coff_bfd_link_hash_table_create
4936#define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
4937#endif
4938#ifndef coff_bfd_link_add_symbols
4939#define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
4940#endif
4941#define coff_bfd_final_link _bfd_generic_final_link
4942#endif /* ! defined (coff_relocate_section) */
4943
4944#define coff_bfd_link_split_section _bfd_generic_link_split_section
4945
4946#ifndef coff_start_final_link
4947#define coff_start_final_link NULL
4948#endif
4949
4950#ifndef coff_adjust_symndx
4951#define coff_adjust_symndx NULL
4952#endif
4953
4954#ifndef coff_link_add_one_symbol
4955#define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
4956#endif
4957
4958#ifndef coff_link_output_has_begun
4959
4960static boolean coff_link_output_has_begun
4961 PARAMS ((bfd *, struct coff_final_link_info *));
4962
4963static boolean
4964coff_link_output_has_begun (abfd, info)
4965 bfd * abfd;
5f771d47 4966 struct coff_final_link_info * info ATTRIBUTE_UNUSED;
252b5132
RH		 4967{
4968 return abfd->output_has_begun;
4969}
4970#endif
4971
4972#ifndef coff_final_link_postscript
4973
4974static boolean coff_final_link_postscript
4975 PARAMS ((bfd *, struct coff_final_link_info *));
4976
4977static boolean
4978coff_final_link_postscript (abfd, pfinfo)
5f771d47
ILT		 4979 bfd * abfd ATTRIBUTE_UNUSED;
4980 struct coff_final_link_info * pfinfo ATTRIBUTE_UNUSED;
252b5132
RH		 4981{
4982 return true;
4983}
4984#endif
4985
4986#ifndef coff_SWAP_aux_in
4987#define coff_SWAP_aux_in coff_swap_aux_in
4988#endif
4989#ifndef coff_SWAP_sym_in
4990#define coff_SWAP_sym_in coff_swap_sym_in
4991#endif
4992#ifndef coff_SWAP_lineno_in
4993#define coff_SWAP_lineno_in coff_swap_lineno_in
4994#endif
4995#ifndef coff_SWAP_aux_out
4996#define coff_SWAP_aux_out coff_swap_aux_out
4997#endif
4998#ifndef coff_SWAP_sym_out
4999#define coff_SWAP_sym_out coff_swap_sym_out
5000#endif
5001#ifndef coff_SWAP_lineno_out
5002#define coff_SWAP_lineno_out coff_swap_lineno_out
5003#endif
5004#ifndef coff_SWAP_reloc_out
5005#define coff_SWAP_reloc_out coff_swap_reloc_out
5006#endif
5007#ifndef coff_SWAP_filehdr_out
5008#define coff_SWAP_filehdr_out coff_swap_filehdr_out
5009#endif
5010#ifndef coff_SWAP_aouthdr_out
5011#define coff_SWAP_aouthdr_out coff_swap_aouthdr_out
5012#endif
5013#ifndef coff_SWAP_scnhdr_out
5014#define coff_SWAP_scnhdr_out coff_swap_scnhdr_out
5015#endif
5016#ifndef coff_SWAP_reloc_in
5017#define coff_SWAP_reloc_in coff_swap_reloc_in
5018#endif
5019#ifndef coff_SWAP_filehdr_in
5020#define coff_SWAP_filehdr_in coff_swap_filehdr_in
5021#endif
5022#ifndef coff_SWAP_aouthdr_in
5023#define coff_SWAP_aouthdr_in coff_swap_aouthdr_in
5024#endif
5025#ifndef coff_SWAP_scnhdr_in
5026#define coff_SWAP_scnhdr_in coff_swap_scnhdr_in
5027#endif
5028
692b7d62 5029static const bfd_coff_backend_data bfd_coff_std_swap_table =
252b5132
RH		 5030{
5031 coff_SWAP_aux_in, coff_SWAP_sym_in, coff_SWAP_lineno_in,
5032 coff_SWAP_aux_out, coff_SWAP_sym_out,
5033 coff_SWAP_lineno_out, coff_SWAP_reloc_out,
5034 coff_SWAP_filehdr_out, coff_SWAP_aouthdr_out,
5035 coff_SWAP_scnhdr_out,
692b7d62 5036 FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ, FILNMLEN,
252b5132
RH		 5037#ifdef COFF_LONG_FILENAMES
5038 true,
5039#else
5040 false,
5041#endif
5042#ifdef COFF_LONG_SECTION_NAMES
5043 true,
5044#else
5045 false,
5046#endif
7f6d05e8
CP		 5047 COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
5048#ifdef COFF_FORCE_SYMBOLS_IN_STRINGS
5049 true,
5050#else
5051 false,
5052#endif
5053#ifdef COFF_DEBUG_STRING_WIDE_PREFIX
5054 4,
5055#else
5056 2,
5057#endif
252b5132
RH		 5058 coff_SWAP_filehdr_in, coff_SWAP_aouthdr_in, coff_SWAP_scnhdr_in,
5059 coff_SWAP_reloc_in, coff_bad_format_hook, coff_set_arch_mach_hook,
5060 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
5061 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
5062 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
5d54c628 5063 coff_classify_symbol, coff_compute_section_file_positions,
252b5132
RH		 5064 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
5065 coff_adjust_symndx, coff_link_add_one_symbol,
5066 coff_link_output_has_begun, coff_final_link_postscript
5067};
5068
5069#ifndef coff_close_and_cleanup
5070#define coff_close_and_cleanup _bfd_generic_close_and_cleanup
5071#endif
5072
5073#ifndef coff_bfd_free_cached_info
5074#define coff_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
5075#endif
5076
5077#ifndef coff_get_section_contents
5078#define coff_get_section_contents _bfd_generic_get_section_contents
5079#endif
5080
5081#ifndef coff_bfd_copy_private_symbol_data
5082#define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
5083#endif
5084
5085#ifndef coff_bfd_copy_private_section_data
5086#define coff_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
5087#endif
5088
5089#ifndef coff_bfd_copy_private_bfd_data
5090#define coff_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
5091#endif
5092
5093#ifndef coff_bfd_merge_private_bfd_data
5094#define coff_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
5095#endif
5096
5097#ifndef coff_bfd_set_private_flags
5098#define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
5099#endif
5100
5101#ifndef coff_bfd_print_private_bfd_data
5102#define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
5103#endif
5104
5105#ifndef coff_bfd_is_local_label_name
5106#define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
5107#endif
5108
5109#ifndef coff_read_minisymbols
5110#define coff_read_minisymbols _bfd_generic_read_minisymbols
5111#endif
5112
5113#ifndef coff_minisymbol_to_symbol
5114#define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
5115#endif
5116
5117/* The reloc lookup routine must be supplied by each individual COFF
5118 backend. */
5119#ifndef coff_bfd_reloc_type_lookup
5120#define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
5121#endif
5122
5123#ifndef coff_bfd_get_relocated_section_contents
5124#define coff_bfd_get_relocated_section_contents \
5125 bfd_generic_get_relocated_section_contents
5126#endif
5127
5128#ifndef coff_bfd_relax_section
5129#define coff_bfd_relax_section bfd_generic_relax_section
5130#endif
5131
5132#ifndef coff_bfd_gc_sections
5133#define coff_bfd_gc_sections bfd_generic_gc_sections
5134#endif
c3c89269
NC		 5135
5136#define CREATE_BIG_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
4c117b10
ILT		 5137const bfd_target VAR = \
5138{ \
5139 NAME , \
5140 bfd_target_coff_flavour, \
5141 BFD_ENDIAN_BIG, /* data byte order is big */ \
5142 BFD_ENDIAN_BIG, /* header byte order is big */ \
5143 /* object flags */ \
5144 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5145 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5146 /* section flags */ \
5147 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5148 UNDER, /* leading symbol underscore */ \
5149 '/', /* ar_pad_char */ \
5150 15, /* ar_max_namelen */ \
5151 \
5152 /* Data conversion functions. */ \
5153 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5154 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5155 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5156 \
5157 /* Header conversion functions. */ \
5158 bfd_getb64, bfd_getb_signed_64, bfd_putb64, \
5159 bfd_getb32, bfd_getb_signed_32, bfd_putb32, \
5160 bfd_getb16, bfd_getb_signed_16, bfd_putb16, \
5161 \
5162 /* bfd_check_format */ \
5163 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5164 _bfd_dummy_target }, \
5165 /* bfd_set_format */ \
5166 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5167 /* bfd_write_contents */ \
5168 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5169 bfd_false }, \
5170 \
5171 BFD_JUMP_TABLE_GENERIC (coff), \
5172 BFD_JUMP_TABLE_COPY (coff), \
5173 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5174 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5175 BFD_JUMP_TABLE_SYMBOLS (coff), \
5176 BFD_JUMP_TABLE_RELOCS (coff), \
5177 BFD_JUMP_TABLE_WRITE (coff), \
5178 BFD_JUMP_TABLE_LINK (coff), \
5179 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5180 \
5181 ALTERNATIVE, \
5182 \
5183 COFF_SWAP_TABLE \
c3c89269
NC		 5184};
5185
5186#define CREATE_LITTLE_COFF_TARGET_VEC(VAR, NAME, EXTRA_O_FLAGS, EXTRA_S_FLAGS, UNDER, ALTERNATIVE) \
4c117b10
ILT		 5187const bfd_target VAR = \
5188{ \
5189 NAME , \
5190 bfd_target_coff_flavour, \
5191 BFD_ENDIAN_LITTLE, /* data byte order is little */ \
5192 BFD_ENDIAN_LITTLE, /* header byte order is little */ \
5193 /* object flags */ \
5194 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | \
5195 HAS_SYMS | HAS_LOCALS | WP_TEXT | EXTRA_O_FLAGS), \
5196 /* section flags */ \
5197 (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | EXTRA_S_FLAGS),\
5198 UNDER, /* leading symbol underscore */ \
5199 '/', /* ar_pad_char */ \
5200 15, /* ar_max_namelen */ \
5201 \
5202 /* Data conversion functions. */ \
5203 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5204 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5205 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5206 /* Header conversion functions. */ \
5207 bfd_getl64, bfd_getl_signed_64, bfd_putl64, \
5208 bfd_getl32, bfd_getl_signed_32, bfd_putl32, \
5209 bfd_getl16, bfd_getl_signed_16, bfd_putl16, \
5210 /* bfd_check_format */ \
5211 { _bfd_dummy_target, coff_object_p, bfd_generic_archive_p, \
5212 _bfd_dummy_target }, \
5213 /* bfd_set_format */ \
5214 { bfd_false, coff_mkobject, _bfd_generic_mkarchive, bfd_false }, \
5215 /* bfd_write_contents */ \
5216 { bfd_false, coff_write_object_contents, _bfd_write_archive_contents, \
5217 bfd_false }, \
5218 \
5219 BFD_JUMP_TABLE_GENERIC (coff), \
5220 BFD_JUMP_TABLE_COPY (coff), \
5221 BFD_JUMP_TABLE_CORE (_bfd_nocore), \
5222 BFD_JUMP_TABLE_ARCHIVE (_bfd_archive_coff), \
5223 BFD_JUMP_TABLE_SYMBOLS (coff), \
5224 BFD_JUMP_TABLE_RELOCS (coff), \
5225 BFD_JUMP_TABLE_WRITE (coff), \
5226 BFD_JUMP_TABLE_LINK (coff), \
5227 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic), \
5228 \
5229 ALTERNATIVE, \
5230 \
5231 COFF_SWAP_TABLE \
c3c89269 5232};
Empty description
This page took 0.72955 seconds and 4 git commands to generate.