1 /* Support for the generic parts of COFF, for BFD.
2 Copyright (C) 1990-2020 Free Software Foundation, Inc.
3 Written by Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
22 /* Most of this hacked by Steve Chamberlain, sac@cygnus.com.
23 Split out of coffcode.h by Ian Taylor, ian@cygnus.com. */
25 /* This file contains COFF code that is not dependent on any
26 particular COFF target. There is only one version of this file in
27 libbfd.a, so no target specific code may be put in here. Or, to
30 ********** DO NOT PUT TARGET SPECIFIC CODE IN THIS FILE **********
32 If you need to add some target specific behaviour, add a new hook
33 function to bfd_coff_backend_data.
35 Some of these functions are also called by the ECOFF routines.
36 Those functions may not use any COFF specific information, such as
43 #include "coff/internal.h"
46 /* Take a section header read from a coff file (in HOST byte order),
47 and make a BFD "section" out of it. This is used by ECOFF. */
50 make_a_section_from_file (bfd
*abfd
,
51 struct internal_scnhdr
*hdr
,
52 unsigned int target_index
)
54 asection
*return_section
;
56 bfd_boolean result
= TRUE
;
61 /* Handle long section names as in PE. On reading, we want to
62 accept long names if the format permits them at all, regardless
63 of the current state of the flag that dictates if we would generate
64 them in outputs; this construct checks if that is the case by
65 attempting to set the flag, without changing its state; the call
66 will fail for formats that do not support long names at all. */
67 if (bfd_coff_set_long_section_names (abfd
, bfd_coff_long_section_names (abfd
))
68 && hdr
->s_name
[0] == '/')
75 /* Flag that this BFD uses long names, even though the format might
76 expect them to be off by default. This won't directly affect the
77 format of any output BFD created from this one, but the information
78 can be used to decide what to do. */
79 bfd_coff_set_long_section_names (abfd
, TRUE
);
80 memcpy (buf
, hdr
->s_name
+ 1, SCNNMLEN
- 1);
81 buf
[SCNNMLEN
- 1] = '\0';
82 strindex
= strtol (buf
, &p
, 10);
83 if (*p
== '\0' && strindex
>= 0)
85 strings
= _bfd_coff_read_string_table (abfd
);
88 if ((bfd_size_type
)(strindex
+ 2) >= obj_coff_strings_len (abfd
))
91 name
= (char *) bfd_alloc (abfd
,
92 (bfd_size_type
) strlen (strings
) + 1 + 1);
95 strcpy (name
, strings
);
101 /* Assorted wastage to null-terminate the name, thanks AT&T! */
102 name
= (char *) bfd_alloc (abfd
,
103 (bfd_size_type
) sizeof (hdr
->s_name
) + 1 + 1);
106 strncpy (name
, (char *) &hdr
->s_name
[0], sizeof (hdr
->s_name
));
107 name
[sizeof (hdr
->s_name
)] = 0;
110 return_section
= bfd_make_section_anyway (abfd
, name
);
111 if (return_section
== NULL
)
114 return_section
->vma
= hdr
->s_vaddr
;
115 return_section
->lma
= hdr
->s_paddr
;
116 return_section
->size
= hdr
->s_size
;
117 return_section
->filepos
= hdr
->s_scnptr
;
118 return_section
->rel_filepos
= hdr
->s_relptr
;
119 return_section
->reloc_count
= hdr
->s_nreloc
;
121 bfd_coff_set_alignment_hook (abfd
, return_section
, hdr
);
123 return_section
->line_filepos
= hdr
->s_lnnoptr
;
125 return_section
->lineno_count
= hdr
->s_nlnno
;
126 return_section
->userdata
= NULL
;
127 return_section
->next
= NULL
;
128 return_section
->target_index
= target_index
;
130 if (! bfd_coff_styp_to_sec_flags_hook (abfd
, hdr
, name
, return_section
,
134 return_section
->flags
= flags
;
136 /* At least on i386-coff, the line number count for a shared library
137 section must be ignored. */
138 if ((return_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
139 return_section
->lineno_count
= 0;
141 if (hdr
->s_nreloc
!= 0)
142 return_section
->flags
|= SEC_RELOC
;
143 /* FIXME: should this check 'hdr->s_size > 0'. */
144 if (hdr
->s_scnptr
!= 0)
145 return_section
->flags
|= SEC_HAS_CONTENTS
;
147 /* Compress/decompress DWARF debug sections with names: .debug_* and
148 .zdebug_*, after the section flags is set. */
149 if ((flags
& SEC_DEBUGGING
)
151 && ((name
[1] == 'd' && name
[6] == '_')
152 || (strlen (name
) > 8 && name
[1] == 'z' && name
[7] == '_')))
154 enum { nothing
, compress
, decompress
} action
= nothing
;
155 char *new_name
= NULL
;
157 if (bfd_is_section_compressed (abfd
, return_section
))
159 /* Compressed section. Check if we should decompress. */
160 if ((abfd
->flags
& BFD_DECOMPRESS
))
163 else if (!bfd_is_section_compressed (abfd
, return_section
))
165 /* Normal section. Check if we should compress. */
166 if ((abfd
->flags
& BFD_COMPRESS
) && return_section
->size
!= 0)
175 if (!bfd_init_section_compress_status (abfd
, return_section
))
178 /* xgettext: c-format */
179 (_("%pB: unable to initialize compress status for section %s"),
183 if (return_section
->compress_status
== COMPRESS_SECTION_DONE
)
187 unsigned int len
= strlen (name
);
189 new_name
= bfd_alloc (abfd
, len
+ 2);
190 if (new_name
== NULL
)
194 memcpy (new_name
+ 2, name
+ 1, len
);
199 if (!bfd_init_section_decompress_status (abfd
, return_section
))
202 /* xgettext: c-format */
203 (_("%pB: unable to initialize decompress status for section %s"),
209 unsigned int len
= strlen (name
);
211 new_name
= bfd_alloc (abfd
, len
);
212 if (new_name
== NULL
)
215 memcpy (new_name
+ 1, name
+ 2, len
- 1);
219 if (new_name
!= NULL
)
220 bfd_rename_section (return_section
, new_name
);
226 /* Read in a COFF object and make it into a BFD. This is used by
229 coff_real_object_p (bfd
*,
231 struct internal_filehdr
*,
232 struct internal_aouthdr
*);
234 coff_real_object_p (bfd
*abfd
,
236 struct internal_filehdr
*internal_f
,
237 struct internal_aouthdr
*internal_a
)
239 flagword oflags
= abfd
->flags
;
240 bfd_vma ostart
= bfd_get_start_address (abfd
);
243 bfd_size_type readsize
; /* Length of file_info. */
245 char *external_sections
;
247 if (!(internal_f
->f_flags
& F_RELFLG
))
248 abfd
->flags
|= HAS_RELOC
;
249 if ((internal_f
->f_flags
& F_EXEC
))
250 abfd
->flags
|= EXEC_P
;
251 if (!(internal_f
->f_flags
& F_LNNO
))
252 abfd
->flags
|= HAS_LINENO
;
253 if (!(internal_f
->f_flags
& F_LSYMS
))
254 abfd
->flags
|= HAS_LOCALS
;
256 /* FIXME: How can we set D_PAGED correctly? */
257 if ((internal_f
->f_flags
& F_EXEC
) != 0)
258 abfd
->flags
|= D_PAGED
;
260 abfd
->symcount
= internal_f
->f_nsyms
;
261 if (internal_f
->f_nsyms
)
262 abfd
->flags
|= HAS_SYMS
;
264 if (internal_a
!= (struct internal_aouthdr
*) NULL
)
265 abfd
->start_address
= internal_a
->entry
;
267 abfd
->start_address
= 0;
269 /* Set up the tdata area. ECOFF uses its own routine, and overrides
271 tdata_save
= abfd
->tdata
.any
;
272 tdata
= bfd_coff_mkobject_hook (abfd
, (void *) internal_f
, (void *) internal_a
);
276 scnhsz
= bfd_coff_scnhsz (abfd
);
277 readsize
= (bfd_size_type
) nscns
* scnhsz
;
278 external_sections
= (char *) bfd_alloc (abfd
, readsize
);
279 if (!external_sections
)
282 if (bfd_bread ((void *) external_sections
, readsize
, abfd
) != readsize
)
285 /* Set the arch/mach *before* swapping in sections; section header swapping
286 may depend on arch/mach info. */
287 if (! bfd_coff_set_arch_mach_hook (abfd
, (void *) internal_f
))
290 /* Now copy data as required; construct all asections etc. */
294 for (i
= 0; i
< nscns
; i
++)
296 struct internal_scnhdr tmp
;
297 bfd_coff_swap_scnhdr_in (abfd
,
298 (void *) (external_sections
+ i
* scnhsz
),
300 if (! make_a_section_from_file (abfd
, &tmp
, i
+ 1))
305 _bfd_coff_free_symbols (abfd
);
309 _bfd_coff_free_symbols (abfd
);
310 bfd_release (abfd
, tdata
);
312 abfd
->tdata
.any
= tdata_save
;
313 abfd
->flags
= oflags
;
314 abfd
->start_address
= ostart
;
315 return (const bfd_target
*) NULL
;
318 /* Turn a COFF file into a BFD, but fail with bfd_error_wrong_format if it is
319 not a COFF file. This is also used by ECOFF. */
322 coff_object_p (bfd
*abfd
)
324 bfd_size_type filhsz
;
325 bfd_size_type aoutsz
;
328 struct internal_filehdr internal_f
;
329 struct internal_aouthdr internal_a
;
331 /* Figure out how much to read. */
332 filhsz
= bfd_coff_filhsz (abfd
);
333 aoutsz
= bfd_coff_aoutsz (abfd
);
335 filehdr
= bfd_alloc (abfd
, filhsz
);
338 if (bfd_bread (filehdr
, filhsz
, abfd
) != filhsz
)
340 if (bfd_get_error () != bfd_error_system_call
)
341 bfd_set_error (bfd_error_wrong_format
);
342 bfd_release (abfd
, filehdr
);
345 bfd_coff_swap_filehdr_in (abfd
, filehdr
, &internal_f
);
346 bfd_release (abfd
, filehdr
);
348 /* The XCOFF format has two sizes for the f_opthdr. SMALL_AOUTSZ
349 (less than aoutsz) used in object files and AOUTSZ (equal to
350 aoutsz) in executables. The bfd_coff_swap_aouthdr_in function
351 expects this header to be aoutsz bytes in length, so we use that
352 value in the call to bfd_alloc below. But we must be careful to
353 only read in f_opthdr bytes in the call to bfd_bread. We should
354 also attempt to catch corrupt or non-COFF binaries with a strange
355 value for f_opthdr. */
356 if (! bfd_coff_bad_format_hook (abfd
, &internal_f
)
357 || internal_f
.f_opthdr
> aoutsz
)
359 bfd_set_error (bfd_error_wrong_format
);
362 nscns
= internal_f
.f_nscns
;
364 if (internal_f
.f_opthdr
)
368 opthdr
= bfd_alloc (abfd
, aoutsz
);
371 if (bfd_bread (opthdr
, (bfd_size_type
) internal_f
.f_opthdr
, abfd
)
372 != internal_f
.f_opthdr
)
374 bfd_release (abfd
, opthdr
);
377 /* PR 17512: file: 11056-1136-0.004. */
378 if (internal_f
.f_opthdr
< aoutsz
)
379 memset (((char *) opthdr
) + internal_f
.f_opthdr
, 0, aoutsz
- internal_f
.f_opthdr
);
381 bfd_coff_swap_aouthdr_in (abfd
, opthdr
, (void *) &internal_a
);
382 bfd_release (abfd
, opthdr
);
385 return coff_real_object_p (abfd
, nscns
, &internal_f
,
386 (internal_f
.f_opthdr
!= 0
388 : (struct internal_aouthdr
*) NULL
));
391 /* Get the BFD section from a COFF symbol section number. */
394 coff_section_from_bfd_index (bfd
*abfd
, int section_index
)
396 struct bfd_section
*answer
= abfd
->sections
;
398 if (section_index
== N_ABS
)
399 return bfd_abs_section_ptr
;
400 if (section_index
== N_UNDEF
)
401 return bfd_und_section_ptr
;
402 if (section_index
== N_DEBUG
)
403 return bfd_abs_section_ptr
;
407 if (answer
->target_index
== section_index
)
409 answer
= answer
->next
;
412 /* We should not reach this point, but the SCO 3.2v4 /lib/libc_s.a
413 has a bad symbol table in biglitpow.o. */
414 return bfd_und_section_ptr
;
417 /* Get the upper bound of a COFF symbol table. */
420 coff_get_symtab_upper_bound (bfd
*abfd
)
422 if (!bfd_coff_slurp_symbol_table (abfd
))
425 return (bfd_get_symcount (abfd
) + 1) * (sizeof (coff_symbol_type
*));
428 /* Canonicalize a COFF symbol table. */
431 coff_canonicalize_symtab (bfd
*abfd
, asymbol
**alocation
)
433 unsigned int counter
;
434 coff_symbol_type
*symbase
;
435 coff_symbol_type
**location
= (coff_symbol_type
**) alocation
;
437 if (!bfd_coff_slurp_symbol_table (abfd
))
440 symbase
= obj_symbols (abfd
);
441 counter
= bfd_get_symcount (abfd
);
442 while (counter
-- > 0)
443 *location
++ = symbase
++;
447 return bfd_get_symcount (abfd
);
450 /* Get the name of a symbol. The caller must pass in a buffer of size
454 _bfd_coff_internal_syment_name (bfd
*abfd
,
455 const struct internal_syment
*sym
,
458 /* FIXME: It's not clear this will work correctly if sizeof
460 if (sym
->_n
._n_n
._n_zeroes
!= 0
461 || sym
->_n
._n_n
._n_offset
== 0)
463 memcpy (buf
, sym
->_n
._n_name
, SYMNMLEN
);
464 buf
[SYMNMLEN
] = '\0';
471 BFD_ASSERT (sym
->_n
._n_n
._n_offset
>= STRING_SIZE_SIZE
);
472 strings
= obj_coff_strings (abfd
);
475 strings
= _bfd_coff_read_string_table (abfd
);
479 /* PR 17910: Only check for string overflow if the length has been set.
480 Some DLLs, eg those produced by Visual Studio, may not set the length field. */
481 if (obj_coff_strings_len (abfd
) > 0
482 && sym
->_n
._n_n
._n_offset
>= obj_coff_strings_len (abfd
))
484 return strings
+ sym
->_n
._n_n
._n_offset
;
488 /* Read in and swap the relocs. This returns a buffer holding the
489 relocs for section SEC in file ABFD. If CACHE is TRUE and
490 INTERNAL_RELOCS is NULL, the relocs read in will be saved in case
491 the function is called again. If EXTERNAL_RELOCS is not NULL, it
492 is a buffer large enough to hold the unswapped relocs. If
493 INTERNAL_RELOCS is not NULL, it is a buffer large enough to hold
494 the swapped relocs. If REQUIRE_INTERNAL is TRUE, then the return
495 value must be INTERNAL_RELOCS. The function returns NULL on error. */
497 struct internal_reloc
*
498 _bfd_coff_read_internal_relocs (bfd
*abfd
,
501 bfd_byte
*external_relocs
,
502 bfd_boolean require_internal
,
503 struct internal_reloc
*internal_relocs
)
506 bfd_byte
*free_external
= NULL
;
507 struct internal_reloc
*free_internal
= NULL
;
510 struct internal_reloc
*irel
;
513 if (sec
->reloc_count
== 0)
514 return internal_relocs
; /* Nothing to do. */
516 if (coff_section_data (abfd
, sec
) != NULL
517 && coff_section_data (abfd
, sec
)->relocs
!= NULL
)
519 if (! require_internal
)
520 return coff_section_data (abfd
, sec
)->relocs
;
521 memcpy (internal_relocs
, coff_section_data (abfd
, sec
)->relocs
,
522 sec
->reloc_count
* sizeof (struct internal_reloc
));
523 return internal_relocs
;
526 relsz
= bfd_coff_relsz (abfd
);
528 amt
= sec
->reloc_count
* relsz
;
529 if (external_relocs
== NULL
)
531 free_external
= (bfd_byte
*) bfd_malloc (amt
);
532 if (free_external
== NULL
)
534 external_relocs
= free_external
;
537 if (bfd_seek (abfd
, sec
->rel_filepos
, SEEK_SET
) != 0
538 || bfd_bread (external_relocs
, amt
, abfd
) != amt
)
541 if (internal_relocs
== NULL
)
543 amt
= sec
->reloc_count
;
544 amt
*= sizeof (struct internal_reloc
);
545 free_internal
= (struct internal_reloc
*) bfd_malloc (amt
);
546 if (free_internal
== NULL
)
548 internal_relocs
= free_internal
;
551 /* Swap in the relocs. */
552 erel
= external_relocs
;
553 erel_end
= erel
+ relsz
* sec
->reloc_count
;
554 irel
= internal_relocs
;
555 for (; erel
< erel_end
; erel
+= relsz
, irel
++)
556 bfd_coff_swap_reloc_in (abfd
, (void *) erel
, (void *) irel
);
558 if (free_external
!= NULL
)
560 free (free_external
);
561 free_external
= NULL
;
564 if (cache
&& free_internal
!= NULL
)
566 if (coff_section_data (abfd
, sec
) == NULL
)
568 amt
= sizeof (struct coff_section_tdata
);
569 sec
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
570 if (sec
->used_by_bfd
== NULL
)
572 coff_section_data (abfd
, sec
)->contents
= NULL
;
574 coff_section_data (abfd
, sec
)->relocs
= free_internal
;
577 return internal_relocs
;
580 if (free_external
!= NULL
)
581 free (free_external
);
582 if (free_internal
!= NULL
)
583 free (free_internal
);
587 /* Set lineno_count for the output sections of a COFF file. */
590 coff_count_linenumbers (bfd
*abfd
)
592 unsigned int limit
= bfd_get_symcount (abfd
);
600 /* This may be from the backend linker, in which case the
601 lineno_count in the sections is correct. */
602 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
603 total
+= s
->lineno_count
;
607 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
608 BFD_ASSERT (s
->lineno_count
== 0);
610 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
612 asymbol
*q_maybe
= *p
;
614 if (bfd_family_coff (bfd_asymbol_bfd (q_maybe
)))
616 coff_symbol_type
*q
= coffsymbol (q_maybe
);
618 /* The AIX 4.1 compiler can sometimes generate line numbers
619 attached to debugging symbols. We try to simply ignore
621 if (q
->lineno
!= NULL
622 && q
->symbol
.section
->owner
!= NULL
)
624 /* This symbol has line numbers. Increment the owning
625 section's linenumber count. */
626 alent
*l
= q
->lineno
;
630 asection
* sec
= q
->symbol
.section
->output_section
;
632 /* Do not try to update fields in read-only sections. */
633 if (! bfd_is_const_section (sec
))
634 sec
->lineno_count
++;
639 while (l
->line_number
!= 0);
648 fixup_symbol_value (bfd
*abfd
,
649 coff_symbol_type
*coff_symbol_ptr
,
650 struct internal_syment
*syment
)
652 /* Normalize the symbol flags. */
653 if (coff_symbol_ptr
->symbol
.section
654 && bfd_is_com_section (coff_symbol_ptr
->symbol
.section
))
656 /* A common symbol is undefined with a value. */
657 syment
->n_scnum
= N_UNDEF
;
658 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
660 else if ((coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
) != 0
661 && (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING_RELOC
) == 0)
663 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
665 else if (bfd_is_und_section (coff_symbol_ptr
->symbol
.section
))
667 syment
->n_scnum
= N_UNDEF
;
670 /* FIXME: Do we need to handle the absolute section here? */
673 if (coff_symbol_ptr
->symbol
.section
)
676 coff_symbol_ptr
->symbol
.section
->output_section
->target_index
;
678 syment
->n_value
= (coff_symbol_ptr
->symbol
.value
679 + coff_symbol_ptr
->symbol
.section
->output_offset
);
682 syment
->n_value
+= (syment
->n_sclass
== C_STATLAB
)
683 ? coff_symbol_ptr
->symbol
.section
->output_section
->lma
684 : coff_symbol_ptr
->symbol
.section
->output_section
->vma
;
690 /* This can happen, but I don't know why yet (steve@cygnus.com) */
691 syment
->n_scnum
= N_ABS
;
692 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
697 /* Run through all the symbols in the symbol table and work out what
698 their indexes into the symbol table will be when output.
700 Coff requires that each C_FILE symbol points to the next one in the
701 chain, and that the last one points to the first external symbol. We
705 coff_renumber_symbols (bfd
*bfd_ptr
, int *first_undef
)
707 unsigned int symbol_count
= bfd_get_symcount (bfd_ptr
);
708 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
709 unsigned int native_index
= 0;
710 struct internal_syment
*last_file
= NULL
;
711 unsigned int symbol_index
;
713 /* COFF demands that undefined symbols come after all other symbols.
714 Since we don't need to impose this extra knowledge on all our
715 client programs, deal with that here. Sort the symbol table;
716 just move the undefined symbols to the end, leaving the rest
717 alone. The O'Reilly book says that defined global symbols come
718 at the end before the undefined symbols, so we do that here as
720 /* @@ Do we have some condition we could test for, so we don't always
721 have to do this? I don't think relocatability is quite right, but
722 I'm not certain. [raeburn:19920508.1711EST] */
728 amt
= sizeof (asymbol
*) * ((bfd_size_type
) symbol_count
+ 1);
729 newsyms
= (asymbol
**) bfd_alloc (bfd_ptr
, amt
);
732 bfd_ptr
->outsymbols
= newsyms
;
733 for (i
= 0; i
< symbol_count
; i
++)
734 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) != 0
735 || (!bfd_is_und_section (symbol_ptr_ptr
[i
]->section
)
736 && !bfd_is_com_section (symbol_ptr_ptr
[i
]->section
)
737 && ((symbol_ptr_ptr
[i
]->flags
& BSF_FUNCTION
) != 0
738 || ((symbol_ptr_ptr
[i
]->flags
& (BSF_GLOBAL
| BSF_WEAK
))
740 *newsyms
++ = symbol_ptr_ptr
[i
];
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 && (bfd_is_com_section (symbol_ptr_ptr
[i
]->section
)
746 || ((symbol_ptr_ptr
[i
]->flags
& BSF_FUNCTION
) == 0
747 && ((symbol_ptr_ptr
[i
]->flags
& (BSF_GLOBAL
| BSF_WEAK
))
749 *newsyms
++ = symbol_ptr_ptr
[i
];
751 *first_undef
= newsyms
- bfd_ptr
->outsymbols
;
753 for (i
= 0; i
< symbol_count
; i
++)
754 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) == 0
755 && bfd_is_und_section (symbol_ptr_ptr
[i
]->section
))
756 *newsyms
++ = symbol_ptr_ptr
[i
];
757 *newsyms
= (asymbol
*) NULL
;
758 symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
761 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
763 coff_symbol_type
*coff_symbol_ptr
;
765 coff_symbol_ptr
= coff_symbol_from (symbol_ptr_ptr
[symbol_index
]);
766 symbol_ptr_ptr
[symbol_index
]->udata
.i
= symbol_index
;
767 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
)
769 combined_entry_type
*s
= coff_symbol_ptr
->native
;
772 BFD_ASSERT (s
->is_sym
);
773 if (s
->u
.syment
.n_sclass
== C_FILE
)
775 if (last_file
!= NULL
)
776 last_file
->n_value
= native_index
;
777 last_file
= &(s
->u
.syment
);
780 /* Modify the symbol values according to their section and
782 fixup_symbol_value (bfd_ptr
, coff_symbol_ptr
, &(s
->u
.syment
));
784 for (i
= 0; i
< s
->u
.syment
.n_numaux
+ 1; i
++)
785 s
[i
].offset
= native_index
++;
791 obj_conv_table_size (bfd_ptr
) = native_index
;
796 /* Run thorough the symbol table again, and fix it so that all
797 pointers to entries are changed to the entries' index in the output
801 coff_mangle_symbols (bfd
*bfd_ptr
)
803 unsigned int symbol_count
= bfd_get_symcount (bfd_ptr
);
804 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
805 unsigned int symbol_index
;
807 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
809 coff_symbol_type
*coff_symbol_ptr
;
811 coff_symbol_ptr
= coff_symbol_from (symbol_ptr_ptr
[symbol_index
]);
812 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
)
815 combined_entry_type
*s
= coff_symbol_ptr
->native
;
817 BFD_ASSERT (s
->is_sym
);
820 /* FIXME: We should use a union here. */
821 s
->u
.syment
.n_value
=
822 (bfd_hostptr_t
) ((combined_entry_type
*)
823 ((bfd_hostptr_t
) s
->u
.syment
.n_value
))->offset
;
828 /* The value is the offset into the line number entries
829 for the symbol's section. On output, the symbol's
830 section should be N_DEBUG. */
831 s
->u
.syment
.n_value
=
832 (coff_symbol_ptr
->symbol
.section
->output_section
->line_filepos
833 + s
->u
.syment
.n_value
* bfd_coff_linesz (bfd_ptr
));
834 coff_symbol_ptr
->symbol
.section
=
835 coff_section_from_bfd_index (bfd_ptr
, N_DEBUG
);
836 BFD_ASSERT (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
);
838 for (i
= 0; i
< s
->u
.syment
.n_numaux
; i
++)
840 combined_entry_type
*a
= s
+ i
+ 1;
842 BFD_ASSERT (! a
->is_sym
);
845 a
->u
.auxent
.x_sym
.x_tagndx
.l
=
846 a
->u
.auxent
.x_sym
.x_tagndx
.p
->offset
;
851 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
852 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
->offset
;
857 a
->u
.auxent
.x_csect
.x_scnlen
.l
=
858 a
->u
.auxent
.x_csect
.x_scnlen
.p
->offset
;
867 coff_fix_symbol_name (bfd
*abfd
,
869 combined_entry_type
*native
,
870 bfd_size_type
*string_size_p
,
871 asection
**debug_string_section_p
,
872 bfd_size_type
*debug_string_size_p
)
874 unsigned int name_length
;
875 union internal_auxent
*auxent
;
876 char *name
= (char *) (symbol
->name
);
880 /* COFF symbols always have names, so we'll make one up. */
881 symbol
->name
= "strange";
882 name
= (char *) symbol
->name
;
884 name_length
= strlen (name
);
886 BFD_ASSERT (native
->is_sym
);
887 if (native
->u
.syment
.n_sclass
== C_FILE
888 && native
->u
.syment
.n_numaux
> 0)
890 unsigned int filnmlen
;
892 if (bfd_coff_force_symnames_in_strings (abfd
))
894 native
->u
.syment
._n
._n_n
._n_offset
=
895 (*string_size_p
+ STRING_SIZE_SIZE
);
896 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
897 *string_size_p
+= 6; /* strlen(".file") + 1 */
900 strncpy (native
->u
.syment
._n
._n_name
, ".file", SYMNMLEN
);
902 BFD_ASSERT (! (native
+ 1)->is_sym
);
903 auxent
= &(native
+ 1)->u
.auxent
;
905 filnmlen
= bfd_coff_filnmlen (abfd
);
907 if (bfd_coff_long_filenames (abfd
))
909 if (name_length
<= filnmlen
)
910 strncpy (auxent
->x_file
.x_fname
, name
, filnmlen
);
913 auxent
->x_file
.x_n
.x_offset
= *string_size_p
+ STRING_SIZE_SIZE
;
914 auxent
->x_file
.x_n
.x_zeroes
= 0;
915 *string_size_p
+= name_length
+ 1;
920 strncpy (auxent
->x_file
.x_fname
, name
, filnmlen
);
921 if (name_length
> filnmlen
)
922 name
[filnmlen
] = '\0';
927 if (name_length
<= SYMNMLEN
&& !bfd_coff_force_symnames_in_strings (abfd
))
928 /* This name will fit into the symbol neatly. */
929 strncpy (native
->u
.syment
._n
._n_name
, symbol
->name
, SYMNMLEN
);
931 else if (!bfd_coff_symname_in_debug (abfd
, &native
->u
.syment
))
933 native
->u
.syment
._n
._n_n
._n_offset
= (*string_size_p
935 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
936 *string_size_p
+= name_length
+ 1;
942 int prefix_len
= bfd_coff_debug_string_prefix_length (abfd
);
944 /* This name should be written into the .debug section. For
945 some reason each name is preceded by a two byte length
946 and also followed by a null byte. FIXME: We assume that
947 the .debug section has already been created, and that it
949 if (*debug_string_section_p
== (asection
*) NULL
)
950 *debug_string_section_p
= bfd_get_section_by_name (abfd
, ".debug");
951 filepos
= bfd_tell (abfd
);
953 bfd_put_32 (abfd
, (bfd_vma
) (name_length
+ 1), buf
);
955 bfd_put_16 (abfd
, (bfd_vma
) (name_length
+ 1), buf
);
957 if (!bfd_set_section_contents (abfd
,
958 *debug_string_section_p
,
960 (file_ptr
) *debug_string_size_p
,
961 (bfd_size_type
) prefix_len
)
962 || !bfd_set_section_contents (abfd
,
963 *debug_string_section_p
,
964 (void *) symbol
->name
,
965 (file_ptr
) (*debug_string_size_p
967 (bfd_size_type
) name_length
+ 1))
969 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
971 native
->u
.syment
._n
._n_n
._n_offset
=
972 *debug_string_size_p
+ prefix_len
;
973 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
974 *debug_string_size_p
+= name_length
+ 1 + prefix_len
;
979 /* We need to keep track of the symbol index so that when we write out
980 the relocs we can get the index for a symbol. This method is a
983 #define set_index(symbol, idx) ((symbol)->udata.i = (idx))
985 /* Write a symbol out to a COFF file. */
988 coff_write_symbol (bfd
*abfd
,
990 combined_entry_type
*native
,
992 bfd_size_type
*string_size_p
,
993 asection
**debug_string_section_p
,
994 bfd_size_type
*debug_string_size_p
)
996 unsigned int numaux
= native
->u
.syment
.n_numaux
;
997 int type
= native
->u
.syment
.n_type
;
998 int n_sclass
= (int) native
->u
.syment
.n_sclass
;
999 asection
*output_section
= symbol
->section
->output_section
1000 ? symbol
->section
->output_section
1003 bfd_size_type symesz
;
1005 BFD_ASSERT (native
->is_sym
);
1007 if (native
->u
.syment
.n_sclass
== C_FILE
)
1008 symbol
->flags
|= BSF_DEBUGGING
;
1010 if (symbol
->flags
& BSF_DEBUGGING
1011 && bfd_is_abs_section (symbol
->section
))
1012 native
->u
.syment
.n_scnum
= N_DEBUG
;
1014 else if (bfd_is_abs_section (symbol
->section
))
1015 native
->u
.syment
.n_scnum
= N_ABS
;
1017 else if (bfd_is_und_section (symbol
->section
))
1018 native
->u
.syment
.n_scnum
= N_UNDEF
;
1021 native
->u
.syment
.n_scnum
=
1022 output_section
->target_index
;
1024 coff_fix_symbol_name (abfd
, symbol
, native
, string_size_p
,
1025 debug_string_section_p
, debug_string_size_p
);
1027 symesz
= bfd_coff_symesz (abfd
);
1028 buf
= bfd_alloc (abfd
, symesz
);
1031 bfd_coff_swap_sym_out (abfd
, &native
->u
.syment
, buf
);
1032 if (bfd_bwrite (buf
, symesz
, abfd
) != symesz
)
1034 bfd_release (abfd
, buf
);
1036 if (native
->u
.syment
.n_numaux
> 0)
1038 bfd_size_type auxesz
;
1041 auxesz
= bfd_coff_auxesz (abfd
);
1042 buf
= bfd_alloc (abfd
, auxesz
);
1045 for (j
= 0; j
< native
->u
.syment
.n_numaux
; j
++)
1047 BFD_ASSERT (! (native
+ j
+ 1)->is_sym
);
1048 bfd_coff_swap_aux_out (abfd
,
1049 &((native
+ j
+ 1)->u
.auxent
),
1050 type
, n_sclass
, (int) j
,
1051 native
->u
.syment
.n_numaux
,
1053 if (bfd_bwrite (buf
, auxesz
, abfd
) != auxesz
)
1056 bfd_release (abfd
, buf
);
1059 /* Store the index for use when we write out the relocs. */
1060 set_index (symbol
, *written
);
1062 *written
+= numaux
+ 1;
1066 /* Write out a symbol to a COFF file that does not come from a COFF
1067 file originally. This symbol may have been created by the linker,
1068 or we may be linking a non COFF file to a COFF file. */
1071 coff_write_alien_symbol (bfd
*abfd
,
1073 struct internal_syment
*isym
,
1074 union internal_auxent
*iaux
,
1076 bfd_size_type
*string_size_p
,
1077 asection
**debug_string_section_p
,
1078 bfd_size_type
*debug_string_size_p
)
1080 combined_entry_type
*native
;
1081 combined_entry_type dummy
[2];
1082 asection
*output_section
= symbol
->section
->output_section
1083 ? symbol
->section
->output_section
1085 struct bfd_link_info
*link_info
= coff_data (abfd
)->link_info
;
1088 if ((!link_info
|| link_info
->strip_discarded
)
1089 && !bfd_is_abs_section (symbol
->section
)
1090 && symbol
->section
->output_section
== bfd_abs_section_ptr
)
1094 memset (isym
, 0, sizeof (*isym
));
1098 native
->is_sym
= TRUE
;
1099 native
[1].is_sym
= FALSE
;
1100 native
->u
.syment
.n_type
= T_NULL
;
1101 native
->u
.syment
.n_flags
= 0;
1102 native
->u
.syment
.n_numaux
= 0;
1103 if (bfd_is_und_section (symbol
->section
))
1105 native
->u
.syment
.n_scnum
= N_UNDEF
;
1106 native
->u
.syment
.n_value
= symbol
->value
;
1108 else if (bfd_is_com_section (symbol
->section
))
1110 native
->u
.syment
.n_scnum
= N_UNDEF
;
1111 native
->u
.syment
.n_value
= symbol
->value
;
1113 else if (symbol
->flags
& BSF_FILE
)
1115 native
->u
.syment
.n_scnum
= N_DEBUG
;
1116 native
->u
.syment
.n_numaux
= 1;
1118 else if (symbol
->flags
& BSF_DEBUGGING
)
1120 /* There isn't much point to writing out a debugging symbol
1121 unless we are prepared to convert it into COFF debugging
1122 format. So, we just ignore them. We must clobber the symbol
1123 name to keep it from being put in the string table. */
1126 memset (isym
, 0, sizeof (*isym
));
1131 native
->u
.syment
.n_scnum
= output_section
->target_index
;
1132 native
->u
.syment
.n_value
= (symbol
->value
1133 + symbol
->section
->output_offset
);
1134 if (! obj_pe (abfd
))
1135 native
->u
.syment
.n_value
+= output_section
->vma
;
1137 /* Copy the any flags from the file header into the symbol.
1140 coff_symbol_type
*c
= coff_symbol_from (symbol
);
1141 if (c
!= (coff_symbol_type
*) NULL
)
1142 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (&c
->symbol
)->flags
;
1146 native
->u
.syment
.n_type
= 0;
1147 if (symbol
->flags
& BSF_FILE
)
1148 native
->u
.syment
.n_sclass
= C_FILE
;
1149 else if (symbol
->flags
& BSF_LOCAL
)
1150 native
->u
.syment
.n_sclass
= C_STAT
;
1151 else if (symbol
->flags
& BSF_WEAK
)
1152 native
->u
.syment
.n_sclass
= obj_pe (abfd
) ? C_NT_WEAK
: C_WEAKEXT
;
1154 native
->u
.syment
.n_sclass
= C_EXT
;
1156 ret
= coff_write_symbol (abfd
, symbol
, native
, written
, string_size_p
,
1157 debug_string_section_p
, debug_string_size_p
);
1159 *isym
= native
->u
.syment
;
1160 if (iaux
!= NULL
&& native
->u
.syment
.n_numaux
)
1161 *iaux
= native
[1].u
.auxent
;
1165 /* Write a native symbol to a COFF file. */
1168 coff_write_native_symbol (bfd
*abfd
,
1169 coff_symbol_type
*symbol
,
1171 bfd_size_type
*string_size_p
,
1172 asection
**debug_string_section_p
,
1173 bfd_size_type
*debug_string_size_p
)
1175 combined_entry_type
*native
= symbol
->native
;
1176 alent
*lineno
= symbol
->lineno
;
1177 struct bfd_link_info
*link_info
= coff_data (abfd
)->link_info
;
1179 if ((!link_info
|| link_info
->strip_discarded
)
1180 && !bfd_is_abs_section (symbol
->symbol
.section
)
1181 && symbol
->symbol
.section
->output_section
== bfd_abs_section_ptr
)
1183 symbol
->symbol
.name
= "";
1187 BFD_ASSERT (native
->is_sym
);
1188 /* If this symbol has an associated line number, we must store the
1189 symbol index in the line number field. We also tag the auxent to
1190 point to the right place in the lineno table. */
1191 if (lineno
&& !symbol
->done_lineno
&& symbol
->symbol
.section
->owner
!= NULL
)
1193 unsigned int count
= 0;
1195 lineno
[count
].u
.offset
= *written
;
1196 if (native
->u
.syment
.n_numaux
)
1198 union internal_auxent
*a
= &((native
+ 1)->u
.auxent
);
1200 a
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1201 symbol
->symbol
.section
->output_section
->moving_line_filepos
;
1204 /* Count and relocate all other linenumbers. */
1206 while (lineno
[count
].line_number
!= 0)
1208 lineno
[count
].u
.offset
+=
1209 (symbol
->symbol
.section
->output_section
->vma
1210 + symbol
->symbol
.section
->output_offset
);
1213 symbol
->done_lineno
= TRUE
;
1215 if (! bfd_is_const_section (symbol
->symbol
.section
->output_section
))
1216 symbol
->symbol
.section
->output_section
->moving_line_filepos
+=
1217 count
* bfd_coff_linesz (abfd
);
1220 return coff_write_symbol (abfd
, &(symbol
->symbol
), native
, written
,
1221 string_size_p
, debug_string_section_p
,
1222 debug_string_size_p
);
1226 null_error_handler (const char *fmt ATTRIBUTE_UNUSED
,
1227 va_list ap ATTRIBUTE_UNUSED
)
1231 /* Write out the COFF symbols. */
1234 coff_write_symbols (bfd
*abfd
)
1236 bfd_size_type string_size
;
1237 asection
*debug_string_section
;
1238 bfd_size_type debug_string_size
;
1240 unsigned int limit
= bfd_get_symcount (abfd
);
1241 bfd_vma written
= 0;
1245 debug_string_section
= NULL
;
1246 debug_string_size
= 0;
1248 /* If this target supports long section names, they must be put into
1249 the string table. This is supported by PE. This code must
1250 handle section names just as they are handled in
1251 coff_write_object_contents. */
1252 if (bfd_coff_long_section_names (abfd
))
1256 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1260 len
= strlen (o
->name
);
1262 string_size
+= len
+ 1;
1266 /* Seek to the right place. */
1267 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
1270 /* Output all the symbols we have. */
1272 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1274 asymbol
*symbol
= *p
;
1275 coff_symbol_type
*c_symbol
= coff_symbol_from (symbol
);
1277 if (c_symbol
== (coff_symbol_type
*) NULL
1278 || c_symbol
->native
== (combined_entry_type
*) NULL
)
1280 if (!coff_write_alien_symbol (abfd
, symbol
, NULL
, NULL
, &written
,
1281 &string_size
, &debug_string_section
,
1282 &debug_string_size
))
1287 if (coff_backend_info (abfd
)->_bfd_coff_classify_symbol
!= NULL
)
1289 bfd_error_handler_type current_error_handler
;
1290 enum coff_symbol_classification sym_class
;
1291 unsigned char *n_sclass
;
1293 /* Suppress error reporting by bfd_coff_classify_symbol.
1294 Error messages can be generated when we are processing a local
1295 symbol which has no associated section and we do not have to
1296 worry about this, all we need to know is that it is local. */
1297 current_error_handler
= bfd_set_error_handler (null_error_handler
);
1298 BFD_ASSERT (c_symbol
->native
->is_sym
);
1299 sym_class
= bfd_coff_classify_symbol (abfd
,
1300 &c_symbol
->native
->u
.syment
);
1301 (void) bfd_set_error_handler (current_error_handler
);
1303 n_sclass
= &c_symbol
->native
->u
.syment
.n_sclass
;
1305 /* If the symbol class has been changed (eg objcopy/ld script/etc)
1306 we cannot retain the existing sclass from the original symbol.
1307 Weak symbols only have one valid sclass, so just set it always.
1308 If it is not local class and should be, set it C_STAT.
1309 If it is global and not classified as global, or if it is
1310 weak (which is also classified as global), set it C_EXT. */
1312 if (symbol
->flags
& BSF_WEAK
)
1313 *n_sclass
= obj_pe (abfd
) ? C_NT_WEAK
: C_WEAKEXT
;
1314 else if (symbol
->flags
& BSF_LOCAL
&& sym_class
!= COFF_SYMBOL_LOCAL
)
1316 else if (symbol
->flags
& BSF_GLOBAL
1317 && (sym_class
!= COFF_SYMBOL_GLOBAL
1319 || *n_sclass
== C_NT_WEAK
1321 || *n_sclass
== C_WEAKEXT
))
1322 c_symbol
->native
->u
.syment
.n_sclass
= C_EXT
;
1325 if (!coff_write_native_symbol (abfd
, c_symbol
, &written
,
1326 &string_size
, &debug_string_section
,
1327 &debug_string_size
))
1332 obj_raw_syment_count (abfd
) = written
;
1334 /* Now write out strings. */
1335 if (string_size
!= 0)
1337 unsigned int size
= string_size
+ STRING_SIZE_SIZE
;
1338 bfd_byte buffer
[STRING_SIZE_SIZE
];
1340 #if STRING_SIZE_SIZE == 4
1341 H_PUT_32 (abfd
, size
, buffer
);
1343 #error Change H_PUT_32
1345 if (bfd_bwrite ((void *) buffer
, (bfd_size_type
) sizeof (buffer
), abfd
)
1349 /* Handle long section names. This code must handle section
1350 names just as they are handled in coff_write_object_contents. */
1351 if (bfd_coff_long_section_names (abfd
))
1355 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1359 len
= strlen (o
->name
);
1362 if (bfd_bwrite (o
->name
, (bfd_size_type
) (len
+ 1), abfd
)
1369 for (p
= abfd
->outsymbols
, i
= 0;
1374 size_t name_length
= strlen (q
->name
);
1375 coff_symbol_type
*c_symbol
= coff_symbol_from (q
);
1378 /* Figure out whether the symbol name should go in the string
1379 table. Symbol names that are short enough are stored
1380 directly in the syment structure. File names permit a
1381 different, longer, length in the syment structure. On
1382 XCOFF, some symbol names are stored in the .debug section
1383 rather than in the string table. */
1385 if (c_symbol
== NULL
1386 || c_symbol
->native
== NULL
)
1387 /* This is not a COFF symbol, so it certainly is not a
1388 file name, nor does it go in the .debug section. */
1389 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1391 else if (! c_symbol
->native
->is_sym
)
1392 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1394 else if (bfd_coff_symname_in_debug (abfd
,
1395 &c_symbol
->native
->u
.syment
))
1396 /* This symbol name is in the XCOFF .debug section.
1397 Don't write it into the string table. */
1398 maxlen
= name_length
;
1400 else if (c_symbol
->native
->u
.syment
.n_sclass
== C_FILE
1401 && c_symbol
->native
->u
.syment
.n_numaux
> 0)
1403 if (bfd_coff_force_symnames_in_strings (abfd
))
1405 if (bfd_bwrite (".file", (bfd_size_type
) 6, abfd
) != 6)
1408 maxlen
= bfd_coff_filnmlen (abfd
);
1411 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1413 if (name_length
> maxlen
)
1415 if (bfd_bwrite ((void *) (q
->name
), (bfd_size_type
) name_length
+ 1,
1416 abfd
) != name_length
+ 1)
1423 /* We would normally not write anything here, but we'll write
1424 out 4 so that any stupid coff reader which tries to read the
1425 string table even when there isn't one won't croak. */
1426 unsigned int size
= STRING_SIZE_SIZE
;
1427 bfd_byte buffer
[STRING_SIZE_SIZE
];
1429 #if STRING_SIZE_SIZE == 4
1430 H_PUT_32 (abfd
, size
, buffer
);
1432 #error Change H_PUT_32
1434 if (bfd_bwrite ((void *) buffer
, (bfd_size_type
) STRING_SIZE_SIZE
, abfd
)
1435 != STRING_SIZE_SIZE
)
1439 /* Make sure the .debug section was created to be the correct size.
1440 We should create it ourselves on the fly, but we don't because
1441 BFD won't let us write to any section until we know how large all
1442 the sections are. We could still do it by making another pass
1443 over the symbols. FIXME. */
1444 BFD_ASSERT (debug_string_size
== 0
1445 || (debug_string_section
!= (asection
*) NULL
1446 && (BFD_ALIGN (debug_string_size
,
1447 1 << debug_string_section
->alignment_power
)
1448 == debug_string_section
->size
)));
1454 coff_write_linenumbers (bfd
*abfd
)
1457 bfd_size_type linesz
;
1460 linesz
= bfd_coff_linesz (abfd
);
1461 buff
= bfd_alloc (abfd
, linesz
);
1464 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
1466 if (s
->lineno_count
)
1468 asymbol
**q
= abfd
->outsymbols
;
1469 if (bfd_seek (abfd
, s
->line_filepos
, SEEK_SET
) != 0)
1471 /* Find all the linenumbers in this section. */
1475 if (p
->section
->output_section
== s
)
1478 BFD_SEND (bfd_asymbol_bfd (p
), _get_lineno
,
1479 (bfd_asymbol_bfd (p
), p
));
1482 /* Found a linenumber entry, output. */
1483 struct internal_lineno out
;
1485 memset ((void *) & out
, 0, sizeof (out
));
1487 out
.l_addr
.l_symndx
= l
->u
.offset
;
1488 bfd_coff_swap_lineno_out (abfd
, &out
, buff
);
1489 if (bfd_bwrite (buff
, (bfd_size_type
) linesz
, abfd
)
1493 while (l
->line_number
)
1495 out
.l_lnno
= l
->line_number
;
1496 out
.l_addr
.l_symndx
= l
->u
.offset
;
1497 bfd_coff_swap_lineno_out (abfd
, &out
, buff
);
1498 if (bfd_bwrite (buff
, (bfd_size_type
) linesz
, abfd
)
1509 bfd_release (abfd
, buff
);
1514 coff_get_lineno (bfd
*ignore_abfd ATTRIBUTE_UNUSED
, asymbol
*symbol
)
1516 return coffsymbol (symbol
)->lineno
;
1519 /* This function transforms the offsets into the symbol table into
1520 pointers to syments. */
1523 coff_pointerize_aux (bfd
*abfd
,
1524 combined_entry_type
*table_base
,
1525 combined_entry_type
*symbol
,
1526 unsigned int indaux
,
1527 combined_entry_type
*auxent
,
1528 combined_entry_type
*table_end
)
1530 unsigned int type
= symbol
->u
.syment
.n_type
;
1531 unsigned int n_sclass
= symbol
->u
.syment
.n_sclass
;
1533 BFD_ASSERT (symbol
->is_sym
);
1534 if (coff_backend_info (abfd
)->_bfd_coff_pointerize_aux_hook
)
1536 if ((*coff_backend_info (abfd
)->_bfd_coff_pointerize_aux_hook
)
1537 (abfd
, table_base
, symbol
, indaux
, auxent
))
1541 /* Don't bother if this is a file or a section. */
1542 if (n_sclass
== C_STAT
&& type
== T_NULL
)
1544 if (n_sclass
== C_FILE
)
1547 BFD_ASSERT (! auxent
->is_sym
);
1548 /* Otherwise patch up. */
1549 #define N_TMASK coff_data (abfd)->local_n_tmask
1550 #define N_BTSHFT coff_data (abfd)->local_n_btshft
1552 if ((ISFCN (type
) || ISTAG (n_sclass
) || n_sclass
== C_BLOCK
1553 || n_sclass
== C_FCN
)
1554 && auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
> 0
1555 && auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
1556 < (long) obj_raw_syment_count (abfd
)
1557 && table_base
+ auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
1560 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
=
1561 table_base
+ auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
1562 auxent
->fix_end
= 1;
1565 /* A negative tagndx is meaningless, but the SCO 3.2v4 cc can
1566 generate one, so we must be careful to ignore it. */
1567 if ((unsigned long) auxent
->u
.auxent
.x_sym
.x_tagndx
.l
1568 < obj_raw_syment_count (abfd
)
1569 && table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
< table_end
)
1571 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
=
1572 table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
;
1573 auxent
->fix_tag
= 1;
1577 /* Allocate space for the ".debug" section, and read it.
1578 We did not read the debug section until now, because
1579 we didn't want to go to the trouble until someone needed it. */
1582 build_debug_section (bfd
*abfd
, asection
** sect_return
)
1584 char *debug_section
;
1586 bfd_size_type sec_size
;
1588 asection
*sect
= bfd_get_section_by_name (abfd
, ".debug");
1592 bfd_set_error (bfd_error_no_debug_section
);
1596 sec_size
= sect
->size
;
1597 debug_section
= (char *) bfd_alloc (abfd
, sec_size
);
1598 if (debug_section
== NULL
)
1601 /* Seek to the beginning of the `.debug' section and read it.
1602 Save the current position first; it is needed by our caller.
1603 Then read debug section and reset the file pointer. */
1605 position
= bfd_tell (abfd
);
1606 if (bfd_seek (abfd
, sect
->filepos
, SEEK_SET
) != 0
1607 || bfd_bread (debug_section
, sec_size
, abfd
) != sec_size
1608 || bfd_seek (abfd
, position
, SEEK_SET
) != 0)
1611 * sect_return
= sect
;
1612 return debug_section
;
1615 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
1616 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
1617 be \0-terminated. */
1620 copy_name (bfd
*abfd
, char *name
, size_t maxlen
)
1625 for (len
= 0; len
< maxlen
; ++len
)
1626 if (name
[len
] == '\0')
1629 if ((newname
= (char *) bfd_alloc (abfd
, (bfd_size_type
) len
+ 1)) == NULL
)
1632 strncpy (newname
, name
, len
);
1633 newname
[len
] = '\0';
1637 /* Read in the external symbols. */
1640 _bfd_coff_get_external_symbols (bfd
*abfd
)
1642 bfd_size_type symesz
;
1647 if (obj_coff_external_syms (abfd
) != NULL
)
1650 symesz
= bfd_coff_symesz (abfd
);
1651 size
= obj_raw_syment_count (abfd
) * symesz
;
1655 /* Check for integer overflow and for unreasonable symbol counts. */
1656 filesize
= bfd_get_file_size (abfd
);
1657 if (size
< obj_raw_syment_count (abfd
)
1658 || (filesize
!= 0 && size
> filesize
))
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
;
1704 if (obj_coff_strings (abfd
) != NULL
)
1705 return obj_coff_strings (abfd
);
1707 if (obj_sym_filepos (abfd
) == 0)
1709 bfd_set_error (bfd_error_no_symbols
);
1713 pos
= obj_sym_filepos (abfd
);
1714 pos
+= obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
1715 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
1718 if (bfd_bread (extstrsize
, (bfd_size_type
) sizeof extstrsize
, abfd
)
1719 != sizeof extstrsize
)
1721 if (bfd_get_error () != bfd_error_file_truncated
)
1724 /* There is no string table. */
1725 strsize
= STRING_SIZE_SIZE
;
1729 #if STRING_SIZE_SIZE == 4
1730 strsize
= H_GET_32 (abfd
, extstrsize
);
1732 #error Change H_GET_32
1736 filesize
= bfd_get_file_size (abfd
);
1737 if (strsize
< STRING_SIZE_SIZE
1738 || (filesize
!= 0 && strsize
> filesize
))
1741 /* xgettext: c-format */
1742 (_("%pB: bad string table size %" PRIu64
), abfd
, (uint64_t) strsize
);
1743 bfd_set_error (bfd_error_bad_value
);
1747 strings
= (char *) bfd_malloc (strsize
+ 1);
1748 if (strings
== NULL
)
1751 /* PR 17521 file: 079-54929-0.004.
1752 A corrupt file could contain an index that points into the first
1753 STRING_SIZE_SIZE bytes of the string table, so make sure that
1755 memset (strings
, 0, STRING_SIZE_SIZE
);
1757 if (bfd_bread (strings
+ STRING_SIZE_SIZE
, strsize
- STRING_SIZE_SIZE
, abfd
)
1758 != strsize
- STRING_SIZE_SIZE
)
1764 obj_coff_strings (abfd
) = strings
;
1765 obj_coff_strings_len (abfd
) = strsize
;
1766 /* Terminate the string table, just in case. */
1767 strings
[strsize
] = 0;
1771 /* Free up the external symbols and strings read from a COFF file. */
1774 _bfd_coff_free_symbols (bfd
*abfd
)
1776 if (! bfd_family_coff (abfd
))
1779 if (obj_coff_external_syms (abfd
) != NULL
1780 && ! obj_coff_keep_syms (abfd
))
1782 free (obj_coff_external_syms (abfd
));
1783 obj_coff_external_syms (abfd
) = NULL
;
1786 if (obj_coff_strings (abfd
) != NULL
1787 && ! obj_coff_keep_strings (abfd
))
1789 free (obj_coff_strings (abfd
));
1790 obj_coff_strings (abfd
) = NULL
;
1791 obj_coff_strings_len (abfd
) = 0;
1797 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
1798 knit the symbol names into a normalized form. By normalized here I
1799 mean that all symbols have an n_offset pointer that points to a null-
1800 terminated string. */
1802 combined_entry_type
*
1803 coff_get_normalized_symtab (bfd
*abfd
)
1805 combined_entry_type
*internal
;
1806 combined_entry_type
*internal_ptr
;
1807 combined_entry_type
*symbol_ptr
;
1808 combined_entry_type
*internal_end
;
1812 const char *string_table
= NULL
;
1813 asection
* debug_sec
= NULL
;
1814 char *debug_sec_data
= NULL
;
1817 if (obj_raw_syments (abfd
) != NULL
)
1818 return obj_raw_syments (abfd
);
1820 if (! _bfd_coff_get_external_symbols (abfd
))
1823 size
= obj_raw_syment_count (abfd
);
1824 /* Check for integer overflow. */
1825 if (size
> (bfd_size_type
) -1 / sizeof (combined_entry_type
))
1827 size
*= sizeof (combined_entry_type
);
1828 internal
= (combined_entry_type
*) bfd_zalloc (abfd
, size
);
1829 if (internal
== NULL
&& size
!= 0)
1831 internal_end
= internal
+ obj_raw_syment_count (abfd
);
1833 raw_src
= (char *) obj_coff_external_syms (abfd
);
1835 /* Mark the end of the symbols. */
1836 symesz
= bfd_coff_symesz (abfd
);
1837 raw_end
= (char *) raw_src
+ obj_raw_syment_count (abfd
) * symesz
;
1839 /* FIXME SOMEDAY. A string table size of zero is very weird, but
1840 probably possible. If one shows up, it will probably kill us. */
1842 /* Swap all the raw entries. */
1843 for (internal_ptr
= internal
;
1845 raw_src
+= symesz
, internal_ptr
++)
1849 bfd_coff_swap_sym_in (abfd
, (void *) raw_src
,
1850 (void *) & internal_ptr
->u
.syment
);
1851 symbol_ptr
= internal_ptr
;
1852 internal_ptr
->is_sym
= TRUE
;
1855 i
< symbol_ptr
->u
.syment
.n_numaux
;
1861 /* PR 17512: Prevent buffer overrun. */
1862 if (raw_src
>= raw_end
|| internal_ptr
>= internal_end
)
1864 bfd_release (abfd
, internal
);
1868 bfd_coff_swap_aux_in (abfd
, (void *) raw_src
,
1869 symbol_ptr
->u
.syment
.n_type
,
1870 symbol_ptr
->u
.syment
.n_sclass
,
1871 (int) i
, symbol_ptr
->u
.syment
.n_numaux
,
1872 &(internal_ptr
->u
.auxent
));
1874 internal_ptr
->is_sym
= FALSE
;
1875 coff_pointerize_aux (abfd
, internal
, symbol_ptr
, i
,
1876 internal_ptr
, internal_end
);
1880 /* Free the raw symbols. */
1881 if (obj_coff_external_syms (abfd
) != NULL
1882 && ! obj_coff_keep_syms (abfd
))
1884 free (obj_coff_external_syms (abfd
));
1885 obj_coff_external_syms (abfd
) = NULL
;
1888 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
1891 BFD_ASSERT (internal_ptr
->is_sym
);
1893 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
1894 && internal_ptr
->u
.syment
.n_numaux
> 0)
1896 combined_entry_type
* aux
= internal_ptr
+ 1;
1898 /* Make a file symbol point to the name in the auxent, since
1899 the text ".file" is redundant. */
1900 BFD_ASSERT (! aux
->is_sym
);
1902 if (aux
->u
.auxent
.x_file
.x_n
.x_zeroes
== 0)
1904 /* The filename is a long one, point into the string table. */
1905 if (string_table
== NULL
)
1907 string_table
= _bfd_coff_read_string_table (abfd
);
1908 if (string_table
== NULL
)
1912 if ((bfd_size_type
)(aux
->u
.auxent
.x_file
.x_n
.x_offset
)
1913 >= obj_coff_strings_len (abfd
))
1914 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1916 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1917 (bfd_hostptr_t
) (string_table
+ (aux
->u
.auxent
.x_file
.x_n
.x_offset
));
1921 /* Ordinary short filename, put into memory anyway. The
1922 Microsoft PE tools sometimes store a filename in
1923 multiple AUX entries. */
1924 if (internal_ptr
->u
.syment
.n_numaux
> 1
1925 && coff_data (abfd
)->pe
)
1926 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1929 aux
->u
.auxent
.x_file
.x_fname
,
1930 internal_ptr
->u
.syment
.n_numaux
* symesz
);
1932 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1935 aux
->u
.auxent
.x_file
.x_fname
,
1936 (size_t) bfd_coff_filnmlen (abfd
)));
1941 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0)
1943 /* This is a "short" name. Make it long. */
1947 /* Find the length of this string without walking into memory
1949 for (i
= 0; i
< 8; ++i
)
1950 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0')
1953 newstring
= (char *) bfd_zalloc (abfd
, (bfd_size_type
) (i
+ 1));
1954 if (newstring
== NULL
)
1956 strncpy (newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
);
1957 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) newstring
;
1958 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1960 else if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
== 0)
1961 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) "";
1962 else if (!bfd_coff_symname_in_debug (abfd
, &internal_ptr
->u
.syment
))
1964 /* Long name already. Point symbol at the string in the
1966 if (string_table
== NULL
)
1968 string_table
= _bfd_coff_read_string_table (abfd
);
1969 if (string_table
== NULL
)
1972 if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
>= obj_coff_strings_len (abfd
)
1973 || string_table
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
< string_table
)
1974 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1976 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1979 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
));
1983 /* Long name in debug section. Very similar. */
1984 if (debug_sec_data
== NULL
)
1985 debug_sec_data
= build_debug_section (abfd
, & debug_sec
);
1986 if (debug_sec_data
!= NULL
)
1988 BFD_ASSERT (debug_sec
!= NULL
);
1989 /* PR binutils/17512: Catch out of range offsets into the debug data. */
1990 if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
> debug_sec
->size
1991 || debug_sec_data
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
< debug_sec_data
)
1992 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1994 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
)
1995 (debug_sec_data
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
1998 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) "";
2001 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
2004 obj_raw_syments (abfd
) = internal
;
2005 BFD_ASSERT (obj_raw_syment_count (abfd
)
2006 == (unsigned int) (internal_ptr
- internal
));
2012 coff_get_reloc_upper_bound (bfd
*abfd
, sec_ptr asect
)
2014 if (bfd_get_format (abfd
) != bfd_object
)
2016 bfd_set_error (bfd_error_invalid_operation
);
2019 #if SIZEOF_LONG == SIZEOF_INT
2020 if (asect
->reloc_count
>= LONG_MAX
/ sizeof (arelent
*))
2022 bfd_set_error (bfd_error_file_too_big
);
2026 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
2030 coff_make_empty_symbol (bfd
*abfd
)
2032 size_t amt
= sizeof (coff_symbol_type
);
2033 coff_symbol_type
*new_symbol
= (coff_symbol_type
*) bfd_zalloc (abfd
, amt
);
2035 if (new_symbol
== NULL
)
2037 new_symbol
->symbol
.section
= 0;
2038 new_symbol
->native
= NULL
;
2039 new_symbol
->lineno
= NULL
;
2040 new_symbol
->done_lineno
= FALSE
;
2041 new_symbol
->symbol
.the_bfd
= abfd
;
2043 return & new_symbol
->symbol
;
2046 /* Make a debugging symbol. */
2049 coff_bfd_make_debug_symbol (bfd
*abfd
,
2050 void * ptr ATTRIBUTE_UNUSED
,
2051 unsigned long sz ATTRIBUTE_UNUSED
)
2053 size_t amt
= sizeof (coff_symbol_type
);
2054 coff_symbol_type
*new_symbol
= (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
2056 if (new_symbol
== NULL
)
2058 /* @@ The 10 is a guess at a plausible maximum number of aux entries
2059 (but shouldn't be a constant). */
2060 amt
= sizeof (combined_entry_type
) * 10;
2061 new_symbol
->native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
2062 if (!new_symbol
->native
)
2064 new_symbol
->native
->is_sym
= TRUE
;
2065 new_symbol
->symbol
.section
= bfd_abs_section_ptr
;
2066 new_symbol
->symbol
.flags
= BSF_DEBUGGING
;
2067 new_symbol
->lineno
= NULL
;
2068 new_symbol
->done_lineno
= FALSE
;
2069 new_symbol
->symbol
.the_bfd
= abfd
;
2071 return & new_symbol
->symbol
;
2075 coff_get_symbol_info (bfd
*abfd
, asymbol
*symbol
, symbol_info
*ret
)
2077 bfd_symbol_info (symbol
, ret
);
2079 if (coffsymbol (symbol
)->native
!= NULL
2080 && coffsymbol (symbol
)->native
->fix_value
2081 && coffsymbol (symbol
)->native
->is_sym
)
2082 ret
->value
= coffsymbol (symbol
)->native
->u
.syment
.n_value
-
2083 (bfd_hostptr_t
) obj_raw_syments (abfd
);
2086 /* Print out information about COFF symbol. */
2089 coff_print_symbol (bfd
*abfd
,
2092 bfd_print_symbol_type how
)
2094 FILE * file
= (FILE *) filep
;
2098 case bfd_print_symbol_name
:
2099 fprintf (file
, "%s", symbol
->name
);
2102 case bfd_print_symbol_more
:
2103 fprintf (file
, "coff %s %s",
2104 coffsymbol (symbol
)->native
? "n" : "g",
2105 coffsymbol (symbol
)->lineno
? "l" : " ");
2108 case bfd_print_symbol_all
:
2109 if (coffsymbol (symbol
)->native
)
2113 combined_entry_type
*combined
= coffsymbol (symbol
)->native
;
2114 combined_entry_type
*root
= obj_raw_syments (abfd
);
2115 struct lineno_cache_entry
*l
= coffsymbol (symbol
)->lineno
;
2117 fprintf (file
, "[%3ld]", (long) (combined
- root
));
2119 /* PR 17512: file: 079-33786-0.001:0.1. */
2120 if (combined
< obj_raw_syments (abfd
)
2121 || combined
>= obj_raw_syments (abfd
) + obj_raw_syment_count (abfd
))
2123 fprintf (file
, _("<corrupt info> %s"), symbol
->name
);
2127 BFD_ASSERT (combined
->is_sym
);
2128 if (! combined
->fix_value
)
2129 val
= (bfd_vma
) combined
->u
.syment
.n_value
;
2131 val
= combined
->u
.syment
.n_value
- (bfd_hostptr_t
) root
;
2133 fprintf (file
, "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x",
2134 combined
->u
.syment
.n_scnum
,
2135 combined
->u
.syment
.n_flags
,
2136 combined
->u
.syment
.n_type
,
2137 combined
->u
.syment
.n_sclass
,
2138 combined
->u
.syment
.n_numaux
);
2139 bfd_fprintf_vma (abfd
, file
, val
);
2140 fprintf (file
, " %s", symbol
->name
);
2142 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
2144 combined_entry_type
*auxp
= combined
+ aux
+ 1;
2147 BFD_ASSERT (! auxp
->is_sym
);
2149 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.p
- root
;
2151 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.l
;
2153 fprintf (file
, "\n");
2155 if (bfd_coff_print_aux (abfd
, file
, root
, combined
, auxp
, aux
))
2158 switch (combined
->u
.syment
.n_sclass
)
2161 fprintf (file
, "File ");
2165 if (combined
->u
.syment
.n_type
== T_NULL
)
2166 /* Probably a section symbol ? */
2168 fprintf (file
, "AUX scnlen 0x%lx nreloc %d nlnno %d",
2169 (unsigned long) auxp
->u
.auxent
.x_scn
.x_scnlen
,
2170 auxp
->u
.auxent
.x_scn
.x_nreloc
,
2171 auxp
->u
.auxent
.x_scn
.x_nlinno
);
2172 if (auxp
->u
.auxent
.x_scn
.x_checksum
!= 0
2173 || auxp
->u
.auxent
.x_scn
.x_associated
!= 0
2174 || auxp
->u
.auxent
.x_scn
.x_comdat
!= 0)
2175 fprintf (file
, " checksum 0x%lx assoc %d comdat %d",
2176 auxp
->u
.auxent
.x_scn
.x_checksum
,
2177 auxp
->u
.auxent
.x_scn
.x_associated
,
2178 auxp
->u
.auxent
.x_scn
.x_comdat
);
2184 if (ISFCN (combined
->u
.syment
.n_type
))
2189 next
= (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2192 next
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2193 llnos
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
2195 "AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld",
2197 (unsigned long) auxp
->u
.auxent
.x_sym
.x_misc
.x_fsize
,
2203 fprintf (file
, "AUX lnno %d size 0x%x tagndx %ld",
2204 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
2205 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
,
2208 fprintf (file
, " endndx %ld",
2210 (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2218 fprintf (file
, "\n%s :", l
->u
.sym
->name
);
2220 while (l
->line_number
)
2222 if (l
->line_number
> 0)
2224 fprintf (file
, "\n%4d : ", l
->line_number
);
2225 bfd_fprintf_vma (abfd
, file
, l
->u
.offset
+ symbol
->section
->vma
);
2233 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
2234 fprintf (file
, " %-5s %s %s %s",
2235 symbol
->section
->name
,
2236 coffsymbol (symbol
)->native
? "n" : "g",
2237 coffsymbol (symbol
)->lineno
? "l" : " ",
2243 /* Return whether a symbol name implies a local symbol. In COFF,
2244 local symbols generally start with ``.L''. Most targets use this
2245 function for the is_local_label_name entry point, but some may
2249 _bfd_coff_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
2252 return name
[0] == '.' && name
[1] == 'L';
2255 /* Provided a BFD, a section and an offset (in bytes, not octets) into the
2256 section, calculate and return the name of the source file and the line
2257 nearest to the wanted location. */
2260 coff_find_nearest_line_with_names (bfd
*abfd
,
2264 const char **filename_ptr
,
2265 const char **functionname_ptr
,
2266 unsigned int *line_ptr
,
2267 const struct dwarf_debug_section
*debug_sections
)
2271 unsigned int line_base
;
2272 coff_data_type
*cof
= coff_data (abfd
);
2273 /* Run through the raw syments if available. */
2274 combined_entry_type
*p
;
2275 combined_entry_type
*pend
;
2277 struct coff_section_tdata
*sec_data
;
2280 /* Before looking through the symbol table, try to use a .stab
2281 section to find the information. */
2282 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2283 &found
, filename_ptr
,
2284 functionname_ptr
, line_ptr
,
2285 &coff_data(abfd
)->line_info
))
2291 /* Also try examining DWARF2 debugging information. */
2292 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
2293 filename_ptr
, functionname_ptr
,
2294 line_ptr
, NULL
, debug_sections
,
2295 &coff_data(abfd
)->dwarf2_find_line_info
))
2298 sec_data
= coff_section_data (abfd
, section
);
2300 /* If the DWARF lookup failed, but there is DWARF information available
2301 then the problem might be that the file has been rebased. This tool
2302 changes the VMAs of all the sections, but it does not update the DWARF
2303 information. So try again, using a bias against the address sought. */
2304 if (coff_data (abfd
)->dwarf2_find_line_info
!= NULL
)
2306 bfd_signed_vma bias
= 0;
2308 /* Create a cache of the result for the next call. */
2309 if (sec_data
== NULL
&& section
->owner
== abfd
)
2311 amt
= sizeof (struct coff_section_tdata
);
2312 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
2313 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2316 if (sec_data
!= NULL
&& sec_data
->saved_bias
)
2317 bias
= sec_data
->saved_bias
;
2320 bias
= _bfd_dwarf2_find_symbol_bias (symbols
,
2321 & coff_data (abfd
)->dwarf2_find_line_info
);
2325 sec_data
->saved_bias
= TRUE
;
2326 sec_data
->bias
= bias
;
2331 && _bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
,
2333 filename_ptr
, functionname_ptr
,
2334 line_ptr
, NULL
, debug_sections
,
2335 &coff_data(abfd
)->dwarf2_find_line_info
))
2340 *functionname_ptr
= 0;
2343 /* Don't try and find line numbers in a non coff file. */
2344 if (!bfd_family_coff (abfd
))
2350 /* Find the first C_FILE symbol. */
2351 p
= cof
->raw_syments
;
2355 pend
= p
+ cof
->raw_syment_count
;
2358 BFD_ASSERT (p
->is_sym
);
2359 if (p
->u
.syment
.n_sclass
== C_FILE
)
2361 p
+= 1 + p
->u
.syment
.n_numaux
;
2369 /* Look through the C_FILE symbols to find the best one. */
2370 sec_vma
= bfd_section_vma (section
);
2371 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2372 maxdiff
= (bfd_vma
) 0 - (bfd_vma
) 1;
2376 combined_entry_type
*p2
;
2378 for (p2
= p
+ 1 + p
->u
.syment
.n_numaux
;
2380 p2
+= 1 + p2
->u
.syment
.n_numaux
)
2382 BFD_ASSERT (p2
->is_sym
);
2383 if (p2
->u
.syment
.n_scnum
> 0
2385 == coff_section_from_bfd_index (abfd
,
2386 p2
->u
.syment
.n_scnum
)))
2388 if (p2
->u
.syment
.n_sclass
== C_FILE
)
2397 file_addr
= (bfd_vma
) p2
->u
.syment
.n_value
;
2398 /* PR 11512: Include the section address of the function name symbol. */
2399 if (p2
->u
.syment
.n_scnum
> 0)
2400 file_addr
+= coff_section_from_bfd_index (abfd
,
2401 p2
->u
.syment
.n_scnum
)->vma
;
2402 /* We use <= MAXDIFF here so that if we get a zero length
2403 file, we actually use the next file entry. */
2405 && offset
+ sec_vma
>= file_addr
2406 && offset
+ sec_vma
- file_addr
<= maxdiff
)
2408 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2409 maxdiff
= offset
+ sec_vma
- p2
->u
.syment
.n_value
;
2412 if (p
->u
.syment
.n_value
>= cof
->raw_syment_count
)
2415 /* Avoid endless loops on erroneous files by ensuring that
2416 we always move forward in the file. */
2417 if (p
>= cof
->raw_syments
+ p
->u
.syment
.n_value
)
2420 p
= cof
->raw_syments
+ p
->u
.syment
.n_value
;
2421 if (!p
->is_sym
|| p
->u
.syment
.n_sclass
!= C_FILE
)
2426 if (section
->lineno_count
== 0)
2428 *functionname_ptr
= NULL
;
2433 /* Now wander though the raw linenumbers of the section.
2434 If we have been called on this section before, and the offset
2435 we want is further down then we can prime the lookup loop. */
2436 if (sec_data
!= NULL
2438 && offset
>= sec_data
->offset
)
2441 *functionname_ptr
= sec_data
->function
;
2442 line_base
= sec_data
->line_base
;
2450 if (section
->lineno
!= NULL
)
2452 bfd_vma last_value
= 0;
2454 l
= §ion
->lineno
[i
];
2456 for (; i
< section
->lineno_count
; i
++)
2458 if (l
->line_number
== 0)
2460 /* Get the symbol this line number points at. */
2461 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
2462 if (coff
->symbol
.value
> offset
)
2465 *functionname_ptr
= coff
->symbol
.name
;
2466 last_value
= coff
->symbol
.value
;
2469 combined_entry_type
*s
= coff
->native
;
2471 BFD_ASSERT (s
->is_sym
);
2472 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2474 /* In XCOFF a debugging symbol can follow the
2476 if (s
->u
.syment
.n_scnum
== N_DEBUG
)
2477 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2479 /* S should now point to the .bf of the function. */
2480 if (s
->u
.syment
.n_numaux
)
2482 /* The linenumber is stored in the auxent. */
2483 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
2485 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
2486 *line_ptr
= line_base
;
2492 if (l
->u
.offset
> offset
)
2494 *line_ptr
= l
->line_number
+ line_base
- 1;
2499 /* If we fell off the end of the loop, then assume that this
2500 symbol has no line number info. Otherwise, symbols with no
2501 line number info get reported with the line number of the
2502 last line of the last symbol which does have line number
2503 info. We use 0x100 as a slop to account for cases where the
2504 last line has executable code. */
2505 if (i
>= section
->lineno_count
2507 && offset
- last_value
> 0x100)
2509 *functionname_ptr
= NULL
;
2514 /* Cache the results for the next call. */
2515 if (sec_data
== NULL
&& section
->owner
== abfd
)
2517 amt
= sizeof (struct coff_section_tdata
);
2518 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
2519 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2522 if (sec_data
!= NULL
)
2524 sec_data
->offset
= offset
;
2525 sec_data
->i
= i
- 1;
2526 sec_data
->function
= *functionname_ptr
;
2527 sec_data
->line_base
= line_base
;
2534 coff_find_nearest_line (bfd
*abfd
,
2538 const char **filename_ptr
,
2539 const char **functionname_ptr
,
2540 unsigned int *line_ptr
,
2541 unsigned int *discriminator_ptr
)
2543 if (discriminator_ptr
)
2544 *discriminator_ptr
= 0;
2545 return coff_find_nearest_line_with_names (abfd
, symbols
, section
, offset
,
2546 filename_ptr
, functionname_ptr
,
2547 line_ptr
, dwarf_debug_sections
);
2551 coff_find_inliner_info (bfd
*abfd
,
2552 const char **filename_ptr
,
2553 const char **functionname_ptr
,
2554 unsigned int *line_ptr
)
2558 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
2559 functionname_ptr
, line_ptr
,
2560 &coff_data(abfd
)->dwarf2_find_line_info
);
2565 coff_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
2569 if (!bfd_link_relocatable (info
))
2570 size
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
2572 size
= bfd_coff_filhsz (abfd
);
2574 size
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
2578 /* Change the class of a coff symbol held by BFD. */
2581 bfd_coff_set_symbol_class (bfd
* abfd
,
2583 unsigned int symbol_class
)
2585 coff_symbol_type
* csym
;
2587 csym
= coff_symbol_from (symbol
);
2590 bfd_set_error (bfd_error_invalid_operation
);
2593 else if (csym
->native
== NULL
)
2595 /* This is an alien symbol which no native coff backend data.
2596 We cheat here by creating a fake native entry for it and
2597 then filling in the class. This code is based on that in
2598 coff_write_alien_symbol(). */
2600 combined_entry_type
* native
;
2601 size_t amt
= sizeof (* native
);
2603 native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
2607 native
->is_sym
= TRUE
;
2608 native
->u
.syment
.n_type
= T_NULL
;
2609 native
->u
.syment
.n_sclass
= symbol_class
;
2611 if (bfd_is_und_section (symbol
->section
))
2613 native
->u
.syment
.n_scnum
= N_UNDEF
;
2614 native
->u
.syment
.n_value
= symbol
->value
;
2616 else if (bfd_is_com_section (symbol
->section
))
2618 native
->u
.syment
.n_scnum
= N_UNDEF
;
2619 native
->u
.syment
.n_value
= symbol
->value
;
2623 native
->u
.syment
.n_scnum
=
2624 symbol
->section
->output_section
->target_index
;
2625 native
->u
.syment
.n_value
= (symbol
->value
2626 + symbol
->section
->output_offset
);
2627 if (! obj_pe (abfd
))
2628 native
->u
.syment
.n_value
+= symbol
->section
->output_section
->vma
;
2630 /* Copy the any flags from the file header into the symbol.
2632 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (& csym
->symbol
)->flags
;
2635 csym
->native
= native
;
2638 csym
->native
->u
.syment
.n_sclass
= symbol_class
;
2644 _bfd_coff_section_already_linked (bfd
*abfd
,
2646 struct bfd_link_info
*info
)
2649 const char *name
, *key
;
2650 struct bfd_section_already_linked
*l
;
2651 struct bfd_section_already_linked_hash_entry
*already_linked_list
;
2652 struct coff_comdat_info
*s_comdat
;
2654 if (sec
->output_section
== bfd_abs_section_ptr
)
2658 if ((flags
& SEC_LINK_ONCE
) == 0)
2661 /* The COFF backend linker doesn't support group sections. */
2662 if ((flags
& SEC_GROUP
) != 0)
2665 name
= bfd_section_name (sec
);
2666 s_comdat
= bfd_coff_get_comdat_section (abfd
, sec
);
2668 if (s_comdat
!= NULL
)
2669 key
= s_comdat
->name
;
2672 if (CONST_STRNEQ (name
, ".gnu.linkonce.")
2673 && (key
= strchr (name
+ sizeof (".gnu.linkonce.") - 1, '.')) != NULL
)
2676 /* FIXME: gcc as of 2011-09 emits sections like .text$<key>,
2677 .xdata$<key> and .pdata$<key> only the first of which has a
2678 comdat key. Should these all match the LTO IR key? */
2682 already_linked_list
= bfd_section_already_linked_table_lookup (key
);
2684 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
2686 struct coff_comdat_info
*l_comdat
;
2688 l_comdat
= bfd_coff_get_comdat_section (l
->sec
->owner
, l
->sec
);
2690 /* The section names must match, and both sections must be
2691 comdat and have the same comdat name, or both sections must
2692 be non-comdat. LTO IR plugin sections are an exception. They
2693 are always named .gnu.linkonce.t.<key> (<key> is some string)
2694 and match any comdat section with comdat name of <key>, and
2695 any linkonce section with the same suffix, ie.
2696 .gnu.linkonce.*.<key>. */
2697 if (((s_comdat
!= NULL
) == (l_comdat
!= NULL
)
2698 && strcmp (name
, l
->sec
->name
) == 0)
2699 || (l
->sec
->owner
->flags
& BFD_PLUGIN
) != 0)
2701 /* The section has already been linked. See if we should
2703 return _bfd_handle_already_linked (sec
, l
, info
);
2707 /* This is the first section with this name. Record it. */
2708 if (!bfd_section_already_linked_table_insert (already_linked_list
, sec
))
2709 info
->callbacks
->einfo (_("%F%P: already_linked_table: %E\n"));
2713 /* Initialize COOKIE for input bfd ABFD. */
2716 init_reloc_cookie (struct coff_reloc_cookie
*cookie
,
2717 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2720 /* Sometimes the symbol table does not yet have been loaded here. */
2721 bfd_coff_slurp_symbol_table (abfd
);
2723 cookie
->abfd
= abfd
;
2724 cookie
->sym_hashes
= obj_coff_sym_hashes (abfd
);
2726 cookie
->symbols
= obj_symbols (abfd
);
2731 /* Free the memory allocated by init_reloc_cookie, if appropriate. */
2734 fini_reloc_cookie (struct coff_reloc_cookie
*cookie ATTRIBUTE_UNUSED
,
2735 bfd
*abfd ATTRIBUTE_UNUSED
)
2737 /* Nothing to do. */
2740 /* Initialize the relocation information in COOKIE for input section SEC
2741 of input bfd ABFD. */
2744 init_reloc_cookie_rels (struct coff_reloc_cookie
*cookie
,
2745 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2749 if (sec
->reloc_count
== 0)
2751 cookie
->rels
= NULL
;
2752 cookie
->relend
= NULL
;
2757 cookie
->rels
= _bfd_coff_read_internal_relocs (abfd
, sec
, FALSE
, NULL
, 0, NULL
);
2759 if (cookie
->rels
== NULL
)
2762 cookie
->rel
= cookie
->rels
;
2763 cookie
->relend
= (cookie
->rels
+ sec
->reloc_count
);
2767 /* Free the memory allocated by init_reloc_cookie_rels,
2771 fini_reloc_cookie_rels (struct coff_reloc_cookie
*cookie
,
2775 /* PR 20401. The relocs may not have been cached, so check first.
2776 If the relocs were loaded by init_reloc_cookie_rels() then this
2777 will be the case. FIXME: Would performance be improved if the
2778 relocs *were* cached ? */
2779 && coff_section_data (NULL
, sec
)
2780 && coff_section_data (NULL
, sec
)->relocs
!= cookie
->rels
)
2781 free (cookie
->rels
);
2784 /* Initialize the whole of COOKIE for input section SEC. */
2787 init_reloc_cookie_for_section (struct coff_reloc_cookie
*cookie
,
2788 struct bfd_link_info
*info
,
2791 if (!init_reloc_cookie (cookie
, info
, sec
->owner
))
2794 if (!init_reloc_cookie_rels (cookie
, info
, sec
->owner
, sec
))
2796 fini_reloc_cookie (cookie
, sec
->owner
);
2802 /* Free the memory allocated by init_reloc_cookie_for_section,
2806 fini_reloc_cookie_for_section (struct coff_reloc_cookie
*cookie
,
2809 fini_reloc_cookie_rels (cookie
, sec
);
2810 fini_reloc_cookie (cookie
, sec
->owner
);
2814 _bfd_coff_gc_mark_hook (asection
*sec
,
2815 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2816 struct internal_reloc
*rel ATTRIBUTE_UNUSED
,
2817 struct coff_link_hash_entry
*h
,
2818 struct internal_syment
*sym
)
2822 switch (h
->root
.type
)
2824 case bfd_link_hash_defined
:
2825 case bfd_link_hash_defweak
:
2826 return h
->root
.u
.def
.section
;
2828 case bfd_link_hash_common
:
2829 return h
->root
.u
.c
.p
->section
;
2831 case bfd_link_hash_undefweak
:
2832 if (h
->symbol_class
== C_NT_WEAK
&& h
->numaux
== 1)
2834 /* PE weak externals. A weak symbol may include an auxiliary
2835 record indicating that if the weak symbol is not resolved,
2836 another external symbol is used instead. */
2837 struct coff_link_hash_entry
*h2
=
2838 h
->auxbfd
->tdata
.coff_obj_data
->sym_hashes
[
2839 h
->aux
->x_sym
.x_tagndx
.l
];
2841 if (h2
&& h2
->root
.type
!= bfd_link_hash_undefined
)
2842 return h2
->root
.u
.def
.section
;
2846 case bfd_link_hash_undefined
:
2853 return coff_section_from_bfd_index (sec
->owner
, sym
->n_scnum
);
2856 /* COOKIE->rel describes a relocation against section SEC, which is
2857 a section we've decided to keep. Return the section that contains
2858 the relocation symbol, or NULL if no section contains it. */
2861 _bfd_coff_gc_mark_rsec (struct bfd_link_info
*info
, asection
*sec
,
2862 coff_gc_mark_hook_fn gc_mark_hook
,
2863 struct coff_reloc_cookie
*cookie
)
2865 struct coff_link_hash_entry
*h
;
2867 h
= cookie
->sym_hashes
[cookie
->rel
->r_symndx
];
2870 while (h
->root
.type
== bfd_link_hash_indirect
2871 || h
->root
.type
== bfd_link_hash_warning
)
2872 h
= (struct coff_link_hash_entry
*) h
->root
.u
.i
.link
;
2874 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, h
, NULL
);
2877 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, NULL
,
2879 + obj_convert (sec
->owner
)[cookie
->rel
->r_symndx
])->native
->u
.syment
);
2882 static bfd_boolean _bfd_coff_gc_mark
2883 (struct bfd_link_info
*, asection
*, coff_gc_mark_hook_fn
);
2885 /* COOKIE->rel describes a relocation against section SEC, which is
2886 a section we've decided to keep. Mark the section that contains
2887 the relocation symbol. */
2890 _bfd_coff_gc_mark_reloc (struct bfd_link_info
*info
,
2892 coff_gc_mark_hook_fn gc_mark_hook
,
2893 struct coff_reloc_cookie
*cookie
)
2897 rsec
= _bfd_coff_gc_mark_rsec (info
, sec
, gc_mark_hook
, cookie
);
2898 if (rsec
&& !rsec
->gc_mark
)
2900 if (bfd_get_flavour (rsec
->owner
) != bfd_target_coff_flavour
)
2902 else if (!_bfd_coff_gc_mark (info
, rsec
, gc_mark_hook
))
2908 /* The mark phase of garbage collection. For a given section, mark
2909 it and any sections in this section's group, and all the sections
2910 which define symbols to which it refers. */
2913 _bfd_coff_gc_mark (struct bfd_link_info
*info
,
2915 coff_gc_mark_hook_fn gc_mark_hook
)
2917 bfd_boolean ret
= TRUE
;
2921 /* Look through the section relocs. */
2922 if ((sec
->flags
& SEC_RELOC
) != 0
2923 && sec
->reloc_count
> 0)
2925 struct coff_reloc_cookie cookie
;
2927 if (!init_reloc_cookie_for_section (&cookie
, info
, sec
))
2931 for (; cookie
.rel
< cookie
.relend
; cookie
.rel
++)
2933 if (!_bfd_coff_gc_mark_reloc (info
, sec
, gc_mark_hook
, &cookie
))
2939 fini_reloc_cookie_for_section (&cookie
, sec
);
2947 _bfd_coff_gc_mark_extra_sections (struct bfd_link_info
*info
,
2948 coff_gc_mark_hook_fn mark_hook ATTRIBUTE_UNUSED
)
2952 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
2955 bfd_boolean some_kept
;
2957 if (bfd_get_flavour (ibfd
) != bfd_target_coff_flavour
)
2960 /* Ensure all linker created sections are kept, and see whether
2961 any other section is already marked. */
2963 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
2965 if ((isec
->flags
& SEC_LINKER_CREATED
) != 0)
2967 else if (isec
->gc_mark
)
2971 /* If no section in this file will be kept, then we can
2972 toss out debug sections. */
2976 /* Keep debug and special sections like .comment when they are
2977 not part of a group, or when we have single-member groups. */
2978 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
2979 if ((isec
->flags
& SEC_DEBUGGING
) != 0
2980 || (isec
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0)
2986 /* Sweep symbols in swept sections. Called via coff_link_hash_traverse. */
2989 coff_gc_sweep_symbol (struct coff_link_hash_entry
*h
,
2990 void *data ATTRIBUTE_UNUSED
)
2992 if (h
->root
.type
== bfd_link_hash_warning
)
2993 h
= (struct coff_link_hash_entry
*) h
->root
.u
.i
.link
;
2995 if ((h
->root
.type
== bfd_link_hash_defined
2996 || h
->root
.type
== bfd_link_hash_defweak
)
2997 && !h
->root
.u
.def
.section
->gc_mark
2998 && !(h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
))
3000 /* Do our best to hide the symbol. */
3001 h
->root
.u
.def
.section
= bfd_und_section_ptr
;
3002 h
->symbol_class
= C_HIDDEN
;
3008 /* The sweep phase of garbage collection. Remove all garbage sections. */
3010 typedef bfd_boolean (*gc_sweep_hook_fn
)
3011 (bfd
*, struct bfd_link_info
*, asection
*, const struct internal_reloc
*);
3014 coff_gc_sweep (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
3018 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3022 if (bfd_get_flavour (sub
) != bfd_target_coff_flavour
)
3025 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3027 /* Keep debug and special sections. */
3028 if ((o
->flags
& (SEC_DEBUGGING
| SEC_LINKER_CREATED
)) != 0
3029 || (o
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0)
3031 else if (CONST_STRNEQ (o
->name
, ".idata")
3032 || CONST_STRNEQ (o
->name
, ".pdata")
3033 || CONST_STRNEQ (o
->name
, ".xdata")
3034 || CONST_STRNEQ (o
->name
, ".rsrc"))
3040 /* Skip sweeping sections already excluded. */
3041 if (o
->flags
& SEC_EXCLUDE
)
3044 /* Since this is early in the link process, it is simple
3045 to remove a section from the output. */
3046 o
->flags
|= SEC_EXCLUDE
;
3048 if (info
->print_gc_sections
&& o
->size
!= 0)
3049 /* xgettext: c-format */
3050 _bfd_error_handler (_("removing unused section '%pA' in file '%pB'"),
3054 /* But we also have to update some of the relocation
3055 info we collected before. */
3057 && (o
->flags
& SEC_RELOC
) != 0
3058 && o
->reloc_count
> 0
3059 && !bfd_is_abs_section (o
->output_section
))
3061 struct internal_reloc
*internal_relocs
;
3065 = _bfd_coff_link_read_relocs (o
->owner
, o
, NULL
, NULL
,
3067 if (internal_relocs
== NULL
)
3070 r
= (*gc_sweep_hook
) (o
->owner
, info
, o
, internal_relocs
);
3072 if (coff_section_data (o
)->relocs
!= internal_relocs
)
3073 free (internal_relocs
);
3082 /* Remove the symbols that were in the swept sections from the dynamic
3084 coff_link_hash_traverse (coff_hash_table (info
), coff_gc_sweep_symbol
,
3090 /* Keep all sections containing symbols undefined on the command-line,
3091 and the section containing the entry symbol. */
3094 _bfd_coff_gc_keep (struct bfd_link_info
*info
)
3096 struct bfd_sym_chain
*sym
;
3098 for (sym
= info
->gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
3100 struct coff_link_hash_entry
*h
;
3102 h
= coff_link_hash_lookup (coff_hash_table (info
), sym
->name
,
3103 FALSE
, FALSE
, FALSE
);
3106 && (h
->root
.type
== bfd_link_hash_defined
3107 || h
->root
.type
== bfd_link_hash_defweak
)
3108 && !bfd_is_abs_section (h
->root
.u
.def
.section
))
3109 h
->root
.u
.def
.section
->flags
|= SEC_KEEP
;
3113 /* Do mark and sweep of unused sections. */
3116 bfd_coff_gc_sections (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
3120 /* FIXME: Should we implement this? */
3122 const bfd_coff_backend_data
*bed
= coff_backend_info (abfd
);
3124 if (!bed
->can_gc_sections
3125 || !is_coff_hash_table (info
->hash
))
3127 _bfd_error_handler(_("warning: gc-sections option ignored"));
3132 _bfd_coff_gc_keep (info
);
3134 /* Grovel through relocs to find out who stays ... */
3135 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3139 if (bfd_get_flavour (sub
) != bfd_target_coff_flavour
)
3142 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3144 if (((o
->flags
& (SEC_EXCLUDE
| SEC_KEEP
)) == SEC_KEEP
3145 || CONST_STRNEQ (o
->name
, ".vectors")
3146 || CONST_STRNEQ (o
->name
, ".ctors")
3147 || CONST_STRNEQ (o
->name
, ".dtors"))
3150 if (!_bfd_coff_gc_mark (info
, o
, _bfd_coff_gc_mark_hook
))
3156 /* Allow the backend to mark additional target specific sections. */
3157 _bfd_coff_gc_mark_extra_sections (info
, _bfd_coff_gc_mark_hook
);
3159 /* ... and mark SEC_EXCLUDE for those that go. */
3160 return coff_gc_sweep (abfd
, info
);
3163 /* Return name used to identify a comdat group. */
3166 bfd_coff_group_name (bfd
*abfd
, const asection
*sec
)
3168 struct coff_comdat_info
*ci
= bfd_coff_get_comdat_section (abfd
, sec
);
3175 _bfd_coff_close_and_cleanup (bfd
*abfd
)
3177 if (abfd
->format
== bfd_object
3178 && bfd_family_coff (abfd
)
3179 && coff_data (abfd
) != NULL
)
3182 Do not clear the keep_syms and keep_strings flags.
3183 These may have been set by pe_ILF_build_a_bfd() indicating
3184 that the syms and strings pointers are not to be freed. */
3185 if (!_bfd_coff_free_symbols (abfd
))
3188 return _bfd_generic_close_and_cleanup (abfd
);