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
)
2047 ((coffsymbol (symbol
)->native
->u
.syment
.n_value
-
2048 (bfd_hostptr_t
) obj_raw_syments (abfd
))
2049 / sizeof (combined_entry_type
));
2052 /* Print out information about COFF symbol. */
2055 coff_print_symbol (bfd
*abfd
,
2058 bfd_print_symbol_type how
)
2060 FILE * file
= (FILE *) filep
;
2064 case bfd_print_symbol_name
:
2065 fprintf (file
, "%s", symbol
->name
);
2068 case bfd_print_symbol_more
:
2069 fprintf (file
, "coff %s %s",
2070 coffsymbol (symbol
)->native
? "n" : "g",
2071 coffsymbol (symbol
)->lineno
? "l" : " ");
2074 case bfd_print_symbol_all
:
2075 if (coffsymbol (symbol
)->native
)
2079 combined_entry_type
*combined
= coffsymbol (symbol
)->native
;
2080 combined_entry_type
*root
= obj_raw_syments (abfd
);
2081 struct lineno_cache_entry
*l
= coffsymbol (symbol
)->lineno
;
2083 fprintf (file
, "[%3ld]", (long) (combined
- root
));
2085 /* PR 17512: file: 079-33786-0.001:0.1. */
2086 if (combined
< obj_raw_syments (abfd
)
2087 || combined
>= obj_raw_syments (abfd
) + obj_raw_syment_count (abfd
))
2089 fprintf (file
, _("<corrupt info> %s"), symbol
->name
);
2093 BFD_ASSERT (combined
->is_sym
);
2094 if (! combined
->fix_value
)
2095 val
= (bfd_vma
) combined
->u
.syment
.n_value
;
2097 val
= ((combined
->u
.syment
.n_value
- (bfd_hostptr_t
) root
)
2098 / sizeof (combined_entry_type
));
2100 fprintf (file
, "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x",
2101 combined
->u
.syment
.n_scnum
,
2102 combined
->u
.syment
.n_flags
,
2103 combined
->u
.syment
.n_type
,
2104 combined
->u
.syment
.n_sclass
,
2105 combined
->u
.syment
.n_numaux
);
2106 bfd_fprintf_vma (abfd
, file
, val
);
2107 fprintf (file
, " %s", symbol
->name
);
2109 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
2111 combined_entry_type
*auxp
= combined
+ aux
+ 1;
2114 BFD_ASSERT (! auxp
->is_sym
);
2116 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.p
- root
;
2118 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.l
;
2120 fprintf (file
, "\n");
2122 if (bfd_coff_print_aux (abfd
, file
, root
, combined
, auxp
, aux
))
2125 switch (combined
->u
.syment
.n_sclass
)
2128 fprintf (file
, "File ");
2132 fprintf (file
, "AUX scnlen 0x%lx nreloc %ld",
2133 (unsigned long) auxp
->u
.auxent
.x_sect
.x_scnlen
,
2134 auxp
->u
.auxent
.x_sect
.x_nreloc
);
2138 if (combined
->u
.syment
.n_type
== T_NULL
)
2139 /* Probably a section symbol ? */
2141 fprintf (file
, "AUX scnlen 0x%lx nreloc %d nlnno %d",
2142 (unsigned long) auxp
->u
.auxent
.x_scn
.x_scnlen
,
2143 auxp
->u
.auxent
.x_scn
.x_nreloc
,
2144 auxp
->u
.auxent
.x_scn
.x_nlinno
);
2145 if (auxp
->u
.auxent
.x_scn
.x_checksum
!= 0
2146 || auxp
->u
.auxent
.x_scn
.x_associated
!= 0
2147 || auxp
->u
.auxent
.x_scn
.x_comdat
!= 0)
2148 fprintf (file
, " checksum 0x%lx assoc %d comdat %d",
2149 auxp
->u
.auxent
.x_scn
.x_checksum
,
2150 auxp
->u
.auxent
.x_scn
.x_associated
,
2151 auxp
->u
.auxent
.x_scn
.x_comdat
);
2157 if (ISFCN (combined
->u
.syment
.n_type
))
2162 next
= (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2165 next
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2166 llnos
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
2168 "AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld",
2170 (unsigned long) auxp
->u
.auxent
.x_sym
.x_misc
.x_fsize
,
2176 fprintf (file
, "AUX lnno %d size 0x%x tagndx %ld",
2177 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
2178 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
,
2181 fprintf (file
, " endndx %ld",
2183 (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2191 fprintf (file
, "\n%s :", l
->u
.sym
->name
);
2193 while (l
->line_number
)
2195 if (l
->line_number
> 0)
2197 fprintf (file
, "\n%4d : ", l
->line_number
);
2198 bfd_fprintf_vma (abfd
, file
, l
->u
.offset
+ symbol
->section
->vma
);
2206 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
2207 fprintf (file
, " %-5s %s %s %s",
2208 symbol
->section
->name
,
2209 coffsymbol (symbol
)->native
? "n" : "g",
2210 coffsymbol (symbol
)->lineno
? "l" : " ",
2216 /* Return whether a symbol name implies a local symbol. In COFF,
2217 local symbols generally start with ``.L''. Most targets use this
2218 function for the is_local_label_name entry point, but some may
2222 _bfd_coff_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
2225 return name
[0] == '.' && name
[1] == 'L';
2228 /* Provided a BFD, a section and an offset (in bytes, not octets) into the
2229 section, calculate and return the name of the source file and the line
2230 nearest to the wanted location. */
2233 coff_find_nearest_line_with_names (bfd
*abfd
,
2237 const char **filename_ptr
,
2238 const char **functionname_ptr
,
2239 unsigned int *line_ptr
,
2240 const struct dwarf_debug_section
*debug_sections
)
2244 unsigned int line_base
;
2245 coff_data_type
*cof
= coff_data (abfd
);
2246 /* Run through the raw syments if available. */
2247 combined_entry_type
*p
;
2248 combined_entry_type
*pend
;
2250 struct coff_section_tdata
*sec_data
;
2253 /* Before looking through the symbol table, try to use a .stab
2254 section to find the information. */
2255 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2256 &found
, filename_ptr
,
2257 functionname_ptr
, line_ptr
,
2258 &coff_data(abfd
)->line_info
))
2264 /* Also try examining DWARF2 debugging information. */
2265 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
2266 filename_ptr
, functionname_ptr
,
2267 line_ptr
, NULL
, debug_sections
,
2268 &coff_data(abfd
)->dwarf2_find_line_info
))
2271 sec_data
= coff_section_data (abfd
, section
);
2273 /* If the DWARF lookup failed, but there is DWARF information available
2274 then the problem might be that the file has been rebased. This tool
2275 changes the VMAs of all the sections, but it does not update the DWARF
2276 information. So try again, using a bias against the address sought. */
2277 if (coff_data (abfd
)->dwarf2_find_line_info
!= NULL
)
2279 bfd_signed_vma bias
= 0;
2281 /* Create a cache of the result for the next call. */
2282 if (sec_data
== NULL
&& section
->owner
== abfd
)
2284 amt
= sizeof (struct coff_section_tdata
);
2285 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
2286 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2289 if (sec_data
!= NULL
&& sec_data
->saved_bias
)
2290 bias
= sec_data
->saved_bias
;
2293 bias
= _bfd_dwarf2_find_symbol_bias (symbols
,
2294 & coff_data (abfd
)->dwarf2_find_line_info
);
2298 sec_data
->saved_bias
= true;
2299 sec_data
->bias
= bias
;
2304 && _bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
,
2306 filename_ptr
, functionname_ptr
,
2307 line_ptr
, NULL
, debug_sections
,
2308 &coff_data(abfd
)->dwarf2_find_line_info
))
2313 *functionname_ptr
= 0;
2316 /* Don't try and find line numbers in a non coff file. */
2317 if (!bfd_family_coff (abfd
))
2323 /* Find the first C_FILE symbol. */
2324 p
= cof
->raw_syments
;
2328 pend
= p
+ cof
->raw_syment_count
;
2331 BFD_ASSERT (p
->is_sym
);
2332 if (p
->u
.syment
.n_sclass
== C_FILE
)
2334 p
+= 1 + p
->u
.syment
.n_numaux
;
2342 /* Look through the C_FILE symbols to find the best one. */
2343 sec_vma
= bfd_section_vma (section
);
2344 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2345 maxdiff
= (bfd_vma
) 0 - (bfd_vma
) 1;
2349 combined_entry_type
*p2
;
2351 for (p2
= p
+ 1 + p
->u
.syment
.n_numaux
;
2353 p2
+= 1 + p2
->u
.syment
.n_numaux
)
2355 BFD_ASSERT (p2
->is_sym
);
2356 if (p2
->u
.syment
.n_scnum
> 0
2358 == coff_section_from_bfd_index (abfd
,
2359 p2
->u
.syment
.n_scnum
)))
2361 if (p2
->u
.syment
.n_sclass
== C_FILE
)
2370 file_addr
= (bfd_vma
) p2
->u
.syment
.n_value
;
2371 /* PR 11512: Include the section address of the function name symbol. */
2372 if (p2
->u
.syment
.n_scnum
> 0)
2373 file_addr
+= coff_section_from_bfd_index (abfd
,
2374 p2
->u
.syment
.n_scnum
)->vma
;
2375 /* We use <= MAXDIFF here so that if we get a zero length
2376 file, we actually use the next file entry. */
2378 && offset
+ sec_vma
>= file_addr
2379 && offset
+ sec_vma
- file_addr
<= maxdiff
)
2381 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2382 maxdiff
= offset
+ sec_vma
- p2
->u
.syment
.n_value
;
2385 if (p
->u
.syment
.n_value
>= cof
->raw_syment_count
)
2388 /* Avoid endless loops on erroneous files by ensuring that
2389 we always move forward in the file. */
2390 if (p
>= cof
->raw_syments
+ p
->u
.syment
.n_value
)
2393 p
= cof
->raw_syments
+ p
->u
.syment
.n_value
;
2394 if (!p
->is_sym
|| p
->u
.syment
.n_sclass
!= C_FILE
)
2399 if (section
->lineno_count
== 0)
2401 *functionname_ptr
= NULL
;
2406 /* Now wander though the raw linenumbers of the section.
2407 If we have been called on this section before, and the offset
2408 we want is further down then we can prime the lookup loop. */
2409 if (sec_data
!= NULL
2411 && offset
>= sec_data
->offset
)
2414 *functionname_ptr
= sec_data
->function
;
2415 line_base
= sec_data
->line_base
;
2423 if (section
->lineno
!= NULL
)
2425 bfd_vma last_value
= 0;
2427 l
= §ion
->lineno
[i
];
2429 for (; i
< section
->lineno_count
; i
++)
2431 if (l
->line_number
== 0)
2433 /* Get the symbol this line number points at. */
2434 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
2435 if (coff
->symbol
.value
> offset
)
2438 *functionname_ptr
= coff
->symbol
.name
;
2439 last_value
= coff
->symbol
.value
;
2442 combined_entry_type
*s
= coff
->native
;
2444 BFD_ASSERT (s
->is_sym
);
2445 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2447 /* In XCOFF a debugging symbol can follow the
2449 if (((size_t) ((char *) s
- (char *) obj_raw_syments (abfd
))
2450 < obj_raw_syment_count (abfd
) * sizeof (*s
))
2451 && s
->u
.syment
.n_scnum
== N_DEBUG
)
2452 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2454 /* S should now point to the .bf of the function. */
2455 if (((size_t) ((char *) s
- (char *) obj_raw_syments (abfd
))
2456 < obj_raw_syment_count (abfd
) * sizeof (*s
))
2457 && s
->u
.syment
.n_numaux
)
2459 /* The linenumber is stored in the auxent. */
2460 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
2462 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
2463 *line_ptr
= line_base
;
2469 if (l
->u
.offset
> offset
)
2471 *line_ptr
= l
->line_number
+ line_base
- 1;
2476 /* If we fell off the end of the loop, then assume that this
2477 symbol has no line number info. Otherwise, symbols with no
2478 line number info get reported with the line number of the
2479 last line of the last symbol which does have line number
2480 info. We use 0x100 as a slop to account for cases where the
2481 last line has executable code. */
2482 if (i
>= section
->lineno_count
2484 && offset
- last_value
> 0x100)
2486 *functionname_ptr
= NULL
;
2491 /* Cache the results for the next call. */
2492 if (sec_data
== NULL
&& section
->owner
== abfd
)
2494 amt
= sizeof (struct coff_section_tdata
);
2495 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
2496 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2499 if (sec_data
!= NULL
)
2501 sec_data
->offset
= offset
;
2502 sec_data
->i
= i
- 1;
2503 sec_data
->function
= *functionname_ptr
;
2504 sec_data
->line_base
= line_base
;
2511 coff_find_nearest_line (bfd
*abfd
,
2515 const char **filename_ptr
,
2516 const char **functionname_ptr
,
2517 unsigned int *line_ptr
,
2518 unsigned int *discriminator_ptr
)
2520 if (discriminator_ptr
)
2521 *discriminator_ptr
= 0;
2522 return coff_find_nearest_line_with_names (abfd
, symbols
, section
, offset
,
2523 filename_ptr
, functionname_ptr
,
2524 line_ptr
, dwarf_debug_sections
);
2528 coff_find_inliner_info (bfd
*abfd
,
2529 const char **filename_ptr
,
2530 const char **functionname_ptr
,
2531 unsigned int *line_ptr
)
2535 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
2536 functionname_ptr
, line_ptr
,
2537 &coff_data(abfd
)->dwarf2_find_line_info
);
2542 coff_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
2546 if (!bfd_link_relocatable (info
))
2547 size
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
2549 size
= bfd_coff_filhsz (abfd
);
2551 size
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
2555 /* Change the class of a coff symbol held by BFD. */
2558 bfd_coff_set_symbol_class (bfd
* abfd
,
2560 unsigned int symbol_class
)
2562 coff_symbol_type
* csym
;
2564 csym
= coff_symbol_from (symbol
);
2567 bfd_set_error (bfd_error_invalid_operation
);
2570 else if (csym
->native
== NULL
)
2572 /* This is an alien symbol which no native coff backend data.
2573 We cheat here by creating a fake native entry for it and
2574 then filling in the class. This code is based on that in
2575 coff_write_alien_symbol(). */
2577 combined_entry_type
* native
;
2578 size_t amt
= sizeof (* native
);
2580 native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
2584 native
->is_sym
= true;
2585 native
->u
.syment
.n_type
= T_NULL
;
2586 native
->u
.syment
.n_sclass
= symbol_class
;
2588 if (bfd_is_und_section (symbol
->section
))
2590 native
->u
.syment
.n_scnum
= N_UNDEF
;
2591 native
->u
.syment
.n_value
= symbol
->value
;
2593 else if (bfd_is_com_section (symbol
->section
))
2595 native
->u
.syment
.n_scnum
= N_UNDEF
;
2596 native
->u
.syment
.n_value
= symbol
->value
;
2600 native
->u
.syment
.n_scnum
=
2601 symbol
->section
->output_section
->target_index
;
2602 native
->u
.syment
.n_value
= (symbol
->value
2603 + symbol
->section
->output_offset
);
2604 if (! obj_pe (abfd
))
2605 native
->u
.syment
.n_value
+= symbol
->section
->output_section
->vma
;
2607 /* Copy the any flags from the file header into the symbol.
2609 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (& csym
->symbol
)->flags
;
2612 csym
->native
= native
;
2615 csym
->native
->u
.syment
.n_sclass
= symbol_class
;
2621 _bfd_coff_section_already_linked (bfd
*abfd
,
2623 struct bfd_link_info
*info
)
2626 const char *name
, *key
;
2627 struct bfd_section_already_linked
*l
;
2628 struct bfd_section_already_linked_hash_entry
*already_linked_list
;
2629 struct coff_comdat_info
*s_comdat
;
2631 if (sec
->output_section
== bfd_abs_section_ptr
)
2635 if ((flags
& SEC_LINK_ONCE
) == 0)
2638 /* The COFF backend linker doesn't support group sections. */
2639 if ((flags
& SEC_GROUP
) != 0)
2642 name
= bfd_section_name (sec
);
2643 s_comdat
= bfd_coff_get_comdat_section (abfd
, sec
);
2645 if (s_comdat
!= NULL
)
2646 key
= s_comdat
->name
;
2649 if (startswith (name
, ".gnu.linkonce.")
2650 && (key
= strchr (name
+ sizeof (".gnu.linkonce.") - 1, '.')) != NULL
)
2653 /* FIXME: gcc as of 2011-09 emits sections like .text$<key>,
2654 .xdata$<key> and .pdata$<key> only the first of which has a
2655 comdat key. Should these all match the LTO IR key? */
2659 already_linked_list
= bfd_section_already_linked_table_lookup (key
);
2661 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
2663 struct coff_comdat_info
*l_comdat
;
2665 l_comdat
= bfd_coff_get_comdat_section (l
->sec
->owner
, l
->sec
);
2667 /* The section names must match, and both sections must be
2668 comdat and have the same comdat name, or both sections must
2669 be non-comdat. LTO IR plugin sections are an exception. They
2670 are always named .gnu.linkonce.t.<key> (<key> is some string)
2671 and match any comdat section with comdat name of <key>, and
2672 any linkonce section with the same suffix, ie.
2673 .gnu.linkonce.*.<key>. */
2674 if (((s_comdat
!= NULL
) == (l_comdat
!= NULL
)
2675 && strcmp (name
, l
->sec
->name
) == 0)
2676 || (l
->sec
->owner
->flags
& BFD_PLUGIN
) != 0
2677 || (sec
->owner
->flags
& BFD_PLUGIN
) != 0)
2679 /* The section has already been linked. See if we should
2681 return _bfd_handle_already_linked (sec
, l
, info
);
2685 /* This is the first section with this name. Record it. */
2686 if (!bfd_section_already_linked_table_insert (already_linked_list
, sec
))
2687 info
->callbacks
->einfo (_("%F%P: already_linked_table: %E\n"));
2691 /* Initialize COOKIE for input bfd ABFD. */
2694 init_reloc_cookie (struct coff_reloc_cookie
*cookie
,
2695 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2698 /* Sometimes the symbol table does not yet have been loaded here. */
2699 bfd_coff_slurp_symbol_table (abfd
);
2701 cookie
->abfd
= abfd
;
2702 cookie
->sym_hashes
= obj_coff_sym_hashes (abfd
);
2704 cookie
->symbols
= obj_symbols (abfd
);
2709 /* Free the memory allocated by init_reloc_cookie, if appropriate. */
2712 fini_reloc_cookie (struct coff_reloc_cookie
*cookie ATTRIBUTE_UNUSED
,
2713 bfd
*abfd ATTRIBUTE_UNUSED
)
2715 /* Nothing to do. */
2718 /* Initialize the relocation information in COOKIE for input section SEC
2719 of input bfd ABFD. */
2722 init_reloc_cookie_rels (struct coff_reloc_cookie
*cookie
,
2723 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2727 if (sec
->reloc_count
== 0)
2729 cookie
->rels
= NULL
;
2730 cookie
->relend
= NULL
;
2735 cookie
->rels
= _bfd_coff_read_internal_relocs (abfd
, sec
, false, NULL
,
2738 if (cookie
->rels
== NULL
)
2741 cookie
->rel
= cookie
->rels
;
2742 cookie
->relend
= (cookie
->rels
+ sec
->reloc_count
);
2746 /* Free the memory allocated by init_reloc_cookie_rels,
2750 fini_reloc_cookie_rels (struct coff_reloc_cookie
*cookie
,
2754 /* PR 20401. The relocs may not have been cached, so check first.
2755 If the relocs were loaded by init_reloc_cookie_rels() then this
2756 will be the case. FIXME: Would performance be improved if the
2757 relocs *were* cached ? */
2758 && coff_section_data (NULL
, sec
)
2759 && coff_section_data (NULL
, sec
)->relocs
!= cookie
->rels
)
2760 free (cookie
->rels
);
2763 /* Initialize the whole of COOKIE for input section SEC. */
2766 init_reloc_cookie_for_section (struct coff_reloc_cookie
*cookie
,
2767 struct bfd_link_info
*info
,
2770 if (!init_reloc_cookie (cookie
, info
, sec
->owner
))
2773 if (!init_reloc_cookie_rels (cookie
, info
, sec
->owner
, sec
))
2775 fini_reloc_cookie (cookie
, sec
->owner
);
2781 /* Free the memory allocated by init_reloc_cookie_for_section,
2785 fini_reloc_cookie_for_section (struct coff_reloc_cookie
*cookie
,
2788 fini_reloc_cookie_rels (cookie
, sec
);
2789 fini_reloc_cookie (cookie
, sec
->owner
);
2793 _bfd_coff_gc_mark_hook (asection
*sec
,
2794 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2795 struct internal_reloc
*rel ATTRIBUTE_UNUSED
,
2796 struct coff_link_hash_entry
*h
,
2797 struct internal_syment
*sym
)
2801 switch (h
->root
.type
)
2803 case bfd_link_hash_defined
:
2804 case bfd_link_hash_defweak
:
2805 return h
->root
.u
.def
.section
;
2807 case bfd_link_hash_common
:
2808 return h
->root
.u
.c
.p
->section
;
2810 case bfd_link_hash_undefweak
:
2811 if (h
->symbol_class
== C_NT_WEAK
&& h
->numaux
== 1)
2813 /* PE weak externals. A weak symbol may include an auxiliary
2814 record indicating that if the weak symbol is not resolved,
2815 another external symbol is used instead. */
2816 struct coff_link_hash_entry
*h2
=
2817 h
->auxbfd
->tdata
.coff_obj_data
->sym_hashes
[
2818 h
->aux
->x_sym
.x_tagndx
.l
];
2820 if (h2
&& h2
->root
.type
!= bfd_link_hash_undefined
)
2821 return h2
->root
.u
.def
.section
;
2825 case bfd_link_hash_undefined
:
2832 return coff_section_from_bfd_index (sec
->owner
, sym
->n_scnum
);
2835 /* COOKIE->rel describes a relocation against section SEC, which is
2836 a section we've decided to keep. Return the section that contains
2837 the relocation symbol, or NULL if no section contains it. */
2840 _bfd_coff_gc_mark_rsec (struct bfd_link_info
*info
, asection
*sec
,
2841 coff_gc_mark_hook_fn gc_mark_hook
,
2842 struct coff_reloc_cookie
*cookie
)
2844 struct coff_link_hash_entry
*h
;
2846 h
= cookie
->sym_hashes
[cookie
->rel
->r_symndx
];
2849 while (h
->root
.type
== bfd_link_hash_indirect
2850 || h
->root
.type
== bfd_link_hash_warning
)
2851 h
= (struct coff_link_hash_entry
*) h
->root
.u
.i
.link
;
2853 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, h
, NULL
);
2856 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, NULL
,
2858 + obj_convert (sec
->owner
)[cookie
->rel
->r_symndx
])->native
->u
.syment
);
2861 static bool _bfd_coff_gc_mark
2862 (struct bfd_link_info
*, asection
*, coff_gc_mark_hook_fn
);
2864 /* COOKIE->rel describes a relocation against section SEC, which is
2865 a section we've decided to keep. Mark the section that contains
2866 the relocation symbol. */
2869 _bfd_coff_gc_mark_reloc (struct bfd_link_info
*info
,
2871 coff_gc_mark_hook_fn gc_mark_hook
,
2872 struct coff_reloc_cookie
*cookie
)
2876 rsec
= _bfd_coff_gc_mark_rsec (info
, sec
, gc_mark_hook
, cookie
);
2877 if (rsec
&& !rsec
->gc_mark
)
2879 if (bfd_get_flavour (rsec
->owner
) != bfd_target_coff_flavour
)
2881 else if (!_bfd_coff_gc_mark (info
, rsec
, gc_mark_hook
))
2887 /* The mark phase of garbage collection. For a given section, mark
2888 it and any sections in this section's group, and all the sections
2889 which define symbols to which it refers. */
2892 _bfd_coff_gc_mark (struct bfd_link_info
*info
,
2894 coff_gc_mark_hook_fn gc_mark_hook
)
2900 /* Look through the section relocs. */
2901 if ((sec
->flags
& SEC_RELOC
) != 0
2902 && sec
->reloc_count
> 0)
2904 struct coff_reloc_cookie cookie
;
2906 if (!init_reloc_cookie_for_section (&cookie
, info
, sec
))
2910 for (; cookie
.rel
< cookie
.relend
; cookie
.rel
++)
2912 if (!_bfd_coff_gc_mark_reloc (info
, sec
, gc_mark_hook
, &cookie
))
2918 fini_reloc_cookie_for_section (&cookie
, sec
);
2926 _bfd_coff_gc_mark_extra_sections (struct bfd_link_info
*info
,
2927 coff_gc_mark_hook_fn mark_hook ATTRIBUTE_UNUSED
)
2931 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
2936 if (bfd_get_flavour (ibfd
) != bfd_target_coff_flavour
)
2939 /* Ensure all linker created sections are kept, and see whether
2940 any other section is already marked. */
2942 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
2944 if ((isec
->flags
& SEC_LINKER_CREATED
) != 0)
2946 else if (isec
->gc_mark
)
2950 /* If no section in this file will be kept, then we can
2951 toss out debug sections. */
2955 /* Keep debug and special sections like .comment when they are
2956 not part of a group, or when we have single-member groups. */
2957 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
2958 if ((isec
->flags
& SEC_DEBUGGING
) != 0
2959 || (isec
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0)
2965 /* Sweep symbols in swept sections. Called via coff_link_hash_traverse. */
2968 coff_gc_sweep_symbol (struct coff_link_hash_entry
*h
,
2969 void *data ATTRIBUTE_UNUSED
)
2971 if (h
->root
.type
== bfd_link_hash_warning
)
2972 h
= (struct coff_link_hash_entry
*) h
->root
.u
.i
.link
;
2974 if ((h
->root
.type
== bfd_link_hash_defined
2975 || h
->root
.type
== bfd_link_hash_defweak
)
2976 && !h
->root
.u
.def
.section
->gc_mark
2977 && !(h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
))
2979 /* Do our best to hide the symbol. */
2980 h
->root
.u
.def
.section
= bfd_und_section_ptr
;
2981 h
->symbol_class
= C_HIDDEN
;
2987 /* The sweep phase of garbage collection. Remove all garbage sections. */
2989 typedef bool (*gc_sweep_hook_fn
)
2990 (bfd
*, struct bfd_link_info
*, asection
*, const struct internal_reloc
*);
2993 coff_gc_sweep (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
2997 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3001 if (bfd_get_flavour (sub
) != bfd_target_coff_flavour
)
3004 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3006 /* Keep debug and special sections. */
3007 if ((o
->flags
& (SEC_DEBUGGING
| SEC_LINKER_CREATED
)) != 0
3008 || (o
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0)
3010 else if (startswith (o
->name
, ".idata")
3011 || startswith (o
->name
, ".pdata")
3012 || startswith (o
->name
, ".xdata")
3013 || startswith (o
->name
, ".rsrc"))
3019 /* Skip sweeping sections already excluded. */
3020 if (o
->flags
& SEC_EXCLUDE
)
3023 /* Since this is early in the link process, it is simple
3024 to remove a section from the output. */
3025 o
->flags
|= SEC_EXCLUDE
;
3027 if (info
->print_gc_sections
&& o
->size
!= 0)
3028 /* xgettext: c-format */
3029 _bfd_error_handler (_("removing unused section '%pA' in file '%pB'"),
3033 /* But we also have to update some of the relocation
3034 info we collected before. */
3036 && (o
->flags
& SEC_RELOC
) != 0
3037 && o
->reloc_count
> 0
3038 && !bfd_is_abs_section (o
->output_section
))
3040 struct internal_reloc
*internal_relocs
;
3044 = _bfd_coff_link_read_relocs (o
->owner
, o
, NULL
, NULL
,
3046 if (internal_relocs
== NULL
)
3049 r
= (*gc_sweep_hook
) (o
->owner
, info
, o
, internal_relocs
);
3051 if (coff_section_data (o
)->relocs
!= internal_relocs
)
3052 free (internal_relocs
);
3061 /* Remove the symbols that were in the swept sections from the dynamic
3063 coff_link_hash_traverse (coff_hash_table (info
), coff_gc_sweep_symbol
,
3069 /* Keep all sections containing symbols undefined on the command-line,
3070 and the section containing the entry symbol. */
3073 _bfd_coff_gc_keep (struct bfd_link_info
*info
)
3075 struct bfd_sym_chain
*sym
;
3077 for (sym
= info
->gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
3079 struct coff_link_hash_entry
*h
;
3081 h
= coff_link_hash_lookup (coff_hash_table (info
), sym
->name
,
3082 false, false, false);
3085 && (h
->root
.type
== bfd_link_hash_defined
3086 || h
->root
.type
== bfd_link_hash_defweak
)
3087 && !bfd_is_abs_section (h
->root
.u
.def
.section
))
3088 h
->root
.u
.def
.section
->flags
|= SEC_KEEP
;
3092 /* Do mark and sweep of unused sections. */
3095 bfd_coff_gc_sections (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
3099 /* FIXME: Should we implement this? */
3101 const bfd_coff_backend_data
*bed
= coff_backend_info (abfd
);
3103 if (!bed
->can_gc_sections
3104 || !is_coff_hash_table (info
->hash
))
3106 _bfd_error_handler(_("warning: gc-sections option ignored"));
3111 _bfd_coff_gc_keep (info
);
3113 /* Grovel through relocs to find out who stays ... */
3114 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3118 if (bfd_get_flavour (sub
) != bfd_target_coff_flavour
)
3121 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3123 if (((o
->flags
& (SEC_EXCLUDE
| SEC_KEEP
)) == SEC_KEEP
3124 || startswith (o
->name
, ".vectors")
3125 || startswith (o
->name
, ".ctors")
3126 || startswith (o
->name
, ".dtors"))
3129 if (!_bfd_coff_gc_mark (info
, o
, _bfd_coff_gc_mark_hook
))
3135 /* Allow the backend to mark additional target specific sections. */
3136 _bfd_coff_gc_mark_extra_sections (info
, _bfd_coff_gc_mark_hook
);
3138 /* ... and mark SEC_EXCLUDE for those that go. */
3139 return coff_gc_sweep (abfd
, info
);
3142 /* Return name used to identify a comdat group. */
3145 bfd_coff_group_name (bfd
*abfd
, const asection
*sec
)
3147 struct coff_comdat_info
*ci
= bfd_coff_get_comdat_section (abfd
, sec
);
3154 _bfd_coff_close_and_cleanup (bfd
*abfd
)
3156 struct coff_tdata
*tdata
= coff_data (abfd
);
3161 Do not clear the keep_syms and keep_strings flags.
3162 These may have been set by pe_ILF_build_a_bfd() indicating
3163 that the syms and strings pointers are not to be freed. */
3164 if (bfd_get_format (abfd
) == bfd_object
3165 && bfd_family_coff (abfd
)
3166 && !_bfd_coff_free_symbols (abfd
))
3169 if (bfd_get_format (abfd
) == bfd_object
3170 || bfd_get_format (abfd
) == bfd_core
)
3171 _bfd_dwarf2_cleanup_debug_info (abfd
, &tdata
->dwarf2_find_line_info
);
3173 return _bfd_generic_close_and_cleanup (abfd
);