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