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
;
1646 if (obj_coff_external_syms (abfd
) != NULL
)
1649 symesz
= bfd_coff_symesz (abfd
);
1651 size
= obj_raw_syment_count (abfd
) * symesz
;
1654 /* Check for integer overflow and for unreasonable symbol counts. */
1655 if (size
< obj_raw_syment_count (abfd
)
1656 || (bfd_get_file_size (abfd
) > 0
1657 && size
> bfd_get_file_size (abfd
)))
1660 _bfd_error_handler (_("%pB: corrupt symbol count: %#" PRIx64
""),
1661 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
;
1702 if (obj_coff_strings (abfd
) != NULL
)
1703 return obj_coff_strings (abfd
);
1705 if (obj_sym_filepos (abfd
) == 0)
1707 bfd_set_error (bfd_error_no_symbols
);
1711 pos
= obj_sym_filepos (abfd
);
1712 pos
+= obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
1713 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
1716 if (bfd_bread (extstrsize
, (bfd_size_type
) sizeof extstrsize
, abfd
)
1717 != sizeof extstrsize
)
1719 if (bfd_get_error () != bfd_error_file_truncated
)
1722 /* There is no string table. */
1723 strsize
= STRING_SIZE_SIZE
;
1727 #if STRING_SIZE_SIZE == 4
1728 strsize
= H_GET_32 (abfd
, extstrsize
);
1730 #error Change H_GET_32
1734 if (strsize
< STRING_SIZE_SIZE
|| strsize
> bfd_get_file_size (abfd
))
1737 /* xgettext: c-format */
1738 (_("%pB: bad string table size %" PRIu64
), abfd
, (uint64_t) strsize
);
1739 bfd_set_error (bfd_error_bad_value
);
1743 strings
= (char *) bfd_malloc (strsize
+ 1);
1744 if (strings
== NULL
)
1747 /* PR 17521 file: 079-54929-0.004.
1748 A corrupt file could contain an index that points into the first
1749 STRING_SIZE_SIZE bytes of the string table, so make sure that
1751 memset (strings
, 0, STRING_SIZE_SIZE
);
1753 if (bfd_bread (strings
+ STRING_SIZE_SIZE
, strsize
- STRING_SIZE_SIZE
, abfd
)
1754 != strsize
- STRING_SIZE_SIZE
)
1760 obj_coff_strings (abfd
) = strings
;
1761 obj_coff_strings_len (abfd
) = strsize
;
1762 /* Terminate the string table, just in case. */
1763 strings
[strsize
] = 0;
1767 /* Free up the external symbols and strings read from a COFF file. */
1770 _bfd_coff_free_symbols (bfd
*abfd
)
1772 if (! bfd_family_coff (abfd
))
1775 if (obj_coff_external_syms (abfd
) != NULL
1776 && ! obj_coff_keep_syms (abfd
))
1778 free (obj_coff_external_syms (abfd
));
1779 obj_coff_external_syms (abfd
) = NULL
;
1782 if (obj_coff_strings (abfd
) != NULL
1783 && ! obj_coff_keep_strings (abfd
))
1785 free (obj_coff_strings (abfd
));
1786 obj_coff_strings (abfd
) = NULL
;
1787 obj_coff_strings_len (abfd
) = 0;
1793 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
1794 knit the symbol names into a normalized form. By normalized here I
1795 mean that all symbols have an n_offset pointer that points to a null-
1796 terminated string. */
1798 combined_entry_type
*
1799 coff_get_normalized_symtab (bfd
*abfd
)
1801 combined_entry_type
*internal
;
1802 combined_entry_type
*internal_ptr
;
1803 combined_entry_type
*symbol_ptr
;
1804 combined_entry_type
*internal_end
;
1808 const char *string_table
= NULL
;
1809 asection
* debug_sec
= NULL
;
1810 char *debug_sec_data
= NULL
;
1813 if (obj_raw_syments (abfd
) != NULL
)
1814 return obj_raw_syments (abfd
);
1816 if (! _bfd_coff_get_external_symbols (abfd
))
1819 size
= obj_raw_syment_count (abfd
);
1820 /* Check for integer overflow. */
1821 if (size
> (bfd_size_type
) -1 / sizeof (combined_entry_type
))
1823 size
*= sizeof (combined_entry_type
);
1824 internal
= (combined_entry_type
*) bfd_zalloc (abfd
, size
);
1825 if (internal
== NULL
&& size
!= 0)
1827 internal_end
= internal
+ obj_raw_syment_count (abfd
);
1829 raw_src
= (char *) obj_coff_external_syms (abfd
);
1831 /* Mark the end of the symbols. */
1832 symesz
= bfd_coff_symesz (abfd
);
1833 raw_end
= (char *) raw_src
+ obj_raw_syment_count (abfd
) * symesz
;
1835 /* FIXME SOMEDAY. A string table size of zero is very weird, but
1836 probably possible. If one shows up, it will probably kill us. */
1838 /* Swap all the raw entries. */
1839 for (internal_ptr
= internal
;
1841 raw_src
+= symesz
, internal_ptr
++)
1845 bfd_coff_swap_sym_in (abfd
, (void *) raw_src
,
1846 (void *) & internal_ptr
->u
.syment
);
1847 symbol_ptr
= internal_ptr
;
1848 internal_ptr
->is_sym
= TRUE
;
1851 i
< symbol_ptr
->u
.syment
.n_numaux
;
1857 /* PR 17512: Prevent buffer overrun. */
1858 if (raw_src
>= raw_end
|| internal_ptr
>= internal_end
)
1860 bfd_release (abfd
, internal
);
1864 bfd_coff_swap_aux_in (abfd
, (void *) raw_src
,
1865 symbol_ptr
->u
.syment
.n_type
,
1866 symbol_ptr
->u
.syment
.n_sclass
,
1867 (int) i
, symbol_ptr
->u
.syment
.n_numaux
,
1868 &(internal_ptr
->u
.auxent
));
1870 internal_ptr
->is_sym
= FALSE
;
1871 coff_pointerize_aux (abfd
, internal
, symbol_ptr
, i
,
1872 internal_ptr
, internal_end
);
1876 /* Free the raw symbols. */
1877 if (obj_coff_external_syms (abfd
) != NULL
1878 && ! obj_coff_keep_syms (abfd
))
1880 free (obj_coff_external_syms (abfd
));
1881 obj_coff_external_syms (abfd
) = NULL
;
1884 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
1887 BFD_ASSERT (internal_ptr
->is_sym
);
1889 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
1890 && internal_ptr
->u
.syment
.n_numaux
> 0)
1892 combined_entry_type
* aux
= internal_ptr
+ 1;
1894 /* Make a file symbol point to the name in the auxent, since
1895 the text ".file" is redundant. */
1896 BFD_ASSERT (! aux
->is_sym
);
1898 if (aux
->u
.auxent
.x_file
.x_n
.x_zeroes
== 0)
1900 /* The filename is a long one, point into the string table. */
1901 if (string_table
== NULL
)
1903 string_table
= _bfd_coff_read_string_table (abfd
);
1904 if (string_table
== NULL
)
1908 if ((bfd_size_type
)(aux
->u
.auxent
.x_file
.x_n
.x_offset
)
1909 >= obj_coff_strings_len (abfd
))
1910 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1912 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1913 (bfd_hostptr_t
) (string_table
+ (aux
->u
.auxent
.x_file
.x_n
.x_offset
));
1917 /* Ordinary short filename, put into memory anyway. The
1918 Microsoft PE tools sometimes store a filename in
1919 multiple AUX entries. */
1920 if (internal_ptr
->u
.syment
.n_numaux
> 1
1921 && coff_data (abfd
)->pe
)
1922 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1925 aux
->u
.auxent
.x_file
.x_fname
,
1926 internal_ptr
->u
.syment
.n_numaux
* symesz
);
1928 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1931 aux
->u
.auxent
.x_file
.x_fname
,
1932 (size_t) bfd_coff_filnmlen (abfd
)));
1937 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0)
1939 /* This is a "short" name. Make it long. */
1943 /* Find the length of this string without walking into memory
1945 for (i
= 0; i
< 8; ++i
)
1946 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0')
1949 newstring
= (char *) bfd_zalloc (abfd
, (bfd_size_type
) (i
+ 1));
1950 if (newstring
== NULL
)
1952 strncpy (newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
);
1953 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) newstring
;
1954 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1956 else if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
== 0)
1957 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) "";
1958 else if (!bfd_coff_symname_in_debug (abfd
, &internal_ptr
->u
.syment
))
1960 /* Long name already. Point symbol at the string in the
1962 if (string_table
== NULL
)
1964 string_table
= _bfd_coff_read_string_table (abfd
);
1965 if (string_table
== NULL
)
1968 if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
>= obj_coff_strings_len (abfd
)
1969 || string_table
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
< string_table
)
1970 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1972 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1975 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
));
1979 /* Long name in debug section. Very similar. */
1980 if (debug_sec_data
== NULL
)
1981 debug_sec_data
= build_debug_section (abfd
, & debug_sec
);
1982 if (debug_sec_data
!= NULL
)
1984 BFD_ASSERT (debug_sec
!= NULL
);
1985 /* PR binutils/17512: Catch out of range offsets into the debug data. */
1986 if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
> debug_sec
->size
1987 || debug_sec_data
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
< debug_sec_data
)
1988 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1990 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
)
1991 (debug_sec_data
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
1994 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) "";
1997 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
2000 obj_raw_syments (abfd
) = internal
;
2001 BFD_ASSERT (obj_raw_syment_count (abfd
)
2002 == (unsigned int) (internal_ptr
- internal
));
2008 coff_get_reloc_upper_bound (bfd
*abfd
, sec_ptr asect
)
2010 if (bfd_get_format (abfd
) != bfd_object
)
2012 bfd_set_error (bfd_error_invalid_operation
);
2015 #if SIZEOF_LONG == SIZEOF_INT
2016 if (asect
->reloc_count
>= LONG_MAX
/ sizeof (arelent
*))
2018 bfd_set_error (bfd_error_file_too_big
);
2022 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
2026 coff_make_empty_symbol (bfd
*abfd
)
2028 size_t amt
= sizeof (coff_symbol_type
);
2029 coff_symbol_type
*new_symbol
= (coff_symbol_type
*) bfd_zalloc (abfd
, amt
);
2031 if (new_symbol
== NULL
)
2033 new_symbol
->symbol
.section
= 0;
2034 new_symbol
->native
= NULL
;
2035 new_symbol
->lineno
= NULL
;
2036 new_symbol
->done_lineno
= FALSE
;
2037 new_symbol
->symbol
.the_bfd
= abfd
;
2039 return & new_symbol
->symbol
;
2042 /* Make a debugging symbol. */
2045 coff_bfd_make_debug_symbol (bfd
*abfd
,
2046 void * ptr ATTRIBUTE_UNUSED
,
2047 unsigned long sz ATTRIBUTE_UNUSED
)
2049 size_t amt
= sizeof (coff_symbol_type
);
2050 coff_symbol_type
*new_symbol
= (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
2052 if (new_symbol
== NULL
)
2054 /* @@ The 10 is a guess at a plausible maximum number of aux entries
2055 (but shouldn't be a constant). */
2056 amt
= sizeof (combined_entry_type
) * 10;
2057 new_symbol
->native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
2058 if (!new_symbol
->native
)
2060 new_symbol
->native
->is_sym
= TRUE
;
2061 new_symbol
->symbol
.section
= bfd_abs_section_ptr
;
2062 new_symbol
->symbol
.flags
= BSF_DEBUGGING
;
2063 new_symbol
->lineno
= NULL
;
2064 new_symbol
->done_lineno
= FALSE
;
2065 new_symbol
->symbol
.the_bfd
= abfd
;
2067 return & new_symbol
->symbol
;
2071 coff_get_symbol_info (bfd
*abfd
, asymbol
*symbol
, symbol_info
*ret
)
2073 bfd_symbol_info (symbol
, ret
);
2075 if (coffsymbol (symbol
)->native
!= NULL
2076 && coffsymbol (symbol
)->native
->fix_value
2077 && coffsymbol (symbol
)->native
->is_sym
)
2078 ret
->value
= coffsymbol (symbol
)->native
->u
.syment
.n_value
-
2079 (bfd_hostptr_t
) obj_raw_syments (abfd
);
2082 /* Print out information about COFF symbol. */
2085 coff_print_symbol (bfd
*abfd
,
2088 bfd_print_symbol_type how
)
2090 FILE * file
= (FILE *) filep
;
2094 case bfd_print_symbol_name
:
2095 fprintf (file
, "%s", symbol
->name
);
2098 case bfd_print_symbol_more
:
2099 fprintf (file
, "coff %s %s",
2100 coffsymbol (symbol
)->native
? "n" : "g",
2101 coffsymbol (symbol
)->lineno
? "l" : " ");
2104 case bfd_print_symbol_all
:
2105 if (coffsymbol (symbol
)->native
)
2109 combined_entry_type
*combined
= coffsymbol (symbol
)->native
;
2110 combined_entry_type
*root
= obj_raw_syments (abfd
);
2111 struct lineno_cache_entry
*l
= coffsymbol (symbol
)->lineno
;
2113 fprintf (file
, "[%3ld]", (long) (combined
- root
));
2115 /* PR 17512: file: 079-33786-0.001:0.1. */
2116 if (combined
< obj_raw_syments (abfd
)
2117 || combined
>= obj_raw_syments (abfd
) + obj_raw_syment_count (abfd
))
2119 fprintf (file
, _("<corrupt info> %s"), symbol
->name
);
2123 BFD_ASSERT (combined
->is_sym
);
2124 if (! combined
->fix_value
)
2125 val
= (bfd_vma
) combined
->u
.syment
.n_value
;
2127 val
= combined
->u
.syment
.n_value
- (bfd_hostptr_t
) root
;
2129 fprintf (file
, "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x",
2130 combined
->u
.syment
.n_scnum
,
2131 combined
->u
.syment
.n_flags
,
2132 combined
->u
.syment
.n_type
,
2133 combined
->u
.syment
.n_sclass
,
2134 combined
->u
.syment
.n_numaux
);
2135 bfd_fprintf_vma (abfd
, file
, val
);
2136 fprintf (file
, " %s", symbol
->name
);
2138 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
2140 combined_entry_type
*auxp
= combined
+ aux
+ 1;
2143 BFD_ASSERT (! auxp
->is_sym
);
2145 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.p
- root
;
2147 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.l
;
2149 fprintf (file
, "\n");
2151 if (bfd_coff_print_aux (abfd
, file
, root
, combined
, auxp
, aux
))
2154 switch (combined
->u
.syment
.n_sclass
)
2157 fprintf (file
, "File ");
2161 if (combined
->u
.syment
.n_type
== T_NULL
)
2162 /* Probably a section symbol ? */
2164 fprintf (file
, "AUX scnlen 0x%lx nreloc %d nlnno %d",
2165 (unsigned long) auxp
->u
.auxent
.x_scn
.x_scnlen
,
2166 auxp
->u
.auxent
.x_scn
.x_nreloc
,
2167 auxp
->u
.auxent
.x_scn
.x_nlinno
);
2168 if (auxp
->u
.auxent
.x_scn
.x_checksum
!= 0
2169 || auxp
->u
.auxent
.x_scn
.x_associated
!= 0
2170 || auxp
->u
.auxent
.x_scn
.x_comdat
!= 0)
2171 fprintf (file
, " checksum 0x%lx assoc %d comdat %d",
2172 auxp
->u
.auxent
.x_scn
.x_checksum
,
2173 auxp
->u
.auxent
.x_scn
.x_associated
,
2174 auxp
->u
.auxent
.x_scn
.x_comdat
);
2180 if (ISFCN (combined
->u
.syment
.n_type
))
2185 next
= (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2188 next
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2189 llnos
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
2191 "AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld",
2193 (unsigned long) auxp
->u
.auxent
.x_sym
.x_misc
.x_fsize
,
2199 fprintf (file
, "AUX lnno %d size 0x%x tagndx %ld",
2200 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
2201 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
,
2204 fprintf (file
, " endndx %ld",
2206 (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2214 fprintf (file
, "\n%s :", l
->u
.sym
->name
);
2216 while (l
->line_number
)
2218 if (l
->line_number
> 0)
2220 fprintf (file
, "\n%4d : ", l
->line_number
);
2221 bfd_fprintf_vma (abfd
, file
, l
->u
.offset
+ symbol
->section
->vma
);
2229 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
2230 fprintf (file
, " %-5s %s %s %s",
2231 symbol
->section
->name
,
2232 coffsymbol (symbol
)->native
? "n" : "g",
2233 coffsymbol (symbol
)->lineno
? "l" : " ",
2239 /* Return whether a symbol name implies a local symbol. In COFF,
2240 local symbols generally start with ``.L''. Most targets use this
2241 function for the is_local_label_name entry point, but some may
2245 _bfd_coff_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
2248 return name
[0] == '.' && name
[1] == 'L';
2251 /* Provided a BFD, a section and an offset (in bytes, not octets) into the
2252 section, calculate and return the name of the source file and the line
2253 nearest to the wanted location. */
2256 coff_find_nearest_line_with_names (bfd
*abfd
,
2260 const char **filename_ptr
,
2261 const char **functionname_ptr
,
2262 unsigned int *line_ptr
,
2263 const struct dwarf_debug_section
*debug_sections
)
2267 unsigned int line_base
;
2268 coff_data_type
*cof
= coff_data (abfd
);
2269 /* Run through the raw syments if available. */
2270 combined_entry_type
*p
;
2271 combined_entry_type
*pend
;
2273 struct coff_section_tdata
*sec_data
;
2276 /* Before looking through the symbol table, try to use a .stab
2277 section to find the information. */
2278 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2279 &found
, filename_ptr
,
2280 functionname_ptr
, line_ptr
,
2281 &coff_data(abfd
)->line_info
))
2287 /* Also try examining DWARF2 debugging information. */
2288 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
2289 filename_ptr
, functionname_ptr
,
2290 line_ptr
, NULL
, debug_sections
,
2291 &coff_data(abfd
)->dwarf2_find_line_info
))
2294 sec_data
= coff_section_data (abfd
, section
);
2296 /* If the DWARF lookup failed, but there is DWARF information available
2297 then the problem might be that the file has been rebased. This tool
2298 changes the VMAs of all the sections, but it does not update the DWARF
2299 information. So try again, using a bias against the address sought. */
2300 if (coff_data (abfd
)->dwarf2_find_line_info
!= NULL
)
2302 bfd_signed_vma bias
= 0;
2304 /* Create a cache of the result for the next call. */
2305 if (sec_data
== NULL
&& section
->owner
== abfd
)
2307 amt
= sizeof (struct coff_section_tdata
);
2308 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
2309 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2312 if (sec_data
!= NULL
&& sec_data
->saved_bias
)
2313 bias
= sec_data
->saved_bias
;
2316 bias
= _bfd_dwarf2_find_symbol_bias (symbols
,
2317 & coff_data (abfd
)->dwarf2_find_line_info
);
2321 sec_data
->saved_bias
= TRUE
;
2322 sec_data
->bias
= bias
;
2327 && _bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
,
2329 filename_ptr
, functionname_ptr
,
2330 line_ptr
, NULL
, debug_sections
,
2331 &coff_data(abfd
)->dwarf2_find_line_info
))
2336 *functionname_ptr
= 0;
2339 /* Don't try and find line numbers in a non coff file. */
2340 if (!bfd_family_coff (abfd
))
2346 /* Find the first C_FILE symbol. */
2347 p
= cof
->raw_syments
;
2351 pend
= p
+ cof
->raw_syment_count
;
2354 BFD_ASSERT (p
->is_sym
);
2355 if (p
->u
.syment
.n_sclass
== C_FILE
)
2357 p
+= 1 + p
->u
.syment
.n_numaux
;
2365 /* Look through the C_FILE symbols to find the best one. */
2366 sec_vma
= bfd_section_vma (section
);
2367 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2368 maxdiff
= (bfd_vma
) 0 - (bfd_vma
) 1;
2372 combined_entry_type
*p2
;
2374 for (p2
= p
+ 1 + p
->u
.syment
.n_numaux
;
2376 p2
+= 1 + p2
->u
.syment
.n_numaux
)
2378 BFD_ASSERT (p2
->is_sym
);
2379 if (p2
->u
.syment
.n_scnum
> 0
2381 == coff_section_from_bfd_index (abfd
,
2382 p2
->u
.syment
.n_scnum
)))
2384 if (p2
->u
.syment
.n_sclass
== C_FILE
)
2393 file_addr
= (bfd_vma
) p2
->u
.syment
.n_value
;
2394 /* PR 11512: Include the section address of the function name symbol. */
2395 if (p2
->u
.syment
.n_scnum
> 0)
2396 file_addr
+= coff_section_from_bfd_index (abfd
,
2397 p2
->u
.syment
.n_scnum
)->vma
;
2398 /* We use <= MAXDIFF here so that if we get a zero length
2399 file, we actually use the next file entry. */
2401 && offset
+ sec_vma
>= file_addr
2402 && offset
+ sec_vma
- file_addr
<= maxdiff
)
2404 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2405 maxdiff
= offset
+ sec_vma
- p2
->u
.syment
.n_value
;
2408 if (p
->u
.syment
.n_value
>= cof
->raw_syment_count
)
2411 /* Avoid endless loops on erroneous files by ensuring that
2412 we always move forward in the file. */
2413 if (p
>= cof
->raw_syments
+ p
->u
.syment
.n_value
)
2416 p
= cof
->raw_syments
+ p
->u
.syment
.n_value
;
2417 if (!p
->is_sym
|| p
->u
.syment
.n_sclass
!= C_FILE
)
2422 if (section
->lineno_count
== 0)
2424 *functionname_ptr
= NULL
;
2429 /* Now wander though the raw linenumbers of the section.
2430 If we have been called on this section before, and the offset
2431 we want is further down then we can prime the lookup loop. */
2432 if (sec_data
!= NULL
2434 && offset
>= sec_data
->offset
)
2437 *functionname_ptr
= sec_data
->function
;
2438 line_base
= sec_data
->line_base
;
2446 if (section
->lineno
!= NULL
)
2448 bfd_vma last_value
= 0;
2450 l
= §ion
->lineno
[i
];
2452 for (; i
< section
->lineno_count
; i
++)
2454 if (l
->line_number
== 0)
2456 /* Get the symbol this line number points at. */
2457 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
2458 if (coff
->symbol
.value
> offset
)
2461 *functionname_ptr
= coff
->symbol
.name
;
2462 last_value
= coff
->symbol
.value
;
2465 combined_entry_type
*s
= coff
->native
;
2467 BFD_ASSERT (s
->is_sym
);
2468 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2470 /* In XCOFF a debugging symbol can follow the
2472 if (s
->u
.syment
.n_scnum
== N_DEBUG
)
2473 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2475 /* S should now point to the .bf of the function. */
2476 if (s
->u
.syment
.n_numaux
)
2478 /* The linenumber is stored in the auxent. */
2479 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
2481 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
2482 *line_ptr
= line_base
;
2488 if (l
->u
.offset
> offset
)
2490 *line_ptr
= l
->line_number
+ line_base
- 1;
2495 /* If we fell off the end of the loop, then assume that this
2496 symbol has no line number info. Otherwise, symbols with no
2497 line number info get reported with the line number of the
2498 last line of the last symbol which does have line number
2499 info. We use 0x100 as a slop to account for cases where the
2500 last line has executable code. */
2501 if (i
>= section
->lineno_count
2503 && offset
- last_value
> 0x100)
2505 *functionname_ptr
= NULL
;
2510 /* Cache the results for the next call. */
2511 if (sec_data
== NULL
&& section
->owner
== abfd
)
2513 amt
= sizeof (struct coff_section_tdata
);
2514 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
2515 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2518 if (sec_data
!= NULL
)
2520 sec_data
->offset
= offset
;
2521 sec_data
->i
= i
- 1;
2522 sec_data
->function
= *functionname_ptr
;
2523 sec_data
->line_base
= line_base
;
2530 coff_find_nearest_line (bfd
*abfd
,
2534 const char **filename_ptr
,
2535 const char **functionname_ptr
,
2536 unsigned int *line_ptr
,
2537 unsigned int *discriminator_ptr
)
2539 if (discriminator_ptr
)
2540 *discriminator_ptr
= 0;
2541 return coff_find_nearest_line_with_names (abfd
, symbols
, section
, offset
,
2542 filename_ptr
, functionname_ptr
,
2543 line_ptr
, dwarf_debug_sections
);
2547 coff_find_inliner_info (bfd
*abfd
,
2548 const char **filename_ptr
,
2549 const char **functionname_ptr
,
2550 unsigned int *line_ptr
)
2554 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
2555 functionname_ptr
, line_ptr
,
2556 &coff_data(abfd
)->dwarf2_find_line_info
);
2561 coff_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
2565 if (!bfd_link_relocatable (info
))
2566 size
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
2568 size
= bfd_coff_filhsz (abfd
);
2570 size
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
2574 /* Change the class of a coff symbol held by BFD. */
2577 bfd_coff_set_symbol_class (bfd
* abfd
,
2579 unsigned int symbol_class
)
2581 coff_symbol_type
* csym
;
2583 csym
= coff_symbol_from (symbol
);
2586 bfd_set_error (bfd_error_invalid_operation
);
2589 else if (csym
->native
== NULL
)
2591 /* This is an alien symbol which no native coff backend data.
2592 We cheat here by creating a fake native entry for it and
2593 then filling in the class. This code is based on that in
2594 coff_write_alien_symbol(). */
2596 combined_entry_type
* native
;
2597 size_t amt
= sizeof (* native
);
2599 native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
2603 native
->is_sym
= TRUE
;
2604 native
->u
.syment
.n_type
= T_NULL
;
2605 native
->u
.syment
.n_sclass
= symbol_class
;
2607 if (bfd_is_und_section (symbol
->section
))
2609 native
->u
.syment
.n_scnum
= N_UNDEF
;
2610 native
->u
.syment
.n_value
= symbol
->value
;
2612 else if (bfd_is_com_section (symbol
->section
))
2614 native
->u
.syment
.n_scnum
= N_UNDEF
;
2615 native
->u
.syment
.n_value
= symbol
->value
;
2619 native
->u
.syment
.n_scnum
=
2620 symbol
->section
->output_section
->target_index
;
2621 native
->u
.syment
.n_value
= (symbol
->value
2622 + symbol
->section
->output_offset
);
2623 if (! obj_pe (abfd
))
2624 native
->u
.syment
.n_value
+= symbol
->section
->output_section
->vma
;
2626 /* Copy the any flags from the file header into the symbol.
2628 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (& csym
->symbol
)->flags
;
2631 csym
->native
= native
;
2634 csym
->native
->u
.syment
.n_sclass
= symbol_class
;
2640 _bfd_coff_section_already_linked (bfd
*abfd
,
2642 struct bfd_link_info
*info
)
2645 const char *name
, *key
;
2646 struct bfd_section_already_linked
*l
;
2647 struct bfd_section_already_linked_hash_entry
*already_linked_list
;
2648 struct coff_comdat_info
*s_comdat
;
2650 if (sec
->output_section
== bfd_abs_section_ptr
)
2654 if ((flags
& SEC_LINK_ONCE
) == 0)
2657 /* The COFF backend linker doesn't support group sections. */
2658 if ((flags
& SEC_GROUP
) != 0)
2661 name
= bfd_section_name (sec
);
2662 s_comdat
= bfd_coff_get_comdat_section (abfd
, sec
);
2664 if (s_comdat
!= NULL
)
2665 key
= s_comdat
->name
;
2668 if (CONST_STRNEQ (name
, ".gnu.linkonce.")
2669 && (key
= strchr (name
+ sizeof (".gnu.linkonce.") - 1, '.')) != NULL
)
2672 /* FIXME: gcc as of 2011-09 emits sections like .text$<key>,
2673 .xdata$<key> and .pdata$<key> only the first of which has a
2674 comdat key. Should these all match the LTO IR key? */
2678 already_linked_list
= bfd_section_already_linked_table_lookup (key
);
2680 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
2682 struct coff_comdat_info
*l_comdat
;
2684 l_comdat
= bfd_coff_get_comdat_section (l
->sec
->owner
, l
->sec
);
2686 /* The section names must match, and both sections must be
2687 comdat and have the same comdat name, or both sections must
2688 be non-comdat. LTO IR plugin sections are an exception. They
2689 are always named .gnu.linkonce.t.<key> (<key> is some string)
2690 and match any comdat section with comdat name of <key>, and
2691 any linkonce section with the same suffix, ie.
2692 .gnu.linkonce.*.<key>. */
2693 if (((s_comdat
!= NULL
) == (l_comdat
!= NULL
)
2694 && strcmp (name
, l
->sec
->name
) == 0)
2695 || (l
->sec
->owner
->flags
& BFD_PLUGIN
) != 0)
2697 /* The section has already been linked. See if we should
2699 return _bfd_handle_already_linked (sec
, l
, info
);
2703 /* This is the first section with this name. Record it. */
2704 if (!bfd_section_already_linked_table_insert (already_linked_list
, sec
))
2705 info
->callbacks
->einfo (_("%F%P: already_linked_table: %E\n"));
2709 /* Initialize COOKIE for input bfd ABFD. */
2712 init_reloc_cookie (struct coff_reloc_cookie
*cookie
,
2713 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2716 /* Sometimes the symbol table does not yet have been loaded here. */
2717 bfd_coff_slurp_symbol_table (abfd
);
2719 cookie
->abfd
= abfd
;
2720 cookie
->sym_hashes
= obj_coff_sym_hashes (abfd
);
2722 cookie
->symbols
= obj_symbols (abfd
);
2727 /* Free the memory allocated by init_reloc_cookie, if appropriate. */
2730 fini_reloc_cookie (struct coff_reloc_cookie
*cookie ATTRIBUTE_UNUSED
,
2731 bfd
*abfd ATTRIBUTE_UNUSED
)
2733 /* Nothing to do. */
2736 /* Initialize the relocation information in COOKIE for input section SEC
2737 of input bfd ABFD. */
2740 init_reloc_cookie_rels (struct coff_reloc_cookie
*cookie
,
2741 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2745 if (sec
->reloc_count
== 0)
2747 cookie
->rels
= NULL
;
2748 cookie
->relend
= NULL
;
2753 cookie
->rels
= _bfd_coff_read_internal_relocs (abfd
, sec
, FALSE
, NULL
, 0, NULL
);
2755 if (cookie
->rels
== NULL
)
2758 cookie
->rel
= cookie
->rels
;
2759 cookie
->relend
= (cookie
->rels
+ sec
->reloc_count
);
2763 /* Free the memory allocated by init_reloc_cookie_rels,
2767 fini_reloc_cookie_rels (struct coff_reloc_cookie
*cookie
,
2771 /* PR 20401. The relocs may not have been cached, so check first.
2772 If the relocs were loaded by init_reloc_cookie_rels() then this
2773 will be the case. FIXME: Would performance be improved if the
2774 relocs *were* cached ? */
2775 && coff_section_data (NULL
, sec
)
2776 && coff_section_data (NULL
, sec
)->relocs
!= cookie
->rels
)
2777 free (cookie
->rels
);
2780 /* Initialize the whole of COOKIE for input section SEC. */
2783 init_reloc_cookie_for_section (struct coff_reloc_cookie
*cookie
,
2784 struct bfd_link_info
*info
,
2787 if (!init_reloc_cookie (cookie
, info
, sec
->owner
))
2790 if (!init_reloc_cookie_rels (cookie
, info
, sec
->owner
, sec
))
2792 fini_reloc_cookie (cookie
, sec
->owner
);
2798 /* Free the memory allocated by init_reloc_cookie_for_section,
2802 fini_reloc_cookie_for_section (struct coff_reloc_cookie
*cookie
,
2805 fini_reloc_cookie_rels (cookie
, sec
);
2806 fini_reloc_cookie (cookie
, sec
->owner
);
2810 _bfd_coff_gc_mark_hook (asection
*sec
,
2811 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2812 struct internal_reloc
*rel ATTRIBUTE_UNUSED
,
2813 struct coff_link_hash_entry
*h
,
2814 struct internal_syment
*sym
)
2818 switch (h
->root
.type
)
2820 case bfd_link_hash_defined
:
2821 case bfd_link_hash_defweak
:
2822 return h
->root
.u
.def
.section
;
2824 case bfd_link_hash_common
:
2825 return h
->root
.u
.c
.p
->section
;
2827 case bfd_link_hash_undefweak
:
2828 if (h
->symbol_class
== C_NT_WEAK
&& h
->numaux
== 1)
2830 /* PE weak externals. A weak symbol may include an auxiliary
2831 record indicating that if the weak symbol is not resolved,
2832 another external symbol is used instead. */
2833 struct coff_link_hash_entry
*h2
=
2834 h
->auxbfd
->tdata
.coff_obj_data
->sym_hashes
[
2835 h
->aux
->x_sym
.x_tagndx
.l
];
2837 if (h2
&& h2
->root
.type
!= bfd_link_hash_undefined
)
2838 return h2
->root
.u
.def
.section
;
2842 case bfd_link_hash_undefined
:
2849 return coff_section_from_bfd_index (sec
->owner
, sym
->n_scnum
);
2852 /* COOKIE->rel describes a relocation against section SEC, which is
2853 a section we've decided to keep. Return the section that contains
2854 the relocation symbol, or NULL if no section contains it. */
2857 _bfd_coff_gc_mark_rsec (struct bfd_link_info
*info
, asection
*sec
,
2858 coff_gc_mark_hook_fn gc_mark_hook
,
2859 struct coff_reloc_cookie
*cookie
)
2861 struct coff_link_hash_entry
*h
;
2863 h
= cookie
->sym_hashes
[cookie
->rel
->r_symndx
];
2866 while (h
->root
.type
== bfd_link_hash_indirect
2867 || h
->root
.type
== bfd_link_hash_warning
)
2868 h
= (struct coff_link_hash_entry
*) h
->root
.u
.i
.link
;
2870 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, h
, NULL
);
2873 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, NULL
,
2875 + obj_convert (sec
->owner
)[cookie
->rel
->r_symndx
])->native
->u
.syment
);
2878 static bfd_boolean _bfd_coff_gc_mark
2879 (struct bfd_link_info
*, asection
*, coff_gc_mark_hook_fn
);
2881 /* COOKIE->rel describes a relocation against section SEC, which is
2882 a section we've decided to keep. Mark the section that contains
2883 the relocation symbol. */
2886 _bfd_coff_gc_mark_reloc (struct bfd_link_info
*info
,
2888 coff_gc_mark_hook_fn gc_mark_hook
,
2889 struct coff_reloc_cookie
*cookie
)
2893 rsec
= _bfd_coff_gc_mark_rsec (info
, sec
, gc_mark_hook
, cookie
);
2894 if (rsec
&& !rsec
->gc_mark
)
2896 if (bfd_get_flavour (rsec
->owner
) != bfd_target_coff_flavour
)
2898 else if (!_bfd_coff_gc_mark (info
, rsec
, gc_mark_hook
))
2904 /* The mark phase of garbage collection. For a given section, mark
2905 it and any sections in this section's group, and all the sections
2906 which define symbols to which it refers. */
2909 _bfd_coff_gc_mark (struct bfd_link_info
*info
,
2911 coff_gc_mark_hook_fn gc_mark_hook
)
2913 bfd_boolean ret
= TRUE
;
2917 /* Look through the section relocs. */
2918 if ((sec
->flags
& SEC_RELOC
) != 0
2919 && sec
->reloc_count
> 0)
2921 struct coff_reloc_cookie cookie
;
2923 if (!init_reloc_cookie_for_section (&cookie
, info
, sec
))
2927 for (; cookie
.rel
< cookie
.relend
; cookie
.rel
++)
2929 if (!_bfd_coff_gc_mark_reloc (info
, sec
, gc_mark_hook
, &cookie
))
2935 fini_reloc_cookie_for_section (&cookie
, sec
);
2943 _bfd_coff_gc_mark_extra_sections (struct bfd_link_info
*info
,
2944 coff_gc_mark_hook_fn mark_hook ATTRIBUTE_UNUSED
)
2948 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
2951 bfd_boolean some_kept
;
2953 if (bfd_get_flavour (ibfd
) != bfd_target_coff_flavour
)
2956 /* Ensure all linker created sections are kept, and see whether
2957 any other section is already marked. */
2959 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
2961 if ((isec
->flags
& SEC_LINKER_CREATED
) != 0)
2963 else if (isec
->gc_mark
)
2967 /* If no section in this file will be kept, then we can
2968 toss out debug sections. */
2972 /* Keep debug and special sections like .comment when they are
2973 not part of a group, or when we have single-member groups. */
2974 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
2975 if ((isec
->flags
& SEC_DEBUGGING
) != 0
2976 || (isec
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0)
2982 /* Sweep symbols in swept sections. Called via coff_link_hash_traverse. */
2985 coff_gc_sweep_symbol (struct coff_link_hash_entry
*h
,
2986 void *data ATTRIBUTE_UNUSED
)
2988 if (h
->root
.type
== bfd_link_hash_warning
)
2989 h
= (struct coff_link_hash_entry
*) h
->root
.u
.i
.link
;
2991 if ((h
->root
.type
== bfd_link_hash_defined
2992 || h
->root
.type
== bfd_link_hash_defweak
)
2993 && !h
->root
.u
.def
.section
->gc_mark
2994 && !(h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
))
2996 /* Do our best to hide the symbol. */
2997 h
->root
.u
.def
.section
= bfd_und_section_ptr
;
2998 h
->symbol_class
= C_HIDDEN
;
3004 /* The sweep phase of garbage collection. Remove all garbage sections. */
3006 typedef bfd_boolean (*gc_sweep_hook_fn
)
3007 (bfd
*, struct bfd_link_info
*, asection
*, const struct internal_reloc
*);
3010 coff_gc_sweep (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
3014 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3018 if (bfd_get_flavour (sub
) != bfd_target_coff_flavour
)
3021 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3023 /* Keep debug and special sections. */
3024 if ((o
->flags
& (SEC_DEBUGGING
| SEC_LINKER_CREATED
)) != 0
3025 || (o
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0)
3027 else if (CONST_STRNEQ (o
->name
, ".idata")
3028 || CONST_STRNEQ (o
->name
, ".pdata")
3029 || CONST_STRNEQ (o
->name
, ".xdata")
3030 || CONST_STRNEQ (o
->name
, ".rsrc"))
3036 /* Skip sweeping sections already excluded. */
3037 if (o
->flags
& SEC_EXCLUDE
)
3040 /* Since this is early in the link process, it is simple
3041 to remove a section from the output. */
3042 o
->flags
|= SEC_EXCLUDE
;
3044 if (info
->print_gc_sections
&& o
->size
!= 0)
3045 /* xgettext: c-format */
3046 _bfd_error_handler (_("removing unused section '%pA' in file '%pB'"),
3050 /* But we also have to update some of the relocation
3051 info we collected before. */
3053 && (o
->flags
& SEC_RELOC
) != 0
3054 && o
->reloc_count
> 0
3055 && !bfd_is_abs_section (o
->output_section
))
3057 struct internal_reloc
*internal_relocs
;
3061 = _bfd_coff_link_read_relocs (o
->owner
, o
, NULL
, NULL
,
3063 if (internal_relocs
== NULL
)
3066 r
= (*gc_sweep_hook
) (o
->owner
, info
, o
, internal_relocs
);
3068 if (coff_section_data (o
)->relocs
!= internal_relocs
)
3069 free (internal_relocs
);
3078 /* Remove the symbols that were in the swept sections from the dynamic
3080 coff_link_hash_traverse (coff_hash_table (info
), coff_gc_sweep_symbol
,
3086 /* Keep all sections containing symbols undefined on the command-line,
3087 and the section containing the entry symbol. */
3090 _bfd_coff_gc_keep (struct bfd_link_info
*info
)
3092 struct bfd_sym_chain
*sym
;
3094 for (sym
= info
->gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
3096 struct coff_link_hash_entry
*h
;
3098 h
= coff_link_hash_lookup (coff_hash_table (info
), sym
->name
,
3099 FALSE
, FALSE
, FALSE
);
3102 && (h
->root
.type
== bfd_link_hash_defined
3103 || h
->root
.type
== bfd_link_hash_defweak
)
3104 && !bfd_is_abs_section (h
->root
.u
.def
.section
))
3105 h
->root
.u
.def
.section
->flags
|= SEC_KEEP
;
3109 /* Do mark and sweep of unused sections. */
3112 bfd_coff_gc_sections (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
3116 /* FIXME: Should we implement this? */
3118 const bfd_coff_backend_data
*bed
= coff_backend_info (abfd
);
3120 if (!bed
->can_gc_sections
3121 || !is_coff_hash_table (info
->hash
))
3123 _bfd_error_handler(_("warning: gc-sections option ignored"));
3128 _bfd_coff_gc_keep (info
);
3130 /* Grovel through relocs to find out who stays ... */
3131 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3135 if (bfd_get_flavour (sub
) != bfd_target_coff_flavour
)
3138 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3140 if (((o
->flags
& (SEC_EXCLUDE
| SEC_KEEP
)) == SEC_KEEP
3141 || CONST_STRNEQ (o
->name
, ".vectors")
3142 || CONST_STRNEQ (o
->name
, ".ctors")
3143 || CONST_STRNEQ (o
->name
, ".dtors"))
3146 if (!_bfd_coff_gc_mark (info
, o
, _bfd_coff_gc_mark_hook
))
3152 /* Allow the backend to mark additional target specific sections. */
3153 _bfd_coff_gc_mark_extra_sections (info
, _bfd_coff_gc_mark_hook
);
3155 /* ... and mark SEC_EXCLUDE for those that go. */
3156 return coff_gc_sweep (abfd
, info
);
3159 /* Return name used to identify a comdat group. */
3162 bfd_coff_group_name (bfd
*abfd
, const asection
*sec
)
3164 struct coff_comdat_info
*ci
= bfd_coff_get_comdat_section (abfd
, sec
);
3171 _bfd_coff_close_and_cleanup (bfd
*abfd
)
3173 if (abfd
->format
== bfd_object
3174 && bfd_family_coff (abfd
)
3175 && coff_data (abfd
) != NULL
)
3178 Do not clear the keep_syms and keep_strings flags.
3179 These may have been set by pe_ILF_build_a_bfd() indicating
3180 that the syms and strings pointers are not to be freed. */
3181 if (!_bfd_coff_free_symbols (abfd
))
3184 return _bfd_generic_close_and_cleanup (abfd
);