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
;
1670 if (obj_coff_strings (abfd
) != NULL
)
1671 return obj_coff_strings (abfd
);
1673 if (obj_sym_filepos (abfd
) == 0)
1675 bfd_set_error (bfd_error_no_symbols
);
1679 symesz
= bfd_coff_symesz (abfd
);
1680 pos
= obj_sym_filepos (abfd
);
1681 if (_bfd_mul_overflow (obj_raw_syment_count (abfd
), symesz
, &size
)
1682 || pos
+ size
< pos
)
1684 bfd_set_error (bfd_error_file_truncated
);
1688 if (bfd_seek (abfd
, pos
+ size
, SEEK_SET
) != 0)
1691 if (bfd_bread (extstrsize
, (bfd_size_type
) sizeof extstrsize
, abfd
)
1692 != sizeof extstrsize
)
1694 if (bfd_get_error () != bfd_error_file_truncated
)
1697 /* There is no string table. */
1698 strsize
= STRING_SIZE_SIZE
;
1702 #if STRING_SIZE_SIZE == 4
1703 strsize
= H_GET_32 (abfd
, extstrsize
);
1705 #error Change H_GET_32
1709 filesize
= bfd_get_file_size (abfd
);
1710 if (strsize
< STRING_SIZE_SIZE
1711 || (filesize
!= 0 && strsize
> filesize
))
1714 /* xgettext: c-format */
1715 (_("%pB: bad string table size %" PRIu64
), abfd
, (uint64_t) strsize
);
1716 bfd_set_error (bfd_error_bad_value
);
1720 strings
= (char *) bfd_malloc (strsize
+ 1);
1721 if (strings
== NULL
)
1724 /* PR 17521 file: 079-54929-0.004.
1725 A corrupt file could contain an index that points into the first
1726 STRING_SIZE_SIZE bytes of the string table, so make sure that
1728 memset (strings
, 0, STRING_SIZE_SIZE
);
1730 if (bfd_bread (strings
+ STRING_SIZE_SIZE
, strsize
- STRING_SIZE_SIZE
, abfd
)
1731 != strsize
- STRING_SIZE_SIZE
)
1737 obj_coff_strings (abfd
) = strings
;
1738 obj_coff_strings_len (abfd
) = strsize
;
1739 /* Terminate the string table, just in case. */
1740 strings
[strsize
] = 0;
1744 /* Free up the external symbols and strings read from a COFF file. */
1747 _bfd_coff_free_symbols (bfd
*abfd
)
1749 if (! bfd_family_coff (abfd
))
1752 if (obj_coff_external_syms (abfd
) != NULL
1753 && ! obj_coff_keep_syms (abfd
))
1755 free (obj_coff_external_syms (abfd
));
1756 obj_coff_external_syms (abfd
) = NULL
;
1759 if (obj_coff_strings (abfd
) != NULL
1760 && ! obj_coff_keep_strings (abfd
))
1762 free (obj_coff_strings (abfd
));
1763 obj_coff_strings (abfd
) = NULL
;
1764 obj_coff_strings_len (abfd
) = 0;
1770 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
1771 knit the symbol names into a normalized form. By normalized here I
1772 mean that all symbols have an n_offset pointer that points to a null-
1773 terminated string. */
1775 combined_entry_type
*
1776 coff_get_normalized_symtab (bfd
*abfd
)
1778 combined_entry_type
*internal
;
1779 combined_entry_type
*internal_ptr
;
1780 combined_entry_type
*symbol_ptr
;
1781 combined_entry_type
*internal_end
;
1785 const char *string_table
= NULL
;
1786 asection
* debug_sec
= NULL
;
1787 char *debug_sec_data
= NULL
;
1790 if (obj_raw_syments (abfd
) != NULL
)
1791 return obj_raw_syments (abfd
);
1793 if (! _bfd_coff_get_external_symbols (abfd
))
1796 size
= obj_raw_syment_count (abfd
);
1797 /* Check for integer overflow. */
1798 if (size
> (bfd_size_type
) -1 / sizeof (combined_entry_type
))
1800 size
*= sizeof (combined_entry_type
);
1801 internal
= (combined_entry_type
*) bfd_zalloc (abfd
, size
);
1802 if (internal
== NULL
&& size
!= 0)
1804 internal_end
= internal
+ obj_raw_syment_count (abfd
);
1806 raw_src
= (char *) obj_coff_external_syms (abfd
);
1808 /* Mark the end of the symbols. */
1809 symesz
= bfd_coff_symesz (abfd
);
1810 raw_end
= (char *) raw_src
+ obj_raw_syment_count (abfd
) * symesz
;
1812 /* FIXME SOMEDAY. A string table size of zero is very weird, but
1813 probably possible. If one shows up, it will probably kill us. */
1815 /* Swap all the raw entries. */
1816 for (internal_ptr
= internal
;
1818 raw_src
+= symesz
, internal_ptr
++)
1822 bfd_coff_swap_sym_in (abfd
, (void *) raw_src
,
1823 (void *) & internal_ptr
->u
.syment
);
1824 symbol_ptr
= internal_ptr
;
1825 internal_ptr
->is_sym
= true;
1827 /* PR 17512: Prevent buffer overrun. */
1828 if (symbol_ptr
->u
.syment
.n_numaux
> ((raw_end
- 1) - raw_src
) / symesz
)
1830 bfd_release (abfd
, internal
);
1835 i
< symbol_ptr
->u
.syment
.n_numaux
;
1841 bfd_coff_swap_aux_in (abfd
, (void *) raw_src
,
1842 symbol_ptr
->u
.syment
.n_type
,
1843 symbol_ptr
->u
.syment
.n_sclass
,
1844 (int) i
, symbol_ptr
->u
.syment
.n_numaux
,
1845 &(internal_ptr
->u
.auxent
));
1847 internal_ptr
->is_sym
= false;
1848 coff_pointerize_aux (abfd
, internal
, symbol_ptr
, i
,
1849 internal_ptr
, internal_end
);
1853 /* Free the raw symbols. */
1854 if (obj_coff_external_syms (abfd
) != NULL
1855 && ! obj_coff_keep_syms (abfd
))
1857 free (obj_coff_external_syms (abfd
));
1858 obj_coff_external_syms (abfd
) = NULL
;
1861 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
1864 BFD_ASSERT (internal_ptr
->is_sym
);
1866 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
1867 && internal_ptr
->u
.syment
.n_numaux
> 0)
1869 combined_entry_type
* aux
= internal_ptr
+ 1;
1871 /* Make a file symbol point to the name in the auxent, since
1872 the text ".file" is redundant. */
1873 BFD_ASSERT (! aux
->is_sym
);
1875 if (aux
->u
.auxent
.x_file
.x_n
.x_zeroes
== 0)
1877 /* The filename is a long one, point into the string table. */
1878 if (string_table
== NULL
)
1880 string_table
= _bfd_coff_read_string_table (abfd
);
1881 if (string_table
== NULL
)
1885 if ((bfd_size_type
)(aux
->u
.auxent
.x_file
.x_n
.x_offset
)
1886 >= obj_coff_strings_len (abfd
))
1887 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1889 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1890 (bfd_hostptr_t
) (string_table
+ (aux
->u
.auxent
.x_file
.x_n
.x_offset
));
1894 /* Ordinary short filename, put into memory anyway. The
1895 Microsoft PE tools sometimes store a filename in
1896 multiple AUX entries. */
1897 if (internal_ptr
->u
.syment
.n_numaux
> 1
1898 && coff_data (abfd
)->pe
)
1899 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1902 aux
->u
.auxent
.x_file
.x_fname
,
1903 internal_ptr
->u
.syment
.n_numaux
* symesz
);
1905 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1908 aux
->u
.auxent
.x_file
.x_fname
,
1909 (size_t) bfd_coff_filnmlen (abfd
)));
1914 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0)
1916 /* This is a "short" name. Make it long. */
1920 /* Find the length of this string without walking into memory
1922 for (i
= 0; i
< 8; ++i
)
1923 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0')
1926 newstring
= (char *) bfd_zalloc (abfd
, (bfd_size_type
) (i
+ 1));
1927 if (newstring
== NULL
)
1929 strncpy (newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
);
1930 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) newstring
;
1931 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1933 else if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
== 0)
1934 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) "";
1935 else if (!bfd_coff_symname_in_debug (abfd
, &internal_ptr
->u
.syment
))
1937 /* Long name already. Point symbol at the string in the
1939 if (string_table
== NULL
)
1941 string_table
= _bfd_coff_read_string_table (abfd
);
1942 if (string_table
== NULL
)
1945 if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
>= obj_coff_strings_len (abfd
)
1946 || string_table
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
< string_table
)
1947 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1949 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1952 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
));
1956 /* Long name in debug section. Very similar. */
1957 if (debug_sec_data
== NULL
)
1958 debug_sec_data
= build_debug_section (abfd
, & debug_sec
);
1959 if (debug_sec_data
!= NULL
)
1961 BFD_ASSERT (debug_sec
!= NULL
);
1962 /* PR binutils/17512: Catch out of range offsets into the debug data. */
1963 if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
> debug_sec
->size
1964 || debug_sec_data
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
< debug_sec_data
)
1965 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1967 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
)
1968 (debug_sec_data
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
1971 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) "";
1974 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
1977 obj_raw_syments (abfd
) = internal
;
1978 BFD_ASSERT (obj_raw_syment_count (abfd
)
1979 == (unsigned int) (internal_ptr
- internal
));
1985 coff_get_reloc_upper_bound (bfd
*abfd
, sec_ptr asect
)
1987 if (bfd_get_format (abfd
) != bfd_object
)
1989 bfd_set_error (bfd_error_invalid_operation
);
1992 #if SIZEOF_LONG == SIZEOF_INT
1993 if (asect
->reloc_count
>= LONG_MAX
/ sizeof (arelent
*))
1995 bfd_set_error (bfd_error_file_too_big
);
1999 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
2003 coff_make_empty_symbol (bfd
*abfd
)
2005 size_t amt
= sizeof (coff_symbol_type
);
2006 coff_symbol_type
*new_symbol
= (coff_symbol_type
*) bfd_zalloc (abfd
, amt
);
2008 if (new_symbol
== NULL
)
2010 new_symbol
->symbol
.section
= 0;
2011 new_symbol
->native
= NULL
;
2012 new_symbol
->lineno
= NULL
;
2013 new_symbol
->done_lineno
= false;
2014 new_symbol
->symbol
.the_bfd
= abfd
;
2016 return & new_symbol
->symbol
;
2019 /* Make a debugging symbol. */
2022 coff_bfd_make_debug_symbol (bfd
*abfd
,
2023 void * ptr ATTRIBUTE_UNUSED
,
2024 unsigned long sz ATTRIBUTE_UNUSED
)
2026 size_t amt
= sizeof (coff_symbol_type
);
2027 coff_symbol_type
*new_symbol
= (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
2029 if (new_symbol
== NULL
)
2031 /* @@ The 10 is a guess at a plausible maximum number of aux entries
2032 (but shouldn't be a constant). */
2033 amt
= sizeof (combined_entry_type
) * 10;
2034 new_symbol
->native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
2035 if (!new_symbol
->native
)
2037 new_symbol
->native
->is_sym
= true;
2038 new_symbol
->symbol
.section
= bfd_abs_section_ptr
;
2039 new_symbol
->symbol
.flags
= BSF_DEBUGGING
;
2040 new_symbol
->lineno
= NULL
;
2041 new_symbol
->done_lineno
= false;
2042 new_symbol
->symbol
.the_bfd
= abfd
;
2044 return & new_symbol
->symbol
;
2048 coff_get_symbol_info (bfd
*abfd
, asymbol
*symbol
, symbol_info
*ret
)
2050 bfd_symbol_info (symbol
, ret
);
2052 if (coffsymbol (symbol
)->native
!= NULL
2053 && coffsymbol (symbol
)->native
->fix_value
2054 && coffsymbol (symbol
)->native
->is_sym
)
2056 ((coffsymbol (symbol
)->native
->u
.syment
.n_value
-
2057 (bfd_hostptr_t
) obj_raw_syments (abfd
))
2058 / sizeof (combined_entry_type
));
2061 /* Print out information about COFF symbol. */
2064 coff_print_symbol (bfd
*abfd
,
2067 bfd_print_symbol_type how
)
2069 FILE * file
= (FILE *) filep
;
2073 case bfd_print_symbol_name
:
2074 fprintf (file
, "%s", symbol
->name
);
2077 case bfd_print_symbol_more
:
2078 fprintf (file
, "coff %s %s",
2079 coffsymbol (symbol
)->native
? "n" : "g",
2080 coffsymbol (symbol
)->lineno
? "l" : " ");
2083 case bfd_print_symbol_all
:
2084 if (coffsymbol (symbol
)->native
)
2088 combined_entry_type
*combined
= coffsymbol (symbol
)->native
;
2089 combined_entry_type
*root
= obj_raw_syments (abfd
);
2090 struct lineno_cache_entry
*l
= coffsymbol (symbol
)->lineno
;
2092 fprintf (file
, "[%3ld]", (long) (combined
- root
));
2094 /* PR 17512: file: 079-33786-0.001:0.1. */
2095 if (combined
< obj_raw_syments (abfd
)
2096 || combined
>= obj_raw_syments (abfd
) + obj_raw_syment_count (abfd
))
2098 fprintf (file
, _("<corrupt info> %s"), symbol
->name
);
2102 BFD_ASSERT (combined
->is_sym
);
2103 if (! combined
->fix_value
)
2104 val
= (bfd_vma
) combined
->u
.syment
.n_value
;
2106 val
= ((combined
->u
.syment
.n_value
- (bfd_hostptr_t
) root
)
2107 / sizeof (combined_entry_type
));
2109 fprintf (file
, "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x",
2110 combined
->u
.syment
.n_scnum
,
2111 combined
->u
.syment
.n_flags
,
2112 combined
->u
.syment
.n_type
,
2113 combined
->u
.syment
.n_sclass
,
2114 combined
->u
.syment
.n_numaux
);
2115 bfd_fprintf_vma (abfd
, file
, val
);
2116 fprintf (file
, " %s", symbol
->name
);
2118 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
2120 combined_entry_type
*auxp
= combined
+ aux
+ 1;
2123 BFD_ASSERT (! auxp
->is_sym
);
2125 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.p
- root
;
2127 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.l
;
2129 fprintf (file
, "\n");
2131 if (bfd_coff_print_aux (abfd
, file
, root
, combined
, auxp
, aux
))
2134 switch (combined
->u
.syment
.n_sclass
)
2137 fprintf (file
, "File ");
2141 fprintf (file
, "AUX scnlen 0x%lx nreloc %ld",
2142 (unsigned long) auxp
->u
.auxent
.x_sect
.x_scnlen
,
2143 auxp
->u
.auxent
.x_sect
.x_nreloc
);
2147 if (combined
->u
.syment
.n_type
== T_NULL
)
2148 /* Probably a section symbol ? */
2150 fprintf (file
, "AUX scnlen 0x%lx nreloc %d nlnno %d",
2151 (unsigned long) auxp
->u
.auxent
.x_scn
.x_scnlen
,
2152 auxp
->u
.auxent
.x_scn
.x_nreloc
,
2153 auxp
->u
.auxent
.x_scn
.x_nlinno
);
2154 if (auxp
->u
.auxent
.x_scn
.x_checksum
!= 0
2155 || auxp
->u
.auxent
.x_scn
.x_associated
!= 0
2156 || auxp
->u
.auxent
.x_scn
.x_comdat
!= 0)
2157 fprintf (file
, " checksum 0x%lx assoc %d comdat %d",
2158 auxp
->u
.auxent
.x_scn
.x_checksum
,
2159 auxp
->u
.auxent
.x_scn
.x_associated
,
2160 auxp
->u
.auxent
.x_scn
.x_comdat
);
2166 if (ISFCN (combined
->u
.syment
.n_type
))
2171 next
= (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2174 next
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2175 llnos
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
2177 "AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld",
2179 (unsigned long) auxp
->u
.auxent
.x_sym
.x_misc
.x_fsize
,
2185 fprintf (file
, "AUX lnno %d size 0x%x tagndx %ld",
2186 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
2187 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
,
2190 fprintf (file
, " endndx %ld",
2192 (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2200 fprintf (file
, "\n%s :", l
->u
.sym
->name
);
2202 while (l
->line_number
)
2204 if (l
->line_number
> 0)
2206 fprintf (file
, "\n%4d : ", l
->line_number
);
2207 bfd_fprintf_vma (abfd
, file
, l
->u
.offset
+ symbol
->section
->vma
);
2215 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
2216 fprintf (file
, " %-5s %s %s %s",
2217 symbol
->section
->name
,
2218 coffsymbol (symbol
)->native
? "n" : "g",
2219 coffsymbol (symbol
)->lineno
? "l" : " ",
2225 /* Return whether a symbol name implies a local symbol. In COFF,
2226 local symbols generally start with ``.L''. Most targets use this
2227 function for the is_local_label_name entry point, but some may
2231 _bfd_coff_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
2234 return name
[0] == '.' && name
[1] == 'L';
2237 /* Provided a BFD, a section and an offset (in bytes, not octets) into the
2238 section, calculate and return the name of the source file and the line
2239 nearest to the wanted location. */
2242 coff_find_nearest_line_with_names (bfd
*abfd
,
2246 const char **filename_ptr
,
2247 const char **functionname_ptr
,
2248 unsigned int *line_ptr
,
2249 const struct dwarf_debug_section
*debug_sections
)
2253 unsigned int line_base
;
2254 coff_data_type
*cof
= coff_data (abfd
);
2255 /* Run through the raw syments if available. */
2256 combined_entry_type
*p
;
2257 combined_entry_type
*pend
;
2259 struct coff_section_tdata
*sec_data
;
2262 /* Before looking through the symbol table, try to use a .stab
2263 section to find the information. */
2264 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2265 &found
, filename_ptr
,
2266 functionname_ptr
, line_ptr
,
2267 &coff_data(abfd
)->line_info
))
2273 /* Also try examining DWARF2 debugging information. */
2274 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
2275 filename_ptr
, functionname_ptr
,
2276 line_ptr
, NULL
, debug_sections
,
2277 &coff_data(abfd
)->dwarf2_find_line_info
))
2280 sec_data
= coff_section_data (abfd
, section
);
2282 /* If the DWARF lookup failed, but there is DWARF information available
2283 then the problem might be that the file has been rebased. This tool
2284 changes the VMAs of all the sections, but it does not update the DWARF
2285 information. So try again, using a bias against the address sought. */
2286 if (coff_data (abfd
)->dwarf2_find_line_info
!= NULL
)
2288 bfd_signed_vma bias
= 0;
2290 /* Create a cache of the result for the next call. */
2291 if (sec_data
== NULL
&& section
->owner
== abfd
)
2293 amt
= sizeof (struct coff_section_tdata
);
2294 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
2295 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2298 if (sec_data
!= NULL
&& sec_data
->saved_bias
)
2299 bias
= sec_data
->saved_bias
;
2302 bias
= _bfd_dwarf2_find_symbol_bias (symbols
,
2303 & coff_data (abfd
)->dwarf2_find_line_info
);
2307 sec_data
->saved_bias
= true;
2308 sec_data
->bias
= bias
;
2313 && _bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
,
2315 filename_ptr
, functionname_ptr
,
2316 line_ptr
, NULL
, debug_sections
,
2317 &coff_data(abfd
)->dwarf2_find_line_info
))
2322 *functionname_ptr
= 0;
2325 /* Don't try and find line numbers in a non coff file. */
2326 if (!bfd_family_coff (abfd
))
2332 /* Find the first C_FILE symbol. */
2333 p
= cof
->raw_syments
;
2337 pend
= p
+ cof
->raw_syment_count
;
2340 BFD_ASSERT (p
->is_sym
);
2341 if (p
->u
.syment
.n_sclass
== C_FILE
)
2343 p
+= 1 + p
->u
.syment
.n_numaux
;
2351 /* Look through the C_FILE symbols to find the best one. */
2352 sec_vma
= bfd_section_vma (section
);
2353 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2354 maxdiff
= (bfd_vma
) 0 - (bfd_vma
) 1;
2358 combined_entry_type
*p2
;
2360 for (p2
= p
+ 1 + p
->u
.syment
.n_numaux
;
2362 p2
+= 1 + p2
->u
.syment
.n_numaux
)
2364 BFD_ASSERT (p2
->is_sym
);
2365 if (p2
->u
.syment
.n_scnum
> 0
2367 == coff_section_from_bfd_index (abfd
,
2368 p2
->u
.syment
.n_scnum
)))
2370 if (p2
->u
.syment
.n_sclass
== C_FILE
)
2379 file_addr
= (bfd_vma
) p2
->u
.syment
.n_value
;
2380 /* PR 11512: Include the section address of the function name symbol. */
2381 if (p2
->u
.syment
.n_scnum
> 0)
2382 file_addr
+= coff_section_from_bfd_index (abfd
,
2383 p2
->u
.syment
.n_scnum
)->vma
;
2384 /* We use <= MAXDIFF here so that if we get a zero length
2385 file, we actually use the next file entry. */
2387 && offset
+ sec_vma
>= file_addr
2388 && offset
+ sec_vma
- file_addr
<= maxdiff
)
2390 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2391 maxdiff
= offset
+ sec_vma
- p2
->u
.syment
.n_value
;
2394 if (p
->u
.syment
.n_value
>= cof
->raw_syment_count
)
2397 /* Avoid endless loops on erroneous files by ensuring that
2398 we always move forward in the file. */
2399 if (p
>= cof
->raw_syments
+ p
->u
.syment
.n_value
)
2402 p
= cof
->raw_syments
+ p
->u
.syment
.n_value
;
2403 if (!p
->is_sym
|| p
->u
.syment
.n_sclass
!= C_FILE
)
2408 if (section
->lineno_count
== 0)
2410 *functionname_ptr
= NULL
;
2415 /* Now wander though the raw linenumbers of the section.
2416 If we have been called on this section before, and the offset
2417 we want is further down then we can prime the lookup loop. */
2418 if (sec_data
!= NULL
2420 && offset
>= sec_data
->offset
)
2423 *functionname_ptr
= sec_data
->function
;
2424 line_base
= sec_data
->line_base
;
2432 if (section
->lineno
!= NULL
)
2434 bfd_vma last_value
= 0;
2436 l
= §ion
->lineno
[i
];
2438 for (; i
< section
->lineno_count
; i
++)
2440 if (l
->line_number
== 0)
2442 /* Get the symbol this line number points at. */
2443 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
2444 if (coff
->symbol
.value
> offset
)
2447 *functionname_ptr
= coff
->symbol
.name
;
2448 last_value
= coff
->symbol
.value
;
2451 combined_entry_type
*s
= coff
->native
;
2453 BFD_ASSERT (s
->is_sym
);
2454 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2456 /* In XCOFF a debugging symbol can follow the
2458 if (((size_t) ((char *) s
- (char *) obj_raw_syments (abfd
))
2459 < obj_raw_syment_count (abfd
) * sizeof (*s
))
2460 && s
->u
.syment
.n_scnum
== N_DEBUG
)
2461 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2463 /* S should now point to the .bf of the function. */
2464 if (((size_t) ((char *) s
- (char *) obj_raw_syments (abfd
))
2465 < obj_raw_syment_count (abfd
) * sizeof (*s
))
2466 && s
->u
.syment
.n_numaux
)
2468 /* The linenumber is stored in the auxent. */
2469 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
2471 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
2472 *line_ptr
= line_base
;
2478 if (l
->u
.offset
> offset
)
2480 *line_ptr
= l
->line_number
+ line_base
- 1;
2485 /* If we fell off the end of the loop, then assume that this
2486 symbol has no line number info. Otherwise, symbols with no
2487 line number info get reported with the line number of the
2488 last line of the last symbol which does have line number
2489 info. We use 0x100 as a slop to account for cases where the
2490 last line has executable code. */
2491 if (i
>= section
->lineno_count
2493 && offset
- last_value
> 0x100)
2495 *functionname_ptr
= NULL
;
2500 /* Cache the results for the next call. */
2501 if (sec_data
== NULL
&& section
->owner
== abfd
)
2503 amt
= sizeof (struct coff_section_tdata
);
2504 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
2505 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2508 if (sec_data
!= NULL
)
2510 sec_data
->offset
= offset
;
2511 sec_data
->i
= i
- 1;
2512 sec_data
->function
= *functionname_ptr
;
2513 sec_data
->line_base
= line_base
;
2520 coff_find_nearest_line (bfd
*abfd
,
2524 const char **filename_ptr
,
2525 const char **functionname_ptr
,
2526 unsigned int *line_ptr
,
2527 unsigned int *discriminator_ptr
)
2529 if (discriminator_ptr
)
2530 *discriminator_ptr
= 0;
2531 return coff_find_nearest_line_with_names (abfd
, symbols
, section
, offset
,
2532 filename_ptr
, functionname_ptr
,
2533 line_ptr
, dwarf_debug_sections
);
2537 coff_find_inliner_info (bfd
*abfd
,
2538 const char **filename_ptr
,
2539 const char **functionname_ptr
,
2540 unsigned int *line_ptr
)
2544 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
2545 functionname_ptr
, line_ptr
,
2546 &coff_data(abfd
)->dwarf2_find_line_info
);
2551 coff_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
2555 if (!bfd_link_relocatable (info
))
2556 size
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
2558 size
= bfd_coff_filhsz (abfd
);
2560 size
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
2564 /* Change the class of a coff symbol held by BFD. */
2567 bfd_coff_set_symbol_class (bfd
* abfd
,
2569 unsigned int symbol_class
)
2571 coff_symbol_type
* csym
;
2573 csym
= coff_symbol_from (symbol
);
2576 bfd_set_error (bfd_error_invalid_operation
);
2579 else if (csym
->native
== NULL
)
2581 /* This is an alien symbol which no native coff backend data.
2582 We cheat here by creating a fake native entry for it and
2583 then filling in the class. This code is based on that in
2584 coff_write_alien_symbol(). */
2586 combined_entry_type
* native
;
2587 size_t amt
= sizeof (* native
);
2589 native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
2593 native
->is_sym
= true;
2594 native
->u
.syment
.n_type
= T_NULL
;
2595 native
->u
.syment
.n_sclass
= symbol_class
;
2597 if (bfd_is_und_section (symbol
->section
))
2599 native
->u
.syment
.n_scnum
= N_UNDEF
;
2600 native
->u
.syment
.n_value
= symbol
->value
;
2602 else if (bfd_is_com_section (symbol
->section
))
2604 native
->u
.syment
.n_scnum
= N_UNDEF
;
2605 native
->u
.syment
.n_value
= symbol
->value
;
2609 native
->u
.syment
.n_scnum
=
2610 symbol
->section
->output_section
->target_index
;
2611 native
->u
.syment
.n_value
= (symbol
->value
2612 + symbol
->section
->output_offset
);
2613 if (! obj_pe (abfd
))
2614 native
->u
.syment
.n_value
+= symbol
->section
->output_section
->vma
;
2616 /* Copy the any flags from the file header into the symbol.
2618 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (& csym
->symbol
)->flags
;
2621 csym
->native
= native
;
2624 csym
->native
->u
.syment
.n_sclass
= symbol_class
;
2630 _bfd_coff_section_already_linked (bfd
*abfd
,
2632 struct bfd_link_info
*info
)
2635 const char *name
, *key
;
2636 struct bfd_section_already_linked
*l
;
2637 struct bfd_section_already_linked_hash_entry
*already_linked_list
;
2638 struct coff_comdat_info
*s_comdat
;
2640 if (sec
->output_section
== bfd_abs_section_ptr
)
2644 if ((flags
& SEC_LINK_ONCE
) == 0)
2647 /* The COFF backend linker doesn't support group sections. */
2648 if ((flags
& SEC_GROUP
) != 0)
2651 name
= bfd_section_name (sec
);
2652 s_comdat
= bfd_coff_get_comdat_section (abfd
, sec
);
2654 if (s_comdat
!= NULL
)
2655 key
= s_comdat
->name
;
2658 if (startswith (name
, ".gnu.linkonce.")
2659 && (key
= strchr (name
+ sizeof (".gnu.linkonce.") - 1, '.')) != NULL
)
2662 /* FIXME: gcc as of 2011-09 emits sections like .text$<key>,
2663 .xdata$<key> and .pdata$<key> only the first of which has a
2664 comdat key. Should these all match the LTO IR key? */
2668 already_linked_list
= bfd_section_already_linked_table_lookup (key
);
2670 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
2672 struct coff_comdat_info
*l_comdat
;
2674 l_comdat
= bfd_coff_get_comdat_section (l
->sec
->owner
, l
->sec
);
2676 /* The section names must match, and both sections must be
2677 comdat and have the same comdat name, or both sections must
2678 be non-comdat. LTO IR plugin sections are an exception. They
2679 are always named .gnu.linkonce.t.<key> (<key> is some string)
2680 and match any comdat section with comdat name of <key>, and
2681 any linkonce section with the same suffix, ie.
2682 .gnu.linkonce.*.<key>. */
2683 if (((s_comdat
!= NULL
) == (l_comdat
!= NULL
)
2684 && strcmp (name
, l
->sec
->name
) == 0)
2685 || (l
->sec
->owner
->flags
& BFD_PLUGIN
) != 0
2686 || (sec
->owner
->flags
& BFD_PLUGIN
) != 0)
2688 /* The section has already been linked. See if we should
2690 return _bfd_handle_already_linked (sec
, l
, info
);
2694 /* This is the first section with this name. Record it. */
2695 if (!bfd_section_already_linked_table_insert (already_linked_list
, sec
))
2696 info
->callbacks
->einfo (_("%F%P: already_linked_table: %E\n"));
2700 /* Initialize COOKIE for input bfd ABFD. */
2703 init_reloc_cookie (struct coff_reloc_cookie
*cookie
,
2704 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2707 /* Sometimes the symbol table does not yet have been loaded here. */
2708 bfd_coff_slurp_symbol_table (abfd
);
2710 cookie
->abfd
= abfd
;
2711 cookie
->sym_hashes
= obj_coff_sym_hashes (abfd
);
2713 cookie
->symbols
= obj_symbols (abfd
);
2718 /* Free the memory allocated by init_reloc_cookie, if appropriate. */
2721 fini_reloc_cookie (struct coff_reloc_cookie
*cookie ATTRIBUTE_UNUSED
,
2722 bfd
*abfd ATTRIBUTE_UNUSED
)
2724 /* Nothing to do. */
2727 /* Initialize the relocation information in COOKIE for input section SEC
2728 of input bfd ABFD. */
2731 init_reloc_cookie_rels (struct coff_reloc_cookie
*cookie
,
2732 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2736 if (sec
->reloc_count
== 0)
2738 cookie
->rels
= NULL
;
2739 cookie
->relend
= NULL
;
2744 cookie
->rels
= _bfd_coff_read_internal_relocs (abfd
, sec
, false, NULL
,
2747 if (cookie
->rels
== NULL
)
2750 cookie
->rel
= cookie
->rels
;
2751 cookie
->relend
= (cookie
->rels
+ sec
->reloc_count
);
2755 /* Free the memory allocated by init_reloc_cookie_rels,
2759 fini_reloc_cookie_rels (struct coff_reloc_cookie
*cookie
,
2763 /* PR 20401. The relocs may not have been cached, so check first.
2764 If the relocs were loaded by init_reloc_cookie_rels() then this
2765 will be the case. FIXME: Would performance be improved if the
2766 relocs *were* cached ? */
2767 && coff_section_data (NULL
, sec
)
2768 && coff_section_data (NULL
, sec
)->relocs
!= cookie
->rels
)
2769 free (cookie
->rels
);
2772 /* Initialize the whole of COOKIE for input section SEC. */
2775 init_reloc_cookie_for_section (struct coff_reloc_cookie
*cookie
,
2776 struct bfd_link_info
*info
,
2779 if (!init_reloc_cookie (cookie
, info
, sec
->owner
))
2782 if (!init_reloc_cookie_rels (cookie
, info
, sec
->owner
, sec
))
2784 fini_reloc_cookie (cookie
, sec
->owner
);
2790 /* Free the memory allocated by init_reloc_cookie_for_section,
2794 fini_reloc_cookie_for_section (struct coff_reloc_cookie
*cookie
,
2797 fini_reloc_cookie_rels (cookie
, sec
);
2798 fini_reloc_cookie (cookie
, sec
->owner
);
2802 _bfd_coff_gc_mark_hook (asection
*sec
,
2803 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2804 struct internal_reloc
*rel ATTRIBUTE_UNUSED
,
2805 struct coff_link_hash_entry
*h
,
2806 struct internal_syment
*sym
)
2810 switch (h
->root
.type
)
2812 case bfd_link_hash_defined
:
2813 case bfd_link_hash_defweak
:
2814 return h
->root
.u
.def
.section
;
2816 case bfd_link_hash_common
:
2817 return h
->root
.u
.c
.p
->section
;
2819 case bfd_link_hash_undefweak
:
2820 if (h
->symbol_class
== C_NT_WEAK
&& h
->numaux
== 1)
2822 /* PE weak externals. A weak symbol may include an auxiliary
2823 record indicating that if the weak symbol is not resolved,
2824 another external symbol is used instead. */
2825 struct coff_link_hash_entry
*h2
=
2826 h
->auxbfd
->tdata
.coff_obj_data
->sym_hashes
[
2827 h
->aux
->x_sym
.x_tagndx
.l
];
2829 if (h2
&& h2
->root
.type
!= bfd_link_hash_undefined
)
2830 return h2
->root
.u
.def
.section
;
2834 case bfd_link_hash_undefined
:
2841 return coff_section_from_bfd_index (sec
->owner
, sym
->n_scnum
);
2844 /* COOKIE->rel describes a relocation against section SEC, which is
2845 a section we've decided to keep. Return the section that contains
2846 the relocation symbol, or NULL if no section contains it. */
2849 _bfd_coff_gc_mark_rsec (struct bfd_link_info
*info
, asection
*sec
,
2850 coff_gc_mark_hook_fn gc_mark_hook
,
2851 struct coff_reloc_cookie
*cookie
)
2853 struct coff_link_hash_entry
*h
;
2855 h
= cookie
->sym_hashes
[cookie
->rel
->r_symndx
];
2858 while (h
->root
.type
== bfd_link_hash_indirect
2859 || h
->root
.type
== bfd_link_hash_warning
)
2860 h
= (struct coff_link_hash_entry
*) h
->root
.u
.i
.link
;
2862 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, h
, NULL
);
2865 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, NULL
,
2867 + obj_convert (sec
->owner
)[cookie
->rel
->r_symndx
])->native
->u
.syment
);
2870 static bool _bfd_coff_gc_mark
2871 (struct bfd_link_info
*, asection
*, coff_gc_mark_hook_fn
);
2873 /* COOKIE->rel describes a relocation against section SEC, which is
2874 a section we've decided to keep. Mark the section that contains
2875 the relocation symbol. */
2878 _bfd_coff_gc_mark_reloc (struct bfd_link_info
*info
,
2880 coff_gc_mark_hook_fn gc_mark_hook
,
2881 struct coff_reloc_cookie
*cookie
)
2885 rsec
= _bfd_coff_gc_mark_rsec (info
, sec
, gc_mark_hook
, cookie
);
2886 if (rsec
&& !rsec
->gc_mark
)
2888 if (bfd_get_flavour (rsec
->owner
) != bfd_target_coff_flavour
)
2890 else if (!_bfd_coff_gc_mark (info
, rsec
, gc_mark_hook
))
2896 /* The mark phase of garbage collection. For a given section, mark
2897 it and any sections in this section's group, and all the sections
2898 which define symbols to which it refers. */
2901 _bfd_coff_gc_mark (struct bfd_link_info
*info
,
2903 coff_gc_mark_hook_fn gc_mark_hook
)
2909 /* Look through the section relocs. */
2910 if ((sec
->flags
& SEC_RELOC
) != 0
2911 && sec
->reloc_count
> 0)
2913 struct coff_reloc_cookie cookie
;
2915 if (!init_reloc_cookie_for_section (&cookie
, info
, sec
))
2919 for (; cookie
.rel
< cookie
.relend
; cookie
.rel
++)
2921 if (!_bfd_coff_gc_mark_reloc (info
, sec
, gc_mark_hook
, &cookie
))
2927 fini_reloc_cookie_for_section (&cookie
, sec
);
2935 _bfd_coff_gc_mark_extra_sections (struct bfd_link_info
*info
,
2936 coff_gc_mark_hook_fn mark_hook ATTRIBUTE_UNUSED
)
2940 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
2945 if (bfd_get_flavour (ibfd
) != bfd_target_coff_flavour
)
2948 /* Ensure all linker created sections are kept, and see whether
2949 any other section is already marked. */
2951 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
2953 if ((isec
->flags
& SEC_LINKER_CREATED
) != 0)
2955 else if (isec
->gc_mark
)
2959 /* If no section in this file will be kept, then we can
2960 toss out debug sections. */
2964 /* Keep debug and special sections like .comment when they are
2965 not part of a group, or when we have single-member groups. */
2966 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
2967 if ((isec
->flags
& SEC_DEBUGGING
) != 0
2968 || (isec
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0)
2974 /* Sweep symbols in swept sections. Called via coff_link_hash_traverse. */
2977 coff_gc_sweep_symbol (struct coff_link_hash_entry
*h
,
2978 void *data ATTRIBUTE_UNUSED
)
2980 if (h
->root
.type
== bfd_link_hash_warning
)
2981 h
= (struct coff_link_hash_entry
*) h
->root
.u
.i
.link
;
2983 if ((h
->root
.type
== bfd_link_hash_defined
2984 || h
->root
.type
== bfd_link_hash_defweak
)
2985 && !h
->root
.u
.def
.section
->gc_mark
2986 && !(h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
))
2988 /* Do our best to hide the symbol. */
2989 h
->root
.u
.def
.section
= bfd_und_section_ptr
;
2990 h
->symbol_class
= C_HIDDEN
;
2996 /* The sweep phase of garbage collection. Remove all garbage sections. */
2998 typedef bool (*gc_sweep_hook_fn
)
2999 (bfd
*, struct bfd_link_info
*, asection
*, const struct internal_reloc
*);
3002 coff_gc_sweep (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
3006 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3010 if (bfd_get_flavour (sub
) != bfd_target_coff_flavour
)
3013 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3015 /* Keep debug and special sections. */
3016 if ((o
->flags
& (SEC_DEBUGGING
| SEC_LINKER_CREATED
)) != 0
3017 || (o
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0)
3019 else if (startswith (o
->name
, ".idata")
3020 || startswith (o
->name
, ".pdata")
3021 || startswith (o
->name
, ".xdata")
3022 || startswith (o
->name
, ".rsrc"))
3028 /* Skip sweeping sections already excluded. */
3029 if (o
->flags
& SEC_EXCLUDE
)
3032 /* Since this is early in the link process, it is simple
3033 to remove a section from the output. */
3034 o
->flags
|= SEC_EXCLUDE
;
3036 if (info
->print_gc_sections
&& o
->size
!= 0)
3037 /* xgettext: c-format */
3038 _bfd_error_handler (_("removing unused section '%pA' in file '%pB'"),
3042 /* But we also have to update some of the relocation
3043 info we collected before. */
3045 && (o
->flags
& SEC_RELOC
) != 0
3046 && o
->reloc_count
> 0
3047 && !bfd_is_abs_section (o
->output_section
))
3049 struct internal_reloc
*internal_relocs
;
3053 = _bfd_coff_link_read_relocs (o
->owner
, o
, NULL
, NULL
,
3055 if (internal_relocs
== NULL
)
3058 r
= (*gc_sweep_hook
) (o
->owner
, info
, o
, internal_relocs
);
3060 if (coff_section_data (o
)->relocs
!= internal_relocs
)
3061 free (internal_relocs
);
3070 /* Remove the symbols that were in the swept sections from the dynamic
3072 coff_link_hash_traverse (coff_hash_table (info
), coff_gc_sweep_symbol
,
3078 /* Keep all sections containing symbols undefined on the command-line,
3079 and the section containing the entry symbol. */
3082 _bfd_coff_gc_keep (struct bfd_link_info
*info
)
3084 struct bfd_sym_chain
*sym
;
3086 for (sym
= info
->gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
3088 struct coff_link_hash_entry
*h
;
3090 h
= coff_link_hash_lookup (coff_hash_table (info
), sym
->name
,
3091 false, false, false);
3094 && (h
->root
.type
== bfd_link_hash_defined
3095 || h
->root
.type
== bfd_link_hash_defweak
)
3096 && !bfd_is_abs_section (h
->root
.u
.def
.section
))
3097 h
->root
.u
.def
.section
->flags
|= SEC_KEEP
;
3101 /* Do mark and sweep of unused sections. */
3104 bfd_coff_gc_sections (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
3108 /* FIXME: Should we implement this? */
3110 const bfd_coff_backend_data
*bed
= coff_backend_info (abfd
);
3112 if (!bed
->can_gc_sections
3113 || !is_coff_hash_table (info
->hash
))
3115 _bfd_error_handler(_("warning: gc-sections option ignored"));
3120 _bfd_coff_gc_keep (info
);
3122 /* Grovel through relocs to find out who stays ... */
3123 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3127 if (bfd_get_flavour (sub
) != bfd_target_coff_flavour
)
3130 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3132 if (((o
->flags
& (SEC_EXCLUDE
| SEC_KEEP
)) == SEC_KEEP
3133 || startswith (o
->name
, ".vectors")
3134 || startswith (o
->name
, ".ctors")
3135 || startswith (o
->name
, ".dtors"))
3138 if (!_bfd_coff_gc_mark (info
, o
, _bfd_coff_gc_mark_hook
))
3144 /* Allow the backend to mark additional target specific sections. */
3145 _bfd_coff_gc_mark_extra_sections (info
, _bfd_coff_gc_mark_hook
);
3147 /* ... and mark SEC_EXCLUDE for those that go. */
3148 return coff_gc_sweep (abfd
, info
);
3151 /* Return name used to identify a comdat group. */
3154 bfd_coff_group_name (bfd
*abfd
, const asection
*sec
)
3156 struct coff_comdat_info
*ci
= bfd_coff_get_comdat_section (abfd
, sec
);
3163 _bfd_coff_close_and_cleanup (bfd
*abfd
)
3165 struct coff_tdata
*tdata
= coff_data (abfd
);
3170 Do not clear the keep_syms and keep_strings flags.
3171 These may have been set by pe_ILF_build_a_bfd() indicating
3172 that the syms and strings pointers are not to be freed. */
3173 if (bfd_get_format (abfd
) == bfd_object
3174 && bfd_family_coff (abfd
)
3175 && !_bfd_coff_free_symbols (abfd
))
3178 if (bfd_get_format (abfd
) == bfd_object
3179 || bfd_get_format (abfd
) == bfd_core
)
3180 _bfd_dwarf2_cleanup_debug_info (abfd
, &tdata
->dwarf2_find_line_info
);
3182 return _bfd_generic_close_and_cleanup (abfd
);