1 /* Support for the generic parts of COFF, for BFD.
2 Copyright (C) 1990-2023 Free Software Foundation, Inc.
3 Written by Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
22 /* Most of this hacked by Steve Chamberlain, sac@cygnus.com.
23 Split out of coffcode.h by Ian Taylor, ian@cygnus.com. */
25 /* This file contains COFF code that is not dependent on any
26 particular COFF target. There is only one version of this file in
27 libbfd.a, so no target specific code may be put in here. Or, to
30 ********** DO NOT PUT TARGET SPECIFIC CODE IN THIS FILE **********
32 If you need to add some target specific behaviour, add a new hook
33 function to bfd_coff_backend_data.
35 Some of these functions are also called by the ECOFF routines.
36 Those functions may not use any COFF specific information, such as
43 #include "coff/internal.h"
47 /* Extract a long section name at STRINDEX and copy it to the bfd objstack.
48 Return NULL in case of error. */
51 extract_long_section_name(bfd
*abfd
, unsigned long strindex
)
56 strings
= _bfd_coff_read_string_table (abfd
);
59 if ((bfd_size_type
)(strindex
+ 2) >= obj_coff_strings_len (abfd
))
62 name
= (char *) bfd_alloc (abfd
, (bfd_size_type
) strlen (strings
) + 1);
65 strcpy (name
, strings
);
70 /* Decode a base 64 coded string at STR of length LEN, and write the result
71 to RES. Return true on success.
72 Return false in case of invalid character or overflow. */
75 decode_base64 (const char *str
, unsigned len
, uint32_t *res
)
81 for (i
= 0; i
< len
; i
++)
86 if (c
>= 'A' && c
<= 'Z')
88 else if (c
>= 'a' && c
<= 'z')
90 else if (c
>= '0' && c
<= '9')
99 /* Check for overflow. */
100 if ((val
>> 26) != 0)
103 val
= (val
<< 6) + d
;
110 /* Take a section header read from a coff file (in HOST byte order),
111 and make a BFD "section" out of it. This is used by ECOFF. */
114 make_a_section_from_file (bfd
*abfd
,
115 struct internal_scnhdr
*hdr
,
116 unsigned int target_index
)
125 /* Handle long section names as in PE. On reading, we want to
126 accept long names if the format permits them at all, regardless
127 of the current state of the flag that dictates if we would generate
128 them in outputs; this construct checks if that is the case by
129 attempting to set the flag, without changing its state; the call
130 will fail for formats that do not support long names at all. */
131 if (bfd_coff_set_long_section_names (abfd
, bfd_coff_long_section_names (abfd
))
132 && hdr
->s_name
[0] == '/')
134 /* Flag that this BFD uses long names, even though the format might
135 expect them to be off by default. This won't directly affect the
136 format of any output BFD created from this one, but the information
137 can be used to decide what to do. */
138 bfd_coff_set_long_section_names (abfd
, true);
140 if (hdr
->s_name
[1] == '/')
142 /* LLVM extension: the '/' is followed by another '/' and then by
143 the index in the strtab encoded in base64 without NUL at the
147 /* Decode the index. No overflow is expected as the string table
148 length is at most 2^32 - 1 (the length is written on the first
150 Also, contrary to RFC 4648, all the characters must be decoded,
151 there is no padding. */
152 if (!decode_base64 (hdr
->s_name
+ 2, SCNNMLEN
- 2, &strindex
))
155 name
= extract_long_section_name (abfd
, strindex
);
161 /* PE classic long section name. The '/' is followed by the index
162 in the strtab. The index is formatted as a decimal string. */
167 memcpy (buf
, hdr
->s_name
+ 1, SCNNMLEN
- 1);
168 buf
[SCNNMLEN
- 1] = '\0';
169 strindex
= strtol (buf
, &p
, 10);
170 if (*p
== '\0' && strindex
>= 0)
172 name
= extract_long_section_name (abfd
, strindex
);
181 /* Assorted wastage to null-terminate the name, thanks AT&T! */
182 name
= (char *) bfd_alloc (abfd
,
183 (bfd_size_type
) sizeof (hdr
->s_name
) + 1 + 1);
186 strncpy (name
, (char *) &hdr
->s_name
[0], sizeof (hdr
->s_name
));
187 name
[sizeof (hdr
->s_name
)] = 0;
190 newsect
= bfd_make_section_anyway (abfd
, name
);
194 newsect
->vma
= hdr
->s_vaddr
;
195 newsect
->lma
= hdr
->s_paddr
;
196 newsect
->size
= hdr
->s_size
;
197 newsect
->filepos
= hdr
->s_scnptr
;
198 newsect
->rel_filepos
= hdr
->s_relptr
;
199 newsect
->reloc_count
= hdr
->s_nreloc
;
201 bfd_coff_set_alignment_hook (abfd
, newsect
, hdr
);
203 newsect
->line_filepos
= hdr
->s_lnnoptr
;
205 newsect
->lineno_count
= hdr
->s_nlnno
;
206 newsect
->userdata
= NULL
;
207 newsect
->next
= NULL
;
208 newsect
->target_index
= target_index
;
210 if (!bfd_coff_styp_to_sec_flags_hook (abfd
, hdr
, name
, newsect
, &flags
))
213 /* At least on i386-coff, the line number count for a shared library
214 section must be ignored. */
215 if ((flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
216 newsect
->lineno_count
= 0;
218 if (hdr
->s_nreloc
!= 0)
220 /* FIXME: should this check 'hdr->s_size > 0'. */
221 if (hdr
->s_scnptr
!= 0)
222 flags
|= SEC_HAS_CONTENTS
;
224 newsect
->flags
= flags
;
226 /* Compress/decompress DWARF debug sections. */
227 if ((flags
& SEC_DEBUGGING
) != 0
228 && (flags
& SEC_HAS_CONTENTS
) != 0
229 && (startswith (name
, ".debug_")
230 || startswith (name
, ".zdebug_")
231 || startswith (name
, ".gnu.debuglto_.debug_")
232 || startswith (name
, ".gnu.linkonce.wi.")))
234 enum { nothing
, compress
, decompress
} action
= nothing
;
236 if (bfd_is_section_compressed (abfd
, newsect
))
238 /* Compressed section. Check if we should decompress. */
239 if ((abfd
->flags
& BFD_DECOMPRESS
))
244 /* Normal section. Check if we should compress. */
245 if ((abfd
->flags
& BFD_COMPRESS
) && newsect
->size
!= 0)
249 if (action
== compress
)
251 if (!bfd_init_section_compress_status (abfd
, newsect
))
254 /* xgettext:c-format */
255 (_("%pB: unable to compress section %s"), abfd
, name
);
259 else if (action
== decompress
)
261 if (!bfd_init_section_decompress_status (abfd
, newsect
))
264 /* xgettext:c-format */
265 (_("%pB: unable to decompress section %s"), abfd
, name
);
268 if (abfd
->is_linker_input
271 /* Rename section from .zdebug_* to .debug_* so that ld
272 scripts will see this section as a debug section. */
273 char *new_name
= bfd_zdebug_name_to_debug (abfd
, name
);
274 if (new_name
== NULL
)
276 bfd_rename_section (newsect
, new_name
);
285 coff_object_cleanup (bfd
*abfd
)
287 if (bfd_family_coff (abfd
) && bfd_get_format (abfd
) == bfd_object
)
289 struct coff_tdata
*td
= coff_data (abfd
);
292 if (td
->section_by_index
)
293 htab_delete (td
->section_by_index
);
294 if (td
->section_by_target_index
)
295 htab_delete (td
->section_by_target_index
);
300 /* Read in a COFF object and make it into a BFD. This is used by
303 coff_real_object_p (bfd
*abfd
,
305 struct internal_filehdr
*internal_f
,
306 struct internal_aouthdr
*internal_a
)
308 flagword oflags
= abfd
->flags
;
309 bfd_vma ostart
= bfd_get_start_address (abfd
);
312 bfd_size_type readsize
; /* Length of file_info. */
314 char *external_sections
;
316 if (!(internal_f
->f_flags
& F_RELFLG
))
317 abfd
->flags
|= HAS_RELOC
;
318 if ((internal_f
->f_flags
& F_EXEC
))
319 abfd
->flags
|= EXEC_P
;
320 if (!(internal_f
->f_flags
& F_LNNO
))
321 abfd
->flags
|= HAS_LINENO
;
322 if (!(internal_f
->f_flags
& F_LSYMS
))
323 abfd
->flags
|= HAS_LOCALS
;
325 /* FIXME: How can we set D_PAGED correctly? */
326 if ((internal_f
->f_flags
& F_EXEC
) != 0)
327 abfd
->flags
|= D_PAGED
;
329 abfd
->symcount
= internal_f
->f_nsyms
;
330 if (internal_f
->f_nsyms
)
331 abfd
->flags
|= HAS_SYMS
;
333 if (internal_a
!= (struct internal_aouthdr
*) NULL
)
334 abfd
->start_address
= internal_a
->entry
;
336 abfd
->start_address
= 0;
338 /* Set up the tdata area. ECOFF uses its own routine, and overrides
340 tdata_save
= abfd
->tdata
.any
;
341 tdata
= bfd_coff_mkobject_hook (abfd
, (void *) internal_f
, (void *) internal_a
);
345 scnhsz
= bfd_coff_scnhsz (abfd
);
346 readsize
= (bfd_size_type
) nscns
* scnhsz
;
347 external_sections
= (char *) _bfd_alloc_and_read (abfd
, readsize
, readsize
);
348 if (!external_sections
)
351 /* Set the arch/mach *before* swapping in sections; section header swapping
352 may depend on arch/mach info. */
353 if (! bfd_coff_set_arch_mach_hook (abfd
, (void *) internal_f
))
356 /* Now copy data as required; construct all asections etc. */
360 for (i
= 0; i
< nscns
; i
++)
362 struct internal_scnhdr tmp
;
363 bfd_coff_swap_scnhdr_in (abfd
,
364 (void *) (external_sections
+ i
* scnhsz
),
366 if (! make_a_section_from_file (abfd
, &tmp
, i
+ 1))
371 _bfd_coff_free_symbols (abfd
);
372 return coff_object_cleanup
;
375 coff_object_cleanup (abfd
);
376 _bfd_coff_free_symbols (abfd
);
377 bfd_release (abfd
, tdata
);
379 abfd
->tdata
.any
= tdata_save
;
380 abfd
->flags
= oflags
;
381 abfd
->start_address
= ostart
;
385 /* Turn a COFF file into a BFD, but fail with bfd_error_wrong_format if it is
386 not a COFF file. This is also used by ECOFF. */
389 coff_object_p (bfd
*abfd
)
391 bfd_size_type filhsz
;
392 bfd_size_type aoutsz
;
395 struct internal_filehdr internal_f
;
396 struct internal_aouthdr internal_a
;
398 /* Figure out how much to read. */
399 filhsz
= bfd_coff_filhsz (abfd
);
400 aoutsz
= bfd_coff_aoutsz (abfd
);
402 filehdr
= _bfd_alloc_and_read (abfd
, filhsz
, filhsz
);
405 if (bfd_get_error () != bfd_error_system_call
)
406 bfd_set_error (bfd_error_wrong_format
);
409 bfd_coff_swap_filehdr_in (abfd
, filehdr
, &internal_f
);
410 bfd_release (abfd
, filehdr
);
412 /* The XCOFF format has two sizes for the f_opthdr. SMALL_AOUTSZ
413 (less than aoutsz) used in object files and AOUTSZ (equal to
414 aoutsz) in executables. The bfd_coff_swap_aouthdr_in function
415 expects this header to be aoutsz bytes in length, so we use that
416 value in the call to bfd_alloc below. But we must be careful to
417 only read in f_opthdr bytes in the call to bfd_bread. We should
418 also attempt to catch corrupt or non-COFF binaries with a strange
419 value for f_opthdr. */
420 if (! bfd_coff_bad_format_hook (abfd
, &internal_f
)
421 || internal_f
.f_opthdr
> aoutsz
)
423 bfd_set_error (bfd_error_wrong_format
);
426 nscns
= internal_f
.f_nscns
;
428 if (internal_f
.f_opthdr
)
432 opthdr
= _bfd_alloc_and_read (abfd
, aoutsz
, internal_f
.f_opthdr
);
435 /* PR 17512: file: 11056-1136-0.004. */
436 if (internal_f
.f_opthdr
< aoutsz
)
437 memset (((char *) opthdr
) + internal_f
.f_opthdr
, 0,
438 aoutsz
- internal_f
.f_opthdr
);
440 bfd_coff_swap_aouthdr_in (abfd
, opthdr
, (void *) &internal_a
);
441 bfd_release (abfd
, opthdr
);
444 return coff_real_object_p (abfd
, nscns
, &internal_f
,
445 (internal_f
.f_opthdr
!= 0
447 : (struct internal_aouthdr
*) NULL
));
451 htab_hash_section_target_index (const void * entry
)
453 const struct bfd_section
* sec
= entry
;
454 return sec
->target_index
;
458 htab_eq_section_target_index (const void * e1
, const void * e2
)
460 const struct bfd_section
* sec1
= e1
;
461 const struct bfd_section
* sec2
= e2
;
462 return sec1
->target_index
== sec2
->target_index
;
465 /* Get the BFD section from a COFF symbol section number. */
468 coff_section_from_bfd_index (bfd
*abfd
, int section_index
)
470 if (section_index
== N_ABS
)
471 return bfd_abs_section_ptr
;
472 if (section_index
== N_UNDEF
)
473 return bfd_und_section_ptr
;
474 if (section_index
== N_DEBUG
)
475 return bfd_abs_section_ptr
;
477 struct bfd_section
*answer
;
478 htab_t table
= coff_data (abfd
)->section_by_target_index
;
482 table
= htab_create (10, htab_hash_section_target_index
,
483 htab_eq_section_target_index
, NULL
);
485 return bfd_und_section_ptr
;
486 coff_data (abfd
)->section_by_target_index
= table
;
489 if (htab_elements (table
) == 0)
491 for (answer
= abfd
->sections
; answer
; answer
= answer
->next
)
493 void **slot
= htab_find_slot (table
, answer
, INSERT
);
495 return bfd_und_section_ptr
;
500 struct bfd_section needle
;
501 needle
.target_index
= section_index
;
503 answer
= htab_find (table
, &needle
);
507 /* Cover the unlikely case of sections added after the first call to
509 for (answer
= abfd
->sections
; answer
; answer
= answer
->next
)
510 if (answer
->target_index
== section_index
)
512 void **slot
= htab_find_slot (table
, answer
, INSERT
);
518 /* We should not reach this point, but the SCO 3.2v4 /lib/libc_s.a
519 has a bad symbol table in biglitpow.o. */
520 return bfd_und_section_ptr
;
523 /* Get the upper bound of a COFF symbol table. */
526 coff_get_symtab_upper_bound (bfd
*abfd
)
528 if (!bfd_coff_slurp_symbol_table (abfd
))
531 return (bfd_get_symcount (abfd
) + 1) * (sizeof (coff_symbol_type
*));
534 /* Canonicalize a COFF symbol table. */
537 coff_canonicalize_symtab (bfd
*abfd
, asymbol
**alocation
)
539 unsigned int counter
;
540 coff_symbol_type
*symbase
;
541 coff_symbol_type
**location
= (coff_symbol_type
**) alocation
;
543 if (!bfd_coff_slurp_symbol_table (abfd
))
546 symbase
= obj_symbols (abfd
);
547 counter
= bfd_get_symcount (abfd
);
548 while (counter
-- > 0)
549 *location
++ = symbase
++;
553 return bfd_get_symcount (abfd
);
556 /* Get the name of a symbol. The caller must pass in a buffer of size
560 _bfd_coff_internal_syment_name (bfd
*abfd
,
561 const struct internal_syment
*sym
,
564 /* FIXME: It's not clear this will work correctly if sizeof
566 if (sym
->_n
._n_n
._n_zeroes
!= 0
567 || sym
->_n
._n_n
._n_offset
== 0)
569 memcpy (buf
, sym
->_n
._n_name
, SYMNMLEN
);
570 buf
[SYMNMLEN
] = '\0';
577 BFD_ASSERT (sym
->_n
._n_n
._n_offset
>= STRING_SIZE_SIZE
);
578 strings
= obj_coff_strings (abfd
);
581 strings
= _bfd_coff_read_string_table (abfd
);
585 if (sym
->_n
._n_n
._n_offset
>= obj_coff_strings_len (abfd
))
587 return strings
+ sym
->_n
._n_n
._n_offset
;
591 /* Read in and swap the relocs. This returns a buffer holding the
592 relocs for section SEC in file ABFD. If CACHE is TRUE and
593 INTERNAL_RELOCS is NULL, the relocs read in will be saved in case
594 the function is called again. If EXTERNAL_RELOCS is not NULL, it
595 is a buffer large enough to hold the unswapped relocs. If
596 INTERNAL_RELOCS is not NULL, it is a buffer large enough to hold
597 the swapped relocs. If REQUIRE_INTERNAL is TRUE, then the return
598 value must be INTERNAL_RELOCS. The function returns NULL on error. */
600 struct internal_reloc
*
601 _bfd_coff_read_internal_relocs (bfd
*abfd
,
604 bfd_byte
*external_relocs
,
605 bool require_internal
,
606 struct internal_reloc
*internal_relocs
)
609 bfd_byte
*free_external
= NULL
;
610 struct internal_reloc
*free_internal
= NULL
;
613 struct internal_reloc
*irel
;
616 if (sec
->reloc_count
== 0)
617 return internal_relocs
; /* Nothing to do. */
619 if (coff_section_data (abfd
, sec
) != NULL
620 && coff_section_data (abfd
, sec
)->relocs
!= NULL
)
622 if (! require_internal
)
623 return coff_section_data (abfd
, sec
)->relocs
;
624 memcpy (internal_relocs
, coff_section_data (abfd
, sec
)->relocs
,
625 sec
->reloc_count
* sizeof (struct internal_reloc
));
626 return internal_relocs
;
629 relsz
= bfd_coff_relsz (abfd
);
631 amt
= sec
->reloc_count
* relsz
;
632 if (external_relocs
== NULL
)
634 free_external
= (bfd_byte
*) bfd_malloc (amt
);
635 if (free_external
== NULL
)
637 external_relocs
= free_external
;
640 if (bfd_seek (abfd
, sec
->rel_filepos
, SEEK_SET
) != 0
641 || bfd_bread (external_relocs
, amt
, abfd
) != amt
)
644 if (internal_relocs
== NULL
)
646 amt
= sec
->reloc_count
;
647 amt
*= sizeof (struct internal_reloc
);
648 free_internal
= (struct internal_reloc
*) bfd_malloc (amt
);
649 if (free_internal
== NULL
)
651 internal_relocs
= free_internal
;
654 /* Swap in the relocs. */
655 erel
= external_relocs
;
656 erel_end
= erel
+ relsz
* sec
->reloc_count
;
657 irel
= internal_relocs
;
658 for (; erel
< erel_end
; erel
+= relsz
, irel
++)
659 bfd_coff_swap_reloc_in (abfd
, (void *) erel
, (void *) irel
);
661 free (free_external
);
662 free_external
= NULL
;
664 if (cache
&& free_internal
!= NULL
)
666 if (coff_section_data (abfd
, sec
) == NULL
)
668 amt
= sizeof (struct coff_section_tdata
);
669 sec
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
670 if (sec
->used_by_bfd
== NULL
)
672 coff_section_data (abfd
, sec
)->contents
= NULL
;
674 coff_section_data (abfd
, sec
)->relocs
= free_internal
;
677 return internal_relocs
;
680 free (free_external
);
681 free (free_internal
);
685 /* Set lineno_count for the output sections of a COFF file. */
688 coff_count_linenumbers (bfd
*abfd
)
690 unsigned int limit
= bfd_get_symcount (abfd
);
698 /* This may be from the backend linker, in which case the
699 lineno_count in the sections is correct. */
700 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
701 total
+= s
->lineno_count
;
705 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
706 BFD_ASSERT (s
->lineno_count
== 0);
708 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
710 asymbol
*q_maybe
= *p
;
712 if (bfd_asymbol_bfd (q_maybe
) != NULL
713 && bfd_family_coff (bfd_asymbol_bfd (q_maybe
)))
715 coff_symbol_type
*q
= coffsymbol (q_maybe
);
717 /* The AIX 4.1 compiler can sometimes generate line numbers
718 attached to debugging symbols. We try to simply ignore
720 if (q
->lineno
!= NULL
721 && q
->symbol
.section
->owner
!= NULL
)
723 /* This symbol has line numbers. Increment the owning
724 section's linenumber count. */
725 alent
*l
= q
->lineno
;
729 asection
* sec
= q
->symbol
.section
->output_section
;
731 /* Do not try to update fields in read-only sections. */
732 if (! bfd_is_const_section (sec
))
733 sec
->lineno_count
++;
738 while (l
->line_number
!= 0);
747 fixup_symbol_value (bfd
*abfd
,
748 coff_symbol_type
*coff_symbol_ptr
,
749 struct internal_syment
*syment
)
751 /* Normalize the symbol flags. */
752 if (coff_symbol_ptr
->symbol
.section
753 && bfd_is_com_section (coff_symbol_ptr
->symbol
.section
))
755 /* A common symbol is undefined with a value. */
756 syment
->n_scnum
= N_UNDEF
;
757 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
759 else if ((coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
) != 0
760 && (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING_RELOC
) == 0)
762 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
764 else if (bfd_is_und_section (coff_symbol_ptr
->symbol
.section
))
766 syment
->n_scnum
= N_UNDEF
;
769 /* FIXME: Do we need to handle the absolute section here? */
772 if (coff_symbol_ptr
->symbol
.section
)
775 coff_symbol_ptr
->symbol
.section
->output_section
->target_index
;
777 syment
->n_value
= (coff_symbol_ptr
->symbol
.value
778 + coff_symbol_ptr
->symbol
.section
->output_offset
);
781 syment
->n_value
+= (syment
->n_sclass
== C_STATLAB
)
782 ? coff_symbol_ptr
->symbol
.section
->output_section
->lma
783 : coff_symbol_ptr
->symbol
.section
->output_section
->vma
;
789 /* This can happen, but I don't know why yet (steve@cygnus.com) */
790 syment
->n_scnum
= N_ABS
;
791 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
796 /* Run through all the symbols in the symbol table and work out what
797 their indexes into the symbol table will be when output.
799 Coff requires that each C_FILE symbol points to the next one in the
800 chain, and that the last one points to the first external symbol. We
804 coff_renumber_symbols (bfd
*bfd_ptr
, int *first_undef
)
806 unsigned int symbol_count
= bfd_get_symcount (bfd_ptr
);
807 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
808 unsigned int native_index
= 0;
809 struct internal_syment
*last_file
= NULL
;
810 unsigned int symbol_index
;
812 /* COFF demands that undefined symbols come after all other symbols.
813 Since we don't need to impose this extra knowledge on all our
814 client programs, deal with that here. Sort the symbol table;
815 just move the undefined symbols to the end, leaving the rest
816 alone. The O'Reilly book says that defined global symbols come
817 at the end before the undefined symbols, so we do that here as
819 /* @@ Do we have some condition we could test for, so we don't always
820 have to do this? I don't think relocatability is quite right, but
821 I'm not certain. [raeburn:19920508.1711EST] */
827 amt
= sizeof (asymbol
*) * ((bfd_size_type
) symbol_count
+ 1);
828 newsyms
= (asymbol
**) bfd_alloc (bfd_ptr
, amt
);
831 bfd_ptr
->outsymbols
= newsyms
;
832 for (i
= 0; i
< symbol_count
; i
++)
833 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) != 0
834 || (!bfd_is_und_section (symbol_ptr_ptr
[i
]->section
)
835 && !bfd_is_com_section (symbol_ptr_ptr
[i
]->section
)
836 && ((symbol_ptr_ptr
[i
]->flags
& BSF_FUNCTION
) != 0
837 || ((symbol_ptr_ptr
[i
]->flags
& (BSF_GLOBAL
| BSF_WEAK
))
839 *newsyms
++ = symbol_ptr_ptr
[i
];
841 for (i
= 0; i
< symbol_count
; i
++)
842 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) == 0
843 && !bfd_is_und_section (symbol_ptr_ptr
[i
]->section
)
844 && (bfd_is_com_section (symbol_ptr_ptr
[i
]->section
)
845 || ((symbol_ptr_ptr
[i
]->flags
& BSF_FUNCTION
) == 0
846 && ((symbol_ptr_ptr
[i
]->flags
& (BSF_GLOBAL
| BSF_WEAK
))
848 *newsyms
++ = symbol_ptr_ptr
[i
];
850 *first_undef
= newsyms
- bfd_ptr
->outsymbols
;
852 for (i
= 0; i
< symbol_count
; i
++)
853 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) == 0
854 && bfd_is_und_section (symbol_ptr_ptr
[i
]->section
))
855 *newsyms
++ = symbol_ptr_ptr
[i
];
856 *newsyms
= (asymbol
*) NULL
;
857 symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
860 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
862 coff_symbol_type
*coff_symbol_ptr
;
864 coff_symbol_ptr
= coff_symbol_from (symbol_ptr_ptr
[symbol_index
]);
865 symbol_ptr_ptr
[symbol_index
]->udata
.i
= symbol_index
;
866 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
)
868 combined_entry_type
*s
= coff_symbol_ptr
->native
;
871 BFD_ASSERT (s
->is_sym
);
872 if (s
->u
.syment
.n_sclass
== C_FILE
)
874 if (last_file
!= NULL
)
875 last_file
->n_value
= native_index
;
876 last_file
= &(s
->u
.syment
);
879 /* Modify the symbol values according to their section and
881 fixup_symbol_value (bfd_ptr
, coff_symbol_ptr
, &(s
->u
.syment
));
883 for (i
= 0; i
< s
->u
.syment
.n_numaux
+ 1; i
++)
884 s
[i
].offset
= native_index
++;
890 obj_conv_table_size (bfd_ptr
) = native_index
;
895 /* Run thorough the symbol table again, and fix it so that all
896 pointers to entries are changed to the entries' index in the output
900 coff_mangle_symbols (bfd
*bfd_ptr
)
902 unsigned int symbol_count
= bfd_get_symcount (bfd_ptr
);
903 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
904 unsigned int symbol_index
;
906 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
908 coff_symbol_type
*coff_symbol_ptr
;
910 coff_symbol_ptr
= coff_symbol_from (symbol_ptr_ptr
[symbol_index
]);
911 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
)
914 combined_entry_type
*s
= coff_symbol_ptr
->native
;
916 BFD_ASSERT (s
->is_sym
);
919 /* FIXME: We should use a union here. */
920 s
->u
.syment
.n_value
=
921 (uintptr_t) ((combined_entry_type
*)
922 (uintptr_t) s
->u
.syment
.n_value
)->offset
;
927 /* The value is the offset into the line number entries
928 for the symbol's section. On output, the symbol's
929 section should be N_DEBUG. */
930 s
->u
.syment
.n_value
=
931 (coff_symbol_ptr
->symbol
.section
->output_section
->line_filepos
932 + s
->u
.syment
.n_value
* bfd_coff_linesz (bfd_ptr
));
933 coff_symbol_ptr
->symbol
.section
=
934 coff_section_from_bfd_index (bfd_ptr
, N_DEBUG
);
935 BFD_ASSERT (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
);
937 for (i
= 0; i
< s
->u
.syment
.n_numaux
; i
++)
939 combined_entry_type
*a
= s
+ i
+ 1;
941 BFD_ASSERT (! a
->is_sym
);
944 a
->u
.auxent
.x_sym
.x_tagndx
.u32
=
945 a
->u
.auxent
.x_sym
.x_tagndx
.p
->offset
;
950 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.u32
=
951 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
->offset
;
956 a
->u
.auxent
.x_csect
.x_scnlen
.u64
=
957 a
->u
.auxent
.x_csect
.x_scnlen
.p
->offset
;
966 coff_write_auxent_fname (bfd
*abfd
,
968 union internal_auxent
*auxent
,
969 struct bfd_strtab_hash
*strtab
,
972 unsigned int str_length
= strlen (str
);
973 unsigned int filnmlen
= bfd_coff_filnmlen (abfd
);
975 if (bfd_coff_long_filenames (abfd
))
977 if (str_length
<= filnmlen
)
978 strncpy (auxent
->x_file
.x_n
.x_fname
, str
, filnmlen
);
981 bfd_size_type indx
= _bfd_stringtab_add (strtab
, str
, hash
, false);
983 if (indx
== (bfd_size_type
) -1)
986 auxent
->x_file
.x_n
.x_n
.x_offset
= STRING_SIZE_SIZE
+ indx
;
987 auxent
->x_file
.x_n
.x_n
.x_zeroes
= 0;
992 strncpy (auxent
->x_file
.x_n
.x_fname
, str
, filnmlen
);
993 if (str_length
> filnmlen
)
994 str
[filnmlen
] = '\0';
1001 coff_fix_symbol_name (bfd
*abfd
,
1003 combined_entry_type
*native
,
1004 struct bfd_strtab_hash
*strtab
,
1006 asection
**debug_string_section_p
,
1007 bfd_size_type
*debug_string_size_p
)
1009 unsigned int name_length
;
1010 char *name
= (char *) (symbol
->name
);
1015 /* COFF symbols always have names, so we'll make one up. */
1016 symbol
->name
= "strange";
1017 name
= (char *) symbol
->name
;
1019 name_length
= strlen (name
);
1021 BFD_ASSERT (native
->is_sym
);
1022 if (native
->u
.syment
.n_sclass
== C_FILE
1023 && native
->u
.syment
.n_numaux
> 0)
1025 if (bfd_coff_force_symnames_in_strings (abfd
))
1027 indx
= _bfd_stringtab_add (strtab
, ".file", hash
, false);
1028 if (indx
== (bfd_size_type
) -1)
1031 native
->u
.syment
._n
._n_n
._n_offset
= STRING_SIZE_SIZE
+ indx
;
1032 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1035 strncpy (native
->u
.syment
._n
._n_name
, ".file", SYMNMLEN
);
1037 BFD_ASSERT (! (native
+ 1)->is_sym
);
1038 if (!coff_write_auxent_fname (abfd
, name
, &(native
+ 1)->u
.auxent
,
1044 if (name_length
<= SYMNMLEN
&& !bfd_coff_force_symnames_in_strings (abfd
))
1045 /* This name will fit into the symbol neatly. */
1046 strncpy (native
->u
.syment
._n
._n_name
, symbol
->name
, SYMNMLEN
);
1048 else if (!bfd_coff_symname_in_debug (abfd
, &native
->u
.syment
))
1050 indx
= _bfd_stringtab_add (strtab
, name
, hash
, false);
1051 if (indx
== (bfd_size_type
) -1)
1054 native
->u
.syment
._n
._n_n
._n_offset
= STRING_SIZE_SIZE
+ indx
;
1055 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1061 int prefix_len
= bfd_coff_debug_string_prefix_length (abfd
);
1063 /* This name should be written into the .debug section. For
1064 some reason each name is preceded by a two byte length
1065 and also followed by a null byte. FIXME: We assume that
1066 the .debug section has already been created, and that it
1068 if (*debug_string_section_p
== (asection
*) NULL
)
1069 *debug_string_section_p
= bfd_get_section_by_name (abfd
, ".debug");
1070 filepos
= bfd_tell (abfd
);
1071 if (prefix_len
== 4)
1072 bfd_put_32 (abfd
, (bfd_vma
) (name_length
+ 1), buf
);
1074 bfd_put_16 (abfd
, (bfd_vma
) (name_length
+ 1), buf
);
1076 if (!bfd_set_section_contents (abfd
,
1077 *debug_string_section_p
,
1079 (file_ptr
) *debug_string_size_p
,
1080 (bfd_size_type
) prefix_len
)
1081 || !bfd_set_section_contents (abfd
,
1082 *debug_string_section_p
,
1083 (void *) symbol
->name
,
1084 (file_ptr
) (*debug_string_size_p
1086 (bfd_size_type
) name_length
+ 1))
1088 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
1090 native
->u
.syment
._n
._n_n
._n_offset
=
1091 *debug_string_size_p
+ prefix_len
;
1092 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1093 *debug_string_size_p
+= name_length
+ 1 + prefix_len
;
1100 /* We need to keep track of the symbol index so that when we write out
1101 the relocs we can get the index for a symbol. This method is a
1104 #define set_index(symbol, idx) ((symbol)->udata.i = (idx))
1106 /* Write a symbol out to a COFF file. */
1109 coff_write_symbol (bfd
*abfd
,
1111 combined_entry_type
*native
,
1113 struct bfd_strtab_hash
*strtab
,
1115 asection
**debug_string_section_p
,
1116 bfd_size_type
*debug_string_size_p
)
1118 unsigned int numaux
= native
->u
.syment
.n_numaux
;
1119 int type
= native
->u
.syment
.n_type
;
1120 int n_sclass
= (int) native
->u
.syment
.n_sclass
;
1121 asection
*output_section
= symbol
->section
->output_section
1122 ? symbol
->section
->output_section
1125 bfd_size_type symesz
;
1127 BFD_ASSERT (native
->is_sym
);
1129 if (native
->u
.syment
.n_sclass
== C_FILE
)
1130 symbol
->flags
|= BSF_DEBUGGING
;
1132 if (symbol
->flags
& BSF_DEBUGGING
1133 && bfd_is_abs_section (symbol
->section
))
1134 native
->u
.syment
.n_scnum
= N_DEBUG
;
1136 else if (bfd_is_abs_section (symbol
->section
))
1137 native
->u
.syment
.n_scnum
= N_ABS
;
1139 else if (bfd_is_und_section (symbol
->section
))
1140 native
->u
.syment
.n_scnum
= N_UNDEF
;
1143 native
->u
.syment
.n_scnum
=
1144 output_section
->target_index
;
1146 if (!coff_fix_symbol_name (abfd
, symbol
, native
, strtab
, hash
,
1147 debug_string_section_p
, debug_string_size_p
))
1150 symesz
= bfd_coff_symesz (abfd
);
1151 buf
= bfd_alloc (abfd
, symesz
);
1154 bfd_coff_swap_sym_out (abfd
, &native
->u
.syment
, buf
);
1155 if (bfd_bwrite (buf
, symesz
, abfd
) != symesz
)
1157 bfd_release (abfd
, buf
);
1159 if (native
->u
.syment
.n_numaux
> 0)
1161 bfd_size_type auxesz
;
1164 auxesz
= bfd_coff_auxesz (abfd
);
1165 buf
= bfd_alloc (abfd
, auxesz
);
1168 for (j
= 0; j
< native
->u
.syment
.n_numaux
; j
++)
1170 BFD_ASSERT (! (native
+ j
+ 1)->is_sym
);
1172 /* Adjust auxent only if this isn't the filename
1174 if (native
->u
.syment
.n_sclass
== C_FILE
1175 && (native
+ j
+ 1)->u
.auxent
.x_file
.x_ftype
1176 && (native
+ j
+ 1)->extrap
)
1177 coff_write_auxent_fname (abfd
, (char *) (native
+ j
+ 1)->extrap
,
1178 &(native
+ j
+ 1)->u
.auxent
, strtab
, hash
);
1180 bfd_coff_swap_aux_out (abfd
,
1181 &((native
+ j
+ 1)->u
.auxent
),
1182 type
, n_sclass
, (int) j
,
1183 native
->u
.syment
.n_numaux
,
1185 if (bfd_bwrite (buf
, auxesz
, abfd
) != auxesz
)
1188 bfd_release (abfd
, buf
);
1191 /* Store the index for use when we write out the relocs. */
1192 set_index (symbol
, *written
);
1194 *written
+= numaux
+ 1;
1198 /* Write out a symbol to a COFF file that does not come from a COFF
1199 file originally. This symbol may have been created by the linker,
1200 or we may be linking a non COFF file to a COFF file. */
1203 coff_write_alien_symbol (bfd
*abfd
,
1205 struct internal_syment
*isym
,
1207 struct bfd_strtab_hash
*strtab
,
1209 asection
**debug_string_section_p
,
1210 bfd_size_type
*debug_string_size_p
)
1212 combined_entry_type
*native
;
1213 combined_entry_type dummy
[2];
1214 asection
*output_section
= symbol
->section
->output_section
1215 ? symbol
->section
->output_section
1217 struct bfd_link_info
*link_info
= coff_data (abfd
)->link_info
;
1220 if ((!link_info
|| link_info
->strip_discarded
)
1221 && !bfd_is_abs_section (symbol
->section
)
1222 && symbol
->section
->output_section
== bfd_abs_section_ptr
)
1226 memset (isym
, 0, sizeof (*isym
));
1229 memset (dummy
, 0, sizeof dummy
);
1231 native
->is_sym
= true;
1232 native
[1].is_sym
= false;
1233 native
->u
.syment
.n_type
= T_NULL
;
1234 native
->u
.syment
.n_flags
= 0;
1235 native
->u
.syment
.n_numaux
= 0;
1236 if (bfd_is_und_section (symbol
->section
))
1238 native
->u
.syment
.n_scnum
= N_UNDEF
;
1239 native
->u
.syment
.n_value
= symbol
->value
;
1241 else if (bfd_is_com_section (symbol
->section
))
1243 native
->u
.syment
.n_scnum
= N_UNDEF
;
1244 native
->u
.syment
.n_value
= symbol
->value
;
1246 else if (symbol
->flags
& BSF_FILE
)
1248 native
->u
.syment
.n_scnum
= N_DEBUG
;
1249 native
->u
.syment
.n_numaux
= 1;
1251 else if (symbol
->flags
& BSF_DEBUGGING
)
1253 /* There isn't much point to writing out a debugging symbol
1254 unless we are prepared to convert it into COFF debugging
1255 format. So, we just ignore them. We must clobber the symbol
1256 name to keep it from being put in the string table. */
1259 memset (isym
, 0, sizeof (*isym
));
1264 native
->u
.syment
.n_scnum
= output_section
->target_index
;
1265 native
->u
.syment
.n_value
= (symbol
->value
1266 + symbol
->section
->output_offset
);
1267 if (! obj_pe (abfd
))
1268 native
->u
.syment
.n_value
+= output_section
->vma
;
1270 /* Copy the any flags from the file header into the symbol.
1273 coff_symbol_type
*c
= coff_symbol_from (symbol
);
1274 if (c
!= (coff_symbol_type
*) NULL
)
1275 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (&c
->symbol
)->flags
;
1279 native
->u
.syment
.n_type
= 0;
1280 if (symbol
->flags
& BSF_FILE
)
1281 native
->u
.syment
.n_sclass
= C_FILE
;
1282 else if (symbol
->flags
& BSF_LOCAL
)
1283 native
->u
.syment
.n_sclass
= C_STAT
;
1284 else if (symbol
->flags
& BSF_WEAK
)
1285 native
->u
.syment
.n_sclass
= obj_pe (abfd
) ? C_NT_WEAK
: C_WEAKEXT
;
1287 native
->u
.syment
.n_sclass
= C_EXT
;
1289 ret
= coff_write_symbol (abfd
, symbol
, native
, written
, strtab
, hash
,
1290 debug_string_section_p
, debug_string_size_p
);
1292 *isym
= native
->u
.syment
;
1296 /* Write a native symbol to a COFF file. */
1299 coff_write_native_symbol (bfd
*abfd
,
1300 coff_symbol_type
*symbol
,
1302 struct bfd_strtab_hash
*strtab
,
1303 asection
**debug_string_section_p
,
1304 bfd_size_type
*debug_string_size_p
)
1306 combined_entry_type
*native
= symbol
->native
;
1307 alent
*lineno
= symbol
->lineno
;
1308 struct bfd_link_info
*link_info
= coff_data (abfd
)->link_info
;
1310 if ((!link_info
|| link_info
->strip_discarded
)
1311 && !bfd_is_abs_section (symbol
->symbol
.section
)
1312 && symbol
->symbol
.section
->output_section
== bfd_abs_section_ptr
)
1314 symbol
->symbol
.name
= "";
1318 BFD_ASSERT (native
->is_sym
);
1319 /* If this symbol has an associated line number, we must store the
1320 symbol index in the line number field. We also tag the auxent to
1321 point to the right place in the lineno table. */
1322 if (lineno
&& !symbol
->done_lineno
&& symbol
->symbol
.section
->owner
!= NULL
)
1324 unsigned int count
= 0;
1326 lineno
[count
].u
.offset
= *written
;
1327 if (native
->u
.syment
.n_numaux
)
1329 union internal_auxent
*a
= &((native
+ 1)->u
.auxent
);
1331 a
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1332 symbol
->symbol
.section
->output_section
->moving_line_filepos
;
1335 /* Count and relocate all other linenumbers. */
1337 while (lineno
[count
].line_number
!= 0)
1339 lineno
[count
].u
.offset
+=
1340 (symbol
->symbol
.section
->output_section
->vma
1341 + symbol
->symbol
.section
->output_offset
);
1344 symbol
->done_lineno
= true;
1346 if (! bfd_is_const_section (symbol
->symbol
.section
->output_section
))
1347 symbol
->symbol
.section
->output_section
->moving_line_filepos
+=
1348 count
* bfd_coff_linesz (abfd
);
1351 return coff_write_symbol (abfd
, &(symbol
->symbol
), native
, written
,
1352 strtab
, true, debug_string_section_p
,
1353 debug_string_size_p
);
1357 null_error_handler (const char *fmt ATTRIBUTE_UNUSED
,
1358 va_list ap ATTRIBUTE_UNUSED
)
1362 /* Write out the COFF symbols. */
1365 coff_write_symbols (bfd
*abfd
)
1367 struct bfd_strtab_hash
*strtab
;
1368 asection
*debug_string_section
;
1369 bfd_size_type debug_string_size
;
1371 unsigned int limit
= bfd_get_symcount (abfd
);
1372 bfd_vma written
= 0;
1375 debug_string_section
= NULL
;
1376 debug_string_size
= 0;
1378 strtab
= _bfd_stringtab_init ();
1382 /* If this target supports long section names, they must be put into
1383 the string table. This is supported by PE. This code must
1384 handle section names just as they are handled in
1385 coff_write_object_contents. This is why we pass hash as FALSE below. */
1386 if (bfd_coff_long_section_names (abfd
))
1390 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1391 if (strlen (o
->name
) > SCNNMLEN
1392 && _bfd_stringtab_add (strtab
, o
->name
, false, false)
1393 == (bfd_size_type
) -1)
1397 /* Seek to the right place. */
1398 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
1401 /* Output all the symbols we have. */
1403 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1405 asymbol
*symbol
= *p
;
1406 coff_symbol_type
*c_symbol
= coff_symbol_from (symbol
);
1408 if (c_symbol
== (coff_symbol_type
*) NULL
1409 || c_symbol
->native
== (combined_entry_type
*) NULL
)
1411 if (!coff_write_alien_symbol (abfd
, symbol
, NULL
, &written
,
1412 strtab
, true, &debug_string_section
,
1413 &debug_string_size
))
1418 if (coff_backend_info (abfd
)->_bfd_coff_classify_symbol
!= NULL
)
1420 bfd_error_handler_type current_error_handler
;
1421 enum coff_symbol_classification sym_class
;
1422 unsigned char *n_sclass
;
1424 /* Suppress error reporting by bfd_coff_classify_symbol.
1425 Error messages can be generated when we are processing a local
1426 symbol which has no associated section and we do not have to
1427 worry about this, all we need to know is that it is local. */
1428 current_error_handler
= bfd_set_error_handler (null_error_handler
);
1429 BFD_ASSERT (c_symbol
->native
->is_sym
);
1430 sym_class
= bfd_coff_classify_symbol (abfd
,
1431 &c_symbol
->native
->u
.syment
);
1432 (void) bfd_set_error_handler (current_error_handler
);
1434 n_sclass
= &c_symbol
->native
->u
.syment
.n_sclass
;
1436 /* If the symbol class has been changed (eg objcopy/ld script/etc)
1437 we cannot retain the existing sclass from the original symbol.
1438 Weak symbols only have one valid sclass, so just set it always.
1439 If it is not local class and should be, set it C_STAT.
1440 If it is global and not classified as global, or if it is
1441 weak (which is also classified as global), set it C_EXT. */
1443 if (symbol
->flags
& BSF_WEAK
)
1444 *n_sclass
= obj_pe (abfd
) ? C_NT_WEAK
: C_WEAKEXT
;
1445 else if (symbol
->flags
& BSF_LOCAL
&& sym_class
!= COFF_SYMBOL_LOCAL
)
1447 else if (symbol
->flags
& BSF_GLOBAL
1448 && (sym_class
!= COFF_SYMBOL_GLOBAL
1450 || *n_sclass
== C_NT_WEAK
1452 || *n_sclass
== C_WEAKEXT
))
1453 c_symbol
->native
->u
.syment
.n_sclass
= C_EXT
;
1456 if (!coff_write_native_symbol (abfd
, c_symbol
, &written
,
1457 strtab
, &debug_string_section
,
1458 &debug_string_size
))
1463 obj_raw_syment_count (abfd
) = written
;
1465 /* Now write out strings.
1467 We would normally not write anything here if there are no strings, but
1468 we'll write out 4 so that any stupid coff reader which tries to read the
1469 string table even when there isn't one won't croak. */
1471 bfd_byte buffer
[STRING_SIZE_SIZE
];
1473 #if STRING_SIZE_SIZE == 4
1474 H_PUT_32 (abfd
, _bfd_stringtab_size (strtab
) + STRING_SIZE_SIZE
, buffer
);
1476 #error Change H_PUT_32
1478 if (bfd_bwrite ((void *) buffer
, (bfd_size_type
) sizeof (buffer
), abfd
)
1482 if (! _bfd_stringtab_emit (abfd
, strtab
))
1486 _bfd_stringtab_free (strtab
);
1488 /* Make sure the .debug section was created to be the correct size.
1489 We should create it ourselves on the fly, but we don't because
1490 BFD won't let us write to any section until we know how large all
1491 the sections are. We could still do it by making another pass
1492 over the symbols. FIXME. */
1493 BFD_ASSERT (debug_string_size
== 0
1494 || (debug_string_section
!= (asection
*) NULL
1495 && (BFD_ALIGN (debug_string_size
,
1496 1 << debug_string_section
->alignment_power
)
1497 == debug_string_section
->size
)));
1503 coff_write_linenumbers (bfd
*abfd
)
1506 bfd_size_type linesz
;
1509 linesz
= bfd_coff_linesz (abfd
);
1510 buff
= bfd_alloc (abfd
, linesz
);
1513 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
1515 if (s
->lineno_count
)
1517 asymbol
**q
= abfd
->outsymbols
;
1518 if (bfd_seek (abfd
, s
->line_filepos
, SEEK_SET
) != 0)
1520 /* Find all the linenumbers in this section. */
1524 if (p
->section
->output_section
== s
)
1527 BFD_SEND (bfd_asymbol_bfd (p
), _get_lineno
,
1528 (bfd_asymbol_bfd (p
), p
));
1531 /* Found a linenumber entry, output. */
1532 struct internal_lineno out
;
1534 memset ((void *) & out
, 0, sizeof (out
));
1536 out
.l_addr
.l_symndx
= l
->u
.offset
;
1537 bfd_coff_swap_lineno_out (abfd
, &out
, buff
);
1538 if (bfd_bwrite (buff
, (bfd_size_type
) linesz
, abfd
)
1542 while (l
->line_number
)
1544 out
.l_lnno
= l
->line_number
;
1545 out
.l_addr
.l_symndx
= l
->u
.offset
;
1546 bfd_coff_swap_lineno_out (abfd
, &out
, buff
);
1547 if (bfd_bwrite (buff
, (bfd_size_type
) linesz
, abfd
)
1558 bfd_release (abfd
, buff
);
1563 coff_get_lineno (bfd
*ignore_abfd ATTRIBUTE_UNUSED
, asymbol
*symbol
)
1565 return coffsymbol (symbol
)->lineno
;
1568 /* This function transforms the offsets into the symbol table into
1569 pointers to syments. */
1572 coff_pointerize_aux (bfd
*abfd
,
1573 combined_entry_type
*table_base
,
1574 combined_entry_type
*symbol
,
1575 unsigned int indaux
,
1576 combined_entry_type
*auxent
)
1578 unsigned int type
= symbol
->u
.syment
.n_type
;
1579 unsigned int n_sclass
= symbol
->u
.syment
.n_sclass
;
1581 BFD_ASSERT (symbol
->is_sym
);
1582 if (coff_backend_info (abfd
)->_bfd_coff_pointerize_aux_hook
)
1584 if ((*coff_backend_info (abfd
)->_bfd_coff_pointerize_aux_hook
)
1585 (abfd
, table_base
, symbol
, indaux
, auxent
))
1589 /* Don't bother if this is a file or a section. */
1590 if (n_sclass
== C_STAT
&& type
== T_NULL
)
1592 if (n_sclass
== C_FILE
)
1594 if (n_sclass
== C_DWARF
)
1597 BFD_ASSERT (! auxent
->is_sym
);
1598 /* Otherwise patch up. */
1599 #define N_TMASK coff_data (abfd)->local_n_tmask
1600 #define N_BTSHFT coff_data (abfd)->local_n_btshft
1602 if ((ISFCN (type
) || ISTAG (n_sclass
) || n_sclass
== C_BLOCK
1603 || n_sclass
== C_FCN
)
1604 && auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.u32
> 0
1605 && (auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.u32
1606 < obj_raw_syment_count (abfd
)))
1608 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
=
1609 table_base
+ auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.u32
;
1610 auxent
->fix_end
= 1;
1613 /* A negative tagndx is meaningless, but the SCO 3.2v4 cc can
1614 generate one, so we must be careful to ignore it. */
1615 if (auxent
->u
.auxent
.x_sym
.x_tagndx
.u32
< obj_raw_syment_count (abfd
))
1617 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
=
1618 table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.u32
;
1619 auxent
->fix_tag
= 1;
1623 /* Allocate space for the ".debug" section, and read it.
1624 We did not read the debug section until now, because
1625 we didn't want to go to the trouble until someone needed it. */
1628 build_debug_section (bfd
*abfd
, asection
** sect_return
)
1630 char *debug_section
;
1632 bfd_size_type sec_size
;
1634 asection
*sect
= bfd_get_section_by_name (abfd
, ".debug");
1638 bfd_set_error (bfd_error_no_debug_section
);
1642 /* Seek to the beginning of the `.debug' section and read it.
1643 Save the current position first; it is needed by our caller.
1644 Then read debug section and reset the file pointer. */
1646 position
= bfd_tell (abfd
);
1647 if (bfd_seek (abfd
, sect
->filepos
, SEEK_SET
) != 0)
1650 sec_size
= sect
->size
;
1651 debug_section
= (char *) _bfd_alloc_and_read (abfd
, sec_size
+ 1, sec_size
);
1652 if (debug_section
== NULL
)
1654 debug_section
[sec_size
] = 0;
1656 if (bfd_seek (abfd
, position
, SEEK_SET
) != 0)
1659 * sect_return
= sect
;
1660 return debug_section
;
1663 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
1664 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
1665 be \0-terminated. */
1668 copy_name (bfd
*abfd
, char *name
, size_t maxlen
)
1673 for (len
= 0; len
< maxlen
; ++len
)
1674 if (name
[len
] == '\0')
1677 if ((newname
= (char *) bfd_alloc (abfd
, (bfd_size_type
) len
+ 1)) == NULL
)
1680 strncpy (newname
, name
, len
);
1681 newname
[len
] = '\0';
1685 /* Read in the external symbols. */
1688 _bfd_coff_get_external_symbols (bfd
*abfd
)
1695 if (obj_coff_external_syms (abfd
) != NULL
)
1698 symesz
= bfd_coff_symesz (abfd
);
1699 if (_bfd_mul_overflow (obj_raw_syment_count (abfd
), symesz
, &size
))
1701 bfd_set_error (bfd_error_file_truncated
);
1708 filesize
= bfd_get_file_size (abfd
);
1710 && ((ufile_ptr
) obj_sym_filepos (abfd
) > filesize
1711 || size
> filesize
- obj_sym_filepos (abfd
)))
1713 bfd_set_error (bfd_error_file_truncated
);
1717 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
1719 syms
= _bfd_malloc_and_read (abfd
, size
, size
);
1720 obj_coff_external_syms (abfd
) = syms
;
1721 return syms
!= NULL
;
1724 /* Read in the external strings. The strings are not loaded until
1725 they are needed. This is because we have no simple way of
1726 detecting a missing string table in an archive. If the strings
1727 are loaded then the STRINGS and STRINGS_LEN fields in the
1728 coff_tdata structure will be set. */
1731 _bfd_coff_read_string_table (bfd
*abfd
)
1733 char extstrsize
[STRING_SIZE_SIZE
];
1734 bfd_size_type strsize
;
1741 if (obj_coff_strings (abfd
) != NULL
)
1742 return obj_coff_strings (abfd
);
1744 if (obj_sym_filepos (abfd
) == 0)
1746 bfd_set_error (bfd_error_no_symbols
);
1750 symesz
= bfd_coff_symesz (abfd
);
1751 pos
= obj_sym_filepos (abfd
);
1752 if (_bfd_mul_overflow (obj_raw_syment_count (abfd
), symesz
, &size
)
1753 || pos
+ size
< pos
)
1755 bfd_set_error (bfd_error_file_truncated
);
1759 if (bfd_seek (abfd
, pos
+ size
, SEEK_SET
) != 0)
1762 if (bfd_bread (extstrsize
, (bfd_size_type
) sizeof extstrsize
, abfd
)
1763 != sizeof extstrsize
)
1765 if (bfd_get_error () != bfd_error_file_truncated
)
1768 /* There is no string table. */
1769 strsize
= STRING_SIZE_SIZE
;
1773 #if STRING_SIZE_SIZE == 4
1774 strsize
= H_GET_32 (abfd
, extstrsize
);
1776 #error Change H_GET_32
1780 filesize
= bfd_get_file_size (abfd
);
1781 if (strsize
< STRING_SIZE_SIZE
1782 || (filesize
!= 0 && strsize
> filesize
))
1785 /* xgettext: c-format */
1786 (_("%pB: bad string table size %" PRIu64
), abfd
, (uint64_t) strsize
);
1787 bfd_set_error (bfd_error_bad_value
);
1791 strings
= (char *) bfd_malloc (strsize
+ 1);
1792 if (strings
== NULL
)
1795 /* PR 17521 file: 079-54929-0.004.
1796 A corrupt file could contain an index that points into the first
1797 STRING_SIZE_SIZE bytes of the string table, so make sure that
1799 memset (strings
, 0, STRING_SIZE_SIZE
);
1801 if (bfd_bread (strings
+ STRING_SIZE_SIZE
, strsize
- STRING_SIZE_SIZE
, abfd
)
1802 != strsize
- STRING_SIZE_SIZE
)
1808 obj_coff_strings (abfd
) = strings
;
1809 obj_coff_strings_len (abfd
) = strsize
;
1810 /* Terminate the string table, just in case. */
1811 strings
[strsize
] = 0;
1815 /* Free up the external symbols and strings read from a COFF file. */
1818 _bfd_coff_free_symbols (bfd
*abfd
)
1820 if (! bfd_family_coff (abfd
))
1823 if (obj_coff_external_syms (abfd
) != NULL
1824 && ! obj_coff_keep_syms (abfd
))
1826 free (obj_coff_external_syms (abfd
));
1827 obj_coff_external_syms (abfd
) = NULL
;
1830 if (obj_coff_strings (abfd
) != NULL
1831 && ! obj_coff_keep_strings (abfd
))
1833 free (obj_coff_strings (abfd
));
1834 obj_coff_strings (abfd
) = NULL
;
1835 obj_coff_strings_len (abfd
) = 0;
1841 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
1842 knit the symbol names into a normalized form. By normalized here I
1843 mean that all symbols have an n_offset pointer that points to a null-
1844 terminated string. */
1846 combined_entry_type
*
1847 coff_get_normalized_symtab (bfd
*abfd
)
1849 combined_entry_type
*internal
;
1850 combined_entry_type
*internal_ptr
;
1851 combined_entry_type
*symbol_ptr
;
1852 combined_entry_type
*internal_end
;
1856 const char *string_table
= NULL
;
1857 asection
* debug_sec
= NULL
;
1858 char *debug_sec_data
= NULL
;
1861 if (obj_raw_syments (abfd
) != NULL
)
1862 return obj_raw_syments (abfd
);
1864 if (! _bfd_coff_get_external_symbols (abfd
))
1867 size
= obj_raw_syment_count (abfd
);
1868 /* Check for integer overflow. */
1869 if (size
> (bfd_size_type
) -1 / sizeof (combined_entry_type
))
1871 size
*= sizeof (combined_entry_type
);
1872 internal
= (combined_entry_type
*) bfd_zalloc (abfd
, size
);
1873 if (internal
== NULL
&& size
!= 0)
1875 internal_end
= internal
+ obj_raw_syment_count (abfd
);
1877 raw_src
= (char *) obj_coff_external_syms (abfd
);
1879 /* Mark the end of the symbols. */
1880 symesz
= bfd_coff_symesz (abfd
);
1881 raw_end
= PTR_ADD (raw_src
, obj_raw_syment_count (abfd
) * symesz
);
1883 /* FIXME SOMEDAY. A string table size of zero is very weird, but
1884 probably possible. If one shows up, it will probably kill us. */
1886 /* Swap all the raw entries. */
1887 for (internal_ptr
= internal
;
1889 raw_src
+= symesz
, internal_ptr
++)
1893 bfd_coff_swap_sym_in (abfd
, (void *) raw_src
,
1894 (void *) & internal_ptr
->u
.syment
);
1895 symbol_ptr
= internal_ptr
;
1896 internal_ptr
->is_sym
= true;
1898 /* PR 17512: Prevent buffer overrun. */
1899 if (symbol_ptr
->u
.syment
.n_numaux
> ((raw_end
- 1) - raw_src
) / symesz
)
1903 i
< symbol_ptr
->u
.syment
.n_numaux
;
1909 bfd_coff_swap_aux_in (abfd
, (void *) raw_src
,
1910 symbol_ptr
->u
.syment
.n_type
,
1911 symbol_ptr
->u
.syment
.n_sclass
,
1912 (int) i
, symbol_ptr
->u
.syment
.n_numaux
,
1913 &(internal_ptr
->u
.auxent
));
1915 internal_ptr
->is_sym
= false;
1916 coff_pointerize_aux (abfd
, internal
, symbol_ptr
, i
, internal_ptr
);
1920 /* Free the raw symbols. */
1921 if (obj_coff_external_syms (abfd
) != NULL
1922 && ! obj_coff_keep_syms (abfd
))
1924 free (obj_coff_external_syms (abfd
));
1925 obj_coff_external_syms (abfd
) = NULL
;
1928 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
1931 BFD_ASSERT (internal_ptr
->is_sym
);
1933 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
1934 && internal_ptr
->u
.syment
.n_numaux
> 0)
1936 combined_entry_type
* aux
= internal_ptr
+ 1;
1938 /* Make a file symbol point to the name in the auxent, since
1939 the text ".file" is redundant. */
1940 BFD_ASSERT (! aux
->is_sym
);
1942 if (aux
->u
.auxent
.x_file
.x_n
.x_n
.x_zeroes
== 0)
1944 /* The filename is a long one, point into the string table. */
1945 if (string_table
== NULL
)
1947 string_table
= _bfd_coff_read_string_table (abfd
);
1948 if (string_table
== NULL
)
1952 if ((bfd_size_type
)(aux
->u
.auxent
.x_file
.x_n
.x_n
.x_offset
)
1953 >= obj_coff_strings_len (abfd
))
1954 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1955 (uintptr_t) _("<corrupt>");
1957 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1958 (uintptr_t) (string_table
1959 + aux
->u
.auxent
.x_file
.x_n
.x_n
.x_offset
);
1963 /* Ordinary short filename, put into memory anyway. The
1964 Microsoft PE tools sometimes store a filename in
1965 multiple AUX entries. */
1966 if (internal_ptr
->u
.syment
.n_numaux
> 1 && obj_pe (abfd
))
1967 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1970 aux
->u
.auxent
.x_file
.x_n
.x_fname
,
1971 internal_ptr
->u
.syment
.n_numaux
* symesz
));
1973 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1976 aux
->u
.auxent
.x_file
.x_n
.x_fname
,
1977 (size_t) bfd_coff_filnmlen (abfd
)));
1980 /* Normalize other strings available in C_FILE aux entries. */
1982 for (int numaux
= 1; numaux
< internal_ptr
->u
.syment
.n_numaux
; numaux
++)
1984 aux
= internal_ptr
+ numaux
+ 1;
1985 BFD_ASSERT (! aux
->is_sym
);
1987 if (aux
->u
.auxent
.x_file
.x_n
.x_n
.x_zeroes
== 0)
1989 /* The string information is a long one, point into the string table. */
1990 if (string_table
== NULL
)
1992 string_table
= _bfd_coff_read_string_table (abfd
);
1993 if (string_table
== NULL
)
1997 if ((bfd_size_type
)(aux
->u
.auxent
.x_file
.x_n
.x_n
.x_offset
)
1998 >= obj_coff_strings_len (abfd
))
1999 aux
->u
.auxent
.x_file
.x_n
.x_n
.x_offset
=
2000 (uintptr_t) _("<corrupt>");
2002 aux
->u
.auxent
.x_file
.x_n
.x_n
.x_offset
=
2003 (uintptr_t) (string_table
2004 + (aux
->u
.auxent
.x_file
.x_n
.x_n
.x_offset
));
2007 aux
->u
.auxent
.x_file
.x_n
.x_n
.x_offset
=
2010 aux
->u
.auxent
.x_file
.x_n
.x_fname
,
2011 (size_t) bfd_coff_filnmlen (abfd
)));
2017 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0)
2019 /* This is a "short" name. Make it long. */
2023 /* Find the length of this string without walking into memory
2025 for (i
= 0; i
< 8; ++i
)
2026 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0')
2029 newstring
= (char *) bfd_zalloc (abfd
, (bfd_size_type
) (i
+ 1));
2030 if (newstring
== NULL
)
2032 strncpy (newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
);
2033 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (uintptr_t) newstring
;
2034 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
2036 else if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
== 0)
2037 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (uintptr_t) "";
2038 else if (!bfd_coff_symname_in_debug (abfd
, &internal_ptr
->u
.syment
))
2040 /* Long name already. Point symbol at the string in the
2042 if (string_table
== NULL
)
2044 string_table
= _bfd_coff_read_string_table (abfd
);
2045 if (string_table
== NULL
)
2048 if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
>= obj_coff_strings_len (abfd
)
2049 || string_table
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
< string_table
)
2050 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
2051 (uintptr_t) _("<corrupt>");
2053 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
2054 ((uintptr_t) (string_table
2055 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
));
2059 /* Long name in debug section. Very similar. */
2060 if (debug_sec_data
== NULL
)
2061 debug_sec_data
= build_debug_section (abfd
, & debug_sec
);
2062 if (debug_sec_data
!= NULL
)
2064 BFD_ASSERT (debug_sec
!= NULL
);
2065 /* PR binutils/17512: Catch out of range offsets into the debug data. */
2066 if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
> debug_sec
->size
2067 || debug_sec_data
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
< debug_sec_data
)
2068 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
2069 (uintptr_t) _("<corrupt>");
2071 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
2072 (uintptr_t) (debug_sec_data
2073 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
2076 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (uintptr_t) "";
2079 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
2082 obj_raw_syments (abfd
) = internal
;
2083 BFD_ASSERT (obj_raw_syment_count (abfd
)
2084 == (unsigned int) (internal_ptr
- internal
));
2090 coff_get_reloc_upper_bound (bfd
*abfd
, sec_ptr asect
)
2094 count
= asect
->reloc_count
;
2095 if (count
>= LONG_MAX
/ sizeof (arelent
*)
2096 || _bfd_mul_overflow (count
, bfd_coff_relsz (abfd
), &raw
))
2098 bfd_set_error (bfd_error_file_too_big
);
2101 if (!bfd_write_p (abfd
))
2103 ufile_ptr filesize
= bfd_get_file_size (abfd
);
2104 if (filesize
!= 0 && raw
> filesize
)
2106 bfd_set_error (bfd_error_file_truncated
);
2110 return (count
+ 1) * sizeof (arelent
*);
2114 coff_make_empty_symbol (bfd
*abfd
)
2116 size_t amt
= sizeof (coff_symbol_type
);
2117 coff_symbol_type
*new_symbol
= (coff_symbol_type
*) bfd_zalloc (abfd
, amt
);
2119 if (new_symbol
== NULL
)
2121 new_symbol
->symbol
.section
= 0;
2122 new_symbol
->native
= NULL
;
2123 new_symbol
->lineno
= NULL
;
2124 new_symbol
->done_lineno
= false;
2125 new_symbol
->symbol
.the_bfd
= abfd
;
2127 return & new_symbol
->symbol
;
2130 /* Make a debugging symbol. */
2133 coff_bfd_make_debug_symbol (bfd
*abfd
)
2135 size_t amt
= sizeof (coff_symbol_type
);
2136 coff_symbol_type
*new_symbol
= (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
2138 if (new_symbol
== NULL
)
2140 /* @@ The 10 is a guess at a plausible maximum number of aux entries
2141 (but shouldn't be a constant). */
2142 amt
= sizeof (combined_entry_type
) * 10;
2143 new_symbol
->native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
2144 if (!new_symbol
->native
)
2146 new_symbol
->native
->is_sym
= true;
2147 new_symbol
->symbol
.section
= bfd_abs_section_ptr
;
2148 new_symbol
->symbol
.flags
= BSF_DEBUGGING
;
2149 new_symbol
->lineno
= NULL
;
2150 new_symbol
->done_lineno
= false;
2151 new_symbol
->symbol
.the_bfd
= abfd
;
2153 return & new_symbol
->symbol
;
2157 coff_get_symbol_info (bfd
*abfd
, asymbol
*symbol
, symbol_info
*ret
)
2159 bfd_symbol_info (symbol
, ret
);
2161 if (coffsymbol (symbol
)->native
!= NULL
2162 && coffsymbol (symbol
)->native
->fix_value
2163 && coffsymbol (symbol
)->native
->is_sym
)
2165 = (((uintptr_t) coffsymbol (symbol
)->native
->u
.syment
.n_value
2166 - (uintptr_t) obj_raw_syments (abfd
))
2167 / sizeof (combined_entry_type
));
2170 /* Print out information about COFF symbol. */
2173 coff_print_symbol (bfd
*abfd
,
2176 bfd_print_symbol_type how
)
2178 FILE * file
= (FILE *) filep
;
2182 case bfd_print_symbol_name
:
2183 fprintf (file
, "%s", symbol
->name
);
2186 case bfd_print_symbol_more
:
2187 fprintf (file
, "coff %s %s",
2188 coffsymbol (symbol
)->native
? "n" : "g",
2189 coffsymbol (symbol
)->lineno
? "l" : " ");
2192 case bfd_print_symbol_all
:
2193 if (coffsymbol (symbol
)->native
)
2197 combined_entry_type
*combined
= coffsymbol (symbol
)->native
;
2198 combined_entry_type
*root
= obj_raw_syments (abfd
);
2199 struct lineno_cache_entry
*l
= coffsymbol (symbol
)->lineno
;
2201 fprintf (file
, "[%3ld]", (long) (combined
- root
));
2203 /* PR 17512: file: 079-33786-0.001:0.1. */
2204 if (combined
< obj_raw_syments (abfd
)
2205 || combined
>= obj_raw_syments (abfd
) + obj_raw_syment_count (abfd
))
2207 fprintf (file
, _("<corrupt info> %s"), symbol
->name
);
2211 BFD_ASSERT (combined
->is_sym
);
2212 if (! combined
->fix_value
)
2213 val
= (bfd_vma
) combined
->u
.syment
.n_value
;
2215 val
= (((uintptr_t) combined
->u
.syment
.n_value
- (uintptr_t) root
)
2216 / sizeof (combined_entry_type
));
2218 fprintf (file
, "(sec %2d)(fl 0x%02x)(ty %4x)(scl %3d) (nx %d) 0x",
2219 combined
->u
.syment
.n_scnum
,
2220 combined
->u
.syment
.n_flags
,
2221 combined
->u
.syment
.n_type
,
2222 combined
->u
.syment
.n_sclass
,
2223 combined
->u
.syment
.n_numaux
);
2224 bfd_fprintf_vma (abfd
, file
, val
);
2225 fprintf (file
, " %s", symbol
->name
);
2227 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
2229 combined_entry_type
*auxp
= combined
+ aux
+ 1;
2232 BFD_ASSERT (! auxp
->is_sym
);
2234 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.p
- root
;
2236 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.u32
;
2238 fprintf (file
, "\n");
2240 if (bfd_coff_print_aux (abfd
, file
, root
, combined
, auxp
, aux
))
2243 switch (combined
->u
.syment
.n_sclass
)
2246 fprintf (file
, "File ");
2247 /* Add additional information if this isn't the filename
2249 if (auxp
->u
.auxent
.x_file
.x_ftype
)
2250 fprintf (file
, "ftype %d fname \"%s\"",
2251 auxp
->u
.auxent
.x_file
.x_ftype
,
2252 (char *) auxp
->u
.auxent
.x_file
.x_n
.x_n
.x_offset
);
2256 fprintf (file
, "AUX scnlen %#" PRIx64
" nreloc %" PRId64
,
2257 auxp
->u
.auxent
.x_sect
.x_scnlen
,
2258 auxp
->u
.auxent
.x_sect
.x_nreloc
);
2262 if (combined
->u
.syment
.n_type
== T_NULL
)
2263 /* Probably a section symbol ? */
2265 fprintf (file
, "AUX scnlen 0x%lx nreloc %d nlnno %d",
2266 (unsigned long) auxp
->u
.auxent
.x_scn
.x_scnlen
,
2267 auxp
->u
.auxent
.x_scn
.x_nreloc
,
2268 auxp
->u
.auxent
.x_scn
.x_nlinno
);
2269 if (auxp
->u
.auxent
.x_scn
.x_checksum
!= 0
2270 || auxp
->u
.auxent
.x_scn
.x_associated
!= 0
2271 || auxp
->u
.auxent
.x_scn
.x_comdat
!= 0)
2272 fprintf (file
, " checksum 0x%x assoc %d comdat %d",
2273 auxp
->u
.auxent
.x_scn
.x_checksum
,
2274 auxp
->u
.auxent
.x_scn
.x_associated
,
2275 auxp
->u
.auxent
.x_scn
.x_comdat
);
2281 if (ISFCN (combined
->u
.syment
.n_type
))
2286 next
= (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2289 next
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.u32
;
2290 llnos
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
2292 "AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld",
2294 (unsigned long) auxp
->u
.auxent
.x_sym
.x_misc
.x_fsize
,
2300 fprintf (file
, "AUX lnno %d size 0x%x tagndx %ld",
2301 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
2302 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
,
2305 fprintf (file
, " endndx %ld",
2307 (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2315 fprintf (file
, "\n%s :", l
->u
.sym
->name
);
2317 while (l
->line_number
)
2319 if (l
->line_number
> 0)
2321 fprintf (file
, "\n%4d : ", l
->line_number
);
2322 bfd_fprintf_vma (abfd
, file
, l
->u
.offset
+ symbol
->section
->vma
);
2330 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
2331 fprintf (file
, " %-5s %s %s %s",
2332 symbol
->section
->name
,
2333 coffsymbol (symbol
)->native
? "n" : "g",
2334 coffsymbol (symbol
)->lineno
? "l" : " ",
2340 /* Return whether a symbol name implies a local symbol. In COFF,
2341 local symbols generally start with ``.L''. Most targets use this
2342 function for the is_local_label_name entry point, but some may
2346 _bfd_coff_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
2349 return name
[0] == '.' && name
[1] == 'L';
2352 /* Provided a BFD, a section and an offset (in bytes, not octets) into the
2353 section, calculate and return the name of the source file and the line
2354 nearest to the wanted location. */
2357 coff_find_nearest_line_with_names (bfd
*abfd
,
2361 const char **filename_ptr
,
2362 const char **functionname_ptr
,
2363 unsigned int *line_ptr
,
2364 const struct dwarf_debug_section
*debug_sections
)
2368 unsigned int line_base
;
2369 coff_data_type
*cof
= coff_data (abfd
);
2370 /* Run through the raw syments if available. */
2371 combined_entry_type
*p
;
2372 combined_entry_type
*pend
;
2374 struct coff_section_tdata
*sec_data
;
2377 /* Before looking through the symbol table, try to use a .stab
2378 section to find the information. */
2379 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2380 &found
, filename_ptr
,
2381 functionname_ptr
, line_ptr
,
2382 &coff_data(abfd
)->line_info
))
2388 /* Also try examining DWARF2 debugging information. */
2389 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
2390 filename_ptr
, functionname_ptr
,
2391 line_ptr
, NULL
, debug_sections
,
2392 &coff_data(abfd
)->dwarf2_find_line_info
))
2395 sec_data
= coff_section_data (abfd
, section
);
2397 /* If the DWARF lookup failed, but there is DWARF information available
2398 then the problem might be that the file has been rebased. This tool
2399 changes the VMAs of all the sections, but it does not update the DWARF
2400 information. So try again, using a bias against the address sought. */
2401 if (coff_data (abfd
)->dwarf2_find_line_info
!= NULL
)
2403 bfd_signed_vma bias
= 0;
2405 /* Create a cache of the result for the next call. */
2406 if (sec_data
== NULL
&& section
->owner
== abfd
)
2408 amt
= sizeof (struct coff_section_tdata
);
2409 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
2410 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2413 if (sec_data
!= NULL
&& sec_data
->saved_bias
)
2414 bias
= sec_data
->bias
;
2417 bias
= _bfd_dwarf2_find_symbol_bias (symbols
,
2418 & coff_data (abfd
)->dwarf2_find_line_info
);
2422 sec_data
->saved_bias
= true;
2423 sec_data
->bias
= bias
;
2428 && _bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
,
2430 filename_ptr
, functionname_ptr
,
2431 line_ptr
, NULL
, debug_sections
,
2432 &coff_data(abfd
)->dwarf2_find_line_info
))
2437 *functionname_ptr
= 0;
2440 /* Don't try and find line numbers in a non coff file. */
2441 if (!bfd_family_coff (abfd
))
2447 /* Find the first C_FILE symbol. */
2448 p
= cof
->raw_syments
;
2452 pend
= p
+ cof
->raw_syment_count
;
2455 BFD_ASSERT (p
->is_sym
);
2456 if (p
->u
.syment
.n_sclass
== C_FILE
)
2458 p
+= 1 + p
->u
.syment
.n_numaux
;
2466 /* Look through the C_FILE symbols to find the best one. */
2467 sec_vma
= bfd_section_vma (section
);
2468 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2469 maxdiff
= (bfd_vma
) 0 - (bfd_vma
) 1;
2473 combined_entry_type
*p2
;
2475 for (p2
= p
+ 1 + p
->u
.syment
.n_numaux
;
2477 p2
+= 1 + p2
->u
.syment
.n_numaux
)
2479 BFD_ASSERT (p2
->is_sym
);
2480 if (p2
->u
.syment
.n_scnum
> 0
2482 == coff_section_from_bfd_index (abfd
,
2483 p2
->u
.syment
.n_scnum
)))
2485 if (p2
->u
.syment
.n_sclass
== C_FILE
)
2494 file_addr
= (bfd_vma
) p2
->u
.syment
.n_value
;
2495 /* PR 11512: Include the section address of the function name symbol. */
2496 if (p2
->u
.syment
.n_scnum
> 0)
2497 file_addr
+= coff_section_from_bfd_index (abfd
,
2498 p2
->u
.syment
.n_scnum
)->vma
;
2499 /* We use <= MAXDIFF here so that if we get a zero length
2500 file, we actually use the next file entry. */
2502 && offset
+ sec_vma
>= file_addr
2503 && offset
+ sec_vma
- file_addr
<= maxdiff
)
2505 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2506 maxdiff
= offset
+ sec_vma
- p2
->u
.syment
.n_value
;
2509 if (p
->u
.syment
.n_value
>= cof
->raw_syment_count
)
2512 /* Avoid endless loops on erroneous files by ensuring that
2513 we always move forward in the file. */
2514 if (p
>= cof
->raw_syments
+ p
->u
.syment
.n_value
)
2517 p
= cof
->raw_syments
+ p
->u
.syment
.n_value
;
2518 if (!p
->is_sym
|| p
->u
.syment
.n_sclass
!= C_FILE
)
2523 if (section
->lineno_count
== 0)
2525 *functionname_ptr
= NULL
;
2530 /* Now wander though the raw linenumbers of the section.
2531 If we have been called on this section before, and the offset
2532 we want is further down then we can prime the lookup loop. */
2533 if (sec_data
!= NULL
2535 && offset
>= sec_data
->offset
)
2538 *functionname_ptr
= sec_data
->function
;
2539 line_base
= sec_data
->line_base
;
2547 if (section
->lineno
!= NULL
)
2549 bfd_vma last_value
= 0;
2551 l
= §ion
->lineno
[i
];
2553 for (; i
< section
->lineno_count
; i
++)
2555 if (l
->line_number
== 0)
2557 /* Get the symbol this line number points at. */
2558 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
2559 if (coff
->symbol
.value
> offset
)
2562 *functionname_ptr
= coff
->symbol
.name
;
2563 last_value
= coff
->symbol
.value
;
2566 combined_entry_type
*s
= coff
->native
;
2568 BFD_ASSERT (s
->is_sym
);
2569 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2571 /* In XCOFF a debugging symbol can follow the
2573 if (((size_t) ((char *) s
- (char *) obj_raw_syments (abfd
))
2574 < obj_raw_syment_count (abfd
) * sizeof (*s
))
2575 && s
->u
.syment
.n_scnum
== N_DEBUG
)
2576 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2578 /* S should now point to the .bf of the function. */
2579 if (((size_t) ((char *) s
- (char *) obj_raw_syments (abfd
))
2580 < obj_raw_syment_count (abfd
) * sizeof (*s
))
2581 && s
->u
.syment
.n_numaux
)
2583 /* The linenumber is stored in the auxent. */
2584 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
2586 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
2587 *line_ptr
= line_base
;
2593 if (l
->u
.offset
> offset
)
2595 *line_ptr
= l
->line_number
+ line_base
- 1;
2600 /* If we fell off the end of the loop, then assume that this
2601 symbol has no line number info. Otherwise, symbols with no
2602 line number info get reported with the line number of the
2603 last line of the last symbol which does have line number
2604 info. We use 0x100 as a slop to account for cases where the
2605 last line has executable code. */
2606 if (i
>= section
->lineno_count
2608 && offset
- last_value
> 0x100)
2610 *functionname_ptr
= NULL
;
2615 /* Cache the results for the next call. */
2616 if (sec_data
== NULL
&& section
->owner
== abfd
)
2618 amt
= sizeof (struct coff_section_tdata
);
2619 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
2620 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2623 if (sec_data
!= NULL
)
2625 sec_data
->offset
= offset
;
2626 sec_data
->i
= i
- 1;
2627 sec_data
->function
= *functionname_ptr
;
2628 sec_data
->line_base
= line_base
;
2635 coff_find_nearest_line (bfd
*abfd
,
2639 const char **filename_ptr
,
2640 const char **functionname_ptr
,
2641 unsigned int *line_ptr
,
2642 unsigned int *discriminator_ptr
)
2644 if (discriminator_ptr
)
2645 *discriminator_ptr
= 0;
2646 return coff_find_nearest_line_with_names (abfd
, symbols
, section
, offset
,
2647 filename_ptr
, functionname_ptr
,
2648 line_ptr
, dwarf_debug_sections
);
2652 coff_find_inliner_info (bfd
*abfd
,
2653 const char **filename_ptr
,
2654 const char **functionname_ptr
,
2655 unsigned int *line_ptr
)
2659 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
2660 functionname_ptr
, line_ptr
,
2661 &coff_data(abfd
)->dwarf2_find_line_info
);
2666 coff_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
2670 if (!bfd_link_relocatable (info
))
2671 size
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
2673 size
= bfd_coff_filhsz (abfd
);
2675 size
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
2679 /* Change the class of a coff symbol held by BFD. */
2682 bfd_coff_set_symbol_class (bfd
* abfd
,
2684 unsigned int symbol_class
)
2686 coff_symbol_type
* csym
;
2688 csym
= coff_symbol_from (symbol
);
2691 bfd_set_error (bfd_error_invalid_operation
);
2694 else if (csym
->native
== NULL
)
2696 /* This is an alien symbol which no native coff backend data.
2697 We cheat here by creating a fake native entry for it and
2698 then filling in the class. This code is based on that in
2699 coff_write_alien_symbol(). */
2701 combined_entry_type
* native
;
2702 size_t amt
= sizeof (* native
);
2704 native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
2708 native
->is_sym
= true;
2709 native
->u
.syment
.n_type
= T_NULL
;
2710 native
->u
.syment
.n_sclass
= symbol_class
;
2712 if (bfd_is_und_section (symbol
->section
))
2714 native
->u
.syment
.n_scnum
= N_UNDEF
;
2715 native
->u
.syment
.n_value
= symbol
->value
;
2717 else if (bfd_is_com_section (symbol
->section
))
2719 native
->u
.syment
.n_scnum
= N_UNDEF
;
2720 native
->u
.syment
.n_value
= symbol
->value
;
2724 native
->u
.syment
.n_scnum
=
2725 symbol
->section
->output_section
->target_index
;
2726 native
->u
.syment
.n_value
= (symbol
->value
2727 + symbol
->section
->output_offset
);
2728 if (! obj_pe (abfd
))
2729 native
->u
.syment
.n_value
+= symbol
->section
->output_section
->vma
;
2731 /* Copy the any flags from the file header into the symbol.
2733 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (& csym
->symbol
)->flags
;
2736 csym
->native
= native
;
2739 csym
->native
->u
.syment
.n_sclass
= symbol_class
;
2745 _bfd_coff_section_already_linked (bfd
*abfd
,
2747 struct bfd_link_info
*info
)
2750 const char *name
, *key
;
2751 struct bfd_section_already_linked
*l
;
2752 struct bfd_section_already_linked_hash_entry
*already_linked_list
;
2753 struct coff_comdat_info
*s_comdat
;
2755 if (sec
->output_section
== bfd_abs_section_ptr
)
2759 if ((flags
& SEC_LINK_ONCE
) == 0)
2762 /* The COFF backend linker doesn't support group sections. */
2763 if ((flags
& SEC_GROUP
) != 0)
2766 name
= bfd_section_name (sec
);
2767 s_comdat
= bfd_coff_get_comdat_section (abfd
, sec
);
2769 if (s_comdat
!= NULL
)
2770 key
= s_comdat
->name
;
2773 if (startswith (name
, ".gnu.linkonce.")
2774 && (key
= strchr (name
+ sizeof (".gnu.linkonce.") - 1, '.')) != NULL
)
2777 /* FIXME: gcc as of 2011-09 emits sections like .text$<key>,
2778 .xdata$<key> and .pdata$<key> only the first of which has a
2779 comdat key. Should these all match the LTO IR key? */
2783 already_linked_list
= bfd_section_already_linked_table_lookup (key
);
2785 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
2787 struct coff_comdat_info
*l_comdat
;
2789 l_comdat
= bfd_coff_get_comdat_section (l
->sec
->owner
, l
->sec
);
2791 /* The section names must match, and both sections must be
2792 comdat and have the same comdat name, or both sections must
2793 be non-comdat. LTO IR plugin sections are an exception. They
2794 are always named .gnu.linkonce.t.<key> (<key> is some string)
2795 and match any comdat section with comdat name of <key>, and
2796 any linkonce section with the same suffix, ie.
2797 .gnu.linkonce.*.<key>. */
2798 if (((s_comdat
!= NULL
) == (l_comdat
!= NULL
)
2799 && strcmp (name
, l
->sec
->name
) == 0)
2800 || (l
->sec
->owner
->flags
& BFD_PLUGIN
) != 0
2801 || (sec
->owner
->flags
& BFD_PLUGIN
) != 0)
2803 /* The section has already been linked. See if we should
2805 return _bfd_handle_already_linked (sec
, l
, info
);
2809 /* This is the first section with this name. Record it. */
2810 if (!bfd_section_already_linked_table_insert (already_linked_list
, sec
))
2811 info
->callbacks
->einfo (_("%F%P: already_linked_table: %E\n"));
2815 /* Initialize COOKIE for input bfd ABFD. */
2818 init_reloc_cookie (struct coff_reloc_cookie
*cookie
,
2819 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2822 /* Sometimes the symbol table does not yet have been loaded here. */
2823 bfd_coff_slurp_symbol_table (abfd
);
2825 cookie
->abfd
= abfd
;
2826 cookie
->sym_hashes
= obj_coff_sym_hashes (abfd
);
2828 cookie
->symbols
= obj_symbols (abfd
);
2833 /* Free the memory allocated by init_reloc_cookie, if appropriate. */
2836 fini_reloc_cookie (struct coff_reloc_cookie
*cookie ATTRIBUTE_UNUSED
,
2837 bfd
*abfd ATTRIBUTE_UNUSED
)
2839 /* Nothing to do. */
2842 /* Initialize the relocation information in COOKIE for input section SEC
2843 of input bfd ABFD. */
2846 init_reloc_cookie_rels (struct coff_reloc_cookie
*cookie
,
2847 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2851 if (sec
->reloc_count
== 0)
2853 cookie
->rels
= NULL
;
2854 cookie
->relend
= NULL
;
2859 cookie
->rels
= _bfd_coff_read_internal_relocs (abfd
, sec
, false, NULL
,
2862 if (cookie
->rels
== NULL
)
2865 cookie
->rel
= cookie
->rels
;
2866 cookie
->relend
= (cookie
->rels
+ sec
->reloc_count
);
2870 /* Free the memory allocated by init_reloc_cookie_rels,
2874 fini_reloc_cookie_rels (struct coff_reloc_cookie
*cookie
,
2878 /* PR 20401. The relocs may not have been cached, so check first.
2879 If the relocs were loaded by init_reloc_cookie_rels() then this
2880 will be the case. FIXME: Would performance be improved if the
2881 relocs *were* cached ? */
2882 && coff_section_data (NULL
, sec
)
2883 && coff_section_data (NULL
, sec
)->relocs
!= cookie
->rels
)
2884 free (cookie
->rels
);
2887 /* Initialize the whole of COOKIE for input section SEC. */
2890 init_reloc_cookie_for_section (struct coff_reloc_cookie
*cookie
,
2891 struct bfd_link_info
*info
,
2894 if (!init_reloc_cookie (cookie
, info
, sec
->owner
))
2897 if (!init_reloc_cookie_rels (cookie
, info
, sec
->owner
, sec
))
2899 fini_reloc_cookie (cookie
, sec
->owner
);
2905 /* Free the memory allocated by init_reloc_cookie_for_section,
2909 fini_reloc_cookie_for_section (struct coff_reloc_cookie
*cookie
,
2912 fini_reloc_cookie_rels (cookie
, sec
);
2913 fini_reloc_cookie (cookie
, sec
->owner
);
2917 _bfd_coff_gc_mark_hook (asection
*sec
,
2918 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2919 struct internal_reloc
*rel ATTRIBUTE_UNUSED
,
2920 struct coff_link_hash_entry
*h
,
2921 struct internal_syment
*sym
)
2925 switch (h
->root
.type
)
2927 case bfd_link_hash_defined
:
2928 case bfd_link_hash_defweak
:
2929 return h
->root
.u
.def
.section
;
2931 case bfd_link_hash_common
:
2932 return h
->root
.u
.c
.p
->section
;
2934 case bfd_link_hash_undefweak
:
2935 if (h
->symbol_class
== C_NT_WEAK
&& h
->numaux
== 1)
2937 /* PE weak externals. A weak symbol may include an auxiliary
2938 record indicating that if the weak symbol is not resolved,
2939 another external symbol is used instead. */
2940 struct coff_link_hash_entry
*h2
=
2941 h
->auxbfd
->tdata
.coff_obj_data
->sym_hashes
2942 [h
->aux
->x_sym
.x_tagndx
.u32
];
2944 if (h2
&& h2
->root
.type
!= bfd_link_hash_undefined
)
2945 return h2
->root
.u
.def
.section
;
2949 case bfd_link_hash_undefined
:
2956 return coff_section_from_bfd_index (sec
->owner
, sym
->n_scnum
);
2959 /* COOKIE->rel describes a relocation against section SEC, which is
2960 a section we've decided to keep. Return the section that contains
2961 the relocation symbol, or NULL if no section contains it. */
2964 _bfd_coff_gc_mark_rsec (struct bfd_link_info
*info
, asection
*sec
,
2965 coff_gc_mark_hook_fn gc_mark_hook
,
2966 struct coff_reloc_cookie
*cookie
)
2968 struct coff_link_hash_entry
*h
;
2970 h
= cookie
->sym_hashes
[cookie
->rel
->r_symndx
];
2973 while (h
->root
.type
== bfd_link_hash_indirect
2974 || h
->root
.type
== bfd_link_hash_warning
)
2975 h
= (struct coff_link_hash_entry
*) h
->root
.u
.i
.link
;
2977 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, h
, NULL
);
2980 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, NULL
,
2982 + obj_convert (sec
->owner
)[cookie
->rel
->r_symndx
])->native
->u
.syment
);
2985 static bool _bfd_coff_gc_mark
2986 (struct bfd_link_info
*, asection
*, coff_gc_mark_hook_fn
);
2988 /* COOKIE->rel describes a relocation against section SEC, which is
2989 a section we've decided to keep. Mark the section that contains
2990 the relocation symbol. */
2993 _bfd_coff_gc_mark_reloc (struct bfd_link_info
*info
,
2995 coff_gc_mark_hook_fn gc_mark_hook
,
2996 struct coff_reloc_cookie
*cookie
)
3000 rsec
= _bfd_coff_gc_mark_rsec (info
, sec
, gc_mark_hook
, cookie
);
3001 if (rsec
&& !rsec
->gc_mark
)
3003 if (bfd_get_flavour (rsec
->owner
) != bfd_target_coff_flavour
)
3005 else if (!_bfd_coff_gc_mark (info
, rsec
, gc_mark_hook
))
3011 /* The mark phase of garbage collection. For a given section, mark
3012 it and any sections in this section's group, and all the sections
3013 which define symbols to which it refers. */
3016 _bfd_coff_gc_mark (struct bfd_link_info
*info
,
3018 coff_gc_mark_hook_fn gc_mark_hook
)
3024 /* Look through the section relocs. */
3025 if ((sec
->flags
& SEC_RELOC
) != 0
3026 && sec
->reloc_count
> 0)
3028 struct coff_reloc_cookie cookie
;
3030 if (!init_reloc_cookie_for_section (&cookie
, info
, sec
))
3034 for (; cookie
.rel
< cookie
.relend
; cookie
.rel
++)
3036 if (!_bfd_coff_gc_mark_reloc (info
, sec
, gc_mark_hook
, &cookie
))
3042 fini_reloc_cookie_for_section (&cookie
, sec
);
3050 _bfd_coff_gc_mark_extra_sections (struct bfd_link_info
*info
,
3051 coff_gc_mark_hook_fn mark_hook ATTRIBUTE_UNUSED
)
3055 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
3060 if (bfd_get_flavour (ibfd
) != bfd_target_coff_flavour
)
3063 /* Ensure all linker created sections are kept, and see whether
3064 any other section is already marked. */
3066 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
3068 if ((isec
->flags
& SEC_LINKER_CREATED
) != 0)
3070 else if (isec
->gc_mark
)
3074 /* If no section in this file will be kept, then we can
3075 toss out debug sections. */
3079 /* Keep debug and special sections like .comment when they are
3080 not part of a group, or when we have single-member groups. */
3081 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
3082 if ((isec
->flags
& SEC_DEBUGGING
) != 0
3083 || (isec
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0)
3089 /* Sweep symbols in swept sections. Called via coff_link_hash_traverse. */
3092 coff_gc_sweep_symbol (struct coff_link_hash_entry
*h
,
3093 void *data ATTRIBUTE_UNUSED
)
3095 if (h
->root
.type
== bfd_link_hash_warning
)
3096 h
= (struct coff_link_hash_entry
*) h
->root
.u
.i
.link
;
3098 if ((h
->root
.type
== bfd_link_hash_defined
3099 || h
->root
.type
== bfd_link_hash_defweak
)
3100 && !h
->root
.u
.def
.section
->gc_mark
3101 && !(h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
))
3103 /* Do our best to hide the symbol. */
3104 h
->root
.u
.def
.section
= bfd_und_section_ptr
;
3105 h
->symbol_class
= C_HIDDEN
;
3111 /* The sweep phase of garbage collection. Remove all garbage sections. */
3113 typedef bool (*gc_sweep_hook_fn
)
3114 (bfd
*, struct bfd_link_info
*, asection
*, const struct internal_reloc
*);
3117 coff_gc_sweep (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
3121 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3125 if (bfd_get_flavour (sub
) != bfd_target_coff_flavour
)
3128 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3130 /* Keep debug and special sections. */
3131 if ((o
->flags
& (SEC_DEBUGGING
| SEC_LINKER_CREATED
)) != 0
3132 || (o
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0)
3134 else if (startswith (o
->name
, ".idata")
3135 || startswith (o
->name
, ".pdata")
3136 || startswith (o
->name
, ".xdata")
3137 || startswith (o
->name
, ".rsrc"))
3143 /* Skip sweeping sections already excluded. */
3144 if (o
->flags
& SEC_EXCLUDE
)
3147 /* Since this is early in the link process, it is simple
3148 to remove a section from the output. */
3149 o
->flags
|= SEC_EXCLUDE
;
3151 if (info
->print_gc_sections
&& o
->size
!= 0)
3152 /* xgettext: c-format */
3153 _bfd_error_handler (_("removing unused section '%pA' in file '%pB'"),
3157 /* But we also have to update some of the relocation
3158 info we collected before. */
3160 && (o
->flags
& SEC_RELOC
) != 0
3161 && o
->reloc_count
> 0
3162 && !bfd_is_abs_section (o
->output_section
))
3164 struct internal_reloc
*internal_relocs
;
3168 = _bfd_coff_link_read_relocs (o
->owner
, o
, NULL
, NULL
,
3170 if (internal_relocs
== NULL
)
3173 r
= (*gc_sweep_hook
) (o
->owner
, info
, o
, internal_relocs
);
3175 if (coff_section_data (o
)->relocs
!= internal_relocs
)
3176 free (internal_relocs
);
3185 /* Remove the symbols that were in the swept sections from the dynamic
3187 coff_link_hash_traverse (coff_hash_table (info
), coff_gc_sweep_symbol
,
3193 /* Keep all sections containing symbols undefined on the command-line,
3194 and the section containing the entry symbol. */
3197 _bfd_coff_gc_keep (struct bfd_link_info
*info
)
3199 struct bfd_sym_chain
*sym
;
3201 for (sym
= info
->gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
3203 struct coff_link_hash_entry
*h
;
3205 h
= coff_link_hash_lookup (coff_hash_table (info
), sym
->name
,
3206 false, false, false);
3209 && (h
->root
.type
== bfd_link_hash_defined
3210 || h
->root
.type
== bfd_link_hash_defweak
)
3211 && !bfd_is_abs_section (h
->root
.u
.def
.section
))
3212 h
->root
.u
.def
.section
->flags
|= SEC_KEEP
;
3216 /* Do mark and sweep of unused sections. */
3219 bfd_coff_gc_sections (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
3223 /* FIXME: Should we implement this? */
3225 const bfd_coff_backend_data
*bed
= coff_backend_info (abfd
);
3227 if (!bed
->can_gc_sections
3228 || !is_coff_hash_table (info
->hash
))
3230 _bfd_error_handler(_("warning: gc-sections option ignored"));
3235 _bfd_coff_gc_keep (info
);
3237 /* Grovel through relocs to find out who stays ... */
3238 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3242 if (bfd_get_flavour (sub
) != bfd_target_coff_flavour
)
3245 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3247 if (((o
->flags
& (SEC_EXCLUDE
| SEC_KEEP
)) == SEC_KEEP
3248 || startswith (o
->name
, ".vectors")
3249 || startswith (o
->name
, ".ctors")
3250 || startswith (o
->name
, ".dtors"))
3253 if (!_bfd_coff_gc_mark (info
, o
, _bfd_coff_gc_mark_hook
))
3259 /* Allow the backend to mark additional target specific sections. */
3260 _bfd_coff_gc_mark_extra_sections (info
, _bfd_coff_gc_mark_hook
);
3262 /* ... and mark SEC_EXCLUDE for those that go. */
3263 return coff_gc_sweep (abfd
, info
);
3266 /* Return name used to identify a comdat group. */
3269 bfd_coff_group_name (bfd
*abfd
, const asection
*sec
)
3271 struct coff_comdat_info
*ci
= bfd_coff_get_comdat_section (abfd
, sec
);
3278 _bfd_coff_free_cached_info (bfd
*abfd
)
3280 struct coff_tdata
*tdata
;
3282 if (bfd_family_coff (abfd
)
3283 && (bfd_get_format (abfd
) == bfd_object
3284 || bfd_get_format (abfd
) == bfd_core
)
3285 && (tdata
= coff_data (abfd
)) != NULL
)
3287 if (tdata
->section_by_index
)
3289 htab_delete (tdata
->section_by_index
);
3290 tdata
->section_by_index
= NULL
;
3293 if (tdata
->section_by_target_index
)
3295 htab_delete (tdata
->section_by_target_index
);
3296 tdata
->section_by_target_index
= NULL
;
3299 _bfd_dwarf2_cleanup_debug_info (abfd
, &tdata
->dwarf2_find_line_info
);
3300 _bfd_stab_cleanup (abfd
, &tdata
->line_info
);
3303 Do not clear the keep_syms and keep_strings flags.
3304 These may have been set by pe_ILF_build_a_bfd() indicating
3305 that the syms and strings pointers are not to be freed. */
3306 if (!_bfd_coff_free_symbols (abfd
))
3310 return _bfd_generic_bfd_free_cached_info (abfd
);