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
)
1647 if (obj_coff_external_syms (abfd
) != NULL
)
1650 /* Check for integer overflow and for unreasonable symbol counts. */
1651 filesize
= bfd_get_file_size (abfd
);
1652 symesz
= bfd_coff_symesz (abfd
);
1653 if (_bfd_mul_overflow (obj_raw_syment_count (abfd
), symesz
, &size
)
1654 || (filesize
!= 0 && size
> filesize
))
1656 bfd_set_error (bfd_error_file_truncated
);
1657 _bfd_error_handler (_("%pB: corrupt symbol count: %#" PRIx64
""),
1658 abfd
, (uint64_t) obj_raw_syment_count (abfd
));
1665 syms
= bfd_malloc (size
);
1668 /* PR 21013: Provide an error message when the alloc fails. */
1669 _bfd_error_handler (_("%pB: not enough memory to allocate space "
1670 "for %#" PRIx64
" symbols of size %#" PRIx64
),
1671 abfd
, (uint64_t) obj_raw_syment_count (abfd
),
1676 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
1677 || bfd_bread (syms
, size
, abfd
) != size
)
1684 obj_coff_external_syms (abfd
) = syms
;
1688 /* Read in the external strings. The strings are not loaded until
1689 they are needed. This is because we have no simple way of
1690 detecting a missing string table in an archive. If the strings
1691 are loaded then the STRINGS and STRINGS_LEN fields in the
1692 coff_tdata structure will be set. */
1695 _bfd_coff_read_string_table (bfd
*abfd
)
1697 char extstrsize
[STRING_SIZE_SIZE
];
1698 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 filesize
= bfd_get_file_size (abfd
);
1736 if (strsize
< STRING_SIZE_SIZE
1737 || (filesize
!= 0 && strsize
> filesize
))
1740 /* xgettext: c-format */
1741 (_("%pB: bad string table size %" PRIu64
), abfd
, (uint64_t) strsize
);
1742 bfd_set_error (bfd_error_bad_value
);
1746 strings
= (char *) bfd_malloc (strsize
+ 1);
1747 if (strings
== NULL
)
1750 /* PR 17521 file: 079-54929-0.004.
1751 A corrupt file could contain an index that points into the first
1752 STRING_SIZE_SIZE bytes of the string table, so make sure that
1754 memset (strings
, 0, STRING_SIZE_SIZE
);
1756 if (bfd_bread (strings
+ STRING_SIZE_SIZE
, strsize
- STRING_SIZE_SIZE
, abfd
)
1757 != strsize
- STRING_SIZE_SIZE
)
1763 obj_coff_strings (abfd
) = strings
;
1764 obj_coff_strings_len (abfd
) = strsize
;
1765 /* Terminate the string table, just in case. */
1766 strings
[strsize
] = 0;
1770 /* Free up the external symbols and strings read from a COFF file. */
1773 _bfd_coff_free_symbols (bfd
*abfd
)
1775 if (! bfd_family_coff (abfd
))
1778 if (obj_coff_external_syms (abfd
) != NULL
1779 && ! obj_coff_keep_syms (abfd
))
1781 free (obj_coff_external_syms (abfd
));
1782 obj_coff_external_syms (abfd
) = NULL
;
1785 if (obj_coff_strings (abfd
) != NULL
1786 && ! obj_coff_keep_strings (abfd
))
1788 free (obj_coff_strings (abfd
));
1789 obj_coff_strings (abfd
) = NULL
;
1790 obj_coff_strings_len (abfd
) = 0;
1796 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
1797 knit the symbol names into a normalized form. By normalized here I
1798 mean that all symbols have an n_offset pointer that points to a null-
1799 terminated string. */
1801 combined_entry_type
*
1802 coff_get_normalized_symtab (bfd
*abfd
)
1804 combined_entry_type
*internal
;
1805 combined_entry_type
*internal_ptr
;
1806 combined_entry_type
*symbol_ptr
;
1807 combined_entry_type
*internal_end
;
1811 const char *string_table
= NULL
;
1812 asection
* debug_sec
= NULL
;
1813 char *debug_sec_data
= NULL
;
1816 if (obj_raw_syments (abfd
) != NULL
)
1817 return obj_raw_syments (abfd
);
1819 if (! _bfd_coff_get_external_symbols (abfd
))
1822 size
= obj_raw_syment_count (abfd
);
1823 /* Check for integer overflow. */
1824 if (size
> (bfd_size_type
) -1 / sizeof (combined_entry_type
))
1826 size
*= sizeof (combined_entry_type
);
1827 internal
= (combined_entry_type
*) bfd_zalloc (abfd
, size
);
1828 if (internal
== NULL
&& size
!= 0)
1830 internal_end
= internal
+ obj_raw_syment_count (abfd
);
1832 raw_src
= (char *) obj_coff_external_syms (abfd
);
1834 /* Mark the end of the symbols. */
1835 symesz
= bfd_coff_symesz (abfd
);
1836 raw_end
= (char *) raw_src
+ obj_raw_syment_count (abfd
) * symesz
;
1838 /* FIXME SOMEDAY. A string table size of zero is very weird, but
1839 probably possible. If one shows up, it will probably kill us. */
1841 /* Swap all the raw entries. */
1842 for (internal_ptr
= internal
;
1844 raw_src
+= symesz
, internal_ptr
++)
1848 bfd_coff_swap_sym_in (abfd
, (void *) raw_src
,
1849 (void *) & internal_ptr
->u
.syment
);
1850 symbol_ptr
= internal_ptr
;
1851 internal_ptr
->is_sym
= TRUE
;
1854 i
< symbol_ptr
->u
.syment
.n_numaux
;
1860 /* PR 17512: Prevent buffer overrun. */
1861 if (raw_src
>= raw_end
|| internal_ptr
>= internal_end
)
1863 bfd_release (abfd
, internal
);
1867 bfd_coff_swap_aux_in (abfd
, (void *) raw_src
,
1868 symbol_ptr
->u
.syment
.n_type
,
1869 symbol_ptr
->u
.syment
.n_sclass
,
1870 (int) i
, symbol_ptr
->u
.syment
.n_numaux
,
1871 &(internal_ptr
->u
.auxent
));
1873 internal_ptr
->is_sym
= FALSE
;
1874 coff_pointerize_aux (abfd
, internal
, symbol_ptr
, i
,
1875 internal_ptr
, internal_end
);
1879 /* Free the raw symbols. */
1880 if (obj_coff_external_syms (abfd
) != NULL
1881 && ! obj_coff_keep_syms (abfd
))
1883 free (obj_coff_external_syms (abfd
));
1884 obj_coff_external_syms (abfd
) = NULL
;
1887 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
1890 BFD_ASSERT (internal_ptr
->is_sym
);
1892 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
1893 && internal_ptr
->u
.syment
.n_numaux
> 0)
1895 combined_entry_type
* aux
= internal_ptr
+ 1;
1897 /* Make a file symbol point to the name in the auxent, since
1898 the text ".file" is redundant. */
1899 BFD_ASSERT (! aux
->is_sym
);
1901 if (aux
->u
.auxent
.x_file
.x_n
.x_zeroes
== 0)
1903 /* The filename is a long one, point into the string table. */
1904 if (string_table
== NULL
)
1906 string_table
= _bfd_coff_read_string_table (abfd
);
1907 if (string_table
== NULL
)
1911 if ((bfd_size_type
)(aux
->u
.auxent
.x_file
.x_n
.x_offset
)
1912 >= obj_coff_strings_len (abfd
))
1913 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1915 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1916 (bfd_hostptr_t
) (string_table
+ (aux
->u
.auxent
.x_file
.x_n
.x_offset
));
1920 /* Ordinary short filename, put into memory anyway. The
1921 Microsoft PE tools sometimes store a filename in
1922 multiple AUX entries. */
1923 if (internal_ptr
->u
.syment
.n_numaux
> 1
1924 && coff_data (abfd
)->pe
)
1925 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1928 aux
->u
.auxent
.x_file
.x_fname
,
1929 internal_ptr
->u
.syment
.n_numaux
* symesz
);
1931 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1934 aux
->u
.auxent
.x_file
.x_fname
,
1935 (size_t) bfd_coff_filnmlen (abfd
)));
1940 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0)
1942 /* This is a "short" name. Make it long. */
1946 /* Find the length of this string without walking into memory
1948 for (i
= 0; i
< 8; ++i
)
1949 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0')
1952 newstring
= (char *) bfd_zalloc (abfd
, (bfd_size_type
) (i
+ 1));
1953 if (newstring
== NULL
)
1955 strncpy (newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
);
1956 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) newstring
;
1957 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1959 else if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
== 0)
1960 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) "";
1961 else if (!bfd_coff_symname_in_debug (abfd
, &internal_ptr
->u
.syment
))
1963 /* Long name already. Point symbol at the string in the
1965 if (string_table
== NULL
)
1967 string_table
= _bfd_coff_read_string_table (abfd
);
1968 if (string_table
== NULL
)
1971 if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
>= obj_coff_strings_len (abfd
)
1972 || string_table
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
< string_table
)
1973 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1975 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1978 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
));
1982 /* Long name in debug section. Very similar. */
1983 if (debug_sec_data
== NULL
)
1984 debug_sec_data
= build_debug_section (abfd
, & debug_sec
);
1985 if (debug_sec_data
!= NULL
)
1987 BFD_ASSERT (debug_sec
!= NULL
);
1988 /* PR binutils/17512: Catch out of range offsets into the debug data. */
1989 if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
> debug_sec
->size
1990 || debug_sec_data
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
< debug_sec_data
)
1991 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1993 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
)
1994 (debug_sec_data
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
1997 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) "";
2000 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
2003 obj_raw_syments (abfd
) = internal
;
2004 BFD_ASSERT (obj_raw_syment_count (abfd
)
2005 == (unsigned int) (internal_ptr
- internal
));
2011 coff_get_reloc_upper_bound (bfd
*abfd
, sec_ptr asect
)
2013 if (bfd_get_format (abfd
) != bfd_object
)
2015 bfd_set_error (bfd_error_invalid_operation
);
2018 #if SIZEOF_LONG == SIZEOF_INT
2019 if (asect
->reloc_count
>= LONG_MAX
/ sizeof (arelent
*))
2021 bfd_set_error (bfd_error_file_too_big
);
2025 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
2029 coff_make_empty_symbol (bfd
*abfd
)
2031 size_t amt
= sizeof (coff_symbol_type
);
2032 coff_symbol_type
*new_symbol
= (coff_symbol_type
*) bfd_zalloc (abfd
, amt
);
2034 if (new_symbol
== NULL
)
2036 new_symbol
->symbol
.section
= 0;
2037 new_symbol
->native
= NULL
;
2038 new_symbol
->lineno
= NULL
;
2039 new_symbol
->done_lineno
= FALSE
;
2040 new_symbol
->symbol
.the_bfd
= abfd
;
2042 return & new_symbol
->symbol
;
2045 /* Make a debugging symbol. */
2048 coff_bfd_make_debug_symbol (bfd
*abfd
,
2049 void * ptr ATTRIBUTE_UNUSED
,
2050 unsigned long sz ATTRIBUTE_UNUSED
)
2052 size_t amt
= sizeof (coff_symbol_type
);
2053 coff_symbol_type
*new_symbol
= (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
2055 if (new_symbol
== NULL
)
2057 /* @@ The 10 is a guess at a plausible maximum number of aux entries
2058 (but shouldn't be a constant). */
2059 amt
= sizeof (combined_entry_type
) * 10;
2060 new_symbol
->native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
2061 if (!new_symbol
->native
)
2063 new_symbol
->native
->is_sym
= TRUE
;
2064 new_symbol
->symbol
.section
= bfd_abs_section_ptr
;
2065 new_symbol
->symbol
.flags
= BSF_DEBUGGING
;
2066 new_symbol
->lineno
= NULL
;
2067 new_symbol
->done_lineno
= FALSE
;
2068 new_symbol
->symbol
.the_bfd
= abfd
;
2070 return & new_symbol
->symbol
;
2074 coff_get_symbol_info (bfd
*abfd
, asymbol
*symbol
, symbol_info
*ret
)
2076 bfd_symbol_info (symbol
, ret
);
2078 if (coffsymbol (symbol
)->native
!= NULL
2079 && coffsymbol (symbol
)->native
->fix_value
2080 && coffsymbol (symbol
)->native
->is_sym
)
2081 ret
->value
= coffsymbol (symbol
)->native
->u
.syment
.n_value
-
2082 (bfd_hostptr_t
) obj_raw_syments (abfd
);
2085 /* Print out information about COFF symbol. */
2088 coff_print_symbol (bfd
*abfd
,
2091 bfd_print_symbol_type how
)
2093 FILE * file
= (FILE *) filep
;
2097 case bfd_print_symbol_name
:
2098 fprintf (file
, "%s", symbol
->name
);
2101 case bfd_print_symbol_more
:
2102 fprintf (file
, "coff %s %s",
2103 coffsymbol (symbol
)->native
? "n" : "g",
2104 coffsymbol (symbol
)->lineno
? "l" : " ");
2107 case bfd_print_symbol_all
:
2108 if (coffsymbol (symbol
)->native
)
2112 combined_entry_type
*combined
= coffsymbol (symbol
)->native
;
2113 combined_entry_type
*root
= obj_raw_syments (abfd
);
2114 struct lineno_cache_entry
*l
= coffsymbol (symbol
)->lineno
;
2116 fprintf (file
, "[%3ld]", (long) (combined
- root
));
2118 /* PR 17512: file: 079-33786-0.001:0.1. */
2119 if (combined
< obj_raw_syments (abfd
)
2120 || combined
>= obj_raw_syments (abfd
) + obj_raw_syment_count (abfd
))
2122 fprintf (file
, _("<corrupt info> %s"), symbol
->name
);
2126 BFD_ASSERT (combined
->is_sym
);
2127 if (! combined
->fix_value
)
2128 val
= (bfd_vma
) combined
->u
.syment
.n_value
;
2130 val
= combined
->u
.syment
.n_value
- (bfd_hostptr_t
) root
;
2132 fprintf (file
, "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x",
2133 combined
->u
.syment
.n_scnum
,
2134 combined
->u
.syment
.n_flags
,
2135 combined
->u
.syment
.n_type
,
2136 combined
->u
.syment
.n_sclass
,
2137 combined
->u
.syment
.n_numaux
);
2138 bfd_fprintf_vma (abfd
, file
, val
);
2139 fprintf (file
, " %s", symbol
->name
);
2141 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
2143 combined_entry_type
*auxp
= combined
+ aux
+ 1;
2146 BFD_ASSERT (! auxp
->is_sym
);
2148 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.p
- root
;
2150 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.l
;
2152 fprintf (file
, "\n");
2154 if (bfd_coff_print_aux (abfd
, file
, root
, combined
, auxp
, aux
))
2157 switch (combined
->u
.syment
.n_sclass
)
2160 fprintf (file
, "File ");
2164 if (combined
->u
.syment
.n_type
== T_NULL
)
2165 /* Probably a section symbol ? */
2167 fprintf (file
, "AUX scnlen 0x%lx nreloc %d nlnno %d",
2168 (unsigned long) auxp
->u
.auxent
.x_scn
.x_scnlen
,
2169 auxp
->u
.auxent
.x_scn
.x_nreloc
,
2170 auxp
->u
.auxent
.x_scn
.x_nlinno
);
2171 if (auxp
->u
.auxent
.x_scn
.x_checksum
!= 0
2172 || auxp
->u
.auxent
.x_scn
.x_associated
!= 0
2173 || auxp
->u
.auxent
.x_scn
.x_comdat
!= 0)
2174 fprintf (file
, " checksum 0x%lx assoc %d comdat %d",
2175 auxp
->u
.auxent
.x_scn
.x_checksum
,
2176 auxp
->u
.auxent
.x_scn
.x_associated
,
2177 auxp
->u
.auxent
.x_scn
.x_comdat
);
2183 if (ISFCN (combined
->u
.syment
.n_type
))
2188 next
= (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2191 next
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2192 llnos
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
2194 "AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld",
2196 (unsigned long) auxp
->u
.auxent
.x_sym
.x_misc
.x_fsize
,
2202 fprintf (file
, "AUX lnno %d size 0x%x tagndx %ld",
2203 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
2204 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
,
2207 fprintf (file
, " endndx %ld",
2209 (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2217 fprintf (file
, "\n%s :", l
->u
.sym
->name
);
2219 while (l
->line_number
)
2221 if (l
->line_number
> 0)
2223 fprintf (file
, "\n%4d : ", l
->line_number
);
2224 bfd_fprintf_vma (abfd
, file
, l
->u
.offset
+ symbol
->section
->vma
);
2232 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
2233 fprintf (file
, " %-5s %s %s %s",
2234 symbol
->section
->name
,
2235 coffsymbol (symbol
)->native
? "n" : "g",
2236 coffsymbol (symbol
)->lineno
? "l" : " ",
2242 /* Return whether a symbol name implies a local symbol. In COFF,
2243 local symbols generally start with ``.L''. Most targets use this
2244 function for the is_local_label_name entry point, but some may
2248 _bfd_coff_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
2251 return name
[0] == '.' && name
[1] == 'L';
2254 /* Provided a BFD, a section and an offset (in bytes, not octets) into the
2255 section, calculate and return the name of the source file and the line
2256 nearest to the wanted location. */
2259 coff_find_nearest_line_with_names (bfd
*abfd
,
2263 const char **filename_ptr
,
2264 const char **functionname_ptr
,
2265 unsigned int *line_ptr
,
2266 const struct dwarf_debug_section
*debug_sections
)
2270 unsigned int line_base
;
2271 coff_data_type
*cof
= coff_data (abfd
);
2272 /* Run through the raw syments if available. */
2273 combined_entry_type
*p
;
2274 combined_entry_type
*pend
;
2276 struct coff_section_tdata
*sec_data
;
2279 /* Before looking through the symbol table, try to use a .stab
2280 section to find the information. */
2281 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2282 &found
, filename_ptr
,
2283 functionname_ptr
, line_ptr
,
2284 &coff_data(abfd
)->line_info
))
2290 /* Also try examining DWARF2 debugging information. */
2291 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
2292 filename_ptr
, functionname_ptr
,
2293 line_ptr
, NULL
, debug_sections
,
2294 &coff_data(abfd
)->dwarf2_find_line_info
))
2297 sec_data
= coff_section_data (abfd
, section
);
2299 /* If the DWARF lookup failed, but there is DWARF information available
2300 then the problem might be that the file has been rebased. This tool
2301 changes the VMAs of all the sections, but it does not update the DWARF
2302 information. So try again, using a bias against the address sought. */
2303 if (coff_data (abfd
)->dwarf2_find_line_info
!= NULL
)
2305 bfd_signed_vma bias
= 0;
2307 /* Create a cache of the result for the next call. */
2308 if (sec_data
== NULL
&& section
->owner
== abfd
)
2310 amt
= sizeof (struct coff_section_tdata
);
2311 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
2312 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2315 if (sec_data
!= NULL
&& sec_data
->saved_bias
)
2316 bias
= sec_data
->saved_bias
;
2319 bias
= _bfd_dwarf2_find_symbol_bias (symbols
,
2320 & coff_data (abfd
)->dwarf2_find_line_info
);
2324 sec_data
->saved_bias
= TRUE
;
2325 sec_data
->bias
= bias
;
2330 && _bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
,
2332 filename_ptr
, functionname_ptr
,
2333 line_ptr
, NULL
, debug_sections
,
2334 &coff_data(abfd
)->dwarf2_find_line_info
))
2339 *functionname_ptr
= 0;
2342 /* Don't try and find line numbers in a non coff file. */
2343 if (!bfd_family_coff (abfd
))
2349 /* Find the first C_FILE symbol. */
2350 p
= cof
->raw_syments
;
2354 pend
= p
+ cof
->raw_syment_count
;
2357 BFD_ASSERT (p
->is_sym
);
2358 if (p
->u
.syment
.n_sclass
== C_FILE
)
2360 p
+= 1 + p
->u
.syment
.n_numaux
;
2368 /* Look through the C_FILE symbols to find the best one. */
2369 sec_vma
= bfd_section_vma (section
);
2370 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2371 maxdiff
= (bfd_vma
) 0 - (bfd_vma
) 1;
2375 combined_entry_type
*p2
;
2377 for (p2
= p
+ 1 + p
->u
.syment
.n_numaux
;
2379 p2
+= 1 + p2
->u
.syment
.n_numaux
)
2381 BFD_ASSERT (p2
->is_sym
);
2382 if (p2
->u
.syment
.n_scnum
> 0
2384 == coff_section_from_bfd_index (abfd
,
2385 p2
->u
.syment
.n_scnum
)))
2387 if (p2
->u
.syment
.n_sclass
== C_FILE
)
2396 file_addr
= (bfd_vma
) p2
->u
.syment
.n_value
;
2397 /* PR 11512: Include the section address of the function name symbol. */
2398 if (p2
->u
.syment
.n_scnum
> 0)
2399 file_addr
+= coff_section_from_bfd_index (abfd
,
2400 p2
->u
.syment
.n_scnum
)->vma
;
2401 /* We use <= MAXDIFF here so that if we get a zero length
2402 file, we actually use the next file entry. */
2404 && offset
+ sec_vma
>= file_addr
2405 && offset
+ sec_vma
- file_addr
<= maxdiff
)
2407 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2408 maxdiff
= offset
+ sec_vma
- p2
->u
.syment
.n_value
;
2411 if (p
->u
.syment
.n_value
>= cof
->raw_syment_count
)
2414 /* Avoid endless loops on erroneous files by ensuring that
2415 we always move forward in the file. */
2416 if (p
>= cof
->raw_syments
+ p
->u
.syment
.n_value
)
2419 p
= cof
->raw_syments
+ p
->u
.syment
.n_value
;
2420 if (!p
->is_sym
|| p
->u
.syment
.n_sclass
!= C_FILE
)
2425 if (section
->lineno_count
== 0)
2427 *functionname_ptr
= NULL
;
2432 /* Now wander though the raw linenumbers of the section.
2433 If we have been called on this section before, and the offset
2434 we want is further down then we can prime the lookup loop. */
2435 if (sec_data
!= NULL
2437 && offset
>= sec_data
->offset
)
2440 *functionname_ptr
= sec_data
->function
;
2441 line_base
= sec_data
->line_base
;
2449 if (section
->lineno
!= NULL
)
2451 bfd_vma last_value
= 0;
2453 l
= §ion
->lineno
[i
];
2455 for (; i
< section
->lineno_count
; i
++)
2457 if (l
->line_number
== 0)
2459 /* Get the symbol this line number points at. */
2460 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
2461 if (coff
->symbol
.value
> offset
)
2464 *functionname_ptr
= coff
->symbol
.name
;
2465 last_value
= coff
->symbol
.value
;
2468 combined_entry_type
*s
= coff
->native
;
2470 BFD_ASSERT (s
->is_sym
);
2471 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2473 /* In XCOFF a debugging symbol can follow the
2475 if (s
->u
.syment
.n_scnum
== N_DEBUG
)
2476 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2478 /* S should now point to the .bf of the function. */
2479 if (s
->u
.syment
.n_numaux
)
2481 /* The linenumber is stored in the auxent. */
2482 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
2484 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
2485 *line_ptr
= line_base
;
2491 if (l
->u
.offset
> offset
)
2493 *line_ptr
= l
->line_number
+ line_base
- 1;
2498 /* If we fell off the end of the loop, then assume that this
2499 symbol has no line number info. Otherwise, symbols with no
2500 line number info get reported with the line number of the
2501 last line of the last symbol which does have line number
2502 info. We use 0x100 as a slop to account for cases where the
2503 last line has executable code. */
2504 if (i
>= section
->lineno_count
2506 && offset
- last_value
> 0x100)
2508 *functionname_ptr
= NULL
;
2513 /* Cache the results for the next call. */
2514 if (sec_data
== NULL
&& section
->owner
== abfd
)
2516 amt
= sizeof (struct coff_section_tdata
);
2517 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
2518 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2521 if (sec_data
!= NULL
)
2523 sec_data
->offset
= offset
;
2524 sec_data
->i
= i
- 1;
2525 sec_data
->function
= *functionname_ptr
;
2526 sec_data
->line_base
= line_base
;
2533 coff_find_nearest_line (bfd
*abfd
,
2537 const char **filename_ptr
,
2538 const char **functionname_ptr
,
2539 unsigned int *line_ptr
,
2540 unsigned int *discriminator_ptr
)
2542 if (discriminator_ptr
)
2543 *discriminator_ptr
= 0;
2544 return coff_find_nearest_line_with_names (abfd
, symbols
, section
, offset
,
2545 filename_ptr
, functionname_ptr
,
2546 line_ptr
, dwarf_debug_sections
);
2550 coff_find_inliner_info (bfd
*abfd
,
2551 const char **filename_ptr
,
2552 const char **functionname_ptr
,
2553 unsigned int *line_ptr
)
2557 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
2558 functionname_ptr
, line_ptr
,
2559 &coff_data(abfd
)->dwarf2_find_line_info
);
2564 coff_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
2568 if (!bfd_link_relocatable (info
))
2569 size
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
2571 size
= bfd_coff_filhsz (abfd
);
2573 size
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
2577 /* Change the class of a coff symbol held by BFD. */
2580 bfd_coff_set_symbol_class (bfd
* abfd
,
2582 unsigned int symbol_class
)
2584 coff_symbol_type
* csym
;
2586 csym
= coff_symbol_from (symbol
);
2589 bfd_set_error (bfd_error_invalid_operation
);
2592 else if (csym
->native
== NULL
)
2594 /* This is an alien symbol which no native coff backend data.
2595 We cheat here by creating a fake native entry for it and
2596 then filling in the class. This code is based on that in
2597 coff_write_alien_symbol(). */
2599 combined_entry_type
* native
;
2600 size_t amt
= sizeof (* native
);
2602 native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
2606 native
->is_sym
= TRUE
;
2607 native
->u
.syment
.n_type
= T_NULL
;
2608 native
->u
.syment
.n_sclass
= symbol_class
;
2610 if (bfd_is_und_section (symbol
->section
))
2612 native
->u
.syment
.n_scnum
= N_UNDEF
;
2613 native
->u
.syment
.n_value
= symbol
->value
;
2615 else if (bfd_is_com_section (symbol
->section
))
2617 native
->u
.syment
.n_scnum
= N_UNDEF
;
2618 native
->u
.syment
.n_value
= symbol
->value
;
2622 native
->u
.syment
.n_scnum
=
2623 symbol
->section
->output_section
->target_index
;
2624 native
->u
.syment
.n_value
= (symbol
->value
2625 + symbol
->section
->output_offset
);
2626 if (! obj_pe (abfd
))
2627 native
->u
.syment
.n_value
+= symbol
->section
->output_section
->vma
;
2629 /* Copy the any flags from the file header into the symbol.
2631 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (& csym
->symbol
)->flags
;
2634 csym
->native
= native
;
2637 csym
->native
->u
.syment
.n_sclass
= symbol_class
;
2643 _bfd_coff_section_already_linked (bfd
*abfd
,
2645 struct bfd_link_info
*info
)
2648 const char *name
, *key
;
2649 struct bfd_section_already_linked
*l
;
2650 struct bfd_section_already_linked_hash_entry
*already_linked_list
;
2651 struct coff_comdat_info
*s_comdat
;
2653 if (sec
->output_section
== bfd_abs_section_ptr
)
2657 if ((flags
& SEC_LINK_ONCE
) == 0)
2660 /* The COFF backend linker doesn't support group sections. */
2661 if ((flags
& SEC_GROUP
) != 0)
2664 name
= bfd_section_name (sec
);
2665 s_comdat
= bfd_coff_get_comdat_section (abfd
, sec
);
2667 if (s_comdat
!= NULL
)
2668 key
= s_comdat
->name
;
2671 if (CONST_STRNEQ (name
, ".gnu.linkonce.")
2672 && (key
= strchr (name
+ sizeof (".gnu.linkonce.") - 1, '.')) != NULL
)
2675 /* FIXME: gcc as of 2011-09 emits sections like .text$<key>,
2676 .xdata$<key> and .pdata$<key> only the first of which has a
2677 comdat key. Should these all match the LTO IR key? */
2681 already_linked_list
= bfd_section_already_linked_table_lookup (key
);
2683 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
2685 struct coff_comdat_info
*l_comdat
;
2687 l_comdat
= bfd_coff_get_comdat_section (l
->sec
->owner
, l
->sec
);
2689 /* The section names must match, and both sections must be
2690 comdat and have the same comdat name, or both sections must
2691 be non-comdat. LTO IR plugin sections are an exception. They
2692 are always named .gnu.linkonce.t.<key> (<key> is some string)
2693 and match any comdat section with comdat name of <key>, and
2694 any linkonce section with the same suffix, ie.
2695 .gnu.linkonce.*.<key>. */
2696 if (((s_comdat
!= NULL
) == (l_comdat
!= NULL
)
2697 && strcmp (name
, l
->sec
->name
) == 0)
2698 || (l
->sec
->owner
->flags
& BFD_PLUGIN
) != 0)
2700 /* The section has already been linked. See if we should
2702 return _bfd_handle_already_linked (sec
, l
, info
);
2706 /* This is the first section with this name. Record it. */
2707 if (!bfd_section_already_linked_table_insert (already_linked_list
, sec
))
2708 info
->callbacks
->einfo (_("%F%P: already_linked_table: %E\n"));
2712 /* Initialize COOKIE for input bfd ABFD. */
2715 init_reloc_cookie (struct coff_reloc_cookie
*cookie
,
2716 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2719 /* Sometimes the symbol table does not yet have been loaded here. */
2720 bfd_coff_slurp_symbol_table (abfd
);
2722 cookie
->abfd
= abfd
;
2723 cookie
->sym_hashes
= obj_coff_sym_hashes (abfd
);
2725 cookie
->symbols
= obj_symbols (abfd
);
2730 /* Free the memory allocated by init_reloc_cookie, if appropriate. */
2733 fini_reloc_cookie (struct coff_reloc_cookie
*cookie ATTRIBUTE_UNUSED
,
2734 bfd
*abfd ATTRIBUTE_UNUSED
)
2736 /* Nothing to do. */
2739 /* Initialize the relocation information in COOKIE for input section SEC
2740 of input bfd ABFD. */
2743 init_reloc_cookie_rels (struct coff_reloc_cookie
*cookie
,
2744 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2748 if (sec
->reloc_count
== 0)
2750 cookie
->rels
= NULL
;
2751 cookie
->relend
= NULL
;
2756 cookie
->rels
= _bfd_coff_read_internal_relocs (abfd
, sec
, FALSE
, NULL
, 0, NULL
);
2758 if (cookie
->rels
== NULL
)
2761 cookie
->rel
= cookie
->rels
;
2762 cookie
->relend
= (cookie
->rels
+ sec
->reloc_count
);
2766 /* Free the memory allocated by init_reloc_cookie_rels,
2770 fini_reloc_cookie_rels (struct coff_reloc_cookie
*cookie
,
2774 /* PR 20401. The relocs may not have been cached, so check first.
2775 If the relocs were loaded by init_reloc_cookie_rels() then this
2776 will be the case. FIXME: Would performance be improved if the
2777 relocs *were* cached ? */
2778 && coff_section_data (NULL
, sec
)
2779 && coff_section_data (NULL
, sec
)->relocs
!= cookie
->rels
)
2780 free (cookie
->rels
);
2783 /* Initialize the whole of COOKIE for input section SEC. */
2786 init_reloc_cookie_for_section (struct coff_reloc_cookie
*cookie
,
2787 struct bfd_link_info
*info
,
2790 if (!init_reloc_cookie (cookie
, info
, sec
->owner
))
2793 if (!init_reloc_cookie_rels (cookie
, info
, sec
->owner
, sec
))
2795 fini_reloc_cookie (cookie
, sec
->owner
);
2801 /* Free the memory allocated by init_reloc_cookie_for_section,
2805 fini_reloc_cookie_for_section (struct coff_reloc_cookie
*cookie
,
2808 fini_reloc_cookie_rels (cookie
, sec
);
2809 fini_reloc_cookie (cookie
, sec
->owner
);
2813 _bfd_coff_gc_mark_hook (asection
*sec
,
2814 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2815 struct internal_reloc
*rel ATTRIBUTE_UNUSED
,
2816 struct coff_link_hash_entry
*h
,
2817 struct internal_syment
*sym
)
2821 switch (h
->root
.type
)
2823 case bfd_link_hash_defined
:
2824 case bfd_link_hash_defweak
:
2825 return h
->root
.u
.def
.section
;
2827 case bfd_link_hash_common
:
2828 return h
->root
.u
.c
.p
->section
;
2830 case bfd_link_hash_undefweak
:
2831 if (h
->symbol_class
== C_NT_WEAK
&& h
->numaux
== 1)
2833 /* PE weak externals. A weak symbol may include an auxiliary
2834 record indicating that if the weak symbol is not resolved,
2835 another external symbol is used instead. */
2836 struct coff_link_hash_entry
*h2
=
2837 h
->auxbfd
->tdata
.coff_obj_data
->sym_hashes
[
2838 h
->aux
->x_sym
.x_tagndx
.l
];
2840 if (h2
&& h2
->root
.type
!= bfd_link_hash_undefined
)
2841 return h2
->root
.u
.def
.section
;
2845 case bfd_link_hash_undefined
:
2852 return coff_section_from_bfd_index (sec
->owner
, sym
->n_scnum
);
2855 /* COOKIE->rel describes a relocation against section SEC, which is
2856 a section we've decided to keep. Return the section that contains
2857 the relocation symbol, or NULL if no section contains it. */
2860 _bfd_coff_gc_mark_rsec (struct bfd_link_info
*info
, asection
*sec
,
2861 coff_gc_mark_hook_fn gc_mark_hook
,
2862 struct coff_reloc_cookie
*cookie
)
2864 struct coff_link_hash_entry
*h
;
2866 h
= cookie
->sym_hashes
[cookie
->rel
->r_symndx
];
2869 while (h
->root
.type
== bfd_link_hash_indirect
2870 || h
->root
.type
== bfd_link_hash_warning
)
2871 h
= (struct coff_link_hash_entry
*) h
->root
.u
.i
.link
;
2873 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, h
, NULL
);
2876 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, NULL
,
2878 + obj_convert (sec
->owner
)[cookie
->rel
->r_symndx
])->native
->u
.syment
);
2881 static bfd_boolean _bfd_coff_gc_mark
2882 (struct bfd_link_info
*, asection
*, coff_gc_mark_hook_fn
);
2884 /* COOKIE->rel describes a relocation against section SEC, which is
2885 a section we've decided to keep. Mark the section that contains
2886 the relocation symbol. */
2889 _bfd_coff_gc_mark_reloc (struct bfd_link_info
*info
,
2891 coff_gc_mark_hook_fn gc_mark_hook
,
2892 struct coff_reloc_cookie
*cookie
)
2896 rsec
= _bfd_coff_gc_mark_rsec (info
, sec
, gc_mark_hook
, cookie
);
2897 if (rsec
&& !rsec
->gc_mark
)
2899 if (bfd_get_flavour (rsec
->owner
) != bfd_target_coff_flavour
)
2901 else if (!_bfd_coff_gc_mark (info
, rsec
, gc_mark_hook
))
2907 /* The mark phase of garbage collection. For a given section, mark
2908 it and any sections in this section's group, and all the sections
2909 which define symbols to which it refers. */
2912 _bfd_coff_gc_mark (struct bfd_link_info
*info
,
2914 coff_gc_mark_hook_fn gc_mark_hook
)
2916 bfd_boolean ret
= TRUE
;
2920 /* Look through the section relocs. */
2921 if ((sec
->flags
& SEC_RELOC
) != 0
2922 && sec
->reloc_count
> 0)
2924 struct coff_reloc_cookie cookie
;
2926 if (!init_reloc_cookie_for_section (&cookie
, info
, sec
))
2930 for (; cookie
.rel
< cookie
.relend
; cookie
.rel
++)
2932 if (!_bfd_coff_gc_mark_reloc (info
, sec
, gc_mark_hook
, &cookie
))
2938 fini_reloc_cookie_for_section (&cookie
, sec
);
2946 _bfd_coff_gc_mark_extra_sections (struct bfd_link_info
*info
,
2947 coff_gc_mark_hook_fn mark_hook ATTRIBUTE_UNUSED
)
2951 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
2954 bfd_boolean some_kept
;
2956 if (bfd_get_flavour (ibfd
) != bfd_target_coff_flavour
)
2959 /* Ensure all linker created sections are kept, and see whether
2960 any other section is already marked. */
2962 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
2964 if ((isec
->flags
& SEC_LINKER_CREATED
) != 0)
2966 else if (isec
->gc_mark
)
2970 /* If no section in this file will be kept, then we can
2971 toss out debug sections. */
2975 /* Keep debug and special sections like .comment when they are
2976 not part of a group, or when we have single-member groups. */
2977 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
2978 if ((isec
->flags
& SEC_DEBUGGING
) != 0
2979 || (isec
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0)
2985 /* Sweep symbols in swept sections. Called via coff_link_hash_traverse. */
2988 coff_gc_sweep_symbol (struct coff_link_hash_entry
*h
,
2989 void *data ATTRIBUTE_UNUSED
)
2991 if (h
->root
.type
== bfd_link_hash_warning
)
2992 h
= (struct coff_link_hash_entry
*) h
->root
.u
.i
.link
;
2994 if ((h
->root
.type
== bfd_link_hash_defined
2995 || h
->root
.type
== bfd_link_hash_defweak
)
2996 && !h
->root
.u
.def
.section
->gc_mark
2997 && !(h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
))
2999 /* Do our best to hide the symbol. */
3000 h
->root
.u
.def
.section
= bfd_und_section_ptr
;
3001 h
->symbol_class
= C_HIDDEN
;
3007 /* The sweep phase of garbage collection. Remove all garbage sections. */
3009 typedef bfd_boolean (*gc_sweep_hook_fn
)
3010 (bfd
*, struct bfd_link_info
*, asection
*, const struct internal_reloc
*);
3013 coff_gc_sweep (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
3017 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3021 if (bfd_get_flavour (sub
) != bfd_target_coff_flavour
)
3024 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3026 /* Keep debug and special sections. */
3027 if ((o
->flags
& (SEC_DEBUGGING
| SEC_LINKER_CREATED
)) != 0
3028 || (o
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0)
3030 else if (CONST_STRNEQ (o
->name
, ".idata")
3031 || CONST_STRNEQ (o
->name
, ".pdata")
3032 || CONST_STRNEQ (o
->name
, ".xdata")
3033 || CONST_STRNEQ (o
->name
, ".rsrc"))
3039 /* Skip sweeping sections already excluded. */
3040 if (o
->flags
& SEC_EXCLUDE
)
3043 /* Since this is early in the link process, it is simple
3044 to remove a section from the output. */
3045 o
->flags
|= SEC_EXCLUDE
;
3047 if (info
->print_gc_sections
&& o
->size
!= 0)
3048 /* xgettext: c-format */
3049 _bfd_error_handler (_("removing unused section '%pA' in file '%pB'"),
3053 /* But we also have to update some of the relocation
3054 info we collected before. */
3056 && (o
->flags
& SEC_RELOC
) != 0
3057 && o
->reloc_count
> 0
3058 && !bfd_is_abs_section (o
->output_section
))
3060 struct internal_reloc
*internal_relocs
;
3064 = _bfd_coff_link_read_relocs (o
->owner
, o
, NULL
, NULL
,
3066 if (internal_relocs
== NULL
)
3069 r
= (*gc_sweep_hook
) (o
->owner
, info
, o
, internal_relocs
);
3071 if (coff_section_data (o
)->relocs
!= internal_relocs
)
3072 free (internal_relocs
);
3081 /* Remove the symbols that were in the swept sections from the dynamic
3083 coff_link_hash_traverse (coff_hash_table (info
), coff_gc_sweep_symbol
,
3089 /* Keep all sections containing symbols undefined on the command-line,
3090 and the section containing the entry symbol. */
3093 _bfd_coff_gc_keep (struct bfd_link_info
*info
)
3095 struct bfd_sym_chain
*sym
;
3097 for (sym
= info
->gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
3099 struct coff_link_hash_entry
*h
;
3101 h
= coff_link_hash_lookup (coff_hash_table (info
), sym
->name
,
3102 FALSE
, FALSE
, FALSE
);
3105 && (h
->root
.type
== bfd_link_hash_defined
3106 || h
->root
.type
== bfd_link_hash_defweak
)
3107 && !bfd_is_abs_section (h
->root
.u
.def
.section
))
3108 h
->root
.u
.def
.section
->flags
|= SEC_KEEP
;
3112 /* Do mark and sweep of unused sections. */
3115 bfd_coff_gc_sections (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
3119 /* FIXME: Should we implement this? */
3121 const bfd_coff_backend_data
*bed
= coff_backend_info (abfd
);
3123 if (!bed
->can_gc_sections
3124 || !is_coff_hash_table (info
->hash
))
3126 _bfd_error_handler(_("warning: gc-sections option ignored"));
3131 _bfd_coff_gc_keep (info
);
3133 /* Grovel through relocs to find out who stays ... */
3134 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3138 if (bfd_get_flavour (sub
) != bfd_target_coff_flavour
)
3141 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3143 if (((o
->flags
& (SEC_EXCLUDE
| SEC_KEEP
)) == SEC_KEEP
3144 || CONST_STRNEQ (o
->name
, ".vectors")
3145 || CONST_STRNEQ (o
->name
, ".ctors")
3146 || CONST_STRNEQ (o
->name
, ".dtors"))
3149 if (!_bfd_coff_gc_mark (info
, o
, _bfd_coff_gc_mark_hook
))
3155 /* Allow the backend to mark additional target specific sections. */
3156 _bfd_coff_gc_mark_extra_sections (info
, _bfd_coff_gc_mark_hook
);
3158 /* ... and mark SEC_EXCLUDE for those that go. */
3159 return coff_gc_sweep (abfd
, info
);
3162 /* Return name used to identify a comdat group. */
3165 bfd_coff_group_name (bfd
*abfd
, const asection
*sec
)
3167 struct coff_comdat_info
*ci
= bfd_coff_get_comdat_section (abfd
, sec
);
3174 _bfd_coff_close_and_cleanup (bfd
*abfd
)
3176 if (abfd
->format
== bfd_object
3177 && bfd_family_coff (abfd
)
3178 && coff_data (abfd
) != NULL
)
3181 Do not clear the keep_syms and keep_strings flags.
3182 These may have been set by pe_ILF_build_a_bfd() indicating
3183 that the syms and strings pointers are not to be freed. */
3184 if (!_bfd_coff_free_symbols (abfd
))
3187 return _bfd_generic_close_and_cleanup (abfd
);