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
));
1095 memset (dummy
, 0, sizeof dummy
);
1097 native
->is_sym
= true;
1098 native
[1].is_sym
= false;
1099 native
->u
.syment
.n_type
= T_NULL
;
1100 native
->u
.syment
.n_flags
= 0;
1101 native
->u
.syment
.n_numaux
= 0;
1102 if (bfd_is_und_section (symbol
->section
))
1104 native
->u
.syment
.n_scnum
= N_UNDEF
;
1105 native
->u
.syment
.n_value
= symbol
->value
;
1107 else if (bfd_is_com_section (symbol
->section
))
1109 native
->u
.syment
.n_scnum
= N_UNDEF
;
1110 native
->u
.syment
.n_value
= symbol
->value
;
1112 else if (symbol
->flags
& BSF_FILE
)
1114 native
->u
.syment
.n_scnum
= N_DEBUG
;
1115 native
->u
.syment
.n_numaux
= 1;
1117 else if (symbol
->flags
& BSF_DEBUGGING
)
1119 /* There isn't much point to writing out a debugging symbol
1120 unless we are prepared to convert it into COFF debugging
1121 format. So, we just ignore them. We must clobber the symbol
1122 name to keep it from being put in the string table. */
1125 memset (isym
, 0, sizeof (*isym
));
1130 native
->u
.syment
.n_scnum
= output_section
->target_index
;
1131 native
->u
.syment
.n_value
= (symbol
->value
1132 + symbol
->section
->output_offset
);
1133 if (! obj_pe (abfd
))
1134 native
->u
.syment
.n_value
+= output_section
->vma
;
1136 /* Copy the any flags from the file header into the symbol.
1139 coff_symbol_type
*c
= coff_symbol_from (symbol
);
1140 if (c
!= (coff_symbol_type
*) NULL
)
1141 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (&c
->symbol
)->flags
;
1145 native
->u
.syment
.n_type
= 0;
1146 if (symbol
->flags
& BSF_FILE
)
1147 native
->u
.syment
.n_sclass
= C_FILE
;
1148 else if (symbol
->flags
& BSF_LOCAL
)
1149 native
->u
.syment
.n_sclass
= C_STAT
;
1150 else if (symbol
->flags
& BSF_WEAK
)
1151 native
->u
.syment
.n_sclass
= obj_pe (abfd
) ? C_NT_WEAK
: C_WEAKEXT
;
1153 native
->u
.syment
.n_sclass
= C_EXT
;
1155 ret
= coff_write_symbol (abfd
, symbol
, native
, written
, string_size_p
,
1156 debug_string_section_p
, debug_string_size_p
);
1158 *isym
= native
->u
.syment
;
1159 if (iaux
!= NULL
&& native
->u
.syment
.n_numaux
)
1160 *iaux
= native
[1].u
.auxent
;
1164 /* Write a native symbol to a COFF file. */
1167 coff_write_native_symbol (bfd
*abfd
,
1168 coff_symbol_type
*symbol
,
1170 bfd_size_type
*string_size_p
,
1171 asection
**debug_string_section_p
,
1172 bfd_size_type
*debug_string_size_p
)
1174 combined_entry_type
*native
= symbol
->native
;
1175 alent
*lineno
= symbol
->lineno
;
1176 struct bfd_link_info
*link_info
= coff_data (abfd
)->link_info
;
1178 if ((!link_info
|| link_info
->strip_discarded
)
1179 && !bfd_is_abs_section (symbol
->symbol
.section
)
1180 && symbol
->symbol
.section
->output_section
== bfd_abs_section_ptr
)
1182 symbol
->symbol
.name
= "";
1186 BFD_ASSERT (native
->is_sym
);
1187 /* If this symbol has an associated line number, we must store the
1188 symbol index in the line number field. We also tag the auxent to
1189 point to the right place in the lineno table. */
1190 if (lineno
&& !symbol
->done_lineno
&& symbol
->symbol
.section
->owner
!= NULL
)
1192 unsigned int count
= 0;
1194 lineno
[count
].u
.offset
= *written
;
1195 if (native
->u
.syment
.n_numaux
)
1197 union internal_auxent
*a
= &((native
+ 1)->u
.auxent
);
1199 a
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1200 symbol
->symbol
.section
->output_section
->moving_line_filepos
;
1203 /* Count and relocate all other linenumbers. */
1205 while (lineno
[count
].line_number
!= 0)
1207 lineno
[count
].u
.offset
+=
1208 (symbol
->symbol
.section
->output_section
->vma
1209 + symbol
->symbol
.section
->output_offset
);
1212 symbol
->done_lineno
= true;
1214 if (! bfd_is_const_section (symbol
->symbol
.section
->output_section
))
1215 symbol
->symbol
.section
->output_section
->moving_line_filepos
+=
1216 count
* bfd_coff_linesz (abfd
);
1219 return coff_write_symbol (abfd
, &(symbol
->symbol
), native
, written
,
1220 string_size_p
, debug_string_section_p
,
1221 debug_string_size_p
);
1225 null_error_handler (const char *fmt ATTRIBUTE_UNUSED
,
1226 va_list ap ATTRIBUTE_UNUSED
)
1230 /* Write out the COFF symbols. */
1233 coff_write_symbols (bfd
*abfd
)
1235 bfd_size_type string_size
;
1236 asection
*debug_string_section
;
1237 bfd_size_type debug_string_size
;
1239 unsigned int limit
= bfd_get_symcount (abfd
);
1240 bfd_vma written
= 0;
1244 debug_string_section
= NULL
;
1245 debug_string_size
= 0;
1247 /* If this target supports long section names, they must be put into
1248 the string table. This is supported by PE. This code must
1249 handle section names just as they are handled in
1250 coff_write_object_contents. */
1251 if (bfd_coff_long_section_names (abfd
))
1255 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1259 len
= strlen (o
->name
);
1261 string_size
+= len
+ 1;
1265 /* Seek to the right place. */
1266 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
1269 /* Output all the symbols we have. */
1271 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1273 asymbol
*symbol
= *p
;
1274 coff_symbol_type
*c_symbol
= coff_symbol_from (symbol
);
1276 if (c_symbol
== (coff_symbol_type
*) NULL
1277 || c_symbol
->native
== (combined_entry_type
*) NULL
)
1279 if (!coff_write_alien_symbol (abfd
, symbol
, NULL
, NULL
, &written
,
1280 &string_size
, &debug_string_section
,
1281 &debug_string_size
))
1286 if (coff_backend_info (abfd
)->_bfd_coff_classify_symbol
!= NULL
)
1288 bfd_error_handler_type current_error_handler
;
1289 enum coff_symbol_classification sym_class
;
1290 unsigned char *n_sclass
;
1292 /* Suppress error reporting by bfd_coff_classify_symbol.
1293 Error messages can be generated when we are processing a local
1294 symbol which has no associated section and we do not have to
1295 worry about this, all we need to know is that it is local. */
1296 current_error_handler
= bfd_set_error_handler (null_error_handler
);
1297 BFD_ASSERT (c_symbol
->native
->is_sym
);
1298 sym_class
= bfd_coff_classify_symbol (abfd
,
1299 &c_symbol
->native
->u
.syment
);
1300 (void) bfd_set_error_handler (current_error_handler
);
1302 n_sclass
= &c_symbol
->native
->u
.syment
.n_sclass
;
1304 /* If the symbol class has been changed (eg objcopy/ld script/etc)
1305 we cannot retain the existing sclass from the original symbol.
1306 Weak symbols only have one valid sclass, so just set it always.
1307 If it is not local class and should be, set it C_STAT.
1308 If it is global and not classified as global, or if it is
1309 weak (which is also classified as global), set it C_EXT. */
1311 if (symbol
->flags
& BSF_WEAK
)
1312 *n_sclass
= obj_pe (abfd
) ? C_NT_WEAK
: C_WEAKEXT
;
1313 else if (symbol
->flags
& BSF_LOCAL
&& sym_class
!= COFF_SYMBOL_LOCAL
)
1315 else if (symbol
->flags
& BSF_GLOBAL
1316 && (sym_class
!= COFF_SYMBOL_GLOBAL
1318 || *n_sclass
== C_NT_WEAK
1320 || *n_sclass
== C_WEAKEXT
))
1321 c_symbol
->native
->u
.syment
.n_sclass
= C_EXT
;
1324 if (!coff_write_native_symbol (abfd
, c_symbol
, &written
,
1325 &string_size
, &debug_string_section
,
1326 &debug_string_size
))
1331 obj_raw_syment_count (abfd
) = written
;
1333 /* Now write out strings. */
1334 if (string_size
!= 0)
1336 unsigned int size
= string_size
+ STRING_SIZE_SIZE
;
1337 bfd_byte buffer
[STRING_SIZE_SIZE
];
1339 #if STRING_SIZE_SIZE == 4
1340 H_PUT_32 (abfd
, size
, buffer
);
1342 #error Change H_PUT_32
1344 if (bfd_bwrite ((void *) buffer
, (bfd_size_type
) sizeof (buffer
), abfd
)
1348 /* Handle long section names. This code must handle section
1349 names just as they are handled in coff_write_object_contents. */
1350 if (bfd_coff_long_section_names (abfd
))
1354 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1358 len
= strlen (o
->name
);
1361 if (bfd_bwrite (o
->name
, (bfd_size_type
) (len
+ 1), abfd
)
1368 for (p
= abfd
->outsymbols
, i
= 0;
1373 size_t name_length
= strlen (q
->name
);
1374 coff_symbol_type
*c_symbol
= coff_symbol_from (q
);
1376 bool is_c_file
= false;
1378 /* Figure out whether the symbol name should go in the string
1379 table. Symbol names that are short enough are stored
1380 directly in the syment structure. File names permit a
1381 different, longer, length in the syment structure. On
1382 XCOFF, some symbol names are stored in the .debug section
1383 rather than in the string table. */
1385 if (c_symbol
== NULL
1386 || c_symbol
->native
== NULL
)
1387 /* This is not a COFF symbol, so it certainly is not a
1388 file name, nor does it go in the .debug section. */
1389 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1391 else if (! c_symbol
->native
->is_sym
)
1392 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1394 else if (bfd_coff_symname_in_debug (abfd
,
1395 &c_symbol
->native
->u
.syment
))
1396 /* This symbol name is in the XCOFF .debug section.
1397 Don't write it into the string table. */
1398 maxlen
= name_length
;
1400 else if (c_symbol
->native
->u
.syment
.n_sclass
== C_FILE
1401 && c_symbol
->native
->u
.syment
.n_numaux
> 0)
1404 if (bfd_coff_force_symnames_in_strings (abfd
))
1406 if (bfd_bwrite (".file", (bfd_size_type
) 6, abfd
) != 6)
1409 maxlen
= bfd_coff_filnmlen (abfd
);
1412 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1414 if (name_length
> maxlen
)
1416 if (bfd_bwrite ((void *) (q
->name
), (bfd_size_type
) name_length
+ 1,
1417 abfd
) != name_length
+ 1)
1421 /* Add strings for C_FILE aux entries. */
1423 && c_symbol
->native
->u
.syment
.n_numaux
> 1)
1425 for (int j
= 1; j
< c_symbol
->native
->u
.syment
.n_numaux
; j
++)
1430 /* Add strings from aux entries only if this isn't the
1431 filename auxiliary entry. */
1432 if (!c_symbol
->native
[j
+ 1].u
.auxent
.x_file
.x_ftype
)
1435 if (c_symbol
->native
[j
+ 1].u
.auxent
.x_file
.x_n
.x_fname
[0] != 0)
1438 str
= (char *) c_symbol
->native
[j
+ 1].extrap
;
1439 str_length
= strlen (str
);
1440 if (str_length
> maxlen
)
1442 if (bfd_bwrite ((void *) (str
), (bfd_size_type
) str_length
+ 1,
1443 abfd
) != str_length
+ 1)
1453 /* We would normally not write anything here, but we'll write
1454 out 4 so that any stupid coff reader which tries to read the
1455 string table even when there isn't one won't croak. */
1456 unsigned int size
= STRING_SIZE_SIZE
;
1457 bfd_byte buffer
[STRING_SIZE_SIZE
];
1459 #if STRING_SIZE_SIZE == 4
1460 H_PUT_32 (abfd
, size
, buffer
);
1462 #error Change H_PUT_32
1464 if (bfd_bwrite ((void *) buffer
, (bfd_size_type
) STRING_SIZE_SIZE
, abfd
)
1465 != STRING_SIZE_SIZE
)
1469 /* Make sure the .debug section was created to be the correct size.
1470 We should create it ourselves on the fly, but we don't because
1471 BFD won't let us write to any section until we know how large all
1472 the sections are. We could still do it by making another pass
1473 over the symbols. FIXME. */
1474 BFD_ASSERT (debug_string_size
== 0
1475 || (debug_string_section
!= (asection
*) NULL
1476 && (BFD_ALIGN (debug_string_size
,
1477 1 << debug_string_section
->alignment_power
)
1478 == debug_string_section
->size
)));
1484 coff_write_linenumbers (bfd
*abfd
)
1487 bfd_size_type linesz
;
1490 linesz
= bfd_coff_linesz (abfd
);
1491 buff
= bfd_alloc (abfd
, linesz
);
1494 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
1496 if (s
->lineno_count
)
1498 asymbol
**q
= abfd
->outsymbols
;
1499 if (bfd_seek (abfd
, s
->line_filepos
, SEEK_SET
) != 0)
1501 /* Find all the linenumbers in this section. */
1505 if (p
->section
->output_section
== s
)
1508 BFD_SEND (bfd_asymbol_bfd (p
), _get_lineno
,
1509 (bfd_asymbol_bfd (p
), p
));
1512 /* Found a linenumber entry, output. */
1513 struct internal_lineno out
;
1515 memset ((void *) & out
, 0, sizeof (out
));
1517 out
.l_addr
.l_symndx
= l
->u
.offset
;
1518 bfd_coff_swap_lineno_out (abfd
, &out
, buff
);
1519 if (bfd_bwrite (buff
, (bfd_size_type
) linesz
, abfd
)
1523 while (l
->line_number
)
1525 out
.l_lnno
= l
->line_number
;
1526 out
.l_addr
.l_symndx
= l
->u
.offset
;
1527 bfd_coff_swap_lineno_out (abfd
, &out
, buff
);
1528 if (bfd_bwrite (buff
, (bfd_size_type
) linesz
, abfd
)
1539 bfd_release (abfd
, buff
);
1544 coff_get_lineno (bfd
*ignore_abfd ATTRIBUTE_UNUSED
, asymbol
*symbol
)
1546 return coffsymbol (symbol
)->lineno
;
1549 /* This function transforms the offsets into the symbol table into
1550 pointers to syments. */
1553 coff_pointerize_aux (bfd
*abfd
,
1554 combined_entry_type
*table_base
,
1555 combined_entry_type
*symbol
,
1556 unsigned int indaux
,
1557 combined_entry_type
*auxent
,
1558 combined_entry_type
*table_end
)
1560 unsigned int type
= symbol
->u
.syment
.n_type
;
1561 unsigned int n_sclass
= symbol
->u
.syment
.n_sclass
;
1563 BFD_ASSERT (symbol
->is_sym
);
1564 if (coff_backend_info (abfd
)->_bfd_coff_pointerize_aux_hook
)
1566 if ((*coff_backend_info (abfd
)->_bfd_coff_pointerize_aux_hook
)
1567 (abfd
, table_base
, symbol
, indaux
, auxent
))
1571 /* Don't bother if this is a file or a section. */
1572 if (n_sclass
== C_STAT
&& type
== T_NULL
)
1574 if (n_sclass
== C_FILE
)
1576 if (n_sclass
== C_DWARF
)
1579 BFD_ASSERT (! auxent
->is_sym
);
1580 /* Otherwise patch up. */
1581 #define N_TMASK coff_data (abfd)->local_n_tmask
1582 #define N_BTSHFT coff_data (abfd)->local_n_btshft
1584 if ((ISFCN (type
) || ISTAG (n_sclass
) || n_sclass
== C_BLOCK
1585 || n_sclass
== C_FCN
)
1586 && auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
> 0
1587 && auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
1588 < (long) obj_raw_syment_count (abfd
)
1589 && table_base
+ auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
1592 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
=
1593 table_base
+ auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
1594 auxent
->fix_end
= 1;
1597 /* A negative tagndx is meaningless, but the SCO 3.2v4 cc can
1598 generate one, so we must be careful to ignore it. */
1599 if ((unsigned long) auxent
->u
.auxent
.x_sym
.x_tagndx
.l
1600 < obj_raw_syment_count (abfd
)
1601 && table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
< table_end
)
1603 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
=
1604 table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
;
1605 auxent
->fix_tag
= 1;
1609 /* Allocate space for the ".debug" section, and read it.
1610 We did not read the debug section until now, because
1611 we didn't want to go to the trouble until someone needed it. */
1614 build_debug_section (bfd
*abfd
, asection
** sect_return
)
1616 char *debug_section
;
1618 bfd_size_type sec_size
;
1620 asection
*sect
= bfd_get_section_by_name (abfd
, ".debug");
1624 bfd_set_error (bfd_error_no_debug_section
);
1628 /* Seek to the beginning of the `.debug' section and read it.
1629 Save the current position first; it is needed by our caller.
1630 Then read debug section and reset the file pointer. */
1632 position
= bfd_tell (abfd
);
1633 if (bfd_seek (abfd
, sect
->filepos
, SEEK_SET
) != 0)
1636 sec_size
= sect
->size
;
1637 debug_section
= (char *) _bfd_alloc_and_read (abfd
, sec_size
, sec_size
);
1638 if (debug_section
== NULL
)
1641 if (bfd_seek (abfd
, position
, SEEK_SET
) != 0)
1644 * sect_return
= sect
;
1645 return debug_section
;
1648 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
1649 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
1650 be \0-terminated. */
1653 copy_name (bfd
*abfd
, char *name
, size_t maxlen
)
1658 for (len
= 0; len
< maxlen
; ++len
)
1659 if (name
[len
] == '\0')
1662 if ((newname
= (char *) bfd_alloc (abfd
, (bfd_size_type
) len
+ 1)) == NULL
)
1665 strncpy (newname
, name
, len
);
1666 newname
[len
] = '\0';
1670 /* Read in the external symbols. */
1673 _bfd_coff_get_external_symbols (bfd
*abfd
)
1679 if (obj_coff_external_syms (abfd
) != NULL
)
1682 symesz
= bfd_coff_symesz (abfd
);
1683 if (_bfd_mul_overflow (obj_raw_syment_count (abfd
), symesz
, &size
))
1685 bfd_set_error (bfd_error_file_truncated
);
1692 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
1694 syms
= _bfd_malloc_and_read (abfd
, size
, size
);
1695 obj_coff_external_syms (abfd
) = syms
;
1696 return syms
!= NULL
;
1699 /* Read in the external strings. The strings are not loaded until
1700 they are needed. This is because we have no simple way of
1701 detecting a missing string table in an archive. If the strings
1702 are loaded then the STRINGS and STRINGS_LEN fields in the
1703 coff_tdata structure will be set. */
1706 _bfd_coff_read_string_table (bfd
*abfd
)
1708 char extstrsize
[STRING_SIZE_SIZE
];
1709 bfd_size_type strsize
;
1716 if (obj_coff_strings (abfd
) != NULL
)
1717 return obj_coff_strings (abfd
);
1719 if (obj_sym_filepos (abfd
) == 0)
1721 bfd_set_error (bfd_error_no_symbols
);
1725 symesz
= bfd_coff_symesz (abfd
);
1726 pos
= obj_sym_filepos (abfd
);
1727 if (_bfd_mul_overflow (obj_raw_syment_count (abfd
), symesz
, &size
)
1728 || pos
+ size
< pos
)
1730 bfd_set_error (bfd_error_file_truncated
);
1734 if (bfd_seek (abfd
, pos
+ size
, SEEK_SET
) != 0)
1737 if (bfd_bread (extstrsize
, (bfd_size_type
) sizeof extstrsize
, abfd
)
1738 != sizeof extstrsize
)
1740 if (bfd_get_error () != bfd_error_file_truncated
)
1743 /* There is no string table. */
1744 strsize
= STRING_SIZE_SIZE
;
1748 #if STRING_SIZE_SIZE == 4
1749 strsize
= H_GET_32 (abfd
, extstrsize
);
1751 #error Change H_GET_32
1755 filesize
= bfd_get_file_size (abfd
);
1756 if (strsize
< STRING_SIZE_SIZE
1757 || (filesize
!= 0 && strsize
> filesize
))
1760 /* xgettext: c-format */
1761 (_("%pB: bad string table size %" PRIu64
), abfd
, (uint64_t) strsize
);
1762 bfd_set_error (bfd_error_bad_value
);
1766 strings
= (char *) bfd_malloc (strsize
+ 1);
1767 if (strings
== NULL
)
1770 /* PR 17521 file: 079-54929-0.004.
1771 A corrupt file could contain an index that points into the first
1772 STRING_SIZE_SIZE bytes of the string table, so make sure that
1774 memset (strings
, 0, STRING_SIZE_SIZE
);
1776 if (bfd_bread (strings
+ STRING_SIZE_SIZE
, strsize
- STRING_SIZE_SIZE
, abfd
)
1777 != strsize
- STRING_SIZE_SIZE
)
1783 obj_coff_strings (abfd
) = strings
;
1784 obj_coff_strings_len (abfd
) = strsize
;
1785 /* Terminate the string table, just in case. */
1786 strings
[strsize
] = 0;
1790 /* Free up the external symbols and strings read from a COFF file. */
1793 _bfd_coff_free_symbols (bfd
*abfd
)
1795 if (! bfd_family_coff (abfd
))
1798 if (obj_coff_external_syms (abfd
) != NULL
1799 && ! obj_coff_keep_syms (abfd
))
1801 free (obj_coff_external_syms (abfd
));
1802 obj_coff_external_syms (abfd
) = NULL
;
1805 if (obj_coff_strings (abfd
) != NULL
1806 && ! obj_coff_keep_strings (abfd
))
1808 free (obj_coff_strings (abfd
));
1809 obj_coff_strings (abfd
) = NULL
;
1810 obj_coff_strings_len (abfd
) = 0;
1816 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
1817 knit the symbol names into a normalized form. By normalized here I
1818 mean that all symbols have an n_offset pointer that points to a null-
1819 terminated string. */
1821 combined_entry_type
*
1822 coff_get_normalized_symtab (bfd
*abfd
)
1824 combined_entry_type
*internal
;
1825 combined_entry_type
*internal_ptr
;
1826 combined_entry_type
*symbol_ptr
;
1827 combined_entry_type
*internal_end
;
1831 const char *string_table
= NULL
;
1832 asection
* debug_sec
= NULL
;
1833 char *debug_sec_data
= NULL
;
1836 if (obj_raw_syments (abfd
) != NULL
)
1837 return obj_raw_syments (abfd
);
1839 if (! _bfd_coff_get_external_symbols (abfd
))
1842 size
= obj_raw_syment_count (abfd
);
1843 /* Check for integer overflow. */
1844 if (size
> (bfd_size_type
) -1 / sizeof (combined_entry_type
))
1846 size
*= sizeof (combined_entry_type
);
1847 internal
= (combined_entry_type
*) bfd_zalloc (abfd
, size
);
1848 if (internal
== NULL
&& size
!= 0)
1850 internal_end
= internal
+ obj_raw_syment_count (abfd
);
1852 raw_src
= (char *) obj_coff_external_syms (abfd
);
1854 /* Mark the end of the symbols. */
1855 symesz
= bfd_coff_symesz (abfd
);
1856 raw_end
= PTR_ADD (raw_src
, obj_raw_syment_count (abfd
) * symesz
);
1858 /* FIXME SOMEDAY. A string table size of zero is very weird, but
1859 probably possible. If one shows up, it will probably kill us. */
1861 /* Swap all the raw entries. */
1862 for (internal_ptr
= internal
;
1864 raw_src
+= symesz
, internal_ptr
++)
1868 bfd_coff_swap_sym_in (abfd
, (void *) raw_src
,
1869 (void *) & internal_ptr
->u
.syment
);
1870 symbol_ptr
= internal_ptr
;
1871 internal_ptr
->is_sym
= true;
1873 /* PR 17512: Prevent buffer overrun. */
1874 if (symbol_ptr
->u
.syment
.n_numaux
> ((raw_end
- 1) - raw_src
) / symesz
)
1876 bfd_release (abfd
, internal
);
1881 i
< symbol_ptr
->u
.syment
.n_numaux
;
1887 bfd_coff_swap_aux_in (abfd
, (void *) raw_src
,
1888 symbol_ptr
->u
.syment
.n_type
,
1889 symbol_ptr
->u
.syment
.n_sclass
,
1890 (int) i
, symbol_ptr
->u
.syment
.n_numaux
,
1891 &(internal_ptr
->u
.auxent
));
1893 internal_ptr
->is_sym
= false;
1894 coff_pointerize_aux (abfd
, internal
, symbol_ptr
, i
,
1895 internal_ptr
, internal_end
);
1899 /* Free the raw symbols. */
1900 if (obj_coff_external_syms (abfd
) != NULL
1901 && ! obj_coff_keep_syms (abfd
))
1903 free (obj_coff_external_syms (abfd
));
1904 obj_coff_external_syms (abfd
) = NULL
;
1907 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
1910 BFD_ASSERT (internal_ptr
->is_sym
);
1912 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
1913 && internal_ptr
->u
.syment
.n_numaux
> 0)
1915 combined_entry_type
* aux
= internal_ptr
+ 1;
1917 /* Make a file symbol point to the name in the auxent, since
1918 the text ".file" is redundant. */
1919 BFD_ASSERT (! aux
->is_sym
);
1921 if (aux
->u
.auxent
.x_file
.x_n
.x_n
.x_zeroes
== 0)
1923 /* The filename is a long one, point into the string table. */
1924 if (string_table
== NULL
)
1926 string_table
= _bfd_coff_read_string_table (abfd
);
1927 if (string_table
== NULL
)
1931 if ((bfd_size_type
)(aux
->u
.auxent
.x_file
.x_n
.x_n
.x_offset
)
1932 >= obj_coff_strings_len (abfd
))
1933 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1935 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1936 (bfd_hostptr_t
) (string_table
+ (aux
->u
.auxent
.x_file
.x_n
.x_n
.x_offset
));
1940 /* Ordinary short filename, put into memory anyway. The
1941 Microsoft PE tools sometimes store a filename in
1942 multiple AUX entries. */
1943 if (internal_ptr
->u
.syment
.n_numaux
> 1
1944 && coff_data (abfd
)->pe
)
1945 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1948 aux
->u
.auxent
.x_file
.x_n
.x_fname
,
1949 internal_ptr
->u
.syment
.n_numaux
* symesz
);
1951 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1954 aux
->u
.auxent
.x_file
.x_n
.x_fname
,
1955 (size_t) bfd_coff_filnmlen (abfd
)));
1958 /* Normalize other strings available in C_FILE aux entries. */
1959 if (!coff_data (abfd
)->pe
)
1960 for (int numaux
= 1; numaux
< internal_ptr
->u
.syment
.n_numaux
; numaux
++)
1962 aux
= internal_ptr
+ numaux
+ 1;
1963 BFD_ASSERT (! aux
->is_sym
);
1965 if (aux
->u
.auxent
.x_file
.x_n
.x_n
.x_zeroes
== 0)
1967 /* The string information is a long one, point into the string table. */
1968 if (string_table
== NULL
)
1970 string_table
= _bfd_coff_read_string_table (abfd
);
1971 if (string_table
== NULL
)
1975 if ((bfd_size_type
)(aux
->u
.auxent
.x_file
.x_n
.x_n
.x_offset
)
1976 >= obj_coff_strings_len (abfd
))
1977 aux
->u
.auxent
.x_file
.x_n
.x_n
.x_offset
= (bfd_hostptr_t
) _("<corrupt>");
1979 aux
->u
.auxent
.x_file
.x_n
.x_n
.x_offset
=
1980 (bfd_hostptr_t
) (string_table
+ (aux
->u
.auxent
.x_file
.x_n
.x_n
.x_offset
));
1983 aux
->u
.auxent
.x_file
.x_n
.x_n
.x_offset
=
1986 aux
->u
.auxent
.x_file
.x_n
.x_fname
,
1987 (size_t) bfd_coff_filnmlen (abfd
)));
1993 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0)
1995 /* This is a "short" name. Make it long. */
1999 /* Find the length of this string without walking into memory
2001 for (i
= 0; i
< 8; ++i
)
2002 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0')
2005 newstring
= (char *) bfd_zalloc (abfd
, (bfd_size_type
) (i
+ 1));
2006 if (newstring
== NULL
)
2008 strncpy (newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
);
2009 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) newstring
;
2010 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
2012 else if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
== 0)
2013 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) "";
2014 else if (!bfd_coff_symname_in_debug (abfd
, &internal_ptr
->u
.syment
))
2016 /* Long name already. Point symbol at the string in the
2018 if (string_table
== NULL
)
2020 string_table
= _bfd_coff_read_string_table (abfd
);
2021 if (string_table
== NULL
)
2024 if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
>= obj_coff_strings_len (abfd
)
2025 || string_table
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
< string_table
)
2026 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
2028 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
2031 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
));
2035 /* Long name in debug section. Very similar. */
2036 if (debug_sec_data
== NULL
)
2037 debug_sec_data
= build_debug_section (abfd
, & debug_sec
);
2038 if (debug_sec_data
!= NULL
)
2040 BFD_ASSERT (debug_sec
!= NULL
);
2041 /* PR binutils/17512: Catch out of range offsets into the debug data. */
2042 if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
> debug_sec
->size
2043 || debug_sec_data
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
< debug_sec_data
)
2044 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
2046 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
)
2047 (debug_sec_data
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
2050 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) "";
2053 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
2056 obj_raw_syments (abfd
) = internal
;
2057 BFD_ASSERT (obj_raw_syment_count (abfd
)
2058 == (unsigned int) (internal_ptr
- internal
));
2064 coff_get_reloc_upper_bound (bfd
*abfd
, sec_ptr asect
)
2066 if (bfd_get_format (abfd
) != bfd_object
)
2068 bfd_set_error (bfd_error_invalid_operation
);
2071 #if SIZEOF_LONG == SIZEOF_INT
2072 if (asect
->reloc_count
>= LONG_MAX
/ sizeof (arelent
*))
2074 bfd_set_error (bfd_error_file_too_big
);
2078 return (asect
->reloc_count
+ 1L) * sizeof (arelent
*);
2082 coff_make_empty_symbol (bfd
*abfd
)
2084 size_t amt
= sizeof (coff_symbol_type
);
2085 coff_symbol_type
*new_symbol
= (coff_symbol_type
*) bfd_zalloc (abfd
, amt
);
2087 if (new_symbol
== NULL
)
2089 new_symbol
->symbol
.section
= 0;
2090 new_symbol
->native
= NULL
;
2091 new_symbol
->lineno
= NULL
;
2092 new_symbol
->done_lineno
= false;
2093 new_symbol
->symbol
.the_bfd
= abfd
;
2095 return & new_symbol
->symbol
;
2098 /* Make a debugging symbol. */
2101 coff_bfd_make_debug_symbol (bfd
*abfd
,
2102 void * ptr ATTRIBUTE_UNUSED
,
2103 unsigned long sz ATTRIBUTE_UNUSED
)
2105 size_t amt
= sizeof (coff_symbol_type
);
2106 coff_symbol_type
*new_symbol
= (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
2108 if (new_symbol
== NULL
)
2110 /* @@ The 10 is a guess at a plausible maximum number of aux entries
2111 (but shouldn't be a constant). */
2112 amt
= sizeof (combined_entry_type
) * 10;
2113 new_symbol
->native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
2114 if (!new_symbol
->native
)
2116 new_symbol
->native
->is_sym
= true;
2117 new_symbol
->symbol
.section
= bfd_abs_section_ptr
;
2118 new_symbol
->symbol
.flags
= BSF_DEBUGGING
;
2119 new_symbol
->lineno
= NULL
;
2120 new_symbol
->done_lineno
= false;
2121 new_symbol
->symbol
.the_bfd
= abfd
;
2123 return & new_symbol
->symbol
;
2127 coff_get_symbol_info (bfd
*abfd
, asymbol
*symbol
, symbol_info
*ret
)
2129 bfd_symbol_info (symbol
, ret
);
2131 if (coffsymbol (symbol
)->native
!= NULL
2132 && coffsymbol (symbol
)->native
->fix_value
2133 && coffsymbol (symbol
)->native
->is_sym
)
2135 = (((bfd_hostptr_t
) coffsymbol (symbol
)->native
->u
.syment
.n_value
2136 - (bfd_hostptr_t
) obj_raw_syments (abfd
))
2137 / sizeof (combined_entry_type
));
2140 /* Print out information about COFF symbol. */
2143 coff_print_symbol (bfd
*abfd
,
2146 bfd_print_symbol_type how
)
2148 FILE * file
= (FILE *) filep
;
2152 case bfd_print_symbol_name
:
2153 fprintf (file
, "%s", symbol
->name
);
2156 case bfd_print_symbol_more
:
2157 fprintf (file
, "coff %s %s",
2158 coffsymbol (symbol
)->native
? "n" : "g",
2159 coffsymbol (symbol
)->lineno
? "l" : " ");
2162 case bfd_print_symbol_all
:
2163 if (coffsymbol (symbol
)->native
)
2167 combined_entry_type
*combined
= coffsymbol (symbol
)->native
;
2168 combined_entry_type
*root
= obj_raw_syments (abfd
);
2169 struct lineno_cache_entry
*l
= coffsymbol (symbol
)->lineno
;
2171 fprintf (file
, "[%3ld]", (long) (combined
- root
));
2173 /* PR 17512: file: 079-33786-0.001:0.1. */
2174 if (combined
< obj_raw_syments (abfd
)
2175 || combined
>= obj_raw_syments (abfd
) + obj_raw_syment_count (abfd
))
2177 fprintf (file
, _("<corrupt info> %s"), symbol
->name
);
2181 BFD_ASSERT (combined
->is_sym
);
2182 if (! combined
->fix_value
)
2183 val
= (bfd_vma
) combined
->u
.syment
.n_value
;
2185 val
= (((bfd_hostptr_t
) combined
->u
.syment
.n_value
2186 - (bfd_hostptr_t
) root
)
2187 / sizeof (combined_entry_type
));
2189 fprintf (file
, "(sec %2d)(fl 0x%02x)(ty %4x)(scl %3d) (nx %d) 0x",
2190 combined
->u
.syment
.n_scnum
,
2191 combined
->u
.syment
.n_flags
,
2192 combined
->u
.syment
.n_type
,
2193 combined
->u
.syment
.n_sclass
,
2194 combined
->u
.syment
.n_numaux
);
2195 bfd_fprintf_vma (abfd
, file
, val
);
2196 fprintf (file
, " %s", symbol
->name
);
2198 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
2200 combined_entry_type
*auxp
= combined
+ aux
+ 1;
2203 BFD_ASSERT (! auxp
->is_sym
);
2205 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.p
- root
;
2207 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.l
;
2209 fprintf (file
, "\n");
2211 if (bfd_coff_print_aux (abfd
, file
, root
, combined
, auxp
, aux
))
2214 switch (combined
->u
.syment
.n_sclass
)
2217 fprintf (file
, "File ");
2218 /* Add additional information if this isn't the filename
2220 if (auxp
->u
.auxent
.x_file
.x_ftype
)
2221 fprintf (file
, "ftype %d fname \"%s\"",
2222 auxp
->u
.auxent
.x_file
.x_ftype
,
2223 (char *) auxp
->u
.auxent
.x_file
.x_n
.x_n
.x_offset
);
2227 fprintf (file
, "AUX scnlen 0x%lx nreloc %ld",
2228 (unsigned long) auxp
->u
.auxent
.x_sect
.x_scnlen
,
2229 auxp
->u
.auxent
.x_sect
.x_nreloc
);
2233 if (combined
->u
.syment
.n_type
== T_NULL
)
2234 /* Probably a section symbol ? */
2236 fprintf (file
, "AUX scnlen 0x%lx nreloc %d nlnno %d",
2237 (unsigned long) auxp
->u
.auxent
.x_scn
.x_scnlen
,
2238 auxp
->u
.auxent
.x_scn
.x_nreloc
,
2239 auxp
->u
.auxent
.x_scn
.x_nlinno
);
2240 if (auxp
->u
.auxent
.x_scn
.x_checksum
!= 0
2241 || auxp
->u
.auxent
.x_scn
.x_associated
!= 0
2242 || auxp
->u
.auxent
.x_scn
.x_comdat
!= 0)
2243 fprintf (file
, " checksum 0x%lx assoc %d comdat %d",
2244 auxp
->u
.auxent
.x_scn
.x_checksum
,
2245 auxp
->u
.auxent
.x_scn
.x_associated
,
2246 auxp
->u
.auxent
.x_scn
.x_comdat
);
2252 if (ISFCN (combined
->u
.syment
.n_type
))
2257 next
= (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2260 next
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2261 llnos
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
2263 "AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld",
2265 (unsigned long) auxp
->u
.auxent
.x_sym
.x_misc
.x_fsize
,
2271 fprintf (file
, "AUX lnno %d size 0x%x tagndx %ld",
2272 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
2273 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
,
2276 fprintf (file
, " endndx %ld",
2278 (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2286 fprintf (file
, "\n%s :", l
->u
.sym
->name
);
2288 while (l
->line_number
)
2290 if (l
->line_number
> 0)
2292 fprintf (file
, "\n%4d : ", l
->line_number
);
2293 bfd_fprintf_vma (abfd
, file
, l
->u
.offset
+ symbol
->section
->vma
);
2301 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
2302 fprintf (file
, " %-5s %s %s %s",
2303 symbol
->section
->name
,
2304 coffsymbol (symbol
)->native
? "n" : "g",
2305 coffsymbol (symbol
)->lineno
? "l" : " ",
2311 /* Return whether a symbol name implies a local symbol. In COFF,
2312 local symbols generally start with ``.L''. Most targets use this
2313 function for the is_local_label_name entry point, but some may
2317 _bfd_coff_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
2320 return name
[0] == '.' && name
[1] == 'L';
2323 /* Provided a BFD, a section and an offset (in bytes, not octets) into the
2324 section, calculate and return the name of the source file and the line
2325 nearest to the wanted location. */
2328 coff_find_nearest_line_with_names (bfd
*abfd
,
2332 const char **filename_ptr
,
2333 const char **functionname_ptr
,
2334 unsigned int *line_ptr
,
2335 const struct dwarf_debug_section
*debug_sections
)
2339 unsigned int line_base
;
2340 coff_data_type
*cof
= coff_data (abfd
);
2341 /* Run through the raw syments if available. */
2342 combined_entry_type
*p
;
2343 combined_entry_type
*pend
;
2345 struct coff_section_tdata
*sec_data
;
2348 /* Before looking through the symbol table, try to use a .stab
2349 section to find the information. */
2350 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2351 &found
, filename_ptr
,
2352 functionname_ptr
, line_ptr
,
2353 &coff_data(abfd
)->line_info
))
2359 /* Also try examining DWARF2 debugging information. */
2360 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
2361 filename_ptr
, functionname_ptr
,
2362 line_ptr
, NULL
, debug_sections
,
2363 &coff_data(abfd
)->dwarf2_find_line_info
))
2366 sec_data
= coff_section_data (abfd
, section
);
2368 /* If the DWARF lookup failed, but there is DWARF information available
2369 then the problem might be that the file has been rebased. This tool
2370 changes the VMAs of all the sections, but it does not update the DWARF
2371 information. So try again, using a bias against the address sought. */
2372 if (coff_data (abfd
)->dwarf2_find_line_info
!= NULL
)
2374 bfd_signed_vma bias
= 0;
2376 /* Create a cache of the result for the next call. */
2377 if (sec_data
== NULL
&& section
->owner
== abfd
)
2379 amt
= sizeof (struct coff_section_tdata
);
2380 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
2381 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2384 if (sec_data
!= NULL
&& sec_data
->saved_bias
)
2385 bias
= sec_data
->saved_bias
;
2388 bias
= _bfd_dwarf2_find_symbol_bias (symbols
,
2389 & coff_data (abfd
)->dwarf2_find_line_info
);
2393 sec_data
->saved_bias
= true;
2394 sec_data
->bias
= bias
;
2399 && _bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
,
2401 filename_ptr
, functionname_ptr
,
2402 line_ptr
, NULL
, debug_sections
,
2403 &coff_data(abfd
)->dwarf2_find_line_info
))
2408 *functionname_ptr
= 0;
2411 /* Don't try and find line numbers in a non coff file. */
2412 if (!bfd_family_coff (abfd
))
2418 /* Find the first C_FILE symbol. */
2419 p
= cof
->raw_syments
;
2423 pend
= p
+ cof
->raw_syment_count
;
2426 BFD_ASSERT (p
->is_sym
);
2427 if (p
->u
.syment
.n_sclass
== C_FILE
)
2429 p
+= 1 + p
->u
.syment
.n_numaux
;
2437 /* Look through the C_FILE symbols to find the best one. */
2438 sec_vma
= bfd_section_vma (section
);
2439 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2440 maxdiff
= (bfd_vma
) 0 - (bfd_vma
) 1;
2444 combined_entry_type
*p2
;
2446 for (p2
= p
+ 1 + p
->u
.syment
.n_numaux
;
2448 p2
+= 1 + p2
->u
.syment
.n_numaux
)
2450 BFD_ASSERT (p2
->is_sym
);
2451 if (p2
->u
.syment
.n_scnum
> 0
2453 == coff_section_from_bfd_index (abfd
,
2454 p2
->u
.syment
.n_scnum
)))
2456 if (p2
->u
.syment
.n_sclass
== C_FILE
)
2465 file_addr
= (bfd_vma
) p2
->u
.syment
.n_value
;
2466 /* PR 11512: Include the section address of the function name symbol. */
2467 if (p2
->u
.syment
.n_scnum
> 0)
2468 file_addr
+= coff_section_from_bfd_index (abfd
,
2469 p2
->u
.syment
.n_scnum
)->vma
;
2470 /* We use <= MAXDIFF here so that if we get a zero length
2471 file, we actually use the next file entry. */
2473 && offset
+ sec_vma
>= file_addr
2474 && offset
+ sec_vma
- file_addr
<= maxdiff
)
2476 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2477 maxdiff
= offset
+ sec_vma
- p2
->u
.syment
.n_value
;
2480 if (p
->u
.syment
.n_value
>= cof
->raw_syment_count
)
2483 /* Avoid endless loops on erroneous files by ensuring that
2484 we always move forward in the file. */
2485 if (p
>= cof
->raw_syments
+ p
->u
.syment
.n_value
)
2488 p
= cof
->raw_syments
+ p
->u
.syment
.n_value
;
2489 if (!p
->is_sym
|| p
->u
.syment
.n_sclass
!= C_FILE
)
2494 if (section
->lineno_count
== 0)
2496 *functionname_ptr
= NULL
;
2501 /* Now wander though the raw linenumbers of the section.
2502 If we have been called on this section before, and the offset
2503 we want is further down then we can prime the lookup loop. */
2504 if (sec_data
!= NULL
2506 && offset
>= sec_data
->offset
)
2509 *functionname_ptr
= sec_data
->function
;
2510 line_base
= sec_data
->line_base
;
2518 if (section
->lineno
!= NULL
)
2520 bfd_vma last_value
= 0;
2522 l
= §ion
->lineno
[i
];
2524 for (; i
< section
->lineno_count
; i
++)
2526 if (l
->line_number
== 0)
2528 /* Get the symbol this line number points at. */
2529 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
2530 if (coff
->symbol
.value
> offset
)
2533 *functionname_ptr
= coff
->symbol
.name
;
2534 last_value
= coff
->symbol
.value
;
2537 combined_entry_type
*s
= coff
->native
;
2539 BFD_ASSERT (s
->is_sym
);
2540 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2542 /* In XCOFF a debugging symbol can follow the
2544 if (((size_t) ((char *) s
- (char *) obj_raw_syments (abfd
))
2545 < obj_raw_syment_count (abfd
) * sizeof (*s
))
2546 && s
->u
.syment
.n_scnum
== N_DEBUG
)
2547 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2549 /* S should now point to the .bf of the function. */
2550 if (((size_t) ((char *) s
- (char *) obj_raw_syments (abfd
))
2551 < obj_raw_syment_count (abfd
) * sizeof (*s
))
2552 && s
->u
.syment
.n_numaux
)
2554 /* The linenumber is stored in the auxent. */
2555 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
2557 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
2558 *line_ptr
= line_base
;
2564 if (l
->u
.offset
> offset
)
2566 *line_ptr
= l
->line_number
+ line_base
- 1;
2571 /* If we fell off the end of the loop, then assume that this
2572 symbol has no line number info. Otherwise, symbols with no
2573 line number info get reported with the line number of the
2574 last line of the last symbol which does have line number
2575 info. We use 0x100 as a slop to account for cases where the
2576 last line has executable code. */
2577 if (i
>= section
->lineno_count
2579 && offset
- last_value
> 0x100)
2581 *functionname_ptr
= NULL
;
2586 /* Cache the results for the next call. */
2587 if (sec_data
== NULL
&& section
->owner
== abfd
)
2589 amt
= sizeof (struct coff_section_tdata
);
2590 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
2591 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2594 if (sec_data
!= NULL
)
2596 sec_data
->offset
= offset
;
2597 sec_data
->i
= i
- 1;
2598 sec_data
->function
= *functionname_ptr
;
2599 sec_data
->line_base
= line_base
;
2606 coff_find_nearest_line (bfd
*abfd
,
2610 const char **filename_ptr
,
2611 const char **functionname_ptr
,
2612 unsigned int *line_ptr
,
2613 unsigned int *discriminator_ptr
)
2615 if (discriminator_ptr
)
2616 *discriminator_ptr
= 0;
2617 return coff_find_nearest_line_with_names (abfd
, symbols
, section
, offset
,
2618 filename_ptr
, functionname_ptr
,
2619 line_ptr
, dwarf_debug_sections
);
2623 coff_find_inliner_info (bfd
*abfd
,
2624 const char **filename_ptr
,
2625 const char **functionname_ptr
,
2626 unsigned int *line_ptr
)
2630 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
2631 functionname_ptr
, line_ptr
,
2632 &coff_data(abfd
)->dwarf2_find_line_info
);
2637 coff_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
2641 if (!bfd_link_relocatable (info
))
2642 size
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
2644 size
= bfd_coff_filhsz (abfd
);
2646 size
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
2650 /* Change the class of a coff symbol held by BFD. */
2653 bfd_coff_set_symbol_class (bfd
* abfd
,
2655 unsigned int symbol_class
)
2657 coff_symbol_type
* csym
;
2659 csym
= coff_symbol_from (symbol
);
2662 bfd_set_error (bfd_error_invalid_operation
);
2665 else if (csym
->native
== NULL
)
2667 /* This is an alien symbol which no native coff backend data.
2668 We cheat here by creating a fake native entry for it and
2669 then filling in the class. This code is based on that in
2670 coff_write_alien_symbol(). */
2672 combined_entry_type
* native
;
2673 size_t amt
= sizeof (* native
);
2675 native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
2679 native
->is_sym
= true;
2680 native
->u
.syment
.n_type
= T_NULL
;
2681 native
->u
.syment
.n_sclass
= symbol_class
;
2683 if (bfd_is_und_section (symbol
->section
))
2685 native
->u
.syment
.n_scnum
= N_UNDEF
;
2686 native
->u
.syment
.n_value
= symbol
->value
;
2688 else if (bfd_is_com_section (symbol
->section
))
2690 native
->u
.syment
.n_scnum
= N_UNDEF
;
2691 native
->u
.syment
.n_value
= symbol
->value
;
2695 native
->u
.syment
.n_scnum
=
2696 symbol
->section
->output_section
->target_index
;
2697 native
->u
.syment
.n_value
= (symbol
->value
2698 + symbol
->section
->output_offset
);
2699 if (! obj_pe (abfd
))
2700 native
->u
.syment
.n_value
+= symbol
->section
->output_section
->vma
;
2702 /* Copy the any flags from the file header into the symbol.
2704 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (& csym
->symbol
)->flags
;
2707 csym
->native
= native
;
2710 csym
->native
->u
.syment
.n_sclass
= symbol_class
;
2716 _bfd_coff_section_already_linked (bfd
*abfd
,
2718 struct bfd_link_info
*info
)
2721 const char *name
, *key
;
2722 struct bfd_section_already_linked
*l
;
2723 struct bfd_section_already_linked_hash_entry
*already_linked_list
;
2724 struct coff_comdat_info
*s_comdat
;
2726 if (sec
->output_section
== bfd_abs_section_ptr
)
2730 if ((flags
& SEC_LINK_ONCE
) == 0)
2733 /* The COFF backend linker doesn't support group sections. */
2734 if ((flags
& SEC_GROUP
) != 0)
2737 name
= bfd_section_name (sec
);
2738 s_comdat
= bfd_coff_get_comdat_section (abfd
, sec
);
2740 if (s_comdat
!= NULL
)
2741 key
= s_comdat
->name
;
2744 if (startswith (name
, ".gnu.linkonce.")
2745 && (key
= strchr (name
+ sizeof (".gnu.linkonce.") - 1, '.')) != NULL
)
2748 /* FIXME: gcc as of 2011-09 emits sections like .text$<key>,
2749 .xdata$<key> and .pdata$<key> only the first of which has a
2750 comdat key. Should these all match the LTO IR key? */
2754 already_linked_list
= bfd_section_already_linked_table_lookup (key
);
2756 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
2758 struct coff_comdat_info
*l_comdat
;
2760 l_comdat
= bfd_coff_get_comdat_section (l
->sec
->owner
, l
->sec
);
2762 /* The section names must match, and both sections must be
2763 comdat and have the same comdat name, or both sections must
2764 be non-comdat. LTO IR plugin sections are an exception. They
2765 are always named .gnu.linkonce.t.<key> (<key> is some string)
2766 and match any comdat section with comdat name of <key>, and
2767 any linkonce section with the same suffix, ie.
2768 .gnu.linkonce.*.<key>. */
2769 if (((s_comdat
!= NULL
) == (l_comdat
!= NULL
)
2770 && strcmp (name
, l
->sec
->name
) == 0)
2771 || (l
->sec
->owner
->flags
& BFD_PLUGIN
) != 0
2772 || (sec
->owner
->flags
& BFD_PLUGIN
) != 0)
2774 /* The section has already been linked. See if we should
2776 return _bfd_handle_already_linked (sec
, l
, info
);
2780 /* This is the first section with this name. Record it. */
2781 if (!bfd_section_already_linked_table_insert (already_linked_list
, sec
))
2782 info
->callbacks
->einfo (_("%F%P: already_linked_table: %E\n"));
2786 /* Initialize COOKIE for input bfd ABFD. */
2789 init_reloc_cookie (struct coff_reloc_cookie
*cookie
,
2790 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2793 /* Sometimes the symbol table does not yet have been loaded here. */
2794 bfd_coff_slurp_symbol_table (abfd
);
2796 cookie
->abfd
= abfd
;
2797 cookie
->sym_hashes
= obj_coff_sym_hashes (abfd
);
2799 cookie
->symbols
= obj_symbols (abfd
);
2804 /* Free the memory allocated by init_reloc_cookie, if appropriate. */
2807 fini_reloc_cookie (struct coff_reloc_cookie
*cookie ATTRIBUTE_UNUSED
,
2808 bfd
*abfd ATTRIBUTE_UNUSED
)
2810 /* Nothing to do. */
2813 /* Initialize the relocation information in COOKIE for input section SEC
2814 of input bfd ABFD. */
2817 init_reloc_cookie_rels (struct coff_reloc_cookie
*cookie
,
2818 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2822 if (sec
->reloc_count
== 0)
2824 cookie
->rels
= NULL
;
2825 cookie
->relend
= NULL
;
2830 cookie
->rels
= _bfd_coff_read_internal_relocs (abfd
, sec
, false, NULL
,
2833 if (cookie
->rels
== NULL
)
2836 cookie
->rel
= cookie
->rels
;
2837 cookie
->relend
= (cookie
->rels
+ sec
->reloc_count
);
2841 /* Free the memory allocated by init_reloc_cookie_rels,
2845 fini_reloc_cookie_rels (struct coff_reloc_cookie
*cookie
,
2849 /* PR 20401. The relocs may not have been cached, so check first.
2850 If the relocs were loaded by init_reloc_cookie_rels() then this
2851 will be the case. FIXME: Would performance be improved if the
2852 relocs *were* cached ? */
2853 && coff_section_data (NULL
, sec
)
2854 && coff_section_data (NULL
, sec
)->relocs
!= cookie
->rels
)
2855 free (cookie
->rels
);
2858 /* Initialize the whole of COOKIE for input section SEC. */
2861 init_reloc_cookie_for_section (struct coff_reloc_cookie
*cookie
,
2862 struct bfd_link_info
*info
,
2865 if (!init_reloc_cookie (cookie
, info
, sec
->owner
))
2868 if (!init_reloc_cookie_rels (cookie
, info
, sec
->owner
, sec
))
2870 fini_reloc_cookie (cookie
, sec
->owner
);
2876 /* Free the memory allocated by init_reloc_cookie_for_section,
2880 fini_reloc_cookie_for_section (struct coff_reloc_cookie
*cookie
,
2883 fini_reloc_cookie_rels (cookie
, sec
);
2884 fini_reloc_cookie (cookie
, sec
->owner
);
2888 _bfd_coff_gc_mark_hook (asection
*sec
,
2889 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2890 struct internal_reloc
*rel ATTRIBUTE_UNUSED
,
2891 struct coff_link_hash_entry
*h
,
2892 struct internal_syment
*sym
)
2896 switch (h
->root
.type
)
2898 case bfd_link_hash_defined
:
2899 case bfd_link_hash_defweak
:
2900 return h
->root
.u
.def
.section
;
2902 case bfd_link_hash_common
:
2903 return h
->root
.u
.c
.p
->section
;
2905 case bfd_link_hash_undefweak
:
2906 if (h
->symbol_class
== C_NT_WEAK
&& h
->numaux
== 1)
2908 /* PE weak externals. A weak symbol may include an auxiliary
2909 record indicating that if the weak symbol is not resolved,
2910 another external symbol is used instead. */
2911 struct coff_link_hash_entry
*h2
=
2912 h
->auxbfd
->tdata
.coff_obj_data
->sym_hashes
[
2913 h
->aux
->x_sym
.x_tagndx
.l
];
2915 if (h2
&& h2
->root
.type
!= bfd_link_hash_undefined
)
2916 return h2
->root
.u
.def
.section
;
2920 case bfd_link_hash_undefined
:
2927 return coff_section_from_bfd_index (sec
->owner
, sym
->n_scnum
);
2930 /* COOKIE->rel describes a relocation against section SEC, which is
2931 a section we've decided to keep. Return the section that contains
2932 the relocation symbol, or NULL if no section contains it. */
2935 _bfd_coff_gc_mark_rsec (struct bfd_link_info
*info
, asection
*sec
,
2936 coff_gc_mark_hook_fn gc_mark_hook
,
2937 struct coff_reloc_cookie
*cookie
)
2939 struct coff_link_hash_entry
*h
;
2941 h
= cookie
->sym_hashes
[cookie
->rel
->r_symndx
];
2944 while (h
->root
.type
== bfd_link_hash_indirect
2945 || h
->root
.type
== bfd_link_hash_warning
)
2946 h
= (struct coff_link_hash_entry
*) h
->root
.u
.i
.link
;
2948 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, h
, NULL
);
2951 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, NULL
,
2953 + obj_convert (sec
->owner
)[cookie
->rel
->r_symndx
])->native
->u
.syment
);
2956 static bool _bfd_coff_gc_mark
2957 (struct bfd_link_info
*, asection
*, coff_gc_mark_hook_fn
);
2959 /* COOKIE->rel describes a relocation against section SEC, which is
2960 a section we've decided to keep. Mark the section that contains
2961 the relocation symbol. */
2964 _bfd_coff_gc_mark_reloc (struct bfd_link_info
*info
,
2966 coff_gc_mark_hook_fn gc_mark_hook
,
2967 struct coff_reloc_cookie
*cookie
)
2971 rsec
= _bfd_coff_gc_mark_rsec (info
, sec
, gc_mark_hook
, cookie
);
2972 if (rsec
&& !rsec
->gc_mark
)
2974 if (bfd_get_flavour (rsec
->owner
) != bfd_target_coff_flavour
)
2976 else if (!_bfd_coff_gc_mark (info
, rsec
, gc_mark_hook
))
2982 /* The mark phase of garbage collection. For a given section, mark
2983 it and any sections in this section's group, and all the sections
2984 which define symbols to which it refers. */
2987 _bfd_coff_gc_mark (struct bfd_link_info
*info
,
2989 coff_gc_mark_hook_fn gc_mark_hook
)
2995 /* Look through the section relocs. */
2996 if ((sec
->flags
& SEC_RELOC
) != 0
2997 && sec
->reloc_count
> 0)
2999 struct coff_reloc_cookie cookie
;
3001 if (!init_reloc_cookie_for_section (&cookie
, info
, sec
))
3005 for (; cookie
.rel
< cookie
.relend
; cookie
.rel
++)
3007 if (!_bfd_coff_gc_mark_reloc (info
, sec
, gc_mark_hook
, &cookie
))
3013 fini_reloc_cookie_for_section (&cookie
, sec
);
3021 _bfd_coff_gc_mark_extra_sections (struct bfd_link_info
*info
,
3022 coff_gc_mark_hook_fn mark_hook ATTRIBUTE_UNUSED
)
3026 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
3031 if (bfd_get_flavour (ibfd
) != bfd_target_coff_flavour
)
3034 /* Ensure all linker created sections are kept, and see whether
3035 any other section is already marked. */
3037 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
3039 if ((isec
->flags
& SEC_LINKER_CREATED
) != 0)
3041 else if (isec
->gc_mark
)
3045 /* If no section in this file will be kept, then we can
3046 toss out debug sections. */
3050 /* Keep debug and special sections like .comment when they are
3051 not part of a group, or when we have single-member groups. */
3052 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
3053 if ((isec
->flags
& SEC_DEBUGGING
) != 0
3054 || (isec
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0)
3060 /* Sweep symbols in swept sections. Called via coff_link_hash_traverse. */
3063 coff_gc_sweep_symbol (struct coff_link_hash_entry
*h
,
3064 void *data ATTRIBUTE_UNUSED
)
3066 if (h
->root
.type
== bfd_link_hash_warning
)
3067 h
= (struct coff_link_hash_entry
*) h
->root
.u
.i
.link
;
3069 if ((h
->root
.type
== bfd_link_hash_defined
3070 || h
->root
.type
== bfd_link_hash_defweak
)
3071 && !h
->root
.u
.def
.section
->gc_mark
3072 && !(h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
))
3074 /* Do our best to hide the symbol. */
3075 h
->root
.u
.def
.section
= bfd_und_section_ptr
;
3076 h
->symbol_class
= C_HIDDEN
;
3082 /* The sweep phase of garbage collection. Remove all garbage sections. */
3084 typedef bool (*gc_sweep_hook_fn
)
3085 (bfd
*, struct bfd_link_info
*, asection
*, const struct internal_reloc
*);
3088 coff_gc_sweep (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
3092 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3096 if (bfd_get_flavour (sub
) != bfd_target_coff_flavour
)
3099 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3101 /* Keep debug and special sections. */
3102 if ((o
->flags
& (SEC_DEBUGGING
| SEC_LINKER_CREATED
)) != 0
3103 || (o
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0)
3105 else if (startswith (o
->name
, ".idata")
3106 || startswith (o
->name
, ".pdata")
3107 || startswith (o
->name
, ".xdata")
3108 || startswith (o
->name
, ".rsrc"))
3114 /* Skip sweeping sections already excluded. */
3115 if (o
->flags
& SEC_EXCLUDE
)
3118 /* Since this is early in the link process, it is simple
3119 to remove a section from the output. */
3120 o
->flags
|= SEC_EXCLUDE
;
3122 if (info
->print_gc_sections
&& o
->size
!= 0)
3123 /* xgettext: c-format */
3124 _bfd_error_handler (_("removing unused section '%pA' in file '%pB'"),
3128 /* But we also have to update some of the relocation
3129 info we collected before. */
3131 && (o
->flags
& SEC_RELOC
) != 0
3132 && o
->reloc_count
> 0
3133 && !bfd_is_abs_section (o
->output_section
))
3135 struct internal_reloc
*internal_relocs
;
3139 = _bfd_coff_link_read_relocs (o
->owner
, o
, NULL
, NULL
,
3141 if (internal_relocs
== NULL
)
3144 r
= (*gc_sweep_hook
) (o
->owner
, info
, o
, internal_relocs
);
3146 if (coff_section_data (o
)->relocs
!= internal_relocs
)
3147 free (internal_relocs
);
3156 /* Remove the symbols that were in the swept sections from the dynamic
3158 coff_link_hash_traverse (coff_hash_table (info
), coff_gc_sweep_symbol
,
3164 /* Keep all sections containing symbols undefined on the command-line,
3165 and the section containing the entry symbol. */
3168 _bfd_coff_gc_keep (struct bfd_link_info
*info
)
3170 struct bfd_sym_chain
*sym
;
3172 for (sym
= info
->gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
3174 struct coff_link_hash_entry
*h
;
3176 h
= coff_link_hash_lookup (coff_hash_table (info
), sym
->name
,
3177 false, false, false);
3180 && (h
->root
.type
== bfd_link_hash_defined
3181 || h
->root
.type
== bfd_link_hash_defweak
)
3182 && !bfd_is_abs_section (h
->root
.u
.def
.section
))
3183 h
->root
.u
.def
.section
->flags
|= SEC_KEEP
;
3187 /* Do mark and sweep of unused sections. */
3190 bfd_coff_gc_sections (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
3194 /* FIXME: Should we implement this? */
3196 const bfd_coff_backend_data
*bed
= coff_backend_info (abfd
);
3198 if (!bed
->can_gc_sections
3199 || !is_coff_hash_table (info
->hash
))
3201 _bfd_error_handler(_("warning: gc-sections option ignored"));
3206 _bfd_coff_gc_keep (info
);
3208 /* Grovel through relocs to find out who stays ... */
3209 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3213 if (bfd_get_flavour (sub
) != bfd_target_coff_flavour
)
3216 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3218 if (((o
->flags
& (SEC_EXCLUDE
| SEC_KEEP
)) == SEC_KEEP
3219 || startswith (o
->name
, ".vectors")
3220 || startswith (o
->name
, ".ctors")
3221 || startswith (o
->name
, ".dtors"))
3224 if (!_bfd_coff_gc_mark (info
, o
, _bfd_coff_gc_mark_hook
))
3230 /* Allow the backend to mark additional target specific sections. */
3231 _bfd_coff_gc_mark_extra_sections (info
, _bfd_coff_gc_mark_hook
);
3233 /* ... and mark SEC_EXCLUDE for those that go. */
3234 return coff_gc_sweep (abfd
, info
);
3237 /* Return name used to identify a comdat group. */
3240 bfd_coff_group_name (bfd
*abfd
, const asection
*sec
)
3242 struct coff_comdat_info
*ci
= bfd_coff_get_comdat_section (abfd
, sec
);
3249 _bfd_coff_close_and_cleanup (bfd
*abfd
)
3251 struct coff_tdata
*tdata
= coff_data (abfd
);
3256 Do not clear the keep_syms and keep_strings flags.
3257 These may have been set by pe_ILF_build_a_bfd() indicating
3258 that the syms and strings pointers are not to be freed. */
3259 if (bfd_get_format (abfd
) == bfd_object
3260 && bfd_family_coff (abfd
)
3261 && !_bfd_coff_free_symbols (abfd
))
3264 if (bfd_get_format (abfd
) == bfd_object
3265 || bfd_get_format (abfd
) == bfd_core
)
3266 _bfd_dwarf2_cleanup_debug_info (abfd
, &tdata
->dwarf2_find_line_info
);
3268 return _bfd_generic_close_and_cleanup (abfd
);