1 /* Support for the generic parts of COFF, for BFD.
2 Copyright (C) 1990-2021 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"
46 /* Take a section header read from a coff file (in HOST byte order),
47 and make a BFD "section" out of it. This is used by ECOFF. */
50 make_a_section_from_file (bfd
*abfd
,
51 struct internal_scnhdr
*hdr
,
52 unsigned int target_index
)
54 asection
*return_section
;
61 /* Handle long section names as in PE. On reading, we want to
62 accept long names if the format permits them at all, regardless
63 of the current state of the flag that dictates if we would generate
64 them in outputs; this construct checks if that is the case by
65 attempting to set the flag, without changing its state; the call
66 will fail for formats that do not support long names at all. */
67 if (bfd_coff_set_long_section_names (abfd
, bfd_coff_long_section_names (abfd
))
68 && hdr
->s_name
[0] == '/')
75 /* Flag that this BFD uses long names, even though the format might
76 expect them to be off by default. This won't directly affect the
77 format of any output BFD created from this one, but the information
78 can be used to decide what to do. */
79 bfd_coff_set_long_section_names (abfd
, true);
80 memcpy (buf
, hdr
->s_name
+ 1, SCNNMLEN
- 1);
81 buf
[SCNNMLEN
- 1] = '\0';
82 strindex
= strtol (buf
, &p
, 10);
83 if (*p
== '\0' && strindex
>= 0)
85 strings
= _bfd_coff_read_string_table (abfd
);
88 if ((bfd_size_type
)(strindex
+ 2) >= obj_coff_strings_len (abfd
))
91 name
= (char *) bfd_alloc (abfd
,
92 (bfd_size_type
) strlen (strings
) + 1 + 1);
95 strcpy (name
, strings
);
101 /* Assorted wastage to null-terminate the name, thanks AT&T! */
102 name
= (char *) bfd_alloc (abfd
,
103 (bfd_size_type
) sizeof (hdr
->s_name
) + 1 + 1);
106 strncpy (name
, (char *) &hdr
->s_name
[0], sizeof (hdr
->s_name
));
107 name
[sizeof (hdr
->s_name
)] = 0;
110 return_section
= bfd_make_section_anyway (abfd
, name
);
111 if (return_section
== NULL
)
114 return_section
->vma
= hdr
->s_vaddr
;
115 return_section
->lma
= hdr
->s_paddr
;
116 return_section
->size
= hdr
->s_size
;
117 return_section
->filepos
= hdr
->s_scnptr
;
118 return_section
->rel_filepos
= hdr
->s_relptr
;
119 return_section
->reloc_count
= hdr
->s_nreloc
;
121 bfd_coff_set_alignment_hook (abfd
, return_section
, hdr
);
123 return_section
->line_filepos
= hdr
->s_lnnoptr
;
125 return_section
->lineno_count
= hdr
->s_nlnno
;
126 return_section
->userdata
= NULL
;
127 return_section
->next
= NULL
;
128 return_section
->target_index
= target_index
;
130 if (! bfd_coff_styp_to_sec_flags_hook (abfd
, hdr
, name
, return_section
,
134 return_section
->flags
= flags
;
136 /* At least on i386-coff, the line number count for a shared library
137 section must be ignored. */
138 if ((return_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
139 return_section
->lineno_count
= 0;
141 if (hdr
->s_nreloc
!= 0)
142 return_section
->flags
|= SEC_RELOC
;
143 /* FIXME: should this check 'hdr->s_size > 0'. */
144 if (hdr
->s_scnptr
!= 0)
145 return_section
->flags
|= SEC_HAS_CONTENTS
;
147 /* Compress/decompress DWARF debug sections with names: .debug_* and
148 .zdebug_*, after the section flags is set. */
149 if ((flags
& SEC_DEBUGGING
)
151 && ((name
[1] == 'd' && name
[6] == '_')
152 || (strlen (name
) > 8 && name
[1] == 'z' && name
[7] == '_')))
154 enum { nothing
, compress
, decompress
} action
= nothing
;
155 char *new_name
= NULL
;
157 if (bfd_is_section_compressed (abfd
, return_section
))
159 /* Compressed section. Check if we should decompress. */
160 if ((abfd
->flags
& BFD_DECOMPRESS
))
163 else if (!bfd_is_section_compressed (abfd
, return_section
))
165 /* Normal section. Check if we should compress. */
166 if ((abfd
->flags
& BFD_COMPRESS
) && return_section
->size
!= 0)
175 if (!bfd_init_section_compress_status (abfd
, return_section
))
178 /* xgettext: c-format */
179 (_("%pB: unable to initialize compress status for section %s"),
183 if (return_section
->compress_status
== COMPRESS_SECTION_DONE
)
187 unsigned int len
= strlen (name
);
189 new_name
= bfd_alloc (abfd
, len
+ 2);
190 if (new_name
== NULL
)
194 memcpy (new_name
+ 2, name
+ 1, len
);
199 if (!bfd_init_section_decompress_status (abfd
, return_section
))
202 /* xgettext: c-format */
203 (_("%pB: unable to initialize decompress status for section %s"),
209 unsigned int len
= strlen (name
);
211 new_name
= bfd_alloc (abfd
, len
);
212 if (new_name
== NULL
)
215 memcpy (new_name
+ 1, name
+ 2, len
- 1);
219 if (new_name
!= NULL
)
220 bfd_rename_section (return_section
, new_name
);
226 /* Read in a COFF object and make it into a BFD. This is used by
229 coff_real_object_p (bfd
*,
231 struct internal_filehdr
*,
232 struct internal_aouthdr
*);
234 coff_real_object_p (bfd
*abfd
,
236 struct internal_filehdr
*internal_f
,
237 struct internal_aouthdr
*internal_a
)
239 flagword oflags
= abfd
->flags
;
240 bfd_vma ostart
= bfd_get_start_address (abfd
);
243 bfd_size_type readsize
; /* Length of file_info. */
245 char *external_sections
;
247 if (!(internal_f
->f_flags
& F_RELFLG
))
248 abfd
->flags
|= HAS_RELOC
;
249 if ((internal_f
->f_flags
& F_EXEC
))
250 abfd
->flags
|= EXEC_P
;
251 if (!(internal_f
->f_flags
& F_LNNO
))
252 abfd
->flags
|= HAS_LINENO
;
253 if (!(internal_f
->f_flags
& F_LSYMS
))
254 abfd
->flags
|= HAS_LOCALS
;
256 /* FIXME: How can we set D_PAGED correctly? */
257 if ((internal_f
->f_flags
& F_EXEC
) != 0)
258 abfd
->flags
|= D_PAGED
;
260 abfd
->symcount
= internal_f
->f_nsyms
;
261 if (internal_f
->f_nsyms
)
262 abfd
->flags
|= HAS_SYMS
;
264 if (internal_a
!= (struct internal_aouthdr
*) NULL
)
265 abfd
->start_address
= internal_a
->entry
;
267 abfd
->start_address
= 0;
269 /* Set up the tdata area. ECOFF uses its own routine, and overrides
271 tdata_save
= abfd
->tdata
.any
;
272 tdata
= bfd_coff_mkobject_hook (abfd
, (void *) internal_f
, (void *) internal_a
);
276 scnhsz
= bfd_coff_scnhsz (abfd
);
277 readsize
= (bfd_size_type
) nscns
* scnhsz
;
278 external_sections
= (char *) _bfd_alloc_and_read (abfd
, readsize
, readsize
);
279 if (!external_sections
)
282 /* Set the arch/mach *before* swapping in sections; section header swapping
283 may depend on arch/mach info. */
284 if (! bfd_coff_set_arch_mach_hook (abfd
, (void *) internal_f
))
287 /* Now copy data as required; construct all asections etc. */
291 for (i
= 0; i
< nscns
; i
++)
293 struct internal_scnhdr tmp
;
294 bfd_coff_swap_scnhdr_in (abfd
,
295 (void *) (external_sections
+ i
* scnhsz
),
297 if (! make_a_section_from_file (abfd
, &tmp
, i
+ 1))
302 _bfd_coff_free_symbols (abfd
);
303 return _bfd_no_cleanup
;
306 _bfd_coff_free_symbols (abfd
);
307 bfd_release (abfd
, tdata
);
309 abfd
->tdata
.any
= tdata_save
;
310 abfd
->flags
= oflags
;
311 abfd
->start_address
= ostart
;
315 /* Turn a COFF file into a BFD, but fail with bfd_error_wrong_format if it is
316 not a COFF file. This is also used by ECOFF. */
319 coff_object_p (bfd
*abfd
)
321 bfd_size_type filhsz
;
322 bfd_size_type aoutsz
;
325 struct internal_filehdr internal_f
;
326 struct internal_aouthdr internal_a
;
328 /* Figure out how much to read. */
329 filhsz
= bfd_coff_filhsz (abfd
);
330 aoutsz
= bfd_coff_aoutsz (abfd
);
332 filehdr
= _bfd_alloc_and_read (abfd
, filhsz
, filhsz
);
335 if (bfd_get_error () != bfd_error_system_call
)
336 bfd_set_error (bfd_error_wrong_format
);
339 bfd_coff_swap_filehdr_in (abfd
, filehdr
, &internal_f
);
340 bfd_release (abfd
, filehdr
);
342 /* The XCOFF format has two sizes for the f_opthdr. SMALL_AOUTSZ
343 (less than aoutsz) used in object files and AOUTSZ (equal to
344 aoutsz) in executables. The bfd_coff_swap_aouthdr_in function
345 expects this header to be aoutsz bytes in length, so we use that
346 value in the call to bfd_alloc below. But we must be careful to
347 only read in f_opthdr bytes in the call to bfd_bread. We should
348 also attempt to catch corrupt or non-COFF binaries with a strange
349 value for f_opthdr. */
350 if (! bfd_coff_bad_format_hook (abfd
, &internal_f
)
351 || internal_f
.f_opthdr
> aoutsz
)
353 bfd_set_error (bfd_error_wrong_format
);
356 nscns
= internal_f
.f_nscns
;
358 if (internal_f
.f_opthdr
)
362 opthdr
= _bfd_alloc_and_read (abfd
, aoutsz
, internal_f
.f_opthdr
);
365 /* PR 17512: file: 11056-1136-0.004. */
366 if (internal_f
.f_opthdr
< aoutsz
)
367 memset (((char *) opthdr
) + internal_f
.f_opthdr
, 0,
368 aoutsz
- internal_f
.f_opthdr
);
370 bfd_coff_swap_aouthdr_in (abfd
, opthdr
, (void *) &internal_a
);
371 bfd_release (abfd
, opthdr
);
374 return coff_real_object_p (abfd
, nscns
, &internal_f
,
375 (internal_f
.f_opthdr
!= 0
377 : (struct internal_aouthdr
*) NULL
));
380 /* Get the BFD section from a COFF symbol section number. */
383 coff_section_from_bfd_index (bfd
*abfd
, int section_index
)
385 struct bfd_section
*answer
= abfd
->sections
;
387 if (section_index
== N_ABS
)
388 return bfd_abs_section_ptr
;
389 if (section_index
== N_UNDEF
)
390 return bfd_und_section_ptr
;
391 if (section_index
== N_DEBUG
)
392 return bfd_abs_section_ptr
;
396 if (answer
->target_index
== section_index
)
398 answer
= answer
->next
;
401 /* We should not reach this point, but the SCO 3.2v4 /lib/libc_s.a
402 has a bad symbol table in biglitpow.o. */
403 return bfd_und_section_ptr
;
406 /* Get the upper bound of a COFF symbol table. */
409 coff_get_symtab_upper_bound (bfd
*abfd
)
411 if (!bfd_coff_slurp_symbol_table (abfd
))
414 return (bfd_get_symcount (abfd
) + 1) * (sizeof (coff_symbol_type
*));
417 /* Canonicalize a COFF symbol table. */
420 coff_canonicalize_symtab (bfd
*abfd
, asymbol
**alocation
)
422 unsigned int counter
;
423 coff_symbol_type
*symbase
;
424 coff_symbol_type
**location
= (coff_symbol_type
**) alocation
;
426 if (!bfd_coff_slurp_symbol_table (abfd
))
429 symbase
= obj_symbols (abfd
);
430 counter
= bfd_get_symcount (abfd
);
431 while (counter
-- > 0)
432 *location
++ = symbase
++;
436 return bfd_get_symcount (abfd
);
439 /* Get the name of a symbol. The caller must pass in a buffer of size
443 _bfd_coff_internal_syment_name (bfd
*abfd
,
444 const struct internal_syment
*sym
,
447 /* FIXME: It's not clear this will work correctly if sizeof
449 if (sym
->_n
._n_n
._n_zeroes
!= 0
450 || sym
->_n
._n_n
._n_offset
== 0)
452 memcpy (buf
, sym
->_n
._n_name
, SYMNMLEN
);
453 buf
[SYMNMLEN
] = '\0';
460 BFD_ASSERT (sym
->_n
._n_n
._n_offset
>= STRING_SIZE_SIZE
);
461 strings
= obj_coff_strings (abfd
);
464 strings
= _bfd_coff_read_string_table (abfd
);
468 /* PR 17910: Only check for string overflow if the length has been set.
469 Some DLLs, eg those produced by Visual Studio, may not set the length field. */
470 if (obj_coff_strings_len (abfd
) > 0
471 && sym
->_n
._n_n
._n_offset
>= obj_coff_strings_len (abfd
))
473 return strings
+ sym
->_n
._n_n
._n_offset
;
477 /* Read in and swap the relocs. This returns a buffer holding the
478 relocs for section SEC in file ABFD. If CACHE is TRUE and
479 INTERNAL_RELOCS is NULL, the relocs read in will be saved in case
480 the function is called again. If EXTERNAL_RELOCS is not NULL, it
481 is a buffer large enough to hold the unswapped relocs. If
482 INTERNAL_RELOCS is not NULL, it is a buffer large enough to hold
483 the swapped relocs. If REQUIRE_INTERNAL is TRUE, then the return
484 value must be INTERNAL_RELOCS. The function returns NULL on error. */
486 struct internal_reloc
*
487 _bfd_coff_read_internal_relocs (bfd
*abfd
,
490 bfd_byte
*external_relocs
,
491 bool require_internal
,
492 struct internal_reloc
*internal_relocs
)
495 bfd_byte
*free_external
= NULL
;
496 struct internal_reloc
*free_internal
= NULL
;
499 struct internal_reloc
*irel
;
502 if (sec
->reloc_count
== 0)
503 return internal_relocs
; /* Nothing to do. */
505 if (coff_section_data (abfd
, sec
) != NULL
506 && coff_section_data (abfd
, sec
)->relocs
!= NULL
)
508 if (! require_internal
)
509 return coff_section_data (abfd
, sec
)->relocs
;
510 memcpy (internal_relocs
, coff_section_data (abfd
, sec
)->relocs
,
511 sec
->reloc_count
* sizeof (struct internal_reloc
));
512 return internal_relocs
;
515 relsz
= bfd_coff_relsz (abfd
);
517 amt
= sec
->reloc_count
* relsz
;
518 if (external_relocs
== NULL
)
520 free_external
= (bfd_byte
*) bfd_malloc (amt
);
521 if (free_external
== NULL
)
523 external_relocs
= free_external
;
526 if (bfd_seek (abfd
, sec
->rel_filepos
, SEEK_SET
) != 0
527 || bfd_bread (external_relocs
, amt
, abfd
) != amt
)
530 if (internal_relocs
== NULL
)
532 amt
= sec
->reloc_count
;
533 amt
*= sizeof (struct internal_reloc
);
534 free_internal
= (struct internal_reloc
*) bfd_malloc (amt
);
535 if (free_internal
== NULL
)
537 internal_relocs
= free_internal
;
540 /* Swap in the relocs. */
541 erel
= external_relocs
;
542 erel_end
= erel
+ relsz
* sec
->reloc_count
;
543 irel
= internal_relocs
;
544 for (; erel
< erel_end
; erel
+= relsz
, irel
++)
545 bfd_coff_swap_reloc_in (abfd
, (void *) erel
, (void *) irel
);
547 free (free_external
);
548 free_external
= NULL
;
550 if (cache
&& free_internal
!= NULL
)
552 if (coff_section_data (abfd
, sec
) == NULL
)
554 amt
= sizeof (struct coff_section_tdata
);
555 sec
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
556 if (sec
->used_by_bfd
== NULL
)
558 coff_section_data (abfd
, sec
)->contents
= NULL
;
560 coff_section_data (abfd
, sec
)->relocs
= free_internal
;
563 return internal_relocs
;
566 free (free_external
);
567 free (free_internal
);
571 /* Set lineno_count for the output sections of a COFF file. */
574 coff_count_linenumbers (bfd
*abfd
)
576 unsigned int limit
= bfd_get_symcount (abfd
);
584 /* This may be from the backend linker, in which case the
585 lineno_count in the sections is correct. */
586 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
587 total
+= s
->lineno_count
;
591 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
592 BFD_ASSERT (s
->lineno_count
== 0);
594 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
596 asymbol
*q_maybe
= *p
;
598 if (bfd_family_coff (bfd_asymbol_bfd (q_maybe
)))
600 coff_symbol_type
*q
= coffsymbol (q_maybe
);
602 /* The AIX 4.1 compiler can sometimes generate line numbers
603 attached to debugging symbols. We try to simply ignore
605 if (q
->lineno
!= NULL
606 && q
->symbol
.section
->owner
!= NULL
)
608 /* This symbol has line numbers. Increment the owning
609 section's linenumber count. */
610 alent
*l
= q
->lineno
;
614 asection
* sec
= q
->symbol
.section
->output_section
;
616 /* Do not try to update fields in read-only sections. */
617 if (! bfd_is_const_section (sec
))
618 sec
->lineno_count
++;
623 while (l
->line_number
!= 0);
632 fixup_symbol_value (bfd
*abfd
,
633 coff_symbol_type
*coff_symbol_ptr
,
634 struct internal_syment
*syment
)
636 /* Normalize the symbol flags. */
637 if (coff_symbol_ptr
->symbol
.section
638 && bfd_is_com_section (coff_symbol_ptr
->symbol
.section
))
640 /* A common symbol is undefined with a value. */
641 syment
->n_scnum
= N_UNDEF
;
642 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
644 else if ((coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
) != 0
645 && (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING_RELOC
) == 0)
647 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
649 else if (bfd_is_und_section (coff_symbol_ptr
->symbol
.section
))
651 syment
->n_scnum
= N_UNDEF
;
654 /* FIXME: Do we need to handle the absolute section here? */
657 if (coff_symbol_ptr
->symbol
.section
)
660 coff_symbol_ptr
->symbol
.section
->output_section
->target_index
;
662 syment
->n_value
= (coff_symbol_ptr
->symbol
.value
663 + coff_symbol_ptr
->symbol
.section
->output_offset
);
666 syment
->n_value
+= (syment
->n_sclass
== C_STATLAB
)
667 ? coff_symbol_ptr
->symbol
.section
->output_section
->lma
668 : coff_symbol_ptr
->symbol
.section
->output_section
->vma
;
674 /* This can happen, but I don't know why yet (steve@cygnus.com) */
675 syment
->n_scnum
= N_ABS
;
676 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
681 /* Run through all the symbols in the symbol table and work out what
682 their indexes into the symbol table will be when output.
684 Coff requires that each C_FILE symbol points to the next one in the
685 chain, and that the last one points to the first external symbol. We
689 coff_renumber_symbols (bfd
*bfd_ptr
, int *first_undef
)
691 unsigned int symbol_count
= bfd_get_symcount (bfd_ptr
);
692 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
693 unsigned int native_index
= 0;
694 struct internal_syment
*last_file
= NULL
;
695 unsigned int symbol_index
;
697 /* COFF demands that undefined symbols come after all other symbols.
698 Since we don't need to impose this extra knowledge on all our
699 client programs, deal with that here. Sort the symbol table;
700 just move the undefined symbols to the end, leaving the rest
701 alone. The O'Reilly book says that defined global symbols come
702 at the end before the undefined symbols, so we do that here as
704 /* @@ Do we have some condition we could test for, so we don't always
705 have to do this? I don't think relocatability is quite right, but
706 I'm not certain. [raeburn:19920508.1711EST] */
712 amt
= sizeof (asymbol
*) * ((bfd_size_type
) symbol_count
+ 1);
713 newsyms
= (asymbol
**) bfd_alloc (bfd_ptr
, amt
);
716 bfd_ptr
->outsymbols
= newsyms
;
717 for (i
= 0; i
< symbol_count
; i
++)
718 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) != 0
719 || (!bfd_is_und_section (symbol_ptr_ptr
[i
]->section
)
720 && !bfd_is_com_section (symbol_ptr_ptr
[i
]->section
)
721 && ((symbol_ptr_ptr
[i
]->flags
& BSF_FUNCTION
) != 0
722 || ((symbol_ptr_ptr
[i
]->flags
& (BSF_GLOBAL
| BSF_WEAK
))
724 *newsyms
++ = symbol_ptr_ptr
[i
];
726 for (i
= 0; i
< symbol_count
; i
++)
727 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) == 0
728 && !bfd_is_und_section (symbol_ptr_ptr
[i
]->section
)
729 && (bfd_is_com_section (symbol_ptr_ptr
[i
]->section
)
730 || ((symbol_ptr_ptr
[i
]->flags
& BSF_FUNCTION
) == 0
731 && ((symbol_ptr_ptr
[i
]->flags
& (BSF_GLOBAL
| BSF_WEAK
))
733 *newsyms
++ = symbol_ptr_ptr
[i
];
735 *first_undef
= newsyms
- bfd_ptr
->outsymbols
;
737 for (i
= 0; i
< symbol_count
; i
++)
738 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) == 0
739 && bfd_is_und_section (symbol_ptr_ptr
[i
]->section
))
740 *newsyms
++ = symbol_ptr_ptr
[i
];
741 *newsyms
= (asymbol
*) NULL
;
742 symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
745 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
747 coff_symbol_type
*coff_symbol_ptr
;
749 coff_symbol_ptr
= coff_symbol_from (symbol_ptr_ptr
[symbol_index
]);
750 symbol_ptr_ptr
[symbol_index
]->udata
.i
= symbol_index
;
751 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
)
753 combined_entry_type
*s
= coff_symbol_ptr
->native
;
756 BFD_ASSERT (s
->is_sym
);
757 if (s
->u
.syment
.n_sclass
== C_FILE
)
759 if (last_file
!= NULL
)
760 last_file
->n_value
= native_index
;
761 last_file
= &(s
->u
.syment
);
764 /* Modify the symbol values according to their section and
766 fixup_symbol_value (bfd_ptr
, coff_symbol_ptr
, &(s
->u
.syment
));
768 for (i
= 0; i
< s
->u
.syment
.n_numaux
+ 1; i
++)
769 s
[i
].offset
= native_index
++;
775 obj_conv_table_size (bfd_ptr
) = native_index
;
780 /* Run thorough the symbol table again, and fix it so that all
781 pointers to entries are changed to the entries' index in the output
785 coff_mangle_symbols (bfd
*bfd_ptr
)
787 unsigned int symbol_count
= bfd_get_symcount (bfd_ptr
);
788 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
789 unsigned int symbol_index
;
791 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
793 coff_symbol_type
*coff_symbol_ptr
;
795 coff_symbol_ptr
= coff_symbol_from (symbol_ptr_ptr
[symbol_index
]);
796 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
)
799 combined_entry_type
*s
= coff_symbol_ptr
->native
;
801 BFD_ASSERT (s
->is_sym
);
804 /* FIXME: We should use a union here. */
805 s
->u
.syment
.n_value
=
806 (bfd_hostptr_t
) ((combined_entry_type
*)
807 ((bfd_hostptr_t
) s
->u
.syment
.n_value
))->offset
;
812 /* The value is the offset into the line number entries
813 for the symbol's section. On output, the symbol's
814 section should be N_DEBUG. */
815 s
->u
.syment
.n_value
=
816 (coff_symbol_ptr
->symbol
.section
->output_section
->line_filepos
817 + s
->u
.syment
.n_value
* bfd_coff_linesz (bfd_ptr
));
818 coff_symbol_ptr
->symbol
.section
=
819 coff_section_from_bfd_index (bfd_ptr
, N_DEBUG
);
820 BFD_ASSERT (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
);
822 for (i
= 0; i
< s
->u
.syment
.n_numaux
; i
++)
824 combined_entry_type
*a
= s
+ i
+ 1;
826 BFD_ASSERT (! a
->is_sym
);
829 a
->u
.auxent
.x_sym
.x_tagndx
.l
=
830 a
->u
.auxent
.x_sym
.x_tagndx
.p
->offset
;
835 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
836 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
->offset
;
841 a
->u
.auxent
.x_csect
.x_scnlen
.l
=
842 a
->u
.auxent
.x_csect
.x_scnlen
.p
->offset
;
851 coff_fix_symbol_name (bfd
*abfd
,
853 combined_entry_type
*native
,
854 bfd_size_type
*string_size_p
,
855 asection
**debug_string_section_p
,
856 bfd_size_type
*debug_string_size_p
)
858 unsigned int name_length
;
859 union internal_auxent
*auxent
;
860 char *name
= (char *) (symbol
->name
);
864 /* COFF symbols always have names, so we'll make one up. */
865 symbol
->name
= "strange";
866 name
= (char *) symbol
->name
;
868 name_length
= strlen (name
);
870 BFD_ASSERT (native
->is_sym
);
871 if (native
->u
.syment
.n_sclass
== C_FILE
872 && native
->u
.syment
.n_numaux
> 0)
874 unsigned int filnmlen
;
876 if (bfd_coff_force_symnames_in_strings (abfd
))
878 native
->u
.syment
._n
._n_n
._n_offset
=
879 (*string_size_p
+ STRING_SIZE_SIZE
);
880 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
881 *string_size_p
+= 6; /* strlen(".file") + 1 */
884 strncpy (native
->u
.syment
._n
._n_name
, ".file", SYMNMLEN
);
886 BFD_ASSERT (! (native
+ 1)->is_sym
);
887 auxent
= &(native
+ 1)->u
.auxent
;
889 filnmlen
= bfd_coff_filnmlen (abfd
);
891 if (bfd_coff_long_filenames (abfd
))
893 if (name_length
<= filnmlen
)
894 strncpy (auxent
->x_file
.x_fname
, name
, filnmlen
);
897 auxent
->x_file
.x_n
.x_offset
= *string_size_p
+ STRING_SIZE_SIZE
;
898 auxent
->x_file
.x_n
.x_zeroes
= 0;
899 *string_size_p
+= name_length
+ 1;
904 strncpy (auxent
->x_file
.x_fname
, name
, filnmlen
);
905 if (name_length
> filnmlen
)
906 name
[filnmlen
] = '\0';
911 if (name_length
<= SYMNMLEN
&& !bfd_coff_force_symnames_in_strings (abfd
))
912 /* This name will fit into the symbol neatly. */
913 strncpy (native
->u
.syment
._n
._n_name
, symbol
->name
, SYMNMLEN
);
915 else if (!bfd_coff_symname_in_debug (abfd
, &native
->u
.syment
))
917 native
->u
.syment
._n
._n_n
._n_offset
= (*string_size_p
919 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
920 *string_size_p
+= name_length
+ 1;
926 int prefix_len
= bfd_coff_debug_string_prefix_length (abfd
);
928 /* This name should be written into the .debug section. For
929 some reason each name is preceded by a two byte length
930 and also followed by a null byte. FIXME: We assume that
931 the .debug section has already been created, and that it
933 if (*debug_string_section_p
== (asection
*) NULL
)
934 *debug_string_section_p
= bfd_get_section_by_name (abfd
, ".debug");
935 filepos
= bfd_tell (abfd
);
937 bfd_put_32 (abfd
, (bfd_vma
) (name_length
+ 1), buf
);
939 bfd_put_16 (abfd
, (bfd_vma
) (name_length
+ 1), buf
);
941 if (!bfd_set_section_contents (abfd
,
942 *debug_string_section_p
,
944 (file_ptr
) *debug_string_size_p
,
945 (bfd_size_type
) prefix_len
)
946 || !bfd_set_section_contents (abfd
,
947 *debug_string_section_p
,
948 (void *) symbol
->name
,
949 (file_ptr
) (*debug_string_size_p
951 (bfd_size_type
) name_length
+ 1))
953 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
955 native
->u
.syment
._n
._n_n
._n_offset
=
956 *debug_string_size_p
+ prefix_len
;
957 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
958 *debug_string_size_p
+= name_length
+ 1 + prefix_len
;
963 /* We need to keep track of the symbol index so that when we write out
964 the relocs we can get the index for a symbol. This method is a
967 #define set_index(symbol, idx) ((symbol)->udata.i = (idx))
969 /* Write a symbol out to a COFF file. */
972 coff_write_symbol (bfd
*abfd
,
974 combined_entry_type
*native
,
976 bfd_size_type
*string_size_p
,
977 asection
**debug_string_section_p
,
978 bfd_size_type
*debug_string_size_p
)
980 unsigned int numaux
= native
->u
.syment
.n_numaux
;
981 int type
= native
->u
.syment
.n_type
;
982 int n_sclass
= (int) native
->u
.syment
.n_sclass
;
983 asection
*output_section
= symbol
->section
->output_section
984 ? symbol
->section
->output_section
987 bfd_size_type symesz
;
989 BFD_ASSERT (native
->is_sym
);
991 if (native
->u
.syment
.n_sclass
== C_FILE
)
992 symbol
->flags
|= BSF_DEBUGGING
;
994 if (symbol
->flags
& BSF_DEBUGGING
995 && bfd_is_abs_section (symbol
->section
))
996 native
->u
.syment
.n_scnum
= N_DEBUG
;
998 else if (bfd_is_abs_section (symbol
->section
))
999 native
->u
.syment
.n_scnum
= N_ABS
;
1001 else if (bfd_is_und_section (symbol
->section
))
1002 native
->u
.syment
.n_scnum
= N_UNDEF
;
1005 native
->u
.syment
.n_scnum
=
1006 output_section
->target_index
;
1008 coff_fix_symbol_name (abfd
, symbol
, native
, string_size_p
,
1009 debug_string_section_p
, debug_string_size_p
);
1011 symesz
= bfd_coff_symesz (abfd
);
1012 buf
= bfd_alloc (abfd
, symesz
);
1015 bfd_coff_swap_sym_out (abfd
, &native
->u
.syment
, buf
);
1016 if (bfd_bwrite (buf
, symesz
, abfd
) != symesz
)
1018 bfd_release (abfd
, buf
);
1020 if (native
->u
.syment
.n_numaux
> 0)
1022 bfd_size_type auxesz
;
1025 auxesz
= bfd_coff_auxesz (abfd
);
1026 buf
= bfd_alloc (abfd
, auxesz
);
1029 for (j
= 0; j
< native
->u
.syment
.n_numaux
; j
++)
1031 BFD_ASSERT (! (native
+ j
+ 1)->is_sym
);
1032 bfd_coff_swap_aux_out (abfd
,
1033 &((native
+ j
+ 1)->u
.auxent
),
1034 type
, n_sclass
, (int) j
,
1035 native
->u
.syment
.n_numaux
,
1037 if (bfd_bwrite (buf
, auxesz
, abfd
) != auxesz
)
1040 bfd_release (abfd
, buf
);
1043 /* Store the index for use when we write out the relocs. */
1044 set_index (symbol
, *written
);
1046 *written
+= numaux
+ 1;
1050 /* Write out a symbol to a COFF file that does not come from a COFF
1051 file originally. This symbol may have been created by the linker,
1052 or we may be linking a non COFF file to a COFF file. */
1055 coff_write_alien_symbol (bfd
*abfd
,
1057 struct internal_syment
*isym
,
1058 union internal_auxent
*iaux
,
1060 bfd_size_type
*string_size_p
,
1061 asection
**debug_string_section_p
,
1062 bfd_size_type
*debug_string_size_p
)
1064 combined_entry_type
*native
;
1065 combined_entry_type dummy
[2];
1066 asection
*output_section
= symbol
->section
->output_section
1067 ? symbol
->section
->output_section
1069 struct bfd_link_info
*link_info
= coff_data (abfd
)->link_info
;
1072 if ((!link_info
|| link_info
->strip_discarded
)
1073 && !bfd_is_abs_section (symbol
->section
)
1074 && symbol
->section
->output_section
== bfd_abs_section_ptr
)
1078 memset (isym
, 0, sizeof (*isym
));
1082 native
->is_sym
= true;
1083 native
[1].is_sym
= false;
1084 native
->u
.syment
.n_type
= T_NULL
;
1085 native
->u
.syment
.n_flags
= 0;
1086 native
->u
.syment
.n_numaux
= 0;
1087 if (bfd_is_und_section (symbol
->section
))
1089 native
->u
.syment
.n_scnum
= N_UNDEF
;
1090 native
->u
.syment
.n_value
= symbol
->value
;
1092 else if (bfd_is_com_section (symbol
->section
))
1094 native
->u
.syment
.n_scnum
= N_UNDEF
;
1095 native
->u
.syment
.n_value
= symbol
->value
;
1097 else if (symbol
->flags
& BSF_FILE
)
1099 native
->u
.syment
.n_scnum
= N_DEBUG
;
1100 native
->u
.syment
.n_numaux
= 1;
1102 else if (symbol
->flags
& BSF_DEBUGGING
)
1104 /* There isn't much point to writing out a debugging symbol
1105 unless we are prepared to convert it into COFF debugging
1106 format. So, we just ignore them. We must clobber the symbol
1107 name to keep it from being put in the string table. */
1110 memset (isym
, 0, sizeof (*isym
));
1115 native
->u
.syment
.n_scnum
= output_section
->target_index
;
1116 native
->u
.syment
.n_value
= (symbol
->value
1117 + symbol
->section
->output_offset
);
1118 if (! obj_pe (abfd
))
1119 native
->u
.syment
.n_value
+= output_section
->vma
;
1121 /* Copy the any flags from the file header into the symbol.
1124 coff_symbol_type
*c
= coff_symbol_from (symbol
);
1125 if (c
!= (coff_symbol_type
*) NULL
)
1126 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (&c
->symbol
)->flags
;
1130 native
->u
.syment
.n_type
= 0;
1131 if (symbol
->flags
& BSF_FILE
)
1132 native
->u
.syment
.n_sclass
= C_FILE
;
1133 else if (symbol
->flags
& BSF_LOCAL
)
1134 native
->u
.syment
.n_sclass
= C_STAT
;
1135 else if (symbol
->flags
& BSF_WEAK
)
1136 native
->u
.syment
.n_sclass
= obj_pe (abfd
) ? C_NT_WEAK
: C_WEAKEXT
;
1138 native
->u
.syment
.n_sclass
= C_EXT
;
1140 ret
= coff_write_symbol (abfd
, symbol
, native
, written
, string_size_p
,
1141 debug_string_section_p
, debug_string_size_p
);
1143 *isym
= native
->u
.syment
;
1144 if (iaux
!= NULL
&& native
->u
.syment
.n_numaux
)
1145 *iaux
= native
[1].u
.auxent
;
1149 /* Write a native symbol to a COFF file. */
1152 coff_write_native_symbol (bfd
*abfd
,
1153 coff_symbol_type
*symbol
,
1155 bfd_size_type
*string_size_p
,
1156 asection
**debug_string_section_p
,
1157 bfd_size_type
*debug_string_size_p
)
1159 combined_entry_type
*native
= symbol
->native
;
1160 alent
*lineno
= symbol
->lineno
;
1161 struct bfd_link_info
*link_info
= coff_data (abfd
)->link_info
;
1163 if ((!link_info
|| link_info
->strip_discarded
)
1164 && !bfd_is_abs_section (symbol
->symbol
.section
)
1165 && symbol
->symbol
.section
->output_section
== bfd_abs_section_ptr
)
1167 symbol
->symbol
.name
= "";
1171 BFD_ASSERT (native
->is_sym
);
1172 /* If this symbol has an associated line number, we must store the
1173 symbol index in the line number field. We also tag the auxent to
1174 point to the right place in the lineno table. */
1175 if (lineno
&& !symbol
->done_lineno
&& symbol
->symbol
.section
->owner
!= NULL
)
1177 unsigned int count
= 0;
1179 lineno
[count
].u
.offset
= *written
;
1180 if (native
->u
.syment
.n_numaux
)
1182 union internal_auxent
*a
= &((native
+ 1)->u
.auxent
);
1184 a
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1185 symbol
->symbol
.section
->output_section
->moving_line_filepos
;
1188 /* Count and relocate all other linenumbers. */
1190 while (lineno
[count
].line_number
!= 0)
1192 lineno
[count
].u
.offset
+=
1193 (symbol
->symbol
.section
->output_section
->vma
1194 + symbol
->symbol
.section
->output_offset
);
1197 symbol
->done_lineno
= true;
1199 if (! bfd_is_const_section (symbol
->symbol
.section
->output_section
))
1200 symbol
->symbol
.section
->output_section
->moving_line_filepos
+=
1201 count
* bfd_coff_linesz (abfd
);
1204 return coff_write_symbol (abfd
, &(symbol
->symbol
), native
, written
,
1205 string_size_p
, debug_string_section_p
,
1206 debug_string_size_p
);
1210 null_error_handler (const char *fmt ATTRIBUTE_UNUSED
,
1211 va_list ap ATTRIBUTE_UNUSED
)
1215 /* Write out the COFF symbols. */
1218 coff_write_symbols (bfd
*abfd
)
1220 bfd_size_type string_size
;
1221 asection
*debug_string_section
;
1222 bfd_size_type debug_string_size
;
1224 unsigned int limit
= bfd_get_symcount (abfd
);
1225 bfd_vma written
= 0;
1229 debug_string_section
= NULL
;
1230 debug_string_size
= 0;
1232 /* If this target supports long section names, they must be put into
1233 the string table. This is supported by PE. This code must
1234 handle section names just as they are handled in
1235 coff_write_object_contents. */
1236 if (bfd_coff_long_section_names (abfd
))
1240 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1244 len
= strlen (o
->name
);
1246 string_size
+= len
+ 1;
1250 /* Seek to the right place. */
1251 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
1254 /* Output all the symbols we have. */
1256 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1258 asymbol
*symbol
= *p
;
1259 coff_symbol_type
*c_symbol
= coff_symbol_from (symbol
);
1261 if (c_symbol
== (coff_symbol_type
*) NULL
1262 || c_symbol
->native
== (combined_entry_type
*) NULL
)
1264 if (!coff_write_alien_symbol (abfd
, symbol
, NULL
, NULL
, &written
,
1265 &string_size
, &debug_string_section
,
1266 &debug_string_size
))
1271 if (coff_backend_info (abfd
)->_bfd_coff_classify_symbol
!= NULL
)
1273 bfd_error_handler_type current_error_handler
;
1274 enum coff_symbol_classification sym_class
;
1275 unsigned char *n_sclass
;
1277 /* Suppress error reporting by bfd_coff_classify_symbol.
1278 Error messages can be generated when we are processing a local
1279 symbol which has no associated section and we do not have to
1280 worry about this, all we need to know is that it is local. */
1281 current_error_handler
= bfd_set_error_handler (null_error_handler
);
1282 BFD_ASSERT (c_symbol
->native
->is_sym
);
1283 sym_class
= bfd_coff_classify_symbol (abfd
,
1284 &c_symbol
->native
->u
.syment
);
1285 (void) bfd_set_error_handler (current_error_handler
);
1287 n_sclass
= &c_symbol
->native
->u
.syment
.n_sclass
;
1289 /* If the symbol class has been changed (eg objcopy/ld script/etc)
1290 we cannot retain the existing sclass from the original symbol.
1291 Weak symbols only have one valid sclass, so just set it always.
1292 If it is not local class and should be, set it C_STAT.
1293 If it is global and not classified as global, or if it is
1294 weak (which is also classified as global), set it C_EXT. */
1296 if (symbol
->flags
& BSF_WEAK
)
1297 *n_sclass
= obj_pe (abfd
) ? C_NT_WEAK
: C_WEAKEXT
;
1298 else if (symbol
->flags
& BSF_LOCAL
&& sym_class
!= COFF_SYMBOL_LOCAL
)
1300 else if (symbol
->flags
& BSF_GLOBAL
1301 && (sym_class
!= COFF_SYMBOL_GLOBAL
1303 || *n_sclass
== C_NT_WEAK
1305 || *n_sclass
== C_WEAKEXT
))
1306 c_symbol
->native
->u
.syment
.n_sclass
= C_EXT
;
1309 if (!coff_write_native_symbol (abfd
, c_symbol
, &written
,
1310 &string_size
, &debug_string_section
,
1311 &debug_string_size
))
1316 obj_raw_syment_count (abfd
) = written
;
1318 /* Now write out strings. */
1319 if (string_size
!= 0)
1321 unsigned int size
= string_size
+ STRING_SIZE_SIZE
;
1322 bfd_byte buffer
[STRING_SIZE_SIZE
];
1324 #if STRING_SIZE_SIZE == 4
1325 H_PUT_32 (abfd
, size
, buffer
);
1327 #error Change H_PUT_32
1329 if (bfd_bwrite ((void *) buffer
, (bfd_size_type
) sizeof (buffer
), abfd
)
1333 /* Handle long section names. This code must handle section
1334 names just as they are handled in coff_write_object_contents. */
1335 if (bfd_coff_long_section_names (abfd
))
1339 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1343 len
= strlen (o
->name
);
1346 if (bfd_bwrite (o
->name
, (bfd_size_type
) (len
+ 1), abfd
)
1353 for (p
= abfd
->outsymbols
, i
= 0;
1358 size_t name_length
= strlen (q
->name
);
1359 coff_symbol_type
*c_symbol
= coff_symbol_from (q
);
1362 /* Figure out whether the symbol name should go in the string
1363 table. Symbol names that are short enough are stored
1364 directly in the syment structure. File names permit a
1365 different, longer, length in the syment structure. On
1366 XCOFF, some symbol names are stored in the .debug section
1367 rather than in the string table. */
1369 if (c_symbol
== NULL
1370 || c_symbol
->native
== NULL
)
1371 /* This is not a COFF symbol, so it certainly is not a
1372 file name, nor does it go in the .debug section. */
1373 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1375 else if (! c_symbol
->native
->is_sym
)
1376 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1378 else if (bfd_coff_symname_in_debug (abfd
,
1379 &c_symbol
->native
->u
.syment
))
1380 /* This symbol name is in the XCOFF .debug section.
1381 Don't write it into the string table. */
1382 maxlen
= name_length
;
1384 else if (c_symbol
->native
->u
.syment
.n_sclass
== C_FILE
1385 && c_symbol
->native
->u
.syment
.n_numaux
> 0)
1387 if (bfd_coff_force_symnames_in_strings (abfd
))
1389 if (bfd_bwrite (".file", (bfd_size_type
) 6, abfd
) != 6)
1392 maxlen
= bfd_coff_filnmlen (abfd
);
1395 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1397 if (name_length
> maxlen
)
1399 if (bfd_bwrite ((void *) (q
->name
), (bfd_size_type
) name_length
+ 1,
1400 abfd
) != name_length
+ 1)
1407 /* We would normally not write anything here, but we'll write
1408 out 4 so that any stupid coff reader which tries to read the
1409 string table even when there isn't one won't croak. */
1410 unsigned int size
= STRING_SIZE_SIZE
;
1411 bfd_byte buffer
[STRING_SIZE_SIZE
];
1413 #if STRING_SIZE_SIZE == 4
1414 H_PUT_32 (abfd
, size
, buffer
);
1416 #error Change H_PUT_32
1418 if (bfd_bwrite ((void *) buffer
, (bfd_size_type
) STRING_SIZE_SIZE
, abfd
)
1419 != STRING_SIZE_SIZE
)
1423 /* Make sure the .debug section was created to be the correct size.
1424 We should create it ourselves on the fly, but we don't because
1425 BFD won't let us write to any section until we know how large all
1426 the sections are. We could still do it by making another pass
1427 over the symbols. FIXME. */
1428 BFD_ASSERT (debug_string_size
== 0
1429 || (debug_string_section
!= (asection
*) NULL
1430 && (BFD_ALIGN (debug_string_size
,
1431 1 << debug_string_section
->alignment_power
)
1432 == debug_string_section
->size
)));
1438 coff_write_linenumbers (bfd
*abfd
)
1441 bfd_size_type linesz
;
1444 linesz
= bfd_coff_linesz (abfd
);
1445 buff
= bfd_alloc (abfd
, linesz
);
1448 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
1450 if (s
->lineno_count
)
1452 asymbol
**q
= abfd
->outsymbols
;
1453 if (bfd_seek (abfd
, s
->line_filepos
, SEEK_SET
) != 0)
1455 /* Find all the linenumbers in this section. */
1459 if (p
->section
->output_section
== s
)
1462 BFD_SEND (bfd_asymbol_bfd (p
), _get_lineno
,
1463 (bfd_asymbol_bfd (p
), p
));
1466 /* Found a linenumber entry, output. */
1467 struct internal_lineno out
;
1469 memset ((void *) & out
, 0, sizeof (out
));
1471 out
.l_addr
.l_symndx
= l
->u
.offset
;
1472 bfd_coff_swap_lineno_out (abfd
, &out
, buff
);
1473 if (bfd_bwrite (buff
, (bfd_size_type
) linesz
, abfd
)
1477 while (l
->line_number
)
1479 out
.l_lnno
= l
->line_number
;
1480 out
.l_addr
.l_symndx
= l
->u
.offset
;
1481 bfd_coff_swap_lineno_out (abfd
, &out
, buff
);
1482 if (bfd_bwrite (buff
, (bfd_size_type
) linesz
, abfd
)
1493 bfd_release (abfd
, buff
);
1498 coff_get_lineno (bfd
*ignore_abfd ATTRIBUTE_UNUSED
, asymbol
*symbol
)
1500 return coffsymbol (symbol
)->lineno
;
1503 /* This function transforms the offsets into the symbol table into
1504 pointers to syments. */
1507 coff_pointerize_aux (bfd
*abfd
,
1508 combined_entry_type
*table_base
,
1509 combined_entry_type
*symbol
,
1510 unsigned int indaux
,
1511 combined_entry_type
*auxent
,
1512 combined_entry_type
*table_end
)
1514 unsigned int type
= symbol
->u
.syment
.n_type
;
1515 unsigned int n_sclass
= symbol
->u
.syment
.n_sclass
;
1517 BFD_ASSERT (symbol
->is_sym
);
1518 if (coff_backend_info (abfd
)->_bfd_coff_pointerize_aux_hook
)
1520 if ((*coff_backend_info (abfd
)->_bfd_coff_pointerize_aux_hook
)
1521 (abfd
, table_base
, symbol
, indaux
, auxent
))
1525 /* Don't bother if this is a file or a section. */
1526 if (n_sclass
== C_STAT
&& type
== T_NULL
)
1528 if (n_sclass
== C_FILE
)
1530 if (n_sclass
== C_DWARF
)
1533 BFD_ASSERT (! auxent
->is_sym
);
1534 /* Otherwise patch up. */
1535 #define N_TMASK coff_data (abfd)->local_n_tmask
1536 #define N_BTSHFT coff_data (abfd)->local_n_btshft
1538 if ((ISFCN (type
) || ISTAG (n_sclass
) || n_sclass
== C_BLOCK
1539 || n_sclass
== C_FCN
)
1540 && auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
> 0
1541 && auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
1542 < (long) obj_raw_syment_count (abfd
)
1543 && table_base
+ auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
1546 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
=
1547 table_base
+ auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
1548 auxent
->fix_end
= 1;
1551 /* A negative tagndx is meaningless, but the SCO 3.2v4 cc can
1552 generate one, so we must be careful to ignore it. */
1553 if ((unsigned long) auxent
->u
.auxent
.x_sym
.x_tagndx
.l
1554 < obj_raw_syment_count (abfd
)
1555 && table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
< table_end
)
1557 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
=
1558 table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
;
1559 auxent
->fix_tag
= 1;
1563 /* Allocate space for the ".debug" section, and read it.
1564 We did not read the debug section until now, because
1565 we didn't want to go to the trouble until someone needed it. */
1568 build_debug_section (bfd
*abfd
, asection
** sect_return
)
1570 char *debug_section
;
1572 bfd_size_type sec_size
;
1574 asection
*sect
= bfd_get_section_by_name (abfd
, ".debug");
1578 bfd_set_error (bfd_error_no_debug_section
);
1582 /* Seek to the beginning of the `.debug' section and read it.
1583 Save the current position first; it is needed by our caller.
1584 Then read debug section and reset the file pointer. */
1586 position
= bfd_tell (abfd
);
1587 if (bfd_seek (abfd
, sect
->filepos
, SEEK_SET
) != 0)
1590 sec_size
= sect
->size
;
1591 debug_section
= (char *) _bfd_alloc_and_read (abfd
, sec_size
, sec_size
);
1592 if (debug_section
== NULL
)
1595 if (bfd_seek (abfd
, position
, SEEK_SET
) != 0)
1598 * sect_return
= sect
;
1599 return debug_section
;
1602 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
1603 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
1604 be \0-terminated. */
1607 copy_name (bfd
*abfd
, char *name
, size_t maxlen
)
1612 for (len
= 0; len
< maxlen
; ++len
)
1613 if (name
[len
] == '\0')
1616 if ((newname
= (char *) bfd_alloc (abfd
, (bfd_size_type
) len
+ 1)) == NULL
)
1619 strncpy (newname
, name
, len
);
1620 newname
[len
] = '\0';
1624 /* Read in the external symbols. */
1627 _bfd_coff_get_external_symbols (bfd
*abfd
)
1633 if (obj_coff_external_syms (abfd
) != NULL
)
1636 symesz
= bfd_coff_symesz (abfd
);
1637 if (_bfd_mul_overflow (obj_raw_syment_count (abfd
), symesz
, &size
))
1639 bfd_set_error (bfd_error_file_truncated
);
1646 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
1648 syms
= _bfd_malloc_and_read (abfd
, size
, size
);
1649 obj_coff_external_syms (abfd
) = syms
;
1650 return syms
!= NULL
;
1653 /* Read in the external strings. The strings are not loaded until
1654 they are needed. This is because we have no simple way of
1655 detecting a missing string table in an archive. If the strings
1656 are loaded then the STRINGS and STRINGS_LEN fields in the
1657 coff_tdata structure will be set. */
1660 _bfd_coff_read_string_table (bfd
*abfd
)
1662 char extstrsize
[STRING_SIZE_SIZE
];
1663 bfd_size_type strsize
;
1668 if (obj_coff_strings (abfd
) != NULL
)
1669 return obj_coff_strings (abfd
);
1671 if (obj_sym_filepos (abfd
) == 0)
1673 bfd_set_error (bfd_error_no_symbols
);
1677 pos
= obj_sym_filepos (abfd
);
1678 pos
+= obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
1679 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
1682 if (bfd_bread (extstrsize
, (bfd_size_type
) sizeof extstrsize
, abfd
)
1683 != sizeof extstrsize
)
1685 if (bfd_get_error () != bfd_error_file_truncated
)
1688 /* There is no string table. */
1689 strsize
= STRING_SIZE_SIZE
;
1693 #if STRING_SIZE_SIZE == 4
1694 strsize
= H_GET_32 (abfd
, extstrsize
);
1696 #error Change H_GET_32
1700 filesize
= bfd_get_file_size (abfd
);
1701 if (strsize
< STRING_SIZE_SIZE
1702 || (filesize
!= 0 && strsize
> filesize
))
1705 /* xgettext: c-format */
1706 (_("%pB: bad string table size %" PRIu64
), abfd
, (uint64_t) strsize
);
1707 bfd_set_error (bfd_error_bad_value
);
1711 strings
= (char *) bfd_malloc (strsize
+ 1);
1712 if (strings
== NULL
)
1715 /* PR 17521 file: 079-54929-0.004.
1716 A corrupt file could contain an index that points into the first
1717 STRING_SIZE_SIZE bytes of the string table, so make sure that
1719 memset (strings
, 0, STRING_SIZE_SIZE
);
1721 if (bfd_bread (strings
+ STRING_SIZE_SIZE
, strsize
- STRING_SIZE_SIZE
, abfd
)
1722 != strsize
- STRING_SIZE_SIZE
)
1728 obj_coff_strings (abfd
) = strings
;
1729 obj_coff_strings_len (abfd
) = strsize
;
1730 /* Terminate the string table, just in case. */
1731 strings
[strsize
] = 0;
1735 /* Free up the external symbols and strings read from a COFF file. */
1738 _bfd_coff_free_symbols (bfd
*abfd
)
1740 if (! bfd_family_coff (abfd
))
1743 if (obj_coff_external_syms (abfd
) != NULL
1744 && ! obj_coff_keep_syms (abfd
))
1746 free (obj_coff_external_syms (abfd
));
1747 obj_coff_external_syms (abfd
) = NULL
;
1750 if (obj_coff_strings (abfd
) != NULL
1751 && ! obj_coff_keep_strings (abfd
))
1753 free (obj_coff_strings (abfd
));
1754 obj_coff_strings (abfd
) = NULL
;
1755 obj_coff_strings_len (abfd
) = 0;
1761 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
1762 knit the symbol names into a normalized form. By normalized here I
1763 mean that all symbols have an n_offset pointer that points to a null-
1764 terminated string. */
1766 combined_entry_type
*
1767 coff_get_normalized_symtab (bfd
*abfd
)
1769 combined_entry_type
*internal
;
1770 combined_entry_type
*internal_ptr
;
1771 combined_entry_type
*symbol_ptr
;
1772 combined_entry_type
*internal_end
;
1776 const char *string_table
= NULL
;
1777 asection
* debug_sec
= NULL
;
1778 char *debug_sec_data
= NULL
;
1781 if (obj_raw_syments (abfd
) != NULL
)
1782 return obj_raw_syments (abfd
);
1784 if (! _bfd_coff_get_external_symbols (abfd
))
1787 size
= obj_raw_syment_count (abfd
);
1788 /* Check for integer overflow. */
1789 if (size
> (bfd_size_type
) -1 / sizeof (combined_entry_type
))
1791 size
*= sizeof (combined_entry_type
);
1792 internal
= (combined_entry_type
*) bfd_zalloc (abfd
, size
);
1793 if (internal
== NULL
&& size
!= 0)
1795 internal_end
= internal
+ obj_raw_syment_count (abfd
);
1797 raw_src
= (char *) obj_coff_external_syms (abfd
);
1799 /* Mark the end of the symbols. */
1800 symesz
= bfd_coff_symesz (abfd
);
1801 raw_end
= (char *) raw_src
+ obj_raw_syment_count (abfd
) * symesz
;
1803 /* FIXME SOMEDAY. A string table size of zero is very weird, but
1804 probably possible. If one shows up, it will probably kill us. */
1806 /* Swap all the raw entries. */
1807 for (internal_ptr
= internal
;
1809 raw_src
+= symesz
, internal_ptr
++)
1813 bfd_coff_swap_sym_in (abfd
, (void *) raw_src
,
1814 (void *) & internal_ptr
->u
.syment
);
1815 symbol_ptr
= internal_ptr
;
1816 internal_ptr
->is_sym
= true;
1818 /* PR 17512: Prevent buffer overrun. */
1819 if (symbol_ptr
->u
.syment
.n_numaux
> ((raw_end
- 1) - raw_src
) / symesz
)
1821 bfd_release (abfd
, internal
);
1826 i
< symbol_ptr
->u
.syment
.n_numaux
;
1832 bfd_coff_swap_aux_in (abfd
, (void *) raw_src
,
1833 symbol_ptr
->u
.syment
.n_type
,
1834 symbol_ptr
->u
.syment
.n_sclass
,
1835 (int) i
, symbol_ptr
->u
.syment
.n_numaux
,
1836 &(internal_ptr
->u
.auxent
));
1838 internal_ptr
->is_sym
= false;
1839 coff_pointerize_aux (abfd
, internal
, symbol_ptr
, i
,
1840 internal_ptr
, internal_end
);
1844 /* Free the raw symbols. */
1845 if (obj_coff_external_syms (abfd
) != NULL
1846 && ! obj_coff_keep_syms (abfd
))
1848 free (obj_coff_external_syms (abfd
));
1849 obj_coff_external_syms (abfd
) = NULL
;
1852 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
1855 BFD_ASSERT (internal_ptr
->is_sym
);
1857 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
1858 && internal_ptr
->u
.syment
.n_numaux
> 0)
1860 combined_entry_type
* aux
= internal_ptr
+ 1;
1862 /* Make a file symbol point to the name in the auxent, since
1863 the text ".file" is redundant. */
1864 BFD_ASSERT (! aux
->is_sym
);
1866 if (aux
->u
.auxent
.x_file
.x_n
.x_zeroes
== 0)
1868 /* The filename is a long one, point into the string table. */
1869 if (string_table
== NULL
)
1871 string_table
= _bfd_coff_read_string_table (abfd
);
1872 if (string_table
== NULL
)
1876 if ((bfd_size_type
)(aux
->u
.auxent
.x_file
.x_n
.x_offset
)
1877 >= obj_coff_strings_len (abfd
))
1878 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1880 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1881 (bfd_hostptr_t
) (string_table
+ (aux
->u
.auxent
.x_file
.x_n
.x_offset
));
1885 /* Ordinary short filename, put into memory anyway. The
1886 Microsoft PE tools sometimes store a filename in
1887 multiple AUX entries. */
1888 if (internal_ptr
->u
.syment
.n_numaux
> 1
1889 && coff_data (abfd
)->pe
)
1890 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1893 aux
->u
.auxent
.x_file
.x_fname
,
1894 internal_ptr
->u
.syment
.n_numaux
* symesz
);
1896 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1899 aux
->u
.auxent
.x_file
.x_fname
,
1900 (size_t) bfd_coff_filnmlen (abfd
)));
1905 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0)
1907 /* This is a "short" name. Make it long. */
1911 /* Find the length of this string without walking into memory
1913 for (i
= 0; i
< 8; ++i
)
1914 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0')
1917 newstring
= (char *) bfd_zalloc (abfd
, (bfd_size_type
) (i
+ 1));
1918 if (newstring
== NULL
)
1920 strncpy (newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
);
1921 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) newstring
;
1922 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1924 else if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
== 0)
1925 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) "";
1926 else if (!bfd_coff_symname_in_debug (abfd
, &internal_ptr
->u
.syment
))
1928 /* Long name already. Point symbol at the string in the
1930 if (string_table
== NULL
)
1932 string_table
= _bfd_coff_read_string_table (abfd
);
1933 if (string_table
== NULL
)
1936 if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
>= obj_coff_strings_len (abfd
)
1937 || string_table
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
< string_table
)
1938 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1940 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1943 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
));
1947 /* Long name in debug section. Very similar. */
1948 if (debug_sec_data
== NULL
)
1949 debug_sec_data
= build_debug_section (abfd
, & debug_sec
);
1950 if (debug_sec_data
!= NULL
)
1952 BFD_ASSERT (debug_sec
!= NULL
);
1953 /* PR binutils/17512: Catch out of range offsets into the debug data. */
1954 if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
> debug_sec
->size
1955 || debug_sec_data
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
< debug_sec_data
)
1956 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1958 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
)
1959 (debug_sec_data
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
1962 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) "";
1965 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
1968 obj_raw_syments (abfd
) = internal
;
1969 BFD_ASSERT (obj_raw_syment_count (abfd
)
1970 == (unsigned int) (internal_ptr
- internal
));
1976 coff_get_reloc_upper_bound (bfd
*abfd
, sec_ptr asect
)
1978 if (bfd_get_format (abfd
) != bfd_object
)
1980 bfd_set_error (bfd_error_invalid_operation
);
1983 #if SIZEOF_LONG == SIZEOF_INT
1984 if (asect
->reloc_count
>= LONG_MAX
/ sizeof (arelent
*))
1986 bfd_set_error (bfd_error_file_too_big
);
1990 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
1994 coff_make_empty_symbol (bfd
*abfd
)
1996 size_t amt
= sizeof (coff_symbol_type
);
1997 coff_symbol_type
*new_symbol
= (coff_symbol_type
*) bfd_zalloc (abfd
, amt
);
1999 if (new_symbol
== NULL
)
2001 new_symbol
->symbol
.section
= 0;
2002 new_symbol
->native
= NULL
;
2003 new_symbol
->lineno
= NULL
;
2004 new_symbol
->done_lineno
= false;
2005 new_symbol
->symbol
.the_bfd
= abfd
;
2007 return & new_symbol
->symbol
;
2010 /* Make a debugging symbol. */
2013 coff_bfd_make_debug_symbol (bfd
*abfd
,
2014 void * ptr ATTRIBUTE_UNUSED
,
2015 unsigned long sz ATTRIBUTE_UNUSED
)
2017 size_t amt
= sizeof (coff_symbol_type
);
2018 coff_symbol_type
*new_symbol
= (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
2020 if (new_symbol
== NULL
)
2022 /* @@ The 10 is a guess at a plausible maximum number of aux entries
2023 (but shouldn't be a constant). */
2024 amt
= sizeof (combined_entry_type
) * 10;
2025 new_symbol
->native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
2026 if (!new_symbol
->native
)
2028 new_symbol
->native
->is_sym
= true;
2029 new_symbol
->symbol
.section
= bfd_abs_section_ptr
;
2030 new_symbol
->symbol
.flags
= BSF_DEBUGGING
;
2031 new_symbol
->lineno
= NULL
;
2032 new_symbol
->done_lineno
= false;
2033 new_symbol
->symbol
.the_bfd
= abfd
;
2035 return & new_symbol
->symbol
;
2039 coff_get_symbol_info (bfd
*abfd
, asymbol
*symbol
, symbol_info
*ret
)
2041 bfd_symbol_info (symbol
, ret
);
2043 if (coffsymbol (symbol
)->native
!= NULL
2044 && coffsymbol (symbol
)->native
->fix_value
2045 && coffsymbol (symbol
)->native
->is_sym
)
2046 ret
->value
= coffsymbol (symbol
)->native
->u
.syment
.n_value
-
2047 (bfd_hostptr_t
) obj_raw_syments (abfd
);
2050 /* Print out information about COFF symbol. */
2053 coff_print_symbol (bfd
*abfd
,
2056 bfd_print_symbol_type how
)
2058 FILE * file
= (FILE *) filep
;
2062 case bfd_print_symbol_name
:
2063 fprintf (file
, "%s", symbol
->name
);
2066 case bfd_print_symbol_more
:
2067 fprintf (file
, "coff %s %s",
2068 coffsymbol (symbol
)->native
? "n" : "g",
2069 coffsymbol (symbol
)->lineno
? "l" : " ");
2072 case bfd_print_symbol_all
:
2073 if (coffsymbol (symbol
)->native
)
2077 combined_entry_type
*combined
= coffsymbol (symbol
)->native
;
2078 combined_entry_type
*root
= obj_raw_syments (abfd
);
2079 struct lineno_cache_entry
*l
= coffsymbol (symbol
)->lineno
;
2081 fprintf (file
, "[%3ld]", (long) (combined
- root
));
2083 /* PR 17512: file: 079-33786-0.001:0.1. */
2084 if (combined
< obj_raw_syments (abfd
)
2085 || combined
>= obj_raw_syments (abfd
) + obj_raw_syment_count (abfd
))
2087 fprintf (file
, _("<corrupt info> %s"), symbol
->name
);
2091 BFD_ASSERT (combined
->is_sym
);
2092 if (! combined
->fix_value
)
2093 val
= (bfd_vma
) combined
->u
.syment
.n_value
;
2095 val
= combined
->u
.syment
.n_value
- (bfd_hostptr_t
) root
;
2097 fprintf (file
, "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x",
2098 combined
->u
.syment
.n_scnum
,
2099 combined
->u
.syment
.n_flags
,
2100 combined
->u
.syment
.n_type
,
2101 combined
->u
.syment
.n_sclass
,
2102 combined
->u
.syment
.n_numaux
);
2103 bfd_fprintf_vma (abfd
, file
, val
);
2104 fprintf (file
, " %s", symbol
->name
);
2106 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
2108 combined_entry_type
*auxp
= combined
+ aux
+ 1;
2111 BFD_ASSERT (! auxp
->is_sym
);
2113 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.p
- root
;
2115 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.l
;
2117 fprintf (file
, "\n");
2119 if (bfd_coff_print_aux (abfd
, file
, root
, combined
, auxp
, aux
))
2122 switch (combined
->u
.syment
.n_sclass
)
2125 fprintf (file
, "File ");
2129 fprintf (file
, "AUX scnlen 0x%lx nreloc %ld",
2130 (unsigned long) auxp
->u
.auxent
.x_sect
.x_scnlen
,
2131 auxp
->u
.auxent
.x_sect
.x_nreloc
);
2135 if (combined
->u
.syment
.n_type
== T_NULL
)
2136 /* Probably a section symbol ? */
2138 fprintf (file
, "AUX scnlen 0x%lx nreloc %d nlnno %d",
2139 (unsigned long) auxp
->u
.auxent
.x_scn
.x_scnlen
,
2140 auxp
->u
.auxent
.x_scn
.x_nreloc
,
2141 auxp
->u
.auxent
.x_scn
.x_nlinno
);
2142 if (auxp
->u
.auxent
.x_scn
.x_checksum
!= 0
2143 || auxp
->u
.auxent
.x_scn
.x_associated
!= 0
2144 || auxp
->u
.auxent
.x_scn
.x_comdat
!= 0)
2145 fprintf (file
, " checksum 0x%lx assoc %d comdat %d",
2146 auxp
->u
.auxent
.x_scn
.x_checksum
,
2147 auxp
->u
.auxent
.x_scn
.x_associated
,
2148 auxp
->u
.auxent
.x_scn
.x_comdat
);
2154 if (ISFCN (combined
->u
.syment
.n_type
))
2159 next
= (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2162 next
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2163 llnos
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
2165 "AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld",
2167 (unsigned long) auxp
->u
.auxent
.x_sym
.x_misc
.x_fsize
,
2173 fprintf (file
, "AUX lnno %d size 0x%x tagndx %ld",
2174 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
2175 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
,
2178 fprintf (file
, " endndx %ld",
2180 (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2188 fprintf (file
, "\n%s :", l
->u
.sym
->name
);
2190 while (l
->line_number
)
2192 if (l
->line_number
> 0)
2194 fprintf (file
, "\n%4d : ", l
->line_number
);
2195 bfd_fprintf_vma (abfd
, file
, l
->u
.offset
+ symbol
->section
->vma
);
2203 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
2204 fprintf (file
, " %-5s %s %s %s",
2205 symbol
->section
->name
,
2206 coffsymbol (symbol
)->native
? "n" : "g",
2207 coffsymbol (symbol
)->lineno
? "l" : " ",
2213 /* Return whether a symbol name implies a local symbol. In COFF,
2214 local symbols generally start with ``.L''. Most targets use this
2215 function for the is_local_label_name entry point, but some may
2219 _bfd_coff_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
2222 return name
[0] == '.' && name
[1] == 'L';
2225 /* Provided a BFD, a section and an offset (in bytes, not octets) into the
2226 section, calculate and return the name of the source file and the line
2227 nearest to the wanted location. */
2230 coff_find_nearest_line_with_names (bfd
*abfd
,
2234 const char **filename_ptr
,
2235 const char **functionname_ptr
,
2236 unsigned int *line_ptr
,
2237 const struct dwarf_debug_section
*debug_sections
)
2241 unsigned int line_base
;
2242 coff_data_type
*cof
= coff_data (abfd
);
2243 /* Run through the raw syments if available. */
2244 combined_entry_type
*p
;
2245 combined_entry_type
*pend
;
2247 struct coff_section_tdata
*sec_data
;
2250 /* Before looking through the symbol table, try to use a .stab
2251 section to find the information. */
2252 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2253 &found
, filename_ptr
,
2254 functionname_ptr
, line_ptr
,
2255 &coff_data(abfd
)->line_info
))
2261 /* Also try examining DWARF2 debugging information. */
2262 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
2263 filename_ptr
, functionname_ptr
,
2264 line_ptr
, NULL
, debug_sections
,
2265 &coff_data(abfd
)->dwarf2_find_line_info
))
2268 sec_data
= coff_section_data (abfd
, section
);
2270 /* If the DWARF lookup failed, but there is DWARF information available
2271 then the problem might be that the file has been rebased. This tool
2272 changes the VMAs of all the sections, but it does not update the DWARF
2273 information. So try again, using a bias against the address sought. */
2274 if (coff_data (abfd
)->dwarf2_find_line_info
!= NULL
)
2276 bfd_signed_vma bias
= 0;
2278 /* Create a cache of the result for the next call. */
2279 if (sec_data
== NULL
&& section
->owner
== abfd
)
2281 amt
= sizeof (struct coff_section_tdata
);
2282 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
2283 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2286 if (sec_data
!= NULL
&& sec_data
->saved_bias
)
2287 bias
= sec_data
->saved_bias
;
2290 bias
= _bfd_dwarf2_find_symbol_bias (symbols
,
2291 & coff_data (abfd
)->dwarf2_find_line_info
);
2295 sec_data
->saved_bias
= true;
2296 sec_data
->bias
= bias
;
2301 && _bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
,
2303 filename_ptr
, functionname_ptr
,
2304 line_ptr
, NULL
, debug_sections
,
2305 &coff_data(abfd
)->dwarf2_find_line_info
))
2310 *functionname_ptr
= 0;
2313 /* Don't try and find line numbers in a non coff file. */
2314 if (!bfd_family_coff (abfd
))
2320 /* Find the first C_FILE symbol. */
2321 p
= cof
->raw_syments
;
2325 pend
= p
+ cof
->raw_syment_count
;
2328 BFD_ASSERT (p
->is_sym
);
2329 if (p
->u
.syment
.n_sclass
== C_FILE
)
2331 p
+= 1 + p
->u
.syment
.n_numaux
;
2339 /* Look through the C_FILE symbols to find the best one. */
2340 sec_vma
= bfd_section_vma (section
);
2341 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2342 maxdiff
= (bfd_vma
) 0 - (bfd_vma
) 1;
2346 combined_entry_type
*p2
;
2348 for (p2
= p
+ 1 + p
->u
.syment
.n_numaux
;
2350 p2
+= 1 + p2
->u
.syment
.n_numaux
)
2352 BFD_ASSERT (p2
->is_sym
);
2353 if (p2
->u
.syment
.n_scnum
> 0
2355 == coff_section_from_bfd_index (abfd
,
2356 p2
->u
.syment
.n_scnum
)))
2358 if (p2
->u
.syment
.n_sclass
== C_FILE
)
2367 file_addr
= (bfd_vma
) p2
->u
.syment
.n_value
;
2368 /* PR 11512: Include the section address of the function name symbol. */
2369 if (p2
->u
.syment
.n_scnum
> 0)
2370 file_addr
+= coff_section_from_bfd_index (abfd
,
2371 p2
->u
.syment
.n_scnum
)->vma
;
2372 /* We use <= MAXDIFF here so that if we get a zero length
2373 file, we actually use the next file entry. */
2375 && offset
+ sec_vma
>= file_addr
2376 && offset
+ sec_vma
- file_addr
<= maxdiff
)
2378 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2379 maxdiff
= offset
+ sec_vma
- p2
->u
.syment
.n_value
;
2382 if (p
->u
.syment
.n_value
>= cof
->raw_syment_count
)
2385 /* Avoid endless loops on erroneous files by ensuring that
2386 we always move forward in the file. */
2387 if (p
>= cof
->raw_syments
+ p
->u
.syment
.n_value
)
2390 p
= cof
->raw_syments
+ p
->u
.syment
.n_value
;
2391 if (!p
->is_sym
|| p
->u
.syment
.n_sclass
!= C_FILE
)
2396 if (section
->lineno_count
== 0)
2398 *functionname_ptr
= NULL
;
2403 /* Now wander though the raw linenumbers of the section.
2404 If we have been called on this section before, and the offset
2405 we want is further down then we can prime the lookup loop. */
2406 if (sec_data
!= NULL
2408 && offset
>= sec_data
->offset
)
2411 *functionname_ptr
= sec_data
->function
;
2412 line_base
= sec_data
->line_base
;
2420 if (section
->lineno
!= NULL
)
2422 bfd_vma last_value
= 0;
2424 l
= §ion
->lineno
[i
];
2426 for (; i
< section
->lineno_count
; i
++)
2428 if (l
->line_number
== 0)
2430 /* Get the symbol this line number points at. */
2431 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
2432 if (coff
->symbol
.value
> offset
)
2435 *functionname_ptr
= coff
->symbol
.name
;
2436 last_value
= coff
->symbol
.value
;
2439 combined_entry_type
*s
= coff
->native
;
2441 BFD_ASSERT (s
->is_sym
);
2442 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2444 /* In XCOFF a debugging symbol can follow the
2446 if (((size_t) ((char *) s
- (char *) obj_raw_syments (abfd
))
2447 < obj_raw_syment_count (abfd
) * sizeof (*s
))
2448 && s
->u
.syment
.n_scnum
== N_DEBUG
)
2449 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2451 /* S should now point to the .bf of the function. */
2452 if (((size_t) ((char *) s
- (char *) obj_raw_syments (abfd
))
2453 < obj_raw_syment_count (abfd
) * sizeof (*s
))
2454 && s
->u
.syment
.n_numaux
)
2456 /* The linenumber is stored in the auxent. */
2457 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
2459 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
2460 *line_ptr
= line_base
;
2466 if (l
->u
.offset
> offset
)
2468 *line_ptr
= l
->line_number
+ line_base
- 1;
2473 /* If we fell off the end of the loop, then assume that this
2474 symbol has no line number info. Otherwise, symbols with no
2475 line number info get reported with the line number of the
2476 last line of the last symbol which does have line number
2477 info. We use 0x100 as a slop to account for cases where the
2478 last line has executable code. */
2479 if (i
>= section
->lineno_count
2481 && offset
- last_value
> 0x100)
2483 *functionname_ptr
= NULL
;
2488 /* Cache the results for the next call. */
2489 if (sec_data
== NULL
&& section
->owner
== abfd
)
2491 amt
= sizeof (struct coff_section_tdata
);
2492 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
2493 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2496 if (sec_data
!= NULL
)
2498 sec_data
->offset
= offset
;
2499 sec_data
->i
= i
- 1;
2500 sec_data
->function
= *functionname_ptr
;
2501 sec_data
->line_base
= line_base
;
2508 coff_find_nearest_line (bfd
*abfd
,
2512 const char **filename_ptr
,
2513 const char **functionname_ptr
,
2514 unsigned int *line_ptr
,
2515 unsigned int *discriminator_ptr
)
2517 if (discriminator_ptr
)
2518 *discriminator_ptr
= 0;
2519 return coff_find_nearest_line_with_names (abfd
, symbols
, section
, offset
,
2520 filename_ptr
, functionname_ptr
,
2521 line_ptr
, dwarf_debug_sections
);
2525 coff_find_inliner_info (bfd
*abfd
,
2526 const char **filename_ptr
,
2527 const char **functionname_ptr
,
2528 unsigned int *line_ptr
)
2532 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
2533 functionname_ptr
, line_ptr
,
2534 &coff_data(abfd
)->dwarf2_find_line_info
);
2539 coff_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
2543 if (!bfd_link_relocatable (info
))
2544 size
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
2546 size
= bfd_coff_filhsz (abfd
);
2548 size
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
2552 /* Change the class of a coff symbol held by BFD. */
2555 bfd_coff_set_symbol_class (bfd
* abfd
,
2557 unsigned int symbol_class
)
2559 coff_symbol_type
* csym
;
2561 csym
= coff_symbol_from (symbol
);
2564 bfd_set_error (bfd_error_invalid_operation
);
2567 else if (csym
->native
== NULL
)
2569 /* This is an alien symbol which no native coff backend data.
2570 We cheat here by creating a fake native entry for it and
2571 then filling in the class. This code is based on that in
2572 coff_write_alien_symbol(). */
2574 combined_entry_type
* native
;
2575 size_t amt
= sizeof (* native
);
2577 native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
2581 native
->is_sym
= true;
2582 native
->u
.syment
.n_type
= T_NULL
;
2583 native
->u
.syment
.n_sclass
= symbol_class
;
2585 if (bfd_is_und_section (symbol
->section
))
2587 native
->u
.syment
.n_scnum
= N_UNDEF
;
2588 native
->u
.syment
.n_value
= symbol
->value
;
2590 else if (bfd_is_com_section (symbol
->section
))
2592 native
->u
.syment
.n_scnum
= N_UNDEF
;
2593 native
->u
.syment
.n_value
= symbol
->value
;
2597 native
->u
.syment
.n_scnum
=
2598 symbol
->section
->output_section
->target_index
;
2599 native
->u
.syment
.n_value
= (symbol
->value
2600 + symbol
->section
->output_offset
);
2601 if (! obj_pe (abfd
))
2602 native
->u
.syment
.n_value
+= symbol
->section
->output_section
->vma
;
2604 /* Copy the any flags from the file header into the symbol.
2606 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (& csym
->symbol
)->flags
;
2609 csym
->native
= native
;
2612 csym
->native
->u
.syment
.n_sclass
= symbol_class
;
2618 _bfd_coff_section_already_linked (bfd
*abfd
,
2620 struct bfd_link_info
*info
)
2623 const char *name
, *key
;
2624 struct bfd_section_already_linked
*l
;
2625 struct bfd_section_already_linked_hash_entry
*already_linked_list
;
2626 struct coff_comdat_info
*s_comdat
;
2628 if (sec
->output_section
== bfd_abs_section_ptr
)
2632 if ((flags
& SEC_LINK_ONCE
) == 0)
2635 /* The COFF backend linker doesn't support group sections. */
2636 if ((flags
& SEC_GROUP
) != 0)
2639 name
= bfd_section_name (sec
);
2640 s_comdat
= bfd_coff_get_comdat_section (abfd
, sec
);
2642 if (s_comdat
!= NULL
)
2643 key
= s_comdat
->name
;
2646 if (startswith (name
, ".gnu.linkonce.")
2647 && (key
= strchr (name
+ sizeof (".gnu.linkonce.") - 1, '.')) != NULL
)
2650 /* FIXME: gcc as of 2011-09 emits sections like .text$<key>,
2651 .xdata$<key> and .pdata$<key> only the first of which has a
2652 comdat key. Should these all match the LTO IR key? */
2656 already_linked_list
= bfd_section_already_linked_table_lookup (key
);
2658 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
2660 struct coff_comdat_info
*l_comdat
;
2662 l_comdat
= bfd_coff_get_comdat_section (l
->sec
->owner
, l
->sec
);
2664 /* The section names must match, and both sections must be
2665 comdat and have the same comdat name, or both sections must
2666 be non-comdat. LTO IR plugin sections are an exception. They
2667 are always named .gnu.linkonce.t.<key> (<key> is some string)
2668 and match any comdat section with comdat name of <key>, and
2669 any linkonce section with the same suffix, ie.
2670 .gnu.linkonce.*.<key>. */
2671 if (((s_comdat
!= NULL
) == (l_comdat
!= NULL
)
2672 && strcmp (name
, l
->sec
->name
) == 0)
2673 || (l
->sec
->owner
->flags
& BFD_PLUGIN
) != 0
2674 || (sec
->owner
->flags
& BFD_PLUGIN
) != 0)
2676 /* The section has already been linked. See if we should
2678 return _bfd_handle_already_linked (sec
, l
, info
);
2682 /* This is the first section with this name. Record it. */
2683 if (!bfd_section_already_linked_table_insert (already_linked_list
, sec
))
2684 info
->callbacks
->einfo (_("%F%P: already_linked_table: %E\n"));
2688 /* Initialize COOKIE for input bfd ABFD. */
2691 init_reloc_cookie (struct coff_reloc_cookie
*cookie
,
2692 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2695 /* Sometimes the symbol table does not yet have been loaded here. */
2696 bfd_coff_slurp_symbol_table (abfd
);
2698 cookie
->abfd
= abfd
;
2699 cookie
->sym_hashes
= obj_coff_sym_hashes (abfd
);
2701 cookie
->symbols
= obj_symbols (abfd
);
2706 /* Free the memory allocated by init_reloc_cookie, if appropriate. */
2709 fini_reloc_cookie (struct coff_reloc_cookie
*cookie ATTRIBUTE_UNUSED
,
2710 bfd
*abfd ATTRIBUTE_UNUSED
)
2712 /* Nothing to do. */
2715 /* Initialize the relocation information in COOKIE for input section SEC
2716 of input bfd ABFD. */
2719 init_reloc_cookie_rels (struct coff_reloc_cookie
*cookie
,
2720 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2724 if (sec
->reloc_count
== 0)
2726 cookie
->rels
= NULL
;
2727 cookie
->relend
= NULL
;
2732 cookie
->rels
= _bfd_coff_read_internal_relocs (abfd
, sec
, false, NULL
,
2735 if (cookie
->rels
== NULL
)
2738 cookie
->rel
= cookie
->rels
;
2739 cookie
->relend
= (cookie
->rels
+ sec
->reloc_count
);
2743 /* Free the memory allocated by init_reloc_cookie_rels,
2747 fini_reloc_cookie_rels (struct coff_reloc_cookie
*cookie
,
2751 /* PR 20401. The relocs may not have been cached, so check first.
2752 If the relocs were loaded by init_reloc_cookie_rels() then this
2753 will be the case. FIXME: Would performance be improved if the
2754 relocs *were* cached ? */
2755 && coff_section_data (NULL
, sec
)
2756 && coff_section_data (NULL
, sec
)->relocs
!= cookie
->rels
)
2757 free (cookie
->rels
);
2760 /* Initialize the whole of COOKIE for input section SEC. */
2763 init_reloc_cookie_for_section (struct coff_reloc_cookie
*cookie
,
2764 struct bfd_link_info
*info
,
2767 if (!init_reloc_cookie (cookie
, info
, sec
->owner
))
2770 if (!init_reloc_cookie_rels (cookie
, info
, sec
->owner
, sec
))
2772 fini_reloc_cookie (cookie
, sec
->owner
);
2778 /* Free the memory allocated by init_reloc_cookie_for_section,
2782 fini_reloc_cookie_for_section (struct coff_reloc_cookie
*cookie
,
2785 fini_reloc_cookie_rels (cookie
, sec
);
2786 fini_reloc_cookie (cookie
, sec
->owner
);
2790 _bfd_coff_gc_mark_hook (asection
*sec
,
2791 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2792 struct internal_reloc
*rel ATTRIBUTE_UNUSED
,
2793 struct coff_link_hash_entry
*h
,
2794 struct internal_syment
*sym
)
2798 switch (h
->root
.type
)
2800 case bfd_link_hash_defined
:
2801 case bfd_link_hash_defweak
:
2802 return h
->root
.u
.def
.section
;
2804 case bfd_link_hash_common
:
2805 return h
->root
.u
.c
.p
->section
;
2807 case bfd_link_hash_undefweak
:
2808 if (h
->symbol_class
== C_NT_WEAK
&& h
->numaux
== 1)
2810 /* PE weak externals. A weak symbol may include an auxiliary
2811 record indicating that if the weak symbol is not resolved,
2812 another external symbol is used instead. */
2813 struct coff_link_hash_entry
*h2
=
2814 h
->auxbfd
->tdata
.coff_obj_data
->sym_hashes
[
2815 h
->aux
->x_sym
.x_tagndx
.l
];
2817 if (h2
&& h2
->root
.type
!= bfd_link_hash_undefined
)
2818 return h2
->root
.u
.def
.section
;
2822 case bfd_link_hash_undefined
:
2829 return coff_section_from_bfd_index (sec
->owner
, sym
->n_scnum
);
2832 /* COOKIE->rel describes a relocation against section SEC, which is
2833 a section we've decided to keep. Return the section that contains
2834 the relocation symbol, or NULL if no section contains it. */
2837 _bfd_coff_gc_mark_rsec (struct bfd_link_info
*info
, asection
*sec
,
2838 coff_gc_mark_hook_fn gc_mark_hook
,
2839 struct coff_reloc_cookie
*cookie
)
2841 struct coff_link_hash_entry
*h
;
2843 h
= cookie
->sym_hashes
[cookie
->rel
->r_symndx
];
2846 while (h
->root
.type
== bfd_link_hash_indirect
2847 || h
->root
.type
== bfd_link_hash_warning
)
2848 h
= (struct coff_link_hash_entry
*) h
->root
.u
.i
.link
;
2850 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, h
, NULL
);
2853 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, NULL
,
2855 + obj_convert (sec
->owner
)[cookie
->rel
->r_symndx
])->native
->u
.syment
);
2858 static bool _bfd_coff_gc_mark
2859 (struct bfd_link_info
*, asection
*, coff_gc_mark_hook_fn
);
2861 /* COOKIE->rel describes a relocation against section SEC, which is
2862 a section we've decided to keep. Mark the section that contains
2863 the relocation symbol. */
2866 _bfd_coff_gc_mark_reloc (struct bfd_link_info
*info
,
2868 coff_gc_mark_hook_fn gc_mark_hook
,
2869 struct coff_reloc_cookie
*cookie
)
2873 rsec
= _bfd_coff_gc_mark_rsec (info
, sec
, gc_mark_hook
, cookie
);
2874 if (rsec
&& !rsec
->gc_mark
)
2876 if (bfd_get_flavour (rsec
->owner
) != bfd_target_coff_flavour
)
2878 else if (!_bfd_coff_gc_mark (info
, rsec
, gc_mark_hook
))
2884 /* The mark phase of garbage collection. For a given section, mark
2885 it and any sections in this section's group, and all the sections
2886 which define symbols to which it refers. */
2889 _bfd_coff_gc_mark (struct bfd_link_info
*info
,
2891 coff_gc_mark_hook_fn gc_mark_hook
)
2897 /* Look through the section relocs. */
2898 if ((sec
->flags
& SEC_RELOC
) != 0
2899 && sec
->reloc_count
> 0)
2901 struct coff_reloc_cookie cookie
;
2903 if (!init_reloc_cookie_for_section (&cookie
, info
, sec
))
2907 for (; cookie
.rel
< cookie
.relend
; cookie
.rel
++)
2909 if (!_bfd_coff_gc_mark_reloc (info
, sec
, gc_mark_hook
, &cookie
))
2915 fini_reloc_cookie_for_section (&cookie
, sec
);
2923 _bfd_coff_gc_mark_extra_sections (struct bfd_link_info
*info
,
2924 coff_gc_mark_hook_fn mark_hook ATTRIBUTE_UNUSED
)
2928 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
2933 if (bfd_get_flavour (ibfd
) != bfd_target_coff_flavour
)
2936 /* Ensure all linker created sections are kept, and see whether
2937 any other section is already marked. */
2939 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
2941 if ((isec
->flags
& SEC_LINKER_CREATED
) != 0)
2943 else if (isec
->gc_mark
)
2947 /* If no section in this file will be kept, then we can
2948 toss out debug sections. */
2952 /* Keep debug and special sections like .comment when they are
2953 not part of a group, or when we have single-member groups. */
2954 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
2955 if ((isec
->flags
& SEC_DEBUGGING
) != 0
2956 || (isec
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0)
2962 /* Sweep symbols in swept sections. Called via coff_link_hash_traverse. */
2965 coff_gc_sweep_symbol (struct coff_link_hash_entry
*h
,
2966 void *data ATTRIBUTE_UNUSED
)
2968 if (h
->root
.type
== bfd_link_hash_warning
)
2969 h
= (struct coff_link_hash_entry
*) h
->root
.u
.i
.link
;
2971 if ((h
->root
.type
== bfd_link_hash_defined
2972 || h
->root
.type
== bfd_link_hash_defweak
)
2973 && !h
->root
.u
.def
.section
->gc_mark
2974 && !(h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
))
2976 /* Do our best to hide the symbol. */
2977 h
->root
.u
.def
.section
= bfd_und_section_ptr
;
2978 h
->symbol_class
= C_HIDDEN
;
2984 /* The sweep phase of garbage collection. Remove all garbage sections. */
2986 typedef bool (*gc_sweep_hook_fn
)
2987 (bfd
*, struct bfd_link_info
*, asection
*, const struct internal_reloc
*);
2990 coff_gc_sweep (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
2994 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
2998 if (bfd_get_flavour (sub
) != bfd_target_coff_flavour
)
3001 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3003 /* Keep debug and special sections. */
3004 if ((o
->flags
& (SEC_DEBUGGING
| SEC_LINKER_CREATED
)) != 0
3005 || (o
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0)
3007 else if (startswith (o
->name
, ".idata")
3008 || startswith (o
->name
, ".pdata")
3009 || startswith (o
->name
, ".xdata")
3010 || startswith (o
->name
, ".rsrc"))
3016 /* Skip sweeping sections already excluded. */
3017 if (o
->flags
& SEC_EXCLUDE
)
3020 /* Since this is early in the link process, it is simple
3021 to remove a section from the output. */
3022 o
->flags
|= SEC_EXCLUDE
;
3024 if (info
->print_gc_sections
&& o
->size
!= 0)
3025 /* xgettext: c-format */
3026 _bfd_error_handler (_("removing unused section '%pA' in file '%pB'"),
3030 /* But we also have to update some of the relocation
3031 info we collected before. */
3033 && (o
->flags
& SEC_RELOC
) != 0
3034 && o
->reloc_count
> 0
3035 && !bfd_is_abs_section (o
->output_section
))
3037 struct internal_reloc
*internal_relocs
;
3041 = _bfd_coff_link_read_relocs (o
->owner
, o
, NULL
, NULL
,
3043 if (internal_relocs
== NULL
)
3046 r
= (*gc_sweep_hook
) (o
->owner
, info
, o
, internal_relocs
);
3048 if (coff_section_data (o
)->relocs
!= internal_relocs
)
3049 free (internal_relocs
);
3058 /* Remove the symbols that were in the swept sections from the dynamic
3060 coff_link_hash_traverse (coff_hash_table (info
), coff_gc_sweep_symbol
,
3066 /* Keep all sections containing symbols undefined on the command-line,
3067 and the section containing the entry symbol. */
3070 _bfd_coff_gc_keep (struct bfd_link_info
*info
)
3072 struct bfd_sym_chain
*sym
;
3074 for (sym
= info
->gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
3076 struct coff_link_hash_entry
*h
;
3078 h
= coff_link_hash_lookup (coff_hash_table (info
), sym
->name
,
3079 false, false, false);
3082 && (h
->root
.type
== bfd_link_hash_defined
3083 || h
->root
.type
== bfd_link_hash_defweak
)
3084 && !bfd_is_abs_section (h
->root
.u
.def
.section
))
3085 h
->root
.u
.def
.section
->flags
|= SEC_KEEP
;
3089 /* Do mark and sweep of unused sections. */
3092 bfd_coff_gc_sections (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
3096 /* FIXME: Should we implement this? */
3098 const bfd_coff_backend_data
*bed
= coff_backend_info (abfd
);
3100 if (!bed
->can_gc_sections
3101 || !is_coff_hash_table (info
->hash
))
3103 _bfd_error_handler(_("warning: gc-sections option ignored"));
3108 _bfd_coff_gc_keep (info
);
3110 /* Grovel through relocs to find out who stays ... */
3111 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3115 if (bfd_get_flavour (sub
) != bfd_target_coff_flavour
)
3118 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3120 if (((o
->flags
& (SEC_EXCLUDE
| SEC_KEEP
)) == SEC_KEEP
3121 || startswith (o
->name
, ".vectors")
3122 || startswith (o
->name
, ".ctors")
3123 || startswith (o
->name
, ".dtors"))
3126 if (!_bfd_coff_gc_mark (info
, o
, _bfd_coff_gc_mark_hook
))
3132 /* Allow the backend to mark additional target specific sections. */
3133 _bfd_coff_gc_mark_extra_sections (info
, _bfd_coff_gc_mark_hook
);
3135 /* ... and mark SEC_EXCLUDE for those that go. */
3136 return coff_gc_sweep (abfd
, info
);
3139 /* Return name used to identify a comdat group. */
3142 bfd_coff_group_name (bfd
*abfd
, const asection
*sec
)
3144 struct coff_comdat_info
*ci
= bfd_coff_get_comdat_section (abfd
, sec
);
3151 _bfd_coff_close_and_cleanup (bfd
*abfd
)
3153 struct coff_tdata
*tdata
= coff_data (abfd
);
3158 Do not clear the keep_syms and keep_strings flags.
3159 These may have been set by pe_ILF_build_a_bfd() indicating
3160 that the syms and strings pointers are not to be freed. */
3161 if (bfd_get_format (abfd
) == bfd_object
3162 && bfd_family_coff (abfd
)
3163 && !_bfd_coff_free_symbols (abfd
))
3166 if (bfd_get_format (abfd
) == bfd_object
3167 || bfd_get_format (abfd
) == bfd_core
)
3168 _bfd_dwarf2_cleanup_debug_info (abfd
, &tdata
->dwarf2_find_line_info
);
3170 return _bfd_generic_close_and_cleanup (abfd
);