1 /* Support for the generic parts of COFF, for BFD.
2 Copyright (C) 1990-2020 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
;
56 bfd_boolean result
= TRUE
;
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 (abfd
, readsize
);
279 if (!external_sections
)
282 if (bfd_bread ((void *) external_sections
, readsize
, abfd
) != readsize
)
285 /* Set the arch/mach *before* swapping in sections; section header swapping
286 may depend on arch/mach info. */
287 if (! bfd_coff_set_arch_mach_hook (abfd
, (void *) internal_f
))
290 /* Now copy data as required; construct all asections etc. */
294 for (i
= 0; i
< nscns
; i
++)
296 struct internal_scnhdr tmp
;
297 bfd_coff_swap_scnhdr_in (abfd
,
298 (void *) (external_sections
+ i
* scnhsz
),
300 if (! make_a_section_from_file (abfd
, &tmp
, i
+ 1))
305 obj_coff_keep_syms (abfd
) = FALSE
;
306 obj_coff_keep_strings (abfd
) = FALSE
;
307 _bfd_coff_free_symbols (abfd
);
311 obj_coff_keep_syms (abfd
) = FALSE
;
312 obj_coff_keep_strings (abfd
) = FALSE
;
313 _bfd_coff_free_symbols (abfd
);
314 bfd_release (abfd
, tdata
);
316 abfd
->tdata
.any
= tdata_save
;
317 abfd
->flags
= oflags
;
318 abfd
->start_address
= ostart
;
319 return (const bfd_target
*) NULL
;
322 /* Turn a COFF file into a BFD, but fail with bfd_error_wrong_format if it is
323 not a COFF file. This is also used by ECOFF. */
326 coff_object_p (bfd
*abfd
)
328 bfd_size_type filhsz
;
329 bfd_size_type aoutsz
;
332 struct internal_filehdr internal_f
;
333 struct internal_aouthdr internal_a
;
335 /* Figure out how much to read. */
336 filhsz
= bfd_coff_filhsz (abfd
);
337 aoutsz
= bfd_coff_aoutsz (abfd
);
339 filehdr
= bfd_alloc (abfd
, filhsz
);
342 if (bfd_bread (filehdr
, filhsz
, abfd
) != filhsz
)
344 if (bfd_get_error () != bfd_error_system_call
)
345 bfd_set_error (bfd_error_wrong_format
);
346 bfd_release (abfd
, filehdr
);
349 bfd_coff_swap_filehdr_in (abfd
, filehdr
, &internal_f
);
350 bfd_release (abfd
, filehdr
);
352 /* The XCOFF format has two sizes for the f_opthdr. SMALL_AOUTSZ
353 (less than aoutsz) used in object files and AOUTSZ (equal to
354 aoutsz) in executables. The bfd_coff_swap_aouthdr_in function
355 expects this header to be aoutsz bytes in length, so we use that
356 value in the call to bfd_alloc below. But we must be careful to
357 only read in f_opthdr bytes in the call to bfd_bread. We should
358 also attempt to catch corrupt or non-COFF binaries with a strange
359 value for f_opthdr. */
360 if (! bfd_coff_bad_format_hook (abfd
, &internal_f
)
361 || internal_f
.f_opthdr
> aoutsz
)
363 bfd_set_error (bfd_error_wrong_format
);
366 nscns
= internal_f
.f_nscns
;
368 if (internal_f
.f_opthdr
)
372 opthdr
= bfd_alloc (abfd
, aoutsz
);
375 if (bfd_bread (opthdr
, (bfd_size_type
) internal_f
.f_opthdr
, abfd
)
376 != internal_f
.f_opthdr
)
378 bfd_release (abfd
, opthdr
);
381 /* PR 17512: file: 11056-1136-0.004. */
382 if (internal_f
.f_opthdr
< aoutsz
)
383 memset (((char *) opthdr
) + internal_f
.f_opthdr
, 0, aoutsz
- internal_f
.f_opthdr
);
385 bfd_coff_swap_aouthdr_in (abfd
, opthdr
, (void *) &internal_a
);
386 bfd_release (abfd
, opthdr
);
389 return coff_real_object_p (abfd
, nscns
, &internal_f
,
390 (internal_f
.f_opthdr
!= 0
392 : (struct internal_aouthdr
*) NULL
));
395 /* Get the BFD section from a COFF symbol section number. */
398 coff_section_from_bfd_index (bfd
*abfd
, int section_index
)
400 struct bfd_section
*answer
= abfd
->sections
;
402 if (section_index
== N_ABS
)
403 return bfd_abs_section_ptr
;
404 if (section_index
== N_UNDEF
)
405 return bfd_und_section_ptr
;
406 if (section_index
== N_DEBUG
)
407 return bfd_abs_section_ptr
;
411 if (answer
->target_index
== section_index
)
413 answer
= answer
->next
;
416 /* We should not reach this point, but the SCO 3.2v4 /lib/libc_s.a
417 has a bad symbol table in biglitpow.o. */
418 return bfd_und_section_ptr
;
421 /* Get the upper bound of a COFF symbol table. */
424 coff_get_symtab_upper_bound (bfd
*abfd
)
426 if (!bfd_coff_slurp_symbol_table (abfd
))
429 return (bfd_get_symcount (abfd
) + 1) * (sizeof (coff_symbol_type
*));
432 /* Canonicalize a COFF symbol table. */
435 coff_canonicalize_symtab (bfd
*abfd
, asymbol
**alocation
)
437 unsigned int counter
;
438 coff_symbol_type
*symbase
;
439 coff_symbol_type
**location
= (coff_symbol_type
**) alocation
;
441 if (!bfd_coff_slurp_symbol_table (abfd
))
444 symbase
= obj_symbols (abfd
);
445 counter
= bfd_get_symcount (abfd
);
446 while (counter
-- > 0)
447 *location
++ = symbase
++;
451 return bfd_get_symcount (abfd
);
454 /* Get the name of a symbol. The caller must pass in a buffer of size
458 _bfd_coff_internal_syment_name (bfd
*abfd
,
459 const struct internal_syment
*sym
,
462 /* FIXME: It's not clear this will work correctly if sizeof
464 if (sym
->_n
._n_n
._n_zeroes
!= 0
465 || sym
->_n
._n_n
._n_offset
== 0)
467 memcpy (buf
, sym
->_n
._n_name
, SYMNMLEN
);
468 buf
[SYMNMLEN
] = '\0';
475 BFD_ASSERT (sym
->_n
._n_n
._n_offset
>= STRING_SIZE_SIZE
);
476 strings
= obj_coff_strings (abfd
);
479 strings
= _bfd_coff_read_string_table (abfd
);
483 /* PR 17910: Only check for string overflow if the length has been set.
484 Some DLLs, eg those produced by Visual Studio, may not set the length field. */
485 if (obj_coff_strings_len (abfd
) > 0
486 && sym
->_n
._n_n
._n_offset
>= obj_coff_strings_len (abfd
))
488 return strings
+ sym
->_n
._n_n
._n_offset
;
492 /* Read in and swap the relocs. This returns a buffer holding the
493 relocs for section SEC in file ABFD. If CACHE is TRUE and
494 INTERNAL_RELOCS is NULL, the relocs read in will be saved in case
495 the function is called again. If EXTERNAL_RELOCS is not NULL, it
496 is a buffer large enough to hold the unswapped relocs. If
497 INTERNAL_RELOCS is not NULL, it is a buffer large enough to hold
498 the swapped relocs. If REQUIRE_INTERNAL is TRUE, then the return
499 value must be INTERNAL_RELOCS. The function returns NULL on error. */
501 struct internal_reloc
*
502 _bfd_coff_read_internal_relocs (bfd
*abfd
,
505 bfd_byte
*external_relocs
,
506 bfd_boolean require_internal
,
507 struct internal_reloc
*internal_relocs
)
510 bfd_byte
*free_external
= NULL
;
511 struct internal_reloc
*free_internal
= NULL
;
514 struct internal_reloc
*irel
;
517 if (sec
->reloc_count
== 0)
518 return internal_relocs
; /* Nothing to do. */
520 if (coff_section_data (abfd
, sec
) != NULL
521 && coff_section_data (abfd
, sec
)->relocs
!= NULL
)
523 if (! require_internal
)
524 return coff_section_data (abfd
, sec
)->relocs
;
525 memcpy (internal_relocs
, coff_section_data (abfd
, sec
)->relocs
,
526 sec
->reloc_count
* sizeof (struct internal_reloc
));
527 return internal_relocs
;
530 relsz
= bfd_coff_relsz (abfd
);
532 amt
= sec
->reloc_count
* relsz
;
533 if (external_relocs
== NULL
)
535 free_external
= (bfd_byte
*) bfd_malloc (amt
);
536 if (free_external
== NULL
)
538 external_relocs
= free_external
;
541 if (bfd_seek (abfd
, sec
->rel_filepos
, SEEK_SET
) != 0
542 || bfd_bread (external_relocs
, amt
, abfd
) != amt
)
545 if (internal_relocs
== NULL
)
547 amt
= sec
->reloc_count
;
548 amt
*= sizeof (struct internal_reloc
);
549 free_internal
= (struct internal_reloc
*) bfd_malloc (amt
);
550 if (free_internal
== NULL
)
552 internal_relocs
= free_internal
;
555 /* Swap in the relocs. */
556 erel
= external_relocs
;
557 erel_end
= erel
+ relsz
* sec
->reloc_count
;
558 irel
= internal_relocs
;
559 for (; erel
< erel_end
; erel
+= relsz
, irel
++)
560 bfd_coff_swap_reloc_in (abfd
, (void *) erel
, (void *) irel
);
562 if (free_external
!= NULL
)
564 free (free_external
);
565 free_external
= NULL
;
568 if (cache
&& free_internal
!= NULL
)
570 if (coff_section_data (abfd
, sec
) == NULL
)
572 amt
= sizeof (struct coff_section_tdata
);
573 sec
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
574 if (sec
->used_by_bfd
== NULL
)
576 coff_section_data (abfd
, sec
)->contents
= NULL
;
578 coff_section_data (abfd
, sec
)->relocs
= free_internal
;
581 return internal_relocs
;
584 if (free_external
!= NULL
)
585 free (free_external
);
586 if (free_internal
!= NULL
)
587 free (free_internal
);
591 /* Set lineno_count for the output sections of a COFF file. */
594 coff_count_linenumbers (bfd
*abfd
)
596 unsigned int limit
= bfd_get_symcount (abfd
);
604 /* This may be from the backend linker, in which case the
605 lineno_count in the sections is correct. */
606 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
607 total
+= s
->lineno_count
;
611 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
612 BFD_ASSERT (s
->lineno_count
== 0);
614 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
616 asymbol
*q_maybe
= *p
;
618 if (bfd_family_coff (bfd_asymbol_bfd (q_maybe
)))
620 coff_symbol_type
*q
= coffsymbol (q_maybe
);
622 /* The AIX 4.1 compiler can sometimes generate line numbers
623 attached to debugging symbols. We try to simply ignore
625 if (q
->lineno
!= NULL
626 && q
->symbol
.section
->owner
!= NULL
)
628 /* This symbol has line numbers. Increment the owning
629 section's linenumber count. */
630 alent
*l
= q
->lineno
;
634 asection
* sec
= q
->symbol
.section
->output_section
;
636 /* Do not try to update fields in read-only sections. */
637 if (! bfd_is_const_section (sec
))
638 sec
->lineno_count
++;
643 while (l
->line_number
!= 0);
652 fixup_symbol_value (bfd
*abfd
,
653 coff_symbol_type
*coff_symbol_ptr
,
654 struct internal_syment
*syment
)
656 /* Normalize the symbol flags. */
657 if (coff_symbol_ptr
->symbol
.section
658 && bfd_is_com_section (coff_symbol_ptr
->symbol
.section
))
660 /* A common symbol is undefined with a value. */
661 syment
->n_scnum
= N_UNDEF
;
662 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
664 else if ((coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
) != 0
665 && (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING_RELOC
) == 0)
667 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
669 else if (bfd_is_und_section (coff_symbol_ptr
->symbol
.section
))
671 syment
->n_scnum
= N_UNDEF
;
674 /* FIXME: Do we need to handle the absolute section here? */
677 if (coff_symbol_ptr
->symbol
.section
)
680 coff_symbol_ptr
->symbol
.section
->output_section
->target_index
;
682 syment
->n_value
= (coff_symbol_ptr
->symbol
.value
683 + coff_symbol_ptr
->symbol
.section
->output_offset
);
686 syment
->n_value
+= (syment
->n_sclass
== C_STATLAB
)
687 ? coff_symbol_ptr
->symbol
.section
->output_section
->lma
688 : coff_symbol_ptr
->symbol
.section
->output_section
->vma
;
694 /* This can happen, but I don't know why yet (steve@cygnus.com) */
695 syment
->n_scnum
= N_ABS
;
696 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
701 /* Run through all the symbols in the symbol table and work out what
702 their indexes into the symbol table will be when output.
704 Coff requires that each C_FILE symbol points to the next one in the
705 chain, and that the last one points to the first external symbol. We
709 coff_renumber_symbols (bfd
*bfd_ptr
, int *first_undef
)
711 unsigned int symbol_count
= bfd_get_symcount (bfd_ptr
);
712 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
713 unsigned int native_index
= 0;
714 struct internal_syment
*last_file
= NULL
;
715 unsigned int symbol_index
;
717 /* COFF demands that undefined symbols come after all other symbols.
718 Since we don't need to impose this extra knowledge on all our
719 client programs, deal with that here. Sort the symbol table;
720 just move the undefined symbols to the end, leaving the rest
721 alone. The O'Reilly book says that defined global symbols come
722 at the end before the undefined symbols, so we do that here as
724 /* @@ Do we have some condition we could test for, so we don't always
725 have to do this? I don't think relocatability is quite right, but
726 I'm not certain. [raeburn:19920508.1711EST] */
732 amt
= sizeof (asymbol
*) * ((bfd_size_type
) symbol_count
+ 1);
733 newsyms
= (asymbol
**) bfd_alloc (bfd_ptr
, amt
);
736 bfd_ptr
->outsymbols
= newsyms
;
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 && !bfd_is_com_section (symbol_ptr_ptr
[i
]->section
)
741 && ((symbol_ptr_ptr
[i
]->flags
& BSF_FUNCTION
) != 0
742 || ((symbol_ptr_ptr
[i
]->flags
& (BSF_GLOBAL
| BSF_WEAK
))
744 *newsyms
++ = symbol_ptr_ptr
[i
];
746 for (i
= 0; i
< symbol_count
; i
++)
747 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) == 0
748 && !bfd_is_und_section (symbol_ptr_ptr
[i
]->section
)
749 && (bfd_is_com_section (symbol_ptr_ptr
[i
]->section
)
750 || ((symbol_ptr_ptr
[i
]->flags
& BSF_FUNCTION
) == 0
751 && ((symbol_ptr_ptr
[i
]->flags
& (BSF_GLOBAL
| BSF_WEAK
))
753 *newsyms
++ = symbol_ptr_ptr
[i
];
755 *first_undef
= newsyms
- bfd_ptr
->outsymbols
;
757 for (i
= 0; i
< symbol_count
; i
++)
758 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) == 0
759 && bfd_is_und_section (symbol_ptr_ptr
[i
]->section
))
760 *newsyms
++ = symbol_ptr_ptr
[i
];
761 *newsyms
= (asymbol
*) NULL
;
762 symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
765 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
767 coff_symbol_type
*coff_symbol_ptr
;
769 coff_symbol_ptr
= coff_symbol_from (symbol_ptr_ptr
[symbol_index
]);
770 symbol_ptr_ptr
[symbol_index
]->udata
.i
= symbol_index
;
771 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
)
773 combined_entry_type
*s
= coff_symbol_ptr
->native
;
776 BFD_ASSERT (s
->is_sym
);
777 if (s
->u
.syment
.n_sclass
== C_FILE
)
779 if (last_file
!= NULL
)
780 last_file
->n_value
= native_index
;
781 last_file
= &(s
->u
.syment
);
784 /* Modify the symbol values according to their section and
786 fixup_symbol_value (bfd_ptr
, coff_symbol_ptr
, &(s
->u
.syment
));
788 for (i
= 0; i
< s
->u
.syment
.n_numaux
+ 1; i
++)
789 s
[i
].offset
= native_index
++;
795 obj_conv_table_size (bfd_ptr
) = native_index
;
800 /* Run thorough the symbol table again, and fix it so that all
801 pointers to entries are changed to the entries' index in the output
805 coff_mangle_symbols (bfd
*bfd_ptr
)
807 unsigned int symbol_count
= bfd_get_symcount (bfd_ptr
);
808 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
809 unsigned int symbol_index
;
811 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
813 coff_symbol_type
*coff_symbol_ptr
;
815 coff_symbol_ptr
= coff_symbol_from (symbol_ptr_ptr
[symbol_index
]);
816 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
)
819 combined_entry_type
*s
= coff_symbol_ptr
->native
;
821 BFD_ASSERT (s
->is_sym
);
824 /* FIXME: We should use a union here. */
825 s
->u
.syment
.n_value
=
826 (bfd_hostptr_t
) ((combined_entry_type
*)
827 ((bfd_hostptr_t
) s
->u
.syment
.n_value
))->offset
;
832 /* The value is the offset into the line number entries
833 for the symbol's section. On output, the symbol's
834 section should be N_DEBUG. */
835 s
->u
.syment
.n_value
=
836 (coff_symbol_ptr
->symbol
.section
->output_section
->line_filepos
837 + s
->u
.syment
.n_value
* bfd_coff_linesz (bfd_ptr
));
838 coff_symbol_ptr
->symbol
.section
=
839 coff_section_from_bfd_index (bfd_ptr
, N_DEBUG
);
840 BFD_ASSERT (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
);
842 for (i
= 0; i
< s
->u
.syment
.n_numaux
; i
++)
844 combined_entry_type
*a
= s
+ i
+ 1;
846 BFD_ASSERT (! a
->is_sym
);
849 a
->u
.auxent
.x_sym
.x_tagndx
.l
=
850 a
->u
.auxent
.x_sym
.x_tagndx
.p
->offset
;
855 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
856 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
->offset
;
861 a
->u
.auxent
.x_csect
.x_scnlen
.l
=
862 a
->u
.auxent
.x_csect
.x_scnlen
.p
->offset
;
871 coff_fix_symbol_name (bfd
*abfd
,
873 combined_entry_type
*native
,
874 bfd_size_type
*string_size_p
,
875 asection
**debug_string_section_p
,
876 bfd_size_type
*debug_string_size_p
)
878 unsigned int name_length
;
879 union internal_auxent
*auxent
;
880 char *name
= (char *) (symbol
->name
);
884 /* COFF symbols always have names, so we'll make one up. */
885 symbol
->name
= "strange";
886 name
= (char *) symbol
->name
;
888 name_length
= strlen (name
);
890 BFD_ASSERT (native
->is_sym
);
891 if (native
->u
.syment
.n_sclass
== C_FILE
892 && native
->u
.syment
.n_numaux
> 0)
894 unsigned int filnmlen
;
896 if (bfd_coff_force_symnames_in_strings (abfd
))
898 native
->u
.syment
._n
._n_n
._n_offset
=
899 (*string_size_p
+ STRING_SIZE_SIZE
);
900 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
901 *string_size_p
+= 6; /* strlen(".file") + 1 */
904 strncpy (native
->u
.syment
._n
._n_name
, ".file", SYMNMLEN
);
906 BFD_ASSERT (! (native
+ 1)->is_sym
);
907 auxent
= &(native
+ 1)->u
.auxent
;
909 filnmlen
= bfd_coff_filnmlen (abfd
);
911 if (bfd_coff_long_filenames (abfd
))
913 if (name_length
<= filnmlen
)
914 strncpy (auxent
->x_file
.x_fname
, name
, filnmlen
);
917 auxent
->x_file
.x_n
.x_offset
= *string_size_p
+ STRING_SIZE_SIZE
;
918 auxent
->x_file
.x_n
.x_zeroes
= 0;
919 *string_size_p
+= name_length
+ 1;
924 strncpy (auxent
->x_file
.x_fname
, name
, filnmlen
);
925 if (name_length
> filnmlen
)
926 name
[filnmlen
] = '\0';
931 if (name_length
<= SYMNMLEN
&& !bfd_coff_force_symnames_in_strings (abfd
))
932 /* This name will fit into the symbol neatly. */
933 strncpy (native
->u
.syment
._n
._n_name
, symbol
->name
, SYMNMLEN
);
935 else if (!bfd_coff_symname_in_debug (abfd
, &native
->u
.syment
))
937 native
->u
.syment
._n
._n_n
._n_offset
= (*string_size_p
939 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
940 *string_size_p
+= name_length
+ 1;
946 int prefix_len
= bfd_coff_debug_string_prefix_length (abfd
);
948 /* This name should be written into the .debug section. For
949 some reason each name is preceded by a two byte length
950 and also followed by a null byte. FIXME: We assume that
951 the .debug section has already been created, and that it
953 if (*debug_string_section_p
== (asection
*) NULL
)
954 *debug_string_section_p
= bfd_get_section_by_name (abfd
, ".debug");
955 filepos
= bfd_tell (abfd
);
957 bfd_put_32 (abfd
, (bfd_vma
) (name_length
+ 1), buf
);
959 bfd_put_16 (abfd
, (bfd_vma
) (name_length
+ 1), buf
);
961 if (!bfd_set_section_contents (abfd
,
962 *debug_string_section_p
,
964 (file_ptr
) *debug_string_size_p
,
965 (bfd_size_type
) prefix_len
)
966 || !bfd_set_section_contents (abfd
,
967 *debug_string_section_p
,
968 (void *) symbol
->name
,
969 (file_ptr
) (*debug_string_size_p
971 (bfd_size_type
) name_length
+ 1))
973 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
975 native
->u
.syment
._n
._n_n
._n_offset
=
976 *debug_string_size_p
+ prefix_len
;
977 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
978 *debug_string_size_p
+= name_length
+ 1 + prefix_len
;
983 /* We need to keep track of the symbol index so that when we write out
984 the relocs we can get the index for a symbol. This method is a
987 #define set_index(symbol, idx) ((symbol)->udata.i = (idx))
989 /* Write a symbol out to a COFF file. */
992 coff_write_symbol (bfd
*abfd
,
994 combined_entry_type
*native
,
996 bfd_size_type
*string_size_p
,
997 asection
**debug_string_section_p
,
998 bfd_size_type
*debug_string_size_p
)
1000 unsigned int numaux
= native
->u
.syment
.n_numaux
;
1001 int type
= native
->u
.syment
.n_type
;
1002 int n_sclass
= (int) native
->u
.syment
.n_sclass
;
1003 asection
*output_section
= symbol
->section
->output_section
1004 ? symbol
->section
->output_section
1007 bfd_size_type symesz
;
1009 BFD_ASSERT (native
->is_sym
);
1011 if (native
->u
.syment
.n_sclass
== C_FILE
)
1012 symbol
->flags
|= BSF_DEBUGGING
;
1014 if (symbol
->flags
& BSF_DEBUGGING
1015 && bfd_is_abs_section (symbol
->section
))
1016 native
->u
.syment
.n_scnum
= N_DEBUG
;
1018 else if (bfd_is_abs_section (symbol
->section
))
1019 native
->u
.syment
.n_scnum
= N_ABS
;
1021 else if (bfd_is_und_section (symbol
->section
))
1022 native
->u
.syment
.n_scnum
= N_UNDEF
;
1025 native
->u
.syment
.n_scnum
=
1026 output_section
->target_index
;
1028 coff_fix_symbol_name (abfd
, symbol
, native
, string_size_p
,
1029 debug_string_section_p
, debug_string_size_p
);
1031 symesz
= bfd_coff_symesz (abfd
);
1032 buf
= bfd_alloc (abfd
, symesz
);
1035 bfd_coff_swap_sym_out (abfd
, &native
->u
.syment
, buf
);
1036 if (bfd_bwrite (buf
, symesz
, abfd
) != symesz
)
1038 bfd_release (abfd
, buf
);
1040 if (native
->u
.syment
.n_numaux
> 0)
1042 bfd_size_type auxesz
;
1045 auxesz
= bfd_coff_auxesz (abfd
);
1046 buf
= bfd_alloc (abfd
, auxesz
);
1049 for (j
= 0; j
< native
->u
.syment
.n_numaux
; j
++)
1051 BFD_ASSERT (! (native
+ j
+ 1)->is_sym
);
1052 bfd_coff_swap_aux_out (abfd
,
1053 &((native
+ j
+ 1)->u
.auxent
),
1054 type
, n_sclass
, (int) j
,
1055 native
->u
.syment
.n_numaux
,
1057 if (bfd_bwrite (buf
, auxesz
, abfd
) != auxesz
)
1060 bfd_release (abfd
, buf
);
1063 /* Store the index for use when we write out the relocs. */
1064 set_index (symbol
, *written
);
1066 *written
+= numaux
+ 1;
1070 /* Write out a symbol to a COFF file that does not come from a COFF
1071 file originally. This symbol may have been created by the linker,
1072 or we may be linking a non COFF file to a COFF file. */
1075 coff_write_alien_symbol (bfd
*abfd
,
1077 struct internal_syment
*isym
,
1078 union internal_auxent
*iaux
,
1080 bfd_size_type
*string_size_p
,
1081 asection
**debug_string_section_p
,
1082 bfd_size_type
*debug_string_size_p
)
1084 combined_entry_type
*native
;
1085 combined_entry_type dummy
[2];
1086 asection
*output_section
= symbol
->section
->output_section
1087 ? symbol
->section
->output_section
1089 struct bfd_link_info
*link_info
= coff_data (abfd
)->link_info
;
1092 if ((!link_info
|| link_info
->strip_discarded
)
1093 && !bfd_is_abs_section (symbol
->section
)
1094 && symbol
->section
->output_section
== bfd_abs_section_ptr
)
1098 memset (isym
, 0, sizeof (*isym
));
1102 native
->is_sym
= TRUE
;
1103 native
[1].is_sym
= FALSE
;
1104 native
->u
.syment
.n_type
= T_NULL
;
1105 native
->u
.syment
.n_flags
= 0;
1106 native
->u
.syment
.n_numaux
= 0;
1107 if (bfd_is_und_section (symbol
->section
))
1109 native
->u
.syment
.n_scnum
= N_UNDEF
;
1110 native
->u
.syment
.n_value
= symbol
->value
;
1112 else if (bfd_is_com_section (symbol
->section
))
1114 native
->u
.syment
.n_scnum
= N_UNDEF
;
1115 native
->u
.syment
.n_value
= symbol
->value
;
1117 else if (symbol
->flags
& BSF_FILE
)
1119 native
->u
.syment
.n_scnum
= N_DEBUG
;
1120 native
->u
.syment
.n_numaux
= 1;
1122 else if (symbol
->flags
& BSF_DEBUGGING
)
1124 /* There isn't much point to writing out a debugging symbol
1125 unless we are prepared to convert it into COFF debugging
1126 format. So, we just ignore them. We must clobber the symbol
1127 name to keep it from being put in the string table. */
1130 memset (isym
, 0, sizeof (*isym
));
1135 native
->u
.syment
.n_scnum
= output_section
->target_index
;
1136 native
->u
.syment
.n_value
= (symbol
->value
1137 + symbol
->section
->output_offset
);
1138 if (! obj_pe (abfd
))
1139 native
->u
.syment
.n_value
+= output_section
->vma
;
1141 /* Copy the any flags from the file header into the symbol.
1144 coff_symbol_type
*c
= coff_symbol_from (symbol
);
1145 if (c
!= (coff_symbol_type
*) NULL
)
1146 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (&c
->symbol
)->flags
;
1150 native
->u
.syment
.n_type
= 0;
1151 if (symbol
->flags
& BSF_FILE
)
1152 native
->u
.syment
.n_sclass
= C_FILE
;
1153 else if (symbol
->flags
& BSF_LOCAL
)
1154 native
->u
.syment
.n_sclass
= C_STAT
;
1155 else if (symbol
->flags
& BSF_WEAK
)
1156 native
->u
.syment
.n_sclass
= obj_pe (abfd
) ? C_NT_WEAK
: C_WEAKEXT
;
1158 native
->u
.syment
.n_sclass
= C_EXT
;
1160 ret
= coff_write_symbol (abfd
, symbol
, native
, written
, string_size_p
,
1161 debug_string_section_p
, debug_string_size_p
);
1163 *isym
= native
->u
.syment
;
1164 if (iaux
!= NULL
&& native
->u
.syment
.n_numaux
)
1165 *iaux
= native
[1].u
.auxent
;
1169 /* Write a native symbol to a COFF file. */
1172 coff_write_native_symbol (bfd
*abfd
,
1173 coff_symbol_type
*symbol
,
1175 bfd_size_type
*string_size_p
,
1176 asection
**debug_string_section_p
,
1177 bfd_size_type
*debug_string_size_p
)
1179 combined_entry_type
*native
= symbol
->native
;
1180 alent
*lineno
= symbol
->lineno
;
1181 struct bfd_link_info
*link_info
= coff_data (abfd
)->link_info
;
1183 if ((!link_info
|| link_info
->strip_discarded
)
1184 && !bfd_is_abs_section (symbol
->symbol
.section
)
1185 && symbol
->symbol
.section
->output_section
== bfd_abs_section_ptr
)
1187 symbol
->symbol
.name
= "";
1191 BFD_ASSERT (native
->is_sym
);
1192 /* If this symbol has an associated line number, we must store the
1193 symbol index in the line number field. We also tag the auxent to
1194 point to the right place in the lineno table. */
1195 if (lineno
&& !symbol
->done_lineno
&& symbol
->symbol
.section
->owner
!= NULL
)
1197 unsigned int count
= 0;
1199 lineno
[count
].u
.offset
= *written
;
1200 if (native
->u
.syment
.n_numaux
)
1202 union internal_auxent
*a
= &((native
+ 1)->u
.auxent
);
1204 a
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1205 symbol
->symbol
.section
->output_section
->moving_line_filepos
;
1208 /* Count and relocate all other linenumbers. */
1210 while (lineno
[count
].line_number
!= 0)
1212 lineno
[count
].u
.offset
+=
1213 (symbol
->symbol
.section
->output_section
->vma
1214 + symbol
->symbol
.section
->output_offset
);
1217 symbol
->done_lineno
= TRUE
;
1219 if (! bfd_is_const_section (symbol
->symbol
.section
->output_section
))
1220 symbol
->symbol
.section
->output_section
->moving_line_filepos
+=
1221 count
* bfd_coff_linesz (abfd
);
1224 return coff_write_symbol (abfd
, &(symbol
->symbol
), native
, written
,
1225 string_size_p
, debug_string_section_p
,
1226 debug_string_size_p
);
1230 null_error_handler (const char *fmt ATTRIBUTE_UNUSED
,
1231 va_list ap ATTRIBUTE_UNUSED
)
1235 /* Write out the COFF symbols. */
1238 coff_write_symbols (bfd
*abfd
)
1240 bfd_size_type string_size
;
1241 asection
*debug_string_section
;
1242 bfd_size_type debug_string_size
;
1244 unsigned int limit
= bfd_get_symcount (abfd
);
1245 bfd_vma written
= 0;
1249 debug_string_section
= NULL
;
1250 debug_string_size
= 0;
1252 /* If this target supports long section names, they must be put into
1253 the string table. This is supported by PE. This code must
1254 handle section names just as they are handled in
1255 coff_write_object_contents. */
1256 if (bfd_coff_long_section_names (abfd
))
1260 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1264 len
= strlen (o
->name
);
1266 string_size
+= len
+ 1;
1270 /* Seek to the right place. */
1271 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
1274 /* Output all the symbols we have. */
1276 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1278 asymbol
*symbol
= *p
;
1279 coff_symbol_type
*c_symbol
= coff_symbol_from (symbol
);
1281 if (c_symbol
== (coff_symbol_type
*) NULL
1282 || c_symbol
->native
== (combined_entry_type
*) NULL
)
1284 if (!coff_write_alien_symbol (abfd
, symbol
, NULL
, NULL
, &written
,
1285 &string_size
, &debug_string_section
,
1286 &debug_string_size
))
1291 if (coff_backend_info (abfd
)->_bfd_coff_classify_symbol
!= NULL
)
1293 bfd_error_handler_type current_error_handler
;
1294 enum coff_symbol_classification sym_class
;
1295 unsigned char *n_sclass
;
1297 /* Suppress error reporting by bfd_coff_classify_symbol.
1298 Error messages can be generated when we are processing a local
1299 symbol which has no associated section and we do not have to
1300 worry about this, all we need to know is that it is local. */
1301 current_error_handler
= bfd_set_error_handler (null_error_handler
);
1302 BFD_ASSERT (c_symbol
->native
->is_sym
);
1303 sym_class
= bfd_coff_classify_symbol (abfd
,
1304 &c_symbol
->native
->u
.syment
);
1305 (void) bfd_set_error_handler (current_error_handler
);
1307 n_sclass
= &c_symbol
->native
->u
.syment
.n_sclass
;
1309 /* If the symbol class has been changed (eg objcopy/ld script/etc)
1310 we cannot retain the existing sclass from the original symbol.
1311 Weak symbols only have one valid sclass, so just set it always.
1312 If it is not local class and should be, set it C_STAT.
1313 If it is global and not classified as global, or if it is
1314 weak (which is also classified as global), set it C_EXT. */
1316 if (symbol
->flags
& BSF_WEAK
)
1317 *n_sclass
= obj_pe (abfd
) ? C_NT_WEAK
: C_WEAKEXT
;
1318 else if (symbol
->flags
& BSF_LOCAL
&& sym_class
!= COFF_SYMBOL_LOCAL
)
1320 else if (symbol
->flags
& BSF_GLOBAL
1321 && (sym_class
!= COFF_SYMBOL_GLOBAL
1323 || *n_sclass
== C_NT_WEAK
1325 || *n_sclass
== C_WEAKEXT
))
1326 c_symbol
->native
->u
.syment
.n_sclass
= C_EXT
;
1329 if (!coff_write_native_symbol (abfd
, c_symbol
, &written
,
1330 &string_size
, &debug_string_section
,
1331 &debug_string_size
))
1336 obj_raw_syment_count (abfd
) = written
;
1338 /* Now write out strings. */
1339 if (string_size
!= 0)
1341 unsigned int size
= string_size
+ STRING_SIZE_SIZE
;
1342 bfd_byte buffer
[STRING_SIZE_SIZE
];
1344 #if STRING_SIZE_SIZE == 4
1345 H_PUT_32 (abfd
, size
, buffer
);
1347 #error Change H_PUT_32
1349 if (bfd_bwrite ((void *) buffer
, (bfd_size_type
) sizeof (buffer
), abfd
)
1353 /* Handle long section names. This code must handle section
1354 names just as they are handled in coff_write_object_contents. */
1355 if (bfd_coff_long_section_names (abfd
))
1359 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1363 len
= strlen (o
->name
);
1366 if (bfd_bwrite (o
->name
, (bfd_size_type
) (len
+ 1), abfd
)
1373 for (p
= abfd
->outsymbols
, i
= 0;
1378 size_t name_length
= strlen (q
->name
);
1379 coff_symbol_type
*c_symbol
= coff_symbol_from (q
);
1382 /* Figure out whether the symbol name should go in the string
1383 table. Symbol names that are short enough are stored
1384 directly in the syment structure. File names permit a
1385 different, longer, length in the syment structure. On
1386 XCOFF, some symbol names are stored in the .debug section
1387 rather than in the string table. */
1389 if (c_symbol
== NULL
1390 || c_symbol
->native
== NULL
)
1391 /* This is not a COFF symbol, so it certainly is not a
1392 file name, nor does it go in the .debug section. */
1393 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1395 else if (! c_symbol
->native
->is_sym
)
1396 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1398 else if (bfd_coff_symname_in_debug (abfd
,
1399 &c_symbol
->native
->u
.syment
))
1400 /* This symbol name is in the XCOFF .debug section.
1401 Don't write it into the string table. */
1402 maxlen
= name_length
;
1404 else if (c_symbol
->native
->u
.syment
.n_sclass
== C_FILE
1405 && c_symbol
->native
->u
.syment
.n_numaux
> 0)
1407 if (bfd_coff_force_symnames_in_strings (abfd
))
1409 if (bfd_bwrite (".file", (bfd_size_type
) 6, abfd
) != 6)
1412 maxlen
= bfd_coff_filnmlen (abfd
);
1415 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1417 if (name_length
> maxlen
)
1419 if (bfd_bwrite ((void *) (q
->name
), (bfd_size_type
) name_length
+ 1,
1420 abfd
) != name_length
+ 1)
1427 /* We would normally not write anything here, but we'll write
1428 out 4 so that any stupid coff reader which tries to read the
1429 string table even when there isn't one won't croak. */
1430 unsigned int size
= STRING_SIZE_SIZE
;
1431 bfd_byte buffer
[STRING_SIZE_SIZE
];
1433 #if STRING_SIZE_SIZE == 4
1434 H_PUT_32 (abfd
, size
, buffer
);
1436 #error Change H_PUT_32
1438 if (bfd_bwrite ((void *) buffer
, (bfd_size_type
) STRING_SIZE_SIZE
, abfd
)
1439 != STRING_SIZE_SIZE
)
1443 /* Make sure the .debug section was created to be the correct size.
1444 We should create it ourselves on the fly, but we don't because
1445 BFD won't let us write to any section until we know how large all
1446 the sections are. We could still do it by making another pass
1447 over the symbols. FIXME. */
1448 BFD_ASSERT (debug_string_size
== 0
1449 || (debug_string_section
!= (asection
*) NULL
1450 && (BFD_ALIGN (debug_string_size
,
1451 1 << debug_string_section
->alignment_power
)
1452 == debug_string_section
->size
)));
1458 coff_write_linenumbers (bfd
*abfd
)
1461 bfd_size_type linesz
;
1464 linesz
= bfd_coff_linesz (abfd
);
1465 buff
= bfd_alloc (abfd
, linesz
);
1468 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
1470 if (s
->lineno_count
)
1472 asymbol
**q
= abfd
->outsymbols
;
1473 if (bfd_seek (abfd
, s
->line_filepos
, SEEK_SET
) != 0)
1475 /* Find all the linenumbers in this section. */
1479 if (p
->section
->output_section
== s
)
1482 BFD_SEND (bfd_asymbol_bfd (p
), _get_lineno
,
1483 (bfd_asymbol_bfd (p
), p
));
1486 /* Found a linenumber entry, output. */
1487 struct internal_lineno out
;
1489 memset ((void *) & out
, 0, sizeof (out
));
1491 out
.l_addr
.l_symndx
= l
->u
.offset
;
1492 bfd_coff_swap_lineno_out (abfd
, &out
, buff
);
1493 if (bfd_bwrite (buff
, (bfd_size_type
) linesz
, abfd
)
1497 while (l
->line_number
)
1499 out
.l_lnno
= l
->line_number
;
1500 out
.l_addr
.l_symndx
= l
->u
.offset
;
1501 bfd_coff_swap_lineno_out (abfd
, &out
, buff
);
1502 if (bfd_bwrite (buff
, (bfd_size_type
) linesz
, abfd
)
1513 bfd_release (abfd
, buff
);
1518 coff_get_lineno (bfd
*ignore_abfd ATTRIBUTE_UNUSED
, asymbol
*symbol
)
1520 return coffsymbol (symbol
)->lineno
;
1523 /* This function transforms the offsets into the symbol table into
1524 pointers to syments. */
1527 coff_pointerize_aux (bfd
*abfd
,
1528 combined_entry_type
*table_base
,
1529 combined_entry_type
*symbol
,
1530 unsigned int indaux
,
1531 combined_entry_type
*auxent
,
1532 combined_entry_type
*table_end
)
1534 unsigned int type
= symbol
->u
.syment
.n_type
;
1535 unsigned int n_sclass
= symbol
->u
.syment
.n_sclass
;
1537 BFD_ASSERT (symbol
->is_sym
);
1538 if (coff_backend_info (abfd
)->_bfd_coff_pointerize_aux_hook
)
1540 if ((*coff_backend_info (abfd
)->_bfd_coff_pointerize_aux_hook
)
1541 (abfd
, table_base
, symbol
, indaux
, auxent
))
1545 /* Don't bother if this is a file or a section. */
1546 if (n_sclass
== C_STAT
&& type
== T_NULL
)
1548 if (n_sclass
== C_FILE
)
1551 BFD_ASSERT (! auxent
->is_sym
);
1552 /* Otherwise patch up. */
1553 #define N_TMASK coff_data (abfd)->local_n_tmask
1554 #define N_BTSHFT coff_data (abfd)->local_n_btshft
1556 if ((ISFCN (type
) || ISTAG (n_sclass
) || n_sclass
== C_BLOCK
1557 || n_sclass
== C_FCN
)
1558 && auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
> 0
1559 && auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
1560 < (long) obj_raw_syment_count (abfd
)
1561 && table_base
+ auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
1564 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
=
1565 table_base
+ auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
1566 auxent
->fix_end
= 1;
1569 /* A negative tagndx is meaningless, but the SCO 3.2v4 cc can
1570 generate one, so we must be careful to ignore it. */
1571 if ((unsigned long) auxent
->u
.auxent
.x_sym
.x_tagndx
.l
1572 < obj_raw_syment_count (abfd
)
1573 && table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
< table_end
)
1575 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
=
1576 table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
;
1577 auxent
->fix_tag
= 1;
1581 /* Allocate space for the ".debug" section, and read it.
1582 We did not read the debug section until now, because
1583 we didn't want to go to the trouble until someone needed it. */
1586 build_debug_section (bfd
*abfd
, asection
** sect_return
)
1588 char *debug_section
;
1590 bfd_size_type sec_size
;
1592 asection
*sect
= bfd_get_section_by_name (abfd
, ".debug");
1596 bfd_set_error (bfd_error_no_debug_section
);
1600 sec_size
= sect
->size
;
1601 debug_section
= (char *) bfd_alloc (abfd
, sec_size
);
1602 if (debug_section
== NULL
)
1605 /* Seek to the beginning of the `.debug' section and read it.
1606 Save the current position first; it is needed by our caller.
1607 Then read debug section and reset the file pointer. */
1609 position
= bfd_tell (abfd
);
1610 if (bfd_seek (abfd
, sect
->filepos
, SEEK_SET
) != 0
1611 || bfd_bread (debug_section
, sec_size
, abfd
) != sec_size
1612 || bfd_seek (abfd
, position
, SEEK_SET
) != 0)
1615 * sect_return
= sect
;
1616 return debug_section
;
1619 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
1620 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
1621 be \0-terminated. */
1624 copy_name (bfd
*abfd
, char *name
, size_t maxlen
)
1629 for (len
= 0; len
< maxlen
; ++len
)
1630 if (name
[len
] == '\0')
1633 if ((newname
= (char *) bfd_alloc (abfd
, (bfd_size_type
) len
+ 1)) == NULL
)
1636 strncpy (newname
, name
, len
);
1637 newname
[len
] = '\0';
1641 /* Read in the external symbols. */
1644 _bfd_coff_get_external_symbols (bfd
*abfd
)
1646 bfd_size_type symesz
;
1650 if (obj_coff_external_syms (abfd
) != NULL
)
1653 symesz
= bfd_coff_symesz (abfd
);
1655 size
= obj_raw_syment_count (abfd
) * symesz
;
1658 /* Check for integer overflow and for unreasonable symbol counts. */
1659 if (size
< obj_raw_syment_count (abfd
)
1660 || (bfd_get_file_size (abfd
) > 0
1661 && size
> bfd_get_file_size (abfd
)))
1664 _bfd_error_handler (_("%pB: corrupt symbol count: %#" PRIx64
""),
1665 abfd
, (uint64_t) obj_raw_syment_count (abfd
));
1669 syms
= bfd_malloc (size
);
1672 /* PR 21013: Provide an error message when the alloc fails. */
1673 _bfd_error_handler (_("%pB: not enough memory to allocate space "
1674 "for %#" PRIx64
" symbols of size %#" PRIx64
),
1675 abfd
, (uint64_t) obj_raw_syment_count (abfd
),
1680 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
1681 || bfd_bread (syms
, size
, abfd
) != size
)
1688 obj_coff_external_syms (abfd
) = syms
;
1692 /* Read in the external strings. The strings are not loaded until
1693 they are needed. This is because we have no simple way of
1694 detecting a missing string table in an archive. If the strings
1695 are loaded then the STRINGS and STRINGS_LEN fields in the
1696 coff_tdata structure will be set. */
1699 _bfd_coff_read_string_table (bfd
*abfd
)
1701 char extstrsize
[STRING_SIZE_SIZE
];
1702 bfd_size_type strsize
;
1706 if (obj_coff_strings (abfd
) != NULL
)
1707 return obj_coff_strings (abfd
);
1709 if (obj_sym_filepos (abfd
) == 0)
1711 bfd_set_error (bfd_error_no_symbols
);
1715 pos
= obj_sym_filepos (abfd
);
1716 pos
+= obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
1717 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
1720 if (bfd_bread (extstrsize
, (bfd_size_type
) sizeof extstrsize
, abfd
)
1721 != sizeof extstrsize
)
1723 if (bfd_get_error () != bfd_error_file_truncated
)
1726 /* There is no string table. */
1727 strsize
= STRING_SIZE_SIZE
;
1731 #if STRING_SIZE_SIZE == 4
1732 strsize
= H_GET_32 (abfd
, extstrsize
);
1734 #error Change H_GET_32
1738 if (strsize
< STRING_SIZE_SIZE
|| strsize
> bfd_get_file_size (abfd
))
1741 /* xgettext: c-format */
1742 (_("%pB: bad string table size %" PRIu64
), abfd
, (uint64_t) strsize
);
1743 bfd_set_error (bfd_error_bad_value
);
1747 strings
= (char *) bfd_malloc (strsize
+ 1);
1748 if (strings
== NULL
)
1751 /* PR 17521 file: 079-54929-0.004.
1752 A corrupt file could contain an index that points into the first
1753 STRING_SIZE_SIZE bytes of the string table, so make sure that
1755 memset (strings
, 0, STRING_SIZE_SIZE
);
1757 if (bfd_bread (strings
+ STRING_SIZE_SIZE
, strsize
- STRING_SIZE_SIZE
, abfd
)
1758 != strsize
- STRING_SIZE_SIZE
)
1764 obj_coff_strings (abfd
) = strings
;
1765 obj_coff_strings_len (abfd
) = strsize
;
1766 /* Terminate the string table, just in case. */
1767 strings
[strsize
] = 0;
1771 /* Free up the external symbols and strings read from a COFF file. */
1774 _bfd_coff_free_symbols (bfd
*abfd
)
1776 if (! bfd_family_coff (abfd
))
1779 if (obj_coff_external_syms (abfd
) != NULL
1780 && ! obj_coff_keep_syms (abfd
))
1782 free (obj_coff_external_syms (abfd
));
1783 obj_coff_external_syms (abfd
) = NULL
;
1786 if (obj_coff_strings (abfd
) != NULL
1787 && ! obj_coff_keep_strings (abfd
))
1789 free (obj_coff_strings (abfd
));
1790 obj_coff_strings (abfd
) = NULL
;
1791 obj_coff_strings_len (abfd
) = 0;
1797 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
1798 knit the symbol names into a normalized form. By normalized here I
1799 mean that all symbols have an n_offset pointer that points to a null-
1800 terminated string. */
1802 combined_entry_type
*
1803 coff_get_normalized_symtab (bfd
*abfd
)
1805 combined_entry_type
*internal
;
1806 combined_entry_type
*internal_ptr
;
1807 combined_entry_type
*symbol_ptr
;
1808 combined_entry_type
*internal_end
;
1812 const char *string_table
= NULL
;
1813 asection
* debug_sec
= NULL
;
1814 char *debug_sec_data
= NULL
;
1817 if (obj_raw_syments (abfd
) != NULL
)
1818 return obj_raw_syments (abfd
);
1820 if (! _bfd_coff_get_external_symbols (abfd
))
1823 size
= obj_raw_syment_count (abfd
);
1824 /* Check for integer overflow. */
1825 if (size
> (bfd_size_type
) -1 / sizeof (combined_entry_type
))
1827 size
*= sizeof (combined_entry_type
);
1828 internal
= (combined_entry_type
*) bfd_zalloc (abfd
, size
);
1829 if (internal
== NULL
&& size
!= 0)
1831 internal_end
= internal
+ obj_raw_syment_count (abfd
);
1833 raw_src
= (char *) obj_coff_external_syms (abfd
);
1835 /* Mark the end of the symbols. */
1836 symesz
= bfd_coff_symesz (abfd
);
1837 raw_end
= (char *) raw_src
+ obj_raw_syment_count (abfd
) * symesz
;
1839 /* FIXME SOMEDAY. A string table size of zero is very weird, but
1840 probably possible. If one shows up, it will probably kill us. */
1842 /* Swap all the raw entries. */
1843 for (internal_ptr
= internal
;
1845 raw_src
+= symesz
, internal_ptr
++)
1849 bfd_coff_swap_sym_in (abfd
, (void *) raw_src
,
1850 (void *) & internal_ptr
->u
.syment
);
1851 symbol_ptr
= internal_ptr
;
1852 internal_ptr
->is_sym
= TRUE
;
1855 i
< symbol_ptr
->u
.syment
.n_numaux
;
1861 /* PR 17512: Prevent buffer overrun. */
1862 if (raw_src
>= raw_end
|| internal_ptr
>= internal_end
)
1864 bfd_release (abfd
, internal
);
1868 bfd_coff_swap_aux_in (abfd
, (void *) raw_src
,
1869 symbol_ptr
->u
.syment
.n_type
,
1870 symbol_ptr
->u
.syment
.n_sclass
,
1871 (int) i
, symbol_ptr
->u
.syment
.n_numaux
,
1872 &(internal_ptr
->u
.auxent
));
1874 internal_ptr
->is_sym
= FALSE
;
1875 coff_pointerize_aux (abfd
, internal
, symbol_ptr
, i
,
1876 internal_ptr
, internal_end
);
1880 /* Free the raw symbols, but not the strings (if we have them). */
1881 obj_coff_keep_strings (abfd
) = TRUE
;
1882 if (! _bfd_coff_free_symbols (abfd
))
1885 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
1888 BFD_ASSERT (internal_ptr
->is_sym
);
1890 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
1891 && internal_ptr
->u
.syment
.n_numaux
> 0)
1893 combined_entry_type
* aux
= internal_ptr
+ 1;
1895 /* Make a file symbol point to the name in the auxent, since
1896 the text ".file" is redundant. */
1897 BFD_ASSERT (! aux
->is_sym
);
1899 if (aux
->u
.auxent
.x_file
.x_n
.x_zeroes
== 0)
1901 /* The filename is a long one, point into the string table. */
1902 if (string_table
== NULL
)
1904 string_table
= _bfd_coff_read_string_table (abfd
);
1905 if (string_table
== NULL
)
1909 if ((bfd_size_type
)(aux
->u
.auxent
.x_file
.x_n
.x_offset
)
1910 >= obj_coff_strings_len (abfd
))
1911 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1913 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1914 (bfd_hostptr_t
) (string_table
+ (aux
->u
.auxent
.x_file
.x_n
.x_offset
));
1918 /* Ordinary short filename, put into memory anyway. The
1919 Microsoft PE tools sometimes store a filename in
1920 multiple AUX entries. */
1921 if (internal_ptr
->u
.syment
.n_numaux
> 1
1922 && coff_data (abfd
)->pe
)
1923 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1926 aux
->u
.auxent
.x_file
.x_fname
,
1927 internal_ptr
->u
.syment
.n_numaux
* symesz
);
1929 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1932 aux
->u
.auxent
.x_file
.x_fname
,
1933 (size_t) bfd_coff_filnmlen (abfd
)));
1938 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0)
1940 /* This is a "short" name. Make it long. */
1944 /* Find the length of this string without walking into memory
1946 for (i
= 0; i
< 8; ++i
)
1947 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0')
1950 newstring
= (char *) bfd_zalloc (abfd
, (bfd_size_type
) (i
+ 1));
1951 if (newstring
== NULL
)
1953 strncpy (newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
);
1954 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) newstring
;
1955 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1957 else if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
== 0)
1958 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) "";
1959 else if (!bfd_coff_symname_in_debug (abfd
, &internal_ptr
->u
.syment
))
1961 /* Long name already. Point symbol at the string in the
1963 if (string_table
== NULL
)
1965 string_table
= _bfd_coff_read_string_table (abfd
);
1966 if (string_table
== NULL
)
1969 if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
>= obj_coff_strings_len (abfd
)
1970 || string_table
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
< string_table
)
1971 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1973 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1976 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
));
1980 /* Long name in debug section. Very similar. */
1981 if (debug_sec_data
== NULL
)
1982 debug_sec_data
= build_debug_section (abfd
, & debug_sec
);
1983 if (debug_sec_data
!= NULL
)
1985 BFD_ASSERT (debug_sec
!= NULL
);
1986 /* PR binutils/17512: Catch out of range offsets into the debug data. */
1987 if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
> debug_sec
->size
1988 || debug_sec_data
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
< debug_sec_data
)
1989 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1991 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
)
1992 (debug_sec_data
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
1995 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) "";
1998 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
2001 obj_raw_syments (abfd
) = internal
;
2002 BFD_ASSERT (obj_raw_syment_count (abfd
)
2003 == (unsigned int) (internal_ptr
- internal
));
2009 coff_get_reloc_upper_bound (bfd
*abfd
, sec_ptr asect
)
2011 if (bfd_get_format (abfd
) != bfd_object
)
2013 bfd_set_error (bfd_error_invalid_operation
);
2016 #if SIZEOF_LONG == SIZEOF_INT
2017 if (asect
->reloc_count
>= LONG_MAX
/ sizeof (arelent
*))
2019 bfd_set_error (bfd_error_file_too_big
);
2023 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
2027 coff_make_empty_symbol (bfd
*abfd
)
2029 bfd_size_type amt
= sizeof (coff_symbol_type
);
2030 coff_symbol_type
*new_symbol
= (coff_symbol_type
*) bfd_zalloc (abfd
, amt
);
2032 if (new_symbol
== NULL
)
2034 new_symbol
->symbol
.section
= 0;
2035 new_symbol
->native
= NULL
;
2036 new_symbol
->lineno
= NULL
;
2037 new_symbol
->done_lineno
= FALSE
;
2038 new_symbol
->symbol
.the_bfd
= abfd
;
2040 return & new_symbol
->symbol
;
2043 /* Make a debugging symbol. */
2046 coff_bfd_make_debug_symbol (bfd
*abfd
,
2047 void * ptr ATTRIBUTE_UNUSED
,
2048 unsigned long sz ATTRIBUTE_UNUSED
)
2050 bfd_size_type amt
= sizeof (coff_symbol_type
);
2051 coff_symbol_type
*new_symbol
= (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
2053 if (new_symbol
== NULL
)
2055 /* @@ The 10 is a guess at a plausible maximum number of aux entries
2056 (but shouldn't be a constant). */
2057 amt
= sizeof (combined_entry_type
) * 10;
2058 new_symbol
->native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
2059 if (!new_symbol
->native
)
2061 new_symbol
->native
->is_sym
= TRUE
;
2062 new_symbol
->symbol
.section
= bfd_abs_section_ptr
;
2063 new_symbol
->symbol
.flags
= BSF_DEBUGGING
;
2064 new_symbol
->lineno
= NULL
;
2065 new_symbol
->done_lineno
= FALSE
;
2066 new_symbol
->symbol
.the_bfd
= abfd
;
2068 return & new_symbol
->symbol
;
2072 coff_get_symbol_info (bfd
*abfd
, asymbol
*symbol
, symbol_info
*ret
)
2074 bfd_symbol_info (symbol
, ret
);
2076 if (coffsymbol (symbol
)->native
!= NULL
2077 && coffsymbol (symbol
)->native
->fix_value
2078 && coffsymbol (symbol
)->native
->is_sym
)
2079 ret
->value
= coffsymbol (symbol
)->native
->u
.syment
.n_value
-
2080 (bfd_hostptr_t
) obj_raw_syments (abfd
);
2083 /* Print out information about COFF symbol. */
2086 coff_print_symbol (bfd
*abfd
,
2089 bfd_print_symbol_type how
)
2091 FILE * file
= (FILE *) filep
;
2095 case bfd_print_symbol_name
:
2096 fprintf (file
, "%s", symbol
->name
);
2099 case bfd_print_symbol_more
:
2100 fprintf (file
, "coff %s %s",
2101 coffsymbol (symbol
)->native
? "n" : "g",
2102 coffsymbol (symbol
)->lineno
? "l" : " ");
2105 case bfd_print_symbol_all
:
2106 if (coffsymbol (symbol
)->native
)
2110 combined_entry_type
*combined
= coffsymbol (symbol
)->native
;
2111 combined_entry_type
*root
= obj_raw_syments (abfd
);
2112 struct lineno_cache_entry
*l
= coffsymbol (symbol
)->lineno
;
2114 fprintf (file
, "[%3ld]", (long) (combined
- root
));
2116 /* PR 17512: file: 079-33786-0.001:0.1. */
2117 if (combined
< obj_raw_syments (abfd
)
2118 || combined
>= obj_raw_syments (abfd
) + obj_raw_syment_count (abfd
))
2120 fprintf (file
, _("<corrupt info> %s"), symbol
->name
);
2124 BFD_ASSERT (combined
->is_sym
);
2125 if (! combined
->fix_value
)
2126 val
= (bfd_vma
) combined
->u
.syment
.n_value
;
2128 val
= combined
->u
.syment
.n_value
- (bfd_hostptr_t
) root
;
2130 fprintf (file
, "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x",
2131 combined
->u
.syment
.n_scnum
,
2132 combined
->u
.syment
.n_flags
,
2133 combined
->u
.syment
.n_type
,
2134 combined
->u
.syment
.n_sclass
,
2135 combined
->u
.syment
.n_numaux
);
2136 bfd_fprintf_vma (abfd
, file
, val
);
2137 fprintf (file
, " %s", symbol
->name
);
2139 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
2141 combined_entry_type
*auxp
= combined
+ aux
+ 1;
2144 BFD_ASSERT (! auxp
->is_sym
);
2146 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.p
- root
;
2148 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.l
;
2150 fprintf (file
, "\n");
2152 if (bfd_coff_print_aux (abfd
, file
, root
, combined
, auxp
, aux
))
2155 switch (combined
->u
.syment
.n_sclass
)
2158 fprintf (file
, "File ");
2162 if (combined
->u
.syment
.n_type
== T_NULL
)
2163 /* Probably a section symbol ? */
2165 fprintf (file
, "AUX scnlen 0x%lx nreloc %d nlnno %d",
2166 (unsigned long) auxp
->u
.auxent
.x_scn
.x_scnlen
,
2167 auxp
->u
.auxent
.x_scn
.x_nreloc
,
2168 auxp
->u
.auxent
.x_scn
.x_nlinno
);
2169 if (auxp
->u
.auxent
.x_scn
.x_checksum
!= 0
2170 || auxp
->u
.auxent
.x_scn
.x_associated
!= 0
2171 || auxp
->u
.auxent
.x_scn
.x_comdat
!= 0)
2172 fprintf (file
, " checksum 0x%lx assoc %d comdat %d",
2173 auxp
->u
.auxent
.x_scn
.x_checksum
,
2174 auxp
->u
.auxent
.x_scn
.x_associated
,
2175 auxp
->u
.auxent
.x_scn
.x_comdat
);
2181 if (ISFCN (combined
->u
.syment
.n_type
))
2186 next
= (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2189 next
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2190 llnos
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
2192 "AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld",
2194 (unsigned long) auxp
->u
.auxent
.x_sym
.x_misc
.x_fsize
,
2200 fprintf (file
, "AUX lnno %d size 0x%x tagndx %ld",
2201 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
2202 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
,
2205 fprintf (file
, " endndx %ld",
2207 (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2215 fprintf (file
, "\n%s :", l
->u
.sym
->name
);
2217 while (l
->line_number
)
2219 if (l
->line_number
> 0)
2221 fprintf (file
, "\n%4d : ", l
->line_number
);
2222 bfd_fprintf_vma (abfd
, file
, l
->u
.offset
+ symbol
->section
->vma
);
2230 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
2231 fprintf (file
, " %-5s %s %s %s",
2232 symbol
->section
->name
,
2233 coffsymbol (symbol
)->native
? "n" : "g",
2234 coffsymbol (symbol
)->lineno
? "l" : " ",
2240 /* Return whether a symbol name implies a local symbol. In COFF,
2241 local symbols generally start with ``.L''. Most targets use this
2242 function for the is_local_label_name entry point, but some may
2246 _bfd_coff_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
2249 return name
[0] == '.' && name
[1] == 'L';
2252 /* Provided a BFD, a section and an offset (in bytes, not octets) into the
2253 section, calculate and return the name of the source file and the line
2254 nearest to the wanted location. */
2257 coff_find_nearest_line_with_names (bfd
*abfd
,
2261 const char **filename_ptr
,
2262 const char **functionname_ptr
,
2263 unsigned int *line_ptr
,
2264 const struct dwarf_debug_section
*debug_sections
)
2268 unsigned int line_base
;
2269 coff_data_type
*cof
= coff_data (abfd
);
2270 /* Run through the raw syments if available. */
2271 combined_entry_type
*p
;
2272 combined_entry_type
*pend
;
2274 struct coff_section_tdata
*sec_data
;
2277 /* Before looking through the symbol table, try to use a .stab
2278 section to find the information. */
2279 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2280 &found
, filename_ptr
,
2281 functionname_ptr
, line_ptr
,
2282 &coff_data(abfd
)->line_info
))
2288 /* Also try examining DWARF2 debugging information. */
2289 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
2290 filename_ptr
, functionname_ptr
,
2291 line_ptr
, NULL
, debug_sections
,
2292 &coff_data(abfd
)->dwarf2_find_line_info
))
2295 sec_data
= coff_section_data (abfd
, section
);
2297 /* If the DWARF lookup failed, but there is DWARF information available
2298 then the problem might be that the file has been rebased. This tool
2299 changes the VMAs of all the sections, but it does not update the DWARF
2300 information. So try again, using a bias against the address sought. */
2301 if (coff_data (abfd
)->dwarf2_find_line_info
!= NULL
)
2303 bfd_signed_vma bias
= 0;
2305 /* Create a cache of the result for the next call. */
2306 if (sec_data
== NULL
&& section
->owner
== abfd
)
2308 amt
= sizeof (struct coff_section_tdata
);
2309 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
2310 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2313 if (sec_data
!= NULL
&& sec_data
->saved_bias
)
2314 bias
= sec_data
->saved_bias
;
2317 bias
= _bfd_dwarf2_find_symbol_bias (symbols
,
2318 & coff_data (abfd
)->dwarf2_find_line_info
);
2322 sec_data
->saved_bias
= TRUE
;
2323 sec_data
->bias
= bias
;
2328 && _bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
,
2330 filename_ptr
, functionname_ptr
,
2331 line_ptr
, NULL
, debug_sections
,
2332 &coff_data(abfd
)->dwarf2_find_line_info
))
2337 *functionname_ptr
= 0;
2340 /* Don't try and find line numbers in a non coff file. */
2341 if (!bfd_family_coff (abfd
))
2347 /* Find the first C_FILE symbol. */
2348 p
= cof
->raw_syments
;
2352 pend
= p
+ cof
->raw_syment_count
;
2355 BFD_ASSERT (p
->is_sym
);
2356 if (p
->u
.syment
.n_sclass
== C_FILE
)
2358 p
+= 1 + p
->u
.syment
.n_numaux
;
2366 /* Look through the C_FILE symbols to find the best one. */
2367 sec_vma
= bfd_section_vma (section
);
2368 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2369 maxdiff
= (bfd_vma
) 0 - (bfd_vma
) 1;
2373 combined_entry_type
*p2
;
2375 for (p2
= p
+ 1 + p
->u
.syment
.n_numaux
;
2377 p2
+= 1 + p2
->u
.syment
.n_numaux
)
2379 BFD_ASSERT (p2
->is_sym
);
2380 if (p2
->u
.syment
.n_scnum
> 0
2382 == coff_section_from_bfd_index (abfd
,
2383 p2
->u
.syment
.n_scnum
)))
2385 if (p2
->u
.syment
.n_sclass
== C_FILE
)
2394 file_addr
= (bfd_vma
) p2
->u
.syment
.n_value
;
2395 /* PR 11512: Include the section address of the function name symbol. */
2396 if (p2
->u
.syment
.n_scnum
> 0)
2397 file_addr
+= coff_section_from_bfd_index (abfd
,
2398 p2
->u
.syment
.n_scnum
)->vma
;
2399 /* We use <= MAXDIFF here so that if we get a zero length
2400 file, we actually use the next file entry. */
2402 && offset
+ sec_vma
>= file_addr
2403 && offset
+ sec_vma
- file_addr
<= maxdiff
)
2405 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2406 maxdiff
= offset
+ sec_vma
- p2
->u
.syment
.n_value
;
2409 if (p
->u
.syment
.n_value
>= cof
->raw_syment_count
)
2412 /* Avoid endless loops on erroneous files by ensuring that
2413 we always move forward in the file. */
2414 if (p
>= cof
->raw_syments
+ p
->u
.syment
.n_value
)
2417 p
= cof
->raw_syments
+ p
->u
.syment
.n_value
;
2418 if (!p
->is_sym
|| p
->u
.syment
.n_sclass
!= C_FILE
)
2423 if (section
->lineno_count
== 0)
2425 *functionname_ptr
= NULL
;
2430 /* Now wander though the raw linenumbers of the section.
2431 If we have been called on this section before, and the offset
2432 we want is further down then we can prime the lookup loop. */
2433 if (sec_data
!= NULL
2435 && offset
>= sec_data
->offset
)
2438 *functionname_ptr
= sec_data
->function
;
2439 line_base
= sec_data
->line_base
;
2447 if (section
->lineno
!= NULL
)
2449 bfd_vma last_value
= 0;
2451 l
= §ion
->lineno
[i
];
2453 for (; i
< section
->lineno_count
; i
++)
2455 if (l
->line_number
== 0)
2457 /* Get the symbol this line number points at. */
2458 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
2459 if (coff
->symbol
.value
> offset
)
2462 *functionname_ptr
= coff
->symbol
.name
;
2463 last_value
= coff
->symbol
.value
;
2466 combined_entry_type
*s
= coff
->native
;
2468 BFD_ASSERT (s
->is_sym
);
2469 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2471 /* In XCOFF a debugging symbol can follow the
2473 if (s
->u
.syment
.n_scnum
== N_DEBUG
)
2474 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2476 /* S should now point to the .bf of the function. */
2477 if (s
->u
.syment
.n_numaux
)
2479 /* The linenumber is stored in the auxent. */
2480 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
2482 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
2483 *line_ptr
= line_base
;
2489 if (l
->u
.offset
> offset
)
2491 *line_ptr
= l
->line_number
+ line_base
- 1;
2496 /* If we fell off the end of the loop, then assume that this
2497 symbol has no line number info. Otherwise, symbols with no
2498 line number info get reported with the line number of the
2499 last line of the last symbol which does have line number
2500 info. We use 0x100 as a slop to account for cases where the
2501 last line has executable code. */
2502 if (i
>= section
->lineno_count
2504 && offset
- last_value
> 0x100)
2506 *functionname_ptr
= NULL
;
2511 /* Cache the results for the next call. */
2512 if (sec_data
== NULL
&& section
->owner
== abfd
)
2514 amt
= sizeof (struct coff_section_tdata
);
2515 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
2516 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2519 if (sec_data
!= NULL
)
2521 sec_data
->offset
= offset
;
2522 sec_data
->i
= i
- 1;
2523 sec_data
->function
= *functionname_ptr
;
2524 sec_data
->line_base
= line_base
;
2531 coff_find_nearest_line (bfd
*abfd
,
2535 const char **filename_ptr
,
2536 const char **functionname_ptr
,
2537 unsigned int *line_ptr
,
2538 unsigned int *discriminator_ptr
)
2540 if (discriminator_ptr
)
2541 *discriminator_ptr
= 0;
2542 return coff_find_nearest_line_with_names (abfd
, symbols
, section
, offset
,
2543 filename_ptr
, functionname_ptr
,
2544 line_ptr
, dwarf_debug_sections
);
2548 coff_find_inliner_info (bfd
*abfd
,
2549 const char **filename_ptr
,
2550 const char **functionname_ptr
,
2551 unsigned int *line_ptr
)
2555 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
2556 functionname_ptr
, line_ptr
,
2557 &coff_data(abfd
)->dwarf2_find_line_info
);
2562 coff_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
2566 if (!bfd_link_relocatable (info
))
2567 size
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
2569 size
= bfd_coff_filhsz (abfd
);
2571 size
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
2575 /* Change the class of a coff symbol held by BFD. */
2578 bfd_coff_set_symbol_class (bfd
* abfd
,
2580 unsigned int symbol_class
)
2582 coff_symbol_type
* csym
;
2584 csym
= coff_symbol_from (symbol
);
2587 bfd_set_error (bfd_error_invalid_operation
);
2590 else if (csym
->native
== NULL
)
2592 /* This is an alien symbol which no native coff backend data.
2593 We cheat here by creating a fake native entry for it and
2594 then filling in the class. This code is based on that in
2595 coff_write_alien_symbol(). */
2597 combined_entry_type
* native
;
2598 bfd_size_type amt
= sizeof (* native
);
2600 native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
2604 native
->is_sym
= TRUE
;
2605 native
->u
.syment
.n_type
= T_NULL
;
2606 native
->u
.syment
.n_sclass
= symbol_class
;
2608 if (bfd_is_und_section (symbol
->section
))
2610 native
->u
.syment
.n_scnum
= N_UNDEF
;
2611 native
->u
.syment
.n_value
= symbol
->value
;
2613 else if (bfd_is_com_section (symbol
->section
))
2615 native
->u
.syment
.n_scnum
= N_UNDEF
;
2616 native
->u
.syment
.n_value
= symbol
->value
;
2620 native
->u
.syment
.n_scnum
=
2621 symbol
->section
->output_section
->target_index
;
2622 native
->u
.syment
.n_value
= (symbol
->value
2623 + symbol
->section
->output_offset
);
2624 if (! obj_pe (abfd
))
2625 native
->u
.syment
.n_value
+= symbol
->section
->output_section
->vma
;
2627 /* Copy the any flags from the file header into the symbol.
2629 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (& csym
->symbol
)->flags
;
2632 csym
->native
= native
;
2635 csym
->native
->u
.syment
.n_sclass
= symbol_class
;
2641 _bfd_coff_section_already_linked (bfd
*abfd
,
2643 struct bfd_link_info
*info
)
2646 const char *name
, *key
;
2647 struct bfd_section_already_linked
*l
;
2648 struct bfd_section_already_linked_hash_entry
*already_linked_list
;
2649 struct coff_comdat_info
*s_comdat
;
2651 if (sec
->output_section
== bfd_abs_section_ptr
)
2655 if ((flags
& SEC_LINK_ONCE
) == 0)
2658 /* The COFF backend linker doesn't support group sections. */
2659 if ((flags
& SEC_GROUP
) != 0)
2662 name
= bfd_section_name (sec
);
2663 s_comdat
= bfd_coff_get_comdat_section (abfd
, sec
);
2665 if (s_comdat
!= NULL
)
2666 key
= s_comdat
->name
;
2669 if (CONST_STRNEQ (name
, ".gnu.linkonce.")
2670 && (key
= strchr (name
+ sizeof (".gnu.linkonce.") - 1, '.')) != NULL
)
2673 /* FIXME: gcc as of 2011-09 emits sections like .text$<key>,
2674 .xdata$<key> and .pdata$<key> only the first of which has a
2675 comdat key. Should these all match the LTO IR key? */
2679 already_linked_list
= bfd_section_already_linked_table_lookup (key
);
2681 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
2683 struct coff_comdat_info
*l_comdat
;
2685 l_comdat
= bfd_coff_get_comdat_section (l
->sec
->owner
, l
->sec
);
2687 /* The section names must match, and both sections must be
2688 comdat and have the same comdat name, or both sections must
2689 be non-comdat. LTO IR plugin sections are an exception. They
2690 are always named .gnu.linkonce.t.<key> (<key> is some string)
2691 and match any comdat section with comdat name of <key>, and
2692 any linkonce section with the same suffix, ie.
2693 .gnu.linkonce.*.<key>. */
2694 if (((s_comdat
!= NULL
) == (l_comdat
!= NULL
)
2695 && strcmp (name
, l
->sec
->name
) == 0)
2696 || (l
->sec
->owner
->flags
& BFD_PLUGIN
) != 0)
2698 /* The section has already been linked. See if we should
2700 return _bfd_handle_already_linked (sec
, l
, info
);
2704 /* This is the first section with this name. Record it. */
2705 if (!bfd_section_already_linked_table_insert (already_linked_list
, sec
))
2706 info
->callbacks
->einfo (_("%F%P: already_linked_table: %E\n"));
2710 /* Initialize COOKIE for input bfd ABFD. */
2713 init_reloc_cookie (struct coff_reloc_cookie
*cookie
,
2714 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2717 /* Sometimes the symbol table does not yet have been loaded here. */
2718 bfd_coff_slurp_symbol_table (abfd
);
2720 cookie
->abfd
= abfd
;
2721 cookie
->sym_hashes
= obj_coff_sym_hashes (abfd
);
2723 cookie
->symbols
= obj_symbols (abfd
);
2728 /* Free the memory allocated by init_reloc_cookie, if appropriate. */
2731 fini_reloc_cookie (struct coff_reloc_cookie
*cookie ATTRIBUTE_UNUSED
,
2732 bfd
*abfd ATTRIBUTE_UNUSED
)
2734 /* Nothing to do. */
2737 /* Initialize the relocation information in COOKIE for input section SEC
2738 of input bfd ABFD. */
2741 init_reloc_cookie_rels (struct coff_reloc_cookie
*cookie
,
2742 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2746 if (sec
->reloc_count
== 0)
2748 cookie
->rels
= NULL
;
2749 cookie
->relend
= NULL
;
2754 cookie
->rels
= _bfd_coff_read_internal_relocs (abfd
, sec
, FALSE
, NULL
, 0, NULL
);
2756 if (cookie
->rels
== NULL
)
2759 cookie
->rel
= cookie
->rels
;
2760 cookie
->relend
= (cookie
->rels
+ sec
->reloc_count
);
2764 /* Free the memory allocated by init_reloc_cookie_rels,
2768 fini_reloc_cookie_rels (struct coff_reloc_cookie
*cookie
,
2772 /* PR 20401. The relocs may not have been cached, so check first.
2773 If the relocs were loaded by init_reloc_cookie_rels() then this
2774 will be the case. FIXME: Would performance be improved if the
2775 relocs *were* cached ? */
2776 && coff_section_data (NULL
, sec
)
2777 && coff_section_data (NULL
, sec
)->relocs
!= cookie
->rels
)
2778 free (cookie
->rels
);
2781 /* Initialize the whole of COOKIE for input section SEC. */
2784 init_reloc_cookie_for_section (struct coff_reloc_cookie
*cookie
,
2785 struct bfd_link_info
*info
,
2788 if (!init_reloc_cookie (cookie
, info
, sec
->owner
))
2791 if (!init_reloc_cookie_rels (cookie
, info
, sec
->owner
, sec
))
2793 fini_reloc_cookie (cookie
, sec
->owner
);
2799 /* Free the memory allocated by init_reloc_cookie_for_section,
2803 fini_reloc_cookie_for_section (struct coff_reloc_cookie
*cookie
,
2806 fini_reloc_cookie_rels (cookie
, sec
);
2807 fini_reloc_cookie (cookie
, sec
->owner
);
2811 _bfd_coff_gc_mark_hook (asection
*sec
,
2812 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2813 struct internal_reloc
*rel ATTRIBUTE_UNUSED
,
2814 struct coff_link_hash_entry
*h
,
2815 struct internal_syment
*sym
)
2819 switch (h
->root
.type
)
2821 case bfd_link_hash_defined
:
2822 case bfd_link_hash_defweak
:
2823 return h
->root
.u
.def
.section
;
2825 case bfd_link_hash_common
:
2826 return h
->root
.u
.c
.p
->section
;
2828 case bfd_link_hash_undefweak
:
2829 if (h
->symbol_class
== C_NT_WEAK
&& h
->numaux
== 1)
2831 /* PE weak externals. A weak symbol may include an auxiliary
2832 record indicating that if the weak symbol is not resolved,
2833 another external symbol is used instead. */
2834 struct coff_link_hash_entry
*h2
=
2835 h
->auxbfd
->tdata
.coff_obj_data
->sym_hashes
[
2836 h
->aux
->x_sym
.x_tagndx
.l
];
2838 if (h2
&& h2
->root
.type
!= bfd_link_hash_undefined
)
2839 return h2
->root
.u
.def
.section
;
2843 case bfd_link_hash_undefined
:
2850 return coff_section_from_bfd_index (sec
->owner
, sym
->n_scnum
);
2853 /* COOKIE->rel describes a relocation against section SEC, which is
2854 a section we've decided to keep. Return the section that contains
2855 the relocation symbol, or NULL if no section contains it. */
2858 _bfd_coff_gc_mark_rsec (struct bfd_link_info
*info
, asection
*sec
,
2859 coff_gc_mark_hook_fn gc_mark_hook
,
2860 struct coff_reloc_cookie
*cookie
)
2862 struct coff_link_hash_entry
*h
;
2864 h
= cookie
->sym_hashes
[cookie
->rel
->r_symndx
];
2867 while (h
->root
.type
== bfd_link_hash_indirect
2868 || h
->root
.type
== bfd_link_hash_warning
)
2869 h
= (struct coff_link_hash_entry
*) h
->root
.u
.i
.link
;
2871 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, h
, NULL
);
2874 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, NULL
,
2876 + obj_convert (sec
->owner
)[cookie
->rel
->r_symndx
])->native
->u
.syment
);
2879 static bfd_boolean _bfd_coff_gc_mark
2880 (struct bfd_link_info
*, asection
*, coff_gc_mark_hook_fn
);
2882 /* COOKIE->rel describes a relocation against section SEC, which is
2883 a section we've decided to keep. Mark the section that contains
2884 the relocation symbol. */
2887 _bfd_coff_gc_mark_reloc (struct bfd_link_info
*info
,
2889 coff_gc_mark_hook_fn gc_mark_hook
,
2890 struct coff_reloc_cookie
*cookie
)
2894 rsec
= _bfd_coff_gc_mark_rsec (info
, sec
, gc_mark_hook
, cookie
);
2895 if (rsec
&& !rsec
->gc_mark
)
2897 if (bfd_get_flavour (rsec
->owner
) != bfd_target_coff_flavour
)
2899 else if (!_bfd_coff_gc_mark (info
, rsec
, gc_mark_hook
))
2905 /* The mark phase of garbage collection. For a given section, mark
2906 it and any sections in this section's group, and all the sections
2907 which define symbols to which it refers. */
2910 _bfd_coff_gc_mark (struct bfd_link_info
*info
,
2912 coff_gc_mark_hook_fn gc_mark_hook
)
2914 bfd_boolean ret
= TRUE
;
2918 /* Look through the section relocs. */
2919 if ((sec
->flags
& SEC_RELOC
) != 0
2920 && sec
->reloc_count
> 0)
2922 struct coff_reloc_cookie cookie
;
2924 if (!init_reloc_cookie_for_section (&cookie
, info
, sec
))
2928 for (; cookie
.rel
< cookie
.relend
; cookie
.rel
++)
2930 if (!_bfd_coff_gc_mark_reloc (info
, sec
, gc_mark_hook
, &cookie
))
2936 fini_reloc_cookie_for_section (&cookie
, sec
);
2944 _bfd_coff_gc_mark_extra_sections (struct bfd_link_info
*info
,
2945 coff_gc_mark_hook_fn mark_hook ATTRIBUTE_UNUSED
)
2949 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
2952 bfd_boolean some_kept
;
2954 if (bfd_get_flavour (ibfd
) != bfd_target_coff_flavour
)
2957 /* Ensure all linker created sections are kept, and see whether
2958 any other section is already marked. */
2960 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
2962 if ((isec
->flags
& SEC_LINKER_CREATED
) != 0)
2964 else if (isec
->gc_mark
)
2968 /* If no section in this file will be kept, then we can
2969 toss out debug sections. */
2973 /* Keep debug and special sections like .comment when they are
2974 not part of a group, or when we have single-member groups. */
2975 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
2976 if ((isec
->flags
& SEC_DEBUGGING
) != 0
2977 || (isec
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0)
2983 /* Sweep symbols in swept sections. Called via coff_link_hash_traverse. */
2986 coff_gc_sweep_symbol (struct coff_link_hash_entry
*h
,
2987 void *data ATTRIBUTE_UNUSED
)
2989 if (h
->root
.type
== bfd_link_hash_warning
)
2990 h
= (struct coff_link_hash_entry
*) h
->root
.u
.i
.link
;
2992 if ((h
->root
.type
== bfd_link_hash_defined
2993 || h
->root
.type
== bfd_link_hash_defweak
)
2994 && !h
->root
.u
.def
.section
->gc_mark
2995 && !(h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
))
2997 /* Do our best to hide the symbol. */
2998 h
->root
.u
.def
.section
= bfd_und_section_ptr
;
2999 h
->symbol_class
= C_HIDDEN
;
3005 /* The sweep phase of garbage collection. Remove all garbage sections. */
3007 typedef bfd_boolean (*gc_sweep_hook_fn
)
3008 (bfd
*, struct bfd_link_info
*, asection
*, const struct internal_reloc
*);
3011 coff_gc_sweep (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
3015 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3019 if (bfd_get_flavour (sub
) != bfd_target_coff_flavour
)
3022 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3024 /* Keep debug and special sections. */
3025 if ((o
->flags
& (SEC_DEBUGGING
| SEC_LINKER_CREATED
)) != 0
3026 || (o
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0)
3028 else if (CONST_STRNEQ (o
->name
, ".idata")
3029 || CONST_STRNEQ (o
->name
, ".pdata")
3030 || CONST_STRNEQ (o
->name
, ".xdata")
3031 || CONST_STRNEQ (o
->name
, ".rsrc"))
3037 /* Skip sweeping sections already excluded. */
3038 if (o
->flags
& SEC_EXCLUDE
)
3041 /* Since this is early in the link process, it is simple
3042 to remove a section from the output. */
3043 o
->flags
|= SEC_EXCLUDE
;
3045 if (info
->print_gc_sections
&& o
->size
!= 0)
3046 /* xgettext: c-format */
3047 _bfd_error_handler (_("removing unused section '%pA' in file '%pB'"),
3051 /* But we also have to update some of the relocation
3052 info we collected before. */
3054 && (o
->flags
& SEC_RELOC
) != 0
3055 && o
->reloc_count
> 0
3056 && !bfd_is_abs_section (o
->output_section
))
3058 struct internal_reloc
*internal_relocs
;
3062 = _bfd_coff_link_read_relocs (o
->owner
, o
, NULL
, NULL
,
3064 if (internal_relocs
== NULL
)
3067 r
= (*gc_sweep_hook
) (o
->owner
, info
, o
, internal_relocs
);
3069 if (coff_section_data (o
)->relocs
!= internal_relocs
)
3070 free (internal_relocs
);
3079 /* Remove the symbols that were in the swept sections from the dynamic
3081 coff_link_hash_traverse (coff_hash_table (info
), coff_gc_sweep_symbol
,
3087 /* Keep all sections containing symbols undefined on the command-line,
3088 and the section containing the entry symbol. */
3091 _bfd_coff_gc_keep (struct bfd_link_info
*info
)
3093 struct bfd_sym_chain
*sym
;
3095 for (sym
= info
->gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
3097 struct coff_link_hash_entry
*h
;
3099 h
= coff_link_hash_lookup (coff_hash_table (info
), sym
->name
,
3100 FALSE
, FALSE
, FALSE
);
3103 && (h
->root
.type
== bfd_link_hash_defined
3104 || h
->root
.type
== bfd_link_hash_defweak
)
3105 && !bfd_is_abs_section (h
->root
.u
.def
.section
))
3106 h
->root
.u
.def
.section
->flags
|= SEC_KEEP
;
3110 /* Do mark and sweep of unused sections. */
3113 bfd_coff_gc_sections (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
3117 /* FIXME: Should we implement this? */
3119 const bfd_coff_backend_data
*bed
= coff_backend_info (abfd
);
3121 if (!bed
->can_gc_sections
3122 || !is_coff_hash_table (info
->hash
))
3124 _bfd_error_handler(_("warning: gc-sections option ignored"));
3129 _bfd_coff_gc_keep (info
);
3131 /* Grovel through relocs to find out who stays ... */
3132 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3136 if (bfd_get_flavour (sub
) != bfd_target_coff_flavour
)
3139 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3141 if (((o
->flags
& (SEC_EXCLUDE
| SEC_KEEP
)) == SEC_KEEP
3142 || CONST_STRNEQ (o
->name
, ".vectors")
3143 || CONST_STRNEQ (o
->name
, ".ctors")
3144 || CONST_STRNEQ (o
->name
, ".dtors"))
3147 if (!_bfd_coff_gc_mark (info
, o
, _bfd_coff_gc_mark_hook
))
3153 /* Allow the backend to mark additional target specific sections. */
3154 _bfd_coff_gc_mark_extra_sections (info
, _bfd_coff_gc_mark_hook
);
3156 /* ... and mark SEC_EXCLUDE for those that go. */
3157 return coff_gc_sweep (abfd
, info
);
3160 /* Return name used to identify a comdat group. */
3163 bfd_coff_group_name (bfd
*abfd
, const asection
*sec
)
3165 struct coff_comdat_info
*ci
= bfd_coff_get_comdat_section (abfd
, sec
);
3172 _bfd_coff_close_and_cleanup (bfd
*abfd
)
3174 if (abfd
->format
== bfd_object
3175 && bfd_family_coff (abfd
)
3176 && coff_data (abfd
) != NULL
)
3178 obj_coff_keep_syms (abfd
) = FALSE
;
3179 obj_coff_keep_strings (abfd
) = FALSE
;
3180 if (!_bfd_coff_free_symbols (abfd
))
3183 return _bfd_generic_close_and_cleanup (abfd
);