]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - bfd/coffcode.h
projects / thirdparty / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* config/sh/tm-sh.h (BELIEVE_PCC_PROMOTION): Define, so that
[thirdparty/binutils-gdb.git] / bfd / coffcode.h
1 /* Support for the generic parts of most COFF variants, for BFD.
2 Copyright 1990, 91, 92, 93, 94, 95, 96, 97, 1998
3 Free Software Foundation, Inc.
4 Written by Cygnus Support.
5
6 This file is part of BFD, the Binary File Descriptor library.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21
22 /*
23 Most of this hacked by Steve Chamberlain,
24 sac@cygnus.com
25 */
26 /*
27
28 SECTION
29 coff backends
30
31 BFD supports a number of different flavours of coff format.
32 The major differences between formats are the sizes and
33 alignments of fields in structures on disk, and the occasional
34 extra field.
35
36 Coff in all its varieties is implemented with a few common
37 files and a number of implementation specific files. For
38 example, The 88k bcs coff format is implemented in the file
39 @file{coff-m88k.c}. This file @code{#include}s
40 @file{coff/m88k.h} which defines the external structure of the
41 coff format for the 88k, and @file{coff/internal.h} which
42 defines the internal structure. @file{coff-m88k.c} also
43 defines the relocations used by the 88k format
44 @xref{Relocations}.
45
46 The Intel i960 processor version of coff is implemented in
47 @file{coff-i960.c}. This file has the same structure as
48 @file{coff-m88k.c}, except that it includes @file{coff/i960.h}
49 rather than @file{coff-m88k.h}.
50
51 SUBSECTION
52 Porting to a new version of coff
53
54 The recommended method is to select from the existing
55 implementations the version of coff which is most like the one
56 you want to use. For example, we'll say that i386 coff is
57 the one you select, and that your coff flavour is called foo.
58 Copy @file{i386coff.c} to @file{foocoff.c}, copy
59 @file{../include/coff/i386.h} to @file{../include/coff/foo.h},
60 and add the lines to @file{targets.c} and @file{Makefile.in}
61 so that your new back end is used. Alter the shapes of the
62 structures in @file{../include/coff/foo.h} so that they match
63 what you need. You will probably also have to add
64 @code{#ifdef}s to the code in @file{coff/internal.h} and
65 @file{coffcode.h} if your version of coff is too wild.
66
67 You can verify that your new BFD backend works quite simply by
68 building @file{objdump} from the @file{binutils} directory,
69 and making sure that its version of what's going on and your
70 host system's idea (assuming it has the pretty standard coff
71 dump utility, usually called @code{att-dump} or just
72 @code{dump}) are the same. Then clean up your code, and send
73 what you've done to Cygnus. Then your stuff will be in the
74 next release, and you won't have to keep integrating it.
75
76 SUBSECTION
77 How the coff backend works
78
79 SUBSUBSECTION
80 File layout
81
82 The Coff backend is split into generic routines that are
83 applicable to any Coff target and routines that are specific
84 to a particular target. The target-specific routines are
85 further split into ones which are basically the same for all
86 Coff targets except that they use the external symbol format
87 or use different values for certain constants.
88
89 The generic routines are in @file{coffgen.c}. These routines
90 work for any Coff target. They use some hooks into the target
91 specific code; the hooks are in a @code{bfd_coff_backend_data}
92 structure, one of which exists for each target.
93
94 The essentially similar target-specific routines are in
95 @file{coffcode.h}. This header file includes executable C code.
96 The various Coff targets first include the appropriate Coff
97 header file, make any special defines that are needed, and
98 then include @file{coffcode.h}.
99
100 Some of the Coff targets then also have additional routines in
101 the target source file itself.
102
103 For example, @file{coff-i960.c} includes
104 @file{coff/internal.h} and @file{coff/i960.h}. It then
105 defines a few constants, such as @code{I960}, and includes
106 @file{coffcode.h}. Since the i960 has complex relocation
107 types, @file{coff-i960.c} also includes some code to
108 manipulate the i960 relocs. This code is not in
109 @file{coffcode.h} because it would not be used by any other
110 target.
111
112 SUBSUBSECTION
113 Bit twiddling
114
115 Each flavour of coff supported in BFD has its own header file
116 describing the external layout of the structures. There is also
117 an internal description of the coff layout, in
118 @file{coff/internal.h}. A major function of the
119 coff backend is swapping the bytes and twiddling the bits to
120 translate the external form of the structures into the normal
121 internal form. This is all performed in the
122 @code{bfd_swap}_@i{thing}_@i{direction} routines. Some
123 elements are different sizes between different versions of
124 coff; it is the duty of the coff version specific include file
125 to override the definitions of various packing routines in
126 @file{coffcode.h}. E.g., the size of line number entry in coff is
127 sometimes 16 bits, and sometimes 32 bits. @code{#define}ing
128 @code{PUT_LNSZ_LNNO} and @code{GET_LNSZ_LNNO} will select the
129 correct one. No doubt, some day someone will find a version of
130 coff which has a varying field size not catered to at the
131 moment. To port BFD, that person will have to add more @code{#defines}.
132 Three of the bit twiddling routines are exported to
133 @code{gdb}; @code{coff_swap_aux_in}, @code{coff_swap_sym_in}
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
143 on the way out, making cross ports much safer. Doing so also
144 allows BFD (and thus the linker) to use the same header files
145 as @code{gas}, which makes one avenue to disaster disappear.
146
147 SUBSUBSECTION
148 Symbol reading
149
150 The simple canonical form for symbols used by BFD is not rich
151 enough to keep all the information available in a coff symbol
152 table. The back end gets around this problem by keeping the original
153 symbol table around, "behind the scenes".
154
155 When a symbol table is requested (through a call to
156 @code{bfd_canonicalize_symtab}), a request gets through to
157 @code{coff_get_normalized_symtab}. This reads the symbol table from
158 the coff file and swaps all the structures inside into the
159 internal form. It also fixes up all the pointers in the table
160 (represented in the file by offsets from the first symbol in
161 the table) into physical pointers to elements in the new
162 internal table. This involves some work since the meanings of
163 fields change depending upon context: a field that is a
164 pointer to another structure in the symbol table at one moment
165 may be the size in bytes of a structure at the next. Another
166 pass is made over the table. All symbols which mark file names
167 (<<C_FILE>> symbols) are modified so that the internal
168 string points to the value in the auxent (the real filename)
169 rather than the normal text associated with the symbol
170 (@code{".file"}).
171
172 At this time the symbol names are moved around. Coff stores
173 all symbols less than nine characters long physically
174 within the symbol table; longer strings are kept at the end of
175 the file in the string table. This pass moves all strings
176 into memory and replaces them with pointers to the strings.
177
178
179 The symbol table is massaged once again, this time to create
180 the canonical table used by the BFD application. Each symbol
181 is inspected in turn, and a decision made (using the
182 @code{sclass} field) about the various flags to set in the
183 @code{asymbol}. @xref{Symbols}. The generated canonical table
184 shares strings with the hidden internal symbol table.
185
186 Any linenumbers are read from the coff file too, and attached
187 to the symbols which own the functions the linenumbers belong to.
188
189 SUBSUBSECTION
190 Symbol writing
191
192 Writing a symbol to a coff file which didn't come from a coff
193 file will lose any debugging information. The @code{asymbol}
194 structure remembers the BFD from which the symbol was taken, and on
195 output the back end makes sure that the same destination target as
196 source target is present.
197
198 When the symbols have come from a coff file then all the
199 debugging information is preserved.
200
201 Symbol tables are provided for writing to the back end in a
202 vector of pointers to pointers. This allows applications like
203 the linker to accumulate and output large symbol tables
204 without having to do too much byte copying.
205
206 This function runs through the provided symbol table and
207 patches each symbol marked as a file place holder
208 (@code{C_FILE}) to point to the next file place holder in the
209 list. It also marks each @code{offset} field in the list with
210 the offset from the first symbol of the current symbol.
211
212 Another function of this procedure is to turn the canonical
213 value form of BFD into the form used by coff. Internally, BFD
214 expects symbol values to be offsets from a section base; so a
215 symbol physically at 0x120, but in a section starting at
216 0x100, would have the value 0x20. Coff expects symbols to
217 contain their final value, so symbols have their values
218 changed at this point to reflect their sum with their owning
219 section. This transformation uses the
220 <<output_section>> field of the @code{asymbol}'s
221 @code{asection} @xref{Sections}.
222
223 o <<coff_mangle_symbols>>
224
225 This routine runs though the provided symbol table and uses
226 the offsets generated by the previous pass and the pointers
227 generated when the symbol table was read in to create the
228 structured hierachy required by coff. It changes each pointer
229 to a symbol into the index into the symbol table of the asymbol.
230
231 o <<coff_write_symbols>>
232
233 This routine runs through the symbol table and patches up the
234 symbols from their internal form into the coff way, calls the
235 bit twiddlers, and writes out the table to the file.
236
237 */
238
239 /*
240 INTERNAL_DEFINITION
241 coff_symbol_type
242
243 DESCRIPTION
244 The hidden information for an <<asymbol>> is described in a
245 <<combined_entry_type>>:
246
247 CODE_FRAGMENT
248 .
249 .typedef struct coff_ptr_struct
250 .{
251 .
252 . {* Remembers the offset from the first symbol in the file for
253 . this symbol. Generated by coff_renumber_symbols. *}
254 .unsigned int offset;
255 .
256 . {* Should the value of this symbol be renumbered. Used for
257 . XCOFF C_BSTAT symbols. Set by coff_slurp_symbol_table. *}
258 .unsigned int fix_value : 1;
259 .
260 . {* Should the tag field of this symbol be renumbered.
261 . Created by coff_pointerize_aux. *}
262 .unsigned int fix_tag : 1;
263 .
264 . {* Should the endidx field of this symbol be renumbered.
265 . Created by coff_pointerize_aux. *}
266 .unsigned int fix_end : 1;
267 .
268 . {* Should the x_csect.x_scnlen field be renumbered.
269 . Created by coff_pointerize_aux. *}
270 .unsigned int fix_scnlen : 1;
271 .
272 . {* Fix up an XCOFF C_BINCL/C_EINCL symbol. The value is the
273 . index into the line number entries. Set by
274 . coff_slurp_symbol_table. *}
275 .unsigned int fix_line : 1;
276 .
277 . {* The container for the symbol structure as read and translated
278 . from the file. *}
279 .
280 .union {
281 . union internal_auxent auxent;
282 . struct internal_syment syment;
283 . } u;
284 .} combined_entry_type;
285 .
286 .
287 .{* Each canonical asymbol really looks like this: *}
288 .
289 .typedef struct coff_symbol_struct
290 .{
291 . {* The actual symbol which the rest of BFD works with *}
292 .asymbol symbol;
293 .
294 . {* A pointer to the hidden information for this symbol *}
295 .combined_entry_type *native;
296 .
297 . {* A pointer to the linenumber information for this symbol *}
298 .struct lineno_cache_entry *lineno;
299 .
300 . {* Have the line numbers been relocated yet ? *}
301 .boolean done_lineno;
302 .} coff_symbol_type;
303
304
305 */
306
307 #ifdef COFF_WITH_PE
308 #include "peicode.h"
309 #else
310 #include "coffswap.h"
311 #endif
312
313 #define STRING_SIZE_SIZE (4)
314
315 static long sec_to_styp_flags PARAMS ((const char *, flagword));
316 static flagword styp_to_sec_flags PARAMS ((bfd *, PTR, const char *));
317 static boolean coff_bad_format_hook PARAMS ((bfd *, PTR));
318 static boolean coff_new_section_hook PARAMS ((bfd *, asection *));
319 static boolean coff_set_arch_mach_hook PARAMS ((bfd *, PTR));
320 static boolean coff_write_relocs PARAMS ((bfd *, int));
321 static boolean coff_set_flags
322 PARAMS ((bfd *, unsigned int *, unsigned short *));
323 static boolean coff_set_arch_mach
324 PARAMS ((bfd *, enum bfd_architecture, unsigned long));
325 static boolean coff_compute_section_file_positions PARAMS ((bfd *));
326 static boolean coff_write_object_contents PARAMS ((bfd *));
327 static boolean coff_set_section_contents
328 PARAMS ((bfd *, asection *, PTR, file_ptr, bfd_size_type));
329 static PTR buy_and_read PARAMS ((bfd *, file_ptr, int, size_t));
330 static boolean coff_slurp_line_table PARAMS ((bfd *, asection *));
331 static boolean coff_slurp_symbol_table PARAMS ((bfd *));
332 static boolean coff_slurp_reloc_table PARAMS ((bfd *, asection *, asymbol **));
333 static long coff_canonicalize_reloc
334 PARAMS ((bfd *, asection *, arelent **, asymbol **));
335 #ifndef coff_mkobject_hook
336 static PTR coff_mkobject_hook PARAMS ((bfd *, PTR, PTR));
337 #endif
338 \f
339 /* void warning(); */
340
341 /*
342 * Return a word with STYP_* (scnhdr.s_flags) flags set to represent the
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 */
347 static long
348 sec_to_styp_flags (sec_name, sec_flags)
349 CONST char *sec_name;
350 flagword sec_flags;
351 {
352 long styp_flags = 0;
353
354 if (!strcmp (sec_name, _TEXT))
355 {
356 styp_flags = STYP_TEXT;
357 }
358 else if (!strcmp (sec_name, _DATA))
359 {
360 styp_flags = STYP_DATA;
361 }
362 else if (!strcmp (sec_name, _BSS))
363 {
364 styp_flags = STYP_BSS;
365 #ifdef _COMMENT
366 }
367 else if (!strcmp (sec_name, _COMMENT))
368 {
369 styp_flags = STYP_INFO;
370 #endif /* _COMMENT */
371 #ifdef _LIB
372 }
373 else if (!strcmp (sec_name, _LIB))
374 {
375 styp_flags = STYP_LIB;
376 #endif /* _LIB */
377 #ifdef _LIT
378 }
379 else if (!strcmp (sec_name, _LIT))
380 {
381 styp_flags = STYP_LIT;
382 #endif /* _LIT */
383 }
384 else if (!strcmp (sec_name, ".debug"))
385 {
386 #ifdef STYP_DEBUG
387 styp_flags = STYP_DEBUG;
388 #else
389 styp_flags = STYP_INFO;
390 #endif
391 }
392 else if (!strncmp (sec_name, ".stab", 5))
393 {
394 styp_flags = STYP_INFO;
395 }
396 #ifdef COFF_WITH_PE
397 else if (!strcmp (sec_name, ".edata"))
398 {
399 styp_flags = STYP_DATA;
400 }
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 }
411 #endif
412 /* Try and figure out what it should be */
413 else if (sec_flags & SEC_CODE)
414 {
415 styp_flags = STYP_TEXT;
416 }
417 else if (sec_flags & SEC_DATA)
418 {
419 styp_flags = STYP_DATA;
420 }
421 else if (sec_flags & SEC_READONLY)
422 {
423 #ifdef STYP_LIT /* 29k readonly text/data section */
424 styp_flags = STYP_LIT;
425 #else
426 styp_flags = STYP_TEXT;
427 #endif /* STYP_LIT */
428 }
429 else if (sec_flags & SEC_LOAD)
430 {
431 styp_flags = STYP_TEXT;
432 }
433 else if (sec_flags & SEC_ALLOC)
434 {
435 styp_flags = STYP_BSS;
436 }
437
438 #ifdef STYP_NOLOAD
439 if ((sec_flags & (SEC_NEVER_LOAD | SEC_COFF_SHARED_LIBRARY)) != 0)
440 styp_flags |= STYP_NOLOAD;
441 #endif
442
443 #ifdef COFF_WITH_PE
444 if (sec_flags & SEC_LINK_ONCE)
445 styp_flags |= IMAGE_SCN_LNK_COMDAT;
446 #endif
447
448 return (styp_flags);
449 }
450 /*
451 * Return a word with SEC_* flags set to represent the incoming
452 * STYP_* flags (from scnhdr.s_flags). The inverse of this
453 * function is sec_to_styp_flags().
454 * NOTE: If you add to/change this routine, you should mirror the changes
455 * in sec_to_styp_flags().
456 */
457 static flagword
458 styp_to_sec_flags (abfd, hdr, name)
459 bfd *abfd;
460 PTR hdr;
461 const char *name;
462 {
463 struct internal_scnhdr *internal_s = (struct internal_scnhdr *) hdr;
464 long styp_flags = internal_s->s_flags;
465 flagword sec_flags = 0;
466
467 #ifdef STYP_NOLOAD
468 if (styp_flags & STYP_NOLOAD)
469 {
470 sec_flags |= SEC_NEVER_LOAD;
471 }
472 #endif /* STYP_NOLOAD */
473
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)
477 {
478 if (sec_flags & SEC_NEVER_LOAD)
479 sec_flags |= SEC_CODE | SEC_COFF_SHARED_LIBRARY;
480 else
481 sec_flags |= SEC_CODE | SEC_LOAD | SEC_ALLOC;
482 }
483 else if (styp_flags & STYP_DATA)
484 {
485 if (sec_flags & SEC_NEVER_LOAD)
486 sec_flags |= SEC_DATA | SEC_COFF_SHARED_LIBRARY;
487 else
488 sec_flags |= SEC_DATA | SEC_LOAD | SEC_ALLOC;
489 }
490 else if (styp_flags & STYP_BSS)
491 {
492 #ifdef BSS_NOLOAD_IS_SHARED_LIBRARY
493 if (sec_flags & SEC_NEVER_LOAD)
494 sec_flags |= SEC_ALLOC | SEC_COFF_SHARED_LIBRARY;
495 else
496 #endif
497 sec_flags |= SEC_ALLOC;
498 }
499 else if (styp_flags & STYP_INFO)
500 {
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. */
507 #if defined (COFF_PAGE_SIZE) && !defined (COFF_ALIGN_IN_S_FLAGS)
508 sec_flags |= SEC_DEBUGGING;
509 #endif
510 }
511 else if (styp_flags & STYP_PAD)
512 {
513 sec_flags = 0;
514 }
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 }
522 else if (strcmp (name, _DATA) == 0)
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
542 || strncmp (name, ".stab", 5) == 0)
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
558 else
559 {
560 sec_flags |= SEC_ALLOC | SEC_LOAD;
561 }
562
563 #ifdef STYP_LIT /* A29k readonly text/data section type */
564 if ((styp_flags & STYP_LIT) == STYP_LIT)
565 {
566 sec_flags = (SEC_LOAD | SEC_ALLOC | SEC_READONLY);
567 }
568 #endif /* STYP_LIT */
569 #ifdef STYP_OTHER_LOAD /* Other loaded sections */
570 if (styp_flags & STYP_OTHER_LOAD)
571 {
572 sec_flags = (SEC_LOAD | SEC_ALLOC);
573 }
574 #endif /* STYP_SDATA */
575
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
613 && isym.n_numaux == 1)
614 {
615 char buf[SYMNMLEN + 1];
616 const char *symname;
617
618 symname = _bfd_coff_internal_syment_name (abfd, &isym, buf);
619 if (symname == NULL)
620 abort ();
621
622 if (strcmp (name, symname) == 0)
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
667 return (sec_flags);
668 }
669
670 #define get_index(symbol) ((symbol)->udata.i)
671
672 /*
673 INTERNAL_DEFINITION
674 bfd_coff_backend_data
675
676 CODE_FRAGMENT
677
678 Special entry points for gdb to swap in coff symbol table parts:
679 .typedef struct
680 .{
681 . void (*_bfd_coff_swap_aux_in) PARAMS ((
682 . bfd *abfd,
683 . PTR ext,
684 . int type,
685 . int class,
686 . int indaux,
687 . int numaux,
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
701 Special entry points for gas to swap out coff parts:
702
703 . unsigned int (*_bfd_coff_swap_aux_out) PARAMS ((
704 . bfd *abfd,
705 . PTR in,
706 . int type,
707 . int class,
708 . int indaux,
709 . int numaux,
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 .
742
743 Special entry points for generic COFF routines to call target
744 dependent COFF routines:
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;
751 . unsigned int _bfd_relsz;
752 . unsigned int _bfd_linesz;
753 . boolean _bfd_coff_long_filenames;
754 . boolean _bfd_coff_long_section_names;
755 . unsigned int _bfd_coff_default_section_alignment_power;
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));
768 . void (*_bfd_coff_swap_reloc_in) PARAMS ((
769 . bfd *abfd,
770 . PTR ext,
771 . PTR in));
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,
780 . PTR internal_filehdr,
781 . PTR internal_aouthdr));
782 . flagword (*_bfd_styp_to_sec_flags_hook) PARAMS ((
783 . bfd *abfd,
784 . PTR internal_scnhdr,
785 . const char *name));
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));
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));
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));
808 . void (*_bfd_coff_reloc16_extra_cases) PARAMS ((
809 . bfd *abfd,
810 . struct bfd_link_info *link_info,
811 . struct bfd_link_order *link_order,
812 . arelent *reloc,
813 . bfd_byte *data,
814 . unsigned int *src_ptr,
815 . unsigned int *dst_ptr));
816 . int (*_bfd_coff_reloc16_estimate) PARAMS ((
817 . bfd *abfd,
818 . asection *input_section,
819 . arelent *r,
820 . unsigned int shrink,
821 . struct bfd_link_info *link_info));
822 . boolean (*_bfd_coff_sym_is_global) PARAMS ((
823 . bfd *abfd,
824 . struct internal_syment *));
825 . boolean (*_bfd_coff_compute_section_file_positions) PARAMS ((
826 . bfd *abfd));
827 . boolean (*_bfd_coff_start_final_link) PARAMS ((
828 . bfd *output_bfd,
829 . struct bfd_link_info *info));
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));
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));
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));
864 .
865 . boolean (*_bfd_coff_link_output_has_begun) PARAMS ((
866 . bfd * abfd,
867 . struct coff_final_link_info * pfinfo));
868 . boolean (*_bfd_coff_final_link_postscript) PARAMS ((
869 . bfd * abfd,
870 . struct coff_final_link_info * pfinfo));
871 .
872 .} bfd_coff_backend_data;
873 .
874 .#define coff_backend_info(abfd) ((bfd_coff_backend_data *) (abfd)->xvec->backend_data)
875 .
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))
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 .
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))
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 .
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)
911 .#define bfd_coff_relsz(abfd) (coff_backend_info (abfd)->_bfd_relsz)
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)
914 .#define bfd_coff_long_section_names(abfd) \
915 . (coff_backend_info (abfd)->_bfd_coff_long_section_names)
916 .#define bfd_coff_default_section_alignment_power(abfd) \
917 . (coff_backend_info (abfd)->_bfd_coff_default_section_alignment_power)
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 .
927 .#define bfd_coff_swap_reloc_in(abfd, i, o) \
928 . ((coff_backend_info (abfd)->_bfd_coff_swap_reloc_in) (abfd, i, o))
929 .
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))
935 .#define bfd_coff_mkobject_hook(abfd, filehdr, aouthdr)\
936 . ((coff_backend_info (abfd)->_bfd_coff_mkobject_hook) (abfd, filehdr, aouthdr))
937 .
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))
940 .
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 .
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 .
954 .#define bfd_coff_reloc16_extra_cases(abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr)\
955 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_extra_cases)\
956 . (abfd, link_info, link_order, reloc, data, src_ptr, dst_ptr))
957 .
958 .#define bfd_coff_reloc16_estimate(abfd, section, reloc, shrink, link_info)\
959 . ((coff_backend_info (abfd)->_bfd_coff_reloc16_estimate)\
960 . (abfd, section, reloc, shrink, link_info))
961 .
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 .
970 .#define bfd_coff_start_final_link(obfd, info)\
971 . ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
972 . (obfd, info))
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))
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))
982 .#define bfd_coff_link_add_one_symbol(info,abfd,name,flags,section,value,string,cp,coll,hashp)\
983 . ((coff_backend_info (abfd)->_bfd_coff_link_add_one_symbol)\
984 . (info, abfd, name, flags, section, value, string, cp, coll, hashp))
985 .
986 .#define bfd_coff_link_output_has_begun(a,p) \
987 . ((coff_backend_info (a)->_bfd_coff_link_output_has_begun) (a,p))
988 .#define bfd_coff_final_link_postscript(a,p) \
989 . ((coff_backend_info (a)->_bfd_coff_final_link_postscript) (a,p))
990 .
991 */
992
993 /* See whether the magic number matches. */
994
995 static boolean
996 coff_bad_format_hook (abfd, filehdr)
997 bfd * abfd;
998 PTR filehdr;
999 {
1000 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1001
1002 if (BADMAG (*internal_f))
1003 return false;
1004
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.
1009
1010 But the mips keeps extra stuff in it's opthdr, so dont check
1011 when doing that
1012 */
1013
1014 #if defined(M88) || defined(I960)
1015 if (internal_f->f_opthdr != 0 && AOUTSZ != internal_f->f_opthdr)
1016 return false;
1017 #endif
1018
1019 return true;
1020 }
1021
1022 /*
1023 initialize a section structure with information peculiar to this
1024 particular implementation of coff
1025 */
1026
1027 static boolean
1028 coff_new_section_hook (abfd, section)
1029 bfd * abfd;
1030 asection * section;
1031 {
1032 combined_entry_type *native;
1033
1034 section->alignment_power = COFF_DEFAULT_SECTION_ALIGNMENT_POWER;
1035
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
1045 /* Allocate aux records for section symbols, to store size and
1046 related info.
1047
1048 @@ The 10 is a guess at a plausible maximum number of aux entries
1049 (but shouldn't be a constant). */
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;
1065
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
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. */
1072 if (COFF_DEFAULT_SECTION_ALIGNMENT_POWER > 2
1073 && (strncmp (section->name, ".stab", 5) == 0
1074 || strcmp (section->name, ".ctors") == 0
1075 || strcmp (section->name, ".dtors") == 0))
1076 section->alignment_power = 2;
1077
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
1083 return true;
1084 }
1085
1086 #ifdef COFF_ALIGN_IN_SECTION_HEADER
1087
1088 /* Set the alignment of a BFD section. */
1089
1090 static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1091
1092 static void
1093 coff_set_alignment_hook (abfd, section, scnhdr)
1094 bfd * abfd;
1095 asection * section;
1096 PTR scnhdr;
1097 {
1098 struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
1099 unsigned int i;
1100
1101 #ifdef I960
1102 /* Extract ALIGN from 2**ALIGN stored in section header */
1103 for (i = 0; i < 32; i++)
1104 if ((1 << i) >= hdr->s_align)
1105 break;
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 */
1113 section->alignment_power = i;
1114 }
1115
1116 #else /* ! COFF_ALIGN_IN_SECTION_HEADER */
1117 #ifdef COFF_WITH_PE
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
1132 static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1133
1134 static void
1135 coff_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)
1149
1150 #ifdef POWERPC_LE_PE
1151 if (strcmp (section->name, ".idata$2") == 0)
1152 {
1153 section->alignment_power = 0;
1154 }
1155 else if (strcmp (section->name, ".idata$3") == 0)
1156 {
1157 section->alignment_power = 0;
1158 }
1159 else if (strcmp (section->name, ".idata$4") == 0)
1160 {
1161 section->alignment_power = 2;
1162 }
1163 else if (strcmp (section->name, ".idata$5") == 0)
1164 {
1165 section->alignment_power = 2;
1166 }
1167 else if (strcmp (section->name, ".idata$6") == 0)
1168 {
1169 section->alignment_power = 1;
1170 }
1171 else if (strcmp (section->name, ".reloc") == 0)
1172 {
1173 section->alignment_power = 1;
1174 }
1175 else if (strncmp (section->name, ".stab", 5) == 0)
1176 {
1177 section->alignment_power = 2;
1178 }
1179 #endif
1180
1181 #ifdef COFF_IMAGE_WITH_PE
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
1210 }
1211 #undef ALIGN_SET
1212 #undef ELIFALIGN_SET
1213
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
1221 static void coff_set_alignment_hook PARAMS ((bfd *, asection *, PTR));
1222
1223 static void
1224 coff_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 */
1255
1256 #define coff_set_alignment_hook \
1257 ((void (*) PARAMS ((bfd *, asection *, PTR))) bfd_void)
1258
1259 #endif /* ! RS6000COFF_C */
1260 #endif /* ! COFF_WITH_PE */
1261 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
1262
1263 #ifndef coff_mkobject
1264
1265 static boolean coff_mkobject PARAMS ((bfd *));
1266
1267 static boolean
1268 coff_mkobject (abfd)
1269 bfd * abfd;
1270 {
1271 coff_data_type *coff;
1272
1273 abfd->tdata.coff_obj_data = (struct coff_tdata *) bfd_zalloc (abfd, sizeof (coff_data_type));
1274 if (abfd->tdata.coff_obj_data == 0)
1275 return false;
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;
1280 coff->relocbase = 0;
1281 coff->local_toc_sym_map = 0;
1282
1283 /* make_abs_section(abfd);*/
1284
1285 return true;
1286 }
1287 #endif
1288
1289 /* Create the COFF backend specific information. */
1290 #ifndef coff_mkobject_hook
1291 static PTR
1292 coff_mkobject_hook (abfd, filehdr, aouthdr)
1293 bfd * abfd;
1294 PTR filehdr;
1295 PTR aouthdr;
1296 {
1297 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1298 coff_data_type *coff;
1299
1300 if (coff_mkobject (abfd) == false)
1301 return NULL;
1302
1303 coff = coff_data (abfd);
1304
1305 coff->sym_filepos = internal_f->f_symptr;
1306
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;
1312 coff->local_n_tmask = N_TMASK;
1313 coff->local_n_tshift = N_TSHIFT;
1314 coff->local_symesz = SYMESZ;
1315 coff->local_auxesz = AUXESZ;
1316 coff->local_linesz = LINESZ;
1317
1318 obj_raw_syment_count (abfd) =
1319 obj_conv_table_size (abfd) =
1320 internal_f->f_nsyms;
1321
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);
1332 xcoff->full_aouthdr = true;
1333 xcoff->toc = internal_a->o_toc;
1334 xcoff->sntoc = internal_a->o_sntoc;
1335 xcoff->snentry = internal_a->o_snentry;
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;
1339 xcoff->cputype = internal_a->o_cputype;
1340 xcoff->maxdata = internal_a->o_maxdata;
1341 xcoff->maxstack = internal_a->o_maxstack;
1342 }
1343 #endif
1344
1345 #ifdef ARM
1346 /* Set the flags field from the COFF header read in */
1347 if (! _bfd_coff_arm_set_private_flags (abfd, internal_f->f_flags))
1348 coff->flags = 0;
1349 #endif
1350
1351 return (PTR) coff;
1352 }
1353 #endif
1354
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. */
1361
1362 static boolean
1363 coff_set_arch_mach_hook (abfd, filehdr)
1364 bfd *abfd;
1365 PTR filehdr;
1366 {
1367 long machine;
1368 enum bfd_architecture arch;
1369 struct internal_filehdr *internal_f = (struct internal_filehdr *) filehdr;
1370
1371 machine = 0;
1372 switch (internal_f->f_magic)
1373 {
1374 #ifdef PPCMAGIC
1375 case PPCMAGIC:
1376 arch = bfd_arch_powerpc;
1377 machine = 0; /* what does this mean? (krk) */
1378 break;
1379 #endif
1380 #ifdef I386MAGIC
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;
1388 #endif
1389 #ifdef A29K_MAGIC_BIG
1390 case A29K_MAGIC_BIG:
1391 case A29K_MAGIC_LITTLE:
1392 arch = bfd_arch_a29k;
1393 machine = 0;
1394 break;
1395 #endif
1396 #ifdef ARMMAGIC
1397 case ARMMAGIC:
1398 arch = bfd_arch_arm;
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 }
1409 break;
1410 #endif
1411 #ifdef MC68MAGIC
1412 case MC68MAGIC:
1413 case M68MAGIC:
1414 #ifdef MC68KBCSMAGIC
1415 case MC68KBCSMAGIC:
1416 #endif
1417 #ifdef APOLLOM68KMAGIC
1418 case APOLLOM68KMAGIC:
1419 #endif
1420 #ifdef LYNXCOFFMAGIC
1421 case LYNXCOFFMAGIC:
1422 #endif
1423 arch = bfd_arch_m68k;
1424 machine = bfd_mach_m68020;
1425 break;
1426 #endif
1427 #ifdef MC88MAGIC
1428 case MC88MAGIC:
1429 case MC88DMAGIC:
1430 case MC88OMAGIC:
1431 arch = bfd_arch_m88k;
1432 machine = 88100;
1433 break;
1434 #endif
1435 #ifdef Z8KMAGIC
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;
1450 #endif
1451 #ifdef I860
1452 case I860MAGIC:
1453 arch = bfd_arch_i860;
1454 break;
1455 #endif
1456 #ifdef I960
1457 #ifdef I960ROMAGIC
1458 case I960ROMAGIC:
1459 case I960RWMAGIC:
1460 arch = bfd_arch_i960;
1461 switch (F_I960TYPE & internal_f->f_flags)
1462 {
1463 default:
1464 case F_I960CORE:
1465 machine = bfd_mach_i960_core;
1466 break;
1467 case F_I960KB:
1468 machine = bfd_mach_i960_kb_sb;
1469 break;
1470 case F_I960MC:
1471 machine = bfd_mach_i960_mc;
1472 break;
1473 case F_I960XA:
1474 machine = bfd_mach_i960_xa;
1475 break;
1476 case F_I960CA:
1477 machine = bfd_mach_i960_ca;
1478 break;
1479 case F_I960KA:
1480 machine = bfd_mach_i960_ka_sa;
1481 break;
1482 case F_I960JX:
1483 machine = bfd_mach_i960_jx;
1484 break;
1485 case F_I960HX:
1486 machine = bfd_mach_i960_hx;
1487 break;
1488 }
1489 break;
1490 #endif
1491 #endif
1492
1493 #ifdef RS6000COFF_C
1494 case U802ROMAGIC:
1495 case U802WRMAGIC:
1496 case U802TOCMAGIC:
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:
1531 #ifdef POWERMAC
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;
1536 machine = 0;
1537 #else
1538 arch = bfd_arch_rs6000;
1539 machine = 6000;
1540 #endif /* POWERMAC */
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 }
1561 break;
1562 #endif
1563
1564 #ifdef WE32KMAGIC
1565 case WE32KMAGIC:
1566 arch = bfd_arch_we32k;
1567 machine = 0;
1568 break;
1569 #endif
1570
1571 #ifdef H8300MAGIC
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;
1578 #endif
1579
1580 #ifdef H8300HMAGIC
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;
1587 #endif
1588
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
1598 #ifdef SH_ARCH_MAGIC_BIG
1599 case SH_ARCH_MAGIC_BIG:
1600 case SH_ARCH_MAGIC_LITTLE:
1601 arch = bfd_arch_sh;
1602 machine = 0;
1603 break;
1604 #endif
1605
1606 #ifdef H8500MAGIC
1607 case H8500MAGIC:
1608 arch = bfd_arch_h8500;
1609 machine = 0;
1610 break;
1611 #endif
1612
1613 #ifdef SPARCMAGIC
1614 case SPARCMAGIC:
1615 #ifdef LYNXCOFFMAGIC
1616 case LYNXCOFFMAGIC:
1617 #endif
1618 arch = bfd_arch_sparc;
1619 machine = 0;
1620 break;
1621 #endif
1622
1623 #ifdef TIC30MAGIC
1624 case TIC30MAGIC:
1625 arch = bfd_arch_tic30;
1626 break;
1627 #endif
1628
1629 /* start-sanitize-tic80 */
1630 #ifdef TIC80_ARCH_MAGIC
1631 case TIC80_ARCH_MAGIC:
1632 arch = bfd_arch_tic80;
1633 break;
1634 #endif
1635 /* end-sanitize-tic80 */
1636
1637 default: /* Unreadable input file type */
1638 arch = bfd_arch_obscure;
1639 break;
1640 }
1641
1642 bfd_default_set_arch_mach (abfd, arch, machine);
1643 return true;
1644 }
1645
1646 #ifdef SYMNAME_IN_DEBUG
1647
1648 static boolean symname_in_debug_hook
1649 PARAMS ((bfd *, struct internal_syment *));
1650
1651 static boolean
1652 symname_in_debug_hook (abfd, sym)
1653 bfd * abfd;
1654 struct internal_syment *sym;
1655 {
1656 return SYMNAME_IN_DEBUG (sym) ? true : false;
1657 }
1658
1659 #else
1660
1661 #define symname_in_debug_hook \
1662 (boolean (*) PARAMS ((bfd *, struct internal_syment *))) bfd_false
1663
1664 #endif
1665
1666 #ifdef RS6000COFF_C
1667
1668 /* Handle the csect auxent of a C_EXT or C_HIDEXT symbol. */
1669
1670 static boolean coff_pointerize_aux_hook
1671 PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
1672 unsigned int, combined_entry_type *));
1673
1674 /*ARGSUSED*/
1675 static boolean
1676 coff_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
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;
1703 }
1704
1705 #else
1706 #ifdef I960
1707
1708 /* We don't want to pointerize bal entries. */
1709
1710 static boolean coff_pointerize_aux_hook
1711 PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
1712 unsigned int, combined_entry_type *));
1713
1714 /*ARGSUSED*/
1715 static boolean
1716 coff_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. */
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));
1729 }
1730
1731 #else /* ! I960 */
1732
1733 #define coff_pointerize_aux_hook 0
1734
1735 #endif /* ! I960 */
1736 #endif /* ! RS6000COFF_C */
1737
1738 /* Print an aux entry. This returns true if it has printed it. */
1739
1740 static boolean coff_print_aux
1741 PARAMS ((bfd *, FILE *, combined_entry_type *, combined_entry_type *,
1742 combined_entry_type *, unsigned int));
1743
1744 static boolean
1745 coff_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
1791 /*
1792 SUBSUBSECTION
1793 Writing relocations
1794
1795 To write relocations, the back end steps though the
1796 canonical relocation table and create an
1797 @code{internal_reloc}. The symbol index to use is removed from
1798 the @code{offset} field in the symbol table supplied. The
1799 address comes directly from the sum of the section base
1800 address and the relocation offset; the type is dug directly
1801 from the howto field. Then the @code{internal_reloc} is
1802 swapped into the shape of an @code{external_reloc} and written
1803 out to disk.
1804
1805 */
1806
1807 #ifdef TARG_AUX
1808
1809 static int compare_arelent_ptr PARAMS ((const PTR, const PTR));
1810
1811 /* AUX's ld wants relocations to be sorted */
1812 static int
1813 compare_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
1827 static boolean
1828 coff_write_relocs (abfd, first_undef)
1829 bfd * abfd;
1830 int first_undef;
1831 {
1832 asection *s;
1833
1834 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
1835 {
1836 unsigned int i;
1837 struct external_reloc dst;
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
1850
1851 if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0)
1852 return false;
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
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
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
1889 part doesn't have a symbol; it has an offset. So rebuilt
1890 that here. */
1891 if (q->howto->type == R_IHCONST)
1892 n.r_symndx = q->addend;
1893 else
1894 #endif
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 }
1910
1911 #ifdef SWAP_OUT_RELOC_OFFSET
1912 n.r_offset = q->addend;
1913 #endif
1914
1915 #ifdef SELECT_RELOC
1916 /* Work out reloc type from what is required */
1917 SELECT_RELOC (n, q->howto);
1918 #else
1919 n.r_type = q->howto->type;
1920 #endif
1921 coff_swap_reloc_out (abfd, &n, &dst);
1922 if (bfd_write ((PTR) & dst, 1, RELSZ, abfd) != RELSZ)
1923 return false;
1924 }
1925
1926 #ifdef TARG_AUX
1927 if (p != NULL)
1928 free (p);
1929 #endif
1930 }
1931
1932 return true;
1933 }
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. */
1937
1938 static boolean
1939 coff_set_flags (abfd, magicp, flagsp)
1940 bfd * abfd;
1941 unsigned int *magicp;
1942 unsigned short *flagsp;
1943 {
1944 switch (bfd_get_arch (abfd))
1945 {
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;
1961 #endif
1962 #ifdef I960ROMAGIC
1963
1964 case bfd_arch_i960:
1965
1966 {
1967 unsigned flags;
1968 *magicp = I960ROMAGIC;
1969 /*
1970 ((bfd_get_file_flags(abfd) & WP_TEXT) ? I960ROMAGIC :
1971 I960RWMAGIC); FIXME???
1972 */
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;
1993 case bfd_mach_i960_jx:
1994 flags = F_I960JX;
1995 break;
1996 case bfd_mach_i960_hx:
1997 flags = F_I960HX;
1998 break;
1999 default:
2000 return false;
2001 }
2002 *flagsp = flags;
2003 return true;
2004 }
2005 break;
2006 #endif
2007
2008 #ifdef TIC30MAGIC
2009 case bfd_arch_tic30:
2010 *magicp = TIC30MAGIC;
2011 return true;
2012 #endif
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 */
2020 #ifdef ARMMAGIC
2021 case bfd_arch_arm:
2022 * magicp = ARMMAGIC;
2023 * flagsp = 0;
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;
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 }
2046 return true;
2047 #endif
2048 #ifdef PPCMAGIC
2049 case bfd_arch_powerpc:
2050 *magicp = PPCMAGIC;
2051 return true;
2052 break;
2053 #endif
2054 #ifdef I386MAGIC
2055 case bfd_arch_i386:
2056 *magicp = I386MAGIC;
2057 #ifdef LYNXOS
2058 /* Just overwrite the usual value if we're doing Lynx. */
2059 *magicp = LYNXCOFFMAGIC;
2060 #endif
2061 return true;
2062 break;
2063 #endif
2064 #ifdef I860MAGIC
2065 case bfd_arch_i860:
2066 *magicp = I860MAGIC;
2067 return true;
2068 break;
2069 #endif
2070 #ifdef MC68MAGIC
2071 case bfd_arch_m68k:
2072 #ifdef APOLLOM68KMAGIC
2073 *magicp = APOLLO_COFF_VERSION_NUMBER;
2074 #else
2075 /* NAMES_HAVE_UNDERSCORE may be defined by coff-u68k.c. */
2076 #ifdef NAMES_HAVE_UNDERSCORE
2077 *magicp = MC68KBCSMAGIC;
2078 #else
2079 *magicp = MC68MAGIC;
2080 #endif
2081 #endif
2082 #ifdef LYNXOS
2083 /* Just overwrite the usual value if we're doing Lynx. */
2084 *magicp = LYNXCOFFMAGIC;
2085 #endif
2086 return true;
2087 break;
2088 #endif
2089
2090 #ifdef MC88MAGIC
2091 case bfd_arch_m88k:
2092 *magicp = MC88OMAGIC;
2093 return true;
2094 break;
2095 #endif
2096 #ifdef H8300MAGIC
2097 case bfd_arch_h8300:
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;
2106 case bfd_mach_h8300s:
2107 *magicp = H8300SMAGIC;
2108 return true;
2109 }
2110 break;
2111 #endif
2112
2113 #ifdef SH_ARCH_MAGIC_BIG
2114 case bfd_arch_sh:
2115 if (bfd_big_endian (abfd))
2116 *magicp = SH_ARCH_MAGIC_BIG;
2117 else
2118 *magicp = SH_ARCH_MAGIC_LITTLE;
2119 return true;
2120 break;
2121 #endif
2122
2123 #ifdef SPARCMAGIC
2124 case bfd_arch_sparc:
2125 *magicp = SPARCMAGIC;
2126 #ifdef LYNXOS
2127 /* Just overwrite the usual value if we're doing Lynx. */
2128 *magicp = LYNXCOFFMAGIC;
2129 #endif
2130 return true;
2131 break;
2132 #endif
2133
2134 #ifdef H8500MAGIC
2135 case bfd_arch_h8500:
2136 *magicp = H8500MAGIC;
2137 return true;
2138 break;
2139 #endif
2140 #ifdef A29K_MAGIC_BIG
2141 case bfd_arch_a29k:
2142 if (bfd_big_endian (abfd))
2143 *magicp = A29K_MAGIC_BIG;
2144 else
2145 *magicp = A29K_MAGIC_LITTLE;
2146 return true;
2147 break;
2148 #endif
2149
2150 #ifdef WE32KMAGIC
2151 case bfd_arch_we32k:
2152 *magicp = WE32KMAGIC;
2153 return true;
2154 break;
2155 #endif
2156
2157 #ifdef U802TOCMAGIC
2158 case bfd_arch_rs6000:
2159 #ifndef PPCMAGIC
2160 case bfd_arch_powerpc:
2161 #endif
2162 *magicp = U802TOCMAGIC;
2163 return true;
2164 break;
2165 #endif
2166
2167 default: /* Unknown architecture */
2168 /* return false; -- fall through to "return false" below, to avoid
2169 "statement never reached" errors on the one below. */
2170 break;
2171 }
2172
2173 return false;
2174 }
2175
2176
2177 static boolean
2178 coff_set_arch_mach (abfd, arch, machine)
2179 bfd * abfd;
2180 enum bfd_architecture arch;
2181 unsigned long machine;
2182 {
2183 unsigned dummy1;
2184 unsigned short dummy2;
2185
2186 if (! bfd_default_set_arch_mach (abfd, arch, machine))
2187 return false;
2188
2189 if (arch != bfd_arch_unknown &&
2190 coff_set_flags (abfd, &dummy1, &dummy2) != true)
2191 return false; /* We can't represent this type */
2192
2193 return true; /* We're easy ... */
2194 }
2195
2196
2197 /* Calculate the file position for each section. */
2198
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
2208 static boolean
2209 coff_compute_section_file_positions (abfd)
2210 bfd * abfd;
2211 {
2212 asection *current;
2213 asection *previous = (asection *) NULL;
2214 file_ptr sofar = FILHSZ;
2215 boolean align_adjust;
2216 unsigned int count;
2217 #ifdef ALIGN_SECTIONS_IN_FILE
2218 file_ptr old_sofar;
2219 #endif
2220
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
2259
2260 #ifdef COFF_IMAGE_WITH_PE
2261 int page_size;
2262 if (coff_data (abfd)->link_info)
2263 {
2264 page_size = pe_data (abfd)->pe_opthdr.FileAlignment;
2265 }
2266 else
2267 page_size = PE_DEF_FILE_ALIGNMENT;
2268 #else
2269 #ifdef COFF_PAGE_SIZE
2270 int page_size = COFF_PAGE_SIZE;
2271 #endif
2272 #endif
2273
2274 if (bfd_get_start_address (abfd))
2275 {
2276 /* A start address may have been added to the original file. In this
2277 case it will need an optional header to record it. */
2278 abfd->flags |= EXEC_P;
2279 }
2280
2281 if (abfd->flags & EXEC_P)
2282 sofar += AOUTSZ;
2283 #ifdef RS6000COFF_C
2284 else if (xcoff_data (abfd)->full_aouthdr)
2285 sofar += AOUTSZ;
2286 else
2287 sofar += SMALL_AOUTSZ;
2288 #endif
2289
2290 sofar += abfd->section_count * SCNHSZ;
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
2300 align_adjust = false;
2301 for (current = abfd->sections, count = 1;
2302 current != (asection *) NULL;
2303 current = current->next, ++count)
2304 {
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
2318 current->target_index = count;
2319
2320 /* Only deal with sections which have contents */
2321 if (!(current->flags & SEC_HAS_CONTENTS))
2322 continue;
2323
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... */
2328 #ifdef ALIGN_SECTIONS_IN_FILE
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 */
2333
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 }
2341
2342 #endif
2343
2344 /* In demand paged files the low order bits of the file offset
2345 must match the low order bits of the virtual address. */
2346 #ifdef COFF_PAGE_SIZE
2347 if ((abfd->flags & D_PAGED) != 0
2348 && (current->flags & SEC_ALLOC) != 0)
2349 sofar += (current->vma - sofar) % page_size;
2350 #endif
2351 current->filepos = sofar;
2352
2353 #ifdef COFF_IMAGE_WITH_PE
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)
2362 return false;
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)
2369 return false;
2370 }
2371 if (pei_section_data (abfd, current)->virt_size == 0)
2372 pei_section_data (abfd, current)->virt_size = current->_raw_size;
2373
2374 current->_raw_size = (current->_raw_size + page_size -1) & -page_size;
2375 #endif
2376
2377 sofar += current->_raw_size;
2378
2379 #ifdef ALIGN_SECTIONS_IN_FILE
2380 /* make sure that this section is of the right size too */
2381 if ((abfd->flags & EXEC_P) == 0)
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);
2388 align_adjust = current->_raw_size != old_size;
2389 sofar += current->_raw_size - old_size;
2390 }
2391 else
2392 {
2393 old_sofar = sofar;
2394 sofar = BFD_ALIGN (sofar, 1 << current->alignment_power);
2395 align_adjust = sofar != old_sofar;
2396 current->_raw_size += sofar - old_sofar;
2397 }
2398 #endif
2399
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
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
2416 previous = current;
2417 }
2418
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. */
2437 sofar = BFD_ALIGN (sofar, 1 << COFF_DEFAULT_SECTION_ALIGNMENT_POWER);
2438
2439 obj_relocbase (abfd) = sofar;
2440 abfd->output_has_begun = true;
2441
2442 return true;
2443 }
2444
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. */
2450
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? */
2454 static boolean
2455 coff_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;
2463
2464 for (i = 0; i < nsyms; i++)
2465 {
2466 coff_symbol_type *csym = coff_symbol_from (abfd, sympp[i]);
2467 CONST char *name;
2468 if (csym)
2469 {
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;
2482 #ifdef APOLLO_M68
2483 else if (!strcmp (name, ".wtext"))
2484 need_text = 0;
2485 #endif
2486 else if (!strcmp (name, _DATA))
2487 need_data = 0;
2488 else if (!strcmp (name, _BSS))
2489 need_bss = 0;
2490 }
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)
2497 return true;
2498 nsyms += need_text + need_data + need_bss + need_file;
2499 sympp2 = (asymbol **) bfd_alloc (abfd, nsyms * sizeof (asymbol *));
2500 if (!sympp2)
2501 return false;
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);
2514 BFD_ASSERT (i == nsyms);
2515 bfd_set_symtab (abfd, sympp2, nsyms);
2516 return true;
2517 }
2518
2519 #endif /* 0 */
2520
2521 /* SUPPRESS 558 */
2522 /* SUPPRESS 529 */
2523 static boolean
2524 coff_write_object_contents (abfd)
2525 bfd * abfd;
2526 {
2527 asection *current;
2528 boolean hasrelocs = false;
2529 boolean haslinno = false;
2530 file_ptr scn_base;
2531 file_ptr reloc_base;
2532 file_ptr lineno_base;
2533 file_ptr sym_base;
2534 unsigned long reloc_size = 0;
2535 unsigned long lnno_size = 0;
2536 boolean long_section_names;
2537 asection *text_sec = NULL;
2538 asection *data_sec = NULL;
2539 asection *bss_sec = NULL;
2540 struct internal_filehdr internal_f;
2541 struct internal_aouthdr internal_a;
2542 #ifdef COFF_LONG_SECTION_NAMES
2543 size_t string_size = STRING_SIZE_SIZE;
2544 #endif
2545
2546 bfd_set_error (bfd_error_system_call);
2547
2548 /* Make a pass through the symbol table to count line number entries and
2549 put them into the correct asections */
2550
2551 lnno_size = coff_count_linenumbers (abfd) * LINESZ;
2552
2553 if (abfd->output_has_begun == false)
2554 {
2555 if (! coff_compute_section_file_positions (abfd))
2556 return false;
2557 }
2558
2559 reloc_base = obj_relocbase (abfd);
2560
2561 /* Work out the size of the reloc and linno areas */
2562
2563 for (current = abfd->sections; current != NULL; current =
2564 current->next)
2565 reloc_size += current->reloc_count * RELSZ;
2566
2567 lineno_base = reloc_base + reloc_size;
2568 sym_base = lineno_base + lnno_size;
2569
2570 /* Indicate in each section->line_filepos its actual file address */
2571 for (current = abfd->sections; current != NULL; current =
2572 current->next)
2573 {
2574 if (current->lineno_count)
2575 {
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;
2592 }
2593 }
2594
2595 /* Write section headers to the file. */
2596 internal_f.f_nscns = 0;
2597
2598 if ((abfd->flags & EXEC_P) != 0)
2599 scn_base = FILHSZ + AOUTSZ;
2600 else
2601 {
2602 scn_base = FILHSZ;
2603 #ifdef RS6000COFF_C
2604 if (xcoff_data (abfd)->full_aouthdr)
2605 scn_base += AOUTSZ;
2606 else
2607 scn_base += SMALL_AOUTSZ;
2608 #endif
2609 }
2610
2611 if (bfd_seek (abfd, scn_base, SEEK_SET) != 0)
2612 return false;
2613
2614 long_section_names = false;
2615 for (current = abfd->sections;
2616 current != NULL;
2617 current = current->next)
2618 {
2619 struct internal_scnhdr section;
2620
2621 #ifdef COFF_WITH_PE
2622 /* If we've got a .reloc section, remember. */
2623
2624 #ifdef COFF_IMAGE_WITH_PE
2625 if (strcmp (current->name, ".reloc") == 0)
2626 {
2627 pe_data (abfd)->has_reloc_section = 1;
2628 }
2629 #endif
2630
2631 #endif
2632 internal_f.f_nscns++;
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);
2646 sprintf (section.s_name, "/%lu", (unsigned long) string_size);
2647 string_size += len + 1;
2648 long_section_names = true;
2649 }
2650 }
2651 #endif
2652
2653 #ifdef _LIB
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
2659 #endif
2660 section.s_vaddr = current->vma;
2661 section.s_paddr = current->lma;
2662 section.s_size = current->_raw_size;
2663
2664 #ifdef COFF_WITH_PE
2665 section.s_paddr = 0;
2666 #endif
2667 #ifdef COFF_IMAGE_WITH_PE
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;
2674 #endif
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
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
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;
2716 }
2717 else if (!strcmp (current->name, _BSS))
2718 {
2719 bss_sec = current;
2720 }
2721
2722 #ifdef I960
2723 section.s_align = (current->alignment_power
2724 ? 1 << current->alignment_power
2725 : 0);
2726 /* start-sanitize-tic80 */
2727 #else
2728 #ifdef TIC80COFF
2729 section.s_flags |= (current->alignment_power & 0xF) << 8;
2730 #endif
2731 /* end-sanitize-tic80 */
2732 #endif
2733
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
2742 #endif
2743 {
2744 SCNHDR buff;
2745 if (coff_swap_scnhdr_out (abfd, &section, &buff) == 0
2746 || bfd_write ((PTR) (&buff), 1, SCNHSZ, abfd) != SCNHSZ)
2747 return false;
2748 }
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;
2758 coff_symbol_type *csym = NULL;
2759 asymbol **psymsec;
2760
2761 psymsec = NULL;
2762 count = bfd_get_symcount (abfd);
2763 for (i = 0, psym = abfd->outsymbols; i < count; i++, psym++)
2764 {
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;
2772
2773 /* See if this is the section symbol. */
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;
2783
2784 /* Here *PSYM is the section symbol for CURRENT. */
2785
2786 break;
2787 }
2788 }
2789
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;
2796
2797 /* We don't touch the x_checksum field. The
2798 x_associated field is not currently supported. */
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 }
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 }
2840 }
2841 }
2842 #endif /* COFF_WITH_PE */
2843 }
2844
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;
2854
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
2872
2873 /* OK, now set up the filehdr... */
2874
2875 /* Don't include the internal abs section in the section count */
2876
2877 /*
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 */
2883 internal_f.f_timdat = 0;
2884
2885 internal_f.f_flags = 0;
2886
2887 if (abfd->flags & EXEC_P)
2888 internal_f.f_opthdr = AOUTSZ;
2889 else
2890 {
2891 internal_f.f_opthdr = 0;
2892 #ifdef RS6000COFF_C
2893 if (xcoff_data (abfd)->full_aouthdr)
2894 internal_f.f_opthdr = AOUTSZ;
2895 else
2896 internal_f.f_opthdr = SMALL_AOUTSZ;
2897 #endif
2898 }
2899
2900 if (!hasrelocs)
2901 internal_f.f_flags |= F_RELFLG;
2902 if (!haslinno)
2903 internal_f.f_flags |= F_LNNO;
2904 if (abfd->flags & EXEC_P)
2905 internal_f.f_flags |= F_EXEC;
2906
2907 /* FIXME: this is wrong for PPC_PE! */
2908 if (bfd_little_endian (abfd))
2909 internal_f.f_flags |= F_AR32WR;
2910 else
2911 internal_f.f_flags |= F_AR32W;
2912
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
2919 /*
2920 FIXME, should do something about the other byte orders and
2921 architectures.
2922 */
2923
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
2931 memset (&internal_a, 0, sizeof internal_a);
2932
2933 /* Set up architecture-dependent stuff */
2934
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... */
2942
2943 #ifdef A29K
2944 #ifdef ULTRA3 /* NYU's machine */
2945 /* FIXME: This is a bogus check. I really want to see if there
2946 * is a .shbss or a .shdata section, if so then set the magic
2947 * number to indicate a shared data executable.
2948 */
2949 if (internal_f.f_nscns >= 7)
2950 internal_a.magic = SHMAGIC; /* Shared magic */
2951 else
2952 #endif /* ULTRA3 */
2953 internal_a.magic = NMAGIC; /* Assume separate i/d */
2954 #define __A_MAGIC_SET__
2955 #endif /* A29K */
2956 /* start-sanitize-tic80 */
2957 #ifdef TIC80COFF
2958 internal_a.magic = TIC80_ARCH_MAGIC;
2959 #define __A_MAGIC_SET__
2960 #endif /* TIC80 */
2961 /* end-sanitize-tic80 */
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 */
2967 #ifdef I960
2968 internal_a.magic = (magic == I960ROMAGIC ? NMAGIC : OMAGIC);
2969 #define __A_MAGIC_SET__
2970 #endif /* I960 */
2971 #if M88
2972 #define __A_MAGIC_SET__
2973 internal_a.magic = PAGEMAGICBCS;
2974 #endif /* M88 */
2975
2976 #if APOLLO_M68
2977 #define __A_MAGIC_SET__
2978 internal_a.magic = APOLLO_COFF_VERSION_NUMBER;
2979 #endif
2980
2981 #if defined(M68) || defined(WE32K) || defined(M68K)
2982 #define __A_MAGIC_SET__
2983 #if defined(LYNXOS)
2984 internal_a.magic = LYNXCOFFMAGIC;
2985 #else
2986 #if defined(TARG_AUX)
2987 internal_a.magic = (abfd->flags & D_PAGED ? PAGEMAGICPEXECPAGED :
2988 abfd->flags & WP_TEXT ? PAGEMAGICPEXECSWAPPED :
2989 PAGEMAGICEXECSWAPPED);
2990 #else
2991 #if defined (PAGEMAGICPEXECPAGED)
2992 internal_a.magic = PAGEMAGICPEXECPAGED;
2993 #endif
2994 #endif /* TARG_AUX */
2995 #endif /* LYNXOS */
2996 #endif /* M68 || WE32K || M68K */
2997
2998 #if defined(ARM)
2999 #define __A_MAGIC_SET__
3000 internal_a.magic = ZMAGIC;
3001 #endif
3002
3003 #if defined(PPC_PE)
3004 #define __A_MAGIC_SET__
3005 internal_a.magic = IMAGE_NT_OPTIONAL_HDR_MAGIC;
3006 #endif
3007
3008 #if defined(I386)
3009 #define __A_MAGIC_SET__
3010 #if defined(LYNXOS)
3011 internal_a.magic = LYNXCOFFMAGIC;
3012 #else /* LYNXOS */
3013 internal_a.magic = ZMAGIC;
3014 #endif /* LYNXOS */
3015 #endif /* I386 */
3016
3017 #if defined(SPARC)
3018 #define __A_MAGIC_SET__
3019 #if defined(LYNXOS)
3020 internal_a.magic = LYNXCOFFMAGIC;
3021 #endif /* LYNXOS */
3022 #endif /* SPARC */
3023
3024 #ifdef RS6000COFF_C
3025 #define __A_MAGIC_SET__
3026 internal_a.magic = (abfd->flags & D_PAGED) ? RS6K_AOUTHDR_ZMAGIC :
3027 (abfd->flags & WP_TEXT) ? RS6K_AOUTHDR_NMAGIC :
3028 RS6K_AOUTHDR_OMAGIC;
3029 #endif
3030
3031 #ifndef __A_MAGIC_SET__
3032 #include "Your aouthdr magic number is not being set!"
3033 #else
3034 #undef __A_MAGIC_SET__
3035 #endif
3036 }
3037
3038 /* FIXME: Does anybody ever set this to another value? */
3039 internal_a.vstamp = 0;
3040
3041 /* Now should write relocs, strings, syms */
3042 obj_sym_filepos (abfd) = sym_base;
3043
3044 if (bfd_get_symcount (abfd) != 0)
3045 {
3046 int firstundef;
3047 #if 0
3048 if (!coff_add_missing_symbols (abfd))
3049 return false;
3050 #endif
3051 if (!coff_renumber_symbols (abfd, &firstundef))
3052 return false;
3053 coff_mangle_symbols (abfd);
3054 if (! coff_write_symbols (abfd))
3055 return false;
3056 if (! coff_write_linenumbers (abfd))
3057 return false;
3058 if (! coff_write_relocs (abfd, firstundef))
3059 return false;
3060 }
3061 #ifdef COFF_IMAGE_WITH_PE
3062 #ifdef PPC_PE
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
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)
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 }
3091 else
3092 {
3093 if (long_section_names)
3094 internal_f.f_symptr = sym_base;
3095 else
3096 internal_f.f_symptr = 0;
3097 internal_f.f_flags |= F_LSYMS;
3098 }
3099
3100 if (text_sec)
3101 {
3102 internal_a.tsize = bfd_get_section_size_before_reloc (text_sec);
3103 internal_a.text_start = internal_a.tsize ? text_sec->vma : 0;
3104 }
3105 if (data_sec)
3106 {
3107 internal_a.dsize = bfd_get_section_size_before_reloc (data_sec);
3108 internal_a.data_start = internal_a.dsize ? data_sec->vma : 0;
3109 }
3110 if (bss_sec)
3111 {
3112 internal_a.bsize = bfd_get_section_size_before_reloc (bss_sec);
3113 if (internal_a.bsize && bss_sec->vma < internal_a.data_start)
3114 internal_a.data_start = bss_sec->vma;
3115 }
3116
3117 internal_a.entry = bfd_get_start_address (abfd);
3118 internal_f.f_nsyms = obj_raw_syment_count (abfd);
3119
3120 #ifdef RS6000COFF_C
3121 if (xcoff_data (abfd)->full_aouthdr)
3122 {
3123 bfd_vma toc;
3124 asection *loader_sec;
3125
3126 internal_a.vstamp = 1;
3127
3128 internal_a.o_snentry = xcoff_data (abfd)->snentry;
3129 if (internal_a.o_snentry == 0)
3130 internal_a.entry = (bfd_vma) -1;
3131
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;
3164 internal_a.o_sntoc = xcoff_data (abfd)->sntoc;
3165
3166 internal_a.o_modtype = xcoff_data (abfd)->modtype;
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 }
3186 internal_a.o_maxstack = xcoff_data (abfd)->maxstack;
3187 internal_a.o_maxdata = xcoff_data (abfd)->maxdata;
3188 }
3189 #endif
3190
3191 /* now write them */
3192 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
3193 return false;
3194 {
3195 char buff[FILHSZ];
3196 coff_swap_filehdr_out (abfd, (PTR) & internal_f, (PTR) buff);
3197 if (bfd_write ((PTR) buff, 1, FILHSZ, abfd) != FILHSZ)
3198 return false;
3199 }
3200 if (abfd->flags & EXEC_P)
3201 {
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];
3205 coff_swap_aouthdr_out (abfd, (PTR) & internal_a, (PTR) buff);
3206 if (bfd_write ((PTR) buff, 1, AOUTSZ, abfd) != AOUTSZ)
3207 return false;
3208 }
3209 #ifdef RS6000COFF_C
3210 else
3211 {
3212 AOUTHDR buff;
3213 size_t size;
3214
3215 /* XCOFF seems to always write at least a small a.out header. */
3216 coff_swap_aouthdr_out (abfd, (PTR) &internal_a, (PTR) &buff);
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)
3222 return false;
3223 }
3224 #endif
3225
3226 return true;
3227 }
3228
3229 static boolean
3230 coff_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;
3236 {
3237 if (abfd->output_has_begun == false) /* set by bfd.c handler */
3238 {
3239 if (! coff_compute_section_file_positions (abfd))
3240 return false;
3241 }
3242
3243 #if defined(_LIB) && !defined(TARG_AUX)
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 {
3274 ++section->lma;
3275 rec += bfd_get_32 (abfd, rec) * 4;
3276 }
3277
3278 BFD_ASSERT (rec == recend);
3279 }
3280
3281 #endif
3282
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;
3287
3288 if (bfd_seek (abfd, (file_ptr) (section->filepos + offset), SEEK_SET) != 0)
3289 return false;
3290
3291 if (count != 0)
3292 {
3293 return (bfd_write (location, 1, count, abfd) == count) ? true : false;
3294 }
3295 return true;
3296 }
3297 #if 0
3298 static boolean
3299 coff_close_and_cleanup (abfd)
3300 bfd *abfd;
3301 {
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:
3314 bfd_set_error (bfd_error_invalid_operation);
3315 return false;
3316 }
3317
3318 /* We depend on bfd_close to free all the memory on the objalloc. */
3319 return true;
3320 }
3321
3322 #endif
3323
3324 static PTR
3325 buy_and_read (abfd, where, seek_direction, size)
3326 bfd *abfd;
3327 file_ptr where;
3328 int seek_direction;
3329 size_t size;
3330 {
3331 PTR area = (PTR) bfd_alloc (abfd, size);
3332 if (!area)
3333 return (NULL);
3334 if (bfd_seek (abfd, where, seek_direction) != 0
3335 || bfd_read (area, 1, size, abfd) != size)
3336 return (NULL);
3337 return (area);
3338 } /* buy_and_read() */
3339
3340 /*
3341 SUBSUBSECTION
3342 Reading linenumbers
3343
3344 Creating the linenumber table is done by reading in the entire
3345 coff linenumber table, and creating another table for internal use.
3346
3347 A coff linenumber table is structured so that each function
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
3351 the symbol associated with the function.
3352
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...
3356
3357 How does this work ?
3358
3359 */
3360
3361 static boolean
3362 coff_slurp_line_table (abfd, asect)
3363 bfd *abfd;
3364 asection *asect;
3365 {
3366 LINENO *native_lineno;
3367 alent *lineno_cache;
3368
3369 BFD_ASSERT (asect->lineno == (alent *) NULL);
3370
3371 native_lineno = (LINENO *) buy_and_read (abfd,
3372 asect->line_filepos,
3373 SEEK_SET,
3374 (size_t) (LINESZ *
3375 asect->lineno_count));
3376 lineno_cache =
3377 (alent *) bfd_alloc (abfd, (size_t) ((asect->lineno_count + 1) * sizeof (alent)));
3378 if (lineno_cache == NULL)
3379 return false;
3380 else
3381 {
3382 unsigned int counter = 0;
3383 alent *cache_ptr = lineno_cache;
3384 LINENO *src = native_lineno;
3385
3386 while (counter < asect->lineno_count)
3387 {
3388 struct internal_lineno dst;
3389 coff_swap_lineno_in (abfd, src, &dst);
3390 cache_ptr->line_number = dst.l_lnno;
3391
3392 if (cache_ptr->line_number == 0)
3393 {
3394 boolean warned;
3395 long symndx;
3396 coff_symbol_type *sym;
3397
3398 warned = false;
3399 symndx = dst.l_addr.l_symndx;
3400 if (symndx < 0
3401 || (unsigned long) symndx >= obj_raw_syment_count (abfd))
3402 {
3403 (*_bfd_error_handler)
3404 (_("%s: warning: illegal symbol index %ld in line numbers"),
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));
3414 cache_ptr->u.sym = (asymbol *) sym;
3415 if (sym->lineno != NULL && ! warned)
3416 {
3417 (*_bfd_error_handler)
3418 (_("%s: warning: duplicate line number information for `%s'"),
3419 bfd_get_filename (abfd),
3420 bfd_asymbol_name (&sym->symbol));
3421 }
3422 sym->lineno = cache_ptr;
3423 }
3424 else
3425 {
3426 cache_ptr->u.offset = dst.l_addr.l_paddr
3427 - bfd_section_vma (abfd, asect);
3428 } /* If no linenumber expect a symbol index */
3429
3430 cache_ptr++;
3431 src++;
3432 counter++;
3433 }
3434 cache_ptr->line_number = 0;
3435
3436 }
3437 asect->lineno = lineno_cache;
3438 /* FIXME, free native_lineno here, or use alloca or something. */
3439 return true;
3440 }
3441
3442 static boolean
3443 coff_slurp_symbol_table (abfd)
3444 bfd * abfd;
3445 {
3446 combined_entry_type *native_symbols;
3447 coff_symbol_type *cached_area;
3448 unsigned int *table_ptr;
3449
3450 unsigned int number_of_symbols = 0;
3451
3452 if (obj_symbols (abfd))
3453 return true;
3454
3455 /* Read in the symbol table */
3456 if ((native_symbols = coff_get_normalized_symtab (abfd)) == NULL)
3457 {
3458 return (false);
3459 } /* on error */
3460
3461 /* Allocate enough room for all the symbols in cached form */
3462 cached_area = ((coff_symbol_type *)
3463 bfd_alloc (abfd,
3464 (obj_raw_syment_count (abfd)
3465 * sizeof (coff_symbol_type))));
3466
3467 if (cached_area == NULL)
3468 return false;
3469 table_ptr = ((unsigned int *)
3470 bfd_alloc (abfd,
3471 (obj_raw_syment_count (abfd)
3472 * sizeof (unsigned int))));
3473
3474 if (table_ptr == NULL)
3475 return false;
3476 else
3477 {
3478 coff_symbol_type *dst = cached_area;
3479 unsigned int last_native_index = obj_raw_syment_count (abfd);
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 {
3497 #ifdef I960
3498 case C_LEAFEXT:
3499 #if 0
3500 dst->symbol.value = src->u.syment.n_value - dst->symbol.section->vma;
3501 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
3502 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
3503 #endif
3504 /* Fall through to next case */
3505
3506 #endif
3507
3508 case C_EXT:
3509 #if defined ARM
3510 case C_THUMBEXT:
3511 case C_THUMBEXTFUNC:
3512 #endif
3513 #ifdef RS6000COFF_C
3514 case C_HIDEXT:
3515 #endif
3516 #ifdef C_SYSTEM
3517 case C_SYSTEM: /* System Wide variable */
3518 #endif
3519 #ifdef COFF_WITH_PE
3520 /* PE uses storage class 0x68 to denote a section symbol */
3521 case C_SECTION:
3522 /* PE uses storage class 0x69 for a weak external symbol. */
3523 case C_NT_WEAK:
3524 #endif
3525 if ((src->u.syment.n_scnum) == 0)
3526 {
3527 if ((src->u.syment.n_value) == 0)
3528 {
3529 dst->symbol.section = bfd_und_section_ptr;
3530 dst->symbol.value = 0;
3531 }
3532 else
3533 {
3534 dst->symbol.section = bfd_com_section_ptr;
3535 dst->symbol.value = (src->u.syment.n_value);
3536 }
3537 }
3538 else
3539 {
3540 /* Base the value as an index from the base of the
3541 section */
3542
3543 dst->symbol.flags = BSF_EXPORT | BSF_GLOBAL;
3544
3545 #if defined COFF_WITH_PE
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
3550 dst->symbol.value = (src->u.syment.n_value
3551 - dst->symbol.section->vma);
3552 #endif
3553
3554 if (ISFCN ((src->u.syment.n_type)))
3555 {
3556 /* A function ext does not go at the end of a
3557 file. */
3558 dst->symbol.flags |= BSF_NOT_AT_END | BSF_FUNCTION;
3559 }
3560 }
3561
3562 #ifdef RS6000COFF_C
3563 /* A C_HIDEXT symbol is not global. */
3564 if (src->u.syment.n_sclass == C_HIDEXT)
3565 dst->symbol.flags = BSF_LOCAL;
3566 /* A symbol with a csect entry should not go at the end. */
3567 if (src->u.syment.n_numaux > 0)
3568 dst->symbol.flags |= BSF_NOT_AT_END;
3569 #endif
3570
3571 #ifdef COFF_WITH_PE
3572 if (src->u.syment.n_sclass == C_NT_WEAK)
3573 dst->symbol.flags = BSF_WEAK;
3574 #endif
3575
3576 break;
3577
3578 case C_STAT: /* static */
3579 #ifdef I960
3580 case C_LEAFSTAT: /* static leaf procedure */
3581 #endif
3582 #if defined ARM
3583 case C_THUMBSTAT: /* Thumb static */
3584 case C_THUMBLABEL: /* Thumb label */
3585 case C_THUMBSTATFUNC:/* Thumb static function */
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;
3592
3593 /* Base the value as an index from the base of the
3594 section, if there is one. */
3595 if (dst->symbol.section)
3596 {
3597 #if defined COFF_WITH_PE
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 }
3606 else
3607 dst->symbol.value = src->u.syment.n_value;
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 */
3613 #ifdef C_GLBLREG
3614 case C_GLBLREG: /* A29k-specific storage class */
3615 #endif
3616 #endif
3617 case C_REGPARM: /* register parameter */
3618 case C_REG: /* register variable */
3619 /* start-sanitize-tic80 */
3620 #ifndef TIC80COFF
3621 /* end-sanitize-tic80 */
3622 #ifdef C_AUTOARG
3623 case C_AUTOARG: /* 960-specific storage class */
3624 #endif
3625 /* start-sanitize-tic80 */
3626 #endif
3627 /* end-sanitize-tic80 */
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 */
3642 #ifdef RS6000COFF_C
3643 case C_GSYM:
3644 case C_LSYM:
3645 case C_PSYM:
3646 case C_RSYM:
3647 case C_RPSYM:
3648 case C_STSYM:
3649 case C_BCOMM:
3650 case C_ECOMM:
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;
3659
3660 #ifdef RS6000COFF_C
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)
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))
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
3690 case C_BSTAT:
3691 dst->symbol.flags = BSF_DEBUGGING;
3692
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. */
3696 src->u.syment.n_value =
3697 (long) (native_symbols + src->u.syment.n_value);
3698 dst->symbol.value = src->u.syment.n_value;
3699 src->fix_value = 1;
3700 break;
3701 #endif
3702
3703 case C_BLOCK: /* ".bb" or ".eb" */
3704 case C_FCN: /* ".bf" or ".ef" */
3705 case C_EFCN: /* physical end of function */
3706 dst->symbol.flags = BSF_LOCAL;
3707 #if defined COFF_WITH_PE
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
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);
3716 #endif
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 */
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 */
3726 case C_LINE: /* line # reformatted as symbol table entry */
3727 /* NT uses 0x67 for a weak symbol, not C_ALIAS. */
3728 case C_ALIAS: /* duplicate tag */
3729 #endif
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 */
3738 case C_HIDDEN: /* ext symbol in dmert public lib */
3739 default:
3740 (*_bfd_error_handler)
3741 (_("%s: Unrecognized storage class %d for %s symbol `%s'"),
3742 bfd_get_filename (abfd), src->u.syment.n_sclass,
3743 dst->symbol.section->name, dst->symbol.name);
3744 dst->symbol.flags = BSF_DEBUGGING;
3745 dst->symbol.value = (src->u.syment.n_value);
3746 break;
3747 }
3748
3749 /* BFD_ASSERT(dst->symbol.flags != 0);*/
3750
3751 dst->native = src;
3752
3753 dst->symbol.udata.i = 0;
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 */
3760
3761 obj_symbols (abfd) = cached_area;
3762 obj_raw_syments (abfd) = native_symbols;
3763
3764 bfd_get_symcount (abfd) = number_of_symbols;
3765 obj_convert (abfd) = table_ptr;
3766 /* Slurp the line tables for each section too */
3767 {
3768 asection *p;
3769 p = abfd->sections;
3770 while (p)
3771 {
3772 coff_slurp_line_table (abfd, p);
3773 p = p->next;
3774 }
3775 }
3776 return true;
3777 } /* coff_slurp_symbol_table() */
3778
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
3790 #ifdef COFFARM
3791 #define OTHER_GLOBAL_CLASS C_THUMBEXT || syment->n_sclass == C_THUMBEXTFUNC
3792 #else
3793 #ifdef COFF_WITH_PE
3794 #define OTHER_GLOBAL_CLASS C_SECTION
3795 #endif
3796 #endif
3797
3798 #ifdef OTHER_GLOBAL_CLASS
3799
3800 static boolean coff_sym_is_global PARAMS ((bfd *, struct internal_syment *));
3801
3802 static boolean
3803 coff_sym_is_global (abfd, syment)
3804 bfd * abfd;
3805 struct internal_syment * syment;
3806 {
3807 return (syment->n_sclass == OTHER_GLOBAL_CLASS);
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
3820 /*
3821 SUBSUBSECTION
3822 Reading relocations
3823
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
3829 o Read the entire coff relocation table into memory.
3830
3831 o Process each relocation in turn; first swap it from the
3832 external to the internal form.
3833
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
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
3847 */
3848
3849 #ifndef CALC_ADDEND
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 }
3867 #endif
3868
3869 static boolean
3870 coff_slurp_reloc_table (abfd, asect, symbols)
3871 bfd * abfd;
3872 sec_ptr asect;
3873 asymbol ** symbols;
3874 {
3875 RELOC *native_relocs;
3876 arelent *reloc_cache;
3877 arelent *cache_ptr;
3878
3879 unsigned int idx;
3880
3881 if (asect->relocation)
3882 return true;
3883 if (asect->reloc_count == 0)
3884 return true;
3885 if (asect->flags & SEC_CONSTRUCTOR)
3886 return true;
3887 if (!coff_slurp_symbol_table (abfd))
3888 return false;
3889 native_relocs =
3890 (RELOC *) buy_and_read (abfd,
3891 asect->rel_filepos,
3892 SEEK_SET,
3893 (size_t) (RELSZ *
3894 asect->reloc_count));
3895 reloc_cache = (arelent *)
3896 bfd_alloc (abfd, (size_t) (asect->reloc_count * sizeof (arelent)));
3897
3898 if (reloc_cache == NULL)
3899 return false;
3900
3901
3902 for (idx = 0; idx < asect->reloc_count; idx++)
3903 {
3904 struct internal_reloc dst;
3905 struct external_reloc *src;
3906 #ifndef RELOC_PROCESSING
3907 asymbol *ptr;
3908 #endif
3909
3910 cache_ptr = reloc_cache + idx;
3911 src = native_relocs + idx;
3912
3913 coff_swap_reloc_in (abfd, src, &dst);
3914
3915 #ifdef RELOC_PROCESSING
3916 RELOC_PROCESSING (cache_ptr, &dst, symbols, abfd, asect);
3917 #else
3918 cache_ptr->address = dst.r_vaddr;
3919
3920 if (dst.r_symndx != -1)
3921 {
3922 if (dst.r_symndx < 0 || dst.r_symndx >= obj_conv_table_size (abfd))
3923 {
3924 (*_bfd_error_handler)
3925 (_("%s: warning: illegal symbol index %ld in relocs"),
3926 bfd_get_filename (abfd), dst.r_symndx);
3927 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
3928 ptr = NULL;
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 }
3936 }
3937 else
3938 {
3939 cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
3940 ptr = NULL;
3941 }
3942
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 */
3949
3950 /* Calculate any reloc addend by looking at the symbol */
3951 CALC_ADDEND (abfd, ptr, dst, cache_ptr);
3952
3953 cache_ptr->address -= asect->vma;
3954 /* !! cache_ptr->section = (asection *) NULL;*/
3955
3956 /* Fill in the cache_ptr->howto field from dst.r_type */
3957 RTYPE2HOWTO (cache_ptr, &dst);
3958 #endif /* RELOC_PROCESSING */
3959
3960 if (cache_ptr->howto == NULL)
3961 {
3962 (*_bfd_error_handler)
3963 (_("%s: illegal relocation type %d at address 0x%lx"),
3964 bfd_get_filename (abfd), dst.r_type, (long) dst.r_vaddr);
3965 bfd_set_error (bfd_error_bad_value);
3966 return false;
3967 }
3968 }
3969
3970 asect->relocation = reloc_cache;
3971 return true;
3972 }
3973
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
3983 static 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*/
3989 static reloc_howto_type *
3990 coff_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) */
4010
4011 /* This is stupid. This function should be a boolean predicate. */
4012 static long
4013 coff_canonicalize_reloc (abfd, section, relptr, symbols)
4014 bfd * abfd;
4015 sec_ptr section;
4016 arelent ** relptr;
4017 asymbol ** symbols;
4018 {
4019 arelent *tblptr = section->relocation;
4020 unsigned int count = 0;
4021
4022
4023 if (section->flags & SEC_CONSTRUCTOR)
4024 {
4025 /* this section has relocs made up by us, they are not in the
4026 file, so take them out of their chain and place them into
4027 the data area provided */
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 }
4034
4035 }
4036 else
4037 {
4038 if (! coff_slurp_reloc_table (abfd, section, symbols))
4039 return -1;
4040
4041 tblptr = section->relocation;
4042
4043 for (; count++ < section->reloc_count;)
4044 *relptr++ = tblptr++;
4045
4046
4047 }
4048 *relptr = 0;
4049 return section->reloc_count;
4050 }
4051
4052 #ifdef GNU960
4053 file_ptr
4054 coff_sym_filepos (abfd)
4055 bfd *abfd;
4056 {
4057 return obj_sym_filepos (abfd);
4058 }
4059 #endif
4060
4061 #ifndef coff_reloc16_estimate
4062 #define coff_reloc16_estimate dummy_reloc16_estimate
4063
4064 static int dummy_reloc16_estimate
4065 PARAMS ((bfd *, asection *, arelent *, unsigned int,
4066 struct bfd_link_info *));
4067
4068 static int
4069 dummy_reloc16_estimate (abfd, input_section, reloc, shrink, link_info)
4070 bfd *abfd;
4071 asection *input_section;
4072 arelent *reloc;
4073 unsigned int shrink;
4074 struct bfd_link_info *link_info;
4075 {
4076 abort ();
4077 }
4078
4079 #endif
4080
4081 #ifndef coff_reloc16_extra_cases
4082
4083 #define coff_reloc16_extra_cases dummy_reloc16_extra_cases
4084
4085 /* This works even if abort is not declared in any header file. */
4086
4087 static 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
4091 static void
4092 dummy_reloc16_extra_cases (abfd, link_info, link_order, reloc, data, src_ptr,
4093 dst_ptr)
4094 bfd *abfd;
4095 struct bfd_link_info *link_info;
4096 struct bfd_link_order *link_order;
4097 arelent *reloc;
4098 bfd_byte *data;
4099 unsigned int *src_ptr;
4100 unsigned int *dst_ptr;
4101 {
4102 abort ();
4103 }
4104 #endif
4105
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
4109 #ifndef coff_bfd_link_hash_table_create
4110 #define coff_bfd_link_hash_table_create _bfd_coff_link_hash_table_create
4111 #endif
4112 #ifndef coff_bfd_link_add_symbols
4113 #define coff_bfd_link_add_symbols _bfd_coff_link_add_symbols
4114 #endif
4115 #ifndef coff_bfd_final_link
4116 #define coff_bfd_final_link _bfd_coff_final_link
4117 #endif
4118 #else /* ! defined (coff_relocate_section) */
4119 #define coff_relocate_section NULL
4120 #ifndef coff_bfd_link_hash_table_create
4121 #define coff_bfd_link_hash_table_create _bfd_generic_link_hash_table_create
4122 #endif
4123 #ifndef coff_bfd_link_add_symbols
4124 #define coff_bfd_link_add_symbols _bfd_generic_link_add_symbols
4125 #endif
4126 #define coff_bfd_final_link _bfd_generic_final_link
4127 #endif /* ! defined (coff_relocate_section) */
4128
4129 #define coff_bfd_link_split_section _bfd_generic_link_split_section
4130
4131 #ifndef coff_start_final_link
4132 #define coff_start_final_link NULL
4133 #endif
4134
4135 #ifndef coff_adjust_symndx
4136 #define coff_adjust_symndx NULL
4137 #endif
4138
4139 #ifndef coff_link_add_one_symbol
4140 #define coff_link_add_one_symbol _bfd_generic_link_add_one_symbol
4141 #endif
4142
4143 #ifndef coff_link_output_has_begun
4144 #define coff_link_output_has_begun _coff_link_output_has_begun
4145 static boolean
4146 _coff_link_output_has_begun (abfd, info)
4147 bfd * abfd;
4148 struct bfd_link_info * info;
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
4156 static 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
4210 static CONST bfd_coff_backend_data bfd_coff_std_swap_table =
4211 {
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,
4217 FILHSZ, AOUTSZ, SCNHSZ, SYMESZ, AUXESZ, RELSZ, LINESZ,
4218 #ifdef COFF_LONG_FILENAMES
4219 true,
4220 #else
4221 false,
4222 #endif
4223 #ifdef COFF_LONG_SECTION_NAMES
4224 true,
4225 #else
4226 false,
4227 #endif
4228 COFF_DEFAULT_SECTION_ALIGNMENT_POWER,
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,
4231 coff_mkobject_hook, styp_to_sec_flags, coff_set_alignment_hook,
4232 coff_slurp_symbol_table, symname_in_debug_hook, coff_pointerize_aux_hook,
4233 coff_print_aux, coff_reloc16_extra_cases, coff_reloc16_estimate,
4234 coff_sym_is_global, coff_compute_section_file_positions,
4235 coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
4236 coff_adjust_symndx, coff_link_add_one_symbol,
4237 coff_link_output_has_begun, coff_final_link_postscript
4238 };
4239
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
4251
4252 #ifndef coff_bfd_copy_private_symbol_data
4253 #define coff_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
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
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
4266 #endif
4267
4268 #ifndef coff_bfd_set_private_flags
4269 #define coff_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
4270 #endif
4271
4272 #ifndef coff_bfd_print_private_bfd_data
4273 #define coff_bfd_print_private_bfd_data _bfd_generic_bfd_print_private_bfd_data
4274 #endif
4275
4276 #ifndef coff_bfd_is_local_label_name
4277 #define coff_bfd_is_local_label_name _bfd_coff_is_local_label_name
4278 #endif
4279
4280 #ifndef coff_read_minisymbols
4281 #define coff_read_minisymbols _bfd_generic_read_minisymbols
4282 #endif
4283
4284 #ifndef coff_minisymbol_to_symbol
4285 #define coff_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
4286 #endif
4287
4288 /* The reloc lookup routine must be supplied by each individual COFF
4289 backend. */
4290 #ifndef coff_bfd_reloc_type_lookup
4291 #define coff_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
4292 #endif
4293
4294 #ifndef coff_bfd_get_relocated_section_contents
4295 #define coff_bfd_get_relocated_section_contents \
4296 bfd_generic_get_relocated_section_contents
4297 #endif
4298
4299 #ifndef coff_bfd_relax_section
4300 #define coff_bfd_relax_section bfd_generic_relax_section
4301 #endif
4302
4303 #ifndef coff_bfd_gc_sections
4304 #define coff_bfd_gc_sections bfd_generic_gc_sections
4305 #endif
A mirror of the official binutils-gdb repository