1 /* Support for the generic parts of COFF, for BFD.
2 Copyright (C) 1990-2018 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
42 #include "coff/internal.h"
45 /* Take a section header read from a coff file (in HOST byte order),
46 and make a BFD "section" out of it. This is used by ECOFF. */
49 make_a_section_from_file (bfd
*abfd
,
50 struct internal_scnhdr
*hdr
,
51 unsigned int target_index
)
53 asection
*return_section
;
55 bfd_boolean result
= TRUE
;
60 /* Handle long section names as in PE. On reading, we want to
61 accept long names if the format permits them at all, regardless
62 of the current state of the flag that dictates if we would generate
63 them in outputs; this construct checks if that is the case by
64 attempting to set the flag, without changing its state; the call
65 will fail for formats that do not support long names at all. */
66 if (bfd_coff_set_long_section_names (abfd
, bfd_coff_long_section_names (abfd
))
67 && hdr
->s_name
[0] == '/')
74 /* Flag that this BFD uses long names, even though the format might
75 expect them to be off by default. This won't directly affect the
76 format of any output BFD created from this one, but the information
77 can be used to decide what to do. */
78 bfd_coff_set_long_section_names (abfd
, TRUE
);
79 memcpy (buf
, hdr
->s_name
+ 1, SCNNMLEN
- 1);
80 buf
[SCNNMLEN
- 1] = '\0';
81 strindex
= strtol (buf
, &p
, 10);
82 if (*p
== '\0' && strindex
>= 0)
84 strings
= _bfd_coff_read_string_table (abfd
);
87 if ((bfd_size_type
)(strindex
+ 2) >= obj_coff_strings_len (abfd
))
90 name
= (char *) bfd_alloc (abfd
,
91 (bfd_size_type
) strlen (strings
) + 1 + 1);
94 strcpy (name
, strings
);
100 /* Assorted wastage to null-terminate the name, thanks AT&T! */
101 name
= (char *) bfd_alloc (abfd
,
102 (bfd_size_type
) sizeof (hdr
->s_name
) + 1 + 1);
105 strncpy (name
, (char *) &hdr
->s_name
[0], sizeof (hdr
->s_name
));
106 name
[sizeof (hdr
->s_name
)] = 0;
109 return_section
= bfd_make_section_anyway (abfd
, name
);
110 if (return_section
== NULL
)
113 return_section
->vma
= hdr
->s_vaddr
;
114 return_section
->lma
= hdr
->s_paddr
;
115 return_section
->size
= hdr
->s_size
;
116 return_section
->filepos
= hdr
->s_scnptr
;
117 return_section
->rel_filepos
= hdr
->s_relptr
;
118 return_section
->reloc_count
= hdr
->s_nreloc
;
120 bfd_coff_set_alignment_hook (abfd
, return_section
, hdr
);
122 return_section
->line_filepos
= hdr
->s_lnnoptr
;
124 return_section
->lineno_count
= hdr
->s_nlnno
;
125 return_section
->userdata
= NULL
;
126 return_section
->next
= NULL
;
127 return_section
->target_index
= target_index
;
129 if (! bfd_coff_styp_to_sec_flags_hook (abfd
, hdr
, name
, return_section
,
133 return_section
->flags
= flags
;
135 /* At least on i386-coff, the line number count for a shared library
136 section must be ignored. */
137 if ((return_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
138 return_section
->lineno_count
= 0;
140 if (hdr
->s_nreloc
!= 0)
141 return_section
->flags
|= SEC_RELOC
;
142 /* FIXME: should this check 'hdr->s_size > 0'. */
143 if (hdr
->s_scnptr
!= 0)
144 return_section
->flags
|= SEC_HAS_CONTENTS
;
146 /* Compress/decompress DWARF debug sections with names: .debug_* and
147 .zdebug_*, after the section flags is set. */
148 if ((flags
& SEC_DEBUGGING
)
150 && ((name
[1] == 'd' && name
[6] == '_')
151 || (strlen (name
) > 8 && name
[1] == 'z' && name
[7] == '_')))
153 enum { nothing
, compress
, decompress
} action
= nothing
;
154 char *new_name
= NULL
;
156 if (bfd_is_section_compressed (abfd
, return_section
))
158 /* Compressed section. Check if we should decompress. */
159 if ((abfd
->flags
& BFD_DECOMPRESS
))
162 else if (!bfd_is_section_compressed (abfd
, return_section
))
164 /* Normal section. Check if we should compress. */
165 if ((abfd
->flags
& BFD_COMPRESS
) && return_section
->size
!= 0)
174 if (!bfd_init_section_compress_status (abfd
, return_section
))
177 /* xgettext: c-format */
178 (_("%pB: unable to initialize compress status for section %s"),
182 if (return_section
->compress_status
== COMPRESS_SECTION_DONE
)
186 unsigned int len
= strlen (name
);
188 new_name
= bfd_alloc (abfd
, len
+ 2);
189 if (new_name
== NULL
)
193 memcpy (new_name
+ 2, name
+ 1, len
);
198 if (!bfd_init_section_decompress_status (abfd
, return_section
))
201 /* xgettext: c-format */
202 (_("%pB: unable to initialize decompress status for section %s"),
208 unsigned int len
= strlen (name
);
210 new_name
= bfd_alloc (abfd
, len
);
211 if (new_name
== NULL
)
214 memcpy (new_name
+ 1, name
+ 2, len
- 1);
218 if (new_name
!= NULL
)
219 bfd_rename_section (abfd
, return_section
, new_name
);
225 /* Read in a COFF object and make it into a BFD. This is used by
228 coff_real_object_p (bfd
*,
230 struct internal_filehdr
*,
231 struct internal_aouthdr
*);
233 coff_real_object_p (bfd
*abfd
,
235 struct internal_filehdr
*internal_f
,
236 struct internal_aouthdr
*internal_a
)
238 flagword oflags
= abfd
->flags
;
239 bfd_vma ostart
= bfd_get_start_address (abfd
);
242 bfd_size_type readsize
; /* Length of file_info. */
244 char *external_sections
;
246 if (!(internal_f
->f_flags
& F_RELFLG
))
247 abfd
->flags
|= HAS_RELOC
;
248 if ((internal_f
->f_flags
& F_EXEC
))
249 abfd
->flags
|= EXEC_P
;
250 if (!(internal_f
->f_flags
& F_LNNO
))
251 abfd
->flags
|= HAS_LINENO
;
252 if (!(internal_f
->f_flags
& F_LSYMS
))
253 abfd
->flags
|= HAS_LOCALS
;
255 /* FIXME: How can we set D_PAGED correctly? */
256 if ((internal_f
->f_flags
& F_EXEC
) != 0)
257 abfd
->flags
|= D_PAGED
;
259 bfd_get_symcount (abfd
) = internal_f
->f_nsyms
;
260 if (internal_f
->f_nsyms
)
261 abfd
->flags
|= HAS_SYMS
;
263 if (internal_a
!= (struct internal_aouthdr
*) NULL
)
264 bfd_get_start_address (abfd
) = internal_a
->entry
;
266 bfd_get_start_address (abfd
) = 0;
268 /* Set up the tdata area. ECOFF uses its own routine, and overrides
270 tdata_save
= abfd
->tdata
.any
;
271 tdata
= bfd_coff_mkobject_hook (abfd
, (void *) internal_f
, (void *) internal_a
);
275 scnhsz
= bfd_coff_scnhsz (abfd
);
276 readsize
= (bfd_size_type
) nscns
* scnhsz
;
277 external_sections
= (char *) bfd_alloc (abfd
, readsize
);
278 if (!external_sections
)
281 if (bfd_bread ((void *) external_sections
, readsize
, abfd
) != readsize
)
284 /* Set the arch/mach *before* swapping in sections; section header swapping
285 may depend on arch/mach info. */
286 if (! bfd_coff_set_arch_mach_hook (abfd
, (void *) internal_f
))
289 /* Now copy data as required; construct all asections etc. */
293 for (i
= 0; i
< nscns
; i
++)
295 struct internal_scnhdr tmp
;
296 bfd_coff_swap_scnhdr_in (abfd
,
297 (void *) (external_sections
+ i
* scnhsz
),
299 if (! make_a_section_from_file (abfd
, &tmp
, i
+ 1))
307 bfd_release (abfd
, tdata
);
309 abfd
->tdata
.any
= tdata_save
;
310 abfd
->flags
= oflags
;
311 bfd_get_start_address (abfd
) = ostart
;
312 return (const bfd_target
*) NULL
;
315 /* Turn a COFF file into a BFD, but fail with bfd_error_wrong_format if it is
316 not a COFF file. This is also used by ECOFF. */
319 coff_object_p (bfd
*abfd
)
321 bfd_size_type filhsz
;
322 bfd_size_type aoutsz
;
325 struct internal_filehdr internal_f
;
326 struct internal_aouthdr internal_a
;
328 /* Figure out how much to read. */
329 filhsz
= bfd_coff_filhsz (abfd
);
330 aoutsz
= bfd_coff_aoutsz (abfd
);
332 filehdr
= bfd_alloc (abfd
, filhsz
);
335 if (bfd_bread (filehdr
, filhsz
, abfd
) != filhsz
)
337 if (bfd_get_error () != bfd_error_system_call
)
338 bfd_set_error (bfd_error_wrong_format
);
339 bfd_release (abfd
, filehdr
);
342 bfd_coff_swap_filehdr_in (abfd
, filehdr
, &internal_f
);
343 bfd_release (abfd
, filehdr
);
345 /* The XCOFF format has two sizes for the f_opthdr. SMALL_AOUTSZ
346 (less than aoutsz) used in object files and AOUTSZ (equal to
347 aoutsz) in executables. The bfd_coff_swap_aouthdr_in function
348 expects this header to be aoutsz bytes in length, so we use that
349 value in the call to bfd_alloc below. But we must be careful to
350 only read in f_opthdr bytes in the call to bfd_bread. We should
351 also attempt to catch corrupt or non-COFF binaries with a strange
352 value for f_opthdr. */
353 if (! bfd_coff_bad_format_hook (abfd
, &internal_f
)
354 || internal_f
.f_opthdr
> aoutsz
)
356 bfd_set_error (bfd_error_wrong_format
);
359 nscns
= internal_f
.f_nscns
;
361 if (internal_f
.f_opthdr
)
365 opthdr
= bfd_alloc (abfd
, aoutsz
);
368 if (bfd_bread (opthdr
, (bfd_size_type
) internal_f
.f_opthdr
, abfd
)
369 != internal_f
.f_opthdr
)
371 bfd_release (abfd
, opthdr
);
374 /* PR 17512: file: 11056-1136-0.004. */
375 if (internal_f
.f_opthdr
< aoutsz
)
376 memset (((char *) opthdr
) + internal_f
.f_opthdr
, 0, aoutsz
- internal_f
.f_opthdr
);
378 bfd_coff_swap_aouthdr_in (abfd
, opthdr
, (void *) &internal_a
);
379 bfd_release (abfd
, opthdr
);
382 return coff_real_object_p (abfd
, nscns
, &internal_f
,
383 (internal_f
.f_opthdr
!= 0
385 : (struct internal_aouthdr
*) NULL
));
388 /* Get the BFD section from a COFF symbol section number. */
391 coff_section_from_bfd_index (bfd
*abfd
, int section_index
)
393 struct bfd_section
*answer
= abfd
->sections
;
395 if (section_index
== N_ABS
)
396 return bfd_abs_section_ptr
;
397 if (section_index
== N_UNDEF
)
398 return bfd_und_section_ptr
;
399 if (section_index
== N_DEBUG
)
400 return bfd_abs_section_ptr
;
404 if (answer
->target_index
== section_index
)
406 answer
= answer
->next
;
409 /* We should not reach this point, but the SCO 3.2v4 /lib/libc_s.a
410 has a bad symbol table in biglitpow.o. */
411 return bfd_und_section_ptr
;
414 /* Get the upper bound of a COFF symbol table. */
417 coff_get_symtab_upper_bound (bfd
*abfd
)
419 if (!bfd_coff_slurp_symbol_table (abfd
))
422 return (bfd_get_symcount (abfd
) + 1) * (sizeof (coff_symbol_type
*));
425 /* Canonicalize a COFF symbol table. */
428 coff_canonicalize_symtab (bfd
*abfd
, asymbol
**alocation
)
430 unsigned int counter
;
431 coff_symbol_type
*symbase
;
432 coff_symbol_type
**location
= (coff_symbol_type
**) alocation
;
434 if (!bfd_coff_slurp_symbol_table (abfd
))
437 symbase
= obj_symbols (abfd
);
438 counter
= bfd_get_symcount (abfd
);
439 while (counter
-- > 0)
440 *location
++ = symbase
++;
444 return bfd_get_symcount (abfd
);
447 /* Get the name of a symbol. The caller must pass in a buffer of size
451 _bfd_coff_internal_syment_name (bfd
*abfd
,
452 const struct internal_syment
*sym
,
455 /* FIXME: It's not clear this will work correctly if sizeof
457 if (sym
->_n
._n_n
._n_zeroes
!= 0
458 || sym
->_n
._n_n
._n_offset
== 0)
460 memcpy (buf
, sym
->_n
._n_name
, SYMNMLEN
);
461 buf
[SYMNMLEN
] = '\0';
468 BFD_ASSERT (sym
->_n
._n_n
._n_offset
>= STRING_SIZE_SIZE
);
469 strings
= obj_coff_strings (abfd
);
472 strings
= _bfd_coff_read_string_table (abfd
);
476 /* PR 17910: Only check for string overflow if the length has been set.
477 Some DLLs, eg those produced by Visual Studio, may not set the length field. */
478 if (obj_coff_strings_len (abfd
) > 0
479 && sym
->_n
._n_n
._n_offset
>= obj_coff_strings_len (abfd
))
481 return strings
+ sym
->_n
._n_n
._n_offset
;
485 /* Read in and swap the relocs. This returns a buffer holding the
486 relocs for section SEC in file ABFD. If CACHE is TRUE and
487 INTERNAL_RELOCS is NULL, the relocs read in will be saved in case
488 the function is called again. If EXTERNAL_RELOCS is not NULL, it
489 is a buffer large enough to hold the unswapped relocs. If
490 INTERNAL_RELOCS is not NULL, it is a buffer large enough to hold
491 the swapped relocs. If REQUIRE_INTERNAL is TRUE, then the return
492 value must be INTERNAL_RELOCS. The function returns NULL on error. */
494 struct internal_reloc
*
495 _bfd_coff_read_internal_relocs (bfd
*abfd
,
498 bfd_byte
*external_relocs
,
499 bfd_boolean require_internal
,
500 struct internal_reloc
*internal_relocs
)
503 bfd_byte
*free_external
= NULL
;
504 struct internal_reloc
*free_internal
= NULL
;
507 struct internal_reloc
*irel
;
510 if (sec
->reloc_count
== 0)
511 return internal_relocs
; /* Nothing to do. */
513 if (coff_section_data (abfd
, sec
) != NULL
514 && coff_section_data (abfd
, sec
)->relocs
!= NULL
)
516 if (! require_internal
)
517 return coff_section_data (abfd
, sec
)->relocs
;
518 memcpy (internal_relocs
, coff_section_data (abfd
, sec
)->relocs
,
519 sec
->reloc_count
* sizeof (struct internal_reloc
));
520 return internal_relocs
;
523 relsz
= bfd_coff_relsz (abfd
);
525 amt
= sec
->reloc_count
* relsz
;
526 if (external_relocs
== NULL
)
528 free_external
= (bfd_byte
*) bfd_malloc (amt
);
529 if (free_external
== NULL
)
531 external_relocs
= free_external
;
534 if (bfd_seek (abfd
, sec
->rel_filepos
, SEEK_SET
) != 0
535 || bfd_bread (external_relocs
, amt
, abfd
) != amt
)
538 if (internal_relocs
== NULL
)
540 amt
= sec
->reloc_count
;
541 amt
*= sizeof (struct internal_reloc
);
542 free_internal
= (struct internal_reloc
*) bfd_malloc (amt
);
543 if (free_internal
== NULL
)
545 internal_relocs
= free_internal
;
548 /* Swap in the relocs. */
549 erel
= external_relocs
;
550 erel_end
= erel
+ relsz
* sec
->reloc_count
;
551 irel
= internal_relocs
;
552 for (; erel
< erel_end
; erel
+= relsz
, irel
++)
553 bfd_coff_swap_reloc_in (abfd
, (void *) erel
, (void *) irel
);
555 if (free_external
!= NULL
)
557 free (free_external
);
558 free_external
= NULL
;
561 if (cache
&& free_internal
!= NULL
)
563 if (coff_section_data (abfd
, sec
) == NULL
)
565 amt
= sizeof (struct coff_section_tdata
);
566 sec
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
567 if (sec
->used_by_bfd
== NULL
)
569 coff_section_data (abfd
, sec
)->contents
= NULL
;
571 coff_section_data (abfd
, sec
)->relocs
= free_internal
;
574 return internal_relocs
;
577 if (free_external
!= NULL
)
578 free (free_external
);
579 if (free_internal
!= NULL
)
580 free (free_internal
);
584 /* Set lineno_count for the output sections of a COFF file. */
587 coff_count_linenumbers (bfd
*abfd
)
589 unsigned int limit
= bfd_get_symcount (abfd
);
597 /* This may be from the backend linker, in which case the
598 lineno_count in the sections is correct. */
599 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
600 total
+= s
->lineno_count
;
604 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
605 BFD_ASSERT (s
->lineno_count
== 0);
607 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
609 asymbol
*q_maybe
= *p
;
611 if (bfd_family_coff (bfd_asymbol_bfd (q_maybe
)))
613 coff_symbol_type
*q
= coffsymbol (q_maybe
);
615 /* The AIX 4.1 compiler can sometimes generate line numbers
616 attached to debugging symbols. We try to simply ignore
618 if (q
->lineno
!= NULL
619 && q
->symbol
.section
->owner
!= NULL
)
621 /* This symbol has line numbers. Increment the owning
622 section's linenumber count. */
623 alent
*l
= q
->lineno
;
627 asection
* sec
= q
->symbol
.section
->output_section
;
629 /* Do not try to update fields in read-only sections. */
630 if (! bfd_is_const_section (sec
))
631 sec
->lineno_count
++;
636 while (l
->line_number
!= 0);
645 fixup_symbol_value (bfd
*abfd
,
646 coff_symbol_type
*coff_symbol_ptr
,
647 struct internal_syment
*syment
)
649 /* Normalize the symbol flags. */
650 if (coff_symbol_ptr
->symbol
.section
651 && bfd_is_com_section (coff_symbol_ptr
->symbol
.section
))
653 /* A common symbol is undefined with a value. */
654 syment
->n_scnum
= N_UNDEF
;
655 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
657 else if ((coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
) != 0
658 && (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING_RELOC
) == 0)
660 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
662 else if (bfd_is_und_section (coff_symbol_ptr
->symbol
.section
))
664 syment
->n_scnum
= N_UNDEF
;
667 /* FIXME: Do we need to handle the absolute section here? */
670 if (coff_symbol_ptr
->symbol
.section
)
673 coff_symbol_ptr
->symbol
.section
->output_section
->target_index
;
675 syment
->n_value
= (coff_symbol_ptr
->symbol
.value
676 + coff_symbol_ptr
->symbol
.section
->output_offset
);
679 syment
->n_value
+= (syment
->n_sclass
== C_STATLAB
)
680 ? coff_symbol_ptr
->symbol
.section
->output_section
->lma
681 : coff_symbol_ptr
->symbol
.section
->output_section
->vma
;
687 /* This can happen, but I don't know why yet (steve@cygnus.com) */
688 syment
->n_scnum
= N_ABS
;
689 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
694 /* Run through all the symbols in the symbol table and work out what
695 their indexes into the symbol table will be when output.
697 Coff requires that each C_FILE symbol points to the next one in the
698 chain, and that the last one points to the first external symbol. We
702 coff_renumber_symbols (bfd
*bfd_ptr
, int *first_undef
)
704 unsigned int symbol_count
= bfd_get_symcount (bfd_ptr
);
705 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
706 unsigned int native_index
= 0;
707 struct internal_syment
*last_file
= NULL
;
708 unsigned int symbol_index
;
710 /* COFF demands that undefined symbols come after all other symbols.
711 Since we don't need to impose this extra knowledge on all our
712 client programs, deal with that here. Sort the symbol table;
713 just move the undefined symbols to the end, leaving the rest
714 alone. The O'Reilly book says that defined global symbols come
715 at the end before the undefined symbols, so we do that here as
717 /* @@ Do we have some condition we could test for, so we don't always
718 have to do this? I don't think relocatability is quite right, but
719 I'm not certain. [raeburn:19920508.1711EST] */
725 amt
= sizeof (asymbol
*) * ((bfd_size_type
) symbol_count
+ 1);
726 newsyms
= (asymbol
**) bfd_alloc (bfd_ptr
, amt
);
729 bfd_ptr
->outsymbols
= newsyms
;
730 for (i
= 0; i
< symbol_count
; i
++)
731 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) != 0
732 || (!bfd_is_und_section (symbol_ptr_ptr
[i
]->section
)
733 && !bfd_is_com_section (symbol_ptr_ptr
[i
]->section
)
734 && ((symbol_ptr_ptr
[i
]->flags
& BSF_FUNCTION
) != 0
735 || ((symbol_ptr_ptr
[i
]->flags
& (BSF_GLOBAL
| BSF_WEAK
))
737 *newsyms
++ = symbol_ptr_ptr
[i
];
739 for (i
= 0; i
< symbol_count
; i
++)
740 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) == 0
741 && !bfd_is_und_section (symbol_ptr_ptr
[i
]->section
)
742 && (bfd_is_com_section (symbol_ptr_ptr
[i
]->section
)
743 || ((symbol_ptr_ptr
[i
]->flags
& BSF_FUNCTION
) == 0
744 && ((symbol_ptr_ptr
[i
]->flags
& (BSF_GLOBAL
| BSF_WEAK
))
746 *newsyms
++ = symbol_ptr_ptr
[i
];
748 *first_undef
= newsyms
- bfd_ptr
->outsymbols
;
750 for (i
= 0; i
< symbol_count
; i
++)
751 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) == 0
752 && bfd_is_und_section (symbol_ptr_ptr
[i
]->section
))
753 *newsyms
++ = symbol_ptr_ptr
[i
];
754 *newsyms
= (asymbol
*) NULL
;
755 symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
758 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
760 coff_symbol_type
*coff_symbol_ptr
;
762 coff_symbol_ptr
= coff_symbol_from (symbol_ptr_ptr
[symbol_index
]);
763 symbol_ptr_ptr
[symbol_index
]->udata
.i
= symbol_index
;
764 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
)
766 combined_entry_type
*s
= coff_symbol_ptr
->native
;
769 BFD_ASSERT (s
->is_sym
);
770 if (s
->u
.syment
.n_sclass
== C_FILE
)
772 if (last_file
!= NULL
)
773 last_file
->n_value
= native_index
;
774 last_file
= &(s
->u
.syment
);
777 /* Modify the symbol values according to their section and
779 fixup_symbol_value (bfd_ptr
, coff_symbol_ptr
, &(s
->u
.syment
));
781 for (i
= 0; i
< s
->u
.syment
.n_numaux
+ 1; i
++)
782 s
[i
].offset
= native_index
++;
788 obj_conv_table_size (bfd_ptr
) = native_index
;
793 /* Run thorough the symbol table again, and fix it so that all
794 pointers to entries are changed to the entries' index in the output
798 coff_mangle_symbols (bfd
*bfd_ptr
)
800 unsigned int symbol_count
= bfd_get_symcount (bfd_ptr
);
801 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
802 unsigned int symbol_index
;
804 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
806 coff_symbol_type
*coff_symbol_ptr
;
808 coff_symbol_ptr
= coff_symbol_from (symbol_ptr_ptr
[symbol_index
]);
809 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
)
812 combined_entry_type
*s
= coff_symbol_ptr
->native
;
814 BFD_ASSERT (s
->is_sym
);
817 /* FIXME: We should use a union here. */
818 s
->u
.syment
.n_value
=
819 (bfd_hostptr_t
) ((combined_entry_type
*)
820 ((bfd_hostptr_t
) s
->u
.syment
.n_value
))->offset
;
825 /* The value is the offset into the line number entries
826 for the symbol's section. On output, the symbol's
827 section should be N_DEBUG. */
828 s
->u
.syment
.n_value
=
829 (coff_symbol_ptr
->symbol
.section
->output_section
->line_filepos
830 + s
->u
.syment
.n_value
* bfd_coff_linesz (bfd_ptr
));
831 coff_symbol_ptr
->symbol
.section
=
832 coff_section_from_bfd_index (bfd_ptr
, N_DEBUG
);
833 BFD_ASSERT (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
);
835 for (i
= 0; i
< s
->u
.syment
.n_numaux
; i
++)
837 combined_entry_type
*a
= s
+ i
+ 1;
839 BFD_ASSERT (! a
->is_sym
);
842 a
->u
.auxent
.x_sym
.x_tagndx
.l
=
843 a
->u
.auxent
.x_sym
.x_tagndx
.p
->offset
;
848 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
849 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
->offset
;
854 a
->u
.auxent
.x_csect
.x_scnlen
.l
=
855 a
->u
.auxent
.x_csect
.x_scnlen
.p
->offset
;
864 coff_fix_symbol_name (bfd
*abfd
,
866 combined_entry_type
*native
,
867 bfd_size_type
*string_size_p
,
868 asection
**debug_string_section_p
,
869 bfd_size_type
*debug_string_size_p
)
871 unsigned int name_length
;
872 union internal_auxent
*auxent
;
873 char *name
= (char *) (symbol
->name
);
877 /* COFF symbols always have names, so we'll make one up. */
878 symbol
->name
= "strange";
879 name
= (char *) symbol
->name
;
881 name_length
= strlen (name
);
883 BFD_ASSERT (native
->is_sym
);
884 if (native
->u
.syment
.n_sclass
== C_FILE
885 && native
->u
.syment
.n_numaux
> 0)
887 unsigned int filnmlen
;
889 if (bfd_coff_force_symnames_in_strings (abfd
))
891 native
->u
.syment
._n
._n_n
._n_offset
=
892 (*string_size_p
+ STRING_SIZE_SIZE
);
893 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
894 *string_size_p
+= 6; /* strlen(".file") + 1 */
897 strncpy (native
->u
.syment
._n
._n_name
, ".file", SYMNMLEN
);
899 BFD_ASSERT (! (native
+ 1)->is_sym
);
900 auxent
= &(native
+ 1)->u
.auxent
;
902 filnmlen
= bfd_coff_filnmlen (abfd
);
904 if (bfd_coff_long_filenames (abfd
))
906 if (name_length
<= filnmlen
)
907 strncpy (auxent
->x_file
.x_fname
, name
, filnmlen
);
910 auxent
->x_file
.x_n
.x_offset
= *string_size_p
+ STRING_SIZE_SIZE
;
911 auxent
->x_file
.x_n
.x_zeroes
= 0;
912 *string_size_p
+= name_length
+ 1;
917 strncpy (auxent
->x_file
.x_fname
, name
, filnmlen
);
918 if (name_length
> filnmlen
)
919 name
[filnmlen
] = '\0';
924 if (name_length
<= SYMNMLEN
&& !bfd_coff_force_symnames_in_strings (abfd
))
925 /* This name will fit into the symbol neatly. */
926 strncpy (native
->u
.syment
._n
._n_name
, symbol
->name
, SYMNMLEN
);
928 else if (!bfd_coff_symname_in_debug (abfd
, &native
->u
.syment
))
930 native
->u
.syment
._n
._n_n
._n_offset
= (*string_size_p
932 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
933 *string_size_p
+= name_length
+ 1;
939 int prefix_len
= bfd_coff_debug_string_prefix_length (abfd
);
941 /* This name should be written into the .debug section. For
942 some reason each name is preceded by a two byte length
943 and also followed by a null byte. FIXME: We assume that
944 the .debug section has already been created, and that it
946 if (*debug_string_section_p
== (asection
*) NULL
)
947 *debug_string_section_p
= bfd_get_section_by_name (abfd
, ".debug");
948 filepos
= bfd_tell (abfd
);
950 bfd_put_32 (abfd
, (bfd_vma
) (name_length
+ 1), buf
);
952 bfd_put_16 (abfd
, (bfd_vma
) (name_length
+ 1), buf
);
954 if (!bfd_set_section_contents (abfd
,
955 *debug_string_section_p
,
957 (file_ptr
) *debug_string_size_p
,
958 (bfd_size_type
) prefix_len
)
959 || !bfd_set_section_contents (abfd
,
960 *debug_string_section_p
,
961 (void *) symbol
->name
,
962 (file_ptr
) (*debug_string_size_p
964 (bfd_size_type
) name_length
+ 1))
966 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
968 native
->u
.syment
._n
._n_n
._n_offset
=
969 *debug_string_size_p
+ prefix_len
;
970 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
971 *debug_string_size_p
+= name_length
+ 1 + prefix_len
;
976 /* We need to keep track of the symbol index so that when we write out
977 the relocs we can get the index for a symbol. This method is a
980 #define set_index(symbol, idx) ((symbol)->udata.i = (idx))
982 /* Write a symbol out to a COFF file. */
985 coff_write_symbol (bfd
*abfd
,
987 combined_entry_type
*native
,
989 bfd_size_type
*string_size_p
,
990 asection
**debug_string_section_p
,
991 bfd_size_type
*debug_string_size_p
)
993 unsigned int numaux
= native
->u
.syment
.n_numaux
;
994 int type
= native
->u
.syment
.n_type
;
995 int n_sclass
= (int) native
->u
.syment
.n_sclass
;
996 asection
*output_section
= symbol
->section
->output_section
997 ? symbol
->section
->output_section
1000 bfd_size_type symesz
;
1002 BFD_ASSERT (native
->is_sym
);
1004 if (native
->u
.syment
.n_sclass
== C_FILE
)
1005 symbol
->flags
|= BSF_DEBUGGING
;
1007 if (symbol
->flags
& BSF_DEBUGGING
1008 && bfd_is_abs_section (symbol
->section
))
1009 native
->u
.syment
.n_scnum
= N_DEBUG
;
1011 else if (bfd_is_abs_section (symbol
->section
))
1012 native
->u
.syment
.n_scnum
= N_ABS
;
1014 else if (bfd_is_und_section (symbol
->section
))
1015 native
->u
.syment
.n_scnum
= N_UNDEF
;
1018 native
->u
.syment
.n_scnum
=
1019 output_section
->target_index
;
1021 coff_fix_symbol_name (abfd
, symbol
, native
, string_size_p
,
1022 debug_string_section_p
, debug_string_size_p
);
1024 symesz
= bfd_coff_symesz (abfd
);
1025 buf
= bfd_alloc (abfd
, symesz
);
1028 bfd_coff_swap_sym_out (abfd
, &native
->u
.syment
, buf
);
1029 if (bfd_bwrite (buf
, symesz
, abfd
) != symesz
)
1031 bfd_release (abfd
, buf
);
1033 if (native
->u
.syment
.n_numaux
> 0)
1035 bfd_size_type auxesz
;
1038 auxesz
= bfd_coff_auxesz (abfd
);
1039 buf
= bfd_alloc (abfd
, auxesz
);
1042 for (j
= 0; j
< native
->u
.syment
.n_numaux
; j
++)
1044 BFD_ASSERT (! (native
+ j
+ 1)->is_sym
);
1045 bfd_coff_swap_aux_out (abfd
,
1046 &((native
+ j
+ 1)->u
.auxent
),
1047 type
, n_sclass
, (int) j
,
1048 native
->u
.syment
.n_numaux
,
1050 if (bfd_bwrite (buf
, auxesz
, abfd
) != auxesz
)
1053 bfd_release (abfd
, buf
);
1056 /* Store the index for use when we write out the relocs. */
1057 set_index (symbol
, *written
);
1059 *written
+= numaux
+ 1;
1063 /* Write out a symbol to a COFF file that does not come from a COFF
1064 file originally. This symbol may have been created by the linker,
1065 or we may be linking a non COFF file to a COFF file. */
1068 coff_write_alien_symbol (bfd
*abfd
,
1070 struct internal_syment
*isym
,
1071 union internal_auxent
*iaux
,
1073 bfd_size_type
*string_size_p
,
1074 asection
**debug_string_section_p
,
1075 bfd_size_type
*debug_string_size_p
)
1077 combined_entry_type
*native
;
1078 combined_entry_type dummy
[2];
1079 asection
*output_section
= symbol
->section
->output_section
1080 ? symbol
->section
->output_section
1082 struct bfd_link_info
*link_info
= coff_data (abfd
)->link_info
;
1085 if ((!link_info
|| link_info
->strip_discarded
)
1086 && !bfd_is_abs_section (symbol
->section
)
1087 && symbol
->section
->output_section
== bfd_abs_section_ptr
)
1091 memset (isym
, 0, sizeof (*isym
));
1095 native
->is_sym
= TRUE
;
1096 native
[1].is_sym
= FALSE
;
1097 native
->u
.syment
.n_type
= T_NULL
;
1098 native
->u
.syment
.n_flags
= 0;
1099 native
->u
.syment
.n_numaux
= 0;
1100 if (bfd_is_und_section (symbol
->section
))
1102 native
->u
.syment
.n_scnum
= N_UNDEF
;
1103 native
->u
.syment
.n_value
= symbol
->value
;
1105 else if (bfd_is_com_section (symbol
->section
))
1107 native
->u
.syment
.n_scnum
= N_UNDEF
;
1108 native
->u
.syment
.n_value
= symbol
->value
;
1110 else if (symbol
->flags
& BSF_FILE
)
1112 native
->u
.syment
.n_scnum
= N_DEBUG
;
1113 native
->u
.syment
.n_numaux
= 1;
1115 else if (symbol
->flags
& BSF_DEBUGGING
)
1117 /* There isn't much point to writing out a debugging symbol
1118 unless we are prepared to convert it into COFF debugging
1119 format. So, we just ignore them. We must clobber the symbol
1120 name to keep it from being put in the string table. */
1123 memset (isym
, 0, sizeof (*isym
));
1128 native
->u
.syment
.n_scnum
= output_section
->target_index
;
1129 native
->u
.syment
.n_value
= (symbol
->value
1130 + symbol
->section
->output_offset
);
1131 if (! obj_pe (abfd
))
1132 native
->u
.syment
.n_value
+= output_section
->vma
;
1134 /* Copy the any flags from the file header into the symbol.
1137 coff_symbol_type
*c
= coff_symbol_from (symbol
);
1138 if (c
!= (coff_symbol_type
*) NULL
)
1139 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (&c
->symbol
)->flags
;
1143 native
->u
.syment
.n_type
= 0;
1144 if (symbol
->flags
& BSF_FILE
)
1145 native
->u
.syment
.n_sclass
= C_FILE
;
1146 else if (symbol
->flags
& BSF_LOCAL
)
1147 native
->u
.syment
.n_sclass
= C_STAT
;
1148 else if (symbol
->flags
& BSF_WEAK
)
1149 native
->u
.syment
.n_sclass
= obj_pe (abfd
) ? C_NT_WEAK
: C_WEAKEXT
;
1151 native
->u
.syment
.n_sclass
= C_EXT
;
1153 ret
= coff_write_symbol (abfd
, symbol
, native
, written
, string_size_p
,
1154 debug_string_section_p
, debug_string_size_p
);
1156 *isym
= native
->u
.syment
;
1157 if (iaux
!= NULL
&& native
->u
.syment
.n_numaux
)
1158 *iaux
= native
[1].u
.auxent
;
1162 /* Write a native symbol to a COFF file. */
1165 coff_write_native_symbol (bfd
*abfd
,
1166 coff_symbol_type
*symbol
,
1168 bfd_size_type
*string_size_p
,
1169 asection
**debug_string_section_p
,
1170 bfd_size_type
*debug_string_size_p
)
1172 combined_entry_type
*native
= symbol
->native
;
1173 alent
*lineno
= symbol
->lineno
;
1174 struct bfd_link_info
*link_info
= coff_data (abfd
)->link_info
;
1176 if ((!link_info
|| link_info
->strip_discarded
)
1177 && !bfd_is_abs_section (symbol
->symbol
.section
)
1178 && symbol
->symbol
.section
->output_section
== bfd_abs_section_ptr
)
1180 symbol
->symbol
.name
= "";
1184 BFD_ASSERT (native
->is_sym
);
1185 /* If this symbol has an associated line number, we must store the
1186 symbol index in the line number field. We also tag the auxent to
1187 point to the right place in the lineno table. */
1188 if (lineno
&& !symbol
->done_lineno
&& symbol
->symbol
.section
->owner
!= NULL
)
1190 unsigned int count
= 0;
1192 lineno
[count
].u
.offset
= *written
;
1193 if (native
->u
.syment
.n_numaux
)
1195 union internal_auxent
*a
= &((native
+ 1)->u
.auxent
);
1197 a
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1198 symbol
->symbol
.section
->output_section
->moving_line_filepos
;
1201 /* Count and relocate all other linenumbers. */
1203 while (lineno
[count
].line_number
!= 0)
1205 lineno
[count
].u
.offset
+=
1206 (symbol
->symbol
.section
->output_section
->vma
1207 + symbol
->symbol
.section
->output_offset
);
1210 symbol
->done_lineno
= TRUE
;
1212 if (! bfd_is_const_section (symbol
->symbol
.section
->output_section
))
1213 symbol
->symbol
.section
->output_section
->moving_line_filepos
+=
1214 count
* bfd_coff_linesz (abfd
);
1217 return coff_write_symbol (abfd
, &(symbol
->symbol
), native
, written
,
1218 string_size_p
, debug_string_section_p
,
1219 debug_string_size_p
);
1223 null_error_handler (const char *fmt ATTRIBUTE_UNUSED
,
1224 va_list ap ATTRIBUTE_UNUSED
)
1228 /* Write out the COFF symbols. */
1231 coff_write_symbols (bfd
*abfd
)
1233 bfd_size_type string_size
;
1234 asection
*debug_string_section
;
1235 bfd_size_type debug_string_size
;
1237 unsigned int limit
= bfd_get_symcount (abfd
);
1238 bfd_vma written
= 0;
1242 debug_string_section
= NULL
;
1243 debug_string_size
= 0;
1245 /* If this target supports long section names, they must be put into
1246 the string table. This is supported by PE. This code must
1247 handle section names just as they are handled in
1248 coff_write_object_contents. */
1249 if (bfd_coff_long_section_names (abfd
))
1253 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1257 len
= strlen (o
->name
);
1259 string_size
+= len
+ 1;
1263 /* Seek to the right place. */
1264 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
1267 /* Output all the symbols we have. */
1269 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1271 asymbol
*symbol
= *p
;
1272 coff_symbol_type
*c_symbol
= coff_symbol_from (symbol
);
1274 if (c_symbol
== (coff_symbol_type
*) NULL
1275 || c_symbol
->native
== (combined_entry_type
*) NULL
)
1277 if (!coff_write_alien_symbol (abfd
, symbol
, NULL
, NULL
, &written
,
1278 &string_size
, &debug_string_section
,
1279 &debug_string_size
))
1284 if (coff_backend_info (abfd
)->_bfd_coff_classify_symbol
!= NULL
)
1286 bfd_error_handler_type current_error_handler
;
1287 enum coff_symbol_classification sym_class
;
1288 unsigned char *n_sclass
;
1290 /* Suppress error reporting by bfd_coff_classify_symbol.
1291 Error messages can be generated when we are processing a local
1292 symbol which has no associated section and we do not have to
1293 worry about this, all we need to know is that it is local. */
1294 current_error_handler
= bfd_set_error_handler (null_error_handler
);
1295 BFD_ASSERT (c_symbol
->native
->is_sym
);
1296 sym_class
= bfd_coff_classify_symbol (abfd
,
1297 &c_symbol
->native
->u
.syment
);
1298 (void) bfd_set_error_handler (current_error_handler
);
1300 n_sclass
= &c_symbol
->native
->u
.syment
.n_sclass
;
1302 /* If the symbol class has been changed (eg objcopy/ld script/etc)
1303 we cannot retain the existing sclass from the original symbol.
1304 Weak symbols only have one valid sclass, so just set it always.
1305 If it is not local class and should be, set it C_STAT.
1306 If it is global and not classified as global, or if it is
1307 weak (which is also classified as global), set it C_EXT. */
1309 if (symbol
->flags
& BSF_WEAK
)
1310 *n_sclass
= obj_pe (abfd
) ? C_NT_WEAK
: C_WEAKEXT
;
1311 else if (symbol
->flags
& BSF_LOCAL
&& sym_class
!= COFF_SYMBOL_LOCAL
)
1313 else if (symbol
->flags
& BSF_GLOBAL
1314 && (sym_class
!= COFF_SYMBOL_GLOBAL
1316 || *n_sclass
== C_NT_WEAK
1318 || *n_sclass
== C_WEAKEXT
))
1319 c_symbol
->native
->u
.syment
.n_sclass
= C_EXT
;
1322 if (!coff_write_native_symbol (abfd
, c_symbol
, &written
,
1323 &string_size
, &debug_string_section
,
1324 &debug_string_size
))
1329 obj_raw_syment_count (abfd
) = written
;
1331 /* Now write out strings. */
1332 if (string_size
!= 0)
1334 unsigned int size
= string_size
+ STRING_SIZE_SIZE
;
1335 bfd_byte buffer
[STRING_SIZE_SIZE
];
1337 #if STRING_SIZE_SIZE == 4
1338 H_PUT_32 (abfd
, size
, buffer
);
1340 #error Change H_PUT_32
1342 if (bfd_bwrite ((void *) buffer
, (bfd_size_type
) sizeof (buffer
), abfd
)
1346 /* Handle long section names. This code must handle section
1347 names just as they are handled in coff_write_object_contents. */
1348 if (bfd_coff_long_section_names (abfd
))
1352 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1356 len
= strlen (o
->name
);
1359 if (bfd_bwrite (o
->name
, (bfd_size_type
) (len
+ 1), abfd
)
1366 for (p
= abfd
->outsymbols
, i
= 0;
1371 size_t name_length
= strlen (q
->name
);
1372 coff_symbol_type
*c_symbol
= coff_symbol_from (q
);
1375 /* Figure out whether the symbol name should go in the string
1376 table. Symbol names that are short enough are stored
1377 directly in the syment structure. File names permit a
1378 different, longer, length in the syment structure. On
1379 XCOFF, some symbol names are stored in the .debug section
1380 rather than in the string table. */
1382 if (c_symbol
== NULL
1383 || c_symbol
->native
== NULL
)
1384 /* This is not a COFF symbol, so it certainly is not a
1385 file name, nor does it go in the .debug section. */
1386 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1388 else if (! c_symbol
->native
->is_sym
)
1389 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1391 else if (bfd_coff_symname_in_debug (abfd
,
1392 &c_symbol
->native
->u
.syment
))
1393 /* This symbol name is in the XCOFF .debug section.
1394 Don't write it into the string table. */
1395 maxlen
= name_length
;
1397 else if (c_symbol
->native
->u
.syment
.n_sclass
== C_FILE
1398 && c_symbol
->native
->u
.syment
.n_numaux
> 0)
1400 if (bfd_coff_force_symnames_in_strings (abfd
))
1402 if (bfd_bwrite (".file", (bfd_size_type
) 6, abfd
) != 6)
1405 maxlen
= bfd_coff_filnmlen (abfd
);
1408 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1410 if (name_length
> maxlen
)
1412 if (bfd_bwrite ((void *) (q
->name
), (bfd_size_type
) name_length
+ 1,
1413 abfd
) != name_length
+ 1)
1420 /* We would normally not write anything here, but we'll write
1421 out 4 so that any stupid coff reader which tries to read the
1422 string table even when there isn't one won't croak. */
1423 unsigned int size
= STRING_SIZE_SIZE
;
1424 bfd_byte buffer
[STRING_SIZE_SIZE
];
1426 #if STRING_SIZE_SIZE == 4
1427 H_PUT_32 (abfd
, size
, buffer
);
1429 #error Change H_PUT_32
1431 if (bfd_bwrite ((void *) buffer
, (bfd_size_type
) STRING_SIZE_SIZE
, abfd
)
1432 != STRING_SIZE_SIZE
)
1436 /* Make sure the .debug section was created to be the correct size.
1437 We should create it ourselves on the fly, but we don't because
1438 BFD won't let us write to any section until we know how large all
1439 the sections are. We could still do it by making another pass
1440 over the symbols. FIXME. */
1441 BFD_ASSERT (debug_string_size
== 0
1442 || (debug_string_section
!= (asection
*) NULL
1443 && (BFD_ALIGN (debug_string_size
,
1444 1 << debug_string_section
->alignment_power
)
1445 == debug_string_section
->size
)));
1451 coff_write_linenumbers (bfd
*abfd
)
1454 bfd_size_type linesz
;
1457 linesz
= bfd_coff_linesz (abfd
);
1458 buff
= bfd_alloc (abfd
, linesz
);
1461 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
1463 if (s
->lineno_count
)
1465 asymbol
**q
= abfd
->outsymbols
;
1466 if (bfd_seek (abfd
, s
->line_filepos
, SEEK_SET
) != 0)
1468 /* Find all the linenumbers in this section. */
1472 if (p
->section
->output_section
== s
)
1475 BFD_SEND (bfd_asymbol_bfd (p
), _get_lineno
,
1476 (bfd_asymbol_bfd (p
), p
));
1479 /* Found a linenumber entry, output. */
1480 struct internal_lineno out
;
1482 memset ((void *) & out
, 0, sizeof (out
));
1484 out
.l_addr
.l_symndx
= l
->u
.offset
;
1485 bfd_coff_swap_lineno_out (abfd
, &out
, buff
);
1486 if (bfd_bwrite (buff
, (bfd_size_type
) linesz
, abfd
)
1490 while (l
->line_number
)
1492 out
.l_lnno
= l
->line_number
;
1493 out
.l_addr
.l_symndx
= l
->u
.offset
;
1494 bfd_coff_swap_lineno_out (abfd
, &out
, buff
);
1495 if (bfd_bwrite (buff
, (bfd_size_type
) linesz
, abfd
)
1506 bfd_release (abfd
, buff
);
1511 coff_get_lineno (bfd
*ignore_abfd ATTRIBUTE_UNUSED
, asymbol
*symbol
)
1513 return coffsymbol (symbol
)->lineno
;
1516 /* This function transforms the offsets into the symbol table into
1517 pointers to syments. */
1520 coff_pointerize_aux (bfd
*abfd
,
1521 combined_entry_type
*table_base
,
1522 combined_entry_type
*symbol
,
1523 unsigned int indaux
,
1524 combined_entry_type
*auxent
)
1526 unsigned int type
= symbol
->u
.syment
.n_type
;
1527 unsigned int n_sclass
= symbol
->u
.syment
.n_sclass
;
1529 BFD_ASSERT (symbol
->is_sym
);
1530 if (coff_backend_info (abfd
)->_bfd_coff_pointerize_aux_hook
)
1532 if ((*coff_backend_info (abfd
)->_bfd_coff_pointerize_aux_hook
)
1533 (abfd
, table_base
, symbol
, indaux
, auxent
))
1537 /* Don't bother if this is a file or a section. */
1538 if (n_sclass
== C_STAT
&& type
== T_NULL
)
1540 if (n_sclass
== C_FILE
)
1543 BFD_ASSERT (! auxent
->is_sym
);
1544 /* Otherwise patch up. */
1545 #define N_TMASK coff_data (abfd)->local_n_tmask
1546 #define N_BTSHFT coff_data (abfd)->local_n_btshft
1548 if ((ISFCN (type
) || ISTAG (n_sclass
) || n_sclass
== C_BLOCK
1549 || n_sclass
== C_FCN
)
1550 && auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
> 0
1551 && auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
1552 < (long) obj_raw_syment_count (abfd
))
1554 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
=
1555 table_base
+ auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
1556 auxent
->fix_end
= 1;
1558 /* A negative tagndx is meaningless, but the SCO 3.2v4 cc can
1559 generate one, so we must be careful to ignore it. */
1560 if ((unsigned long) auxent
->u
.auxent
.x_sym
.x_tagndx
.l
1561 < obj_raw_syment_count (abfd
))
1563 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
=
1564 table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
;
1565 auxent
->fix_tag
= 1;
1569 /* Allocate space for the ".debug" section, and read it.
1570 We did not read the debug section until now, because
1571 we didn't want to go to the trouble until someone needed it. */
1574 build_debug_section (bfd
*abfd
, asection
** sect_return
)
1576 char *debug_section
;
1578 bfd_size_type sec_size
;
1580 asection
*sect
= bfd_get_section_by_name (abfd
, ".debug");
1584 bfd_set_error (bfd_error_no_debug_section
);
1588 sec_size
= sect
->size
;
1589 debug_section
= (char *) bfd_alloc (abfd
, sec_size
);
1590 if (debug_section
== NULL
)
1593 /* Seek to the beginning of the `.debug' section and read it.
1594 Save the current position first; it is needed by our caller.
1595 Then read debug section and reset the file pointer. */
1597 position
= bfd_tell (abfd
);
1598 if (bfd_seek (abfd
, sect
->filepos
, SEEK_SET
) != 0
1599 || bfd_bread (debug_section
, sec_size
, abfd
) != sec_size
1600 || bfd_seek (abfd
, position
, SEEK_SET
) != 0)
1603 * sect_return
= sect
;
1604 return debug_section
;
1607 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
1608 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
1609 be \0-terminated. */
1612 copy_name (bfd
*abfd
, char *name
, size_t maxlen
)
1617 for (len
= 0; len
< maxlen
; ++len
)
1618 if (name
[len
] == '\0')
1621 if ((newname
= (char *) bfd_alloc (abfd
, (bfd_size_type
) len
+ 1)) == NULL
)
1624 strncpy (newname
, name
, len
);
1625 newname
[len
] = '\0';
1629 /* Read in the external symbols. */
1632 _bfd_coff_get_external_symbols (bfd
*abfd
)
1634 bfd_size_type symesz
;
1638 if (obj_coff_external_syms (abfd
) != NULL
)
1641 symesz
= bfd_coff_symesz (abfd
);
1643 size
= obj_raw_syment_count (abfd
) * symesz
;
1646 /* Check for integer overflow and for unreasonable symbol counts. */
1647 if (size
< obj_raw_syment_count (abfd
)
1648 || (bfd_get_file_size (abfd
) > 0
1649 && size
> bfd_get_file_size (abfd
)))
1652 _bfd_error_handler (_("%pB: corrupt symbol count: %#" PRIx64
""),
1653 abfd
, (uint64_t) obj_raw_syment_count (abfd
));
1657 syms
= bfd_malloc (size
);
1660 /* PR 21013: Provide an error message when the alloc fails. */
1661 _bfd_error_handler (_("%pB: not enough memory to allocate space "
1662 "for %#" PRIx64
" symbols of size %#" PRIx64
),
1663 abfd
, (uint64_t) obj_raw_syment_count (abfd
),
1668 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
1669 || bfd_bread (syms
, size
, abfd
) != size
)
1676 obj_coff_external_syms (abfd
) = syms
;
1680 /* Read in the external strings. The strings are not loaded until
1681 they are needed. This is because we have no simple way of
1682 detecting a missing string table in an archive. If the strings
1683 are loaded then the STRINGS and STRINGS_LEN fields in the
1684 coff_tdata structure will be set. */
1687 _bfd_coff_read_string_table (bfd
*abfd
)
1689 char extstrsize
[STRING_SIZE_SIZE
];
1690 bfd_size_type strsize
;
1694 if (obj_coff_strings (abfd
) != NULL
)
1695 return obj_coff_strings (abfd
);
1697 if (obj_sym_filepos (abfd
) == 0)
1699 bfd_set_error (bfd_error_no_symbols
);
1703 pos
= obj_sym_filepos (abfd
);
1704 pos
+= obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
1705 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
1708 if (bfd_bread (extstrsize
, (bfd_size_type
) sizeof extstrsize
, abfd
)
1709 != sizeof extstrsize
)
1711 if (bfd_get_error () != bfd_error_file_truncated
)
1714 /* There is no string table. */
1715 strsize
= STRING_SIZE_SIZE
;
1719 #if STRING_SIZE_SIZE == 4
1720 strsize
= H_GET_32 (abfd
, extstrsize
);
1722 #error Change H_GET_32
1726 if (strsize
< STRING_SIZE_SIZE
|| strsize
> bfd_get_file_size (abfd
))
1729 /* xgettext: c-format */
1730 (_("%pB: bad string table size %" PRIu64
), abfd
, (uint64_t) strsize
);
1731 bfd_set_error (bfd_error_bad_value
);
1735 strings
= (char *) bfd_malloc (strsize
+ 1);
1736 if (strings
== NULL
)
1739 /* PR 17521 file: 079-54929-0.004.
1740 A corrupt file could contain an index that points into the first
1741 STRING_SIZE_SIZE bytes of the string table, so make sure that
1743 memset (strings
, 0, STRING_SIZE_SIZE
);
1745 if (bfd_bread (strings
+ STRING_SIZE_SIZE
, strsize
- STRING_SIZE_SIZE
, abfd
)
1746 != strsize
- STRING_SIZE_SIZE
)
1752 obj_coff_strings (abfd
) = strings
;
1753 obj_coff_strings_len (abfd
) = strsize
;
1754 /* Terminate the string table, just in case. */
1755 strings
[strsize
] = 0;
1759 /* Free up the external symbols and strings read from a COFF file. */
1762 _bfd_coff_free_symbols (bfd
*abfd
)
1764 if (! bfd_family_coff (abfd
))
1767 if (obj_coff_external_syms (abfd
) != NULL
1768 && ! obj_coff_keep_syms (abfd
))
1770 free (obj_coff_external_syms (abfd
));
1771 obj_coff_external_syms (abfd
) = NULL
;
1774 if (obj_coff_strings (abfd
) != NULL
1775 && ! obj_coff_keep_strings (abfd
))
1777 free (obj_coff_strings (abfd
));
1778 obj_coff_strings (abfd
) = NULL
;
1779 obj_coff_strings_len (abfd
) = 0;
1785 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
1786 knit the symbol names into a normalized form. By normalized here I
1787 mean that all symbols have an n_offset pointer that points to a null-
1788 terminated string. */
1790 combined_entry_type
*
1791 coff_get_normalized_symtab (bfd
*abfd
)
1793 combined_entry_type
*internal
;
1794 combined_entry_type
*internal_ptr
;
1795 combined_entry_type
*symbol_ptr
;
1796 combined_entry_type
*internal_end
;
1800 const char *string_table
= NULL
;
1801 asection
* debug_sec
= NULL
;
1802 char *debug_sec_data
= NULL
;
1805 if (obj_raw_syments (abfd
) != NULL
)
1806 return obj_raw_syments (abfd
);
1808 if (! _bfd_coff_get_external_symbols (abfd
))
1811 size
= obj_raw_syment_count (abfd
) * sizeof (combined_entry_type
);
1812 /* Check for integer overflow. */
1813 if (size
< obj_raw_syment_count (abfd
))
1815 internal
= (combined_entry_type
*) bfd_zalloc (abfd
, size
);
1816 if (internal
== NULL
&& size
!= 0)
1818 internal_end
= internal
+ obj_raw_syment_count (abfd
);
1820 raw_src
= (char *) obj_coff_external_syms (abfd
);
1822 /* Mark the end of the symbols. */
1823 symesz
= bfd_coff_symesz (abfd
);
1824 raw_end
= (char *) raw_src
+ obj_raw_syment_count (abfd
) * symesz
;
1826 /* FIXME SOMEDAY. A string table size of zero is very weird, but
1827 probably possible. If one shows up, it will probably kill us. */
1829 /* Swap all the raw entries. */
1830 for (internal_ptr
= internal
;
1832 raw_src
+= symesz
, internal_ptr
++)
1836 bfd_coff_swap_sym_in (abfd
, (void *) raw_src
,
1837 (void *) & internal_ptr
->u
.syment
);
1838 symbol_ptr
= internal_ptr
;
1839 internal_ptr
->is_sym
= TRUE
;
1841 /* PR 17512: file: 1353-1166-0.004. */
1842 if (symbol_ptr
->u
.syment
.n_sclass
== C_FILE
1843 && symbol_ptr
->u
.syment
.n_numaux
> 0
1844 && raw_src
+ symesz
+ symbol_ptr
->u
.syment
.n_numaux
1847 bfd_release (abfd
, internal
);
1852 i
< symbol_ptr
->u
.syment
.n_numaux
;
1856 /* PR 17512: Prevent buffer overrun. */
1857 if (internal_ptr
>= internal_end
)
1859 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
,
1876 /* Free the raw symbols, but not the strings (if we have them). */
1877 obj_coff_keep_strings (abfd
) = TRUE
;
1878 if (! _bfd_coff_free_symbols (abfd
))
1881 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
1884 BFD_ASSERT (internal_ptr
->is_sym
);
1886 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
1887 && internal_ptr
->u
.syment
.n_numaux
> 0)
1889 combined_entry_type
* aux
= internal_ptr
+ 1;
1891 /* Make a file symbol point to the name in the auxent, since
1892 the text ".file" is redundant. */
1893 BFD_ASSERT (! aux
->is_sym
);
1895 if (aux
->u
.auxent
.x_file
.x_n
.x_zeroes
== 0)
1897 /* The filename is a long one, point into the string table. */
1898 if (string_table
== NULL
)
1900 string_table
= _bfd_coff_read_string_table (abfd
);
1901 if (string_table
== NULL
)
1905 if ((bfd_size_type
)(aux
->u
.auxent
.x_file
.x_n
.x_offset
)
1906 >= obj_coff_strings_len (abfd
))
1907 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1909 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1910 (bfd_hostptr_t
) (string_table
+ (aux
->u
.auxent
.x_file
.x_n
.x_offset
));
1914 /* Ordinary short filename, put into memory anyway. The
1915 Microsoft PE tools sometimes store a filename in
1916 multiple AUX entries. */
1917 if (internal_ptr
->u
.syment
.n_numaux
> 1
1918 && coff_data (abfd
)->pe
)
1919 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1922 aux
->u
.auxent
.x_file
.x_fname
,
1923 internal_ptr
->u
.syment
.n_numaux
* symesz
);
1925 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1928 aux
->u
.auxent
.x_file
.x_fname
,
1929 (size_t) bfd_coff_filnmlen (abfd
)));
1934 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0)
1936 /* This is a "short" name. Make it long. */
1940 /* Find the length of this string without walking into memory
1942 for (i
= 0; i
< 8; ++i
)
1943 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0')
1946 newstring
= (char *) bfd_zalloc (abfd
, (bfd_size_type
) (i
+ 1));
1947 if (newstring
== NULL
)
1949 strncpy (newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
);
1950 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) newstring
;
1951 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1953 else if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
== 0)
1954 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) "";
1955 else if (!bfd_coff_symname_in_debug (abfd
, &internal_ptr
->u
.syment
))
1957 /* Long name already. Point symbol at the string in the
1959 if (string_table
== NULL
)
1961 string_table
= _bfd_coff_read_string_table (abfd
);
1962 if (string_table
== NULL
)
1965 if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
>= obj_coff_strings_len (abfd
)
1966 || string_table
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
< string_table
)
1967 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1969 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1972 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
));
1976 /* Long name in debug section. Very similar. */
1977 if (debug_sec_data
== NULL
)
1978 debug_sec_data
= build_debug_section (abfd
, & debug_sec
);
1979 if (debug_sec_data
!= NULL
)
1981 BFD_ASSERT (debug_sec
!= NULL
);
1982 /* PR binutils/17512: Catch out of range offsets into the debug data. */
1983 if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
> debug_sec
->size
1984 || debug_sec_data
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
< debug_sec_data
)
1985 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1987 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
)
1988 (debug_sec_data
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
1991 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) "";
1994 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
1997 obj_raw_syments (abfd
) = internal
;
1998 BFD_ASSERT (obj_raw_syment_count (abfd
)
1999 == (unsigned int) (internal_ptr
- internal
));
2005 coff_get_reloc_upper_bound (bfd
*abfd
, sec_ptr asect
)
2007 if (bfd_get_format (abfd
) != bfd_object
)
2009 bfd_set_error (bfd_error_invalid_operation
);
2012 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
2016 coff_make_empty_symbol (bfd
*abfd
)
2018 bfd_size_type amt
= sizeof (coff_symbol_type
);
2019 coff_symbol_type
*new_symbol
= (coff_symbol_type
*) bfd_zalloc (abfd
, amt
);
2021 if (new_symbol
== NULL
)
2023 new_symbol
->symbol
.section
= 0;
2024 new_symbol
->native
= NULL
;
2025 new_symbol
->lineno
= NULL
;
2026 new_symbol
->done_lineno
= FALSE
;
2027 new_symbol
->symbol
.the_bfd
= abfd
;
2029 return & new_symbol
->symbol
;
2032 /* Make a debugging symbol. */
2035 coff_bfd_make_debug_symbol (bfd
*abfd
,
2036 void * ptr ATTRIBUTE_UNUSED
,
2037 unsigned long sz ATTRIBUTE_UNUSED
)
2039 bfd_size_type amt
= sizeof (coff_symbol_type
);
2040 coff_symbol_type
*new_symbol
= (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
2042 if (new_symbol
== NULL
)
2044 /* @@ The 10 is a guess at a plausible maximum number of aux entries
2045 (but shouldn't be a constant). */
2046 amt
= sizeof (combined_entry_type
) * 10;
2047 new_symbol
->native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
2048 if (!new_symbol
->native
)
2050 new_symbol
->native
->is_sym
= TRUE
;
2051 new_symbol
->symbol
.section
= bfd_abs_section_ptr
;
2052 new_symbol
->symbol
.flags
= BSF_DEBUGGING
;
2053 new_symbol
->lineno
= NULL
;
2054 new_symbol
->done_lineno
= FALSE
;
2055 new_symbol
->symbol
.the_bfd
= abfd
;
2057 return & new_symbol
->symbol
;
2061 coff_get_symbol_info (bfd
*abfd
, asymbol
*symbol
, symbol_info
*ret
)
2063 bfd_symbol_info (symbol
, ret
);
2065 if (coffsymbol (symbol
)->native
!= NULL
2066 && coffsymbol (symbol
)->native
->fix_value
2067 && coffsymbol (symbol
)->native
->is_sym
)
2068 ret
->value
= coffsymbol (symbol
)->native
->u
.syment
.n_value
-
2069 (bfd_hostptr_t
) obj_raw_syments (abfd
);
2072 /* Print out information about COFF symbol. */
2075 coff_print_symbol (bfd
*abfd
,
2078 bfd_print_symbol_type how
)
2080 FILE * file
= (FILE *) filep
;
2084 case bfd_print_symbol_name
:
2085 fprintf (file
, "%s", symbol
->name
);
2088 case bfd_print_symbol_more
:
2089 fprintf (file
, "coff %s %s",
2090 coffsymbol (symbol
)->native
? "n" : "g",
2091 coffsymbol (symbol
)->lineno
? "l" : " ");
2094 case bfd_print_symbol_all
:
2095 if (coffsymbol (symbol
)->native
)
2099 combined_entry_type
*combined
= coffsymbol (symbol
)->native
;
2100 combined_entry_type
*root
= obj_raw_syments (abfd
);
2101 struct lineno_cache_entry
*l
= coffsymbol (symbol
)->lineno
;
2103 fprintf (file
, "[%3ld]", (long) (combined
- root
));
2105 /* PR 17512: file: 079-33786-0.001:0.1. */
2106 if (combined
< obj_raw_syments (abfd
)
2107 || combined
>= obj_raw_syments (abfd
) + obj_raw_syment_count (abfd
))
2109 fprintf (file
, _("<corrupt info> %s"), symbol
->name
);
2113 BFD_ASSERT (combined
->is_sym
);
2114 if (! combined
->fix_value
)
2115 val
= (bfd_vma
) combined
->u
.syment
.n_value
;
2117 val
= combined
->u
.syment
.n_value
- (bfd_hostptr_t
) root
;
2119 fprintf (file
, "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x",
2120 combined
->u
.syment
.n_scnum
,
2121 combined
->u
.syment
.n_flags
,
2122 combined
->u
.syment
.n_type
,
2123 combined
->u
.syment
.n_sclass
,
2124 combined
->u
.syment
.n_numaux
);
2125 bfd_fprintf_vma (abfd
, file
, val
);
2126 fprintf (file
, " %s", symbol
->name
);
2128 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
2130 combined_entry_type
*auxp
= combined
+ aux
+ 1;
2133 BFD_ASSERT (! auxp
->is_sym
);
2135 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.p
- root
;
2137 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.l
;
2139 fprintf (file
, "\n");
2141 if (bfd_coff_print_aux (abfd
, file
, root
, combined
, auxp
, aux
))
2144 switch (combined
->u
.syment
.n_sclass
)
2147 fprintf (file
, "File ");
2151 if (combined
->u
.syment
.n_type
== T_NULL
)
2152 /* Probably a section symbol ? */
2154 fprintf (file
, "AUX scnlen 0x%lx nreloc %d nlnno %d",
2155 (unsigned long) auxp
->u
.auxent
.x_scn
.x_scnlen
,
2156 auxp
->u
.auxent
.x_scn
.x_nreloc
,
2157 auxp
->u
.auxent
.x_scn
.x_nlinno
);
2158 if (auxp
->u
.auxent
.x_scn
.x_checksum
!= 0
2159 || auxp
->u
.auxent
.x_scn
.x_associated
!= 0
2160 || auxp
->u
.auxent
.x_scn
.x_comdat
!= 0)
2161 fprintf (file
, " checksum 0x%lx assoc %d comdat %d",
2162 auxp
->u
.auxent
.x_scn
.x_checksum
,
2163 auxp
->u
.auxent
.x_scn
.x_associated
,
2164 auxp
->u
.auxent
.x_scn
.x_comdat
);
2170 if (ISFCN (combined
->u
.syment
.n_type
))
2175 next
= (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2178 next
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2179 llnos
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
2181 "AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld",
2183 (unsigned long) auxp
->u
.auxent
.x_sym
.x_misc
.x_fsize
,
2189 fprintf (file
, "AUX lnno %d size 0x%x tagndx %ld",
2190 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
2191 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
,
2194 fprintf (file
, " endndx %ld",
2196 (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2204 fprintf (file
, "\n%s :", l
->u
.sym
->name
);
2206 while (l
->line_number
)
2208 if (l
->line_number
> 0)
2210 fprintf (file
, "\n%4d : ", l
->line_number
);
2211 bfd_fprintf_vma (abfd
, file
, l
->u
.offset
+ symbol
->section
->vma
);
2219 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
2220 fprintf (file
, " %-5s %s %s %s",
2221 symbol
->section
->name
,
2222 coffsymbol (symbol
)->native
? "n" : "g",
2223 coffsymbol (symbol
)->lineno
? "l" : " ",
2229 /* Return whether a symbol name implies a local symbol. In COFF,
2230 local symbols generally start with ``.L''. Most targets use this
2231 function for the is_local_label_name entry point, but some may
2235 _bfd_coff_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
2238 return name
[0] == '.' && name
[1] == 'L';
2241 /* Provided a BFD, a section and an offset (in bytes, not octets) into the
2242 section, calculate and return the name of the source file and the line
2243 nearest to the wanted location. */
2246 coff_find_nearest_line_with_names (bfd
*abfd
,
2250 const char **filename_ptr
,
2251 const char **functionname_ptr
,
2252 unsigned int *line_ptr
,
2253 const struct dwarf_debug_section
*debug_sections
)
2257 unsigned int line_base
;
2258 coff_data_type
*cof
= coff_data (abfd
);
2259 /* Run through the raw syments if available. */
2260 combined_entry_type
*p
;
2261 combined_entry_type
*pend
;
2263 struct coff_section_tdata
*sec_data
;
2266 /* Before looking through the symbol table, try to use a .stab
2267 section to find the information. */
2268 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2269 &found
, filename_ptr
,
2270 functionname_ptr
, line_ptr
,
2271 &coff_data(abfd
)->line_info
))
2277 /* Also try examining DWARF2 debugging information. */
2278 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
2279 filename_ptr
, functionname_ptr
,
2280 line_ptr
, NULL
, debug_sections
, 0,
2281 &coff_data(abfd
)->dwarf2_find_line_info
))
2284 sec_data
= coff_section_data (abfd
, section
);
2286 /* If the DWARF lookup failed, but there is DWARF information available
2287 then the problem might be that the file has been rebased. This tool
2288 changes the VMAs of all the sections, but it does not update the DWARF
2289 information. So try again, using a bias against the address sought. */
2290 if (coff_data (abfd
)->dwarf2_find_line_info
!= NULL
)
2292 bfd_signed_vma bias
;
2294 /* Create a cache of the result for the next call. */
2295 if (sec_data
== NULL
&& section
->owner
== abfd
)
2297 amt
= sizeof (struct coff_section_tdata
);
2298 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
2299 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2302 if (sec_data
!= NULL
&& sec_data
->saved_bias
)
2303 bias
= sec_data
->saved_bias
;
2306 bias
= _bfd_dwarf2_find_symbol_bias (symbols
,
2307 & coff_data (abfd
)->dwarf2_find_line_info
);
2310 sec_data
->saved_bias
= TRUE
;
2311 sec_data
->bias
= bias
;
2316 && _bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
,
2318 filename_ptr
, functionname_ptr
,
2319 line_ptr
, NULL
, debug_sections
, 0,
2320 &coff_data(abfd
)->dwarf2_find_line_info
))
2325 *functionname_ptr
= 0;
2328 /* Don't try and find line numbers in a non coff file. */
2329 if (!bfd_family_coff (abfd
))
2335 /* Find the first C_FILE symbol. */
2336 p
= cof
->raw_syments
;
2340 pend
= p
+ cof
->raw_syment_count
;
2343 BFD_ASSERT (p
->is_sym
);
2344 if (p
->u
.syment
.n_sclass
== C_FILE
)
2346 p
+= 1 + p
->u
.syment
.n_numaux
;
2354 /* Look through the C_FILE symbols to find the best one. */
2355 sec_vma
= bfd_get_section_vma (abfd
, section
);
2356 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2357 maxdiff
= (bfd_vma
) 0 - (bfd_vma
) 1;
2361 combined_entry_type
*p2
;
2363 for (p2
= p
+ 1 + p
->u
.syment
.n_numaux
;
2365 p2
+= 1 + p2
->u
.syment
.n_numaux
)
2367 BFD_ASSERT (p2
->is_sym
);
2368 if (p2
->u
.syment
.n_scnum
> 0
2370 == coff_section_from_bfd_index (abfd
,
2371 p2
->u
.syment
.n_scnum
)))
2373 if (p2
->u
.syment
.n_sclass
== C_FILE
)
2382 file_addr
= (bfd_vma
) p2
->u
.syment
.n_value
;
2383 /* PR 11512: Include the section address of the function name symbol. */
2384 if (p2
->u
.syment
.n_scnum
> 0)
2385 file_addr
+= coff_section_from_bfd_index (abfd
,
2386 p2
->u
.syment
.n_scnum
)->vma
;
2387 /* We use <= MAXDIFF here so that if we get a zero length
2388 file, we actually use the next file entry. */
2390 && offset
+ sec_vma
>= file_addr
2391 && offset
+ sec_vma
- file_addr
<= maxdiff
)
2393 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2394 maxdiff
= offset
+ sec_vma
- p2
->u
.syment
.n_value
;
2397 /* Avoid endless loops on erroneous files by ensuring that
2398 we always move forward in the file. */
2399 if (p
>= cof
->raw_syments
+ p
->u
.syment
.n_value
)
2402 p
= cof
->raw_syments
+ p
->u
.syment
.n_value
;
2403 if (p
> pend
|| p
->u
.syment
.n_sclass
!= C_FILE
)
2408 if (section
->lineno_count
== 0)
2410 *functionname_ptr
= NULL
;
2415 /* Now wander though the raw linenumbers of the section.
2416 If we have been called on this section before, and the offset
2417 we want is further down then we can prime the lookup loop. */
2418 if (sec_data
!= NULL
2420 && offset
>= sec_data
->offset
)
2423 *functionname_ptr
= sec_data
->function
;
2424 line_base
= sec_data
->line_base
;
2432 if (section
->lineno
!= NULL
)
2434 bfd_vma last_value
= 0;
2436 l
= §ion
->lineno
[i
];
2438 for (; i
< section
->lineno_count
; i
++)
2440 if (l
->line_number
== 0)
2442 /* Get the symbol this line number points at. */
2443 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
2444 if (coff
->symbol
.value
> offset
)
2447 *functionname_ptr
= coff
->symbol
.name
;
2448 last_value
= coff
->symbol
.value
;
2451 combined_entry_type
*s
= coff
->native
;
2453 BFD_ASSERT (s
->is_sym
);
2454 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2456 /* In XCOFF a debugging symbol can follow the
2458 if (s
->u
.syment
.n_scnum
== N_DEBUG
)
2459 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2461 /* S should now point to the .bf of the function. */
2462 if (s
->u
.syment
.n_numaux
)
2464 /* The linenumber is stored in the auxent. */
2465 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
2467 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
2468 *line_ptr
= line_base
;
2474 if (l
->u
.offset
> offset
)
2476 *line_ptr
= l
->line_number
+ line_base
- 1;
2481 /* If we fell off the end of the loop, then assume that this
2482 symbol has no line number info. Otherwise, symbols with no
2483 line number info get reported with the line number of the
2484 last line of the last symbol which does have line number
2485 info. We use 0x100 as a slop to account for cases where the
2486 last line has executable code. */
2487 if (i
>= section
->lineno_count
2489 && offset
- last_value
> 0x100)
2491 *functionname_ptr
= NULL
;
2496 /* Cache the results for the next call. */
2497 if (sec_data
== NULL
&& section
->owner
== abfd
)
2499 amt
= sizeof (struct coff_section_tdata
);
2500 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
2501 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2504 if (sec_data
!= NULL
)
2506 sec_data
->offset
= offset
;
2507 sec_data
->i
= i
- 1;
2508 sec_data
->function
= *functionname_ptr
;
2509 sec_data
->line_base
= line_base
;
2516 coff_find_nearest_line (bfd
*abfd
,
2520 const char **filename_ptr
,
2521 const char **functionname_ptr
,
2522 unsigned int *line_ptr
,
2523 unsigned int *discriminator_ptr
)
2525 if (discriminator_ptr
)
2526 *discriminator_ptr
= 0;
2527 return coff_find_nearest_line_with_names (abfd
, symbols
, section
, offset
,
2528 filename_ptr
, functionname_ptr
,
2529 line_ptr
, dwarf_debug_sections
);
2533 coff_find_inliner_info (bfd
*abfd
,
2534 const char **filename_ptr
,
2535 const char **functionname_ptr
,
2536 unsigned int *line_ptr
)
2540 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
2541 functionname_ptr
, line_ptr
,
2542 &coff_data(abfd
)->dwarf2_find_line_info
);
2547 coff_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
2551 if (!bfd_link_relocatable (info
))
2552 size
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
2554 size
= bfd_coff_filhsz (abfd
);
2556 size
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
2560 /* Change the class of a coff symbol held by BFD. */
2563 bfd_coff_set_symbol_class (bfd
* abfd
,
2565 unsigned int symbol_class
)
2567 coff_symbol_type
* csym
;
2569 csym
= coff_symbol_from (symbol
);
2572 bfd_set_error (bfd_error_invalid_operation
);
2575 else if (csym
->native
== NULL
)
2577 /* This is an alien symbol which no native coff backend data.
2578 We cheat here by creating a fake native entry for it and
2579 then filling in the class. This code is based on that in
2580 coff_write_alien_symbol(). */
2582 combined_entry_type
* native
;
2583 bfd_size_type amt
= sizeof (* native
);
2585 native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
2589 native
->is_sym
= TRUE
;
2590 native
->u
.syment
.n_type
= T_NULL
;
2591 native
->u
.syment
.n_sclass
= symbol_class
;
2593 if (bfd_is_und_section (symbol
->section
))
2595 native
->u
.syment
.n_scnum
= N_UNDEF
;
2596 native
->u
.syment
.n_value
= symbol
->value
;
2598 else if (bfd_is_com_section (symbol
->section
))
2600 native
->u
.syment
.n_scnum
= N_UNDEF
;
2601 native
->u
.syment
.n_value
= symbol
->value
;
2605 native
->u
.syment
.n_scnum
=
2606 symbol
->section
->output_section
->target_index
;
2607 native
->u
.syment
.n_value
= (symbol
->value
2608 + symbol
->section
->output_offset
);
2609 if (! obj_pe (abfd
))
2610 native
->u
.syment
.n_value
+= symbol
->section
->output_section
->vma
;
2612 /* Copy the any flags from the file header into the symbol.
2614 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (& csym
->symbol
)->flags
;
2617 csym
->native
= native
;
2620 csym
->native
->u
.syment
.n_sclass
= symbol_class
;
2626 _bfd_coff_section_already_linked (bfd
*abfd
,
2628 struct bfd_link_info
*info
)
2631 const char *name
, *key
;
2632 struct bfd_section_already_linked
*l
;
2633 struct bfd_section_already_linked_hash_entry
*already_linked_list
;
2634 struct coff_comdat_info
*s_comdat
;
2637 if ((flags
& SEC_LINK_ONCE
) == 0)
2640 /* The COFF backend linker doesn't support group sections. */
2641 if ((flags
& SEC_GROUP
) != 0)
2644 name
= bfd_get_section_name (abfd
, sec
);
2645 s_comdat
= bfd_coff_get_comdat_section (abfd
, sec
);
2647 if (s_comdat
!= NULL
)
2648 key
= s_comdat
->name
;
2651 if (CONST_STRNEQ (name
, ".gnu.linkonce.")
2652 && (key
= strchr (name
+ sizeof (".gnu.linkonce.") - 1, '.')) != NULL
)
2655 /* FIXME: gcc as of 2011-09 emits sections like .text$<key>,
2656 .xdata$<key> and .pdata$<key> only the first of which has a
2657 comdat key. Should these all match the LTO IR key? */
2661 already_linked_list
= bfd_section_already_linked_table_lookup (key
);
2663 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
2665 struct coff_comdat_info
*l_comdat
;
2667 l_comdat
= bfd_coff_get_comdat_section (l
->sec
->owner
, l
->sec
);
2669 /* The section names must match, and both sections must be
2670 comdat and have the same comdat name, or both sections must
2671 be non-comdat. LTO IR plugin sections are an exception. They
2672 are always named .gnu.linkonce.t.<key> (<key> is some string)
2673 and match any comdat section with comdat name of <key>, and
2674 any linkonce section with the same suffix, ie.
2675 .gnu.linkonce.*.<key>. */
2676 if (((s_comdat
!= NULL
) == (l_comdat
!= NULL
)
2677 && strcmp (name
, l
->sec
->name
) == 0)
2678 || (l
->sec
->owner
->flags
& BFD_PLUGIN
) != 0)
2680 /* The section has already been linked. See if we should
2682 return _bfd_handle_already_linked (sec
, l
, info
);
2686 /* This is the first section with this name. Record it. */
2687 if (!bfd_section_already_linked_table_insert (already_linked_list
, sec
))
2688 info
->callbacks
->einfo (_("%F%P: already_linked_table: %E\n"));
2692 /* Initialize COOKIE for input bfd ABFD. */
2695 init_reloc_cookie (struct coff_reloc_cookie
*cookie
,
2696 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2699 /* Sometimes the symbol table does not yet have been loaded here. */
2700 bfd_coff_slurp_symbol_table (abfd
);
2702 cookie
->abfd
= abfd
;
2703 cookie
->sym_hashes
= obj_coff_sym_hashes (abfd
);
2705 cookie
->symbols
= obj_symbols (abfd
);
2710 /* Free the memory allocated by init_reloc_cookie, if appropriate. */
2713 fini_reloc_cookie (struct coff_reloc_cookie
*cookie ATTRIBUTE_UNUSED
,
2714 bfd
*abfd ATTRIBUTE_UNUSED
)
2716 /* Nothing to do. */
2719 /* Initialize the relocation information in COOKIE for input section SEC
2720 of input bfd ABFD. */
2723 init_reloc_cookie_rels (struct coff_reloc_cookie
*cookie
,
2724 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2728 if (sec
->reloc_count
== 0)
2730 cookie
->rels
= NULL
;
2731 cookie
->relend
= NULL
;
2736 cookie
->rels
= _bfd_coff_read_internal_relocs (abfd
, sec
, FALSE
, NULL
, 0, NULL
);
2738 if (cookie
->rels
== NULL
)
2741 cookie
->rel
= cookie
->rels
;
2742 cookie
->relend
= (cookie
->rels
+ sec
->reloc_count
);
2746 /* Free the memory allocated by init_reloc_cookie_rels,
2750 fini_reloc_cookie_rels (struct coff_reloc_cookie
*cookie
,
2754 /* PR 20401. The relocs may not have been cached, so check first.
2755 If the relocs were loaded by init_reloc_cookie_rels() then this
2756 will be the case. FIXME: Would performance be improved if the
2757 relocs *were* cached ? */
2758 && coff_section_data (NULL
, sec
)
2759 && coff_section_data (NULL
, sec
)->relocs
!= cookie
->rels
)
2760 free (cookie
->rels
);
2763 /* Initialize the whole of COOKIE for input section SEC. */
2766 init_reloc_cookie_for_section (struct coff_reloc_cookie
*cookie
,
2767 struct bfd_link_info
*info
,
2770 if (!init_reloc_cookie (cookie
, info
, sec
->owner
))
2773 if (!init_reloc_cookie_rels (cookie
, info
, sec
->owner
, sec
))
2775 fini_reloc_cookie (cookie
, sec
->owner
);
2781 /* Free the memory allocated by init_reloc_cookie_for_section,
2785 fini_reloc_cookie_for_section (struct coff_reloc_cookie
*cookie
,
2788 fini_reloc_cookie_rels (cookie
, sec
);
2789 fini_reloc_cookie (cookie
, sec
->owner
);
2793 _bfd_coff_gc_mark_hook (asection
*sec
,
2794 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2795 struct internal_reloc
*rel ATTRIBUTE_UNUSED
,
2796 struct coff_link_hash_entry
*h
,
2797 struct internal_syment
*sym
)
2801 switch (h
->root
.type
)
2803 case bfd_link_hash_defined
:
2804 case bfd_link_hash_defweak
:
2805 return h
->root
.u
.def
.section
;
2807 case bfd_link_hash_common
:
2808 return h
->root
.u
.c
.p
->section
;
2810 case bfd_link_hash_undefweak
:
2811 if (h
->symbol_class
== C_NT_WEAK
&& h
->numaux
== 1)
2813 /* PE weak externals. A weak symbol may include an auxiliary
2814 record indicating that if the weak symbol is not resolved,
2815 another external symbol is used instead. */
2816 struct coff_link_hash_entry
*h2
=
2817 h
->auxbfd
->tdata
.coff_obj_data
->sym_hashes
[
2818 h
->aux
->x_sym
.x_tagndx
.l
];
2820 if (h2
&& h2
->root
.type
!= bfd_link_hash_undefined
)
2821 return h2
->root
.u
.def
.section
;
2825 case bfd_link_hash_undefined
:
2832 return coff_section_from_bfd_index (sec
->owner
, sym
->n_scnum
);
2835 /* COOKIE->rel describes a relocation against section SEC, which is
2836 a section we've decided to keep. Return the section that contains
2837 the relocation symbol, or NULL if no section contains it. */
2840 _bfd_coff_gc_mark_rsec (struct bfd_link_info
*info
, asection
*sec
,
2841 coff_gc_mark_hook_fn gc_mark_hook
,
2842 struct coff_reloc_cookie
*cookie
)
2844 struct coff_link_hash_entry
*h
;
2846 h
= cookie
->sym_hashes
[cookie
->rel
->r_symndx
];
2849 while (h
->root
.type
== bfd_link_hash_indirect
2850 || h
->root
.type
== bfd_link_hash_warning
)
2851 h
= (struct coff_link_hash_entry
*) h
->root
.u
.i
.link
;
2853 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, h
, NULL
);
2856 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, NULL
,
2858 + obj_convert (sec
->owner
)[cookie
->rel
->r_symndx
])->native
->u
.syment
);
2861 static bfd_boolean _bfd_coff_gc_mark
2862 (struct bfd_link_info
*, asection
*, coff_gc_mark_hook_fn
);
2864 /* COOKIE->rel describes a relocation against section SEC, which is
2865 a section we've decided to keep. Mark the section that contains
2866 the relocation symbol. */
2869 _bfd_coff_gc_mark_reloc (struct bfd_link_info
*info
,
2871 coff_gc_mark_hook_fn gc_mark_hook
,
2872 struct coff_reloc_cookie
*cookie
)
2876 rsec
= _bfd_coff_gc_mark_rsec (info
, sec
, gc_mark_hook
, cookie
);
2877 if (rsec
&& !rsec
->gc_mark
)
2879 if (bfd_get_flavour (rsec
->owner
) != bfd_target_coff_flavour
)
2881 else if (!_bfd_coff_gc_mark (info
, rsec
, gc_mark_hook
))
2887 /* The mark phase of garbage collection. For a given section, mark
2888 it and any sections in this section's group, and all the sections
2889 which define symbols to which it refers. */
2892 _bfd_coff_gc_mark (struct bfd_link_info
*info
,
2894 coff_gc_mark_hook_fn gc_mark_hook
)
2896 bfd_boolean ret
= TRUE
;
2900 /* Look through the section relocs. */
2901 if ((sec
->flags
& SEC_RELOC
) != 0
2902 && sec
->reloc_count
> 0)
2904 struct coff_reloc_cookie cookie
;
2906 if (!init_reloc_cookie_for_section (&cookie
, info
, sec
))
2910 for (; cookie
.rel
< cookie
.relend
; cookie
.rel
++)
2912 if (!_bfd_coff_gc_mark_reloc (info
, sec
, gc_mark_hook
, &cookie
))
2918 fini_reloc_cookie_for_section (&cookie
, sec
);
2926 _bfd_coff_gc_mark_extra_sections (struct bfd_link_info
*info
,
2927 coff_gc_mark_hook_fn mark_hook ATTRIBUTE_UNUSED
)
2931 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
2934 bfd_boolean some_kept
;
2936 if (bfd_get_flavour (ibfd
) != bfd_target_coff_flavour
)
2939 /* Ensure all linker created sections are kept, and see whether
2940 any other section is already marked. */
2942 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
2944 if ((isec
->flags
& SEC_LINKER_CREATED
) != 0)
2946 else if (isec
->gc_mark
)
2950 /* If no section in this file will be kept, then we can
2951 toss out debug sections. */
2955 /* Keep debug and special sections like .comment when they are
2956 not part of a group, or when we have single-member groups. */
2957 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
2958 if ((isec
->flags
& SEC_DEBUGGING
) != 0
2959 || (isec
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0)
2965 /* Sweep symbols in swept sections. Called via coff_link_hash_traverse. */
2968 coff_gc_sweep_symbol (struct coff_link_hash_entry
*h
,
2969 void *data ATTRIBUTE_UNUSED
)
2971 if (h
->root
.type
== bfd_link_hash_warning
)
2972 h
= (struct coff_link_hash_entry
*) h
->root
.u
.i
.link
;
2974 if ((h
->root
.type
== bfd_link_hash_defined
2975 || h
->root
.type
== bfd_link_hash_defweak
)
2976 && !h
->root
.u
.def
.section
->gc_mark
2977 && !(h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
))
2979 /* Do our best to hide the symbol. */
2980 h
->root
.u
.def
.section
= bfd_und_section_ptr
;
2981 h
->symbol_class
= C_HIDDEN
;
2987 /* The sweep phase of garbage collection. Remove all garbage sections. */
2989 typedef bfd_boolean (*gc_sweep_hook_fn
)
2990 (bfd
*, struct bfd_link_info
*, asection
*, const struct internal_reloc
*);
2993 coff_gc_sweep (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
2997 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3001 if (bfd_get_flavour (sub
) != bfd_target_coff_flavour
)
3004 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3006 /* Keep debug and special sections. */
3007 if ((o
->flags
& (SEC_DEBUGGING
| SEC_LINKER_CREATED
)) != 0
3008 || (o
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0)
3010 else if (CONST_STRNEQ (o
->name
, ".idata")
3011 || CONST_STRNEQ (o
->name
, ".pdata")
3012 || CONST_STRNEQ (o
->name
, ".xdata")
3013 || CONST_STRNEQ (o
->name
, ".rsrc"))
3019 /* Skip sweeping sections already excluded. */
3020 if (o
->flags
& SEC_EXCLUDE
)
3023 /* Since this is early in the link process, it is simple
3024 to remove a section from the output. */
3025 o
->flags
|= SEC_EXCLUDE
;
3027 if (info
->print_gc_sections
&& o
->size
!= 0)
3028 /* xgettext: c-format */
3029 _bfd_error_handler (_("removing unused section '%pA' in file '%pB'"),
3033 /* But we also have to update some of the relocation
3034 info we collected before. */
3036 && (o
->flags
& SEC_RELOC
) != 0
3037 && o
->reloc_count
> 0
3038 && !bfd_is_abs_section (o
->output_section
))
3040 struct internal_reloc
*internal_relocs
;
3044 = _bfd_coff_link_read_relocs (o
->owner
, o
, NULL
, NULL
,
3046 if (internal_relocs
== NULL
)
3049 r
= (*gc_sweep_hook
) (o
->owner
, info
, o
, internal_relocs
);
3051 if (coff_section_data (o
)->relocs
!= internal_relocs
)
3052 free (internal_relocs
);
3061 /* Remove the symbols that were in the swept sections from the dynamic
3063 coff_link_hash_traverse (coff_hash_table (info
), coff_gc_sweep_symbol
,
3069 /* Keep all sections containing symbols undefined on the command-line,
3070 and the section containing the entry symbol. */
3073 _bfd_coff_gc_keep (struct bfd_link_info
*info
)
3075 struct bfd_sym_chain
*sym
;
3077 for (sym
= info
->gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
3079 struct coff_link_hash_entry
*h
;
3081 h
= coff_link_hash_lookup (coff_hash_table (info
), sym
->name
,
3082 FALSE
, FALSE
, FALSE
);
3085 && (h
->root
.type
== bfd_link_hash_defined
3086 || h
->root
.type
== bfd_link_hash_defweak
)
3087 && !bfd_is_abs_section (h
->root
.u
.def
.section
))
3088 h
->root
.u
.def
.section
->flags
|= SEC_KEEP
;
3092 /* Do mark and sweep of unused sections. */
3095 bfd_coff_gc_sections (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
3099 /* FIXME: Should we implement this? */
3101 const bfd_coff_backend_data
*bed
= coff_backend_info (abfd
);
3103 if (!bed
->can_gc_sections
3104 || !is_coff_hash_table (info
->hash
))
3106 _bfd_error_handler(_("warning: gc-sections option ignored"));
3111 _bfd_coff_gc_keep (info
);
3113 /* Grovel through relocs to find out who stays ... */
3114 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3118 if (bfd_get_flavour (sub
) != bfd_target_coff_flavour
)
3121 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3123 if (((o
->flags
& (SEC_EXCLUDE
| SEC_KEEP
)) == SEC_KEEP
3124 || CONST_STRNEQ (o
->name
, ".vectors")
3125 || CONST_STRNEQ (o
->name
, ".ctors")
3126 || CONST_STRNEQ (o
->name
, ".dtors"))
3129 if (!_bfd_coff_gc_mark (info
, o
, _bfd_coff_gc_mark_hook
))
3135 /* Allow the backend to mark additional target specific sections. */
3136 _bfd_coff_gc_mark_extra_sections (info
, _bfd_coff_gc_mark_hook
);
3138 /* ... and mark SEC_EXCLUDE for those that go. */
3139 return coff_gc_sweep (abfd
, info
);