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_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 bfd_boolean 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 if (free_external
!= NULL
)
549 free (free_external
);
550 free_external
= NULL
;
553 if (cache
&& free_internal
!= NULL
)
555 if (coff_section_data (abfd
, sec
) == NULL
)
557 amt
= sizeof (struct coff_section_tdata
);
558 sec
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
559 if (sec
->used_by_bfd
== NULL
)
561 coff_section_data (abfd
, sec
)->contents
= NULL
;
563 coff_section_data (abfd
, sec
)->relocs
= free_internal
;
566 return internal_relocs
;
569 if (free_external
!= NULL
)
570 free (free_external
);
571 if (free_internal
!= NULL
)
572 free (free_internal
);
576 /* Set lineno_count for the output sections of a COFF file. */
579 coff_count_linenumbers (bfd
*abfd
)
581 unsigned int limit
= bfd_get_symcount (abfd
);
589 /* This may be from the backend linker, in which case the
590 lineno_count in the sections is correct. */
591 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
592 total
+= s
->lineno_count
;
596 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
597 BFD_ASSERT (s
->lineno_count
== 0);
599 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
601 asymbol
*q_maybe
= *p
;
603 if (bfd_family_coff (bfd_asymbol_bfd (q_maybe
)))
605 coff_symbol_type
*q
= coffsymbol (q_maybe
);
607 /* The AIX 4.1 compiler can sometimes generate line numbers
608 attached to debugging symbols. We try to simply ignore
610 if (q
->lineno
!= NULL
611 && q
->symbol
.section
->owner
!= NULL
)
613 /* This symbol has line numbers. Increment the owning
614 section's linenumber count. */
615 alent
*l
= q
->lineno
;
619 asection
* sec
= q
->symbol
.section
->output_section
;
621 /* Do not try to update fields in read-only sections. */
622 if (! bfd_is_const_section (sec
))
623 sec
->lineno_count
++;
628 while (l
->line_number
!= 0);
637 fixup_symbol_value (bfd
*abfd
,
638 coff_symbol_type
*coff_symbol_ptr
,
639 struct internal_syment
*syment
)
641 /* Normalize the symbol flags. */
642 if (coff_symbol_ptr
->symbol
.section
643 && bfd_is_com_section (coff_symbol_ptr
->symbol
.section
))
645 /* A common symbol is undefined with a value. */
646 syment
->n_scnum
= N_UNDEF
;
647 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
649 else if ((coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
) != 0
650 && (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING_RELOC
) == 0)
652 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
654 else if (bfd_is_und_section (coff_symbol_ptr
->symbol
.section
))
656 syment
->n_scnum
= N_UNDEF
;
659 /* FIXME: Do we need to handle the absolute section here? */
662 if (coff_symbol_ptr
->symbol
.section
)
665 coff_symbol_ptr
->symbol
.section
->output_section
->target_index
;
667 syment
->n_value
= (coff_symbol_ptr
->symbol
.value
668 + coff_symbol_ptr
->symbol
.section
->output_offset
);
671 syment
->n_value
+= (syment
->n_sclass
== C_STATLAB
)
672 ? coff_symbol_ptr
->symbol
.section
->output_section
->lma
673 : coff_symbol_ptr
->symbol
.section
->output_section
->vma
;
679 /* This can happen, but I don't know why yet (steve@cygnus.com) */
680 syment
->n_scnum
= N_ABS
;
681 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
686 /* Run through all the symbols in the symbol table and work out what
687 their indexes into the symbol table will be when output.
689 Coff requires that each C_FILE symbol points to the next one in the
690 chain, and that the last one points to the first external symbol. We
694 coff_renumber_symbols (bfd
*bfd_ptr
, int *first_undef
)
696 unsigned int symbol_count
= bfd_get_symcount (bfd_ptr
);
697 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
698 unsigned int native_index
= 0;
699 struct internal_syment
*last_file
= NULL
;
700 unsigned int symbol_index
;
702 /* COFF demands that undefined symbols come after all other symbols.
703 Since we don't need to impose this extra knowledge on all our
704 client programs, deal with that here. Sort the symbol table;
705 just move the undefined symbols to the end, leaving the rest
706 alone. The O'Reilly book says that defined global symbols come
707 at the end before the undefined symbols, so we do that here as
709 /* @@ Do we have some condition we could test for, so we don't always
710 have to do this? I don't think relocatability is quite right, but
711 I'm not certain. [raeburn:19920508.1711EST] */
717 amt
= sizeof (asymbol
*) * ((bfd_size_type
) symbol_count
+ 1);
718 newsyms
= (asymbol
**) bfd_alloc (bfd_ptr
, amt
);
721 bfd_ptr
->outsymbols
= newsyms
;
722 for (i
= 0; i
< symbol_count
; i
++)
723 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) != 0
724 || (!bfd_is_und_section (symbol_ptr_ptr
[i
]->section
)
725 && !bfd_is_com_section (symbol_ptr_ptr
[i
]->section
)
726 && ((symbol_ptr_ptr
[i
]->flags
& BSF_FUNCTION
) != 0
727 || ((symbol_ptr_ptr
[i
]->flags
& (BSF_GLOBAL
| BSF_WEAK
))
729 *newsyms
++ = symbol_ptr_ptr
[i
];
731 for (i
= 0; i
< symbol_count
; i
++)
732 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) == 0
733 && !bfd_is_und_section (symbol_ptr_ptr
[i
]->section
)
734 && (bfd_is_com_section (symbol_ptr_ptr
[i
]->section
)
735 || ((symbol_ptr_ptr
[i
]->flags
& BSF_FUNCTION
) == 0
736 && ((symbol_ptr_ptr
[i
]->flags
& (BSF_GLOBAL
| BSF_WEAK
))
738 *newsyms
++ = symbol_ptr_ptr
[i
];
740 *first_undef
= newsyms
- bfd_ptr
->outsymbols
;
742 for (i
= 0; i
< symbol_count
; i
++)
743 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) == 0
744 && bfd_is_und_section (symbol_ptr_ptr
[i
]->section
))
745 *newsyms
++ = symbol_ptr_ptr
[i
];
746 *newsyms
= (asymbol
*) NULL
;
747 symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
750 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
752 coff_symbol_type
*coff_symbol_ptr
;
754 coff_symbol_ptr
= coff_symbol_from (symbol_ptr_ptr
[symbol_index
]);
755 symbol_ptr_ptr
[symbol_index
]->udata
.i
= symbol_index
;
756 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
)
758 combined_entry_type
*s
= coff_symbol_ptr
->native
;
761 BFD_ASSERT (s
->is_sym
);
762 if (s
->u
.syment
.n_sclass
== C_FILE
)
764 if (last_file
!= NULL
)
765 last_file
->n_value
= native_index
;
766 last_file
= &(s
->u
.syment
);
769 /* Modify the symbol values according to their section and
771 fixup_symbol_value (bfd_ptr
, coff_symbol_ptr
, &(s
->u
.syment
));
773 for (i
= 0; i
< s
->u
.syment
.n_numaux
+ 1; i
++)
774 s
[i
].offset
= native_index
++;
780 obj_conv_table_size (bfd_ptr
) = native_index
;
785 /* Run thorough the symbol table again, and fix it so that all
786 pointers to entries are changed to the entries' index in the output
790 coff_mangle_symbols (bfd
*bfd_ptr
)
792 unsigned int symbol_count
= bfd_get_symcount (bfd_ptr
);
793 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
794 unsigned int symbol_index
;
796 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
798 coff_symbol_type
*coff_symbol_ptr
;
800 coff_symbol_ptr
= coff_symbol_from (symbol_ptr_ptr
[symbol_index
]);
801 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
)
804 combined_entry_type
*s
= coff_symbol_ptr
->native
;
806 BFD_ASSERT (s
->is_sym
);
809 /* FIXME: We should use a union here. */
810 s
->u
.syment
.n_value
=
811 (bfd_hostptr_t
) ((combined_entry_type
*)
812 ((bfd_hostptr_t
) s
->u
.syment
.n_value
))->offset
;
817 /* The value is the offset into the line number entries
818 for the symbol's section. On output, the symbol's
819 section should be N_DEBUG. */
820 s
->u
.syment
.n_value
=
821 (coff_symbol_ptr
->symbol
.section
->output_section
->line_filepos
822 + s
->u
.syment
.n_value
* bfd_coff_linesz (bfd_ptr
));
823 coff_symbol_ptr
->symbol
.section
=
824 coff_section_from_bfd_index (bfd_ptr
, N_DEBUG
);
825 BFD_ASSERT (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
);
827 for (i
= 0; i
< s
->u
.syment
.n_numaux
; i
++)
829 combined_entry_type
*a
= s
+ i
+ 1;
831 BFD_ASSERT (! a
->is_sym
);
834 a
->u
.auxent
.x_sym
.x_tagndx
.l
=
835 a
->u
.auxent
.x_sym
.x_tagndx
.p
->offset
;
840 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
841 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
->offset
;
846 a
->u
.auxent
.x_csect
.x_scnlen
.l
=
847 a
->u
.auxent
.x_csect
.x_scnlen
.p
->offset
;
856 coff_fix_symbol_name (bfd
*abfd
,
858 combined_entry_type
*native
,
859 bfd_size_type
*string_size_p
,
860 asection
**debug_string_section_p
,
861 bfd_size_type
*debug_string_size_p
)
863 unsigned int name_length
;
864 union internal_auxent
*auxent
;
865 char *name
= (char *) (symbol
->name
);
869 /* COFF symbols always have names, so we'll make one up. */
870 symbol
->name
= "strange";
871 name
= (char *) symbol
->name
;
873 name_length
= strlen (name
);
875 BFD_ASSERT (native
->is_sym
);
876 if (native
->u
.syment
.n_sclass
== C_FILE
877 && native
->u
.syment
.n_numaux
> 0)
879 unsigned int filnmlen
;
881 if (bfd_coff_force_symnames_in_strings (abfd
))
883 native
->u
.syment
._n
._n_n
._n_offset
=
884 (*string_size_p
+ STRING_SIZE_SIZE
);
885 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
886 *string_size_p
+= 6; /* strlen(".file") + 1 */
889 strncpy (native
->u
.syment
._n
._n_name
, ".file", SYMNMLEN
);
891 BFD_ASSERT (! (native
+ 1)->is_sym
);
892 auxent
= &(native
+ 1)->u
.auxent
;
894 filnmlen
= bfd_coff_filnmlen (abfd
);
896 if (bfd_coff_long_filenames (abfd
))
898 if (name_length
<= filnmlen
)
899 strncpy (auxent
->x_file
.x_fname
, name
, filnmlen
);
902 auxent
->x_file
.x_n
.x_offset
= *string_size_p
+ STRING_SIZE_SIZE
;
903 auxent
->x_file
.x_n
.x_zeroes
= 0;
904 *string_size_p
+= name_length
+ 1;
909 strncpy (auxent
->x_file
.x_fname
, name
, filnmlen
);
910 if (name_length
> filnmlen
)
911 name
[filnmlen
] = '\0';
916 if (name_length
<= SYMNMLEN
&& !bfd_coff_force_symnames_in_strings (abfd
))
917 /* This name will fit into the symbol neatly. */
918 strncpy (native
->u
.syment
._n
._n_name
, symbol
->name
, SYMNMLEN
);
920 else if (!bfd_coff_symname_in_debug (abfd
, &native
->u
.syment
))
922 native
->u
.syment
._n
._n_n
._n_offset
= (*string_size_p
924 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
925 *string_size_p
+= name_length
+ 1;
931 int prefix_len
= bfd_coff_debug_string_prefix_length (abfd
);
933 /* This name should be written into the .debug section. For
934 some reason each name is preceded by a two byte length
935 and also followed by a null byte. FIXME: We assume that
936 the .debug section has already been created, and that it
938 if (*debug_string_section_p
== (asection
*) NULL
)
939 *debug_string_section_p
= bfd_get_section_by_name (abfd
, ".debug");
940 filepos
= bfd_tell (abfd
);
942 bfd_put_32 (abfd
, (bfd_vma
) (name_length
+ 1), buf
);
944 bfd_put_16 (abfd
, (bfd_vma
) (name_length
+ 1), buf
);
946 if (!bfd_set_section_contents (abfd
,
947 *debug_string_section_p
,
949 (file_ptr
) *debug_string_size_p
,
950 (bfd_size_type
) prefix_len
)
951 || !bfd_set_section_contents (abfd
,
952 *debug_string_section_p
,
953 (void *) symbol
->name
,
954 (file_ptr
) (*debug_string_size_p
956 (bfd_size_type
) name_length
+ 1))
958 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
960 native
->u
.syment
._n
._n_n
._n_offset
=
961 *debug_string_size_p
+ prefix_len
;
962 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
963 *debug_string_size_p
+= name_length
+ 1 + prefix_len
;
968 /* We need to keep track of the symbol index so that when we write out
969 the relocs we can get the index for a symbol. This method is a
972 #define set_index(symbol, idx) ((symbol)->udata.i = (idx))
974 /* Write a symbol out to a COFF file. */
977 coff_write_symbol (bfd
*abfd
,
979 combined_entry_type
*native
,
981 bfd_size_type
*string_size_p
,
982 asection
**debug_string_section_p
,
983 bfd_size_type
*debug_string_size_p
)
985 unsigned int numaux
= native
->u
.syment
.n_numaux
;
986 int type
= native
->u
.syment
.n_type
;
987 int n_sclass
= (int) native
->u
.syment
.n_sclass
;
988 asection
*output_section
= symbol
->section
->output_section
989 ? symbol
->section
->output_section
992 bfd_size_type symesz
;
994 BFD_ASSERT (native
->is_sym
);
996 if (native
->u
.syment
.n_sclass
== C_FILE
)
997 symbol
->flags
|= BSF_DEBUGGING
;
999 if (symbol
->flags
& BSF_DEBUGGING
1000 && bfd_is_abs_section (symbol
->section
))
1001 native
->u
.syment
.n_scnum
= N_DEBUG
;
1003 else if (bfd_is_abs_section (symbol
->section
))
1004 native
->u
.syment
.n_scnum
= N_ABS
;
1006 else if (bfd_is_und_section (symbol
->section
))
1007 native
->u
.syment
.n_scnum
= N_UNDEF
;
1010 native
->u
.syment
.n_scnum
=
1011 output_section
->target_index
;
1013 coff_fix_symbol_name (abfd
, symbol
, native
, string_size_p
,
1014 debug_string_section_p
, debug_string_size_p
);
1016 symesz
= bfd_coff_symesz (abfd
);
1017 buf
= bfd_alloc (abfd
, symesz
);
1020 bfd_coff_swap_sym_out (abfd
, &native
->u
.syment
, buf
);
1021 if (bfd_bwrite (buf
, symesz
, abfd
) != symesz
)
1023 bfd_release (abfd
, buf
);
1025 if (native
->u
.syment
.n_numaux
> 0)
1027 bfd_size_type auxesz
;
1030 auxesz
= bfd_coff_auxesz (abfd
);
1031 buf
= bfd_alloc (abfd
, auxesz
);
1034 for (j
= 0; j
< native
->u
.syment
.n_numaux
; j
++)
1036 BFD_ASSERT (! (native
+ j
+ 1)->is_sym
);
1037 bfd_coff_swap_aux_out (abfd
,
1038 &((native
+ j
+ 1)->u
.auxent
),
1039 type
, n_sclass
, (int) j
,
1040 native
->u
.syment
.n_numaux
,
1042 if (bfd_bwrite (buf
, auxesz
, abfd
) != auxesz
)
1045 bfd_release (abfd
, buf
);
1048 /* Store the index for use when we write out the relocs. */
1049 set_index (symbol
, *written
);
1051 *written
+= numaux
+ 1;
1055 /* Write out a symbol to a COFF file that does not come from a COFF
1056 file originally. This symbol may have been created by the linker,
1057 or we may be linking a non COFF file to a COFF file. */
1060 coff_write_alien_symbol (bfd
*abfd
,
1062 struct internal_syment
*isym
,
1063 union internal_auxent
*iaux
,
1065 bfd_size_type
*string_size_p
,
1066 asection
**debug_string_section_p
,
1067 bfd_size_type
*debug_string_size_p
)
1069 combined_entry_type
*native
;
1070 combined_entry_type dummy
[2];
1071 asection
*output_section
= symbol
->section
->output_section
1072 ? symbol
->section
->output_section
1074 struct bfd_link_info
*link_info
= coff_data (abfd
)->link_info
;
1077 if ((!link_info
|| link_info
->strip_discarded
)
1078 && !bfd_is_abs_section (symbol
->section
)
1079 && symbol
->section
->output_section
== bfd_abs_section_ptr
)
1083 memset (isym
, 0, sizeof (*isym
));
1087 native
->is_sym
= TRUE
;
1088 native
[1].is_sym
= FALSE
;
1089 native
->u
.syment
.n_type
= T_NULL
;
1090 native
->u
.syment
.n_flags
= 0;
1091 native
->u
.syment
.n_numaux
= 0;
1092 if (bfd_is_und_section (symbol
->section
))
1094 native
->u
.syment
.n_scnum
= N_UNDEF
;
1095 native
->u
.syment
.n_value
= symbol
->value
;
1097 else if (bfd_is_com_section (symbol
->section
))
1099 native
->u
.syment
.n_scnum
= N_UNDEF
;
1100 native
->u
.syment
.n_value
= symbol
->value
;
1102 else if (symbol
->flags
& BSF_FILE
)
1104 native
->u
.syment
.n_scnum
= N_DEBUG
;
1105 native
->u
.syment
.n_numaux
= 1;
1107 else if (symbol
->flags
& BSF_DEBUGGING
)
1109 /* There isn't much point to writing out a debugging symbol
1110 unless we are prepared to convert it into COFF debugging
1111 format. So, we just ignore them. We must clobber the symbol
1112 name to keep it from being put in the string table. */
1115 memset (isym
, 0, sizeof (*isym
));
1120 native
->u
.syment
.n_scnum
= output_section
->target_index
;
1121 native
->u
.syment
.n_value
= (symbol
->value
1122 + symbol
->section
->output_offset
);
1123 if (! obj_pe (abfd
))
1124 native
->u
.syment
.n_value
+= output_section
->vma
;
1126 /* Copy the any flags from the file header into the symbol.
1129 coff_symbol_type
*c
= coff_symbol_from (symbol
);
1130 if (c
!= (coff_symbol_type
*) NULL
)
1131 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (&c
->symbol
)->flags
;
1135 native
->u
.syment
.n_type
= 0;
1136 if (symbol
->flags
& BSF_FILE
)
1137 native
->u
.syment
.n_sclass
= C_FILE
;
1138 else if (symbol
->flags
& BSF_LOCAL
)
1139 native
->u
.syment
.n_sclass
= C_STAT
;
1140 else if (symbol
->flags
& BSF_WEAK
)
1141 native
->u
.syment
.n_sclass
= obj_pe (abfd
) ? C_NT_WEAK
: C_WEAKEXT
;
1143 native
->u
.syment
.n_sclass
= C_EXT
;
1145 ret
= coff_write_symbol (abfd
, symbol
, native
, written
, string_size_p
,
1146 debug_string_section_p
, debug_string_size_p
);
1148 *isym
= native
->u
.syment
;
1149 if (iaux
!= NULL
&& native
->u
.syment
.n_numaux
)
1150 *iaux
= native
[1].u
.auxent
;
1154 /* Write a native symbol to a COFF file. */
1157 coff_write_native_symbol (bfd
*abfd
,
1158 coff_symbol_type
*symbol
,
1160 bfd_size_type
*string_size_p
,
1161 asection
**debug_string_section_p
,
1162 bfd_size_type
*debug_string_size_p
)
1164 combined_entry_type
*native
= symbol
->native
;
1165 alent
*lineno
= symbol
->lineno
;
1166 struct bfd_link_info
*link_info
= coff_data (abfd
)->link_info
;
1168 if ((!link_info
|| link_info
->strip_discarded
)
1169 && !bfd_is_abs_section (symbol
->symbol
.section
)
1170 && symbol
->symbol
.section
->output_section
== bfd_abs_section_ptr
)
1172 symbol
->symbol
.name
= "";
1176 BFD_ASSERT (native
->is_sym
);
1177 /* If this symbol has an associated line number, we must store the
1178 symbol index in the line number field. We also tag the auxent to
1179 point to the right place in the lineno table. */
1180 if (lineno
&& !symbol
->done_lineno
&& symbol
->symbol
.section
->owner
!= NULL
)
1182 unsigned int count
= 0;
1184 lineno
[count
].u
.offset
= *written
;
1185 if (native
->u
.syment
.n_numaux
)
1187 union internal_auxent
*a
= &((native
+ 1)->u
.auxent
);
1189 a
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1190 symbol
->symbol
.section
->output_section
->moving_line_filepos
;
1193 /* Count and relocate all other linenumbers. */
1195 while (lineno
[count
].line_number
!= 0)
1197 lineno
[count
].u
.offset
+=
1198 (symbol
->symbol
.section
->output_section
->vma
1199 + symbol
->symbol
.section
->output_offset
);
1202 symbol
->done_lineno
= TRUE
;
1204 if (! bfd_is_const_section (symbol
->symbol
.section
->output_section
))
1205 symbol
->symbol
.section
->output_section
->moving_line_filepos
+=
1206 count
* bfd_coff_linesz (abfd
);
1209 return coff_write_symbol (abfd
, &(symbol
->symbol
), native
, written
,
1210 string_size_p
, debug_string_section_p
,
1211 debug_string_size_p
);
1215 null_error_handler (const char *fmt ATTRIBUTE_UNUSED
,
1216 va_list ap ATTRIBUTE_UNUSED
)
1220 /* Write out the COFF symbols. */
1223 coff_write_symbols (bfd
*abfd
)
1225 bfd_size_type string_size
;
1226 asection
*debug_string_section
;
1227 bfd_size_type debug_string_size
;
1229 unsigned int limit
= bfd_get_symcount (abfd
);
1230 bfd_vma written
= 0;
1234 debug_string_section
= NULL
;
1235 debug_string_size
= 0;
1237 /* If this target supports long section names, they must be put into
1238 the string table. This is supported by PE. This code must
1239 handle section names just as they are handled in
1240 coff_write_object_contents. */
1241 if (bfd_coff_long_section_names (abfd
))
1245 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1249 len
= strlen (o
->name
);
1251 string_size
+= len
+ 1;
1255 /* Seek to the right place. */
1256 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
1259 /* Output all the symbols we have. */
1261 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1263 asymbol
*symbol
= *p
;
1264 coff_symbol_type
*c_symbol
= coff_symbol_from (symbol
);
1266 if (c_symbol
== (coff_symbol_type
*) NULL
1267 || c_symbol
->native
== (combined_entry_type
*) NULL
)
1269 if (!coff_write_alien_symbol (abfd
, symbol
, NULL
, NULL
, &written
,
1270 &string_size
, &debug_string_section
,
1271 &debug_string_size
))
1276 if (coff_backend_info (abfd
)->_bfd_coff_classify_symbol
!= NULL
)
1278 bfd_error_handler_type current_error_handler
;
1279 enum coff_symbol_classification sym_class
;
1280 unsigned char *n_sclass
;
1282 /* Suppress error reporting by bfd_coff_classify_symbol.
1283 Error messages can be generated when we are processing a local
1284 symbol which has no associated section and we do not have to
1285 worry about this, all we need to know is that it is local. */
1286 current_error_handler
= bfd_set_error_handler (null_error_handler
);
1287 BFD_ASSERT (c_symbol
->native
->is_sym
);
1288 sym_class
= bfd_coff_classify_symbol (abfd
,
1289 &c_symbol
->native
->u
.syment
);
1290 (void) bfd_set_error_handler (current_error_handler
);
1292 n_sclass
= &c_symbol
->native
->u
.syment
.n_sclass
;
1294 /* If the symbol class has been changed (eg objcopy/ld script/etc)
1295 we cannot retain the existing sclass from the original symbol.
1296 Weak symbols only have one valid sclass, so just set it always.
1297 If it is not local class and should be, set it C_STAT.
1298 If it is global and not classified as global, or if it is
1299 weak (which is also classified as global), set it C_EXT. */
1301 if (symbol
->flags
& BSF_WEAK
)
1302 *n_sclass
= obj_pe (abfd
) ? C_NT_WEAK
: C_WEAKEXT
;
1303 else if (symbol
->flags
& BSF_LOCAL
&& sym_class
!= COFF_SYMBOL_LOCAL
)
1305 else if (symbol
->flags
& BSF_GLOBAL
1306 && (sym_class
!= COFF_SYMBOL_GLOBAL
1308 || *n_sclass
== C_NT_WEAK
1310 || *n_sclass
== C_WEAKEXT
))
1311 c_symbol
->native
->u
.syment
.n_sclass
= C_EXT
;
1314 if (!coff_write_native_symbol (abfd
, c_symbol
, &written
,
1315 &string_size
, &debug_string_section
,
1316 &debug_string_size
))
1321 obj_raw_syment_count (abfd
) = written
;
1323 /* Now write out strings. */
1324 if (string_size
!= 0)
1326 unsigned int size
= string_size
+ STRING_SIZE_SIZE
;
1327 bfd_byte buffer
[STRING_SIZE_SIZE
];
1329 #if STRING_SIZE_SIZE == 4
1330 H_PUT_32 (abfd
, size
, buffer
);
1332 #error Change H_PUT_32
1334 if (bfd_bwrite ((void *) buffer
, (bfd_size_type
) sizeof (buffer
), abfd
)
1338 /* Handle long section names. This code must handle section
1339 names just as they are handled in coff_write_object_contents. */
1340 if (bfd_coff_long_section_names (abfd
))
1344 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1348 len
= strlen (o
->name
);
1351 if (bfd_bwrite (o
->name
, (bfd_size_type
) (len
+ 1), abfd
)
1358 for (p
= abfd
->outsymbols
, i
= 0;
1363 size_t name_length
= strlen (q
->name
);
1364 coff_symbol_type
*c_symbol
= coff_symbol_from (q
);
1367 /* Figure out whether the symbol name should go in the string
1368 table. Symbol names that are short enough are stored
1369 directly in the syment structure. File names permit a
1370 different, longer, length in the syment structure. On
1371 XCOFF, some symbol names are stored in the .debug section
1372 rather than in the string table. */
1374 if (c_symbol
== NULL
1375 || c_symbol
->native
== NULL
)
1376 /* This is not a COFF symbol, so it certainly is not a
1377 file name, nor does it go in the .debug section. */
1378 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1380 else if (! c_symbol
->native
->is_sym
)
1381 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1383 else if (bfd_coff_symname_in_debug (abfd
,
1384 &c_symbol
->native
->u
.syment
))
1385 /* This symbol name is in the XCOFF .debug section.
1386 Don't write it into the string table. */
1387 maxlen
= name_length
;
1389 else if (c_symbol
->native
->u
.syment
.n_sclass
== C_FILE
1390 && c_symbol
->native
->u
.syment
.n_numaux
> 0)
1392 if (bfd_coff_force_symnames_in_strings (abfd
))
1394 if (bfd_bwrite (".file", (bfd_size_type
) 6, abfd
) != 6)
1397 maxlen
= bfd_coff_filnmlen (abfd
);
1400 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1402 if (name_length
> maxlen
)
1404 if (bfd_bwrite ((void *) (q
->name
), (bfd_size_type
) name_length
+ 1,
1405 abfd
) != name_length
+ 1)
1412 /* We would normally not write anything here, but we'll write
1413 out 4 so that any stupid coff reader which tries to read the
1414 string table even when there isn't one won't croak. */
1415 unsigned int size
= STRING_SIZE_SIZE
;
1416 bfd_byte buffer
[STRING_SIZE_SIZE
];
1418 #if STRING_SIZE_SIZE == 4
1419 H_PUT_32 (abfd
, size
, buffer
);
1421 #error Change H_PUT_32
1423 if (bfd_bwrite ((void *) buffer
, (bfd_size_type
) STRING_SIZE_SIZE
, abfd
)
1424 != STRING_SIZE_SIZE
)
1428 /* Make sure the .debug section was created to be the correct size.
1429 We should create it ourselves on the fly, but we don't because
1430 BFD won't let us write to any section until we know how large all
1431 the sections are. We could still do it by making another pass
1432 over the symbols. FIXME. */
1433 BFD_ASSERT (debug_string_size
== 0
1434 || (debug_string_section
!= (asection
*) NULL
1435 && (BFD_ALIGN (debug_string_size
,
1436 1 << debug_string_section
->alignment_power
)
1437 == debug_string_section
->size
)));
1443 coff_write_linenumbers (bfd
*abfd
)
1446 bfd_size_type linesz
;
1449 linesz
= bfd_coff_linesz (abfd
);
1450 buff
= bfd_alloc (abfd
, linesz
);
1453 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
1455 if (s
->lineno_count
)
1457 asymbol
**q
= abfd
->outsymbols
;
1458 if (bfd_seek (abfd
, s
->line_filepos
, SEEK_SET
) != 0)
1460 /* Find all the linenumbers in this section. */
1464 if (p
->section
->output_section
== s
)
1467 BFD_SEND (bfd_asymbol_bfd (p
), _get_lineno
,
1468 (bfd_asymbol_bfd (p
), p
));
1471 /* Found a linenumber entry, output. */
1472 struct internal_lineno out
;
1474 memset ((void *) & out
, 0, sizeof (out
));
1476 out
.l_addr
.l_symndx
= l
->u
.offset
;
1477 bfd_coff_swap_lineno_out (abfd
, &out
, buff
);
1478 if (bfd_bwrite (buff
, (bfd_size_type
) linesz
, abfd
)
1482 while (l
->line_number
)
1484 out
.l_lnno
= l
->line_number
;
1485 out
.l_addr
.l_symndx
= l
->u
.offset
;
1486 bfd_coff_swap_lineno_out (abfd
, &out
, buff
);
1487 if (bfd_bwrite (buff
, (bfd_size_type
) linesz
, abfd
)
1498 bfd_release (abfd
, buff
);
1503 coff_get_lineno (bfd
*ignore_abfd ATTRIBUTE_UNUSED
, asymbol
*symbol
)
1505 return coffsymbol (symbol
)->lineno
;
1508 /* This function transforms the offsets into the symbol table into
1509 pointers to syments. */
1512 coff_pointerize_aux (bfd
*abfd
,
1513 combined_entry_type
*table_base
,
1514 combined_entry_type
*symbol
,
1515 unsigned int indaux
,
1516 combined_entry_type
*auxent
,
1517 combined_entry_type
*table_end
)
1519 unsigned int type
= symbol
->u
.syment
.n_type
;
1520 unsigned int n_sclass
= symbol
->u
.syment
.n_sclass
;
1522 BFD_ASSERT (symbol
->is_sym
);
1523 if (coff_backend_info (abfd
)->_bfd_coff_pointerize_aux_hook
)
1525 if ((*coff_backend_info (abfd
)->_bfd_coff_pointerize_aux_hook
)
1526 (abfd
, table_base
, symbol
, indaux
, auxent
))
1530 /* Don't bother if this is a file or a section. */
1531 if (n_sclass
== C_STAT
&& type
== T_NULL
)
1533 if (n_sclass
== C_FILE
)
1536 BFD_ASSERT (! auxent
->is_sym
);
1537 /* Otherwise patch up. */
1538 #define N_TMASK coff_data (abfd)->local_n_tmask
1539 #define N_BTSHFT coff_data (abfd)->local_n_btshft
1541 if ((ISFCN (type
) || ISTAG (n_sclass
) || n_sclass
== C_BLOCK
1542 || n_sclass
== C_FCN
)
1543 && auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
> 0
1544 && auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
1545 < (long) obj_raw_syment_count (abfd
)
1546 && table_base
+ auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
1549 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
=
1550 table_base
+ auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
1551 auxent
->fix_end
= 1;
1554 /* A negative tagndx is meaningless, but the SCO 3.2v4 cc can
1555 generate one, so we must be careful to ignore it. */
1556 if ((unsigned long) auxent
->u
.auxent
.x_sym
.x_tagndx
.l
1557 < obj_raw_syment_count (abfd
)
1558 && table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
< table_end
)
1560 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
=
1561 table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
;
1562 auxent
->fix_tag
= 1;
1566 /* Allocate space for the ".debug" section, and read it.
1567 We did not read the debug section until now, because
1568 we didn't want to go to the trouble until someone needed it. */
1571 build_debug_section (bfd
*abfd
, asection
** sect_return
)
1573 char *debug_section
;
1575 bfd_size_type sec_size
;
1577 asection
*sect
= bfd_get_section_by_name (abfd
, ".debug");
1581 bfd_set_error (bfd_error_no_debug_section
);
1585 /* Seek to the beginning of the `.debug' section and read it.
1586 Save the current position first; it is needed by our caller.
1587 Then read debug section and reset the file pointer. */
1589 position
= bfd_tell (abfd
);
1590 if (bfd_seek (abfd
, sect
->filepos
, SEEK_SET
) != 0)
1593 sec_size
= sect
->size
;
1594 debug_section
= (char *) _bfd_alloc_and_read (abfd
, sec_size
, sec_size
);
1595 if (debug_section
== NULL
)
1598 if (bfd_seek (abfd
, position
, SEEK_SET
) != 0)
1601 * sect_return
= sect
;
1602 return debug_section
;
1605 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
1606 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
1607 be \0-terminated. */
1610 copy_name (bfd
*abfd
, char *name
, size_t maxlen
)
1615 for (len
= 0; len
< maxlen
; ++len
)
1616 if (name
[len
] == '\0')
1619 if ((newname
= (char *) bfd_alloc (abfd
, (bfd_size_type
) len
+ 1)) == NULL
)
1622 strncpy (newname
, name
, len
);
1623 newname
[len
] = '\0';
1627 /* Read in the external symbols. */
1630 _bfd_coff_get_external_symbols (bfd
*abfd
)
1636 if (obj_coff_external_syms (abfd
) != NULL
)
1639 symesz
= bfd_coff_symesz (abfd
);
1640 if (_bfd_mul_overflow (obj_raw_syment_count (abfd
), symesz
, &size
))
1642 bfd_set_error (bfd_error_file_truncated
);
1649 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
1651 syms
= _bfd_malloc_and_read (abfd
, size
, size
);
1652 obj_coff_external_syms (abfd
) = syms
;
1653 return syms
!= NULL
;
1656 /* Read in the external strings. The strings are not loaded until
1657 they are needed. This is because we have no simple way of
1658 detecting a missing string table in an archive. If the strings
1659 are loaded then the STRINGS and STRINGS_LEN fields in the
1660 coff_tdata structure will be set. */
1663 _bfd_coff_read_string_table (bfd
*abfd
)
1665 char extstrsize
[STRING_SIZE_SIZE
];
1666 bfd_size_type strsize
;
1671 if (obj_coff_strings (abfd
) != NULL
)
1672 return obj_coff_strings (abfd
);
1674 if (obj_sym_filepos (abfd
) == 0)
1676 bfd_set_error (bfd_error_no_symbols
);
1680 pos
= obj_sym_filepos (abfd
);
1681 pos
+= obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
1682 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
1685 if (bfd_bread (extstrsize
, (bfd_size_type
) sizeof extstrsize
, abfd
)
1686 != sizeof extstrsize
)
1688 if (bfd_get_error () != bfd_error_file_truncated
)
1691 /* There is no string table. */
1692 strsize
= STRING_SIZE_SIZE
;
1696 #if STRING_SIZE_SIZE == 4
1697 strsize
= H_GET_32 (abfd
, extstrsize
);
1699 #error Change H_GET_32
1703 filesize
= bfd_get_file_size (abfd
);
1704 if (strsize
< STRING_SIZE_SIZE
1705 || (filesize
!= 0 && strsize
> filesize
))
1708 /* xgettext: c-format */
1709 (_("%pB: bad string table size %" PRIu64
), abfd
, (uint64_t) strsize
);
1710 bfd_set_error (bfd_error_bad_value
);
1714 strings
= (char *) bfd_malloc (strsize
+ 1);
1715 if (strings
== NULL
)
1718 /* PR 17521 file: 079-54929-0.004.
1719 A corrupt file could contain an index that points into the first
1720 STRING_SIZE_SIZE bytes of the string table, so make sure that
1722 memset (strings
, 0, STRING_SIZE_SIZE
);
1724 if (bfd_bread (strings
+ STRING_SIZE_SIZE
, strsize
- STRING_SIZE_SIZE
, abfd
)
1725 != strsize
- STRING_SIZE_SIZE
)
1731 obj_coff_strings (abfd
) = strings
;
1732 obj_coff_strings_len (abfd
) = strsize
;
1733 /* Terminate the string table, just in case. */
1734 strings
[strsize
] = 0;
1738 /* Free up the external symbols and strings read from a COFF file. */
1741 _bfd_coff_free_symbols (bfd
*abfd
)
1743 if (! bfd_family_coff (abfd
))
1746 if (obj_coff_external_syms (abfd
) != NULL
1747 && ! obj_coff_keep_syms (abfd
))
1749 free (obj_coff_external_syms (abfd
));
1750 obj_coff_external_syms (abfd
) = NULL
;
1753 if (obj_coff_strings (abfd
) != NULL
1754 && ! obj_coff_keep_strings (abfd
))
1756 free (obj_coff_strings (abfd
));
1757 obj_coff_strings (abfd
) = NULL
;
1758 obj_coff_strings_len (abfd
) = 0;
1764 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
1765 knit the symbol names into a normalized form. By normalized here I
1766 mean that all symbols have an n_offset pointer that points to a null-
1767 terminated string. */
1769 combined_entry_type
*
1770 coff_get_normalized_symtab (bfd
*abfd
)
1772 combined_entry_type
*internal
;
1773 combined_entry_type
*internal_ptr
;
1774 combined_entry_type
*symbol_ptr
;
1775 combined_entry_type
*internal_end
;
1779 const char *string_table
= NULL
;
1780 asection
* debug_sec
= NULL
;
1781 char *debug_sec_data
= NULL
;
1784 if (obj_raw_syments (abfd
) != NULL
)
1785 return obj_raw_syments (abfd
);
1787 if (! _bfd_coff_get_external_symbols (abfd
))
1790 size
= obj_raw_syment_count (abfd
);
1791 /* Check for integer overflow. */
1792 if (size
> (bfd_size_type
) -1 / sizeof (combined_entry_type
))
1794 size
*= sizeof (combined_entry_type
);
1795 internal
= (combined_entry_type
*) bfd_zalloc (abfd
, size
);
1796 if (internal
== NULL
&& size
!= 0)
1798 internal_end
= internal
+ obj_raw_syment_count (abfd
);
1800 raw_src
= (char *) obj_coff_external_syms (abfd
);
1802 /* Mark the end of the symbols. */
1803 symesz
= bfd_coff_symesz (abfd
);
1804 raw_end
= (char *) raw_src
+ obj_raw_syment_count (abfd
) * symesz
;
1806 /* FIXME SOMEDAY. A string table size of zero is very weird, but
1807 probably possible. If one shows up, it will probably kill us. */
1809 /* Swap all the raw entries. */
1810 for (internal_ptr
= internal
;
1812 raw_src
+= symesz
, internal_ptr
++)
1816 bfd_coff_swap_sym_in (abfd
, (void *) raw_src
,
1817 (void *) & internal_ptr
->u
.syment
);
1818 symbol_ptr
= internal_ptr
;
1819 internal_ptr
->is_sym
= TRUE
;
1822 i
< symbol_ptr
->u
.syment
.n_numaux
;
1828 /* PR 17512: Prevent buffer overrun. */
1829 if (raw_src
>= raw_end
|| internal_ptr
>= internal_end
)
1831 bfd_release (abfd
, internal
);
1835 bfd_coff_swap_aux_in (abfd
, (void *) raw_src
,
1836 symbol_ptr
->u
.syment
.n_type
,
1837 symbol_ptr
->u
.syment
.n_sclass
,
1838 (int) i
, symbol_ptr
->u
.syment
.n_numaux
,
1839 &(internal_ptr
->u
.auxent
));
1841 internal_ptr
->is_sym
= FALSE
;
1842 coff_pointerize_aux (abfd
, internal
, symbol_ptr
, i
,
1843 internal_ptr
, internal_end
);
1847 /* Free the raw symbols. */
1848 if (obj_coff_external_syms (abfd
) != NULL
1849 && ! obj_coff_keep_syms (abfd
))
1851 free (obj_coff_external_syms (abfd
));
1852 obj_coff_external_syms (abfd
) = NULL
;
1855 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
1858 BFD_ASSERT (internal_ptr
->is_sym
);
1860 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
1861 && internal_ptr
->u
.syment
.n_numaux
> 0)
1863 combined_entry_type
* aux
= internal_ptr
+ 1;
1865 /* Make a file symbol point to the name in the auxent, since
1866 the text ".file" is redundant. */
1867 BFD_ASSERT (! aux
->is_sym
);
1869 if (aux
->u
.auxent
.x_file
.x_n
.x_zeroes
== 0)
1871 /* The filename is a long one, point into the string table. */
1872 if (string_table
== NULL
)
1874 string_table
= _bfd_coff_read_string_table (abfd
);
1875 if (string_table
== NULL
)
1879 if ((bfd_size_type
)(aux
->u
.auxent
.x_file
.x_n
.x_offset
)
1880 >= obj_coff_strings_len (abfd
))
1881 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1883 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1884 (bfd_hostptr_t
) (string_table
+ (aux
->u
.auxent
.x_file
.x_n
.x_offset
));
1888 /* Ordinary short filename, put into memory anyway. The
1889 Microsoft PE tools sometimes store a filename in
1890 multiple AUX entries. */
1891 if (internal_ptr
->u
.syment
.n_numaux
> 1
1892 && coff_data (abfd
)->pe
)
1893 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1896 aux
->u
.auxent
.x_file
.x_fname
,
1897 internal_ptr
->u
.syment
.n_numaux
* symesz
);
1899 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1902 aux
->u
.auxent
.x_file
.x_fname
,
1903 (size_t) bfd_coff_filnmlen (abfd
)));
1908 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0)
1910 /* This is a "short" name. Make it long. */
1914 /* Find the length of this string without walking into memory
1916 for (i
= 0; i
< 8; ++i
)
1917 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0')
1920 newstring
= (char *) bfd_zalloc (abfd
, (bfd_size_type
) (i
+ 1));
1921 if (newstring
== NULL
)
1923 strncpy (newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
);
1924 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) newstring
;
1925 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1927 else if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
== 0)
1928 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) "";
1929 else if (!bfd_coff_symname_in_debug (abfd
, &internal_ptr
->u
.syment
))
1931 /* Long name already. Point symbol at the string in the
1933 if (string_table
== NULL
)
1935 string_table
= _bfd_coff_read_string_table (abfd
);
1936 if (string_table
== NULL
)
1939 if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
>= obj_coff_strings_len (abfd
)
1940 || string_table
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
< string_table
)
1941 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1943 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1946 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
));
1950 /* Long name in debug section. Very similar. */
1951 if (debug_sec_data
== NULL
)
1952 debug_sec_data
= build_debug_section (abfd
, & debug_sec
);
1953 if (debug_sec_data
!= NULL
)
1955 BFD_ASSERT (debug_sec
!= NULL
);
1956 /* PR binutils/17512: Catch out of range offsets into the debug data. */
1957 if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
> debug_sec
->size
1958 || debug_sec_data
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
< debug_sec_data
)
1959 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1961 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
)
1962 (debug_sec_data
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
1965 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) "";
1968 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
1971 obj_raw_syments (abfd
) = internal
;
1972 BFD_ASSERT (obj_raw_syment_count (abfd
)
1973 == (unsigned int) (internal_ptr
- internal
));
1979 coff_get_reloc_upper_bound (bfd
*abfd
, sec_ptr asect
)
1981 if (bfd_get_format (abfd
) != bfd_object
)
1983 bfd_set_error (bfd_error_invalid_operation
);
1986 #if SIZEOF_LONG == SIZEOF_INT
1987 if (asect
->reloc_count
>= LONG_MAX
/ sizeof (arelent
*))
1989 bfd_set_error (bfd_error_file_too_big
);
1993 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
1997 coff_make_empty_symbol (bfd
*abfd
)
1999 size_t amt
= sizeof (coff_symbol_type
);
2000 coff_symbol_type
*new_symbol
= (coff_symbol_type
*) bfd_zalloc (abfd
, amt
);
2002 if (new_symbol
== NULL
)
2004 new_symbol
->symbol
.section
= 0;
2005 new_symbol
->native
= NULL
;
2006 new_symbol
->lineno
= NULL
;
2007 new_symbol
->done_lineno
= FALSE
;
2008 new_symbol
->symbol
.the_bfd
= abfd
;
2010 return & new_symbol
->symbol
;
2013 /* Make a debugging symbol. */
2016 coff_bfd_make_debug_symbol (bfd
*abfd
,
2017 void * ptr ATTRIBUTE_UNUSED
,
2018 unsigned long sz ATTRIBUTE_UNUSED
)
2020 size_t amt
= sizeof (coff_symbol_type
);
2021 coff_symbol_type
*new_symbol
= (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
2023 if (new_symbol
== NULL
)
2025 /* @@ The 10 is a guess at a plausible maximum number of aux entries
2026 (but shouldn't be a constant). */
2027 amt
= sizeof (combined_entry_type
) * 10;
2028 new_symbol
->native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
2029 if (!new_symbol
->native
)
2031 new_symbol
->native
->is_sym
= TRUE
;
2032 new_symbol
->symbol
.section
= bfd_abs_section_ptr
;
2033 new_symbol
->symbol
.flags
= BSF_DEBUGGING
;
2034 new_symbol
->lineno
= NULL
;
2035 new_symbol
->done_lineno
= FALSE
;
2036 new_symbol
->symbol
.the_bfd
= abfd
;
2038 return & new_symbol
->symbol
;
2042 coff_get_symbol_info (bfd
*abfd
, asymbol
*symbol
, symbol_info
*ret
)
2044 bfd_symbol_info (symbol
, ret
);
2046 if (coffsymbol (symbol
)->native
!= NULL
2047 && coffsymbol (symbol
)->native
->fix_value
2048 && coffsymbol (symbol
)->native
->is_sym
)
2049 ret
->value
= coffsymbol (symbol
)->native
->u
.syment
.n_value
-
2050 (bfd_hostptr_t
) obj_raw_syments (abfd
);
2053 /* Print out information about COFF symbol. */
2056 coff_print_symbol (bfd
*abfd
,
2059 bfd_print_symbol_type how
)
2061 FILE * file
= (FILE *) filep
;
2065 case bfd_print_symbol_name
:
2066 fprintf (file
, "%s", symbol
->name
);
2069 case bfd_print_symbol_more
:
2070 fprintf (file
, "coff %s %s",
2071 coffsymbol (symbol
)->native
? "n" : "g",
2072 coffsymbol (symbol
)->lineno
? "l" : " ");
2075 case bfd_print_symbol_all
:
2076 if (coffsymbol (symbol
)->native
)
2080 combined_entry_type
*combined
= coffsymbol (symbol
)->native
;
2081 combined_entry_type
*root
= obj_raw_syments (abfd
);
2082 struct lineno_cache_entry
*l
= coffsymbol (symbol
)->lineno
;
2084 fprintf (file
, "[%3ld]", (long) (combined
- root
));
2086 /* PR 17512: file: 079-33786-0.001:0.1. */
2087 if (combined
< obj_raw_syments (abfd
)
2088 || combined
>= obj_raw_syments (abfd
) + obj_raw_syment_count (abfd
))
2090 fprintf (file
, _("<corrupt info> %s"), symbol
->name
);
2094 BFD_ASSERT (combined
->is_sym
);
2095 if (! combined
->fix_value
)
2096 val
= (bfd_vma
) combined
->u
.syment
.n_value
;
2098 val
= combined
->u
.syment
.n_value
- (bfd_hostptr_t
) root
;
2100 fprintf (file
, "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x",
2101 combined
->u
.syment
.n_scnum
,
2102 combined
->u
.syment
.n_flags
,
2103 combined
->u
.syment
.n_type
,
2104 combined
->u
.syment
.n_sclass
,
2105 combined
->u
.syment
.n_numaux
);
2106 bfd_fprintf_vma (abfd
, file
, val
);
2107 fprintf (file
, " %s", symbol
->name
);
2109 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
2111 combined_entry_type
*auxp
= combined
+ aux
+ 1;
2114 BFD_ASSERT (! auxp
->is_sym
);
2116 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.p
- root
;
2118 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.l
;
2120 fprintf (file
, "\n");
2122 if (bfd_coff_print_aux (abfd
, file
, root
, combined
, auxp
, aux
))
2125 switch (combined
->u
.syment
.n_sclass
)
2128 fprintf (file
, "File ");
2132 if (combined
->u
.syment
.n_type
== T_NULL
)
2133 /* Probably a section symbol ? */
2135 fprintf (file
, "AUX scnlen 0x%lx nreloc %d nlnno %d",
2136 (unsigned long) auxp
->u
.auxent
.x_scn
.x_scnlen
,
2137 auxp
->u
.auxent
.x_scn
.x_nreloc
,
2138 auxp
->u
.auxent
.x_scn
.x_nlinno
);
2139 if (auxp
->u
.auxent
.x_scn
.x_checksum
!= 0
2140 || auxp
->u
.auxent
.x_scn
.x_associated
!= 0
2141 || auxp
->u
.auxent
.x_scn
.x_comdat
!= 0)
2142 fprintf (file
, " checksum 0x%lx assoc %d comdat %d",
2143 auxp
->u
.auxent
.x_scn
.x_checksum
,
2144 auxp
->u
.auxent
.x_scn
.x_associated
,
2145 auxp
->u
.auxent
.x_scn
.x_comdat
);
2151 if (ISFCN (combined
->u
.syment
.n_type
))
2156 next
= (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2159 next
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2160 llnos
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
2162 "AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld",
2164 (unsigned long) auxp
->u
.auxent
.x_sym
.x_misc
.x_fsize
,
2170 fprintf (file
, "AUX lnno %d size 0x%x tagndx %ld",
2171 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
2172 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
,
2175 fprintf (file
, " endndx %ld",
2177 (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2185 fprintf (file
, "\n%s :", l
->u
.sym
->name
);
2187 while (l
->line_number
)
2189 if (l
->line_number
> 0)
2191 fprintf (file
, "\n%4d : ", l
->line_number
);
2192 bfd_fprintf_vma (abfd
, file
, l
->u
.offset
+ symbol
->section
->vma
);
2200 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
2201 fprintf (file
, " %-5s %s %s %s",
2202 symbol
->section
->name
,
2203 coffsymbol (symbol
)->native
? "n" : "g",
2204 coffsymbol (symbol
)->lineno
? "l" : " ",
2210 /* Return whether a symbol name implies a local symbol. In COFF,
2211 local symbols generally start with ``.L''. Most targets use this
2212 function for the is_local_label_name entry point, but some may
2216 _bfd_coff_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
2219 return name
[0] == '.' && name
[1] == 'L';
2222 /* Provided a BFD, a section and an offset (in bytes, not octets) into the
2223 section, calculate and return the name of the source file and the line
2224 nearest to the wanted location. */
2227 coff_find_nearest_line_with_names (bfd
*abfd
,
2231 const char **filename_ptr
,
2232 const char **functionname_ptr
,
2233 unsigned int *line_ptr
,
2234 const struct dwarf_debug_section
*debug_sections
)
2238 unsigned int line_base
;
2239 coff_data_type
*cof
= coff_data (abfd
);
2240 /* Run through the raw syments if available. */
2241 combined_entry_type
*p
;
2242 combined_entry_type
*pend
;
2244 struct coff_section_tdata
*sec_data
;
2247 /* Before looking through the symbol table, try to use a .stab
2248 section to find the information. */
2249 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2250 &found
, filename_ptr
,
2251 functionname_ptr
, line_ptr
,
2252 &coff_data(abfd
)->line_info
))
2258 /* Also try examining DWARF2 debugging information. */
2259 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
2260 filename_ptr
, functionname_ptr
,
2261 line_ptr
, NULL
, debug_sections
,
2262 &coff_data(abfd
)->dwarf2_find_line_info
))
2265 sec_data
= coff_section_data (abfd
, section
);
2267 /* If the DWARF lookup failed, but there is DWARF information available
2268 then the problem might be that the file has been rebased. This tool
2269 changes the VMAs of all the sections, but it does not update the DWARF
2270 information. So try again, using a bias against the address sought. */
2271 if (coff_data (abfd
)->dwarf2_find_line_info
!= NULL
)
2273 bfd_signed_vma bias
= 0;
2275 /* Create a cache of the result for the next call. */
2276 if (sec_data
== NULL
&& section
->owner
== abfd
)
2278 amt
= sizeof (struct coff_section_tdata
);
2279 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
2280 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2283 if (sec_data
!= NULL
&& sec_data
->saved_bias
)
2284 bias
= sec_data
->saved_bias
;
2287 bias
= _bfd_dwarf2_find_symbol_bias (symbols
,
2288 & coff_data (abfd
)->dwarf2_find_line_info
);
2292 sec_data
->saved_bias
= TRUE
;
2293 sec_data
->bias
= bias
;
2298 && _bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
,
2300 filename_ptr
, functionname_ptr
,
2301 line_ptr
, NULL
, debug_sections
,
2302 &coff_data(abfd
)->dwarf2_find_line_info
))
2307 *functionname_ptr
= 0;
2310 /* Don't try and find line numbers in a non coff file. */
2311 if (!bfd_family_coff (abfd
))
2317 /* Find the first C_FILE symbol. */
2318 p
= cof
->raw_syments
;
2322 pend
= p
+ cof
->raw_syment_count
;
2325 BFD_ASSERT (p
->is_sym
);
2326 if (p
->u
.syment
.n_sclass
== C_FILE
)
2328 p
+= 1 + p
->u
.syment
.n_numaux
;
2336 /* Look through the C_FILE symbols to find the best one. */
2337 sec_vma
= bfd_section_vma (section
);
2338 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2339 maxdiff
= (bfd_vma
) 0 - (bfd_vma
) 1;
2343 combined_entry_type
*p2
;
2345 for (p2
= p
+ 1 + p
->u
.syment
.n_numaux
;
2347 p2
+= 1 + p2
->u
.syment
.n_numaux
)
2349 BFD_ASSERT (p2
->is_sym
);
2350 if (p2
->u
.syment
.n_scnum
> 0
2352 == coff_section_from_bfd_index (abfd
,
2353 p2
->u
.syment
.n_scnum
)))
2355 if (p2
->u
.syment
.n_sclass
== C_FILE
)
2364 file_addr
= (bfd_vma
) p2
->u
.syment
.n_value
;
2365 /* PR 11512: Include the section address of the function name symbol. */
2366 if (p2
->u
.syment
.n_scnum
> 0)
2367 file_addr
+= coff_section_from_bfd_index (abfd
,
2368 p2
->u
.syment
.n_scnum
)->vma
;
2369 /* We use <= MAXDIFF here so that if we get a zero length
2370 file, we actually use the next file entry. */
2372 && offset
+ sec_vma
>= file_addr
2373 && offset
+ sec_vma
- file_addr
<= maxdiff
)
2375 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2376 maxdiff
= offset
+ sec_vma
- p2
->u
.syment
.n_value
;
2379 if (p
->u
.syment
.n_value
>= cof
->raw_syment_count
)
2382 /* Avoid endless loops on erroneous files by ensuring that
2383 we always move forward in the file. */
2384 if (p
>= cof
->raw_syments
+ p
->u
.syment
.n_value
)
2387 p
= cof
->raw_syments
+ p
->u
.syment
.n_value
;
2388 if (!p
->is_sym
|| p
->u
.syment
.n_sclass
!= C_FILE
)
2393 if (section
->lineno_count
== 0)
2395 *functionname_ptr
= NULL
;
2400 /* Now wander though the raw linenumbers of the section.
2401 If we have been called on this section before, and the offset
2402 we want is further down then we can prime the lookup loop. */
2403 if (sec_data
!= NULL
2405 && offset
>= sec_data
->offset
)
2408 *functionname_ptr
= sec_data
->function
;
2409 line_base
= sec_data
->line_base
;
2417 if (section
->lineno
!= NULL
)
2419 bfd_vma last_value
= 0;
2421 l
= §ion
->lineno
[i
];
2423 for (; i
< section
->lineno_count
; i
++)
2425 if (l
->line_number
== 0)
2427 /* Get the symbol this line number points at. */
2428 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
2429 if (coff
->symbol
.value
> offset
)
2432 *functionname_ptr
= coff
->symbol
.name
;
2433 last_value
= coff
->symbol
.value
;
2436 combined_entry_type
*s
= coff
->native
;
2438 BFD_ASSERT (s
->is_sym
);
2439 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2441 /* In XCOFF a debugging symbol can follow the
2443 if (s
->u
.syment
.n_scnum
== N_DEBUG
)
2444 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2446 /* S should now point to the .bf of the function. */
2447 if (s
->u
.syment
.n_numaux
)
2449 /* The linenumber is stored in the auxent. */
2450 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
2452 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
2453 *line_ptr
= line_base
;
2459 if (l
->u
.offset
> offset
)
2461 *line_ptr
= l
->line_number
+ line_base
- 1;
2466 /* If we fell off the end of the loop, then assume that this
2467 symbol has no line number info. Otherwise, symbols with no
2468 line number info get reported with the line number of the
2469 last line of the last symbol which does have line number
2470 info. We use 0x100 as a slop to account for cases where the
2471 last line has executable code. */
2472 if (i
>= section
->lineno_count
2474 && offset
- last_value
> 0x100)
2476 *functionname_ptr
= NULL
;
2481 /* Cache the results for the next call. */
2482 if (sec_data
== NULL
&& section
->owner
== abfd
)
2484 amt
= sizeof (struct coff_section_tdata
);
2485 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
2486 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2489 if (sec_data
!= NULL
)
2491 sec_data
->offset
= offset
;
2492 sec_data
->i
= i
- 1;
2493 sec_data
->function
= *functionname_ptr
;
2494 sec_data
->line_base
= line_base
;
2501 coff_find_nearest_line (bfd
*abfd
,
2505 const char **filename_ptr
,
2506 const char **functionname_ptr
,
2507 unsigned int *line_ptr
,
2508 unsigned int *discriminator_ptr
)
2510 if (discriminator_ptr
)
2511 *discriminator_ptr
= 0;
2512 return coff_find_nearest_line_with_names (abfd
, symbols
, section
, offset
,
2513 filename_ptr
, functionname_ptr
,
2514 line_ptr
, dwarf_debug_sections
);
2518 coff_find_inliner_info (bfd
*abfd
,
2519 const char **filename_ptr
,
2520 const char **functionname_ptr
,
2521 unsigned int *line_ptr
)
2525 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
2526 functionname_ptr
, line_ptr
,
2527 &coff_data(abfd
)->dwarf2_find_line_info
);
2532 coff_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
2536 if (!bfd_link_relocatable (info
))
2537 size
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
2539 size
= bfd_coff_filhsz (abfd
);
2541 size
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
2545 /* Change the class of a coff symbol held by BFD. */
2548 bfd_coff_set_symbol_class (bfd
* abfd
,
2550 unsigned int symbol_class
)
2552 coff_symbol_type
* csym
;
2554 csym
= coff_symbol_from (symbol
);
2557 bfd_set_error (bfd_error_invalid_operation
);
2560 else if (csym
->native
== NULL
)
2562 /* This is an alien symbol which no native coff backend data.
2563 We cheat here by creating a fake native entry for it and
2564 then filling in the class. This code is based on that in
2565 coff_write_alien_symbol(). */
2567 combined_entry_type
* native
;
2568 size_t amt
= sizeof (* native
);
2570 native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
2574 native
->is_sym
= TRUE
;
2575 native
->u
.syment
.n_type
= T_NULL
;
2576 native
->u
.syment
.n_sclass
= symbol_class
;
2578 if (bfd_is_und_section (symbol
->section
))
2580 native
->u
.syment
.n_scnum
= N_UNDEF
;
2581 native
->u
.syment
.n_value
= symbol
->value
;
2583 else if (bfd_is_com_section (symbol
->section
))
2585 native
->u
.syment
.n_scnum
= N_UNDEF
;
2586 native
->u
.syment
.n_value
= symbol
->value
;
2590 native
->u
.syment
.n_scnum
=
2591 symbol
->section
->output_section
->target_index
;
2592 native
->u
.syment
.n_value
= (symbol
->value
2593 + symbol
->section
->output_offset
);
2594 if (! obj_pe (abfd
))
2595 native
->u
.syment
.n_value
+= symbol
->section
->output_section
->vma
;
2597 /* Copy the any flags from the file header into the symbol.
2599 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (& csym
->symbol
)->flags
;
2602 csym
->native
= native
;
2605 csym
->native
->u
.syment
.n_sclass
= symbol_class
;
2611 _bfd_coff_section_already_linked (bfd
*abfd
,
2613 struct bfd_link_info
*info
)
2616 const char *name
, *key
;
2617 struct bfd_section_already_linked
*l
;
2618 struct bfd_section_already_linked_hash_entry
*already_linked_list
;
2619 struct coff_comdat_info
*s_comdat
;
2621 if (sec
->output_section
== bfd_abs_section_ptr
)
2625 if ((flags
& SEC_LINK_ONCE
) == 0)
2628 /* The COFF backend linker doesn't support group sections. */
2629 if ((flags
& SEC_GROUP
) != 0)
2632 name
= bfd_section_name (sec
);
2633 s_comdat
= bfd_coff_get_comdat_section (abfd
, sec
);
2635 if (s_comdat
!= NULL
)
2636 key
= s_comdat
->name
;
2639 if (CONST_STRNEQ (name
, ".gnu.linkonce.")
2640 && (key
= strchr (name
+ sizeof (".gnu.linkonce.") - 1, '.')) != NULL
)
2643 /* FIXME: gcc as of 2011-09 emits sections like .text$<key>,
2644 .xdata$<key> and .pdata$<key> only the first of which has a
2645 comdat key. Should these all match the LTO IR key? */
2649 already_linked_list
= bfd_section_already_linked_table_lookup (key
);
2651 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
2653 struct coff_comdat_info
*l_comdat
;
2655 l_comdat
= bfd_coff_get_comdat_section (l
->sec
->owner
, l
->sec
);
2657 /* The section names must match, and both sections must be
2658 comdat and have the same comdat name, or both sections must
2659 be non-comdat. LTO IR plugin sections are an exception. They
2660 are always named .gnu.linkonce.t.<key> (<key> is some string)
2661 and match any comdat section with comdat name of <key>, and
2662 any linkonce section with the same suffix, ie.
2663 .gnu.linkonce.*.<key>. */
2664 if (((s_comdat
!= NULL
) == (l_comdat
!= NULL
)
2665 && strcmp (name
, l
->sec
->name
) == 0)
2666 || (l
->sec
->owner
->flags
& BFD_PLUGIN
) != 0)
2668 /* The section has already been linked. See if we should
2670 return _bfd_handle_already_linked (sec
, l
, info
);
2674 /* This is the first section with this name. Record it. */
2675 if (!bfd_section_already_linked_table_insert (already_linked_list
, sec
))
2676 info
->callbacks
->einfo (_("%F%P: already_linked_table: %E\n"));
2680 /* Initialize COOKIE for input bfd ABFD. */
2683 init_reloc_cookie (struct coff_reloc_cookie
*cookie
,
2684 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2687 /* Sometimes the symbol table does not yet have been loaded here. */
2688 bfd_coff_slurp_symbol_table (abfd
);
2690 cookie
->abfd
= abfd
;
2691 cookie
->sym_hashes
= obj_coff_sym_hashes (abfd
);
2693 cookie
->symbols
= obj_symbols (abfd
);
2698 /* Free the memory allocated by init_reloc_cookie, if appropriate. */
2701 fini_reloc_cookie (struct coff_reloc_cookie
*cookie ATTRIBUTE_UNUSED
,
2702 bfd
*abfd ATTRIBUTE_UNUSED
)
2704 /* Nothing to do. */
2707 /* Initialize the relocation information in COOKIE for input section SEC
2708 of input bfd ABFD. */
2711 init_reloc_cookie_rels (struct coff_reloc_cookie
*cookie
,
2712 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2716 if (sec
->reloc_count
== 0)
2718 cookie
->rels
= NULL
;
2719 cookie
->relend
= NULL
;
2724 cookie
->rels
= _bfd_coff_read_internal_relocs (abfd
, sec
, FALSE
, NULL
, 0, NULL
);
2726 if (cookie
->rels
== NULL
)
2729 cookie
->rel
= cookie
->rels
;
2730 cookie
->relend
= (cookie
->rels
+ sec
->reloc_count
);
2734 /* Free the memory allocated by init_reloc_cookie_rels,
2738 fini_reloc_cookie_rels (struct coff_reloc_cookie
*cookie
,
2742 /* PR 20401. The relocs may not have been cached, so check first.
2743 If the relocs were loaded by init_reloc_cookie_rels() then this
2744 will be the case. FIXME: Would performance be improved if the
2745 relocs *were* cached ? */
2746 && coff_section_data (NULL
, sec
)
2747 && coff_section_data (NULL
, sec
)->relocs
!= cookie
->rels
)
2748 free (cookie
->rels
);
2751 /* Initialize the whole of COOKIE for input section SEC. */
2754 init_reloc_cookie_for_section (struct coff_reloc_cookie
*cookie
,
2755 struct bfd_link_info
*info
,
2758 if (!init_reloc_cookie (cookie
, info
, sec
->owner
))
2761 if (!init_reloc_cookie_rels (cookie
, info
, sec
->owner
, sec
))
2763 fini_reloc_cookie (cookie
, sec
->owner
);
2769 /* Free the memory allocated by init_reloc_cookie_for_section,
2773 fini_reloc_cookie_for_section (struct coff_reloc_cookie
*cookie
,
2776 fini_reloc_cookie_rels (cookie
, sec
);
2777 fini_reloc_cookie (cookie
, sec
->owner
);
2781 _bfd_coff_gc_mark_hook (asection
*sec
,
2782 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2783 struct internal_reloc
*rel ATTRIBUTE_UNUSED
,
2784 struct coff_link_hash_entry
*h
,
2785 struct internal_syment
*sym
)
2789 switch (h
->root
.type
)
2791 case bfd_link_hash_defined
:
2792 case bfd_link_hash_defweak
:
2793 return h
->root
.u
.def
.section
;
2795 case bfd_link_hash_common
:
2796 return h
->root
.u
.c
.p
->section
;
2798 case bfd_link_hash_undefweak
:
2799 if (h
->symbol_class
== C_NT_WEAK
&& h
->numaux
== 1)
2801 /* PE weak externals. A weak symbol may include an auxiliary
2802 record indicating that if the weak symbol is not resolved,
2803 another external symbol is used instead. */
2804 struct coff_link_hash_entry
*h2
=
2805 h
->auxbfd
->tdata
.coff_obj_data
->sym_hashes
[
2806 h
->aux
->x_sym
.x_tagndx
.l
];
2808 if (h2
&& h2
->root
.type
!= bfd_link_hash_undefined
)
2809 return h2
->root
.u
.def
.section
;
2813 case bfd_link_hash_undefined
:
2820 return coff_section_from_bfd_index (sec
->owner
, sym
->n_scnum
);
2823 /* COOKIE->rel describes a relocation against section SEC, which is
2824 a section we've decided to keep. Return the section that contains
2825 the relocation symbol, or NULL if no section contains it. */
2828 _bfd_coff_gc_mark_rsec (struct bfd_link_info
*info
, asection
*sec
,
2829 coff_gc_mark_hook_fn gc_mark_hook
,
2830 struct coff_reloc_cookie
*cookie
)
2832 struct coff_link_hash_entry
*h
;
2834 h
= cookie
->sym_hashes
[cookie
->rel
->r_symndx
];
2837 while (h
->root
.type
== bfd_link_hash_indirect
2838 || h
->root
.type
== bfd_link_hash_warning
)
2839 h
= (struct coff_link_hash_entry
*) h
->root
.u
.i
.link
;
2841 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, h
, NULL
);
2844 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, NULL
,
2846 + obj_convert (sec
->owner
)[cookie
->rel
->r_symndx
])->native
->u
.syment
);
2849 static bfd_boolean _bfd_coff_gc_mark
2850 (struct bfd_link_info
*, asection
*, coff_gc_mark_hook_fn
);
2852 /* COOKIE->rel describes a relocation against section SEC, which is
2853 a section we've decided to keep. Mark the section that contains
2854 the relocation symbol. */
2857 _bfd_coff_gc_mark_reloc (struct bfd_link_info
*info
,
2859 coff_gc_mark_hook_fn gc_mark_hook
,
2860 struct coff_reloc_cookie
*cookie
)
2864 rsec
= _bfd_coff_gc_mark_rsec (info
, sec
, gc_mark_hook
, cookie
);
2865 if (rsec
&& !rsec
->gc_mark
)
2867 if (bfd_get_flavour (rsec
->owner
) != bfd_target_coff_flavour
)
2869 else if (!_bfd_coff_gc_mark (info
, rsec
, gc_mark_hook
))
2875 /* The mark phase of garbage collection. For a given section, mark
2876 it and any sections in this section's group, and all the sections
2877 which define symbols to which it refers. */
2880 _bfd_coff_gc_mark (struct bfd_link_info
*info
,
2882 coff_gc_mark_hook_fn gc_mark_hook
)
2884 bfd_boolean ret
= TRUE
;
2888 /* Look through the section relocs. */
2889 if ((sec
->flags
& SEC_RELOC
) != 0
2890 && sec
->reloc_count
> 0)
2892 struct coff_reloc_cookie cookie
;
2894 if (!init_reloc_cookie_for_section (&cookie
, info
, sec
))
2898 for (; cookie
.rel
< cookie
.relend
; cookie
.rel
++)
2900 if (!_bfd_coff_gc_mark_reloc (info
, sec
, gc_mark_hook
, &cookie
))
2906 fini_reloc_cookie_for_section (&cookie
, sec
);
2914 _bfd_coff_gc_mark_extra_sections (struct bfd_link_info
*info
,
2915 coff_gc_mark_hook_fn mark_hook ATTRIBUTE_UNUSED
)
2919 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
2922 bfd_boolean some_kept
;
2924 if (bfd_get_flavour (ibfd
) != bfd_target_coff_flavour
)
2927 /* Ensure all linker created sections are kept, and see whether
2928 any other section is already marked. */
2930 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
2932 if ((isec
->flags
& SEC_LINKER_CREATED
) != 0)
2934 else if (isec
->gc_mark
)
2938 /* If no section in this file will be kept, then we can
2939 toss out debug sections. */
2943 /* Keep debug and special sections like .comment when they are
2944 not part of a group, or when we have single-member groups. */
2945 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
2946 if ((isec
->flags
& SEC_DEBUGGING
) != 0
2947 || (isec
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0)
2953 /* Sweep symbols in swept sections. Called via coff_link_hash_traverse. */
2956 coff_gc_sweep_symbol (struct coff_link_hash_entry
*h
,
2957 void *data ATTRIBUTE_UNUSED
)
2959 if (h
->root
.type
== bfd_link_hash_warning
)
2960 h
= (struct coff_link_hash_entry
*) h
->root
.u
.i
.link
;
2962 if ((h
->root
.type
== bfd_link_hash_defined
2963 || h
->root
.type
== bfd_link_hash_defweak
)
2964 && !h
->root
.u
.def
.section
->gc_mark
2965 && !(h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
))
2967 /* Do our best to hide the symbol. */
2968 h
->root
.u
.def
.section
= bfd_und_section_ptr
;
2969 h
->symbol_class
= C_HIDDEN
;
2975 /* The sweep phase of garbage collection. Remove all garbage sections. */
2977 typedef bfd_boolean (*gc_sweep_hook_fn
)
2978 (bfd
*, struct bfd_link_info
*, asection
*, const struct internal_reloc
*);
2981 coff_gc_sweep (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
2985 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
2989 if (bfd_get_flavour (sub
) != bfd_target_coff_flavour
)
2992 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
2994 /* Keep debug and special sections. */
2995 if ((o
->flags
& (SEC_DEBUGGING
| SEC_LINKER_CREATED
)) != 0
2996 || (o
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0)
2998 else if (CONST_STRNEQ (o
->name
, ".idata")
2999 || CONST_STRNEQ (o
->name
, ".pdata")
3000 || CONST_STRNEQ (o
->name
, ".xdata")
3001 || CONST_STRNEQ (o
->name
, ".rsrc"))
3007 /* Skip sweeping sections already excluded. */
3008 if (o
->flags
& SEC_EXCLUDE
)
3011 /* Since this is early in the link process, it is simple
3012 to remove a section from the output. */
3013 o
->flags
|= SEC_EXCLUDE
;
3015 if (info
->print_gc_sections
&& o
->size
!= 0)
3016 /* xgettext: c-format */
3017 _bfd_error_handler (_("removing unused section '%pA' in file '%pB'"),
3021 /* But we also have to update some of the relocation
3022 info we collected before. */
3024 && (o
->flags
& SEC_RELOC
) != 0
3025 && o
->reloc_count
> 0
3026 && !bfd_is_abs_section (o
->output_section
))
3028 struct internal_reloc
*internal_relocs
;
3032 = _bfd_coff_link_read_relocs (o
->owner
, o
, NULL
, NULL
,
3034 if (internal_relocs
== NULL
)
3037 r
= (*gc_sweep_hook
) (o
->owner
, info
, o
, internal_relocs
);
3039 if (coff_section_data (o
)->relocs
!= internal_relocs
)
3040 free (internal_relocs
);
3049 /* Remove the symbols that were in the swept sections from the dynamic
3051 coff_link_hash_traverse (coff_hash_table (info
), coff_gc_sweep_symbol
,
3057 /* Keep all sections containing symbols undefined on the command-line,
3058 and the section containing the entry symbol. */
3061 _bfd_coff_gc_keep (struct bfd_link_info
*info
)
3063 struct bfd_sym_chain
*sym
;
3065 for (sym
= info
->gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
3067 struct coff_link_hash_entry
*h
;
3069 h
= coff_link_hash_lookup (coff_hash_table (info
), sym
->name
,
3070 FALSE
, FALSE
, FALSE
);
3073 && (h
->root
.type
== bfd_link_hash_defined
3074 || h
->root
.type
== bfd_link_hash_defweak
)
3075 && !bfd_is_abs_section (h
->root
.u
.def
.section
))
3076 h
->root
.u
.def
.section
->flags
|= SEC_KEEP
;
3080 /* Do mark and sweep of unused sections. */
3083 bfd_coff_gc_sections (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
3087 /* FIXME: Should we implement this? */
3089 const bfd_coff_backend_data
*bed
= coff_backend_info (abfd
);
3091 if (!bed
->can_gc_sections
3092 || !is_coff_hash_table (info
->hash
))
3094 _bfd_error_handler(_("warning: gc-sections option ignored"));
3099 _bfd_coff_gc_keep (info
);
3101 /* Grovel through relocs to find out who stays ... */
3102 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3106 if (bfd_get_flavour (sub
) != bfd_target_coff_flavour
)
3109 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3111 if (((o
->flags
& (SEC_EXCLUDE
| SEC_KEEP
)) == SEC_KEEP
3112 || CONST_STRNEQ (o
->name
, ".vectors")
3113 || CONST_STRNEQ (o
->name
, ".ctors")
3114 || CONST_STRNEQ (o
->name
, ".dtors"))
3117 if (!_bfd_coff_gc_mark (info
, o
, _bfd_coff_gc_mark_hook
))
3123 /* Allow the backend to mark additional target specific sections. */
3124 _bfd_coff_gc_mark_extra_sections (info
, _bfd_coff_gc_mark_hook
);
3126 /* ... and mark SEC_EXCLUDE for those that go. */
3127 return coff_gc_sweep (abfd
, info
);
3130 /* Return name used to identify a comdat group. */
3133 bfd_coff_group_name (bfd
*abfd
, const asection
*sec
)
3135 struct coff_comdat_info
*ci
= bfd_coff_get_comdat_section (abfd
, sec
);
3142 _bfd_coff_close_and_cleanup (bfd
*abfd
)
3144 if (abfd
->format
== bfd_object
3145 && bfd_family_coff (abfd
)
3146 && coff_data (abfd
) != NULL
)
3149 Do not clear the keep_syms and keep_strings flags.
3150 These may have been set by pe_ILF_build_a_bfd() indicating
3151 that the syms and strings pointers are not to be freed. */
3152 if (!_bfd_coff_free_symbols (abfd
))
3155 return _bfd_generic_close_and_cleanup (abfd
);