1 /* Support for the generic parts of COFF, for BFD.
2 Copyright (C) 1990-2017 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 (_("%B: 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 (_("%B: 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)
1552 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
=
1553 table_base
+ auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
1554 auxent
->fix_end
= 1;
1556 /* A negative tagndx is meaningless, but the SCO 3.2v4 cc can
1557 generate one, so we must be careful to ignore it. */
1558 if (auxent
->u
.auxent
.x_sym
.x_tagndx
.l
> 0)
1560 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
=
1561 table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
;
1562 auxent
->fix_tag
= 1;
1566 /* Allocate space for the ".debug" section, and read it.
1567 We did not read the debug section until now, because
1568 we didn't want to go to the trouble until someone needed it. */
1571 build_debug_section (bfd
*abfd
, asection
** sect_return
)
1573 char *debug_section
;
1575 bfd_size_type sec_size
;
1577 asection
*sect
= bfd_get_section_by_name (abfd
, ".debug");
1581 bfd_set_error (bfd_error_no_debug_section
);
1585 sec_size
= sect
->size
;
1586 debug_section
= (char *) bfd_alloc (abfd
, sec_size
);
1587 if (debug_section
== NULL
)
1590 /* Seek to the beginning of the `.debug' section and read it.
1591 Save the current position first; it is needed by our caller.
1592 Then read debug section and reset the file pointer. */
1594 position
= bfd_tell (abfd
);
1595 if (bfd_seek (abfd
, sect
->filepos
, SEEK_SET
) != 0
1596 || bfd_bread (debug_section
, sec_size
, abfd
) != sec_size
1597 || bfd_seek (abfd
, position
, SEEK_SET
) != 0)
1600 * sect_return
= sect
;
1601 return debug_section
;
1604 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
1605 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
1606 be \0-terminated. */
1609 copy_name (bfd
*abfd
, char *name
, size_t maxlen
)
1614 for (len
= 0; len
< maxlen
; ++len
)
1615 if (name
[len
] == '\0')
1618 if ((newname
= (char *) bfd_alloc (abfd
, (bfd_size_type
) len
+ 1)) == NULL
)
1621 strncpy (newname
, name
, len
);
1622 newname
[len
] = '\0';
1626 /* Read in the external symbols. */
1629 _bfd_coff_get_external_symbols (bfd
*abfd
)
1631 bfd_size_type symesz
;
1635 if (obj_coff_external_syms (abfd
) != NULL
)
1638 symesz
= bfd_coff_symesz (abfd
);
1640 size
= obj_raw_syment_count (abfd
) * symesz
;
1644 syms
= bfd_malloc (size
);
1647 /* PR 21013: Provide an error message when the alloc fails. */
1648 _bfd_error_handler (_("%B: Not enough memory to allocate space for %Lu symbols"),
1653 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
1654 || bfd_bread (syms
, size
, abfd
) != size
)
1661 obj_coff_external_syms (abfd
) = syms
;
1665 /* Read in the external strings. The strings are not loaded until
1666 they are needed. This is because we have no simple way of
1667 detecting a missing string table in an archive. If the strings
1668 are loaded then the STRINGS and STRINGS_LEN fields in the
1669 coff_tdata structure will be set. */
1672 _bfd_coff_read_string_table (bfd
*abfd
)
1674 char extstrsize
[STRING_SIZE_SIZE
];
1675 bfd_size_type strsize
;
1679 if (obj_coff_strings (abfd
) != NULL
)
1680 return obj_coff_strings (abfd
);
1682 if (obj_sym_filepos (abfd
) == 0)
1684 bfd_set_error (bfd_error_no_symbols
);
1688 pos
= obj_sym_filepos (abfd
);
1689 pos
+= obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
1690 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
1693 if (bfd_bread (extstrsize
, (bfd_size_type
) sizeof extstrsize
, abfd
)
1694 != sizeof extstrsize
)
1696 if (bfd_get_error () != bfd_error_file_truncated
)
1699 /* There is no string table. */
1700 strsize
= STRING_SIZE_SIZE
;
1704 #if STRING_SIZE_SIZE == 4
1705 strsize
= H_GET_32 (abfd
, extstrsize
);
1707 #error Change H_GET_32
1711 if (strsize
< STRING_SIZE_SIZE
)
1714 /* xgettext: c-format */
1715 (_("%B: bad string table size %Lu"), abfd
, strsize
);
1716 bfd_set_error (bfd_error_bad_value
);
1720 strings
= (char *) bfd_malloc (strsize
+ 1);
1721 if (strings
== NULL
)
1724 /* PR 17521 file: 079-54929-0.004.
1725 A corrupt file could contain an index that points into the first
1726 STRING_SIZE_SIZE bytes of the string table, so make sure that
1728 memset (strings
, 0, STRING_SIZE_SIZE
);
1730 if (bfd_bread (strings
+ STRING_SIZE_SIZE
, strsize
- STRING_SIZE_SIZE
, abfd
)
1731 != strsize
- STRING_SIZE_SIZE
)
1737 obj_coff_strings (abfd
) = strings
;
1738 obj_coff_strings_len (abfd
) = strsize
;
1739 /* Terminate the string table, just in case. */
1740 strings
[strsize
] = 0;
1744 /* Free up the external symbols and strings read from a COFF file. */
1747 _bfd_coff_free_symbols (bfd
*abfd
)
1749 if (! bfd_family_coff (abfd
))
1752 if (obj_coff_external_syms (abfd
) != NULL
1753 && ! obj_coff_keep_syms (abfd
))
1755 free (obj_coff_external_syms (abfd
));
1756 obj_coff_external_syms (abfd
) = NULL
;
1759 if (obj_coff_strings (abfd
) != NULL
1760 && ! obj_coff_keep_strings (abfd
))
1762 free (obj_coff_strings (abfd
));
1763 obj_coff_strings (abfd
) = NULL
;
1764 obj_coff_strings_len (abfd
) = 0;
1770 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
1771 knit the symbol names into a normalized form. By normalized here I
1772 mean that all symbols have an n_offset pointer that points to a null-
1773 terminated string. */
1775 combined_entry_type
*
1776 coff_get_normalized_symtab (bfd
*abfd
)
1778 combined_entry_type
*internal
;
1779 combined_entry_type
*internal_ptr
;
1780 combined_entry_type
*symbol_ptr
;
1781 combined_entry_type
*internal_end
;
1785 const char *string_table
= NULL
;
1786 asection
* debug_sec
= NULL
;
1787 char *debug_sec_data
= NULL
;
1790 if (obj_raw_syments (abfd
) != NULL
)
1791 return obj_raw_syments (abfd
);
1793 if (! _bfd_coff_get_external_symbols (abfd
))
1796 size
= obj_raw_syment_count (abfd
) * sizeof (combined_entry_type
);
1797 internal
= (combined_entry_type
*) bfd_zalloc (abfd
, size
);
1798 if (internal
== NULL
&& size
!= 0)
1800 internal_end
= internal
+ obj_raw_syment_count (abfd
);
1802 raw_src
= (char *) obj_coff_external_syms (abfd
);
1804 /* Mark the end of the symbols. */
1805 symesz
= bfd_coff_symesz (abfd
);
1806 raw_end
= (char *) raw_src
+ obj_raw_syment_count (abfd
) * symesz
;
1808 /* FIXME SOMEDAY. A string table size of zero is very weird, but
1809 probably possible. If one shows up, it will probably kill us. */
1811 /* Swap all the raw entries. */
1812 for (internal_ptr
= internal
;
1814 raw_src
+= symesz
, internal_ptr
++)
1818 bfd_coff_swap_sym_in (abfd
, (void *) raw_src
,
1819 (void *) & internal_ptr
->u
.syment
);
1820 symbol_ptr
= internal_ptr
;
1821 internal_ptr
->is_sym
= TRUE
;
1823 /* PR 17512: file: 1353-1166-0.004. */
1824 if (symbol_ptr
->u
.syment
.n_sclass
== C_FILE
1825 && symbol_ptr
->u
.syment
.n_numaux
> 0
1826 && raw_src
+ symesz
+ symbol_ptr
->u
.syment
.n_numaux
1829 bfd_release (abfd
, internal
);
1834 i
< symbol_ptr
->u
.syment
.n_numaux
;
1838 /* PR 17512: Prevent buffer overrun. */
1839 if (internal_ptr
>= internal_end
)
1841 bfd_release (abfd
, internal
);
1846 bfd_coff_swap_aux_in (abfd
, (void *) raw_src
,
1847 symbol_ptr
->u
.syment
.n_type
,
1848 symbol_ptr
->u
.syment
.n_sclass
,
1849 (int) i
, symbol_ptr
->u
.syment
.n_numaux
,
1850 &(internal_ptr
->u
.auxent
));
1852 internal_ptr
->is_sym
= FALSE
;
1853 coff_pointerize_aux (abfd
, internal
, symbol_ptr
, i
,
1858 /* Free the raw symbols, but not the strings (if we have them). */
1859 obj_coff_keep_strings (abfd
) = TRUE
;
1860 if (! _bfd_coff_free_symbols (abfd
))
1863 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
1866 BFD_ASSERT (internal_ptr
->is_sym
);
1868 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
1869 && internal_ptr
->u
.syment
.n_numaux
> 0)
1871 combined_entry_type
* aux
= internal_ptr
+ 1;
1873 /* Make a file symbol point to the name in the auxent, since
1874 the text ".file" is redundant. */
1875 BFD_ASSERT (! aux
->is_sym
);
1877 if (aux
->u
.auxent
.x_file
.x_n
.x_zeroes
== 0)
1879 /* The filename is a long one, point into the string table. */
1880 if (string_table
== NULL
)
1882 string_table
= _bfd_coff_read_string_table (abfd
);
1883 if (string_table
== NULL
)
1887 if ((bfd_size_type
)(aux
->u
.auxent
.x_file
.x_n
.x_offset
)
1888 >= obj_coff_strings_len (abfd
))
1889 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1891 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1892 (bfd_hostptr_t
) (string_table
+ (aux
->u
.auxent
.x_file
.x_n
.x_offset
));
1896 /* Ordinary short filename, put into memory anyway. The
1897 Microsoft PE tools sometimes store a filename in
1898 multiple AUX entries. */
1899 if (internal_ptr
->u
.syment
.n_numaux
> 1
1900 && coff_data (abfd
)->pe
)
1901 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1904 aux
->u
.auxent
.x_file
.x_fname
,
1905 internal_ptr
->u
.syment
.n_numaux
* symesz
);
1907 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1910 aux
->u
.auxent
.x_file
.x_fname
,
1911 (size_t) bfd_coff_filnmlen (abfd
)));
1916 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0)
1918 /* This is a "short" name. Make it long. */
1922 /* Find the length of this string without walking into memory
1924 for (i
= 0; i
< 8; ++i
)
1925 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0')
1928 newstring
= (char *) bfd_zalloc (abfd
, (bfd_size_type
) (i
+ 1));
1929 if (newstring
== NULL
)
1931 strncpy (newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
);
1932 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) newstring
;
1933 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1935 else if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
== 0)
1936 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) "";
1937 else if (!bfd_coff_symname_in_debug (abfd
, &internal_ptr
->u
.syment
))
1939 /* Long name already. Point symbol at the string in the
1941 if (string_table
== NULL
)
1943 string_table
= _bfd_coff_read_string_table (abfd
);
1944 if (string_table
== NULL
)
1947 if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
>= obj_coff_strings_len (abfd
)
1948 || string_table
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
< string_table
)
1949 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1951 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1954 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
));
1958 /* Long name in debug section. Very similar. */
1959 if (debug_sec_data
== NULL
)
1960 debug_sec_data
= build_debug_section (abfd
, & debug_sec
);
1961 if (debug_sec_data
!= NULL
)
1963 BFD_ASSERT (debug_sec
!= NULL
);
1964 /* PR binutils/17512: Catch out of range offsets into the debug data. */
1965 if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
> debug_sec
->size
1966 || debug_sec_data
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
< debug_sec_data
)
1967 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1969 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
)
1970 (debug_sec_data
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
1973 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) "";
1976 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
1979 obj_raw_syments (abfd
) = internal
;
1980 BFD_ASSERT (obj_raw_syment_count (abfd
)
1981 == (unsigned int) (internal_ptr
- internal
));
1987 coff_get_reloc_upper_bound (bfd
*abfd
, sec_ptr asect
)
1989 if (bfd_get_format (abfd
) != bfd_object
)
1991 bfd_set_error (bfd_error_invalid_operation
);
1994 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
1998 coff_make_empty_symbol (bfd
*abfd
)
2000 bfd_size_type amt
= sizeof (coff_symbol_type
);
2001 coff_symbol_type
*new_symbol
= (coff_symbol_type
*) bfd_zalloc (abfd
, amt
);
2003 if (new_symbol
== NULL
)
2005 new_symbol
->symbol
.section
= 0;
2006 new_symbol
->native
= NULL
;
2007 new_symbol
->lineno
= NULL
;
2008 new_symbol
->done_lineno
= FALSE
;
2009 new_symbol
->symbol
.the_bfd
= abfd
;
2011 return & new_symbol
->symbol
;
2014 /* Make a debugging symbol. */
2017 coff_bfd_make_debug_symbol (bfd
*abfd
,
2018 void * ptr ATTRIBUTE_UNUSED
,
2019 unsigned long sz ATTRIBUTE_UNUSED
)
2021 bfd_size_type amt
= sizeof (coff_symbol_type
);
2022 coff_symbol_type
*new_symbol
= (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
2024 if (new_symbol
== NULL
)
2026 /* @@ The 10 is a guess at a plausible maximum number of aux entries
2027 (but shouldn't be a constant). */
2028 amt
= sizeof (combined_entry_type
) * 10;
2029 new_symbol
->native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
2030 if (!new_symbol
->native
)
2032 new_symbol
->native
->is_sym
= TRUE
;
2033 new_symbol
->symbol
.section
= bfd_abs_section_ptr
;
2034 new_symbol
->symbol
.flags
= BSF_DEBUGGING
;
2035 new_symbol
->lineno
= NULL
;
2036 new_symbol
->done_lineno
= FALSE
;
2037 new_symbol
->symbol
.the_bfd
= abfd
;
2039 return & new_symbol
->symbol
;
2043 coff_get_symbol_info (bfd
*abfd
, asymbol
*symbol
, symbol_info
*ret
)
2045 bfd_symbol_info (symbol
, ret
);
2047 if (coffsymbol (symbol
)->native
!= NULL
2048 && coffsymbol (symbol
)->native
->fix_value
2049 && coffsymbol (symbol
)->native
->is_sym
)
2050 ret
->value
= coffsymbol (symbol
)->native
->u
.syment
.n_value
-
2051 (bfd_hostptr_t
) obj_raw_syments (abfd
);
2054 /* Print out information about COFF symbol. */
2057 coff_print_symbol (bfd
*abfd
,
2060 bfd_print_symbol_type how
)
2062 FILE * file
= (FILE *) filep
;
2066 case bfd_print_symbol_name
:
2067 fprintf (file
, "%s", symbol
->name
);
2070 case bfd_print_symbol_more
:
2071 fprintf (file
, "coff %s %s",
2072 coffsymbol (symbol
)->native
? "n" : "g",
2073 coffsymbol (symbol
)->lineno
? "l" : " ");
2076 case bfd_print_symbol_all
:
2077 if (coffsymbol (symbol
)->native
)
2081 combined_entry_type
*combined
= coffsymbol (symbol
)->native
;
2082 combined_entry_type
*root
= obj_raw_syments (abfd
);
2083 struct lineno_cache_entry
*l
= coffsymbol (symbol
)->lineno
;
2085 fprintf (file
, "[%3ld]", (long) (combined
- root
));
2087 /* PR 17512: file: 079-33786-0.001:0.1. */
2088 if (combined
< obj_raw_syments (abfd
)
2089 || combined
>= obj_raw_syments (abfd
) + obj_raw_syment_count (abfd
))
2091 fprintf (file
, _("<corrupt info> %s"), symbol
->name
);
2095 BFD_ASSERT (combined
->is_sym
);
2096 if (! combined
->fix_value
)
2097 val
= (bfd_vma
) combined
->u
.syment
.n_value
;
2099 val
= combined
->u
.syment
.n_value
- (bfd_hostptr_t
) root
;
2101 fprintf (file
, "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x",
2102 combined
->u
.syment
.n_scnum
,
2103 combined
->u
.syment
.n_flags
,
2104 combined
->u
.syment
.n_type
,
2105 combined
->u
.syment
.n_sclass
,
2106 combined
->u
.syment
.n_numaux
);
2107 bfd_fprintf_vma (abfd
, file
, val
);
2108 fprintf (file
, " %s", symbol
->name
);
2110 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
2112 combined_entry_type
*auxp
= combined
+ aux
+ 1;
2115 BFD_ASSERT (! auxp
->is_sym
);
2117 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.p
- root
;
2119 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.l
;
2121 fprintf (file
, "\n");
2123 if (bfd_coff_print_aux (abfd
, file
, root
, combined
, auxp
, aux
))
2126 switch (combined
->u
.syment
.n_sclass
)
2129 fprintf (file
, "File ");
2133 if (combined
->u
.syment
.n_type
== T_NULL
)
2134 /* Probably a section symbol ? */
2136 fprintf (file
, "AUX scnlen 0x%lx nreloc %d nlnno %d",
2137 (unsigned long) auxp
->u
.auxent
.x_scn
.x_scnlen
,
2138 auxp
->u
.auxent
.x_scn
.x_nreloc
,
2139 auxp
->u
.auxent
.x_scn
.x_nlinno
);
2140 if (auxp
->u
.auxent
.x_scn
.x_checksum
!= 0
2141 || auxp
->u
.auxent
.x_scn
.x_associated
!= 0
2142 || auxp
->u
.auxent
.x_scn
.x_comdat
!= 0)
2143 fprintf (file
, " checksum 0x%lx assoc %d comdat %d",
2144 auxp
->u
.auxent
.x_scn
.x_checksum
,
2145 auxp
->u
.auxent
.x_scn
.x_associated
,
2146 auxp
->u
.auxent
.x_scn
.x_comdat
);
2152 if (ISFCN (combined
->u
.syment
.n_type
))
2157 next
= (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2160 next
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2161 llnos
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
2163 "AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld",
2165 (unsigned long) auxp
->u
.auxent
.x_sym
.x_misc
.x_fsize
,
2171 fprintf (file
, "AUX lnno %d size 0x%x tagndx %ld",
2172 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
2173 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
,
2176 fprintf (file
, " endndx %ld",
2178 (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2186 fprintf (file
, "\n%s :", l
->u
.sym
->name
);
2188 while (l
->line_number
)
2190 if (l
->line_number
> 0)
2192 fprintf (file
, "\n%4d : ", l
->line_number
);
2193 bfd_fprintf_vma (abfd
, file
, l
->u
.offset
+ symbol
->section
->vma
);
2201 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
2202 fprintf (file
, " %-5s %s %s %s",
2203 symbol
->section
->name
,
2204 coffsymbol (symbol
)->native
? "n" : "g",
2205 coffsymbol (symbol
)->lineno
? "l" : " ",
2211 /* Return whether a symbol name implies a local symbol. In COFF,
2212 local symbols generally start with ``.L''. Most targets use this
2213 function for the is_local_label_name entry point, but some may
2217 _bfd_coff_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
2220 return name
[0] == '.' && name
[1] == 'L';
2223 /* Provided a BFD, a section and an offset (in bytes, not octets) into the
2224 section, calculate and return the name of the source file and the line
2225 nearest to the wanted location. */
2228 coff_find_nearest_line_with_names (bfd
*abfd
,
2232 const char **filename_ptr
,
2233 const char **functionname_ptr
,
2234 unsigned int *line_ptr
,
2235 const struct dwarf_debug_section
*debug_sections
)
2239 unsigned int line_base
;
2240 coff_data_type
*cof
= coff_data (abfd
);
2241 /* Run through the raw syments if available. */
2242 combined_entry_type
*p
;
2243 combined_entry_type
*pend
;
2245 struct coff_section_tdata
*sec_data
;
2248 /* Before looking through the symbol table, try to use a .stab
2249 section to find the information. */
2250 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2251 &found
, filename_ptr
,
2252 functionname_ptr
, line_ptr
,
2253 &coff_data(abfd
)->line_info
))
2259 /* Also try examining DWARF2 debugging information. */
2260 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
2261 filename_ptr
, functionname_ptr
,
2262 line_ptr
, NULL
, debug_sections
, 0,
2263 &coff_data(abfd
)->dwarf2_find_line_info
))
2266 sec_data
= coff_section_data (abfd
, section
);
2268 /* If the DWARF lookup failed, but there is DWARF information available
2269 then the problem might be that the file has been rebased. This tool
2270 changes the VMAs of all the sections, but it does not update the DWARF
2271 information. So try again, using a bias against the address sought. */
2272 if (coff_data (abfd
)->dwarf2_find_line_info
!= NULL
)
2274 bfd_signed_vma bias
;
2276 /* Create a cache of the result for the next call. */
2277 if (sec_data
== NULL
&& section
->owner
== abfd
)
2279 amt
= sizeof (struct coff_section_tdata
);
2280 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
2281 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2284 if (sec_data
!= NULL
&& sec_data
->saved_bias
)
2285 bias
= sec_data
->saved_bias
;
2288 bias
= _bfd_dwarf2_find_symbol_bias (symbols
,
2289 & coff_data (abfd
)->dwarf2_find_line_info
);
2292 sec_data
->saved_bias
= TRUE
;
2293 sec_data
->bias
= bias
;
2298 && _bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
,
2300 filename_ptr
, functionname_ptr
,
2301 line_ptr
, NULL
, debug_sections
, 0,
2302 &coff_data(abfd
)->dwarf2_find_line_info
))
2307 *functionname_ptr
= 0;
2310 /* Don't try and find line numbers in a non coff file. */
2311 if (!bfd_family_coff (abfd
))
2317 /* Find the first C_FILE symbol. */
2318 p
= cof
->raw_syments
;
2322 pend
= p
+ cof
->raw_syment_count
;
2325 BFD_ASSERT (p
->is_sym
);
2326 if (p
->u
.syment
.n_sclass
== C_FILE
)
2328 p
+= 1 + p
->u
.syment
.n_numaux
;
2336 /* Look through the C_FILE symbols to find the best one. */
2337 sec_vma
= bfd_get_section_vma (abfd
, section
);
2338 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2339 maxdiff
= (bfd_vma
) 0 - (bfd_vma
) 1;
2343 combined_entry_type
*p2
;
2345 for (p2
= p
+ 1 + p
->u
.syment
.n_numaux
;
2347 p2
+= 1 + p2
->u
.syment
.n_numaux
)
2349 BFD_ASSERT (p2
->is_sym
);
2350 if (p2
->u
.syment
.n_scnum
> 0
2352 == coff_section_from_bfd_index (abfd
,
2353 p2
->u
.syment
.n_scnum
)))
2355 if (p2
->u
.syment
.n_sclass
== C_FILE
)
2364 file_addr
= (bfd_vma
) p2
->u
.syment
.n_value
;
2365 /* PR 11512: Include the section address of the function name symbol. */
2366 if (p2
->u
.syment
.n_scnum
> 0)
2367 file_addr
+= coff_section_from_bfd_index (abfd
,
2368 p2
->u
.syment
.n_scnum
)->vma
;
2369 /* We use <= MAXDIFF here so that if we get a zero length
2370 file, we actually use the next file entry. */
2372 && offset
+ sec_vma
>= file_addr
2373 && offset
+ sec_vma
- file_addr
<= maxdiff
)
2375 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2376 maxdiff
= offset
+ sec_vma
- p2
->u
.syment
.n_value
;
2379 /* Avoid endless loops on erroneous files by ensuring that
2380 we always move forward in the file. */
2381 if (p
>= cof
->raw_syments
+ p
->u
.syment
.n_value
)
2384 p
= cof
->raw_syments
+ p
->u
.syment
.n_value
;
2385 if (p
> pend
|| p
->u
.syment
.n_sclass
!= C_FILE
)
2390 if (section
->lineno_count
== 0)
2392 *functionname_ptr
= NULL
;
2397 /* Now wander though the raw linenumbers of the section.
2398 If we have been called on this section before, and the offset
2399 we want is further down then we can prime the lookup loop. */
2400 if (sec_data
!= NULL
2402 && offset
>= sec_data
->offset
)
2405 *functionname_ptr
= sec_data
->function
;
2406 line_base
= sec_data
->line_base
;
2414 if (section
->lineno
!= NULL
)
2416 bfd_vma last_value
= 0;
2418 l
= §ion
->lineno
[i
];
2420 for (; i
< section
->lineno_count
; i
++)
2422 if (l
->line_number
== 0)
2424 /* Get the symbol this line number points at. */
2425 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
2426 if (coff
->symbol
.value
> offset
)
2429 *functionname_ptr
= coff
->symbol
.name
;
2430 last_value
= coff
->symbol
.value
;
2433 combined_entry_type
*s
= coff
->native
;
2435 BFD_ASSERT (s
->is_sym
);
2436 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2438 /* In XCOFF a debugging symbol can follow the
2440 if (s
->u
.syment
.n_scnum
== N_DEBUG
)
2441 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2443 /* S should now point to the .bf of the function. */
2444 if (s
->u
.syment
.n_numaux
)
2446 /* The linenumber is stored in the auxent. */
2447 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
2449 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
2450 *line_ptr
= line_base
;
2456 if (l
->u
.offset
> offset
)
2458 *line_ptr
= l
->line_number
+ line_base
- 1;
2463 /* If we fell off the end of the loop, then assume that this
2464 symbol has no line number info. Otherwise, symbols with no
2465 line number info get reported with the line number of the
2466 last line of the last symbol which does have line number
2467 info. We use 0x100 as a slop to account for cases where the
2468 last line has executable code. */
2469 if (i
>= section
->lineno_count
2471 && offset
- last_value
> 0x100)
2473 *functionname_ptr
= NULL
;
2478 /* Cache the results for the next call. */
2479 if (sec_data
== NULL
&& section
->owner
== abfd
)
2481 amt
= sizeof (struct coff_section_tdata
);
2482 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
2483 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2486 if (sec_data
!= NULL
)
2488 sec_data
->offset
= offset
;
2489 sec_data
->i
= i
- 1;
2490 sec_data
->function
= *functionname_ptr
;
2491 sec_data
->line_base
= line_base
;
2498 coff_find_nearest_line (bfd
*abfd
,
2502 const char **filename_ptr
,
2503 const char **functionname_ptr
,
2504 unsigned int *line_ptr
,
2505 unsigned int *discriminator_ptr
)
2507 if (discriminator_ptr
)
2508 *discriminator_ptr
= 0;
2509 return coff_find_nearest_line_with_names (abfd
, symbols
, section
, offset
,
2510 filename_ptr
, functionname_ptr
,
2511 line_ptr
, dwarf_debug_sections
);
2515 coff_find_inliner_info (bfd
*abfd
,
2516 const char **filename_ptr
,
2517 const char **functionname_ptr
,
2518 unsigned int *line_ptr
)
2522 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
2523 functionname_ptr
, line_ptr
,
2524 &coff_data(abfd
)->dwarf2_find_line_info
);
2529 coff_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
2533 if (!bfd_link_relocatable (info
))
2534 size
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
2536 size
= bfd_coff_filhsz (abfd
);
2538 size
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
2542 /* Change the class of a coff symbol held by BFD. */
2545 bfd_coff_set_symbol_class (bfd
* abfd
,
2547 unsigned int symbol_class
)
2549 coff_symbol_type
* csym
;
2551 csym
= coff_symbol_from (symbol
);
2554 bfd_set_error (bfd_error_invalid_operation
);
2557 else if (csym
->native
== NULL
)
2559 /* This is an alien symbol which no native coff backend data.
2560 We cheat here by creating a fake native entry for it and
2561 then filling in the class. This code is based on that in
2562 coff_write_alien_symbol(). */
2564 combined_entry_type
* native
;
2565 bfd_size_type amt
= sizeof (* native
);
2567 native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
2571 native
->is_sym
= TRUE
;
2572 native
->u
.syment
.n_type
= T_NULL
;
2573 native
->u
.syment
.n_sclass
= symbol_class
;
2575 if (bfd_is_und_section (symbol
->section
))
2577 native
->u
.syment
.n_scnum
= N_UNDEF
;
2578 native
->u
.syment
.n_value
= symbol
->value
;
2580 else if (bfd_is_com_section (symbol
->section
))
2582 native
->u
.syment
.n_scnum
= N_UNDEF
;
2583 native
->u
.syment
.n_value
= symbol
->value
;
2587 native
->u
.syment
.n_scnum
=
2588 symbol
->section
->output_section
->target_index
;
2589 native
->u
.syment
.n_value
= (symbol
->value
2590 + symbol
->section
->output_offset
);
2591 if (! obj_pe (abfd
))
2592 native
->u
.syment
.n_value
+= symbol
->section
->output_section
->vma
;
2594 /* Copy the any flags from the file header into the symbol.
2596 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (& csym
->symbol
)->flags
;
2599 csym
->native
= native
;
2602 csym
->native
->u
.syment
.n_sclass
= symbol_class
;
2608 _bfd_coff_section_already_linked (bfd
*abfd
,
2610 struct bfd_link_info
*info
)
2613 const char *name
, *key
;
2614 struct bfd_section_already_linked
*l
;
2615 struct bfd_section_already_linked_hash_entry
*already_linked_list
;
2616 struct coff_comdat_info
*s_comdat
;
2619 if ((flags
& SEC_LINK_ONCE
) == 0)
2622 /* The COFF backend linker doesn't support group sections. */
2623 if ((flags
& SEC_GROUP
) != 0)
2626 name
= bfd_get_section_name (abfd
, sec
);
2627 s_comdat
= bfd_coff_get_comdat_section (abfd
, sec
);
2629 if (s_comdat
!= NULL
)
2630 key
= s_comdat
->name
;
2633 if (CONST_STRNEQ (name
, ".gnu.linkonce.")
2634 && (key
= strchr (name
+ sizeof (".gnu.linkonce.") - 1, '.')) != NULL
)
2637 /* FIXME: gcc as of 2011-09 emits sections like .text$<key>,
2638 .xdata$<key> and .pdata$<key> only the first of which has a
2639 comdat key. Should these all match the LTO IR key? */
2643 already_linked_list
= bfd_section_already_linked_table_lookup (key
);
2645 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
2647 struct coff_comdat_info
*l_comdat
;
2649 l_comdat
= bfd_coff_get_comdat_section (l
->sec
->owner
, l
->sec
);
2651 /* The section names must match, and both sections must be
2652 comdat and have the same comdat name, or both sections must
2653 be non-comdat. LTO IR plugin sections are an exception. They
2654 are always named .gnu.linkonce.t.<key> (<key> is some string)
2655 and match any comdat section with comdat name of <key>, and
2656 any linkonce section with the same suffix, ie.
2657 .gnu.linkonce.*.<key>. */
2658 if (((s_comdat
!= NULL
) == (l_comdat
!= NULL
)
2659 && strcmp (name
, l
->sec
->name
) == 0)
2660 || (l
->sec
->owner
->flags
& BFD_PLUGIN
) != 0)
2662 /* The section has already been linked. See if we should
2664 return _bfd_handle_already_linked (sec
, l
, info
);
2668 /* This is the first section with this name. Record it. */
2669 if (!bfd_section_already_linked_table_insert (already_linked_list
, sec
))
2670 info
->callbacks
->einfo (_("%F%P: already_linked_table: %E\n"));
2674 /* Initialize COOKIE for input bfd ABFD. */
2677 init_reloc_cookie (struct coff_reloc_cookie
*cookie
,
2678 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2681 /* Sometimes the symbol table does not yet have been loaded here. */
2682 bfd_coff_slurp_symbol_table (abfd
);
2684 cookie
->abfd
= abfd
;
2685 cookie
->sym_hashes
= obj_coff_sym_hashes (abfd
);
2687 cookie
->symbols
= obj_symbols (abfd
);
2692 /* Free the memory allocated by init_reloc_cookie, if appropriate. */
2695 fini_reloc_cookie (struct coff_reloc_cookie
*cookie ATTRIBUTE_UNUSED
,
2696 bfd
*abfd ATTRIBUTE_UNUSED
)
2698 /* Nothing to do. */
2701 /* Initialize the relocation information in COOKIE for input section SEC
2702 of input bfd ABFD. */
2705 init_reloc_cookie_rels (struct coff_reloc_cookie
*cookie
,
2706 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2710 if (sec
->reloc_count
== 0)
2712 cookie
->rels
= NULL
;
2713 cookie
->relend
= NULL
;
2718 cookie
->rels
= _bfd_coff_read_internal_relocs (abfd
, sec
, FALSE
, NULL
, 0, NULL
);
2720 if (cookie
->rels
== NULL
)
2723 cookie
->rel
= cookie
->rels
;
2724 cookie
->relend
= (cookie
->rels
+ sec
->reloc_count
);
2728 /* Free the memory allocated by init_reloc_cookie_rels,
2732 fini_reloc_cookie_rels (struct coff_reloc_cookie
*cookie
,
2736 /* PR 20401. The relocs may not have been cached, so check first.
2737 If the relocs were loaded by init_reloc_cookie_rels() then this
2738 will be the case. FIXME: Would performance be improved if the
2739 relocs *were* cached ? */
2740 && coff_section_data (NULL
, sec
)
2741 && coff_section_data (NULL
, sec
)->relocs
!= cookie
->rels
)
2742 free (cookie
->rels
);
2745 /* Initialize the whole of COOKIE for input section SEC. */
2748 init_reloc_cookie_for_section (struct coff_reloc_cookie
*cookie
,
2749 struct bfd_link_info
*info
,
2752 if (!init_reloc_cookie (cookie
, info
, sec
->owner
))
2755 if (!init_reloc_cookie_rels (cookie
, info
, sec
->owner
, sec
))
2757 fini_reloc_cookie (cookie
, sec
->owner
);
2763 /* Free the memory allocated by init_reloc_cookie_for_section,
2767 fini_reloc_cookie_for_section (struct coff_reloc_cookie
*cookie
,
2770 fini_reloc_cookie_rels (cookie
, sec
);
2771 fini_reloc_cookie (cookie
, sec
->owner
);
2775 _bfd_coff_gc_mark_hook (asection
*sec
,
2776 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2777 struct internal_reloc
*rel ATTRIBUTE_UNUSED
,
2778 struct coff_link_hash_entry
*h
,
2779 struct internal_syment
*sym
)
2783 switch (h
->root
.type
)
2785 case bfd_link_hash_defined
:
2786 case bfd_link_hash_defweak
:
2787 return h
->root
.u
.def
.section
;
2789 case bfd_link_hash_common
:
2790 return h
->root
.u
.c
.p
->section
;
2792 case bfd_link_hash_undefweak
:
2793 if (h
->symbol_class
== C_NT_WEAK
&& h
->numaux
== 1)
2795 /* PE weak externals. A weak symbol may include an auxiliary
2796 record indicating that if the weak symbol is not resolved,
2797 another external symbol is used instead. */
2798 struct coff_link_hash_entry
*h2
=
2799 h
->auxbfd
->tdata
.coff_obj_data
->sym_hashes
[
2800 h
->aux
->x_sym
.x_tagndx
.l
];
2802 if (h2
&& h2
->root
.type
!= bfd_link_hash_undefined
)
2803 return h2
->root
.u
.def
.section
;
2807 case bfd_link_hash_undefined
:
2814 return coff_section_from_bfd_index (sec
->owner
, sym
->n_scnum
);
2817 /* COOKIE->rel describes a relocation against section SEC, which is
2818 a section we've decided to keep. Return the section that contains
2819 the relocation symbol, or NULL if no section contains it. */
2822 _bfd_coff_gc_mark_rsec (struct bfd_link_info
*info
, asection
*sec
,
2823 coff_gc_mark_hook_fn gc_mark_hook
,
2824 struct coff_reloc_cookie
*cookie
)
2826 struct coff_link_hash_entry
*h
;
2828 h
= cookie
->sym_hashes
[cookie
->rel
->r_symndx
];
2831 while (h
->root
.type
== bfd_link_hash_indirect
2832 || h
->root
.type
== bfd_link_hash_warning
)
2833 h
= (struct coff_link_hash_entry
*) h
->root
.u
.i
.link
;
2835 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, h
, NULL
);
2838 return (*gc_mark_hook
) (sec
, info
, cookie
->rel
, NULL
,
2840 + obj_convert (sec
->owner
)[cookie
->rel
->r_symndx
])->native
->u
.syment
);
2843 static bfd_boolean _bfd_coff_gc_mark
2844 (struct bfd_link_info
*, asection
*, coff_gc_mark_hook_fn
);
2846 /* COOKIE->rel describes a relocation against section SEC, which is
2847 a section we've decided to keep. Mark the section that contains
2848 the relocation symbol. */
2851 _bfd_coff_gc_mark_reloc (struct bfd_link_info
*info
,
2853 coff_gc_mark_hook_fn gc_mark_hook
,
2854 struct coff_reloc_cookie
*cookie
)
2858 rsec
= _bfd_coff_gc_mark_rsec (info
, sec
, gc_mark_hook
, cookie
);
2859 if (rsec
&& !rsec
->gc_mark
)
2861 if (bfd_get_flavour (rsec
->owner
) != bfd_target_coff_flavour
)
2863 else if (!_bfd_coff_gc_mark (info
, rsec
, gc_mark_hook
))
2869 /* The mark phase of garbage collection. For a given section, mark
2870 it and any sections in this section's group, and all the sections
2871 which define symbols to which it refers. */
2874 _bfd_coff_gc_mark (struct bfd_link_info
*info
,
2876 coff_gc_mark_hook_fn gc_mark_hook
)
2878 bfd_boolean ret
= TRUE
;
2882 /* Look through the section relocs. */
2883 if ((sec
->flags
& SEC_RELOC
) != 0
2884 && sec
->reloc_count
> 0)
2886 struct coff_reloc_cookie cookie
;
2888 if (!init_reloc_cookie_for_section (&cookie
, info
, sec
))
2892 for (; cookie
.rel
< cookie
.relend
; cookie
.rel
++)
2894 if (!_bfd_coff_gc_mark_reloc (info
, sec
, gc_mark_hook
, &cookie
))
2900 fini_reloc_cookie_for_section (&cookie
, sec
);
2908 _bfd_coff_gc_mark_extra_sections (struct bfd_link_info
*info
,
2909 coff_gc_mark_hook_fn mark_hook ATTRIBUTE_UNUSED
)
2913 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link
.next
)
2916 bfd_boolean some_kept
;
2918 if (bfd_get_flavour (ibfd
) != bfd_target_coff_flavour
)
2921 /* Ensure all linker created sections are kept, and see whether
2922 any other section is already marked. */
2924 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
2926 if ((isec
->flags
& SEC_LINKER_CREATED
) != 0)
2928 else if (isec
->gc_mark
)
2932 /* If no section in this file will be kept, then we can
2933 toss out debug sections. */
2937 /* Keep debug and special sections like .comment when they are
2938 not part of a group, or when we have single-member groups. */
2939 for (isec
= ibfd
->sections
; isec
!= NULL
; isec
= isec
->next
)
2940 if ((isec
->flags
& SEC_DEBUGGING
) != 0
2941 || (isec
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0)
2947 /* Sweep symbols in swept sections. Called via coff_link_hash_traverse. */
2950 coff_gc_sweep_symbol (struct coff_link_hash_entry
*h
,
2951 void *data ATTRIBUTE_UNUSED
)
2953 if (h
->root
.type
== bfd_link_hash_warning
)
2954 h
= (struct coff_link_hash_entry
*) h
->root
.u
.i
.link
;
2956 if ((h
->root
.type
== bfd_link_hash_defined
2957 || h
->root
.type
== bfd_link_hash_defweak
)
2958 && !h
->root
.u
.def
.section
->gc_mark
2959 && !(h
->root
.u
.def
.section
->owner
->flags
& DYNAMIC
))
2961 /* Do our best to hide the symbol. */
2962 h
->root
.u
.def
.section
= bfd_und_section_ptr
;
2963 h
->symbol_class
= C_HIDDEN
;
2969 /* The sweep phase of garbage collection. Remove all garbage sections. */
2971 typedef bfd_boolean (*gc_sweep_hook_fn
)
2972 (bfd
*, struct bfd_link_info
*, asection
*, const struct internal_reloc
*);
2975 coff_gc_sweep (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
2979 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
2983 if (bfd_get_flavour (sub
) != bfd_target_coff_flavour
)
2986 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
2988 /* Keep debug and special sections. */
2989 if ((o
->flags
& (SEC_DEBUGGING
| SEC_LINKER_CREATED
)) != 0
2990 || (o
->flags
& (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
)) == 0)
2992 else if (CONST_STRNEQ (o
->name
, ".idata")
2993 || CONST_STRNEQ (o
->name
, ".pdata")
2994 || CONST_STRNEQ (o
->name
, ".xdata")
2995 || CONST_STRNEQ (o
->name
, ".rsrc"))
3001 /* Skip sweeping sections already excluded. */
3002 if (o
->flags
& SEC_EXCLUDE
)
3005 /* Since this is early in the link process, it is simple
3006 to remove a section from the output. */
3007 o
->flags
|= SEC_EXCLUDE
;
3009 if (info
->print_gc_sections
&& o
->size
!= 0)
3010 /* xgettext: c-format */
3011 _bfd_error_handler (_("Removing unused section '%A' in file '%B'"),
3015 /* But we also have to update some of the relocation
3016 info we collected before. */
3018 && (o
->flags
& SEC_RELOC
) != 0
3019 && o
->reloc_count
> 0
3020 && !bfd_is_abs_section (o
->output_section
))
3022 struct internal_reloc
*internal_relocs
;
3026 = _bfd_coff_link_read_relocs (o
->owner
, o
, NULL
, NULL
,
3028 if (internal_relocs
== NULL
)
3031 r
= (*gc_sweep_hook
) (o
->owner
, info
, o
, internal_relocs
);
3033 if (coff_section_data (o
)->relocs
!= internal_relocs
)
3034 free (internal_relocs
);
3043 /* Remove the symbols that were in the swept sections from the dynamic
3045 coff_link_hash_traverse (coff_hash_table (info
), coff_gc_sweep_symbol
,
3051 /* Keep all sections containing symbols undefined on the command-line,
3052 and the section containing the entry symbol. */
3055 _bfd_coff_gc_keep (struct bfd_link_info
*info
)
3057 struct bfd_sym_chain
*sym
;
3059 for (sym
= info
->gc_sym_list
; sym
!= NULL
; sym
= sym
->next
)
3061 struct coff_link_hash_entry
*h
;
3063 h
= coff_link_hash_lookup (coff_hash_table (info
), sym
->name
,
3064 FALSE
, FALSE
, FALSE
);
3067 && (h
->root
.type
== bfd_link_hash_defined
3068 || h
->root
.type
== bfd_link_hash_defweak
)
3069 && !bfd_is_abs_section (h
->root
.u
.def
.section
))
3070 h
->root
.u
.def
.section
->flags
|= SEC_KEEP
;
3074 /* Do mark and sweep of unused sections. */
3077 bfd_coff_gc_sections (bfd
*abfd ATTRIBUTE_UNUSED
, struct bfd_link_info
*info
)
3081 /* FIXME: Should we implement this? */
3083 const bfd_coff_backend_data
*bed
= coff_backend_info (abfd
);
3085 if (!bed
->can_gc_sections
3086 || !is_coff_hash_table (info
->hash
))
3088 _bfd_error_handler(_("Warning: gc-sections option ignored"));
3093 _bfd_coff_gc_keep (info
);
3095 /* Grovel through relocs to find out who stays ... */
3096 for (sub
= info
->input_bfds
; sub
!= NULL
; sub
= sub
->link
.next
)
3100 if (bfd_get_flavour (sub
) != bfd_target_coff_flavour
)
3103 for (o
= sub
->sections
; o
!= NULL
; o
= o
->next
)
3105 if (((o
->flags
& (SEC_EXCLUDE
| SEC_KEEP
)) == SEC_KEEP
3106 || CONST_STRNEQ (o
->name
, ".vectors")
3107 || CONST_STRNEQ (o
->name
, ".ctors")
3108 || CONST_STRNEQ (o
->name
, ".dtors"))
3111 if (!_bfd_coff_gc_mark (info
, o
, _bfd_coff_gc_mark_hook
))
3117 /* Allow the backend to mark additional target specific sections. */
3118 _bfd_coff_gc_mark_extra_sections (info
, _bfd_coff_gc_mark_hook
);
3120 /* ... and mark SEC_EXCLUDE for those that go. */
3121 return coff_gc_sweep (abfd
, info
);