1 /* Support for the generic parts of COFF, for BFD.
2 Copyright (C) 1990-2022 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_write_auxent_fname (bfd
*abfd
,
853 union internal_auxent
*auxent
,
854 bfd_size_type
*string_size_p
)
856 unsigned int str_length
= strlen (str
);
857 unsigned int filnmlen
= bfd_coff_filnmlen (abfd
);
859 if (bfd_coff_long_filenames (abfd
))
861 if (str_length
<= filnmlen
)
862 strncpy (auxent
->x_file
.x_n
.x_fname
, str
, filnmlen
);
865 auxent
->x_file
.x_n
.x_n
.x_offset
= *string_size_p
+ STRING_SIZE_SIZE
;
866 auxent
->x_file
.x_n
.x_n
.x_zeroes
= 0;
867 *string_size_p
+= str_length
+ 1;
872 strncpy (auxent
->x_file
.x_n
.x_fname
, str
, filnmlen
);
873 if (str_length
> filnmlen
)
874 str
[filnmlen
] = '\0';
879 coff_fix_symbol_name (bfd
*abfd
,
881 combined_entry_type
*native
,
882 bfd_size_type
*string_size_p
,
883 asection
**debug_string_section_p
,
884 bfd_size_type
*debug_string_size_p
)
886 unsigned int name_length
;
887 char *name
= (char *) (symbol
->name
);
891 /* COFF symbols always have names, so we'll make one up. */
892 symbol
->name
= "strange";
893 name
= (char *) symbol
->name
;
895 name_length
= strlen (name
);
897 BFD_ASSERT (native
->is_sym
);
898 if (native
->u
.syment
.n_sclass
== C_FILE
899 && native
->u
.syment
.n_numaux
> 0)
901 if (bfd_coff_force_symnames_in_strings (abfd
))
903 native
->u
.syment
._n
._n_n
._n_offset
=
904 (*string_size_p
+ STRING_SIZE_SIZE
);
905 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
906 *string_size_p
+= 6; /* strlen(".file") + 1 */
909 strncpy (native
->u
.syment
._n
._n_name
, ".file", SYMNMLEN
);
911 BFD_ASSERT (! (native
+ 1)->is_sym
);
912 coff_write_auxent_fname (abfd
, name
, &(native
+ 1)->u
.auxent
,
917 if (name_length
<= SYMNMLEN
&& !bfd_coff_force_symnames_in_strings (abfd
))
918 /* This name will fit into the symbol neatly. */
919 strncpy (native
->u
.syment
._n
._n_name
, symbol
->name
, SYMNMLEN
);
921 else if (!bfd_coff_symname_in_debug (abfd
, &native
->u
.syment
))
923 native
->u
.syment
._n
._n_n
._n_offset
= (*string_size_p
925 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
926 *string_size_p
+= name_length
+ 1;
932 int prefix_len
= bfd_coff_debug_string_prefix_length (abfd
);
934 /* This name should be written into the .debug section. For
935 some reason each name is preceded by a two byte length
936 and also followed by a null byte. FIXME: We assume that
937 the .debug section has already been created, and that it
939 if (*debug_string_section_p
== (asection
*) NULL
)
940 *debug_string_section_p
= bfd_get_section_by_name (abfd
, ".debug");
941 filepos
= bfd_tell (abfd
);
943 bfd_put_32 (abfd
, (bfd_vma
) (name_length
+ 1), buf
);
945 bfd_put_16 (abfd
, (bfd_vma
) (name_length
+ 1), buf
);
947 if (!bfd_set_section_contents (abfd
,
948 *debug_string_section_p
,
950 (file_ptr
) *debug_string_size_p
,
951 (bfd_size_type
) prefix_len
)
952 || !bfd_set_section_contents (abfd
,
953 *debug_string_section_p
,
954 (void *) symbol
->name
,
955 (file_ptr
) (*debug_string_size_p
957 (bfd_size_type
) name_length
+ 1))
959 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
961 native
->u
.syment
._n
._n_n
._n_offset
=
962 *debug_string_size_p
+ prefix_len
;
963 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
964 *debug_string_size_p
+= name_length
+ 1 + prefix_len
;
969 /* We need to keep track of the symbol index so that when we write out
970 the relocs we can get the index for a symbol. This method is a
973 #define set_index(symbol, idx) ((symbol)->udata.i = (idx))
975 /* Write a symbol out to a COFF file. */
978 coff_write_symbol (bfd
*abfd
,
980 combined_entry_type
*native
,
982 bfd_size_type
*string_size_p
,
983 asection
**debug_string_section_p
,
984 bfd_size_type
*debug_string_size_p
)
986 unsigned int numaux
= native
->u
.syment
.n_numaux
;
987 int type
= native
->u
.syment
.n_type
;
988 int n_sclass
= (int) native
->u
.syment
.n_sclass
;
989 asection
*output_section
= symbol
->section
->output_section
990 ? symbol
->section
->output_section
993 bfd_size_type symesz
;
995 BFD_ASSERT (native
->is_sym
);
997 if (native
->u
.syment
.n_sclass
== C_FILE
)
998 symbol
->flags
|= BSF_DEBUGGING
;
1000 if (symbol
->flags
& BSF_DEBUGGING
1001 && bfd_is_abs_section (symbol
->section
))
1002 native
->u
.syment
.n_scnum
= N_DEBUG
;
1004 else if (bfd_is_abs_section (symbol
->section
))
1005 native
->u
.syment
.n_scnum
= N_ABS
;
1007 else if (bfd_is_und_section (symbol
->section
))
1008 native
->u
.syment
.n_scnum
= N_UNDEF
;
1011 native
->u
.syment
.n_scnum
=
1012 output_section
->target_index
;
1014 coff_fix_symbol_name (abfd
, symbol
, native
, string_size_p
,
1015 debug_string_section_p
, debug_string_size_p
);
1017 symesz
= bfd_coff_symesz (abfd
);
1018 buf
= bfd_alloc (abfd
, symesz
);
1021 bfd_coff_swap_sym_out (abfd
, &native
->u
.syment
, buf
);
1022 if (bfd_bwrite (buf
, symesz
, abfd
) != symesz
)
1024 bfd_release (abfd
, buf
);
1026 if (native
->u
.syment
.n_numaux
> 0)
1028 bfd_size_type auxesz
;
1031 auxesz
= bfd_coff_auxesz (abfd
);
1032 buf
= bfd_alloc (abfd
, auxesz
);
1035 for (j
= 0; j
< native
->u
.syment
.n_numaux
; j
++)
1037 BFD_ASSERT (! (native
+ j
+ 1)->is_sym
);
1039 /* Adjust auxent only if this isn't the filename
1041 if (native
->u
.syment
.n_sclass
== C_FILE
1042 && (native
+ j
+ 1)->u
.auxent
.x_file
.x_ftype
)
1043 coff_write_auxent_fname (abfd
, (char *) (native
+ j
+ 1)->extrap
,
1044 &(native
+ j
+ 1)->u
.auxent
, string_size_p
);
1046 bfd_coff_swap_aux_out (abfd
,
1047 &((native
+ j
+ 1)->u
.auxent
),
1048 type
, n_sclass
, (int) j
,
1049 native
->u
.syment
.n_numaux
,
1051 if (bfd_bwrite (buf
, auxesz
, abfd
) != auxesz
)
1054 bfd_release (abfd
, buf
);
1057 /* Store the index for use when we write out the relocs. */
1058 set_index (symbol
, *written
);
1060 *written
+= numaux
+ 1;
1064 /* Write out a symbol to a COFF file that does not come from a COFF
1065 file originally. This symbol may have been created by the linker,
1066 or we may be linking a non COFF file to a COFF file. */
1069 coff_write_alien_symbol (bfd
*abfd
,
1071 struct internal_syment
*isym
,
1072 union internal_auxent
*iaux
,
1074 bfd_size_type
*string_size_p
,
1075 asection
**debug_string_section_p
,
1076 bfd_size_type
*debug_string_size_p
)
1078 combined_entry_type
*native
;
1079 combined_entry_type dummy
[2];
1080 asection
*output_section
= symbol
->section
->output_section
1081 ? symbol
->section
->output_section
1083 struct bfd_link_info
*link_info
= coff_data (abfd
)->link_info
;
1086 if ((!link_info
|| link_info
->strip_discarded
)
1087 && !bfd_is_abs_section (symbol
->section
)
1088 && symbol
->section
->output_section
== bfd_abs_section_ptr
)
1092 memset (isym
, 0, sizeof (*isym
));
1096 native
->is_sym
= true;
1097 native
[1].is_sym
= false;
1098 native
->u
.syment
.n_type
= T_NULL
;
1099 native
->u
.syment
.n_flags
= 0;
1100 native
->u
.syment
.n_numaux
= 0;
1101 if (bfd_is_und_section (symbol
->section
))
1103 native
->u
.syment
.n_scnum
= N_UNDEF
;
1104 native
->u
.syment
.n_value
= symbol
->value
;
1106 else if (bfd_is_com_section (symbol
->section
))
1108 native
->u
.syment
.n_scnum
= N_UNDEF
;
1109 native
->u
.syment
.n_value
= symbol
->value
;
1111 else if (symbol
->flags
& BSF_FILE
)
1113 native
->u
.syment
.n_scnum
= N_DEBUG
;
1114 native
->u
.syment
.n_numaux
= 1;
1116 else if (symbol
->flags
& BSF_DEBUGGING
)
1118 /* There isn't much point to writing out a debugging symbol
1119 unless we are prepared to convert it into COFF debugging
1120 format. So, we just ignore them. We must clobber the symbol
1121 name to keep it from being put in the string table. */
1124 memset (isym
, 0, sizeof (*isym
));
1129 native
->u
.syment
.n_scnum
= output_section
->target_index
;
1130 native
->u
.syment
.n_value
= (symbol
->value
1131 + symbol
->section
->output_offset
);
1132 if (! obj_pe (abfd
))
1133 native
->u
.syment
.n_value
+= output_section
->vma
;
1135 /* Copy the any flags from the file header into the symbol.
1138 coff_symbol_type
*c
= coff_symbol_from (symbol
);
1139 if (c
!= (coff_symbol_type
*) NULL
)
1140 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (&c
->symbol
)->flags
;
1144 native
->u
.syment
.n_type
= 0;
1145 if (symbol
->flags
& BSF_FILE
)
1146 native
->u
.syment
.n_sclass
= C_FILE
;
1147 else if (symbol
->flags
& BSF_LOCAL
)
1148 native
->u
.syment
.n_sclass
= C_STAT
;
1149 else if (symbol
->flags
& BSF_WEAK
)
1150 native
->u
.syment
.n_sclass
= obj_pe (abfd
) ? C_NT_WEAK
: C_WEAKEXT
;
1152 native
->u
.syment
.n_sclass
= C_EXT
;
1154 ret
= coff_write_symbol (abfd
, symbol
, native
, written
, string_size_p
,
1155 debug_string_section_p
, debug_string_size_p
);
1157 *isym
= native
->u
.syment
;
1158 if (iaux
!= NULL
&& native
->u
.syment
.n_numaux
)
1159 *iaux
= native
[1].u
.auxent
;
1163 /* Write a native symbol to a COFF file. */
1166 coff_write_native_symbol (bfd
*abfd
,
1167 coff_symbol_type
*symbol
,
1169 bfd_size_type
*string_size_p
,
1170 asection
**debug_string_section_p
,
1171 bfd_size_type
*debug_string_size_p
)
1173 combined_entry_type
*native
= symbol
->native
;
1174 alent
*lineno
= symbol
->lineno
;
1175 struct bfd_link_info
*link_info
= coff_data (abfd
)->link_info
;
1177 if ((!link_info
|| link_info
->strip_discarded
)
1178 && !bfd_is_abs_section (symbol
->symbol
.section
)
1179 && symbol
->symbol
.section
->output_section
== bfd_abs_section_ptr
)
1181 symbol
->symbol
.name
= "";
1185 BFD_ASSERT (native
->is_sym
);
1186 /* If this symbol has an associated line number, we must store the
1187 symbol index in the line number field. We also tag the auxent to
1188 point to the right place in the lineno table. */
1189 if (lineno
&& !symbol
->done_lineno
&& symbol
->symbol
.section
->owner
!= NULL
)
1191 unsigned int count
= 0;
1193 lineno
[count
].u
.offset
= *written
;
1194 if (native
->u
.syment
.n_numaux
)
1196 union internal_auxent
*a
= &((native
+ 1)->u
.auxent
);
1198 a
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1199 symbol
->symbol
.section
->output_section
->moving_line_filepos
;
1202 /* Count and relocate all other linenumbers. */
1204 while (lineno
[count
].line_number
!= 0)
1206 lineno
[count
].u
.offset
+=
1207 (symbol
->symbol
.section
->output_section
->vma
1208 + symbol
->symbol
.section
->output_offset
);
1211 symbol
->done_lineno
= true;
1213 if (! bfd_is_const_section (symbol
->symbol
.section
->output_section
))
1214 symbol
->symbol
.section
->output_section
->moving_line_filepos
+=
1215 count
* bfd_coff_linesz (abfd
);
1218 return coff_write_symbol (abfd
, &(symbol
->symbol
), native
, written
,
1219 string_size_p
, debug_string_section_p
,
1220 debug_string_size_p
);
1224 null_error_handler (const char *fmt ATTRIBUTE_UNUSED
,
1225 va_list ap ATTRIBUTE_UNUSED
)
1229 /* Write out the COFF symbols. */
1232 coff_write_symbols (bfd
*abfd
)
1234 bfd_size_type string_size
;
1235 asection
*debug_string_section
;
1236 bfd_size_type debug_string_size
;
1238 unsigned int limit
= bfd_get_symcount (abfd
);
1239 bfd_vma written
= 0;
1243 debug_string_section
= NULL
;
1244 debug_string_size
= 0;
1246 /* If this target supports long section names, they must be put into
1247 the string table. This is supported by PE. This code must
1248 handle section names just as they are handled in
1249 coff_write_object_contents. */
1250 if (bfd_coff_long_section_names (abfd
))
1254 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1258 len
= strlen (o
->name
);
1260 string_size
+= len
+ 1;
1264 /* Seek to the right place. */
1265 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
1268 /* Output all the symbols we have. */
1270 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1272 asymbol
*symbol
= *p
;
1273 coff_symbol_type
*c_symbol
= coff_symbol_from (symbol
);
1275 if (c_symbol
== (coff_symbol_type
*) NULL
1276 || c_symbol
->native
== (combined_entry_type
*) NULL
)
1278 if (!coff_write_alien_symbol (abfd
, symbol
, NULL
, NULL
, &written
,
1279 &string_size
, &debug_string_section
,
1280 &debug_string_size
))
1285 if (coff_backend_info (abfd
)->_bfd_coff_classify_symbol
!= NULL
)
1287 bfd_error_handler_type current_error_handler
;
1288 enum coff_symbol_classification sym_class
;
1289 unsigned char *n_sclass
;
1291 /* Suppress error reporting by bfd_coff_classify_symbol.
1292 Error messages can be generated when we are processing a local
1293 symbol which has no associated section and we do not have to
1294 worry about this, all we need to know is that it is local. */
1295 current_error_handler
= bfd_set_error_handler (null_error_handler
);
1296 BFD_ASSERT (c_symbol
->native
->is_sym
);
1297 sym_class
= bfd_coff_classify_symbol (abfd
,
1298 &c_symbol
->native
->u
.syment
);
1299 (void) bfd_set_error_handler (current_error_handler
);
1301 n_sclass
= &c_symbol
->native
->u
.syment
.n_sclass
;
1303 /* If the symbol class has been changed (eg objcopy/ld script/etc)
1304 we cannot retain the existing sclass from the original symbol.
1305 Weak symbols only have one valid sclass, so just set it always.
1306 If it is not local class and should be, set it C_STAT.
1307 If it is global and not classified as global, or if it is
1308 weak (which is also classified as global), set it C_EXT. */
1310 if (symbol
->flags
& BSF_WEAK
)
1311 *n_sclass
= obj_pe (abfd
) ? C_NT_WEAK
: C_WEAKEXT
;
1312 else if (symbol
->flags
& BSF_LOCAL
&& sym_class
!= COFF_SYMBOL_LOCAL
)
1314 else if (symbol
->flags
& BSF_GLOBAL
1315 && (sym_class
!= COFF_SYMBOL_GLOBAL
1317 || *n_sclass
== C_NT_WEAK
1319 || *n_sclass
== C_WEAKEXT
))
1320 c_symbol
->native
->u
.syment
.n_sclass
= C_EXT
;
1323 if (!coff_write_native_symbol (abfd
, c_symbol
, &written
,
1324 &string_size
, &debug_string_section
,
1325 &debug_string_size
))
1330 obj_raw_syment_count (abfd
) = written
;
1332 /* Now write out strings. */
1333 if (string_size
!= 0)
1335 unsigned int size
= string_size
+ STRING_SIZE_SIZE
;
1336 bfd_byte buffer
[STRING_SIZE_SIZE
];
1338 #if STRING_SIZE_SIZE == 4
1339 H_PUT_32 (abfd
, size
, buffer
);
1341 #error Change H_PUT_32
1343 if (bfd_bwrite ((void *) buffer
, (bfd_size_type
) sizeof (buffer
), abfd
)
1347 /* Handle long section names. This code must handle section
1348 names just as they are handled in coff_write_object_contents. */
1349 if (bfd_coff_long_section_names (abfd
))
1353 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1357 len
= strlen (o
->name
);
1360 if (bfd_bwrite (o
->name
, (bfd_size_type
) (len
+ 1), abfd
)
1367 for (p
= abfd
->outsymbols
, i
= 0;
1372 size_t name_length
= strlen (q
->name
);
1373 coff_symbol_type
*c_symbol
= coff_symbol_from (q
);
1375 bool is_c_file
= false;
1377 /* Figure out whether the symbol name should go in the string
1378 table. Symbol names that are short enough are stored
1379 directly in the syment structure. File names permit a
1380 different, longer, length in the syment structure. On
1381 XCOFF, some symbol names are stored in the .debug section
1382 rather than in the string table. */
1384 if (c_symbol
== NULL
1385 || c_symbol
->native
== NULL
)
1386 /* This is not a COFF symbol, so it certainly is not a
1387 file name, nor does it go in the .debug section. */
1388 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1390 else if (! c_symbol
->native
->is_sym
)
1391 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1393 else if (bfd_coff_symname_in_debug (abfd
,
1394 &c_symbol
->native
->u
.syment
))
1395 /* This symbol name is in the XCOFF .debug section.
1396 Don't write it into the string table. */
1397 maxlen
= name_length
;
1399 else if (c_symbol
->native
->u
.syment
.n_sclass
== C_FILE
1400 && c_symbol
->native
->u
.syment
.n_numaux
> 0)
1403 if (bfd_coff_force_symnames_in_strings (abfd
))
1405 if (bfd_bwrite (".file", (bfd_size_type
) 6, abfd
) != 6)
1408 maxlen
= bfd_coff_filnmlen (abfd
);
1411 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1413 if (name_length
> maxlen
)
1415 if (bfd_bwrite ((void *) (q
->name
), (bfd_size_type
) name_length
+ 1,
1416 abfd
) != name_length
+ 1)
1420 /* Add strings for C_FILE aux entries. */
1422 && c_symbol
->native
->u
.syment
.n_numaux
> 1)
1424 for (int j
= 1; j
< c_symbol
->native
->u
.syment
.n_numaux
; j
++)
1429 /* Add strings from aux entries only if this isn't the
1430 filename auxiliary entry. */
1431 if (!c_symbol
->native
[j
+ 1].u
.auxent
.x_file
.x_ftype
)
1434 if (c_symbol
->native
[j
+ 1].u
.auxent
.x_file
.x_n
.x_fname
[0] != 0)
1437 str
= (char *) c_symbol
->native
[j
+ 1].extrap
;
1438 str_length
= strlen (str
);
1439 if (str_length
> maxlen
)
1441 if (bfd_bwrite ((void *) (str
), (bfd_size_type
) str_length
+ 1,
1442 abfd
) != str_length
+ 1)
1452 /* We would normally not write anything here, but we'll write
1453 out 4 so that any stupid coff reader which tries to read the
1454 string table even when there isn't one won't croak. */
1455 unsigned int size
= STRING_SIZE_SIZE
;
1456 bfd_byte buffer
[STRING_SIZE_SIZE
];
1458 #if STRING_SIZE_SIZE == 4
1459 H_PUT_32 (abfd
, size
, buffer
);
1461 #error Change H_PUT_32
1463 if (bfd_bwrite ((void *) buffer
, (bfd_size_type
) STRING_SIZE_SIZE
, abfd
)
1464 != STRING_SIZE_SIZE
)
1468 /* Make sure the .debug section was created to be the correct size.
1469 We should create it ourselves on the fly, but we don't because
1470 BFD won't let us write to any section until we know how large all
1471 the sections are. We could still do it by making another pass
1472 over the symbols. FIXME. */
1473 BFD_ASSERT (debug_string_size
== 0
1474 || (debug_string_section
!= (asection
*) NULL
1475 && (BFD_ALIGN (debug_string_size
,
1476 1 << debug_string_section
->alignment_power
)
1477 == debug_string_section
->size
)));
1483 coff_write_linenumbers (bfd
*abfd
)
1486 bfd_size_type linesz
;
1489 linesz
= bfd_coff_linesz (abfd
);
1490 buff
= bfd_alloc (abfd
, linesz
);
1493 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
1495 if (s
->lineno_count
)
1497 asymbol
**q
= abfd
->outsymbols
;
1498 if (bfd_seek (abfd
, s
->line_filepos
, SEEK_SET
) != 0)
1500 /* Find all the linenumbers in this section. */
1504 if (p
->section
->output_section
== s
)
1507 BFD_SEND (bfd_asymbol_bfd (p
), _get_lineno
,
1508 (bfd_asymbol_bfd (p
), p
));
1511 /* Found a linenumber entry, output. */
1512 struct internal_lineno out
;
1514 memset ((void *) & out
, 0, sizeof (out
));
1516 out
.l_addr
.l_symndx
= l
->u
.offset
;
1517 bfd_coff_swap_lineno_out (abfd
, &out
, buff
);
1518 if (bfd_bwrite (buff
, (bfd_size_type
) linesz
, abfd
)
1522 while (l
->line_number
)
1524 out
.l_lnno
= l
->line_number
;
1525 out
.l_addr
.l_symndx
= l
->u
.offset
;
1526 bfd_coff_swap_lineno_out (abfd
, &out
, buff
);
1527 if (bfd_bwrite (buff
, (bfd_size_type
) linesz
, abfd
)
1538 bfd_release (abfd
, buff
);
1543 coff_get_lineno (bfd
*ignore_abfd ATTRIBUTE_UNUSED
, asymbol
*symbol
)
1545 return coffsymbol (symbol
)->lineno
;
1548 /* This function transforms the offsets into the symbol table into
1549 pointers to syments. */
1552 coff_pointerize_aux (bfd
*abfd
,
1553 combined_entry_type
*table_base
,
1554 combined_entry_type
*symbol
,
1555 unsigned int indaux
,
1556 combined_entry_type
*auxent
,
1557 combined_entry_type
*table_end
)
1559 unsigned int type
= symbol
->u
.syment
.n_type
;
1560 unsigned int n_sclass
= symbol
->u
.syment
.n_sclass
;
1562 BFD_ASSERT (symbol
->is_sym
);
1563 if (coff_backend_info (abfd
)->_bfd_coff_pointerize_aux_hook
)
1565 if ((*coff_backend_info (abfd
)->_bfd_coff_pointerize_aux_hook
)
1566 (abfd
, table_base
, symbol
, indaux
, auxent
))
1570 /* Don't bother if this is a file or a section. */
1571 if (n_sclass
== C_STAT
&& type
== T_NULL
)
1573 if (n_sclass
== C_FILE
)
1575 if (n_sclass
== C_DWARF
)
1578 BFD_ASSERT (! auxent
->is_sym
);
1579 /* Otherwise patch up. */
1580 #define N_TMASK coff_data (abfd)->local_n_tmask
1581 #define N_BTSHFT coff_data (abfd)->local_n_btshft
1583 if ((ISFCN (type
) || ISTAG (n_sclass
) || n_sclass
== C_BLOCK
1584 || n_sclass
== C_FCN
)
1585 && auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
> 0
1586 && auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
1587 < (long) obj_raw_syment_count (abfd
)
1588 && table_base
+ auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
1591 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
=
1592 table_base
+ auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
1593 auxent
->fix_end
= 1;
1596 /* A negative tagndx is meaningless, but the SCO 3.2v4 cc can
1597 generate one, so we must be careful to ignore it. */
1598 if ((unsigned long) auxent
->u
.auxent
.x_sym
.x_tagndx
.l
1599 < obj_raw_syment_count (abfd
)
1600 && table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
< table_end
)
1602 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
=
1603 table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
;
1604 auxent
->fix_tag
= 1;
1608 /* Allocate space for the ".debug" section, and read it.
1609 We did not read the debug section until now, because
1610 we didn't want to go to the trouble until someone needed it. */
1613 build_debug_section (bfd
*abfd
, asection
** sect_return
)
1615 char *debug_section
;
1617 bfd_size_type sec_size
;
1619 asection
*sect
= bfd_get_section_by_name (abfd
, ".debug");
1623 bfd_set_error (bfd_error_no_debug_section
);
1627 /* Seek to the beginning of the `.debug' section and read it.
1628 Save the current position first; it is needed by our caller.
1629 Then read debug section and reset the file pointer. */
1631 position
= bfd_tell (abfd
);
1632 if (bfd_seek (abfd
, sect
->filepos
, SEEK_SET
) != 0)
1635 sec_size
= sect
->size
;
1636 debug_section
= (char *) _bfd_alloc_and_read (abfd
, sec_size
, sec_size
);
1637 if (debug_section
== NULL
)
1640 if (bfd_seek (abfd
, position
, SEEK_SET
) != 0)
1643 * sect_return
= sect
;
1644 return debug_section
;
1647 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
1648 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
1649 be \0-terminated. */
1652 copy_name (bfd
*abfd
, char *name
, size_t maxlen
)
1657 for (len
= 0; len
< maxlen
; ++len
)
1658 if (name
[len
] == '\0')
1661 if ((newname
= (char *) bfd_alloc (abfd
, (bfd_size_type
) len
+ 1)) == NULL
)
1664 strncpy (newname
, name
, len
);
1665 newname
[len
] = '\0';
1669 /* Read in the external symbols. */
1672 _bfd_coff_get_external_symbols (bfd
*abfd
)
1678 if (obj_coff_external_syms (abfd
) != NULL
)
1681 symesz
= bfd_coff_symesz (abfd
);
1682 if (_bfd_mul_overflow (obj_raw_syment_count (abfd
), symesz
, &size
))
1684 bfd_set_error (bfd_error_file_truncated
);
1691 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
1693 syms
= _bfd_malloc_and_read (abfd
, size
, size
);
1694 obj_coff_external_syms (abfd
) = syms
;
1695 return syms
!= NULL
;
1698 /* Read in the external strings. The strings are not loaded until
1699 they are needed. This is because we have no simple way of
1700 detecting a missing string table in an archive. If the strings
1701 are loaded then the STRINGS and STRINGS_LEN fields in the
1702 coff_tdata structure will be set. */
1705 _bfd_coff_read_string_table (bfd
*abfd
)
1707 char extstrsize
[STRING_SIZE_SIZE
];
1708 bfd_size_type strsize
;
1715 if (obj_coff_strings (abfd
) != NULL
)
1716 return obj_coff_strings (abfd
);
1718 if (obj_sym_filepos (abfd
) == 0)
1720 bfd_set_error (bfd_error_no_symbols
);
1724 symesz
= bfd_coff_symesz (abfd
);
1725 pos
= obj_sym_filepos (abfd
);
1726 if (_bfd_mul_overflow (obj_raw_syment_count (abfd
), symesz
, &size
)
1727 || pos
+ size
< pos
)
1729 bfd_set_error (bfd_error_file_truncated
);
1733 if (bfd_seek (abfd
, pos
+ size
, SEEK_SET
) != 0)
1736 if (bfd_bread (extstrsize
, (bfd_size_type
) sizeof extstrsize
, abfd
)
1737 != sizeof extstrsize
)
1739 if (bfd_get_error () != bfd_error_file_truncated
)
1742 /* There is no string table. */
1743 strsize
= STRING_SIZE_SIZE
;
1747 #if STRING_SIZE_SIZE == 4
1748 strsize
= H_GET_32 (abfd
, extstrsize
);
1750 #error Change H_GET_32
1754 filesize
= bfd_get_file_size (abfd
);
1755 if (strsize
< STRING_SIZE_SIZE
1756 || (filesize
!= 0 && strsize
> filesize
))
1759 /* xgettext: c-format */
1760 (_("%pB: bad string table size %" PRIu64
), abfd
, (uint64_t) strsize
);
1761 bfd_set_error (bfd_error_bad_value
);
1765 strings
= (char *) bfd_malloc (strsize
+ 1);
1766 if (strings
== NULL
)
1769 /* PR 17521 file: 079-54929-0.004.
1770 A corrupt file could contain an index that points into the first
1771 STRING_SIZE_SIZE bytes of the string table, so make sure that
1773 memset (strings
, 0, STRING_SIZE_SIZE
);
1775 if (bfd_bread (strings
+ STRING_SIZE_SIZE
, strsize
- STRING_SIZE_SIZE
, abfd
)
1776 != strsize
- STRING_SIZE_SIZE
)
1782 obj_coff_strings (abfd
) = strings
;
1783 obj_coff_strings_len (abfd
) = strsize
;
1784 /* Terminate the string table, just in case. */
1785 strings
[strsize
] = 0;
1789 /* Free up the external symbols and strings read from a COFF file. */
1792 _bfd_coff_free_symbols (bfd
*abfd
)
1794 if (! bfd_family_coff (abfd
))
1797 if (obj_coff_external_syms (abfd
) != NULL
1798 && ! obj_coff_keep_syms (abfd
))
1800 free (obj_coff_external_syms (abfd
));
1801 obj_coff_external_syms (abfd
) = NULL
;
1804 if (obj_coff_strings (abfd
) != NULL
1805 && ! obj_coff_keep_strings (abfd
))
1807 free (obj_coff_strings (abfd
));
1808 obj_coff_strings (abfd
) = NULL
;
1809 obj_coff_strings_len (abfd
) = 0;
1815 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
1816 knit the symbol names into a normalized form. By normalized here I
1817 mean that all symbols have an n_offset pointer that points to a null-
1818 terminated string. */
1820 combined_entry_type
*
1821 coff_get_normalized_symtab (bfd
*abfd
)
1823 combined_entry_type
*internal
;
1824 combined_entry_type
*internal_ptr
;
1825 combined_entry_type
*symbol_ptr
;
1826 combined_entry_type
*internal_end
;
1830 const char *string_table
= NULL
;
1831 asection
* debug_sec
= NULL
;
1832 char *debug_sec_data
= NULL
;
1835 if (obj_raw_syments (abfd
) != NULL
)
1836 return obj_raw_syments (abfd
);
1838 if (! _bfd_coff_get_external_symbols (abfd
))
1841 size
= obj_raw_syment_count (abfd
);
1842 /* Check for integer overflow. */
1843 if (size
> (bfd_size_type
) -1 / sizeof (combined_entry_type
))
1845 size
*= sizeof (combined_entry_type
);
1846 internal
= (combined_entry_type
*) bfd_zalloc (abfd
, size
);
1847 if (internal
== NULL
&& size
!= 0)
1849 internal_end
= internal
+ obj_raw_syment_count (abfd
);
1851 raw_src
= (char *) obj_coff_external_syms (abfd
);
1853 /* Mark the end of the symbols. */
1854 symesz
= bfd_coff_symesz (abfd
);
1855 raw_end
= PTR_ADD (raw_src
, obj_raw_syment_count (abfd
) * symesz
);
1857 /* FIXME SOMEDAY. A string table size of zero is very weird, but
1858 probably possible. If one shows up, it will probably kill us. */
1860 /* Swap all the raw entries. */
1861 for (internal_ptr
= internal
;
1863 raw_src
+= symesz
, internal_ptr
++)
1867 bfd_coff_swap_sym_in (abfd
, (void *) raw_src
,
1868 (void *) & internal_ptr
->u
.syment
);
1869 symbol_ptr
= internal_ptr
;
1870 internal_ptr
->is_sym
= true;
1872 /* PR 17512: Prevent buffer overrun. */
1873 if (symbol_ptr
->u
.syment
.n_numaux
> ((raw_end
- 1) - raw_src
) / symesz
)
1875 bfd_release (abfd
, internal
);
1880 i
< symbol_ptr
->u
.syment
.n_numaux
;
1886 bfd_coff_swap_aux_in (abfd
, (void *) raw_src
,
1887 symbol_ptr
->u
.syment
.n_type
,
1888 symbol_ptr
->u
.syment
.n_sclass
,
1889 (int) i
, symbol_ptr
->u
.syment
.n_numaux
,
1890 &(internal_ptr
->u
.auxent
));
1892 internal_ptr
->is_sym
= false;
1893 coff_pointerize_aux (abfd
, internal
, symbol_ptr
, i
,
1894 internal_ptr
, internal_end
);
1898 /* Free the raw symbols. */
1899 if (obj_coff_external_syms (abfd
) != NULL
1900 && ! obj_coff_keep_syms (abfd
))
1902 free (obj_coff_external_syms (abfd
));
1903 obj_coff_external_syms (abfd
) = NULL
;
1906 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
1909 BFD_ASSERT (internal_ptr
->is_sym
);
1911 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
1912 && internal_ptr
->u
.syment
.n_numaux
> 0)
1914 combined_entry_type
* aux
= internal_ptr
+ 1;
1916 /* Make a file symbol point to the name in the auxent, since
1917 the text ".file" is redundant. */
1918 BFD_ASSERT (! aux
->is_sym
);
1920 if (aux
->u
.auxent
.x_file
.x_n
.x_n
.x_zeroes
== 0)
1922 /* The filename is a long one, point into the string table. */
1923 if (string_table
== NULL
)
1925 string_table
= _bfd_coff_read_string_table (abfd
);
1926 if (string_table
== NULL
)
1930 if ((bfd_size_type
)(aux
->u
.auxent
.x_file
.x_n
.x_n
.x_offset
)
1931 >= obj_coff_strings_len (abfd
))
1932 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1934 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1935 (bfd_hostptr_t
) (string_table
+ (aux
->u
.auxent
.x_file
.x_n
.x_n
.x_offset
));
1939 /* Ordinary short filename, put into memory anyway. The
1940 Microsoft PE tools sometimes store a filename in
1941 multiple AUX entries. */
1942 if (internal_ptr
->u
.syment
.n_numaux
> 1
1943 && coff_data (abfd
)->pe
)
1944 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1947 aux
->u
.auxent
.x_file
.x_n
.x_fname
,
1948 internal_ptr
->u
.syment
.n_numaux
* symesz
);
1950 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1953 aux
->u
.auxent
.x_file
.x_n
.x_fname
,
1954 (size_t) bfd_coff_filnmlen (abfd
)));
1957 /* Normalize other strings available in C_FILE aux entries. */
1958 if (!coff_data (abfd
)->pe
)
1959 for (int numaux
= 1; numaux
< internal_ptr
->u
.syment
.n_numaux
; numaux
++)
1961 aux
= internal_ptr
+ numaux
+ 1;
1962 BFD_ASSERT (! aux
->is_sym
);
1964 if (aux
->u
.auxent
.x_file
.x_n
.x_n
.x_zeroes
== 0)
1966 /* The string information is a long one, point into the string table. */
1967 if (string_table
== NULL
)
1969 string_table
= _bfd_coff_read_string_table (abfd
);
1970 if (string_table
== NULL
)
1974 if ((bfd_size_type
)(aux
->u
.auxent
.x_file
.x_n
.x_n
.x_offset
)
1975 >= obj_coff_strings_len (abfd
))
1976 aux
->u
.auxent
.x_file
.x_n
.x_n
.x_offset
= (bfd_hostptr_t
) _("<corrupt>");
1978 aux
->u
.auxent
.x_file
.x_n
.x_n
.x_offset
=
1979 (bfd_hostptr_t
) (string_table
+ (aux
->u
.auxent
.x_file
.x_n
.x_n
.x_offset
));
1982 aux
->u
.auxent
.x_file
.x_n
.x_n
.x_offset
=
1985 aux
->u
.auxent
.x_file
.x_n
.x_fname
,
1986 (size_t) bfd_coff_filnmlen (abfd
)));
1992 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0)
1994 /* This is a "short" name. Make it long. */
1998 /* Find the length of this string without walking into memory
2000 for (i
= 0; i
< 8; ++i
)
2001 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0')
2004 newstring
= (char *) bfd_zalloc (abfd
, (bfd_size_type
) (i
+ 1));
2005 if (newstring
== NULL
)
2007 strncpy (newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
);
2008 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) newstring
;
2009 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
2011 else if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
== 0)
2012 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) "";
2013 else if (!bfd_coff_symname_in_debug (abfd
, &internal_ptr
->u
.syment
))
2015 /* Long name already. Point symbol at the string in the
2017 if (string_table
== NULL
)
2019 string_table
= _bfd_coff_read_string_table (abfd
);
2020 if (string_table
== NULL
)
2023 if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
>= obj_coff_strings_len (abfd
)
2024 || string_table
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
< string_table
)
2025 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
2027 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
2030 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
));
2034 /* Long name in debug section. Very similar. */
2035 if (debug_sec_data
== NULL
)
2036 debug_sec_data
= build_debug_section (abfd
, & debug_sec
);
2037 if (debug_sec_data
!= NULL
)
2039 BFD_ASSERT (debug_sec
!= NULL
);
2040 /* PR binutils/17512: Catch out of range offsets into the debug data. */
2041 if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
> debug_sec
->size
2042 || debug_sec_data
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
< debug_sec_data
)
2043 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
2045 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
)
2046 (debug_sec_data
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
2049 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) "";
2052 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
2055 obj_raw_syments (abfd
) = internal
;
2056 BFD_ASSERT (obj_raw_syment_count (abfd
)
2057 == (unsigned int) (internal_ptr
- internal
));
2063 coff_get_reloc_upper_bound (bfd
*abfd
, sec_ptr asect
)
2065 if (bfd_get_format (abfd
) != bfd_object
)
2067 bfd_set_error (bfd_error_invalid_operation
);
2070 #if SIZEOF_LONG == SIZEOF_INT
2071 if (asect
->reloc_count
>= LONG_MAX
/ sizeof (arelent
*))
2073 bfd_set_error (bfd_error_file_too_big
);
2077 return (asect
->reloc_count
+ 1L) * sizeof (arelent
*);
2081 coff_make_empty_symbol (bfd
*abfd
)
2083 size_t amt
= sizeof (coff_symbol_type
);
2084 coff_symbol_type
*new_symbol
= (coff_symbol_type
*) bfd_zalloc (abfd
, amt
);
2086 if (new_symbol
== NULL
)
2088 new_symbol
->symbol
.section
= 0;
2089 new_symbol
->native
= NULL
;
2090 new_symbol
->lineno
= NULL
;
2091 new_symbol
->done_lineno
= false;
2092 new_symbol
->symbol
.the_bfd
= abfd
;
2094 return & new_symbol
->symbol
;
2097 /* Make a debugging symbol. */
2100 coff_bfd_make_debug_symbol (bfd
*abfd
,
2101 void * ptr ATTRIBUTE_UNUSED
,
2102 unsigned long sz ATTRIBUTE_UNUSED
)
2104 size_t amt
= sizeof (coff_symbol_type
);
2105 coff_symbol_type
*new_symbol
= (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
2107 if (new_symbol
== NULL
)
2109 /* @@ The 10 is a guess at a plausible maximum number of aux entries
2110 (but shouldn't be a constant). */
2111 amt
= sizeof (combined_entry_type
) * 10;
2112 new_symbol
->native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
2113 if (!new_symbol
->native
)
2115 new_symbol
->native
->is_sym
= true;
2116 new_symbol
->symbol
.section
= bfd_abs_section_ptr
;
2117 new_symbol
->symbol
.flags
= BSF_DEBUGGING
;
2118 new_symbol
->lineno
= NULL
;
2119 new_symbol
->done_lineno
= false;
2120 new_symbol
->symbol
.the_bfd
= abfd
;
2122 return & new_symbol
->symbol
;
2126 coff_get_symbol_info (bfd
*abfd
, asymbol
*symbol
, symbol_info
*ret
)
2128 bfd_symbol_info (symbol
, ret
);
2130 if (coffsymbol (symbol
)->native
!= NULL
2131 && coffsymbol (symbol
)->native
->fix_value
2132 && coffsymbol (symbol
)->native
->is_sym
)
2134 = (((bfd_hostptr_t
) coffsymbol (symbol
)->native
->u
.syment
.n_value
2135 - (bfd_hostptr_t
) obj_raw_syments (abfd
))
2136 / sizeof (combined_entry_type
));
2139 /* Print out information about COFF symbol. */
2142 coff_print_symbol (bfd
*abfd
,
2145 bfd_print_symbol_type how
)
2147 FILE * file
= (FILE *) filep
;
2151 case bfd_print_symbol_name
:
2152 fprintf (file
, "%s", symbol
->name
);
2155 case bfd_print_symbol_more
:
2156 fprintf (file
, "coff %s %s",
2157 coffsymbol (symbol
)->native
? "n" : "g",
2158 coffsymbol (symbol
)->lineno
? "l" : " ");
2161 case bfd_print_symbol_all
:
2162 if (coffsymbol (symbol
)->native
)
2166 combined_entry_type
*combined
= coffsymbol (symbol
)->native
;
2167 combined_entry_type
*root
= obj_raw_syments (abfd
);
2168 struct lineno_cache_entry
*l
= coffsymbol (symbol
)->lineno
;
2170 fprintf (file
, "[%3ld]", (long) (combined
- root
));
2172 /* PR 17512: file: 079-33786-0.001:0.1. */
2173 if (combined
< obj_raw_syments (abfd
)
2174 || combined
>= obj_raw_syments (abfd
) + obj_raw_syment_count (abfd
))
2176 fprintf (file
, _("<corrupt info> %s"), symbol
->name
);
2180 BFD_ASSERT (combined
->is_sym
);
2181 if (! combined
->fix_value
)
2182 val
= (bfd_vma
) combined
->u
.syment
.n_value
;
2184 val
= (((bfd_hostptr_t
) combined
->u
.syment
.n_value
2185 - (bfd_hostptr_t
) root
)
2186 / sizeof (combined_entry_type
));
2188 fprintf (file
, "(sec %2d)(fl 0x%02x)(ty %4x)(scl %3d) (nx %d) 0x",
2189 combined
->u
.syment
.n_scnum
,
2190 combined
->u
.syment
.n_flags
,
2191 combined
->u
.syment
.n_type
,
2192 combined
->u
.syment
.n_sclass
,
2193 combined
->u
.syment
.n_numaux
);
2194 bfd_fprintf_vma (abfd
, file
, val
);
2195 fprintf (file
, " %s", symbol
->name
);
2197 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
2199 combined_entry_type
*auxp
= combined
+ aux
+ 1;
2202 BFD_ASSERT (! auxp
->is_sym
);
2204 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.p
- root
;
2206 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.l
;
2208 fprintf (file
, "\n");
2210 if (bfd_coff_print_aux (abfd
, file
, root
, combined
, auxp
, aux
))
2213 switch (combined
->u
.syment
.n_sclass
)
2216 fprintf (file
, "File ");
2217 /* Add additional information if this isn't the filename
2219 if (auxp
->u
.auxent
.x_file
.x_ftype
)
2220 fprintf (file
, "ftype %d fname \"%s\"",
2221 auxp
->u
.auxent
.x_file
.x_ftype
,
2222 (char *) auxp
->u
.auxent
.x_file
.x_n
.x_n
.x_offset
);
2226 fprintf (file
, "AUX scnlen 0x%lx nreloc %ld",
2227 (unsigned long) auxp
->u
.auxent
.x_sect
.x_scnlen
,
2228 auxp
->u
.auxent
.x_sect
.x_nreloc
);
2232 if (combined
->u
.syment
.n_type
== T_NULL
)
2233 /* Probably a section symbol ? */
2235 fprintf (file
, "AUX scnlen 0x%lx nreloc %d nlnno %d",
2236 (unsigned long) auxp
->u
.auxent
.x_scn
.x_scnlen
,
2237 auxp
->u
.auxent
.x_scn
.x_nreloc
,
2238 auxp
->u
.auxent
.x_scn
.x_nlinno
);
2239 if (auxp
->u
.auxent
.x_scn
.x_checksum
!= 0
2240 || auxp
->u
.auxent
.x_scn
.x_associated
!= 0
2241 || auxp
->u
.auxent
.x_scn
.x_comdat
!= 0)
2242 fprintf (file
, " checksum 0x%lx assoc %d comdat %d",
2243 auxp
->u
.auxent
.x_scn
.x_checksum
,
2244 auxp
->u
.auxent
.x_scn
.x_associated
,
2245 auxp
->u
.auxent
.x_scn
.x_comdat
);
2251 if (ISFCN (combined
->u
.syment
.n_type
))
2256 next
= (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2259 next
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2260 llnos
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
2262 "AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld",
2264 (unsigned long) auxp
->u
.auxent
.x_sym
.x_misc
.x_fsize
,
2270 fprintf (file
, "AUX lnno %d size 0x%x tagndx %ld",
2271 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
2272 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
,
2275 fprintf (file
, " endndx %ld",
2277 (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2285 fprintf (file
, "\n%s :", l
->u
.sym
->name
);
2287 while (l
->line_number
)
2289 if (l
->line_number
> 0)
2291 fprintf (file
, "\n%4d : ", l
->line_number
);
2292 bfd_fprintf_vma (abfd
, file
, l
->u
.offset
+ symbol
->section
->vma
);
2300 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
2301 fprintf (file
, " %-5s %s %s %s",
2302 symbol
->section
->name
,
2303 coffsymbol (symbol
)->native
? "n" : "g",
2304 coffsymbol (symbol
)->lineno
? "l" : " ",
2310 /* Return whether a symbol name implies a local symbol. In COFF,
2311 local symbols generally start with ``.L''. Most targets use this
2312 function for the is_local_label_name entry point, but some may
2316 _bfd_coff_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
2319 return name
[0] == '.' && name
[1] == 'L';
2322 /* Provided a BFD, a section and an offset (in bytes, not octets) into the
2323 section, calculate and return the name of the source file and the line
2324 nearest to the wanted location. */
2327 coff_find_nearest_line_with_names (bfd
*abfd
,
2331 const char **filename_ptr
,
2332 const char **functionname_ptr
,
2333 unsigned int *line_ptr
,
2334 const struct dwarf_debug_section
*debug_sections
)
2338 unsigned int line_base
;
2339 coff_data_type
*cof
= coff_data (abfd
);
2340 /* Run through the raw syments if available. */
2341 combined_entry_type
*p
;
2342 combined_entry_type
*pend
;
2344 struct coff_section_tdata
*sec_data
;
2347 /* Before looking through the symbol table, try to use a .stab
2348 section to find the information. */
2349 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2350 &found
, filename_ptr
,
2351 functionname_ptr
, line_ptr
,
2352 &coff_data(abfd
)->line_info
))
2358 /* Also try examining DWARF2 debugging information. */
2359 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
2360 filename_ptr
, functionname_ptr
,
2361 line_ptr
, NULL
, debug_sections
,
2362 &coff_data(abfd
)->dwarf2_find_line_info
))
2365 sec_data
= coff_section_data (abfd
, section
);
2367 /* If the DWARF lookup failed, but there is DWARF information available
2368 then the problem might be that the file has been rebased. This tool
2369 changes the VMAs of all the sections, but it does not update the DWARF
2370 information. So try again, using a bias against the address sought. */
2371 if (coff_data (abfd
)->dwarf2_find_line_info
!= NULL
)
2373 bfd_signed_vma bias
= 0;
2375 /* Create a cache of the result for the next call. */
2376 if (sec_data
== NULL
&& section
->owner
== abfd
)
2378 amt
= sizeof (struct coff_section_tdata
);
2379 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
2380 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2383 if (sec_data
!= NULL
&& sec_data
->saved_bias
)
2384 bias
= sec_data
->saved_bias
;
2387 bias
= _bfd_dwarf2_find_symbol_bias (symbols
,
2388 & coff_data (abfd
)->dwarf2_find_line_info
);
2392 sec_data
->saved_bias
= true;
2393 sec_data
->bias
= bias
;
2398 && _bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
,
2400 filename_ptr
, functionname_ptr
,
2401 line_ptr
, NULL
, debug_sections
,
2402 &coff_data(abfd
)->dwarf2_find_line_info
))
2407 *functionname_ptr
= 0;
2410 /* Don't try and find line numbers in a non coff file. */
2411 if (!bfd_family_coff (abfd
))
2417 /* Find the first C_FILE symbol. */
2418 p
= cof
->raw_syments
;
2422 pend
= p
+ cof
->raw_syment_count
;
2425 BFD_ASSERT (p
->is_sym
);
2426 if (p
->u
.syment
.n_sclass
== C_FILE
)
2428 p
+= 1 + p
->u
.syment
.n_numaux
;
2436 /* Look through the C_FILE symbols to find the best one. */
2437 sec_vma
= bfd_section_vma (section
);
2438 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2439 maxdiff
= (bfd_vma
) 0 - (bfd_vma
) 1;
2443 combined_entry_type
*p2
;
2445 for (p2
= p
+ 1 + p
->u
.syment
.n_numaux
;
2447 p2
+= 1 + p2
->u
.syment
.n_numaux
)
2449 BFD_ASSERT (p2
->is_sym
);
2450 if (p2
->u
.syment
.n_scnum
> 0
2452 == coff_section_from_bfd_index (abfd
,
2453 p2
->u
.syment
.n_scnum
)))
2455 if (p2
->u
.syment
.n_sclass
== C_FILE
)
2464 file_addr
= (bfd_vma
) p2
->u
.syment
.n_value
;
2465 /* PR 11512: Include the section address of the function name symbol. */
2466 if (p2
->u
.syment
.n_scnum
> 0)
2467 file_addr
+= coff_section_from_bfd_index (abfd
,
2468 p2
->u
.syment
.n_scnum
)->vma
;
2469 /* We use <= MAXDIFF here so that if we get a zero length
2470 file, we actually use the next file entry. */
2472 && offset
+ sec_vma
>= file_addr
2473 && offset
+ sec_vma
- file_addr
<= maxdiff
)
2475 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2476 maxdiff
= offset
+ sec_vma
- p2
->u
.syment
.n_value
;
2479 if (p
->u
.syment
.n_value
>= cof
->raw_syment_count
)
2482 /* Avoid endless loops on erroneous files by ensuring that
2483 we always move forward in the file. */
2484 if (p
>= cof
->raw_syments
+ p
->u
.syment
.n_value
)
2487 p
= cof
->raw_syments
+ p
->u
.syment
.n_value
;
2488 if (!p
->is_sym
|| p
->u
.syment
.n_sclass
!= C_FILE
)
2493 if (section
->lineno_count
== 0)
2495 *functionname_ptr
= NULL
;
2500 /* Now wander though the raw linenumbers of the section.
2501 If we have been called on this section before, and the offset
2502 we want is further down then we can prime the lookup loop. */
2503 if (sec_data
!= NULL
2505 && offset
>= sec_data
->offset
)
2508 *functionname_ptr
= sec_data
->function
;
2509 line_base
= sec_data
->line_base
;
2517 if (section
->lineno
!= NULL
)
2519 bfd_vma last_value
= 0;
2521 l
= §ion
->lineno
[i
];
2523 for (; i
< section
->lineno_count
; i
++)
2525 if (l
->line_number
== 0)
2527 /* Get the symbol this line number points at. */
2528 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
2529 if (coff
->symbol
.value
> offset
)
2532 *functionname_ptr
= coff
->symbol
.name
;
2533 last_value
= coff
->symbol
.value
;
2536 combined_entry_type
*s
= coff
->native
;
2538 BFD_ASSERT (s
->is_sym
);
2539 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2541 /* In XCOFF a debugging symbol can follow the
2543 if (((size_t) ((char *) s
- (char *) obj_raw_syments (abfd
))
2544 < obj_raw_syment_count (abfd
) * sizeof (*s
))
2545 && s
->u
.syment
.n_scnum
== N_DEBUG
)
2546 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2548 /* S should now point to the .bf of the function. */
2549 if (((size_t) ((char *) s
- (char *) obj_raw_syments (abfd
))
2550 < obj_raw_syment_count (abfd
) * sizeof (*s
))
2551 && s
->u
.syment
.n_numaux
)
2553 /* The linenumber is stored in the auxent. */
2554 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
2556 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
2557 *line_ptr
= line_base
;
2563 if (l
->u
.offset
> offset
)
2565 *line_ptr
= l
->line_number
+ line_base
- 1;
2570 /* If we fell off the end of the loop, then assume that this
2571 symbol has no line number info. Otherwise, symbols with no
2572 line number info get reported with the line number of the
2573 last line of the last symbol which does have line number
2574 info. We use 0x100 as a slop to account for cases where the
2575 last line has executable code. */
2576 if (i
>= section
->lineno_count
2578 && offset
- last_value
> 0x100)
2580 *functionname_ptr
= NULL
;
2585 /* Cache the results for the next call. */
2586 if (sec_data
== NULL
&& section
->owner
== abfd
)
2588 amt
= sizeof (struct coff_section_tdata
);
2589 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
2590 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2593 if (sec_data
!= NULL
)
2595 sec_data
->offset
= offset
;
2596 sec_data
->i
= i
- 1;
2597 sec_data
->function
= *functionname_ptr
;
2598 sec_data
->line_base
= line_base
;
2605 coff_find_nearest_line (bfd
*abfd
,
2609 const char **filename_ptr
,
2610 const char **functionname_ptr
,
2611 unsigned int *line_ptr
,
2612 unsigned int *discriminator_ptr
)
2614 if (discriminator_ptr
)
2615 *discriminator_ptr
= 0;
2616 return coff_find_nearest_line_with_names (abfd
, symbols
, section
, offset
,
2617 filename_ptr
, functionname_ptr
,
2618 line_ptr
, dwarf_debug_sections
);
2622 coff_find_inliner_info (bfd
*abfd
,
2623 const char **filename_ptr
,
2624 const char **functionname_ptr
,
2625 unsigned int *line_ptr
)
2629 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
2630 functionname_ptr
, line_ptr
,
2631 &coff_data(abfd
)->dwarf2_find_line_info
);
2636 coff_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
2640 if (!bfd_link_relocatable (info
))
2641 size
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
2643 size
= bfd_coff_filhsz (abfd
);
2645 size
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
2649 /* Change the class of a coff symbol held by BFD. */
2652 bfd_coff_set_symbol_class (bfd
* abfd
,
2654 unsigned int symbol_class
)
2656 coff_symbol_type
* csym
;
2658 csym
= coff_symbol_from (symbol
);
2661 bfd_set_error (bfd_error_invalid_operation
);
2664 else if (csym
->native
== NULL
)
2666 /* This is an alien symbol which no native coff backend data.
2667 We cheat here by creating a fake native entry for it and
2668 then filling in the class. This code is based on that in
2669 coff_write_alien_symbol(). */
2671 combined_entry_type
* native
;
2672 size_t amt
= sizeof (* native
);
2674 native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
2678 native
->is_sym
= true;
2679 native
->u
.syment
.n_type
= T_NULL
;
2680 native
->u
.syment
.n_sclass
= symbol_class
;
2682 if (bfd_is_und_section (symbol
->section
))
2684 native
->u
.syment
.n_scnum
= N_UNDEF
;
2685 native
->u
.syment
.n_value
= symbol
->value
;
2687 else if (bfd_is_com_section (symbol
->section
))
2689 native
->u
.syment
.n_scnum
= N_UNDEF
;
2690 native
->u
.syment
.n_value
= symbol
->value
;
2694 native
->u
.syment
.n_scnum
=
2695 symbol
->section
->output_section
->target_index
;
2696 native
->u
.syment
.n_value
= (symbol
->value
2697 + symbol
->section
->output_offset
);
2698 if (! obj_pe (abfd
))
2699 native
->u
.syment
.n_value
+= symbol
->section
->output_section
->vma
;
2701 /* Copy the any flags from the file header into the symbol.
2703 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (& csym
->symbol
)->flags
;
2706 csym
->native
= native
;
2709 csym
->native
->u
.syment
.n_sclass
= symbol_class
;
2715 _bfd_coff_section_already_linked (bfd
*abfd
,
2717 struct bfd_link_info
*info
)
2720 const char *name
, *key
;
2721 struct bfd_section_already_linked
*l
;
2722 struct bfd_section_already_linked_hash_entry
*already_linked_list
;
2723 struct coff_comdat_info
*s_comdat
;
2725 if (sec
->output_section
== bfd_abs_section_ptr
)
2729 if ((flags
& SEC_LINK_ONCE
) == 0)
2732 /* The COFF backend linker doesn't support group sections. */
2733 if ((flags
& SEC_GROUP
) != 0)
2736 name
= bfd_section_name (sec
);
2737 s_comdat
= bfd_coff_get_comdat_section (abfd
, sec
);
2739 if (s_comdat
!= NULL
)
2740 key
= s_comdat
->name
;
2743 if (startswith (name
, ".gnu.linkonce.")
2744 && (key
= strchr (name
+ sizeof (".gnu.linkonce.") - 1, '.')) != NULL
)
2747 /* FIXME: gcc as of 2011-09 emits sections like .text$<key>,
2748 .xdata$<key> and .pdata$<key> only the first of which has a
2749 comdat key. Should these all match the LTO IR key? */
2753 already_linked_list
= bfd_section_already_linked_table_lookup (key
);
2755 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
2757 struct coff_comdat_info
*l_comdat
;
2759 l_comdat
= bfd_coff_get_comdat_section (l
->sec
->owner
, l
->sec
);
2761 /* The section names must match, and both sections must be
2762 comdat and have the same comdat name, or both sections must
2763 be non-comdat. LTO IR plugin sections are an exception. They
2764 are always named .gnu.linkonce.t.<key> (<key> is some string)
2765 and match any comdat section with comdat name of <key>, and
2766 any linkonce section with the same suffix, ie.
2767 .gnu.linkonce.*.<key>. */
2768 if (((s_comdat
!= NULL
) == (l_comdat
!= NULL
)
2769 && strcmp (name
, l
->sec
->name
) == 0)
2770 || (l
->sec
->owner
->flags
& BFD_PLUGIN
) != 0
2771 || (sec
->owner
->flags
& BFD_PLUGIN
) != 0)
2773 /* The section has already been linked. See if we should
2775 return _bfd_handle_already_linked (sec
, l
, info
);
2779 /* This is the first section with this name. Record it. */
2780 if (!bfd_section_already_linked_table_insert (already_linked_list
, sec
))
2781 info
->callbacks
->einfo (_("%F%P: already_linked_table: %E\n"));
2785 /* Initialize COOKIE for input bfd ABFD. */
2788 init_reloc_cookie (struct coff_reloc_cookie
*cookie
,
2789 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2792 /* Sometimes the symbol table does not yet have been loaded here. */
2793 bfd_coff_slurp_symbol_table (abfd
);
2795 cookie
->abfd
= abfd
;
2796 cookie
->sym_hashes
= obj_coff_sym_hashes (abfd
);
2798 cookie
->symbols
= obj_symbols (abfd
);
2803 /* Free the memory allocated by init_reloc_cookie, if appropriate. */
2806 fini_reloc_cookie (struct coff_reloc_cookie
*cookie ATTRIBUTE_UNUSED
,
2807 bfd
*abfd ATTRIBUTE_UNUSED
)
2809 /* Nothing to do. */
2812 /* Initialize the relocation information in COOKIE for input section SEC
2813 of input bfd ABFD. */
2816 init_reloc_cookie_rels (struct coff_reloc_cookie
*cookie
,
2817 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2821 if (sec
->reloc_count
== 0)
2823 cookie
->rels
= NULL
;
2824 cookie
->relend
= NULL
;
2829 cookie
->rels
= _bfd_coff_read_internal_relocs (abfd
, sec
, false, NULL
,
2832 if (cookie
->rels
== NULL
)
2835 cookie
->rel
= cookie
->rels
;
2836 cookie
->relend
= (cookie
->rels
+ sec
->reloc_count
);
2840 /* Free the memory allocated by init_reloc_cookie_rels,
2844 fini_reloc_cookie_rels (struct coff_reloc_cookie
*cookie
,
2848 /* PR 20401. The relocs may not have been cached, so check first.
2849 If the relocs were loaded by init_reloc_cookie_rels() then this
2850 will be the case. FIXME: Would performance be improved if the
2851 relocs *were* cached ? */
2852 && coff_section_data (NULL
, sec
)
2853 && coff_section_data (NULL
, sec
)->relocs
!= cookie
->rels
)
2854 free (cookie
->rels
);
2857 /* Initialize the whole of COOKIE for input section SEC. */
2860 init_reloc_cookie_for_section (struct coff_reloc_cookie
*cookie
,
2861 struct bfd_link_info
*info
,
2864 if (!init_reloc_cookie (cookie
, info
, sec
->owner
))
2867 if (!init_reloc_cookie_rels (cookie
, info
, sec
->owner
, sec
))
2869 fini_reloc_cookie (cookie
, sec
->owner
);
2875 /* Free the memory allocated by init_reloc_cookie_for_section,
2879 fini_reloc_cookie_for_section (struct coff_reloc_cookie
*cookie
,
2882 fini_reloc_cookie_rels (cookie
, sec
);
2883 fini_reloc_cookie (cookie
, sec
->owner
);
2887 _bfd_coff_gc_mark_hook (asection
*sec
,
2888 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2889 struct internal_reloc
*rel ATTRIBUTE_UNUSED
,
2890 struct coff_link_hash_entry
*h
,
2891 struct internal_syment
*sym
)
2895 switch (h
->root
.type
)
2897 case bfd_link_hash_defined
:
2898 case bfd_link_hash_defweak
:
2899 return h
->root
.u
.def
.section
;
2901 case bfd_link_hash_common
:
2902 return h
->root
.u
.c
.p
->section
;
2904 case bfd_link_hash_undefweak
:
2905 if (h
->symbol_class
== C_NT_WEAK
&& h
->numaux
== 1)
2907 /* PE weak externals. A weak symbol may include an auxiliary
2908 record indicating that if the weak symbol is not resolved,
2909 another external symbol is used instead. */
2910 struct coff_link_hash_entry
*h2
=
2911 h
->auxbfd
->tdata
.coff_obj_data
->sym_hashes
[
2912 h
->aux
->x_sym
.x_tagndx
.l
];
2914 if (h2
&& h2
->root
.type
!= bfd_link_hash_undefined
)
2915 return h2
->root
.u
.def
.section
;
2919 case bfd_link_hash_undefined
:
2926 return coff_section_from_bfd_index (sec
->owner
, sym
->n_scnum
);
2929 /* COOKIE->rel describes a relocation against section SEC, which is
2930 a section we've decided to keep. Return the section that contains
2931 the relocation symbol, or NULL if no section contains it. */
2934 _bfd_coff_gc_mark_rsec (struct bfd_link_info
*info
, asection
*sec
,
2935 coff_gc_mark_hook_fn gc_mark_hook
,
2936 struct coff_reloc_cookie
*cookie
)
2938 struct coff_link_hash_entry
*h
;
2940 h
= cookie
->sym_hashes
[cookie
->rel
->r_symndx
];
2943 while (h
->root
.type
== bfd_link_hash_indirect
2944 || h
->root
.type
== bfd_link_hash_warning
)
2945 h
= (struct coff_link_hash_entry
*) h
->root
.u
.i
.link
;
2947 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, h
, NULL
);
2950 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, NULL
,
2952 + obj_convert (sec
->owner
)[cookie
->rel
->r_symndx
])->native
->u
.syment
);
2955 static bool _bfd_coff_gc_mark
2956 (struct bfd_link_info
*, asection
*, coff_gc_mark_hook_fn
);
2958 /* COOKIE->rel describes a relocation against section SEC, which is
2959 a section we've decided to keep. Mark the section that contains
2960 the relocation symbol. */
2963 _bfd_coff_gc_mark_reloc (struct bfd_link_info
*info
,
2965 coff_gc_mark_hook_fn gc_mark_hook
,
2966 struct coff_reloc_cookie
*cookie
)
2970 rsec
= _bfd_coff_gc_mark_rsec (info
, sec
, gc_mark_hook
, cookie
);
2971 if (rsec
&& !rsec
->gc_mark
)
2973 if (bfd_get_flavour (rsec
->owner
) != bfd_target_coff_flavour
)
2975 else if (!_bfd_coff_gc_mark (info
, rsec
, gc_mark_hook
))
2981 /* The mark phase of garbage collection. For a given section, mark
2982 it and any sections in this section's group, and all the sections
2983 which define symbols to which it refers. */
2986 _bfd_coff_gc_mark (struct bfd_link_info
*info
,
2988 coff_gc_mark_hook_fn gc_mark_hook
)
2994 /* Look through the section relocs. */
2995 if ((sec
->flags
& SEC_RELOC
) != 0
2996 && sec
->reloc_count
> 0)
2998 struct coff_reloc_cookie cookie
;
3000 if (!init_reloc_cookie_for_section (&cookie
, info
, sec
))
3004 for (; cookie
.rel
< cookie
.relend
; cookie
.rel
++)
3006 if (!_bfd_coff_gc_mark_reloc (info
, sec
, gc_mark_hook
, &cookie
))
3012 fini_reloc_cookie_for_section (&cookie
, sec
);
3020 _bfd_coff_gc_mark_extra_sections (struct bfd_link_info
*info
,
3021 coff_gc_mark_hook_fn mark_hook ATTRIBUTE_UNUSED
)
3025 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
3030 if (bfd_get_flavour (ibfd
) != bfd_target_coff_flavour
)
3033 /* Ensure all linker created sections are kept, and see whether
3034 any other section is already marked. */
3036 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
3038 if ((isec
->flags
& SEC_LINKER_CREATED
) != 0)
3040 else if (isec
->gc_mark
)
3044 /* If no section in this file will be kept, then we can
3045 toss out debug sections. */
3049 /* Keep debug and special sections like .comment when they are
3050 not part of a group, or when we have single-member groups. */
3051 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
3052 if ((isec
->flags
& SEC_DEBUGGING
) != 0
3053 || (isec
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0)
3059 /* Sweep symbols in swept sections. Called via coff_link_hash_traverse. */
3062 coff_gc_sweep_symbol (struct coff_link_hash_entry
*h
,
3063 void *data ATTRIBUTE_UNUSED
)
3065 if (h
->root
.type
== bfd_link_hash_warning
)
3066 h
= (struct coff_link_hash_entry
*) h
->root
.u
.i
.link
;
3068 if ((h
->root
.type
== bfd_link_hash_defined
3069 || h
->root
.type
== bfd_link_hash_defweak
)
3070 && !h
->root
.u
.def
.section
->gc_mark
3071 && !(h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
))
3073 /* Do our best to hide the symbol. */
3074 h
->root
.u
.def
.section
= bfd_und_section_ptr
;
3075 h
->symbol_class
= C_HIDDEN
;
3081 /* The sweep phase of garbage collection. Remove all garbage sections. */
3083 typedef bool (*gc_sweep_hook_fn
)
3084 (bfd
*, struct bfd_link_info
*, asection
*, const struct internal_reloc
*);
3087 coff_gc_sweep (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
3091 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3095 if (bfd_get_flavour (sub
) != bfd_target_coff_flavour
)
3098 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3100 /* Keep debug and special sections. */
3101 if ((o
->flags
& (SEC_DEBUGGING
| SEC_LINKER_CREATED
)) != 0
3102 || (o
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0)
3104 else if (startswith (o
->name
, ".idata")
3105 || startswith (o
->name
, ".pdata")
3106 || startswith (o
->name
, ".xdata")
3107 || startswith (o
->name
, ".rsrc"))
3113 /* Skip sweeping sections already excluded. */
3114 if (o
->flags
& SEC_EXCLUDE
)
3117 /* Since this is early in the link process, it is simple
3118 to remove a section from the output. */
3119 o
->flags
|= SEC_EXCLUDE
;
3121 if (info
->print_gc_sections
&& o
->size
!= 0)
3122 /* xgettext: c-format */
3123 _bfd_error_handler (_("removing unused section '%pA' in file '%pB'"),
3127 /* But we also have to update some of the relocation
3128 info we collected before. */
3130 && (o
->flags
& SEC_RELOC
) != 0
3131 && o
->reloc_count
> 0
3132 && !bfd_is_abs_section (o
->output_section
))
3134 struct internal_reloc
*internal_relocs
;
3138 = _bfd_coff_link_read_relocs (o
->owner
, o
, NULL
, NULL
,
3140 if (internal_relocs
== NULL
)
3143 r
= (*gc_sweep_hook
) (o
->owner
, info
, o
, internal_relocs
);
3145 if (coff_section_data (o
)->relocs
!= internal_relocs
)
3146 free (internal_relocs
);
3155 /* Remove the symbols that were in the swept sections from the dynamic
3157 coff_link_hash_traverse (coff_hash_table (info
), coff_gc_sweep_symbol
,
3163 /* Keep all sections containing symbols undefined on the command-line,
3164 and the section containing the entry symbol. */
3167 _bfd_coff_gc_keep (struct bfd_link_info
*info
)
3169 struct bfd_sym_chain
*sym
;
3171 for (sym
= info
->gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
3173 struct coff_link_hash_entry
*h
;
3175 h
= coff_link_hash_lookup (coff_hash_table (info
), sym
->name
,
3176 false, false, false);
3179 && (h
->root
.type
== bfd_link_hash_defined
3180 || h
->root
.type
== bfd_link_hash_defweak
)
3181 && !bfd_is_abs_section (h
->root
.u
.def
.section
))
3182 h
->root
.u
.def
.section
->flags
|= SEC_KEEP
;
3186 /* Do mark and sweep of unused sections. */
3189 bfd_coff_gc_sections (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
3193 /* FIXME: Should we implement this? */
3195 const bfd_coff_backend_data
*bed
= coff_backend_info (abfd
);
3197 if (!bed
->can_gc_sections
3198 || !is_coff_hash_table (info
->hash
))
3200 _bfd_error_handler(_("warning: gc-sections option ignored"));
3205 _bfd_coff_gc_keep (info
);
3207 /* Grovel through relocs to find out who stays ... */
3208 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3212 if (bfd_get_flavour (sub
) != bfd_target_coff_flavour
)
3215 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3217 if (((o
->flags
& (SEC_EXCLUDE
| SEC_KEEP
)) == SEC_KEEP
3218 || startswith (o
->name
, ".vectors")
3219 || startswith (o
->name
, ".ctors")
3220 || startswith (o
->name
, ".dtors"))
3223 if (!_bfd_coff_gc_mark (info
, o
, _bfd_coff_gc_mark_hook
))
3229 /* Allow the backend to mark additional target specific sections. */
3230 _bfd_coff_gc_mark_extra_sections (info
, _bfd_coff_gc_mark_hook
);
3232 /* ... and mark SEC_EXCLUDE for those that go. */
3233 return coff_gc_sweep (abfd
, info
);
3236 /* Return name used to identify a comdat group. */
3239 bfd_coff_group_name (bfd
*abfd
, const asection
*sec
)
3241 struct coff_comdat_info
*ci
= bfd_coff_get_comdat_section (abfd
, sec
);
3248 _bfd_coff_close_and_cleanup (bfd
*abfd
)
3250 struct coff_tdata
*tdata
= coff_data (abfd
);
3255 Do not clear the keep_syms and keep_strings flags.
3256 These may have been set by pe_ILF_build_a_bfd() indicating
3257 that the syms and strings pointers are not to be freed. */
3258 if (bfd_get_format (abfd
) == bfd_object
3259 && bfd_family_coff (abfd
)
3260 && !_bfd_coff_free_symbols (abfd
))
3263 if (bfd_get_format (abfd
) == bfd_object
3264 || bfd_get_format (abfd
) == bfd_core
)
3265 _bfd_dwarf2_cleanup_debug_info (abfd
, &tdata
->dwarf2_find_line_info
);
3267 return _bfd_generic_close_and_cleanup (abfd
);