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
);
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
;
312 return (const bfd_target
*) NULL
;
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
)
1637 if (obj_coff_external_syms (abfd
) != NULL
)
1640 /* Check for integer overflow and for unreasonable symbol counts. */
1641 filesize
= bfd_get_file_size (abfd
);
1642 symesz
= bfd_coff_symesz (abfd
);
1643 if (_bfd_mul_overflow (obj_raw_syment_count (abfd
), symesz
, &size
)
1644 || (filesize
!= 0 && size
> filesize
))
1646 bfd_set_error (bfd_error_file_truncated
);
1647 _bfd_error_handler (_("%pB: corrupt symbol count: %#" PRIx64
""),
1648 abfd
, (uint64_t) obj_raw_syment_count (abfd
));
1655 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
1657 syms
= _bfd_malloc_and_read (abfd
, size
, size
);
1658 obj_coff_external_syms (abfd
) = syms
;
1659 return syms
!= NULL
;
1662 /* Read in the external strings. The strings are not loaded until
1663 they are needed. This is because we have no simple way of
1664 detecting a missing string table in an archive. If the strings
1665 are loaded then the STRINGS and STRINGS_LEN fields in the
1666 coff_tdata structure will be set. */
1669 _bfd_coff_read_string_table (bfd
*abfd
)
1671 char extstrsize
[STRING_SIZE_SIZE
];
1672 bfd_size_type strsize
;
1677 if (obj_coff_strings (abfd
) != NULL
)
1678 return obj_coff_strings (abfd
);
1680 if (obj_sym_filepos (abfd
) == 0)
1682 bfd_set_error (bfd_error_no_symbols
);
1686 pos
= obj_sym_filepos (abfd
);
1687 pos
+= obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
1688 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
1691 if (bfd_bread (extstrsize
, (bfd_size_type
) sizeof extstrsize
, abfd
)
1692 != sizeof extstrsize
)
1694 if (bfd_get_error () != bfd_error_file_truncated
)
1697 /* There is no string table. */
1698 strsize
= STRING_SIZE_SIZE
;
1702 #if STRING_SIZE_SIZE == 4
1703 strsize
= H_GET_32 (abfd
, extstrsize
);
1705 #error Change H_GET_32
1709 filesize
= bfd_get_file_size (abfd
);
1710 if (strsize
< STRING_SIZE_SIZE
1711 || (filesize
!= 0 && strsize
> filesize
))
1714 /* xgettext: c-format */
1715 (_("%pB: bad string table size %" PRIu64
), abfd
, (uint64_t) strsize
);
1716 bfd_set_error (bfd_error_bad_value
);
1720 strings
= (char *) bfd_malloc (strsize
+ 1);
1721 if (strings
== NULL
)
1724 /* PR 17521 file: 079-54929-0.004.
1725 A corrupt file could contain an index that points into the first
1726 STRING_SIZE_SIZE bytes of the string table, so make sure that
1728 memset (strings
, 0, STRING_SIZE_SIZE
);
1730 if (bfd_bread (strings
+ STRING_SIZE_SIZE
, strsize
- STRING_SIZE_SIZE
, abfd
)
1731 != strsize
- STRING_SIZE_SIZE
)
1737 obj_coff_strings (abfd
) = strings
;
1738 obj_coff_strings_len (abfd
) = strsize
;
1739 /* Terminate the string table, just in case. */
1740 strings
[strsize
] = 0;
1744 /* Free up the external symbols and strings read from a COFF file. */
1747 _bfd_coff_free_symbols (bfd
*abfd
)
1749 if (! bfd_family_coff (abfd
))
1752 if (obj_coff_external_syms (abfd
) != NULL
1753 && ! obj_coff_keep_syms (abfd
))
1755 free (obj_coff_external_syms (abfd
));
1756 obj_coff_external_syms (abfd
) = NULL
;
1759 if (obj_coff_strings (abfd
) != NULL
1760 && ! obj_coff_keep_strings (abfd
))
1762 free (obj_coff_strings (abfd
));
1763 obj_coff_strings (abfd
) = NULL
;
1764 obj_coff_strings_len (abfd
) = 0;
1770 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
1771 knit the symbol names into a normalized form. By normalized here I
1772 mean that all symbols have an n_offset pointer that points to a null-
1773 terminated string. */
1775 combined_entry_type
*
1776 coff_get_normalized_symtab (bfd
*abfd
)
1778 combined_entry_type
*internal
;
1779 combined_entry_type
*internal_ptr
;
1780 combined_entry_type
*symbol_ptr
;
1781 combined_entry_type
*internal_end
;
1785 const char *string_table
= NULL
;
1786 asection
* debug_sec
= NULL
;
1787 char *debug_sec_data
= NULL
;
1790 if (obj_raw_syments (abfd
) != NULL
)
1791 return obj_raw_syments (abfd
);
1793 if (! _bfd_coff_get_external_symbols (abfd
))
1796 size
= obj_raw_syment_count (abfd
);
1797 /* Check for integer overflow. */
1798 if (size
> (bfd_size_type
) -1 / sizeof (combined_entry_type
))
1800 size
*= sizeof (combined_entry_type
);
1801 internal
= (combined_entry_type
*) bfd_zalloc (abfd
, size
);
1802 if (internal
== NULL
&& size
!= 0)
1804 internal_end
= internal
+ obj_raw_syment_count (abfd
);
1806 raw_src
= (char *) obj_coff_external_syms (abfd
);
1808 /* Mark the end of the symbols. */
1809 symesz
= bfd_coff_symesz (abfd
);
1810 raw_end
= (char *) raw_src
+ obj_raw_syment_count (abfd
) * symesz
;
1812 /* FIXME SOMEDAY. A string table size of zero is very weird, but
1813 probably possible. If one shows up, it will probably kill us. */
1815 /* Swap all the raw entries. */
1816 for (internal_ptr
= internal
;
1818 raw_src
+= symesz
, internal_ptr
++)
1822 bfd_coff_swap_sym_in (abfd
, (void *) raw_src
,
1823 (void *) & internal_ptr
->u
.syment
);
1824 symbol_ptr
= internal_ptr
;
1825 internal_ptr
->is_sym
= TRUE
;
1828 i
< symbol_ptr
->u
.syment
.n_numaux
;
1834 /* PR 17512: Prevent buffer overrun. */
1835 if (raw_src
>= raw_end
|| internal_ptr
>= internal_end
)
1837 bfd_release (abfd
, internal
);
1841 bfd_coff_swap_aux_in (abfd
, (void *) raw_src
,
1842 symbol_ptr
->u
.syment
.n_type
,
1843 symbol_ptr
->u
.syment
.n_sclass
,
1844 (int) i
, symbol_ptr
->u
.syment
.n_numaux
,
1845 &(internal_ptr
->u
.auxent
));
1847 internal_ptr
->is_sym
= FALSE
;
1848 coff_pointerize_aux (abfd
, internal
, symbol_ptr
, i
,
1849 internal_ptr
, internal_end
);
1853 /* Free the raw symbols. */
1854 if (obj_coff_external_syms (abfd
) != NULL
1855 && ! obj_coff_keep_syms (abfd
))
1857 free (obj_coff_external_syms (abfd
));
1858 obj_coff_external_syms (abfd
) = NULL
;
1861 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
1864 BFD_ASSERT (internal_ptr
->is_sym
);
1866 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
1867 && internal_ptr
->u
.syment
.n_numaux
> 0)
1869 combined_entry_type
* aux
= internal_ptr
+ 1;
1871 /* Make a file symbol point to the name in the auxent, since
1872 the text ".file" is redundant. */
1873 BFD_ASSERT (! aux
->is_sym
);
1875 if (aux
->u
.auxent
.x_file
.x_n
.x_zeroes
== 0)
1877 /* The filename is a long one, point into the string table. */
1878 if (string_table
== NULL
)
1880 string_table
= _bfd_coff_read_string_table (abfd
);
1881 if (string_table
== NULL
)
1885 if ((bfd_size_type
)(aux
->u
.auxent
.x_file
.x_n
.x_offset
)
1886 >= obj_coff_strings_len (abfd
))
1887 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1889 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1890 (bfd_hostptr_t
) (string_table
+ (aux
->u
.auxent
.x_file
.x_n
.x_offset
));
1894 /* Ordinary short filename, put into memory anyway. The
1895 Microsoft PE tools sometimes store a filename in
1896 multiple AUX entries. */
1897 if (internal_ptr
->u
.syment
.n_numaux
> 1
1898 && coff_data (abfd
)->pe
)
1899 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1902 aux
->u
.auxent
.x_file
.x_fname
,
1903 internal_ptr
->u
.syment
.n_numaux
* symesz
);
1905 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1908 aux
->u
.auxent
.x_file
.x_fname
,
1909 (size_t) bfd_coff_filnmlen (abfd
)));
1914 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0)
1916 /* This is a "short" name. Make it long. */
1920 /* Find the length of this string without walking into memory
1922 for (i
= 0; i
< 8; ++i
)
1923 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0')
1926 newstring
= (char *) bfd_zalloc (abfd
, (bfd_size_type
) (i
+ 1));
1927 if (newstring
== NULL
)
1929 strncpy (newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
);
1930 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) newstring
;
1931 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1933 else if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
== 0)
1934 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) "";
1935 else if (!bfd_coff_symname_in_debug (abfd
, &internal_ptr
->u
.syment
))
1937 /* Long name already. Point symbol at the string in the
1939 if (string_table
== NULL
)
1941 string_table
= _bfd_coff_read_string_table (abfd
);
1942 if (string_table
== NULL
)
1945 if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
>= obj_coff_strings_len (abfd
)
1946 || string_table
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
< string_table
)
1947 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1949 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1952 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
));
1956 /* Long name in debug section. Very similar. */
1957 if (debug_sec_data
== NULL
)
1958 debug_sec_data
= build_debug_section (abfd
, & debug_sec
);
1959 if (debug_sec_data
!= NULL
)
1961 BFD_ASSERT (debug_sec
!= NULL
);
1962 /* PR binutils/17512: Catch out of range offsets into the debug data. */
1963 if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
> debug_sec
->size
1964 || debug_sec_data
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
< debug_sec_data
)
1965 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1967 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
)
1968 (debug_sec_data
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
1971 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) "";
1974 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
1977 obj_raw_syments (abfd
) = internal
;
1978 BFD_ASSERT (obj_raw_syment_count (abfd
)
1979 == (unsigned int) (internal_ptr
- internal
));
1985 coff_get_reloc_upper_bound (bfd
*abfd
, sec_ptr asect
)
1987 if (bfd_get_format (abfd
) != bfd_object
)
1989 bfd_set_error (bfd_error_invalid_operation
);
1992 #if SIZEOF_LONG == SIZEOF_INT
1993 if (asect
->reloc_count
>= LONG_MAX
/ sizeof (arelent
*))
1995 bfd_set_error (bfd_error_file_too_big
);
1999 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
2003 coff_make_empty_symbol (bfd
*abfd
)
2005 size_t amt
= sizeof (coff_symbol_type
);
2006 coff_symbol_type
*new_symbol
= (coff_symbol_type
*) bfd_zalloc (abfd
, amt
);
2008 if (new_symbol
== NULL
)
2010 new_symbol
->symbol
.section
= 0;
2011 new_symbol
->native
= NULL
;
2012 new_symbol
->lineno
= NULL
;
2013 new_symbol
->done_lineno
= FALSE
;
2014 new_symbol
->symbol
.the_bfd
= abfd
;
2016 return & new_symbol
->symbol
;
2019 /* Make a debugging symbol. */
2022 coff_bfd_make_debug_symbol (bfd
*abfd
,
2023 void * ptr ATTRIBUTE_UNUSED
,
2024 unsigned long sz ATTRIBUTE_UNUSED
)
2026 size_t amt
= sizeof (coff_symbol_type
);
2027 coff_symbol_type
*new_symbol
= (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
2029 if (new_symbol
== NULL
)
2031 /* @@ The 10 is a guess at a plausible maximum number of aux entries
2032 (but shouldn't be a constant). */
2033 amt
= sizeof (combined_entry_type
) * 10;
2034 new_symbol
->native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
2035 if (!new_symbol
->native
)
2037 new_symbol
->native
->is_sym
= TRUE
;
2038 new_symbol
->symbol
.section
= bfd_abs_section_ptr
;
2039 new_symbol
->symbol
.flags
= BSF_DEBUGGING
;
2040 new_symbol
->lineno
= NULL
;
2041 new_symbol
->done_lineno
= FALSE
;
2042 new_symbol
->symbol
.the_bfd
= abfd
;
2044 return & new_symbol
->symbol
;
2048 coff_get_symbol_info (bfd
*abfd
, asymbol
*symbol
, symbol_info
*ret
)
2050 bfd_symbol_info (symbol
, ret
);
2052 if (coffsymbol (symbol
)->native
!= NULL
2053 && coffsymbol (symbol
)->native
->fix_value
2054 && coffsymbol (symbol
)->native
->is_sym
)
2055 ret
->value
= coffsymbol (symbol
)->native
->u
.syment
.n_value
-
2056 (bfd_hostptr_t
) obj_raw_syments (abfd
);
2059 /* Print out information about COFF symbol. */
2062 coff_print_symbol (bfd
*abfd
,
2065 bfd_print_symbol_type how
)
2067 FILE * file
= (FILE *) filep
;
2071 case bfd_print_symbol_name
:
2072 fprintf (file
, "%s", symbol
->name
);
2075 case bfd_print_symbol_more
:
2076 fprintf (file
, "coff %s %s",
2077 coffsymbol (symbol
)->native
? "n" : "g",
2078 coffsymbol (symbol
)->lineno
? "l" : " ");
2081 case bfd_print_symbol_all
:
2082 if (coffsymbol (symbol
)->native
)
2086 combined_entry_type
*combined
= coffsymbol (symbol
)->native
;
2087 combined_entry_type
*root
= obj_raw_syments (abfd
);
2088 struct lineno_cache_entry
*l
= coffsymbol (symbol
)->lineno
;
2090 fprintf (file
, "[%3ld]", (long) (combined
- root
));
2092 /* PR 17512: file: 079-33786-0.001:0.1. */
2093 if (combined
< obj_raw_syments (abfd
)
2094 || combined
>= obj_raw_syments (abfd
) + obj_raw_syment_count (abfd
))
2096 fprintf (file
, _("<corrupt info> %s"), symbol
->name
);
2100 BFD_ASSERT (combined
->is_sym
);
2101 if (! combined
->fix_value
)
2102 val
= (bfd_vma
) combined
->u
.syment
.n_value
;
2104 val
= combined
->u
.syment
.n_value
- (bfd_hostptr_t
) root
;
2106 fprintf (file
, "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x",
2107 combined
->u
.syment
.n_scnum
,
2108 combined
->u
.syment
.n_flags
,
2109 combined
->u
.syment
.n_type
,
2110 combined
->u
.syment
.n_sclass
,
2111 combined
->u
.syment
.n_numaux
);
2112 bfd_fprintf_vma (abfd
, file
, val
);
2113 fprintf (file
, " %s", symbol
->name
);
2115 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
2117 combined_entry_type
*auxp
= combined
+ aux
+ 1;
2120 BFD_ASSERT (! auxp
->is_sym
);
2122 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.p
- root
;
2124 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.l
;
2126 fprintf (file
, "\n");
2128 if (bfd_coff_print_aux (abfd
, file
, root
, combined
, auxp
, aux
))
2131 switch (combined
->u
.syment
.n_sclass
)
2134 fprintf (file
, "File ");
2138 if (combined
->u
.syment
.n_type
== T_NULL
)
2139 /* Probably a section symbol ? */
2141 fprintf (file
, "AUX scnlen 0x%lx nreloc %d nlnno %d",
2142 (unsigned long) auxp
->u
.auxent
.x_scn
.x_scnlen
,
2143 auxp
->u
.auxent
.x_scn
.x_nreloc
,
2144 auxp
->u
.auxent
.x_scn
.x_nlinno
);
2145 if (auxp
->u
.auxent
.x_scn
.x_checksum
!= 0
2146 || auxp
->u
.auxent
.x_scn
.x_associated
!= 0
2147 || auxp
->u
.auxent
.x_scn
.x_comdat
!= 0)
2148 fprintf (file
, " checksum 0x%lx assoc %d comdat %d",
2149 auxp
->u
.auxent
.x_scn
.x_checksum
,
2150 auxp
->u
.auxent
.x_scn
.x_associated
,
2151 auxp
->u
.auxent
.x_scn
.x_comdat
);
2157 if (ISFCN (combined
->u
.syment
.n_type
))
2162 next
= (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2165 next
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2166 llnos
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
2168 "AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld",
2170 (unsigned long) auxp
->u
.auxent
.x_sym
.x_misc
.x_fsize
,
2176 fprintf (file
, "AUX lnno %d size 0x%x tagndx %ld",
2177 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
2178 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
,
2181 fprintf (file
, " endndx %ld",
2183 (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2191 fprintf (file
, "\n%s :", l
->u
.sym
->name
);
2193 while (l
->line_number
)
2195 if (l
->line_number
> 0)
2197 fprintf (file
, "\n%4d : ", l
->line_number
);
2198 bfd_fprintf_vma (abfd
, file
, l
->u
.offset
+ symbol
->section
->vma
);
2206 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
2207 fprintf (file
, " %-5s %s %s %s",
2208 symbol
->section
->name
,
2209 coffsymbol (symbol
)->native
? "n" : "g",
2210 coffsymbol (symbol
)->lineno
? "l" : " ",
2216 /* Return whether a symbol name implies a local symbol. In COFF,
2217 local symbols generally start with ``.L''. Most targets use this
2218 function for the is_local_label_name entry point, but some may
2222 _bfd_coff_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
2225 return name
[0] == '.' && name
[1] == 'L';
2228 /* Provided a BFD, a section and an offset (in bytes, not octets) into the
2229 section, calculate and return the name of the source file and the line
2230 nearest to the wanted location. */
2233 coff_find_nearest_line_with_names (bfd
*abfd
,
2237 const char **filename_ptr
,
2238 const char **functionname_ptr
,
2239 unsigned int *line_ptr
,
2240 const struct dwarf_debug_section
*debug_sections
)
2244 unsigned int line_base
;
2245 coff_data_type
*cof
= coff_data (abfd
);
2246 /* Run through the raw syments if available. */
2247 combined_entry_type
*p
;
2248 combined_entry_type
*pend
;
2250 struct coff_section_tdata
*sec_data
;
2253 /* Before looking through the symbol table, try to use a .stab
2254 section to find the information. */
2255 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2256 &found
, filename_ptr
,
2257 functionname_ptr
, line_ptr
,
2258 &coff_data(abfd
)->line_info
))
2264 /* Also try examining DWARF2 debugging information. */
2265 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
2266 filename_ptr
, functionname_ptr
,
2267 line_ptr
, NULL
, debug_sections
,
2268 &coff_data(abfd
)->dwarf2_find_line_info
))
2271 sec_data
= coff_section_data (abfd
, section
);
2273 /* If the DWARF lookup failed, but there is DWARF information available
2274 then the problem might be that the file has been rebased. This tool
2275 changes the VMAs of all the sections, but it does not update the DWARF
2276 information. So try again, using a bias against the address sought. */
2277 if (coff_data (abfd
)->dwarf2_find_line_info
!= NULL
)
2279 bfd_signed_vma bias
= 0;
2281 /* Create a cache of the result for the next call. */
2282 if (sec_data
== NULL
&& section
->owner
== abfd
)
2284 amt
= sizeof (struct coff_section_tdata
);
2285 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
2286 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2289 if (sec_data
!= NULL
&& sec_data
->saved_bias
)
2290 bias
= sec_data
->saved_bias
;
2293 bias
= _bfd_dwarf2_find_symbol_bias (symbols
,
2294 & coff_data (abfd
)->dwarf2_find_line_info
);
2298 sec_data
->saved_bias
= TRUE
;
2299 sec_data
->bias
= bias
;
2304 && _bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
,
2306 filename_ptr
, functionname_ptr
,
2307 line_ptr
, NULL
, debug_sections
,
2308 &coff_data(abfd
)->dwarf2_find_line_info
))
2313 *functionname_ptr
= 0;
2316 /* Don't try and find line numbers in a non coff file. */
2317 if (!bfd_family_coff (abfd
))
2323 /* Find the first C_FILE symbol. */
2324 p
= cof
->raw_syments
;
2328 pend
= p
+ cof
->raw_syment_count
;
2331 BFD_ASSERT (p
->is_sym
);
2332 if (p
->u
.syment
.n_sclass
== C_FILE
)
2334 p
+= 1 + p
->u
.syment
.n_numaux
;
2342 /* Look through the C_FILE symbols to find the best one. */
2343 sec_vma
= bfd_section_vma (section
);
2344 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2345 maxdiff
= (bfd_vma
) 0 - (bfd_vma
) 1;
2349 combined_entry_type
*p2
;
2351 for (p2
= p
+ 1 + p
->u
.syment
.n_numaux
;
2353 p2
+= 1 + p2
->u
.syment
.n_numaux
)
2355 BFD_ASSERT (p2
->is_sym
);
2356 if (p2
->u
.syment
.n_scnum
> 0
2358 == coff_section_from_bfd_index (abfd
,
2359 p2
->u
.syment
.n_scnum
)))
2361 if (p2
->u
.syment
.n_sclass
== C_FILE
)
2370 file_addr
= (bfd_vma
) p2
->u
.syment
.n_value
;
2371 /* PR 11512: Include the section address of the function name symbol. */
2372 if (p2
->u
.syment
.n_scnum
> 0)
2373 file_addr
+= coff_section_from_bfd_index (abfd
,
2374 p2
->u
.syment
.n_scnum
)->vma
;
2375 /* We use <= MAXDIFF here so that if we get a zero length
2376 file, we actually use the next file entry. */
2378 && offset
+ sec_vma
>= file_addr
2379 && offset
+ sec_vma
- file_addr
<= maxdiff
)
2381 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2382 maxdiff
= offset
+ sec_vma
- p2
->u
.syment
.n_value
;
2385 if (p
->u
.syment
.n_value
>= cof
->raw_syment_count
)
2388 /* Avoid endless loops on erroneous files by ensuring that
2389 we always move forward in the file. */
2390 if (p
>= cof
->raw_syments
+ p
->u
.syment
.n_value
)
2393 p
= cof
->raw_syments
+ p
->u
.syment
.n_value
;
2394 if (!p
->is_sym
|| p
->u
.syment
.n_sclass
!= C_FILE
)
2399 if (section
->lineno_count
== 0)
2401 *functionname_ptr
= NULL
;
2406 /* Now wander though the raw linenumbers of the section.
2407 If we have been called on this section before, and the offset
2408 we want is further down then we can prime the lookup loop. */
2409 if (sec_data
!= NULL
2411 && offset
>= sec_data
->offset
)
2414 *functionname_ptr
= sec_data
->function
;
2415 line_base
= sec_data
->line_base
;
2423 if (section
->lineno
!= NULL
)
2425 bfd_vma last_value
= 0;
2427 l
= §ion
->lineno
[i
];
2429 for (; i
< section
->lineno_count
; i
++)
2431 if (l
->line_number
== 0)
2433 /* Get the symbol this line number points at. */
2434 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
2435 if (coff
->symbol
.value
> offset
)
2438 *functionname_ptr
= coff
->symbol
.name
;
2439 last_value
= coff
->symbol
.value
;
2442 combined_entry_type
*s
= coff
->native
;
2444 BFD_ASSERT (s
->is_sym
);
2445 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2447 /* In XCOFF a debugging symbol can follow the
2449 if (s
->u
.syment
.n_scnum
== N_DEBUG
)
2450 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2452 /* S should now point to the .bf of the function. */
2453 if (s
->u
.syment
.n_numaux
)
2455 /* The linenumber is stored in the auxent. */
2456 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
2458 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
2459 *line_ptr
= line_base
;
2465 if (l
->u
.offset
> offset
)
2467 *line_ptr
= l
->line_number
+ line_base
- 1;
2472 /* If we fell off the end of the loop, then assume that this
2473 symbol has no line number info. Otherwise, symbols with no
2474 line number info get reported with the line number of the
2475 last line of the last symbol which does have line number
2476 info. We use 0x100 as a slop to account for cases where the
2477 last line has executable code. */
2478 if (i
>= section
->lineno_count
2480 && offset
- last_value
> 0x100)
2482 *functionname_ptr
= NULL
;
2487 /* Cache the results for the next call. */
2488 if (sec_data
== NULL
&& section
->owner
== abfd
)
2490 amt
= sizeof (struct coff_section_tdata
);
2491 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
2492 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2495 if (sec_data
!= NULL
)
2497 sec_data
->offset
= offset
;
2498 sec_data
->i
= i
- 1;
2499 sec_data
->function
= *functionname_ptr
;
2500 sec_data
->line_base
= line_base
;
2507 coff_find_nearest_line (bfd
*abfd
,
2511 const char **filename_ptr
,
2512 const char **functionname_ptr
,
2513 unsigned int *line_ptr
,
2514 unsigned int *discriminator_ptr
)
2516 if (discriminator_ptr
)
2517 *discriminator_ptr
= 0;
2518 return coff_find_nearest_line_with_names (abfd
, symbols
, section
, offset
,
2519 filename_ptr
, functionname_ptr
,
2520 line_ptr
, dwarf_debug_sections
);
2524 coff_find_inliner_info (bfd
*abfd
,
2525 const char **filename_ptr
,
2526 const char **functionname_ptr
,
2527 unsigned int *line_ptr
)
2531 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
2532 functionname_ptr
, line_ptr
,
2533 &coff_data(abfd
)->dwarf2_find_line_info
);
2538 coff_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
2542 if (!bfd_link_relocatable (info
))
2543 size
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
2545 size
= bfd_coff_filhsz (abfd
);
2547 size
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
2551 /* Change the class of a coff symbol held by BFD. */
2554 bfd_coff_set_symbol_class (bfd
* abfd
,
2556 unsigned int symbol_class
)
2558 coff_symbol_type
* csym
;
2560 csym
= coff_symbol_from (symbol
);
2563 bfd_set_error (bfd_error_invalid_operation
);
2566 else if (csym
->native
== NULL
)
2568 /* This is an alien symbol which no native coff backend data.
2569 We cheat here by creating a fake native entry for it and
2570 then filling in the class. This code is based on that in
2571 coff_write_alien_symbol(). */
2573 combined_entry_type
* native
;
2574 size_t amt
= sizeof (* native
);
2576 native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
2580 native
->is_sym
= TRUE
;
2581 native
->u
.syment
.n_type
= T_NULL
;
2582 native
->u
.syment
.n_sclass
= symbol_class
;
2584 if (bfd_is_und_section (symbol
->section
))
2586 native
->u
.syment
.n_scnum
= N_UNDEF
;
2587 native
->u
.syment
.n_value
= symbol
->value
;
2589 else if (bfd_is_com_section (symbol
->section
))
2591 native
->u
.syment
.n_scnum
= N_UNDEF
;
2592 native
->u
.syment
.n_value
= symbol
->value
;
2596 native
->u
.syment
.n_scnum
=
2597 symbol
->section
->output_section
->target_index
;
2598 native
->u
.syment
.n_value
= (symbol
->value
2599 + symbol
->section
->output_offset
);
2600 if (! obj_pe (abfd
))
2601 native
->u
.syment
.n_value
+= symbol
->section
->output_section
->vma
;
2603 /* Copy the any flags from the file header into the symbol.
2605 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (& csym
->symbol
)->flags
;
2608 csym
->native
= native
;
2611 csym
->native
->u
.syment
.n_sclass
= symbol_class
;
2617 _bfd_coff_section_already_linked (bfd
*abfd
,
2619 struct bfd_link_info
*info
)
2622 const char *name
, *key
;
2623 struct bfd_section_already_linked
*l
;
2624 struct bfd_section_already_linked_hash_entry
*already_linked_list
;
2625 struct coff_comdat_info
*s_comdat
;
2627 if (sec
->output_section
== bfd_abs_section_ptr
)
2631 if ((flags
& SEC_LINK_ONCE
) == 0)
2634 /* The COFF backend linker doesn't support group sections. */
2635 if ((flags
& SEC_GROUP
) != 0)
2638 name
= bfd_section_name (sec
);
2639 s_comdat
= bfd_coff_get_comdat_section (abfd
, sec
);
2641 if (s_comdat
!= NULL
)
2642 key
= s_comdat
->name
;
2645 if (CONST_STRNEQ (name
, ".gnu.linkonce.")
2646 && (key
= strchr (name
+ sizeof (".gnu.linkonce.") - 1, '.')) != NULL
)
2649 /* FIXME: gcc as of 2011-09 emits sections like .text$<key>,
2650 .xdata$<key> and .pdata$<key> only the first of which has a
2651 comdat key. Should these all match the LTO IR key? */
2655 already_linked_list
= bfd_section_already_linked_table_lookup (key
);
2657 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
2659 struct coff_comdat_info
*l_comdat
;
2661 l_comdat
= bfd_coff_get_comdat_section (l
->sec
->owner
, l
->sec
);
2663 /* The section names must match, and both sections must be
2664 comdat and have the same comdat name, or both sections must
2665 be non-comdat. LTO IR plugin sections are an exception. They
2666 are always named .gnu.linkonce.t.<key> (<key> is some string)
2667 and match any comdat section with comdat name of <key>, and
2668 any linkonce section with the same suffix, ie.
2669 .gnu.linkonce.*.<key>. */
2670 if (((s_comdat
!= NULL
) == (l_comdat
!= NULL
)
2671 && strcmp (name
, l
->sec
->name
) == 0)
2672 || (l
->sec
->owner
->flags
& BFD_PLUGIN
) != 0)
2674 /* The section has already been linked. See if we should
2676 return _bfd_handle_already_linked (sec
, l
, info
);
2680 /* This is the first section with this name. Record it. */
2681 if (!bfd_section_already_linked_table_insert (already_linked_list
, sec
))
2682 info
->callbacks
->einfo (_("%F%P: already_linked_table: %E\n"));
2686 /* Initialize COOKIE for input bfd ABFD. */
2689 init_reloc_cookie (struct coff_reloc_cookie
*cookie
,
2690 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2693 /* Sometimes the symbol table does not yet have been loaded here. */
2694 bfd_coff_slurp_symbol_table (abfd
);
2696 cookie
->abfd
= abfd
;
2697 cookie
->sym_hashes
= obj_coff_sym_hashes (abfd
);
2699 cookie
->symbols
= obj_symbols (abfd
);
2704 /* Free the memory allocated by init_reloc_cookie, if appropriate. */
2707 fini_reloc_cookie (struct coff_reloc_cookie
*cookie ATTRIBUTE_UNUSED
,
2708 bfd
*abfd ATTRIBUTE_UNUSED
)
2710 /* Nothing to do. */
2713 /* Initialize the relocation information in COOKIE for input section SEC
2714 of input bfd ABFD. */
2717 init_reloc_cookie_rels (struct coff_reloc_cookie
*cookie
,
2718 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2722 if (sec
->reloc_count
== 0)
2724 cookie
->rels
= NULL
;
2725 cookie
->relend
= NULL
;
2730 cookie
->rels
= _bfd_coff_read_internal_relocs (abfd
, sec
, FALSE
, NULL
, 0, NULL
);
2732 if (cookie
->rels
== NULL
)
2735 cookie
->rel
= cookie
->rels
;
2736 cookie
->relend
= (cookie
->rels
+ sec
->reloc_count
);
2740 /* Free the memory allocated by init_reloc_cookie_rels,
2744 fini_reloc_cookie_rels (struct coff_reloc_cookie
*cookie
,
2748 /* PR 20401. The relocs may not have been cached, so check first.
2749 If the relocs were loaded by init_reloc_cookie_rels() then this
2750 will be the case. FIXME: Would performance be improved if the
2751 relocs *were* cached ? */
2752 && coff_section_data (NULL
, sec
)
2753 && coff_section_data (NULL
, sec
)->relocs
!= cookie
->rels
)
2754 free (cookie
->rels
);
2757 /* Initialize the whole of COOKIE for input section SEC. */
2760 init_reloc_cookie_for_section (struct coff_reloc_cookie
*cookie
,
2761 struct bfd_link_info
*info
,
2764 if (!init_reloc_cookie (cookie
, info
, sec
->owner
))
2767 if (!init_reloc_cookie_rels (cookie
, info
, sec
->owner
, sec
))
2769 fini_reloc_cookie (cookie
, sec
->owner
);
2775 /* Free the memory allocated by init_reloc_cookie_for_section,
2779 fini_reloc_cookie_for_section (struct coff_reloc_cookie
*cookie
,
2782 fini_reloc_cookie_rels (cookie
, sec
);
2783 fini_reloc_cookie (cookie
, sec
->owner
);
2787 _bfd_coff_gc_mark_hook (asection
*sec
,
2788 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2789 struct internal_reloc
*rel ATTRIBUTE_UNUSED
,
2790 struct coff_link_hash_entry
*h
,
2791 struct internal_syment
*sym
)
2795 switch (h
->root
.type
)
2797 case bfd_link_hash_defined
:
2798 case bfd_link_hash_defweak
:
2799 return h
->root
.u
.def
.section
;
2801 case bfd_link_hash_common
:
2802 return h
->root
.u
.c
.p
->section
;
2804 case bfd_link_hash_undefweak
:
2805 if (h
->symbol_class
== C_NT_WEAK
&& h
->numaux
== 1)
2807 /* PE weak externals. A weak symbol may include an auxiliary
2808 record indicating that if the weak symbol is not resolved,
2809 another external symbol is used instead. */
2810 struct coff_link_hash_entry
*h2
=
2811 h
->auxbfd
->tdata
.coff_obj_data
->sym_hashes
[
2812 h
->aux
->x_sym
.x_tagndx
.l
];
2814 if (h2
&& h2
->root
.type
!= bfd_link_hash_undefined
)
2815 return h2
->root
.u
.def
.section
;
2819 case bfd_link_hash_undefined
:
2826 return coff_section_from_bfd_index (sec
->owner
, sym
->n_scnum
);
2829 /* COOKIE->rel describes a relocation against section SEC, which is
2830 a section we've decided to keep. Return the section that contains
2831 the relocation symbol, or NULL if no section contains it. */
2834 _bfd_coff_gc_mark_rsec (struct bfd_link_info
*info
, asection
*sec
,
2835 coff_gc_mark_hook_fn gc_mark_hook
,
2836 struct coff_reloc_cookie
*cookie
)
2838 struct coff_link_hash_entry
*h
;
2840 h
= cookie
->sym_hashes
[cookie
->rel
->r_symndx
];
2843 while (h
->root
.type
== bfd_link_hash_indirect
2844 || h
->root
.type
== bfd_link_hash_warning
)
2845 h
= (struct coff_link_hash_entry
*) h
->root
.u
.i
.link
;
2847 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, h
, NULL
);
2850 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, NULL
,
2852 + obj_convert (sec
->owner
)[cookie
->rel
->r_symndx
])->native
->u
.syment
);
2855 static bfd_boolean _bfd_coff_gc_mark
2856 (struct bfd_link_info
*, asection
*, coff_gc_mark_hook_fn
);
2858 /* COOKIE->rel describes a relocation against section SEC, which is
2859 a section we've decided to keep. Mark the section that contains
2860 the relocation symbol. */
2863 _bfd_coff_gc_mark_reloc (struct bfd_link_info
*info
,
2865 coff_gc_mark_hook_fn gc_mark_hook
,
2866 struct coff_reloc_cookie
*cookie
)
2870 rsec
= _bfd_coff_gc_mark_rsec (info
, sec
, gc_mark_hook
, cookie
);
2871 if (rsec
&& !rsec
->gc_mark
)
2873 if (bfd_get_flavour (rsec
->owner
) != bfd_target_coff_flavour
)
2875 else if (!_bfd_coff_gc_mark (info
, rsec
, gc_mark_hook
))
2881 /* The mark phase of garbage collection. For a given section, mark
2882 it and any sections in this section's group, and all the sections
2883 which define symbols to which it refers. */
2886 _bfd_coff_gc_mark (struct bfd_link_info
*info
,
2888 coff_gc_mark_hook_fn gc_mark_hook
)
2890 bfd_boolean ret
= TRUE
;
2894 /* Look through the section relocs. */
2895 if ((sec
->flags
& SEC_RELOC
) != 0
2896 && sec
->reloc_count
> 0)
2898 struct coff_reloc_cookie cookie
;
2900 if (!init_reloc_cookie_for_section (&cookie
, info
, sec
))
2904 for (; cookie
.rel
< cookie
.relend
; cookie
.rel
++)
2906 if (!_bfd_coff_gc_mark_reloc (info
, sec
, gc_mark_hook
, &cookie
))
2912 fini_reloc_cookie_for_section (&cookie
, sec
);
2920 _bfd_coff_gc_mark_extra_sections (struct bfd_link_info
*info
,
2921 coff_gc_mark_hook_fn mark_hook ATTRIBUTE_UNUSED
)
2925 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
2928 bfd_boolean some_kept
;
2930 if (bfd_get_flavour (ibfd
) != bfd_target_coff_flavour
)
2933 /* Ensure all linker created sections are kept, and see whether
2934 any other section is already marked. */
2936 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
2938 if ((isec
->flags
& SEC_LINKER_CREATED
) != 0)
2940 else if (isec
->gc_mark
)
2944 /* If no section in this file will be kept, then we can
2945 toss out debug sections. */
2949 /* Keep debug and special sections like .comment when they are
2950 not part of a group, or when we have single-member groups. */
2951 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
2952 if ((isec
->flags
& SEC_DEBUGGING
) != 0
2953 || (isec
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0)
2959 /* Sweep symbols in swept sections. Called via coff_link_hash_traverse. */
2962 coff_gc_sweep_symbol (struct coff_link_hash_entry
*h
,
2963 void *data ATTRIBUTE_UNUSED
)
2965 if (h
->root
.type
== bfd_link_hash_warning
)
2966 h
= (struct coff_link_hash_entry
*) h
->root
.u
.i
.link
;
2968 if ((h
->root
.type
== bfd_link_hash_defined
2969 || h
->root
.type
== bfd_link_hash_defweak
)
2970 && !h
->root
.u
.def
.section
->gc_mark
2971 && !(h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
))
2973 /* Do our best to hide the symbol. */
2974 h
->root
.u
.def
.section
= bfd_und_section_ptr
;
2975 h
->symbol_class
= C_HIDDEN
;
2981 /* The sweep phase of garbage collection. Remove all garbage sections. */
2983 typedef bfd_boolean (*gc_sweep_hook_fn
)
2984 (bfd
*, struct bfd_link_info
*, asection
*, const struct internal_reloc
*);
2987 coff_gc_sweep (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
2991 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
2995 if (bfd_get_flavour (sub
) != bfd_target_coff_flavour
)
2998 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3000 /* Keep debug and special sections. */
3001 if ((o
->flags
& (SEC_DEBUGGING
| SEC_LINKER_CREATED
)) != 0
3002 || (o
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0)
3004 else if (CONST_STRNEQ (o
->name
, ".idata")
3005 || CONST_STRNEQ (o
->name
, ".pdata")
3006 || CONST_STRNEQ (o
->name
, ".xdata")
3007 || CONST_STRNEQ (o
->name
, ".rsrc"))
3013 /* Skip sweeping sections already excluded. */
3014 if (o
->flags
& SEC_EXCLUDE
)
3017 /* Since this is early in the link process, it is simple
3018 to remove a section from the output. */
3019 o
->flags
|= SEC_EXCLUDE
;
3021 if (info
->print_gc_sections
&& o
->size
!= 0)
3022 /* xgettext: c-format */
3023 _bfd_error_handler (_("removing unused section '%pA' in file '%pB'"),
3027 /* But we also have to update some of the relocation
3028 info we collected before. */
3030 && (o
->flags
& SEC_RELOC
) != 0
3031 && o
->reloc_count
> 0
3032 && !bfd_is_abs_section (o
->output_section
))
3034 struct internal_reloc
*internal_relocs
;
3038 = _bfd_coff_link_read_relocs (o
->owner
, o
, NULL
, NULL
,
3040 if (internal_relocs
== NULL
)
3043 r
= (*gc_sweep_hook
) (o
->owner
, info
, o
, internal_relocs
);
3045 if (coff_section_data (o
)->relocs
!= internal_relocs
)
3046 free (internal_relocs
);
3055 /* Remove the symbols that were in the swept sections from the dynamic
3057 coff_link_hash_traverse (coff_hash_table (info
), coff_gc_sweep_symbol
,
3063 /* Keep all sections containing symbols undefined on the command-line,
3064 and the section containing the entry symbol. */
3067 _bfd_coff_gc_keep (struct bfd_link_info
*info
)
3069 struct bfd_sym_chain
*sym
;
3071 for (sym
= info
->gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
3073 struct coff_link_hash_entry
*h
;
3075 h
= coff_link_hash_lookup (coff_hash_table (info
), sym
->name
,
3076 FALSE
, FALSE
, FALSE
);
3079 && (h
->root
.type
== bfd_link_hash_defined
3080 || h
->root
.type
== bfd_link_hash_defweak
)
3081 && !bfd_is_abs_section (h
->root
.u
.def
.section
))
3082 h
->root
.u
.def
.section
->flags
|= SEC_KEEP
;
3086 /* Do mark and sweep of unused sections. */
3089 bfd_coff_gc_sections (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
3093 /* FIXME: Should we implement this? */
3095 const bfd_coff_backend_data
*bed
= coff_backend_info (abfd
);
3097 if (!bed
->can_gc_sections
3098 || !is_coff_hash_table (info
->hash
))
3100 _bfd_error_handler(_("warning: gc-sections option ignored"));
3105 _bfd_coff_gc_keep (info
);
3107 /* Grovel through relocs to find out who stays ... */
3108 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3112 if (bfd_get_flavour (sub
) != bfd_target_coff_flavour
)
3115 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3117 if (((o
->flags
& (SEC_EXCLUDE
| SEC_KEEP
)) == SEC_KEEP
3118 || CONST_STRNEQ (o
->name
, ".vectors")
3119 || CONST_STRNEQ (o
->name
, ".ctors")
3120 || CONST_STRNEQ (o
->name
, ".dtors"))
3123 if (!_bfd_coff_gc_mark (info
, o
, _bfd_coff_gc_mark_hook
))
3129 /* Allow the backend to mark additional target specific sections. */
3130 _bfd_coff_gc_mark_extra_sections (info
, _bfd_coff_gc_mark_hook
);
3132 /* ... and mark SEC_EXCLUDE for those that go. */
3133 return coff_gc_sweep (abfd
, info
);
3136 /* Return name used to identify a comdat group. */
3139 bfd_coff_group_name (bfd
*abfd
, const asection
*sec
)
3141 struct coff_comdat_info
*ci
= bfd_coff_get_comdat_section (abfd
, sec
);
3148 _bfd_coff_close_and_cleanup (bfd
*abfd
)
3150 if (abfd
->format
== bfd_object
3151 && bfd_family_coff (abfd
)
3152 && coff_data (abfd
) != NULL
)
3155 Do not clear the keep_syms and keep_strings flags.
3156 These may have been set by pe_ILF_build_a_bfd() indicating
3157 that the syms and strings pointers are not to be freed. */
3158 if (!_bfd_coff_free_symbols (abfd
))
3161 return _bfd_generic_close_and_cleanup (abfd
);