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