1 /* Support for the generic parts of COFF, for BFD.
2 Copyright (C) 1990-2020 Free Software Foundation, Inc.
3 Written by Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
22 /* Most of this hacked by Steve Chamberlain, sac@cygnus.com.
23 Split out of coffcode.h by Ian Taylor, ian@cygnus.com. */
25 /* This file contains COFF code that is not dependent on any
26 particular COFF target. There is only one version of this file in
27 libbfd.a, so no target specific code may be put in here. Or, to
30 ********** DO NOT PUT TARGET SPECIFIC CODE IN THIS FILE **********
32 If you need to add some target specific behaviour, add a new hook
33 function to bfd_coff_backend_data.
35 Some of these functions are also called by the ECOFF routines.
36 Those functions may not use any COFF specific information, such as
43 #include "coff/internal.h"
46 /* Take a section header read from a coff file (in HOST byte order),
47 and make a BFD "section" out of it. This is used by ECOFF. */
50 make_a_section_from_file (bfd
*abfd
,
51 struct internal_scnhdr
*hdr
,
52 unsigned int target_index
)
54 asection
*return_section
;
56 bfd_boolean result
= TRUE
;
61 /* Handle long section names as in PE. On reading, we want to
62 accept long names if the format permits them at all, regardless
63 of the current state of the flag that dictates if we would generate
64 them in outputs; this construct checks if that is the case by
65 attempting to set the flag, without changing its state; the call
66 will fail for formats that do not support long names at all. */
67 if (bfd_coff_set_long_section_names (abfd
, bfd_coff_long_section_names (abfd
))
68 && hdr
->s_name
[0] == '/')
75 /* Flag that this BFD uses long names, even though the format might
76 expect them to be off by default. This won't directly affect the
77 format of any output BFD created from this one, but the information
78 can be used to decide what to do. */
79 bfd_coff_set_long_section_names (abfd
, TRUE
);
80 memcpy (buf
, hdr
->s_name
+ 1, SCNNMLEN
- 1);
81 buf
[SCNNMLEN
- 1] = '\0';
82 strindex
= strtol (buf
, &p
, 10);
83 if (*p
== '\0' && strindex
>= 0)
85 strings
= _bfd_coff_read_string_table (abfd
);
88 if ((bfd_size_type
)(strindex
+ 2) >= obj_coff_strings_len (abfd
))
91 name
= (char *) bfd_alloc (abfd
,
92 (bfd_size_type
) strlen (strings
) + 1 + 1);
95 strcpy (name
, strings
);
101 /* Assorted wastage to null-terminate the name, thanks AT&T! */
102 name
= (char *) bfd_alloc (abfd
,
103 (bfd_size_type
) sizeof (hdr
->s_name
) + 1 + 1);
106 strncpy (name
, (char *) &hdr
->s_name
[0], sizeof (hdr
->s_name
));
107 name
[sizeof (hdr
->s_name
)] = 0;
110 return_section
= bfd_make_section_anyway (abfd
, name
);
111 if (return_section
== NULL
)
114 return_section
->vma
= hdr
->s_vaddr
;
115 return_section
->lma
= hdr
->s_paddr
;
116 return_section
->size
= hdr
->s_size
;
117 return_section
->filepos
= hdr
->s_scnptr
;
118 return_section
->rel_filepos
= hdr
->s_relptr
;
119 return_section
->reloc_count
= hdr
->s_nreloc
;
121 bfd_coff_set_alignment_hook (abfd
, return_section
, hdr
);
123 return_section
->line_filepos
= hdr
->s_lnnoptr
;
125 return_section
->lineno_count
= hdr
->s_nlnno
;
126 return_section
->userdata
= NULL
;
127 return_section
->next
= NULL
;
128 return_section
->target_index
= target_index
;
130 if (! bfd_coff_styp_to_sec_flags_hook (abfd
, hdr
, name
, return_section
,
134 return_section
->flags
= flags
;
136 /* At least on i386-coff, the line number count for a shared library
137 section must be ignored. */
138 if ((return_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
139 return_section
->lineno_count
= 0;
141 if (hdr
->s_nreloc
!= 0)
142 return_section
->flags
|= SEC_RELOC
;
143 /* FIXME: should this check 'hdr->s_size > 0'. */
144 if (hdr
->s_scnptr
!= 0)
145 return_section
->flags
|= SEC_HAS_CONTENTS
;
147 /* Compress/decompress DWARF debug sections with names: .debug_* and
148 .zdebug_*, after the section flags is set. */
149 if ((flags
& SEC_DEBUGGING
)
151 && ((name
[1] == 'd' && name
[6] == '_')
152 || (strlen (name
) > 8 && name
[1] == 'z' && name
[7] == '_')))
154 enum { nothing
, compress
, decompress
} action
= nothing
;
155 char *new_name
= NULL
;
157 if (bfd_is_section_compressed (abfd
, return_section
))
159 /* Compressed section. Check if we should decompress. */
160 if ((abfd
->flags
& BFD_DECOMPRESS
))
163 else if (!bfd_is_section_compressed (abfd
, return_section
))
165 /* Normal section. Check if we should compress. */
166 if ((abfd
->flags
& BFD_COMPRESS
) && return_section
->size
!= 0)
175 if (!bfd_init_section_compress_status (abfd
, return_section
))
178 /* xgettext: c-format */
179 (_("%pB: unable to initialize compress status for section %s"),
183 if (return_section
->compress_status
== COMPRESS_SECTION_DONE
)
187 unsigned int len
= strlen (name
);
189 new_name
= bfd_alloc (abfd
, len
+ 2);
190 if (new_name
== NULL
)
194 memcpy (new_name
+ 2, name
+ 1, len
);
199 if (!bfd_init_section_decompress_status (abfd
, return_section
))
202 /* xgettext: c-format */
203 (_("%pB: unable to initialize decompress status for section %s"),
209 unsigned int len
= strlen (name
);
211 new_name
= bfd_alloc (abfd
, len
);
212 if (new_name
== NULL
)
215 memcpy (new_name
+ 1, name
+ 2, len
- 1);
219 if (new_name
!= NULL
)
220 bfd_rename_section (return_section
, new_name
);
226 /* Read in a COFF object and make it into a BFD. This is used by
229 coff_real_object_p (bfd
*,
231 struct internal_filehdr
*,
232 struct internal_aouthdr
*);
234 coff_real_object_p (bfd
*abfd
,
236 struct internal_filehdr
*internal_f
,
237 struct internal_aouthdr
*internal_a
)
239 flagword oflags
= abfd
->flags
;
240 bfd_vma ostart
= bfd_get_start_address (abfd
);
243 bfd_size_type readsize
; /* Length of file_info. */
245 char *external_sections
;
247 if (!(internal_f
->f_flags
& F_RELFLG
))
248 abfd
->flags
|= HAS_RELOC
;
249 if ((internal_f
->f_flags
& F_EXEC
))
250 abfd
->flags
|= EXEC_P
;
251 if (!(internal_f
->f_flags
& F_LNNO
))
252 abfd
->flags
|= HAS_LINENO
;
253 if (!(internal_f
->f_flags
& F_LSYMS
))
254 abfd
->flags
|= HAS_LOCALS
;
256 /* FIXME: How can we set D_PAGED correctly? */
257 if ((internal_f
->f_flags
& F_EXEC
) != 0)
258 abfd
->flags
|= D_PAGED
;
260 abfd
->symcount
= internal_f
->f_nsyms
;
261 if (internal_f
->f_nsyms
)
262 abfd
->flags
|= HAS_SYMS
;
264 if (internal_a
!= (struct internal_aouthdr
*) NULL
)
265 abfd
->start_address
= internal_a
->entry
;
267 abfd
->start_address
= 0;
269 /* Set up the tdata area. ECOFF uses its own routine, and overrides
271 tdata_save
= abfd
->tdata
.any
;
272 tdata
= bfd_coff_mkobject_hook (abfd
, (void *) internal_f
, (void *) internal_a
);
276 scnhsz
= bfd_coff_scnhsz (abfd
);
277 readsize
= (bfd_size_type
) nscns
* scnhsz
;
278 external_sections
= (char *) bfd_alloc (abfd
, readsize
);
279 if (!external_sections
)
282 if (bfd_bread ((void *) external_sections
, readsize
, abfd
) != readsize
)
285 /* Set the arch/mach *before* swapping in sections; section header swapping
286 may depend on arch/mach info. */
287 if (! bfd_coff_set_arch_mach_hook (abfd
, (void *) internal_f
))
290 /* Now copy data as required; construct all asections etc. */
294 for (i
= 0; i
< nscns
; i
++)
296 struct internal_scnhdr tmp
;
297 bfd_coff_swap_scnhdr_in (abfd
,
298 (void *) (external_sections
+ i
* scnhsz
),
300 if (! make_a_section_from_file (abfd
, &tmp
, i
+ 1))
308 obj_coff_keep_syms (abfd
) = FALSE
;
309 obj_coff_keep_strings (abfd
) = FALSE
;
310 _bfd_coff_free_symbols (abfd
);
311 bfd_release (abfd
, tdata
);
313 abfd
->tdata
.any
= tdata_save
;
314 abfd
->flags
= oflags
;
315 abfd
->start_address
= ostart
;
316 return (const bfd_target
*) NULL
;
319 /* Turn a COFF file into a BFD, but fail with bfd_error_wrong_format if it is
320 not a COFF file. This is also used by ECOFF. */
323 coff_object_p (bfd
*abfd
)
325 bfd_size_type filhsz
;
326 bfd_size_type aoutsz
;
329 struct internal_filehdr internal_f
;
330 struct internal_aouthdr internal_a
;
332 /* Figure out how much to read. */
333 filhsz
= bfd_coff_filhsz (abfd
);
334 aoutsz
= bfd_coff_aoutsz (abfd
);
336 filehdr
= bfd_alloc (abfd
, filhsz
);
339 if (bfd_bread (filehdr
, filhsz
, abfd
) != filhsz
)
341 if (bfd_get_error () != bfd_error_system_call
)
342 bfd_set_error (bfd_error_wrong_format
);
343 bfd_release (abfd
, filehdr
);
346 bfd_coff_swap_filehdr_in (abfd
, filehdr
, &internal_f
);
347 bfd_release (abfd
, filehdr
);
349 /* The XCOFF format has two sizes for the f_opthdr. SMALL_AOUTSZ
350 (less than aoutsz) used in object files and AOUTSZ (equal to
351 aoutsz) in executables. The bfd_coff_swap_aouthdr_in function
352 expects this header to be aoutsz bytes in length, so we use that
353 value in the call to bfd_alloc below. But we must be careful to
354 only read in f_opthdr bytes in the call to bfd_bread. We should
355 also attempt to catch corrupt or non-COFF binaries with a strange
356 value for f_opthdr. */
357 if (! bfd_coff_bad_format_hook (abfd
, &internal_f
)
358 || internal_f
.f_opthdr
> aoutsz
)
360 bfd_set_error (bfd_error_wrong_format
);
363 nscns
= internal_f
.f_nscns
;
365 if (internal_f
.f_opthdr
)
369 opthdr
= bfd_alloc (abfd
, aoutsz
);
372 if (bfd_bread (opthdr
, (bfd_size_type
) internal_f
.f_opthdr
, abfd
)
373 != internal_f
.f_opthdr
)
375 bfd_release (abfd
, opthdr
);
378 /* PR 17512: file: 11056-1136-0.004. */
379 if (internal_f
.f_opthdr
< aoutsz
)
380 memset (((char *) opthdr
) + internal_f
.f_opthdr
, 0, aoutsz
- internal_f
.f_opthdr
);
382 bfd_coff_swap_aouthdr_in (abfd
, opthdr
, (void *) &internal_a
);
383 bfd_release (abfd
, opthdr
);
386 return coff_real_object_p (abfd
, nscns
, &internal_f
,
387 (internal_f
.f_opthdr
!= 0
389 : (struct internal_aouthdr
*) NULL
));
392 /* Get the BFD section from a COFF symbol section number. */
395 coff_section_from_bfd_index (bfd
*abfd
, int section_index
)
397 struct bfd_section
*answer
= abfd
->sections
;
399 if (section_index
== N_ABS
)
400 return bfd_abs_section_ptr
;
401 if (section_index
== N_UNDEF
)
402 return bfd_und_section_ptr
;
403 if (section_index
== N_DEBUG
)
404 return bfd_abs_section_ptr
;
408 if (answer
->target_index
== section_index
)
410 answer
= answer
->next
;
413 /* We should not reach this point, but the SCO 3.2v4 /lib/libc_s.a
414 has a bad symbol table in biglitpow.o. */
415 return bfd_und_section_ptr
;
418 /* Get the upper bound of a COFF symbol table. */
421 coff_get_symtab_upper_bound (bfd
*abfd
)
423 if (!bfd_coff_slurp_symbol_table (abfd
))
426 return (bfd_get_symcount (abfd
) + 1) * (sizeof (coff_symbol_type
*));
429 /* Canonicalize a COFF symbol table. */
432 coff_canonicalize_symtab (bfd
*abfd
, asymbol
**alocation
)
434 unsigned int counter
;
435 coff_symbol_type
*symbase
;
436 coff_symbol_type
**location
= (coff_symbol_type
**) alocation
;
438 if (!bfd_coff_slurp_symbol_table (abfd
))
441 symbase
= obj_symbols (abfd
);
442 counter
= bfd_get_symcount (abfd
);
443 while (counter
-- > 0)
444 *location
++ = symbase
++;
448 return bfd_get_symcount (abfd
);
451 /* Get the name of a symbol. The caller must pass in a buffer of size
455 _bfd_coff_internal_syment_name (bfd
*abfd
,
456 const struct internal_syment
*sym
,
459 /* FIXME: It's not clear this will work correctly if sizeof
461 if (sym
->_n
._n_n
._n_zeroes
!= 0
462 || sym
->_n
._n_n
._n_offset
== 0)
464 memcpy (buf
, sym
->_n
._n_name
, SYMNMLEN
);
465 buf
[SYMNMLEN
] = '\0';
472 BFD_ASSERT (sym
->_n
._n_n
._n_offset
>= STRING_SIZE_SIZE
);
473 strings
= obj_coff_strings (abfd
);
476 strings
= _bfd_coff_read_string_table (abfd
);
480 /* PR 17910: Only check for string overflow if the length has been set.
481 Some DLLs, eg those produced by Visual Studio, may not set the length field. */
482 if (obj_coff_strings_len (abfd
) > 0
483 && sym
->_n
._n_n
._n_offset
>= obj_coff_strings_len (abfd
))
485 return strings
+ sym
->_n
._n_n
._n_offset
;
489 /* Read in and swap the relocs. This returns a buffer holding the
490 relocs for section SEC in file ABFD. If CACHE is TRUE and
491 INTERNAL_RELOCS is NULL, the relocs read in will be saved in case
492 the function is called again. If EXTERNAL_RELOCS is not NULL, it
493 is a buffer large enough to hold the unswapped relocs. If
494 INTERNAL_RELOCS is not NULL, it is a buffer large enough to hold
495 the swapped relocs. If REQUIRE_INTERNAL is TRUE, then the return
496 value must be INTERNAL_RELOCS. The function returns NULL on error. */
498 struct internal_reloc
*
499 _bfd_coff_read_internal_relocs (bfd
*abfd
,
502 bfd_byte
*external_relocs
,
503 bfd_boolean require_internal
,
504 struct internal_reloc
*internal_relocs
)
507 bfd_byte
*free_external
= NULL
;
508 struct internal_reloc
*free_internal
= NULL
;
511 struct internal_reloc
*irel
;
514 if (sec
->reloc_count
== 0)
515 return internal_relocs
; /* Nothing to do. */
517 if (coff_section_data (abfd
, sec
) != NULL
518 && coff_section_data (abfd
, sec
)->relocs
!= NULL
)
520 if (! require_internal
)
521 return coff_section_data (abfd
, sec
)->relocs
;
522 memcpy (internal_relocs
, coff_section_data (abfd
, sec
)->relocs
,
523 sec
->reloc_count
* sizeof (struct internal_reloc
));
524 return internal_relocs
;
527 relsz
= bfd_coff_relsz (abfd
);
529 amt
= sec
->reloc_count
* relsz
;
530 if (external_relocs
== NULL
)
532 free_external
= (bfd_byte
*) bfd_malloc (amt
);
533 if (free_external
== NULL
)
535 external_relocs
= free_external
;
538 if (bfd_seek (abfd
, sec
->rel_filepos
, SEEK_SET
) != 0
539 || bfd_bread (external_relocs
, amt
, abfd
) != amt
)
542 if (internal_relocs
== NULL
)
544 amt
= sec
->reloc_count
;
545 amt
*= sizeof (struct internal_reloc
);
546 free_internal
= (struct internal_reloc
*) bfd_malloc (amt
);
547 if (free_internal
== NULL
)
549 internal_relocs
= free_internal
;
552 /* Swap in the relocs. */
553 erel
= external_relocs
;
554 erel_end
= erel
+ relsz
* sec
->reloc_count
;
555 irel
= internal_relocs
;
556 for (; erel
< erel_end
; erel
+= relsz
, irel
++)
557 bfd_coff_swap_reloc_in (abfd
, (void *) erel
, (void *) irel
);
559 if (free_external
!= NULL
)
561 free (free_external
);
562 free_external
= NULL
;
565 if (cache
&& free_internal
!= NULL
)
567 if (coff_section_data (abfd
, sec
) == NULL
)
569 amt
= sizeof (struct coff_section_tdata
);
570 sec
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
571 if (sec
->used_by_bfd
== NULL
)
573 coff_section_data (abfd
, sec
)->contents
= NULL
;
575 coff_section_data (abfd
, sec
)->relocs
= free_internal
;
578 return internal_relocs
;
581 if (free_external
!= NULL
)
582 free (free_external
);
583 if (free_internal
!= NULL
)
584 free (free_internal
);
588 /* Set lineno_count for the output sections of a COFF file. */
591 coff_count_linenumbers (bfd
*abfd
)
593 unsigned int limit
= bfd_get_symcount (abfd
);
601 /* This may be from the backend linker, in which case the
602 lineno_count in the sections is correct. */
603 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
604 total
+= s
->lineno_count
;
608 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
609 BFD_ASSERT (s
->lineno_count
== 0);
611 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
613 asymbol
*q_maybe
= *p
;
615 if (bfd_family_coff (bfd_asymbol_bfd (q_maybe
)))
617 coff_symbol_type
*q
= coffsymbol (q_maybe
);
619 /* The AIX 4.1 compiler can sometimes generate line numbers
620 attached to debugging symbols. We try to simply ignore
622 if (q
->lineno
!= NULL
623 && q
->symbol
.section
->owner
!= NULL
)
625 /* This symbol has line numbers. Increment the owning
626 section's linenumber count. */
627 alent
*l
= q
->lineno
;
631 asection
* sec
= q
->symbol
.section
->output_section
;
633 /* Do not try to update fields in read-only sections. */
634 if (! bfd_is_const_section (sec
))
635 sec
->lineno_count
++;
640 while (l
->line_number
!= 0);
649 fixup_symbol_value (bfd
*abfd
,
650 coff_symbol_type
*coff_symbol_ptr
,
651 struct internal_syment
*syment
)
653 /* Normalize the symbol flags. */
654 if (coff_symbol_ptr
->symbol
.section
655 && bfd_is_com_section (coff_symbol_ptr
->symbol
.section
))
657 /* A common symbol is undefined with a value. */
658 syment
->n_scnum
= N_UNDEF
;
659 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
661 else if ((coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
) != 0
662 && (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING_RELOC
) == 0)
664 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
666 else if (bfd_is_und_section (coff_symbol_ptr
->symbol
.section
))
668 syment
->n_scnum
= N_UNDEF
;
671 /* FIXME: Do we need to handle the absolute section here? */
674 if (coff_symbol_ptr
->symbol
.section
)
677 coff_symbol_ptr
->symbol
.section
->output_section
->target_index
;
679 syment
->n_value
= (coff_symbol_ptr
->symbol
.value
680 + coff_symbol_ptr
->symbol
.section
->output_offset
);
683 syment
->n_value
+= (syment
->n_sclass
== C_STATLAB
)
684 ? coff_symbol_ptr
->symbol
.section
->output_section
->lma
685 : coff_symbol_ptr
->symbol
.section
->output_section
->vma
;
691 /* This can happen, but I don't know why yet (steve@cygnus.com) */
692 syment
->n_scnum
= N_ABS
;
693 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
698 /* Run through all the symbols in the symbol table and work out what
699 their indexes into the symbol table will be when output.
701 Coff requires that each C_FILE symbol points to the next one in the
702 chain, and that the last one points to the first external symbol. We
706 coff_renumber_symbols (bfd
*bfd_ptr
, int *first_undef
)
708 unsigned int symbol_count
= bfd_get_symcount (bfd_ptr
);
709 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
710 unsigned int native_index
= 0;
711 struct internal_syment
*last_file
= NULL
;
712 unsigned int symbol_index
;
714 /* COFF demands that undefined symbols come after all other symbols.
715 Since we don't need to impose this extra knowledge on all our
716 client programs, deal with that here. Sort the symbol table;
717 just move the undefined symbols to the end, leaving the rest
718 alone. The O'Reilly book says that defined global symbols come
719 at the end before the undefined symbols, so we do that here as
721 /* @@ Do we have some condition we could test for, so we don't always
722 have to do this? I don't think relocatability is quite right, but
723 I'm not certain. [raeburn:19920508.1711EST] */
729 amt
= sizeof (asymbol
*) * ((bfd_size_type
) symbol_count
+ 1);
730 newsyms
= (asymbol
**) bfd_alloc (bfd_ptr
, amt
);
733 bfd_ptr
->outsymbols
= newsyms
;
734 for (i
= 0; i
< symbol_count
; i
++)
735 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) != 0
736 || (!bfd_is_und_section (symbol_ptr_ptr
[i
]->section
)
737 && !bfd_is_com_section (symbol_ptr_ptr
[i
]->section
)
738 && ((symbol_ptr_ptr
[i
]->flags
& BSF_FUNCTION
) != 0
739 || ((symbol_ptr_ptr
[i
]->flags
& (BSF_GLOBAL
| BSF_WEAK
))
741 *newsyms
++ = symbol_ptr_ptr
[i
];
743 for (i
= 0; i
< symbol_count
; i
++)
744 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) == 0
745 && !bfd_is_und_section (symbol_ptr_ptr
[i
]->section
)
746 && (bfd_is_com_section (symbol_ptr_ptr
[i
]->section
)
747 || ((symbol_ptr_ptr
[i
]->flags
& BSF_FUNCTION
) == 0
748 && ((symbol_ptr_ptr
[i
]->flags
& (BSF_GLOBAL
| BSF_WEAK
))
750 *newsyms
++ = symbol_ptr_ptr
[i
];
752 *first_undef
= newsyms
- bfd_ptr
->outsymbols
;
754 for (i
= 0; i
< symbol_count
; i
++)
755 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) == 0
756 && bfd_is_und_section (symbol_ptr_ptr
[i
]->section
))
757 *newsyms
++ = symbol_ptr_ptr
[i
];
758 *newsyms
= (asymbol
*) NULL
;
759 symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
762 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
764 coff_symbol_type
*coff_symbol_ptr
;
766 coff_symbol_ptr
= coff_symbol_from (symbol_ptr_ptr
[symbol_index
]);
767 symbol_ptr_ptr
[symbol_index
]->udata
.i
= symbol_index
;
768 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
)
770 combined_entry_type
*s
= coff_symbol_ptr
->native
;
773 BFD_ASSERT (s
->is_sym
);
774 if (s
->u
.syment
.n_sclass
== C_FILE
)
776 if (last_file
!= NULL
)
777 last_file
->n_value
= native_index
;
778 last_file
= &(s
->u
.syment
);
781 /* Modify the symbol values according to their section and
783 fixup_symbol_value (bfd_ptr
, coff_symbol_ptr
, &(s
->u
.syment
));
785 for (i
= 0; i
< s
->u
.syment
.n_numaux
+ 1; i
++)
786 s
[i
].offset
= native_index
++;
792 obj_conv_table_size (bfd_ptr
) = native_index
;
797 /* Run thorough the symbol table again, and fix it so that all
798 pointers to entries are changed to the entries' index in the output
802 coff_mangle_symbols (bfd
*bfd_ptr
)
804 unsigned int symbol_count
= bfd_get_symcount (bfd_ptr
);
805 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
806 unsigned int symbol_index
;
808 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
810 coff_symbol_type
*coff_symbol_ptr
;
812 coff_symbol_ptr
= coff_symbol_from (symbol_ptr_ptr
[symbol_index
]);
813 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
)
816 combined_entry_type
*s
= coff_symbol_ptr
->native
;
818 BFD_ASSERT (s
->is_sym
);
821 /* FIXME: We should use a union here. */
822 s
->u
.syment
.n_value
=
823 (bfd_hostptr_t
) ((combined_entry_type
*)
824 ((bfd_hostptr_t
) s
->u
.syment
.n_value
))->offset
;
829 /* The value is the offset into the line number entries
830 for the symbol's section. On output, the symbol's
831 section should be N_DEBUG. */
832 s
->u
.syment
.n_value
=
833 (coff_symbol_ptr
->symbol
.section
->output_section
->line_filepos
834 + s
->u
.syment
.n_value
* bfd_coff_linesz (bfd_ptr
));
835 coff_symbol_ptr
->symbol
.section
=
836 coff_section_from_bfd_index (bfd_ptr
, N_DEBUG
);
837 BFD_ASSERT (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
);
839 for (i
= 0; i
< s
->u
.syment
.n_numaux
; i
++)
841 combined_entry_type
*a
= s
+ i
+ 1;
843 BFD_ASSERT (! a
->is_sym
);
846 a
->u
.auxent
.x_sym
.x_tagndx
.l
=
847 a
->u
.auxent
.x_sym
.x_tagndx
.p
->offset
;
852 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
853 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
->offset
;
858 a
->u
.auxent
.x_csect
.x_scnlen
.l
=
859 a
->u
.auxent
.x_csect
.x_scnlen
.p
->offset
;
868 coff_fix_symbol_name (bfd
*abfd
,
870 combined_entry_type
*native
,
871 bfd_size_type
*string_size_p
,
872 asection
**debug_string_section_p
,
873 bfd_size_type
*debug_string_size_p
)
875 unsigned int name_length
;
876 union internal_auxent
*auxent
;
877 char *name
= (char *) (symbol
->name
);
881 /* COFF symbols always have names, so we'll make one up. */
882 symbol
->name
= "strange";
883 name
= (char *) symbol
->name
;
885 name_length
= strlen (name
);
887 BFD_ASSERT (native
->is_sym
);
888 if (native
->u
.syment
.n_sclass
== C_FILE
889 && native
->u
.syment
.n_numaux
> 0)
891 unsigned int filnmlen
;
893 if (bfd_coff_force_symnames_in_strings (abfd
))
895 native
->u
.syment
._n
._n_n
._n_offset
=
896 (*string_size_p
+ STRING_SIZE_SIZE
);
897 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
898 *string_size_p
+= 6; /* strlen(".file") + 1 */
901 strncpy (native
->u
.syment
._n
._n_name
, ".file", SYMNMLEN
);
903 BFD_ASSERT (! (native
+ 1)->is_sym
);
904 auxent
= &(native
+ 1)->u
.auxent
;
906 filnmlen
= bfd_coff_filnmlen (abfd
);
908 if (bfd_coff_long_filenames (abfd
))
910 if (name_length
<= filnmlen
)
911 strncpy (auxent
->x_file
.x_fname
, name
, filnmlen
);
914 auxent
->x_file
.x_n
.x_offset
= *string_size_p
+ STRING_SIZE_SIZE
;
915 auxent
->x_file
.x_n
.x_zeroes
= 0;
916 *string_size_p
+= name_length
+ 1;
921 strncpy (auxent
->x_file
.x_fname
, name
, filnmlen
);
922 if (name_length
> filnmlen
)
923 name
[filnmlen
] = '\0';
928 if (name_length
<= SYMNMLEN
&& !bfd_coff_force_symnames_in_strings (abfd
))
929 /* This name will fit into the symbol neatly. */
930 strncpy (native
->u
.syment
._n
._n_name
, symbol
->name
, SYMNMLEN
);
932 else if (!bfd_coff_symname_in_debug (abfd
, &native
->u
.syment
))
934 native
->u
.syment
._n
._n_n
._n_offset
= (*string_size_p
936 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
937 *string_size_p
+= name_length
+ 1;
943 int prefix_len
= bfd_coff_debug_string_prefix_length (abfd
);
945 /* This name should be written into the .debug section. For
946 some reason each name is preceded by a two byte length
947 and also followed by a null byte. FIXME: We assume that
948 the .debug section has already been created, and that it
950 if (*debug_string_section_p
== (asection
*) NULL
)
951 *debug_string_section_p
= bfd_get_section_by_name (abfd
, ".debug");
952 filepos
= bfd_tell (abfd
);
954 bfd_put_32 (abfd
, (bfd_vma
) (name_length
+ 1), buf
);
956 bfd_put_16 (abfd
, (bfd_vma
) (name_length
+ 1), buf
);
958 if (!bfd_set_section_contents (abfd
,
959 *debug_string_section_p
,
961 (file_ptr
) *debug_string_size_p
,
962 (bfd_size_type
) prefix_len
)
963 || !bfd_set_section_contents (abfd
,
964 *debug_string_section_p
,
965 (void *) symbol
->name
,
966 (file_ptr
) (*debug_string_size_p
968 (bfd_size_type
) name_length
+ 1))
970 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
972 native
->u
.syment
._n
._n_n
._n_offset
=
973 *debug_string_size_p
+ prefix_len
;
974 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
975 *debug_string_size_p
+= name_length
+ 1 + prefix_len
;
980 /* We need to keep track of the symbol index so that when we write out
981 the relocs we can get the index for a symbol. This method is a
984 #define set_index(symbol, idx) ((symbol)->udata.i = (idx))
986 /* Write a symbol out to a COFF file. */
989 coff_write_symbol (bfd
*abfd
,
991 combined_entry_type
*native
,
993 bfd_size_type
*string_size_p
,
994 asection
**debug_string_section_p
,
995 bfd_size_type
*debug_string_size_p
)
997 unsigned int numaux
= native
->u
.syment
.n_numaux
;
998 int type
= native
->u
.syment
.n_type
;
999 int n_sclass
= (int) native
->u
.syment
.n_sclass
;
1000 asection
*output_section
= symbol
->section
->output_section
1001 ? symbol
->section
->output_section
1004 bfd_size_type symesz
;
1006 BFD_ASSERT (native
->is_sym
);
1008 if (native
->u
.syment
.n_sclass
== C_FILE
)
1009 symbol
->flags
|= BSF_DEBUGGING
;
1011 if (symbol
->flags
& BSF_DEBUGGING
1012 && bfd_is_abs_section (symbol
->section
))
1013 native
->u
.syment
.n_scnum
= N_DEBUG
;
1015 else if (bfd_is_abs_section (symbol
->section
))
1016 native
->u
.syment
.n_scnum
= N_ABS
;
1018 else if (bfd_is_und_section (symbol
->section
))
1019 native
->u
.syment
.n_scnum
= N_UNDEF
;
1022 native
->u
.syment
.n_scnum
=
1023 output_section
->target_index
;
1025 coff_fix_symbol_name (abfd
, symbol
, native
, string_size_p
,
1026 debug_string_section_p
, debug_string_size_p
);
1028 symesz
= bfd_coff_symesz (abfd
);
1029 buf
= bfd_alloc (abfd
, symesz
);
1032 bfd_coff_swap_sym_out (abfd
, &native
->u
.syment
, buf
);
1033 if (bfd_bwrite (buf
, symesz
, abfd
) != symesz
)
1035 bfd_release (abfd
, buf
);
1037 if (native
->u
.syment
.n_numaux
> 0)
1039 bfd_size_type auxesz
;
1042 auxesz
= bfd_coff_auxesz (abfd
);
1043 buf
= bfd_alloc (abfd
, auxesz
);
1046 for (j
= 0; j
< native
->u
.syment
.n_numaux
; j
++)
1048 BFD_ASSERT (! (native
+ j
+ 1)->is_sym
);
1049 bfd_coff_swap_aux_out (abfd
,
1050 &((native
+ j
+ 1)->u
.auxent
),
1051 type
, n_sclass
, (int) j
,
1052 native
->u
.syment
.n_numaux
,
1054 if (bfd_bwrite (buf
, auxesz
, abfd
) != auxesz
)
1057 bfd_release (abfd
, buf
);
1060 /* Store the index for use when we write out the relocs. */
1061 set_index (symbol
, *written
);
1063 *written
+= numaux
+ 1;
1067 /* Write out a symbol to a COFF file that does not come from a COFF
1068 file originally. This symbol may have been created by the linker,
1069 or we may be linking a non COFF file to a COFF file. */
1072 coff_write_alien_symbol (bfd
*abfd
,
1074 struct internal_syment
*isym
,
1075 union internal_auxent
*iaux
,
1077 bfd_size_type
*string_size_p
,
1078 asection
**debug_string_section_p
,
1079 bfd_size_type
*debug_string_size_p
)
1081 combined_entry_type
*native
;
1082 combined_entry_type dummy
[2];
1083 asection
*output_section
= symbol
->section
->output_section
1084 ? symbol
->section
->output_section
1086 struct bfd_link_info
*link_info
= coff_data (abfd
)->link_info
;
1089 if ((!link_info
|| link_info
->strip_discarded
)
1090 && !bfd_is_abs_section (symbol
->section
)
1091 && symbol
->section
->output_section
== bfd_abs_section_ptr
)
1095 memset (isym
, 0, sizeof (*isym
));
1099 native
->is_sym
= TRUE
;
1100 native
[1].is_sym
= FALSE
;
1101 native
->u
.syment
.n_type
= T_NULL
;
1102 native
->u
.syment
.n_flags
= 0;
1103 native
->u
.syment
.n_numaux
= 0;
1104 if (bfd_is_und_section (symbol
->section
))
1106 native
->u
.syment
.n_scnum
= N_UNDEF
;
1107 native
->u
.syment
.n_value
= symbol
->value
;
1109 else if (bfd_is_com_section (symbol
->section
))
1111 native
->u
.syment
.n_scnum
= N_UNDEF
;
1112 native
->u
.syment
.n_value
= symbol
->value
;
1114 else if (symbol
->flags
& BSF_FILE
)
1116 native
->u
.syment
.n_scnum
= N_DEBUG
;
1117 native
->u
.syment
.n_numaux
= 1;
1119 else if (symbol
->flags
& BSF_DEBUGGING
)
1121 /* There isn't much point to writing out a debugging symbol
1122 unless we are prepared to convert it into COFF debugging
1123 format. So, we just ignore them. We must clobber the symbol
1124 name to keep it from being put in the string table. */
1127 memset (isym
, 0, sizeof (*isym
));
1132 native
->u
.syment
.n_scnum
= output_section
->target_index
;
1133 native
->u
.syment
.n_value
= (symbol
->value
1134 + symbol
->section
->output_offset
);
1135 if (! obj_pe (abfd
))
1136 native
->u
.syment
.n_value
+= output_section
->vma
;
1138 /* Copy the any flags from the file header into the symbol.
1141 coff_symbol_type
*c
= coff_symbol_from (symbol
);
1142 if (c
!= (coff_symbol_type
*) NULL
)
1143 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (&c
->symbol
)->flags
;
1147 native
->u
.syment
.n_type
= 0;
1148 if (symbol
->flags
& BSF_FILE
)
1149 native
->u
.syment
.n_sclass
= C_FILE
;
1150 else if (symbol
->flags
& BSF_LOCAL
)
1151 native
->u
.syment
.n_sclass
= C_STAT
;
1152 else if (symbol
->flags
& BSF_WEAK
)
1153 native
->u
.syment
.n_sclass
= obj_pe (abfd
) ? C_NT_WEAK
: C_WEAKEXT
;
1155 native
->u
.syment
.n_sclass
= C_EXT
;
1157 ret
= coff_write_symbol (abfd
, symbol
, native
, written
, string_size_p
,
1158 debug_string_section_p
, debug_string_size_p
);
1160 *isym
= native
->u
.syment
;
1161 if (iaux
!= NULL
&& native
->u
.syment
.n_numaux
)
1162 *iaux
= native
[1].u
.auxent
;
1166 /* Write a native symbol to a COFF file. */
1169 coff_write_native_symbol (bfd
*abfd
,
1170 coff_symbol_type
*symbol
,
1172 bfd_size_type
*string_size_p
,
1173 asection
**debug_string_section_p
,
1174 bfd_size_type
*debug_string_size_p
)
1176 combined_entry_type
*native
= symbol
->native
;
1177 alent
*lineno
= symbol
->lineno
;
1178 struct bfd_link_info
*link_info
= coff_data (abfd
)->link_info
;
1180 if ((!link_info
|| link_info
->strip_discarded
)
1181 && !bfd_is_abs_section (symbol
->symbol
.section
)
1182 && symbol
->symbol
.section
->output_section
== bfd_abs_section_ptr
)
1184 symbol
->symbol
.name
= "";
1188 BFD_ASSERT (native
->is_sym
);
1189 /* If this symbol has an associated line number, we must store the
1190 symbol index in the line number field. We also tag the auxent to
1191 point to the right place in the lineno table. */
1192 if (lineno
&& !symbol
->done_lineno
&& symbol
->symbol
.section
->owner
!= NULL
)
1194 unsigned int count
= 0;
1196 lineno
[count
].u
.offset
= *written
;
1197 if (native
->u
.syment
.n_numaux
)
1199 union internal_auxent
*a
= &((native
+ 1)->u
.auxent
);
1201 a
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1202 symbol
->symbol
.section
->output_section
->moving_line_filepos
;
1205 /* Count and relocate all other linenumbers. */
1207 while (lineno
[count
].line_number
!= 0)
1209 lineno
[count
].u
.offset
+=
1210 (symbol
->symbol
.section
->output_section
->vma
1211 + symbol
->symbol
.section
->output_offset
);
1214 symbol
->done_lineno
= TRUE
;
1216 if (! bfd_is_const_section (symbol
->symbol
.section
->output_section
))
1217 symbol
->symbol
.section
->output_section
->moving_line_filepos
+=
1218 count
* bfd_coff_linesz (abfd
);
1221 return coff_write_symbol (abfd
, &(symbol
->symbol
), native
, written
,
1222 string_size_p
, debug_string_section_p
,
1223 debug_string_size_p
);
1227 null_error_handler (const char *fmt ATTRIBUTE_UNUSED
,
1228 va_list ap ATTRIBUTE_UNUSED
)
1232 /* Write out the COFF symbols. */
1235 coff_write_symbols (bfd
*abfd
)
1237 bfd_size_type string_size
;
1238 asection
*debug_string_section
;
1239 bfd_size_type debug_string_size
;
1241 unsigned int limit
= bfd_get_symcount (abfd
);
1242 bfd_vma written
= 0;
1246 debug_string_section
= NULL
;
1247 debug_string_size
= 0;
1249 /* If this target supports long section names, they must be put into
1250 the string table. This is supported by PE. This code must
1251 handle section names just as they are handled in
1252 coff_write_object_contents. */
1253 if (bfd_coff_long_section_names (abfd
))
1257 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1261 len
= strlen (o
->name
);
1263 string_size
+= len
+ 1;
1267 /* Seek to the right place. */
1268 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
1271 /* Output all the symbols we have. */
1273 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1275 asymbol
*symbol
= *p
;
1276 coff_symbol_type
*c_symbol
= coff_symbol_from (symbol
);
1278 if (c_symbol
== (coff_symbol_type
*) NULL
1279 || c_symbol
->native
== (combined_entry_type
*) NULL
)
1281 if (!coff_write_alien_symbol (abfd
, symbol
, NULL
, NULL
, &written
,
1282 &string_size
, &debug_string_section
,
1283 &debug_string_size
))
1288 if (coff_backend_info (abfd
)->_bfd_coff_classify_symbol
!= NULL
)
1290 bfd_error_handler_type current_error_handler
;
1291 enum coff_symbol_classification sym_class
;
1292 unsigned char *n_sclass
;
1294 /* Suppress error reporting by bfd_coff_classify_symbol.
1295 Error messages can be generated when we are processing a local
1296 symbol which has no associated section and we do not have to
1297 worry about this, all we need to know is that it is local. */
1298 current_error_handler
= bfd_set_error_handler (null_error_handler
);
1299 BFD_ASSERT (c_symbol
->native
->is_sym
);
1300 sym_class
= bfd_coff_classify_symbol (abfd
,
1301 &c_symbol
->native
->u
.syment
);
1302 (void) bfd_set_error_handler (current_error_handler
);
1304 n_sclass
= &c_symbol
->native
->u
.syment
.n_sclass
;
1306 /* If the symbol class has been changed (eg objcopy/ld script/etc)
1307 we cannot retain the existing sclass from the original symbol.
1308 Weak symbols only have one valid sclass, so just set it always.
1309 If it is not local class and should be, set it C_STAT.
1310 If it is global and not classified as global, or if it is
1311 weak (which is also classified as global), set it C_EXT. */
1313 if (symbol
->flags
& BSF_WEAK
)
1314 *n_sclass
= obj_pe (abfd
) ? C_NT_WEAK
: C_WEAKEXT
;
1315 else if (symbol
->flags
& BSF_LOCAL
&& sym_class
!= COFF_SYMBOL_LOCAL
)
1317 else if (symbol
->flags
& BSF_GLOBAL
1318 && (sym_class
!= COFF_SYMBOL_GLOBAL
1320 || *n_sclass
== C_NT_WEAK
1322 || *n_sclass
== C_WEAKEXT
))
1323 c_symbol
->native
->u
.syment
.n_sclass
= C_EXT
;
1326 if (!coff_write_native_symbol (abfd
, c_symbol
, &written
,
1327 &string_size
, &debug_string_section
,
1328 &debug_string_size
))
1333 obj_raw_syment_count (abfd
) = written
;
1335 /* Now write out strings. */
1336 if (string_size
!= 0)
1338 unsigned int size
= string_size
+ STRING_SIZE_SIZE
;
1339 bfd_byte buffer
[STRING_SIZE_SIZE
];
1341 #if STRING_SIZE_SIZE == 4
1342 H_PUT_32 (abfd
, size
, buffer
);
1344 #error Change H_PUT_32
1346 if (bfd_bwrite ((void *) buffer
, (bfd_size_type
) sizeof (buffer
), abfd
)
1350 /* Handle long section names. This code must handle section
1351 names just as they are handled in coff_write_object_contents. */
1352 if (bfd_coff_long_section_names (abfd
))
1356 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1360 len
= strlen (o
->name
);
1363 if (bfd_bwrite (o
->name
, (bfd_size_type
) (len
+ 1), abfd
)
1370 for (p
= abfd
->outsymbols
, i
= 0;
1375 size_t name_length
= strlen (q
->name
);
1376 coff_symbol_type
*c_symbol
= coff_symbol_from (q
);
1379 /* Figure out whether the symbol name should go in the string
1380 table. Symbol names that are short enough are stored
1381 directly in the syment structure. File names permit a
1382 different, longer, length in the syment structure. On
1383 XCOFF, some symbol names are stored in the .debug section
1384 rather than in the string table. */
1386 if (c_symbol
== NULL
1387 || c_symbol
->native
== NULL
)
1388 /* This is not a COFF symbol, so it certainly is not a
1389 file name, nor does it go in the .debug section. */
1390 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1392 else if (! c_symbol
->native
->is_sym
)
1393 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1395 else if (bfd_coff_symname_in_debug (abfd
,
1396 &c_symbol
->native
->u
.syment
))
1397 /* This symbol name is in the XCOFF .debug section.
1398 Don't write it into the string table. */
1399 maxlen
= name_length
;
1401 else if (c_symbol
->native
->u
.syment
.n_sclass
== C_FILE
1402 && c_symbol
->native
->u
.syment
.n_numaux
> 0)
1404 if (bfd_coff_force_symnames_in_strings (abfd
))
1406 if (bfd_bwrite (".file", (bfd_size_type
) 6, abfd
) != 6)
1409 maxlen
= bfd_coff_filnmlen (abfd
);
1412 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1414 if (name_length
> maxlen
)
1416 if (bfd_bwrite ((void *) (q
->name
), (bfd_size_type
) name_length
+ 1,
1417 abfd
) != name_length
+ 1)
1424 /* We would normally not write anything here, but we'll write
1425 out 4 so that any stupid coff reader which tries to read the
1426 string table even when there isn't one won't croak. */
1427 unsigned int size
= STRING_SIZE_SIZE
;
1428 bfd_byte buffer
[STRING_SIZE_SIZE
];
1430 #if STRING_SIZE_SIZE == 4
1431 H_PUT_32 (abfd
, size
, buffer
);
1433 #error Change H_PUT_32
1435 if (bfd_bwrite ((void *) buffer
, (bfd_size_type
) STRING_SIZE_SIZE
, abfd
)
1436 != STRING_SIZE_SIZE
)
1440 /* Make sure the .debug section was created to be the correct size.
1441 We should create it ourselves on the fly, but we don't because
1442 BFD won't let us write to any section until we know how large all
1443 the sections are. We could still do it by making another pass
1444 over the symbols. FIXME. */
1445 BFD_ASSERT (debug_string_size
== 0
1446 || (debug_string_section
!= (asection
*) NULL
1447 && (BFD_ALIGN (debug_string_size
,
1448 1 << debug_string_section
->alignment_power
)
1449 == debug_string_section
->size
)));
1455 coff_write_linenumbers (bfd
*abfd
)
1458 bfd_size_type linesz
;
1461 linesz
= bfd_coff_linesz (abfd
);
1462 buff
= bfd_alloc (abfd
, linesz
);
1465 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
1467 if (s
->lineno_count
)
1469 asymbol
**q
= abfd
->outsymbols
;
1470 if (bfd_seek (abfd
, s
->line_filepos
, SEEK_SET
) != 0)
1472 /* Find all the linenumbers in this section. */
1476 if (p
->section
->output_section
== s
)
1479 BFD_SEND (bfd_asymbol_bfd (p
), _get_lineno
,
1480 (bfd_asymbol_bfd (p
), p
));
1483 /* Found a linenumber entry, output. */
1484 struct internal_lineno out
;
1486 memset ((void *) & out
, 0, sizeof (out
));
1488 out
.l_addr
.l_symndx
= l
->u
.offset
;
1489 bfd_coff_swap_lineno_out (abfd
, &out
, buff
);
1490 if (bfd_bwrite (buff
, (bfd_size_type
) linesz
, abfd
)
1494 while (l
->line_number
)
1496 out
.l_lnno
= l
->line_number
;
1497 out
.l_addr
.l_symndx
= l
->u
.offset
;
1498 bfd_coff_swap_lineno_out (abfd
, &out
, buff
);
1499 if (bfd_bwrite (buff
, (bfd_size_type
) linesz
, abfd
)
1510 bfd_release (abfd
, buff
);
1515 coff_get_lineno (bfd
*ignore_abfd ATTRIBUTE_UNUSED
, asymbol
*symbol
)
1517 return coffsymbol (symbol
)->lineno
;
1520 /* This function transforms the offsets into the symbol table into
1521 pointers to syments. */
1524 coff_pointerize_aux (bfd
*abfd
,
1525 combined_entry_type
*table_base
,
1526 combined_entry_type
*symbol
,
1527 unsigned int indaux
,
1528 combined_entry_type
*auxent
,
1529 combined_entry_type
*table_end
)
1531 unsigned int type
= symbol
->u
.syment
.n_type
;
1532 unsigned int n_sclass
= symbol
->u
.syment
.n_sclass
;
1534 BFD_ASSERT (symbol
->is_sym
);
1535 if (coff_backend_info (abfd
)->_bfd_coff_pointerize_aux_hook
)
1537 if ((*coff_backend_info (abfd
)->_bfd_coff_pointerize_aux_hook
)
1538 (abfd
, table_base
, symbol
, indaux
, auxent
))
1542 /* Don't bother if this is a file or a section. */
1543 if (n_sclass
== C_STAT
&& type
== T_NULL
)
1545 if (n_sclass
== C_FILE
)
1548 BFD_ASSERT (! auxent
->is_sym
);
1549 /* Otherwise patch up. */
1550 #define N_TMASK coff_data (abfd)->local_n_tmask
1551 #define N_BTSHFT coff_data (abfd)->local_n_btshft
1553 if ((ISFCN (type
) || ISTAG (n_sclass
) || n_sclass
== C_BLOCK
1554 || n_sclass
== C_FCN
)
1555 && auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
> 0
1556 && auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
1557 < (long) obj_raw_syment_count (abfd
)
1558 && table_base
+ auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
1561 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
=
1562 table_base
+ auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
1563 auxent
->fix_end
= 1;
1566 /* A negative tagndx is meaningless, but the SCO 3.2v4 cc can
1567 generate one, so we must be careful to ignore it. */
1568 if ((unsigned long) auxent
->u
.auxent
.x_sym
.x_tagndx
.l
1569 < obj_raw_syment_count (abfd
)
1570 && table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
< table_end
)
1572 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
=
1573 table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
;
1574 auxent
->fix_tag
= 1;
1578 /* Allocate space for the ".debug" section, and read it.
1579 We did not read the debug section until now, because
1580 we didn't want to go to the trouble until someone needed it. */
1583 build_debug_section (bfd
*abfd
, asection
** sect_return
)
1585 char *debug_section
;
1587 bfd_size_type sec_size
;
1589 asection
*sect
= bfd_get_section_by_name (abfd
, ".debug");
1593 bfd_set_error (bfd_error_no_debug_section
);
1597 sec_size
= sect
->size
;
1598 debug_section
= (char *) bfd_alloc (abfd
, sec_size
);
1599 if (debug_section
== NULL
)
1602 /* Seek to the beginning of the `.debug' section and read it.
1603 Save the current position first; it is needed by our caller.
1604 Then read debug section and reset the file pointer. */
1606 position
= bfd_tell (abfd
);
1607 if (bfd_seek (abfd
, sect
->filepos
, SEEK_SET
) != 0
1608 || bfd_bread (debug_section
, sec_size
, abfd
) != sec_size
1609 || bfd_seek (abfd
, position
, SEEK_SET
) != 0)
1612 * sect_return
= sect
;
1613 return debug_section
;
1616 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
1617 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
1618 be \0-terminated. */
1621 copy_name (bfd
*abfd
, char *name
, size_t maxlen
)
1626 for (len
= 0; len
< maxlen
; ++len
)
1627 if (name
[len
] == '\0')
1630 if ((newname
= (char *) bfd_alloc (abfd
, (bfd_size_type
) len
+ 1)) == NULL
)
1633 strncpy (newname
, name
, len
);
1634 newname
[len
] = '\0';
1638 /* Read in the external symbols. */
1641 _bfd_coff_get_external_symbols (bfd
*abfd
)
1643 bfd_size_type symesz
;
1647 if (obj_coff_external_syms (abfd
) != NULL
)
1650 symesz
= bfd_coff_symesz (abfd
);
1652 size
= obj_raw_syment_count (abfd
) * symesz
;
1655 /* Check for integer overflow and for unreasonable symbol counts. */
1656 if (size
< obj_raw_syment_count (abfd
)
1657 || (bfd_get_file_size (abfd
) > 0
1658 && size
> bfd_get_file_size (abfd
)))
1661 _bfd_error_handler (_("%pB: corrupt symbol count: %#" PRIx64
""),
1662 abfd
, (uint64_t) obj_raw_syment_count (abfd
));
1666 syms
= bfd_malloc (size
);
1669 /* PR 21013: Provide an error message when the alloc fails. */
1670 _bfd_error_handler (_("%pB: not enough memory to allocate space "
1671 "for %#" PRIx64
" symbols of size %#" PRIx64
),
1672 abfd
, (uint64_t) obj_raw_syment_count (abfd
),
1677 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
1678 || bfd_bread (syms
, size
, abfd
) != size
)
1685 obj_coff_external_syms (abfd
) = syms
;
1689 /* Read in the external strings. The strings are not loaded until
1690 they are needed. This is because we have no simple way of
1691 detecting a missing string table in an archive. If the strings
1692 are loaded then the STRINGS and STRINGS_LEN fields in the
1693 coff_tdata structure will be set. */
1696 _bfd_coff_read_string_table (bfd
*abfd
)
1698 char extstrsize
[STRING_SIZE_SIZE
];
1699 bfd_size_type strsize
;
1703 if (obj_coff_strings (abfd
) != NULL
)
1704 return obj_coff_strings (abfd
);
1706 if (obj_sym_filepos (abfd
) == 0)
1708 bfd_set_error (bfd_error_no_symbols
);
1712 pos
= obj_sym_filepos (abfd
);
1713 pos
+= obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
1714 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
1717 if (bfd_bread (extstrsize
, (bfd_size_type
) sizeof extstrsize
, abfd
)
1718 != sizeof extstrsize
)
1720 if (bfd_get_error () != bfd_error_file_truncated
)
1723 /* There is no string table. */
1724 strsize
= STRING_SIZE_SIZE
;
1728 #if STRING_SIZE_SIZE == 4
1729 strsize
= H_GET_32 (abfd
, extstrsize
);
1731 #error Change H_GET_32
1735 if (strsize
< STRING_SIZE_SIZE
|| strsize
> bfd_get_file_size (abfd
))
1738 /* xgettext: c-format */
1739 (_("%pB: bad string table size %" PRIu64
), abfd
, (uint64_t) strsize
);
1740 bfd_set_error (bfd_error_bad_value
);
1744 strings
= (char *) bfd_malloc (strsize
+ 1);
1745 if (strings
== NULL
)
1748 /* PR 17521 file: 079-54929-0.004.
1749 A corrupt file could contain an index that points into the first
1750 STRING_SIZE_SIZE bytes of the string table, so make sure that
1752 memset (strings
, 0, STRING_SIZE_SIZE
);
1754 if (bfd_bread (strings
+ STRING_SIZE_SIZE
, strsize
- STRING_SIZE_SIZE
, abfd
)
1755 != strsize
- STRING_SIZE_SIZE
)
1761 obj_coff_strings (abfd
) = strings
;
1762 obj_coff_strings_len (abfd
) = strsize
;
1763 /* Terminate the string table, just in case. */
1764 strings
[strsize
] = 0;
1768 /* Free up the external symbols and strings read from a COFF file. */
1771 _bfd_coff_free_symbols (bfd
*abfd
)
1773 if (! bfd_family_coff (abfd
))
1776 if (obj_coff_external_syms (abfd
) != NULL
1777 && ! obj_coff_keep_syms (abfd
))
1779 free (obj_coff_external_syms (abfd
));
1780 obj_coff_external_syms (abfd
) = NULL
;
1783 if (obj_coff_strings (abfd
) != NULL
1784 && ! obj_coff_keep_strings (abfd
))
1786 free (obj_coff_strings (abfd
));
1787 obj_coff_strings (abfd
) = NULL
;
1788 obj_coff_strings_len (abfd
) = 0;
1794 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
1795 knit the symbol names into a normalized form. By normalized here I
1796 mean that all symbols have an n_offset pointer that points to a null-
1797 terminated string. */
1799 combined_entry_type
*
1800 coff_get_normalized_symtab (bfd
*abfd
)
1802 combined_entry_type
*internal
;
1803 combined_entry_type
*internal_ptr
;
1804 combined_entry_type
*symbol_ptr
;
1805 combined_entry_type
*internal_end
;
1809 const char *string_table
= NULL
;
1810 asection
* debug_sec
= NULL
;
1811 char *debug_sec_data
= NULL
;
1814 if (obj_raw_syments (abfd
) != NULL
)
1815 return obj_raw_syments (abfd
);
1817 if (! _bfd_coff_get_external_symbols (abfd
))
1820 size
= obj_raw_syment_count (abfd
);
1821 /* Check for integer overflow. */
1822 if (size
> (bfd_size_type
) -1 / sizeof (combined_entry_type
))
1824 size
*= sizeof (combined_entry_type
);
1825 internal
= (combined_entry_type
*) bfd_zalloc (abfd
, size
);
1826 if (internal
== NULL
&& size
!= 0)
1828 internal_end
= internal
+ obj_raw_syment_count (abfd
);
1830 raw_src
= (char *) obj_coff_external_syms (abfd
);
1832 /* Mark the end of the symbols. */
1833 symesz
= bfd_coff_symesz (abfd
);
1834 raw_end
= (char *) raw_src
+ obj_raw_syment_count (abfd
) * symesz
;
1836 /* FIXME SOMEDAY. A string table size of zero is very weird, but
1837 probably possible. If one shows up, it will probably kill us. */
1839 /* Swap all the raw entries. */
1840 for (internal_ptr
= internal
;
1842 raw_src
+= symesz
, internal_ptr
++)
1846 bfd_coff_swap_sym_in (abfd
, (void *) raw_src
,
1847 (void *) & internal_ptr
->u
.syment
);
1848 symbol_ptr
= internal_ptr
;
1849 internal_ptr
->is_sym
= TRUE
;
1852 i
< symbol_ptr
->u
.syment
.n_numaux
;
1858 /* PR 17512: Prevent buffer overrun. */
1859 if (raw_src
>= raw_end
|| internal_ptr
>= internal_end
)
1861 bfd_release (abfd
, internal
);
1865 bfd_coff_swap_aux_in (abfd
, (void *) raw_src
,
1866 symbol_ptr
->u
.syment
.n_type
,
1867 symbol_ptr
->u
.syment
.n_sclass
,
1868 (int) i
, symbol_ptr
->u
.syment
.n_numaux
,
1869 &(internal_ptr
->u
.auxent
));
1871 internal_ptr
->is_sym
= FALSE
;
1872 coff_pointerize_aux (abfd
, internal
, symbol_ptr
, i
,
1873 internal_ptr
, internal_end
);
1877 /* Free the raw symbols, but not the strings (if we have them). */
1878 obj_coff_keep_strings (abfd
) = TRUE
;
1879 if (! _bfd_coff_free_symbols (abfd
))
1882 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
1885 BFD_ASSERT (internal_ptr
->is_sym
);
1887 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
1888 && internal_ptr
->u
.syment
.n_numaux
> 0)
1890 combined_entry_type
* aux
= internal_ptr
+ 1;
1892 /* Make a file symbol point to the name in the auxent, since
1893 the text ".file" is redundant. */
1894 BFD_ASSERT (! aux
->is_sym
);
1896 if (aux
->u
.auxent
.x_file
.x_n
.x_zeroes
== 0)
1898 /* The filename is a long one, point into the string table. */
1899 if (string_table
== NULL
)
1901 string_table
= _bfd_coff_read_string_table (abfd
);
1902 if (string_table
== NULL
)
1906 if ((bfd_size_type
)(aux
->u
.auxent
.x_file
.x_n
.x_offset
)
1907 >= obj_coff_strings_len (abfd
))
1908 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1910 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1911 (bfd_hostptr_t
) (string_table
+ (aux
->u
.auxent
.x_file
.x_n
.x_offset
));
1915 /* Ordinary short filename, put into memory anyway. The
1916 Microsoft PE tools sometimes store a filename in
1917 multiple AUX entries. */
1918 if (internal_ptr
->u
.syment
.n_numaux
> 1
1919 && coff_data (abfd
)->pe
)
1920 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1923 aux
->u
.auxent
.x_file
.x_fname
,
1924 internal_ptr
->u
.syment
.n_numaux
* symesz
);
1926 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1929 aux
->u
.auxent
.x_file
.x_fname
,
1930 (size_t) bfd_coff_filnmlen (abfd
)));
1935 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0)
1937 /* This is a "short" name. Make it long. */
1941 /* Find the length of this string without walking into memory
1943 for (i
= 0; i
< 8; ++i
)
1944 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0')
1947 newstring
= (char *) bfd_zalloc (abfd
, (bfd_size_type
) (i
+ 1));
1948 if (newstring
== NULL
)
1950 strncpy (newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
);
1951 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) newstring
;
1952 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1954 else if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
== 0)
1955 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) "";
1956 else if (!bfd_coff_symname_in_debug (abfd
, &internal_ptr
->u
.syment
))
1958 /* Long name already. Point symbol at the string in the
1960 if (string_table
== NULL
)
1962 string_table
= _bfd_coff_read_string_table (abfd
);
1963 if (string_table
== NULL
)
1966 if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
>= obj_coff_strings_len (abfd
)
1967 || string_table
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
< string_table
)
1968 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1970 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1973 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
));
1977 /* Long name in debug section. Very similar. */
1978 if (debug_sec_data
== NULL
)
1979 debug_sec_data
= build_debug_section (abfd
, & debug_sec
);
1980 if (debug_sec_data
!= NULL
)
1982 BFD_ASSERT (debug_sec
!= NULL
);
1983 /* PR binutils/17512: Catch out of range offsets into the debug data. */
1984 if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
> debug_sec
->size
1985 || debug_sec_data
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
< debug_sec_data
)
1986 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1988 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
)
1989 (debug_sec_data
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
1992 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) "";
1995 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
1998 obj_raw_syments (abfd
) = internal
;
1999 BFD_ASSERT (obj_raw_syment_count (abfd
)
2000 == (unsigned int) (internal_ptr
- internal
));
2006 coff_get_reloc_upper_bound (bfd
*abfd
, sec_ptr asect
)
2008 if (bfd_get_format (abfd
) != bfd_object
)
2010 bfd_set_error (bfd_error_invalid_operation
);
2013 #if SIZEOF_LONG == SIZEOF_INT
2014 if (asect
->reloc_count
>= LONG_MAX
/ sizeof (arelent
*))
2016 bfd_set_error (bfd_error_file_too_big
);
2020 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
2024 coff_make_empty_symbol (bfd
*abfd
)
2026 bfd_size_type amt
= sizeof (coff_symbol_type
);
2027 coff_symbol_type
*new_symbol
= (coff_symbol_type
*) bfd_zalloc (abfd
, amt
);
2029 if (new_symbol
== NULL
)
2031 new_symbol
->symbol
.section
= 0;
2032 new_symbol
->native
= NULL
;
2033 new_symbol
->lineno
= NULL
;
2034 new_symbol
->done_lineno
= FALSE
;
2035 new_symbol
->symbol
.the_bfd
= abfd
;
2037 return & new_symbol
->symbol
;
2040 /* Make a debugging symbol. */
2043 coff_bfd_make_debug_symbol (bfd
*abfd
,
2044 void * ptr ATTRIBUTE_UNUSED
,
2045 unsigned long sz ATTRIBUTE_UNUSED
)
2047 bfd_size_type amt
= sizeof (coff_symbol_type
);
2048 coff_symbol_type
*new_symbol
= (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
2050 if (new_symbol
== NULL
)
2052 /* @@ The 10 is a guess at a plausible maximum number of aux entries
2053 (but shouldn't be a constant). */
2054 amt
= sizeof (combined_entry_type
) * 10;
2055 new_symbol
->native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
2056 if (!new_symbol
->native
)
2058 new_symbol
->native
->is_sym
= TRUE
;
2059 new_symbol
->symbol
.section
= bfd_abs_section_ptr
;
2060 new_symbol
->symbol
.flags
= BSF_DEBUGGING
;
2061 new_symbol
->lineno
= NULL
;
2062 new_symbol
->done_lineno
= FALSE
;
2063 new_symbol
->symbol
.the_bfd
= abfd
;
2065 return & new_symbol
->symbol
;
2069 coff_get_symbol_info (bfd
*abfd
, asymbol
*symbol
, symbol_info
*ret
)
2071 bfd_symbol_info (symbol
, ret
);
2073 if (coffsymbol (symbol
)->native
!= NULL
2074 && coffsymbol (symbol
)->native
->fix_value
2075 && coffsymbol (symbol
)->native
->is_sym
)
2076 ret
->value
= coffsymbol (symbol
)->native
->u
.syment
.n_value
-
2077 (bfd_hostptr_t
) obj_raw_syments (abfd
);
2080 /* Print out information about COFF symbol. */
2083 coff_print_symbol (bfd
*abfd
,
2086 bfd_print_symbol_type how
)
2088 FILE * file
= (FILE *) filep
;
2092 case bfd_print_symbol_name
:
2093 fprintf (file
, "%s", symbol
->name
);
2096 case bfd_print_symbol_more
:
2097 fprintf (file
, "coff %s %s",
2098 coffsymbol (symbol
)->native
? "n" : "g",
2099 coffsymbol (symbol
)->lineno
? "l" : " ");
2102 case bfd_print_symbol_all
:
2103 if (coffsymbol (symbol
)->native
)
2107 combined_entry_type
*combined
= coffsymbol (symbol
)->native
;
2108 combined_entry_type
*root
= obj_raw_syments (abfd
);
2109 struct lineno_cache_entry
*l
= coffsymbol (symbol
)->lineno
;
2111 fprintf (file
, "[%3ld]", (long) (combined
- root
));
2113 /* PR 17512: file: 079-33786-0.001:0.1. */
2114 if (combined
< obj_raw_syments (abfd
)
2115 || combined
>= obj_raw_syments (abfd
) + obj_raw_syment_count (abfd
))
2117 fprintf (file
, _("<corrupt info> %s"), symbol
->name
);
2121 BFD_ASSERT (combined
->is_sym
);
2122 if (! combined
->fix_value
)
2123 val
= (bfd_vma
) combined
->u
.syment
.n_value
;
2125 val
= combined
->u
.syment
.n_value
- (bfd_hostptr_t
) root
;
2127 fprintf (file
, "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x",
2128 combined
->u
.syment
.n_scnum
,
2129 combined
->u
.syment
.n_flags
,
2130 combined
->u
.syment
.n_type
,
2131 combined
->u
.syment
.n_sclass
,
2132 combined
->u
.syment
.n_numaux
);
2133 bfd_fprintf_vma (abfd
, file
, val
);
2134 fprintf (file
, " %s", symbol
->name
);
2136 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
2138 combined_entry_type
*auxp
= combined
+ aux
+ 1;
2141 BFD_ASSERT (! auxp
->is_sym
);
2143 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.p
- root
;
2145 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.l
;
2147 fprintf (file
, "\n");
2149 if (bfd_coff_print_aux (abfd
, file
, root
, combined
, auxp
, aux
))
2152 switch (combined
->u
.syment
.n_sclass
)
2155 fprintf (file
, "File ");
2159 if (combined
->u
.syment
.n_type
== T_NULL
)
2160 /* Probably a section symbol ? */
2162 fprintf (file
, "AUX scnlen 0x%lx nreloc %d nlnno %d",
2163 (unsigned long) auxp
->u
.auxent
.x_scn
.x_scnlen
,
2164 auxp
->u
.auxent
.x_scn
.x_nreloc
,
2165 auxp
->u
.auxent
.x_scn
.x_nlinno
);
2166 if (auxp
->u
.auxent
.x_scn
.x_checksum
!= 0
2167 || auxp
->u
.auxent
.x_scn
.x_associated
!= 0
2168 || auxp
->u
.auxent
.x_scn
.x_comdat
!= 0)
2169 fprintf (file
, " checksum 0x%lx assoc %d comdat %d",
2170 auxp
->u
.auxent
.x_scn
.x_checksum
,
2171 auxp
->u
.auxent
.x_scn
.x_associated
,
2172 auxp
->u
.auxent
.x_scn
.x_comdat
);
2178 if (ISFCN (combined
->u
.syment
.n_type
))
2183 next
= (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2186 next
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2187 llnos
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
2189 "AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld",
2191 (unsigned long) auxp
->u
.auxent
.x_sym
.x_misc
.x_fsize
,
2197 fprintf (file
, "AUX lnno %d size 0x%x tagndx %ld",
2198 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
2199 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
,
2202 fprintf (file
, " endndx %ld",
2204 (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2212 fprintf (file
, "\n%s :", l
->u
.sym
->name
);
2214 while (l
->line_number
)
2216 if (l
->line_number
> 0)
2218 fprintf (file
, "\n%4d : ", l
->line_number
);
2219 bfd_fprintf_vma (abfd
, file
, l
->u
.offset
+ symbol
->section
->vma
);
2227 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
2228 fprintf (file
, " %-5s %s %s %s",
2229 symbol
->section
->name
,
2230 coffsymbol (symbol
)->native
? "n" : "g",
2231 coffsymbol (symbol
)->lineno
? "l" : " ",
2237 /* Return whether a symbol name implies a local symbol. In COFF,
2238 local symbols generally start with ``.L''. Most targets use this
2239 function for the is_local_label_name entry point, but some may
2243 _bfd_coff_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
2246 return name
[0] == '.' && name
[1] == 'L';
2249 /* Provided a BFD, a section and an offset (in bytes, not octets) into the
2250 section, calculate and return the name of the source file and the line
2251 nearest to the wanted location. */
2254 coff_find_nearest_line_with_names (bfd
*abfd
,
2258 const char **filename_ptr
,
2259 const char **functionname_ptr
,
2260 unsigned int *line_ptr
,
2261 const struct dwarf_debug_section
*debug_sections
)
2265 unsigned int line_base
;
2266 coff_data_type
*cof
= coff_data (abfd
);
2267 /* Run through the raw syments if available. */
2268 combined_entry_type
*p
;
2269 combined_entry_type
*pend
;
2271 struct coff_section_tdata
*sec_data
;
2274 /* Before looking through the symbol table, try to use a .stab
2275 section to find the information. */
2276 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2277 &found
, filename_ptr
,
2278 functionname_ptr
, line_ptr
,
2279 &coff_data(abfd
)->line_info
))
2285 /* Also try examining DWARF2 debugging information. */
2286 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
2287 filename_ptr
, functionname_ptr
,
2288 line_ptr
, NULL
, debug_sections
,
2289 &coff_data(abfd
)->dwarf2_find_line_info
))
2292 sec_data
= coff_section_data (abfd
, section
);
2294 /* If the DWARF lookup failed, but there is DWARF information available
2295 then the problem might be that the file has been rebased. This tool
2296 changes the VMAs of all the sections, but it does not update the DWARF
2297 information. So try again, using a bias against the address sought. */
2298 if (coff_data (abfd
)->dwarf2_find_line_info
!= NULL
)
2300 bfd_signed_vma bias
= 0;
2302 /* Create a cache of the result for the next call. */
2303 if (sec_data
== NULL
&& section
->owner
== abfd
)
2305 amt
= sizeof (struct coff_section_tdata
);
2306 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
2307 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2310 if (sec_data
!= NULL
&& sec_data
->saved_bias
)
2311 bias
= sec_data
->saved_bias
;
2314 bias
= _bfd_dwarf2_find_symbol_bias (symbols
,
2315 & coff_data (abfd
)->dwarf2_find_line_info
);
2319 sec_data
->saved_bias
= TRUE
;
2320 sec_data
->bias
= bias
;
2325 && _bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
,
2327 filename_ptr
, functionname_ptr
,
2328 line_ptr
, NULL
, debug_sections
,
2329 &coff_data(abfd
)->dwarf2_find_line_info
))
2334 *functionname_ptr
= 0;
2337 /* Don't try and find line numbers in a non coff file. */
2338 if (!bfd_family_coff (abfd
))
2344 /* Find the first C_FILE symbol. */
2345 p
= cof
->raw_syments
;
2349 pend
= p
+ cof
->raw_syment_count
;
2352 BFD_ASSERT (p
->is_sym
);
2353 if (p
->u
.syment
.n_sclass
== C_FILE
)
2355 p
+= 1 + p
->u
.syment
.n_numaux
;
2363 /* Look through the C_FILE symbols to find the best one. */
2364 sec_vma
= bfd_section_vma (section
);
2365 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2366 maxdiff
= (bfd_vma
) 0 - (bfd_vma
) 1;
2370 combined_entry_type
*p2
;
2372 for (p2
= p
+ 1 + p
->u
.syment
.n_numaux
;
2374 p2
+= 1 + p2
->u
.syment
.n_numaux
)
2376 BFD_ASSERT (p2
->is_sym
);
2377 if (p2
->u
.syment
.n_scnum
> 0
2379 == coff_section_from_bfd_index (abfd
,
2380 p2
->u
.syment
.n_scnum
)))
2382 if (p2
->u
.syment
.n_sclass
== C_FILE
)
2391 file_addr
= (bfd_vma
) p2
->u
.syment
.n_value
;
2392 /* PR 11512: Include the section address of the function name symbol. */
2393 if (p2
->u
.syment
.n_scnum
> 0)
2394 file_addr
+= coff_section_from_bfd_index (abfd
,
2395 p2
->u
.syment
.n_scnum
)->vma
;
2396 /* We use <= MAXDIFF here so that if we get a zero length
2397 file, we actually use the next file entry. */
2399 && offset
+ sec_vma
>= file_addr
2400 && offset
+ sec_vma
- file_addr
<= maxdiff
)
2402 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2403 maxdiff
= offset
+ sec_vma
- p2
->u
.syment
.n_value
;
2406 if (p
->u
.syment
.n_value
>= cof
->raw_syment_count
)
2409 /* Avoid endless loops on erroneous files by ensuring that
2410 we always move forward in the file. */
2411 if (p
>= cof
->raw_syments
+ p
->u
.syment
.n_value
)
2414 p
= cof
->raw_syments
+ p
->u
.syment
.n_value
;
2415 if (!p
->is_sym
|| p
->u
.syment
.n_sclass
!= C_FILE
)
2420 if (section
->lineno_count
== 0)
2422 *functionname_ptr
= NULL
;
2427 /* Now wander though the raw linenumbers of the section.
2428 If we have been called on this section before, and the offset
2429 we want is further down then we can prime the lookup loop. */
2430 if (sec_data
!= NULL
2432 && offset
>= sec_data
->offset
)
2435 *functionname_ptr
= sec_data
->function
;
2436 line_base
= sec_data
->line_base
;
2444 if (section
->lineno
!= NULL
)
2446 bfd_vma last_value
= 0;
2448 l
= §ion
->lineno
[i
];
2450 for (; i
< section
->lineno_count
; i
++)
2452 if (l
->line_number
== 0)
2454 /* Get the symbol this line number points at. */
2455 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
2456 if (coff
->symbol
.value
> offset
)
2459 *functionname_ptr
= coff
->symbol
.name
;
2460 last_value
= coff
->symbol
.value
;
2463 combined_entry_type
*s
= coff
->native
;
2465 BFD_ASSERT (s
->is_sym
);
2466 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2468 /* In XCOFF a debugging symbol can follow the
2470 if (s
->u
.syment
.n_scnum
== N_DEBUG
)
2471 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2473 /* S should now point to the .bf of the function. */
2474 if (s
->u
.syment
.n_numaux
)
2476 /* The linenumber is stored in the auxent. */
2477 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
2479 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
2480 *line_ptr
= line_base
;
2486 if (l
->u
.offset
> offset
)
2488 *line_ptr
= l
->line_number
+ line_base
- 1;
2493 /* If we fell off the end of the loop, then assume that this
2494 symbol has no line number info. Otherwise, symbols with no
2495 line number info get reported with the line number of the
2496 last line of the last symbol which does have line number
2497 info. We use 0x100 as a slop to account for cases where the
2498 last line has executable code. */
2499 if (i
>= section
->lineno_count
2501 && offset
- last_value
> 0x100)
2503 *functionname_ptr
= NULL
;
2508 /* Cache the results for the next call. */
2509 if (sec_data
== NULL
&& section
->owner
== abfd
)
2511 amt
= sizeof (struct coff_section_tdata
);
2512 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
2513 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2516 if (sec_data
!= NULL
)
2518 sec_data
->offset
= offset
;
2519 sec_data
->i
= i
- 1;
2520 sec_data
->function
= *functionname_ptr
;
2521 sec_data
->line_base
= line_base
;
2528 coff_find_nearest_line (bfd
*abfd
,
2532 const char **filename_ptr
,
2533 const char **functionname_ptr
,
2534 unsigned int *line_ptr
,
2535 unsigned int *discriminator_ptr
)
2537 if (discriminator_ptr
)
2538 *discriminator_ptr
= 0;
2539 return coff_find_nearest_line_with_names (abfd
, symbols
, section
, offset
,
2540 filename_ptr
, functionname_ptr
,
2541 line_ptr
, dwarf_debug_sections
);
2545 coff_find_inliner_info (bfd
*abfd
,
2546 const char **filename_ptr
,
2547 const char **functionname_ptr
,
2548 unsigned int *line_ptr
)
2552 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
2553 functionname_ptr
, line_ptr
,
2554 &coff_data(abfd
)->dwarf2_find_line_info
);
2559 coff_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
2563 if (!bfd_link_relocatable (info
))
2564 size
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
2566 size
= bfd_coff_filhsz (abfd
);
2568 size
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
2572 /* Change the class of a coff symbol held by BFD. */
2575 bfd_coff_set_symbol_class (bfd
* abfd
,
2577 unsigned int symbol_class
)
2579 coff_symbol_type
* csym
;
2581 csym
= coff_symbol_from (symbol
);
2584 bfd_set_error (bfd_error_invalid_operation
);
2587 else if (csym
->native
== NULL
)
2589 /* This is an alien symbol which no native coff backend data.
2590 We cheat here by creating a fake native entry for it and
2591 then filling in the class. This code is based on that in
2592 coff_write_alien_symbol(). */
2594 combined_entry_type
* native
;
2595 bfd_size_type amt
= sizeof (* native
);
2597 native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
2601 native
->is_sym
= TRUE
;
2602 native
->u
.syment
.n_type
= T_NULL
;
2603 native
->u
.syment
.n_sclass
= symbol_class
;
2605 if (bfd_is_und_section (symbol
->section
))
2607 native
->u
.syment
.n_scnum
= N_UNDEF
;
2608 native
->u
.syment
.n_value
= symbol
->value
;
2610 else if (bfd_is_com_section (symbol
->section
))
2612 native
->u
.syment
.n_scnum
= N_UNDEF
;
2613 native
->u
.syment
.n_value
= symbol
->value
;
2617 native
->u
.syment
.n_scnum
=
2618 symbol
->section
->output_section
->target_index
;
2619 native
->u
.syment
.n_value
= (symbol
->value
2620 + symbol
->section
->output_offset
);
2621 if (! obj_pe (abfd
))
2622 native
->u
.syment
.n_value
+= symbol
->section
->output_section
->vma
;
2624 /* Copy the any flags from the file header into the symbol.
2626 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (& csym
->symbol
)->flags
;
2629 csym
->native
= native
;
2632 csym
->native
->u
.syment
.n_sclass
= symbol_class
;
2638 _bfd_coff_section_already_linked (bfd
*abfd
,
2640 struct bfd_link_info
*info
)
2643 const char *name
, *key
;
2644 struct bfd_section_already_linked
*l
;
2645 struct bfd_section_already_linked_hash_entry
*already_linked_list
;
2646 struct coff_comdat_info
*s_comdat
;
2648 if (sec
->output_section
== bfd_abs_section_ptr
)
2652 if ((flags
& SEC_LINK_ONCE
) == 0)
2655 /* The COFF backend linker doesn't support group sections. */
2656 if ((flags
& SEC_GROUP
) != 0)
2659 name
= bfd_section_name (sec
);
2660 s_comdat
= bfd_coff_get_comdat_section (abfd
, sec
);
2662 if (s_comdat
!= NULL
)
2663 key
= s_comdat
->name
;
2666 if (CONST_STRNEQ (name
, ".gnu.linkonce.")
2667 && (key
= strchr (name
+ sizeof (".gnu.linkonce.") - 1, '.')) != NULL
)
2670 /* FIXME: gcc as of 2011-09 emits sections like .text$<key>,
2671 .xdata$<key> and .pdata$<key> only the first of which has a
2672 comdat key. Should these all match the LTO IR key? */
2676 already_linked_list
= bfd_section_already_linked_table_lookup (key
);
2678 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
2680 struct coff_comdat_info
*l_comdat
;
2682 l_comdat
= bfd_coff_get_comdat_section (l
->sec
->owner
, l
->sec
);
2684 /* The section names must match, and both sections must be
2685 comdat and have the same comdat name, or both sections must
2686 be non-comdat. LTO IR plugin sections are an exception. They
2687 are always named .gnu.linkonce.t.<key> (<key> is some string)
2688 and match any comdat section with comdat name of <key>, and
2689 any linkonce section with the same suffix, ie.
2690 .gnu.linkonce.*.<key>. */
2691 if (((s_comdat
!= NULL
) == (l_comdat
!= NULL
)
2692 && strcmp (name
, l
->sec
->name
) == 0)
2693 || (l
->sec
->owner
->flags
& BFD_PLUGIN
) != 0)
2695 /* The section has already been linked. See if we should
2697 return _bfd_handle_already_linked (sec
, l
, info
);
2701 /* This is the first section with this name. Record it. */
2702 if (!bfd_section_already_linked_table_insert (already_linked_list
, sec
))
2703 info
->callbacks
->einfo (_("%F%P: already_linked_table: %E\n"));
2707 /* Initialize COOKIE for input bfd ABFD. */
2710 init_reloc_cookie (struct coff_reloc_cookie
*cookie
,
2711 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2714 /* Sometimes the symbol table does not yet have been loaded here. */
2715 bfd_coff_slurp_symbol_table (abfd
);
2717 cookie
->abfd
= abfd
;
2718 cookie
->sym_hashes
= obj_coff_sym_hashes (abfd
);
2720 cookie
->symbols
= obj_symbols (abfd
);
2725 /* Free the memory allocated by init_reloc_cookie, if appropriate. */
2728 fini_reloc_cookie (struct coff_reloc_cookie
*cookie ATTRIBUTE_UNUSED
,
2729 bfd
*abfd ATTRIBUTE_UNUSED
)
2731 /* Nothing to do. */
2734 /* Initialize the relocation information in COOKIE for input section SEC
2735 of input bfd ABFD. */
2738 init_reloc_cookie_rels (struct coff_reloc_cookie
*cookie
,
2739 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2743 if (sec
->reloc_count
== 0)
2745 cookie
->rels
= NULL
;
2746 cookie
->relend
= NULL
;
2751 cookie
->rels
= _bfd_coff_read_internal_relocs (abfd
, sec
, FALSE
, NULL
, 0, NULL
);
2753 if (cookie
->rels
== NULL
)
2756 cookie
->rel
= cookie
->rels
;
2757 cookie
->relend
= (cookie
->rels
+ sec
->reloc_count
);
2761 /* Free the memory allocated by init_reloc_cookie_rels,
2765 fini_reloc_cookie_rels (struct coff_reloc_cookie
*cookie
,
2769 /* PR 20401. The relocs may not have been cached, so check first.
2770 If the relocs were loaded by init_reloc_cookie_rels() then this
2771 will be the case. FIXME: Would performance be improved if the
2772 relocs *were* cached ? */
2773 && coff_section_data (NULL
, sec
)
2774 && coff_section_data (NULL
, sec
)->relocs
!= cookie
->rels
)
2775 free (cookie
->rels
);
2778 /* Initialize the whole of COOKIE for input section SEC. */
2781 init_reloc_cookie_for_section (struct coff_reloc_cookie
*cookie
,
2782 struct bfd_link_info
*info
,
2785 if (!init_reloc_cookie (cookie
, info
, sec
->owner
))
2788 if (!init_reloc_cookie_rels (cookie
, info
, sec
->owner
, sec
))
2790 fini_reloc_cookie (cookie
, sec
->owner
);
2796 /* Free the memory allocated by init_reloc_cookie_for_section,
2800 fini_reloc_cookie_for_section (struct coff_reloc_cookie
*cookie
,
2803 fini_reloc_cookie_rels (cookie
, sec
);
2804 fini_reloc_cookie (cookie
, sec
->owner
);
2808 _bfd_coff_gc_mark_hook (asection
*sec
,
2809 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2810 struct internal_reloc
*rel ATTRIBUTE_UNUSED
,
2811 struct coff_link_hash_entry
*h
,
2812 struct internal_syment
*sym
)
2816 switch (h
->root
.type
)
2818 case bfd_link_hash_defined
:
2819 case bfd_link_hash_defweak
:
2820 return h
->root
.u
.def
.section
;
2822 case bfd_link_hash_common
:
2823 return h
->root
.u
.c
.p
->section
;
2825 case bfd_link_hash_undefweak
:
2826 if (h
->symbol_class
== C_NT_WEAK
&& h
->numaux
== 1)
2828 /* PE weak externals. A weak symbol may include an auxiliary
2829 record indicating that if the weak symbol is not resolved,
2830 another external symbol is used instead. */
2831 struct coff_link_hash_entry
*h2
=
2832 h
->auxbfd
->tdata
.coff_obj_data
->sym_hashes
[
2833 h
->aux
->x_sym
.x_tagndx
.l
];
2835 if (h2
&& h2
->root
.type
!= bfd_link_hash_undefined
)
2836 return h2
->root
.u
.def
.section
;
2840 case bfd_link_hash_undefined
:
2847 return coff_section_from_bfd_index (sec
->owner
, sym
->n_scnum
);
2850 /* COOKIE->rel describes a relocation against section SEC, which is
2851 a section we've decided to keep. Return the section that contains
2852 the relocation symbol, or NULL if no section contains it. */
2855 _bfd_coff_gc_mark_rsec (struct bfd_link_info
*info
, asection
*sec
,
2856 coff_gc_mark_hook_fn gc_mark_hook
,
2857 struct coff_reloc_cookie
*cookie
)
2859 struct coff_link_hash_entry
*h
;
2861 h
= cookie
->sym_hashes
[cookie
->rel
->r_symndx
];
2864 while (h
->root
.type
== bfd_link_hash_indirect
2865 || h
->root
.type
== bfd_link_hash_warning
)
2866 h
= (struct coff_link_hash_entry
*) h
->root
.u
.i
.link
;
2868 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, h
, NULL
);
2871 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, NULL
,
2873 + obj_convert (sec
->owner
)[cookie
->rel
->r_symndx
])->native
->u
.syment
);
2876 static bfd_boolean _bfd_coff_gc_mark
2877 (struct bfd_link_info
*, asection
*, coff_gc_mark_hook_fn
);
2879 /* COOKIE->rel describes a relocation against section SEC, which is
2880 a section we've decided to keep. Mark the section that contains
2881 the relocation symbol. */
2884 _bfd_coff_gc_mark_reloc (struct bfd_link_info
*info
,
2886 coff_gc_mark_hook_fn gc_mark_hook
,
2887 struct coff_reloc_cookie
*cookie
)
2891 rsec
= _bfd_coff_gc_mark_rsec (info
, sec
, gc_mark_hook
, cookie
);
2892 if (rsec
&& !rsec
->gc_mark
)
2894 if (bfd_get_flavour (rsec
->owner
) != bfd_target_coff_flavour
)
2896 else if (!_bfd_coff_gc_mark (info
, rsec
, gc_mark_hook
))
2902 /* The mark phase of garbage collection. For a given section, mark
2903 it and any sections in this section's group, and all the sections
2904 which define symbols to which it refers. */
2907 _bfd_coff_gc_mark (struct bfd_link_info
*info
,
2909 coff_gc_mark_hook_fn gc_mark_hook
)
2911 bfd_boolean ret
= TRUE
;
2915 /* Look through the section relocs. */
2916 if ((sec
->flags
& SEC_RELOC
) != 0
2917 && sec
->reloc_count
> 0)
2919 struct coff_reloc_cookie cookie
;
2921 if (!init_reloc_cookie_for_section (&cookie
, info
, sec
))
2925 for (; cookie
.rel
< cookie
.relend
; cookie
.rel
++)
2927 if (!_bfd_coff_gc_mark_reloc (info
, sec
, gc_mark_hook
, &cookie
))
2933 fini_reloc_cookie_for_section (&cookie
, sec
);
2941 _bfd_coff_gc_mark_extra_sections (struct bfd_link_info
*info
,
2942 coff_gc_mark_hook_fn mark_hook ATTRIBUTE_UNUSED
)
2946 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
2949 bfd_boolean some_kept
;
2951 if (bfd_get_flavour (ibfd
) != bfd_target_coff_flavour
)
2954 /* Ensure all linker created sections are kept, and see whether
2955 any other section is already marked. */
2957 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
2959 if ((isec
->flags
& SEC_LINKER_CREATED
) != 0)
2961 else if (isec
->gc_mark
)
2965 /* If no section in this file will be kept, then we can
2966 toss out debug sections. */
2970 /* Keep debug and special sections like .comment when they are
2971 not part of a group, or when we have single-member groups. */
2972 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
2973 if ((isec
->flags
& SEC_DEBUGGING
) != 0
2974 || (isec
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0)
2980 /* Sweep symbols in swept sections. Called via coff_link_hash_traverse. */
2983 coff_gc_sweep_symbol (struct coff_link_hash_entry
*h
,
2984 void *data ATTRIBUTE_UNUSED
)
2986 if (h
->root
.type
== bfd_link_hash_warning
)
2987 h
= (struct coff_link_hash_entry
*) h
->root
.u
.i
.link
;
2989 if ((h
->root
.type
== bfd_link_hash_defined
2990 || h
->root
.type
== bfd_link_hash_defweak
)
2991 && !h
->root
.u
.def
.section
->gc_mark
2992 && !(h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
))
2994 /* Do our best to hide the symbol. */
2995 h
->root
.u
.def
.section
= bfd_und_section_ptr
;
2996 h
->symbol_class
= C_HIDDEN
;
3002 /* The sweep phase of garbage collection. Remove all garbage sections. */
3004 typedef bfd_boolean (*gc_sweep_hook_fn
)
3005 (bfd
*, struct bfd_link_info
*, asection
*, const struct internal_reloc
*);
3008 coff_gc_sweep (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
3012 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3016 if (bfd_get_flavour (sub
) != bfd_target_coff_flavour
)
3019 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3021 /* Keep debug and special sections. */
3022 if ((o
->flags
& (SEC_DEBUGGING
| SEC_LINKER_CREATED
)) != 0
3023 || (o
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0)
3025 else if (CONST_STRNEQ (o
->name
, ".idata")
3026 || CONST_STRNEQ (o
->name
, ".pdata")
3027 || CONST_STRNEQ (o
->name
, ".xdata")
3028 || CONST_STRNEQ (o
->name
, ".rsrc"))
3034 /* Skip sweeping sections already excluded. */
3035 if (o
->flags
& SEC_EXCLUDE
)
3038 /* Since this is early in the link process, it is simple
3039 to remove a section from the output. */
3040 o
->flags
|= SEC_EXCLUDE
;
3042 if (info
->print_gc_sections
&& o
->size
!= 0)
3043 /* xgettext: c-format */
3044 _bfd_error_handler (_("removing unused section '%pA' in file '%pB'"),
3048 /* But we also have to update some of the relocation
3049 info we collected before. */
3051 && (o
->flags
& SEC_RELOC
) != 0
3052 && o
->reloc_count
> 0
3053 && !bfd_is_abs_section (o
->output_section
))
3055 struct internal_reloc
*internal_relocs
;
3059 = _bfd_coff_link_read_relocs (o
->owner
, o
, NULL
, NULL
,
3061 if (internal_relocs
== NULL
)
3064 r
= (*gc_sweep_hook
) (o
->owner
, info
, o
, internal_relocs
);
3066 if (coff_section_data (o
)->relocs
!= internal_relocs
)
3067 free (internal_relocs
);
3076 /* Remove the symbols that were in the swept sections from the dynamic
3078 coff_link_hash_traverse (coff_hash_table (info
), coff_gc_sweep_symbol
,
3084 /* Keep all sections containing symbols undefined on the command-line,
3085 and the section containing the entry symbol. */
3088 _bfd_coff_gc_keep (struct bfd_link_info
*info
)
3090 struct bfd_sym_chain
*sym
;
3092 for (sym
= info
->gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
3094 struct coff_link_hash_entry
*h
;
3096 h
= coff_link_hash_lookup (coff_hash_table (info
), sym
->name
,
3097 FALSE
, FALSE
, FALSE
);
3100 && (h
->root
.type
== bfd_link_hash_defined
3101 || h
->root
.type
== bfd_link_hash_defweak
)
3102 && !bfd_is_abs_section (h
->root
.u
.def
.section
))
3103 h
->root
.u
.def
.section
->flags
|= SEC_KEEP
;
3107 /* Do mark and sweep of unused sections. */
3110 bfd_coff_gc_sections (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
3114 /* FIXME: Should we implement this? */
3116 const bfd_coff_backend_data
*bed
= coff_backend_info (abfd
);
3118 if (!bed
->can_gc_sections
3119 || !is_coff_hash_table (info
->hash
))
3121 _bfd_error_handler(_("warning: gc-sections option ignored"));
3126 _bfd_coff_gc_keep (info
);
3128 /* Grovel through relocs to find out who stays ... */
3129 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3133 if (bfd_get_flavour (sub
) != bfd_target_coff_flavour
)
3136 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3138 if (((o
->flags
& (SEC_EXCLUDE
| SEC_KEEP
)) == SEC_KEEP
3139 || CONST_STRNEQ (o
->name
, ".vectors")
3140 || CONST_STRNEQ (o
->name
, ".ctors")
3141 || CONST_STRNEQ (o
->name
, ".dtors"))
3144 if (!_bfd_coff_gc_mark (info
, o
, _bfd_coff_gc_mark_hook
))
3150 /* Allow the backend to mark additional target specific sections. */
3151 _bfd_coff_gc_mark_extra_sections (info
, _bfd_coff_gc_mark_hook
);
3153 /* ... and mark SEC_EXCLUDE for those that go. */
3154 return coff_gc_sweep (abfd
, info
);
3157 /* Return name used to identify a comdat group. */
3160 bfd_coff_group_name (bfd
*abfd
, const asection
*sec
)
3162 struct coff_comdat_info
*ci
= bfd_coff_get_comdat_section (abfd
, sec
);
3169 _bfd_coff_close_and_cleanup (bfd
*abfd
)
3171 if (abfd
->format
== bfd_object
3172 && bfd_family_coff (abfd
)
3173 && coff_data (abfd
) != NULL
)
3175 obj_coff_keep_syms (abfd
) = FALSE
;
3176 obj_coff_keep_strings (abfd
) = FALSE
;
3177 if (!_bfd_coff_free_symbols (abfd
))
3180 return _bfd_generic_close_and_cleanup (abfd
);