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