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