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)
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 ((unsigned long) auxent->u.auxent.x_sym.x_tagndx.l
1559 < obj_raw_syment_count (abfd))
1561 auxent->u.auxent.x_sym.x_tagndx.p =
1562 table_base + auxent->u.auxent.x_sym.x_tagndx.l;
1563 auxent->fix_tag = 1;
1567 /* Allocate space for the ".debug" section, and read it.
1568 We did not read the debug section until now, because
1569 we didn't want to go to the trouble until someone needed it. */
1572 build_debug_section (bfd *abfd, asection ** sect_return)
1574 char *debug_section;
1576 bfd_size_type sec_size;
1578 asection *sect = bfd_get_section_by_name (abfd, ".debug");
1582 bfd_set_error (bfd_error_no_debug_section);
1586 sec_size = sect->size;
1587 debug_section = (char *) bfd_alloc (abfd, sec_size);
1588 if (debug_section == NULL)
1591 /* Seek to the beginning of the `.debug' section and read it.
1592 Save the current position first; it is needed by our caller.
1593 Then read debug section and reset the file pointer. */
1595 position = bfd_tell (abfd);
1596 if (bfd_seek (abfd, sect->filepos, SEEK_SET) != 0
1597 || bfd_bread (debug_section, sec_size, abfd) != sec_size
1598 || bfd_seek (abfd, position, SEEK_SET) != 0)
1601 * sect_return = sect;
1602 return debug_section;
1605 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
1606 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
1607 be \0-terminated. */
1610 copy_name (bfd *abfd, char *name, size_t maxlen)
1615 for (len = 0; len < maxlen; ++len)
1616 if (name[len] == '\0')
1619 if ((newname = (char *) bfd_alloc (abfd, (bfd_size_type) len + 1)) == NULL)
1622 strncpy (newname, name, len);
1623 newname[len] = '\0';
1627 /* Read in the external symbols. */
1630 _bfd_coff_get_external_symbols (bfd *abfd)
1632 bfd_size_type symesz;
1636 if (obj_coff_external_syms (abfd) != NULL)
1639 symesz = bfd_coff_symesz (abfd);
1641 size = obj_raw_syment_count (abfd) * symesz;
1644 /* Check for integer overflow and for unreasonable symbol counts. */
1645 if (size < obj_raw_syment_count (abfd)
1646 || (bfd_get_file_size (abfd) > 0
1647 && size > bfd_get_file_size (abfd)))
1650 _bfd_error_handler (_("%pB: corrupt symbol count: %#" PRIx64 ""),
1651 abfd, (uint64_t) obj_raw_syment_count (abfd));
1655 syms = bfd_malloc (size);
1658 /* PR 21013: Provide an error message when the alloc fails. */
1659 _bfd_error_handler (_("%pB: not enough memory to allocate space "
1660 "for %#" PRIx64 " symbols of size %#" PRIx64),
1661 abfd, (uint64_t) obj_raw_syment_count (abfd),
1666 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
1667 || bfd_bread (syms, size, abfd) != size)
1674 obj_coff_external_syms (abfd) = syms;
1678 /* Read in the external strings. The strings are not loaded until
1679 they are needed. This is because we have no simple way of
1680 detecting a missing string table in an archive. If the strings
1681 are loaded then the STRINGS and STRINGS_LEN fields in the
1682 coff_tdata structure will be set. */
1685 _bfd_coff_read_string_table (bfd *abfd)
1687 char extstrsize[STRING_SIZE_SIZE];
1688 bfd_size_type strsize;
1692 if (obj_coff_strings (abfd) != NULL)
1693 return obj_coff_strings (abfd);
1695 if (obj_sym_filepos (abfd) == 0)
1697 bfd_set_error (bfd_error_no_symbols);
1701 pos = obj_sym_filepos (abfd);
1702 pos += obj_raw_syment_count (abfd) * bfd_coff_symesz (abfd);
1703 if (bfd_seek (abfd, pos, SEEK_SET) != 0)
1706 if (bfd_bread (extstrsize, (bfd_size_type) sizeof extstrsize, abfd)
1707 != sizeof extstrsize)
1709 if (bfd_get_error () != bfd_error_file_truncated)
1712 /* There is no string table. */
1713 strsize = STRING_SIZE_SIZE;
1717 #if STRING_SIZE_SIZE == 4
1718 strsize = H_GET_32 (abfd, extstrsize);
1720 #error Change H_GET_32
1724 if (strsize < STRING_SIZE_SIZE || strsize > bfd_get_file_size (abfd))
1727 /* xgettext: c-format */
1728 (_("%pB: bad string table size %" PRIu64), abfd, (uint64_t) strsize);
1729 bfd_set_error (bfd_error_bad_value);
1733 strings = (char *) bfd_malloc (strsize + 1);
1734 if (strings == NULL)
1737 /* PR 17521 file: 079-54929-0.004.
1738 A corrupt file could contain an index that points into the first
1739 STRING_SIZE_SIZE bytes of the string table, so make sure that
1741 memset (strings, 0, STRING_SIZE_SIZE);
1743 if (bfd_bread (strings + STRING_SIZE_SIZE, strsize - STRING_SIZE_SIZE, abfd)
1744 != strsize - STRING_SIZE_SIZE)
1750 obj_coff_strings (abfd) = strings;
1751 obj_coff_strings_len (abfd) = strsize;
1752 /* Terminate the string table, just in case. */
1753 strings[strsize] = 0;
1757 /* Free up the external symbols and strings read from a COFF file. */
1760 _bfd_coff_free_symbols (bfd *abfd)
1762 if (! bfd_family_coff (abfd))
1765 if (obj_coff_external_syms (abfd) != NULL
1766 && ! obj_coff_keep_syms (abfd))
1768 free (obj_coff_external_syms (abfd));
1769 obj_coff_external_syms (abfd) = NULL;
1772 if (obj_coff_strings (abfd) != NULL
1773 && ! obj_coff_keep_strings (abfd))
1775 free (obj_coff_strings (abfd));
1776 obj_coff_strings (abfd) = NULL;
1777 obj_coff_strings_len (abfd) = 0;
1783 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
1784 knit the symbol names into a normalized form. By normalized here I
1785 mean that all symbols have an n_offset pointer that points to a null-
1786 terminated string. */
1788 combined_entry_type *
1789 coff_get_normalized_symtab (bfd *abfd)
1791 combined_entry_type *internal;
1792 combined_entry_type *internal_ptr;
1793 combined_entry_type *symbol_ptr;
1794 combined_entry_type *internal_end;
1798 const char *string_table = NULL;
1799 asection * debug_sec = NULL;
1800 char *debug_sec_data = NULL;
1803 if (obj_raw_syments (abfd) != NULL)
1804 return obj_raw_syments (abfd);
1806 if (! _bfd_coff_get_external_symbols (abfd))
1809 size = obj_raw_syment_count (abfd) * sizeof (combined_entry_type);
1810 /* Check for integer overflow. */
1811 if (size < obj_raw_syment_count (abfd))
1813 internal = (combined_entry_type *) bfd_zalloc (abfd, size);
1814 if (internal == NULL && size != 0)
1816 internal_end = internal + obj_raw_syment_count (abfd);
1818 raw_src = (char *) obj_coff_external_syms (abfd);
1820 /* Mark the end of the symbols. */
1821 symesz = bfd_coff_symesz (abfd);
1822 raw_end = (char *) raw_src + obj_raw_syment_count (abfd) * symesz;
1824 /* FIXME SOMEDAY. A string table size of zero is very weird, but
1825 probably possible. If one shows up, it will probably kill us. */
1827 /* Swap all the raw entries. */
1828 for (internal_ptr = internal;
1830 raw_src += symesz, internal_ptr++)
1834 bfd_coff_swap_sym_in (abfd, (void *) raw_src,
1835 (void *) & internal_ptr->u.syment);
1836 symbol_ptr = internal_ptr;
1837 internal_ptr->is_sym = TRUE;
1839 /* PR 17512: file: 1353-1166-0.004. */
1840 if (symbol_ptr->u.syment.n_sclass == C_FILE
1841 && symbol_ptr->u.syment.n_numaux > 0
1842 && raw_src + symesz + symbol_ptr->u.syment.n_numaux
1845 bfd_release (abfd, internal);
1850 i < symbol_ptr->u.syment.n_numaux;
1854 /* PR 17512: Prevent buffer overrun. */
1855 if (internal_ptr >= internal_end)
1857 bfd_release (abfd, internal);
1862 bfd_coff_swap_aux_in (abfd, (void *) raw_src,
1863 symbol_ptr->u.syment.n_type,
1864 symbol_ptr->u.syment.n_sclass,
1865 (int) i, symbol_ptr->u.syment.n_numaux,
1866 &(internal_ptr->u.auxent));
1868 internal_ptr->is_sym = FALSE;
1869 coff_pointerize_aux (abfd, internal, symbol_ptr, i,
1874 /* Free the raw symbols, but not the strings (if we have them). */
1875 obj_coff_keep_strings (abfd) = TRUE;
1876 if (! _bfd_coff_free_symbols (abfd))
1879 for (internal_ptr = internal; internal_ptr < internal_end;
1882 BFD_ASSERT (internal_ptr->is_sym);
1884 if (internal_ptr->u.syment.n_sclass == C_FILE
1885 && internal_ptr->u.syment.n_numaux > 0)
1887 combined_entry_type * aux = internal_ptr + 1;
1889 /* Make a file symbol point to the name in the auxent, since
1890 the text ".file" is redundant. */
1891 BFD_ASSERT (! aux->is_sym);
1893 if (aux->u.auxent.x_file.x_n.x_zeroes == 0)
1895 /* The filename is a long one, point into the string table. */
1896 if (string_table == NULL)
1898 string_table = _bfd_coff_read_string_table (abfd);
1899 if (string_table == NULL)
1903 if ((bfd_size_type)(aux->u.auxent.x_file.x_n.x_offset)
1904 >= obj_coff_strings_len (abfd))
1905 internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) _("<corrupt>");
1907 internal_ptr->u.syment._n._n_n._n_offset =
1908 (bfd_hostptr_t) (string_table + (aux->u.auxent.x_file.x_n.x_offset));
1912 /* Ordinary short filename, put into memory anyway. The
1913 Microsoft PE tools sometimes store a filename in
1914 multiple AUX entries. */
1915 if (internal_ptr->u.syment.n_numaux > 1
1916 && coff_data (abfd)->pe)
1917 internal_ptr->u.syment._n._n_n._n_offset =
1920 aux->u.auxent.x_file.x_fname,
1921 internal_ptr->u.syment.n_numaux * symesz);
1923 internal_ptr->u.syment._n._n_n._n_offset =
1926 aux->u.auxent.x_file.x_fname,
1927 (size_t) bfd_coff_filnmlen (abfd)));
1932 if (internal_ptr->u.syment._n._n_n._n_zeroes != 0)
1934 /* This is a "short" name. Make it long. */
1938 /* Find the length of this string without walking into memory
1940 for (i = 0; i < 8; ++i)
1941 if (internal_ptr->u.syment._n._n_name[i] == '\0')
1944 newstring = (char *) bfd_zalloc (abfd, (bfd_size_type) (i + 1));
1945 if (newstring == NULL)
1947 strncpy (newstring, internal_ptr->u.syment._n._n_name, i);
1948 internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) newstring;
1949 internal_ptr->u.syment._n._n_n._n_zeroes = 0;
1951 else if (internal_ptr->u.syment._n._n_n._n_offset == 0)
1952 internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) "";
1953 else if (!bfd_coff_symname_in_debug (abfd, &internal_ptr->u.syment))
1955 /* Long name already. Point symbol at the string in the
1957 if (string_table == NULL)
1959 string_table = _bfd_coff_read_string_table (abfd);
1960 if (string_table == NULL)
1963 if (internal_ptr->u.syment._n._n_n._n_offset >= obj_coff_strings_len (abfd)
1964 || string_table + internal_ptr->u.syment._n._n_n._n_offset < string_table)
1965 internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) _("<corrupt>");
1967 internal_ptr->u.syment._n._n_n._n_offset =
1970 + internal_ptr->u.syment._n._n_n._n_offset));
1974 /* Long name in debug section. Very similar. */
1975 if (debug_sec_data == NULL)
1976 debug_sec_data = build_debug_section (abfd, & debug_sec);
1977 if (debug_sec_data != NULL)
1979 BFD_ASSERT (debug_sec != NULL);
1980 /* PR binutils/17512: Catch out of range offsets into the debug data. */
1981 if (internal_ptr->u.syment._n._n_n._n_offset > debug_sec->size
1982 || debug_sec_data + internal_ptr->u.syment._n._n_n._n_offset < debug_sec_data)
1983 internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) _("<corrupt>");
1985 internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t)
1986 (debug_sec_data + internal_ptr->u.syment._n._n_n._n_offset);
1989 internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) "";
1992 internal_ptr += internal_ptr->u.syment.n_numaux;
1995 obj_raw_syments (abfd) = internal;
1996 BFD_ASSERT (obj_raw_syment_count (abfd)
1997 == (unsigned int) (internal_ptr - internal));
2003 coff_get_reloc_upper_bound (bfd *abfd, sec_ptr asect)
2005 if (bfd_get_format (abfd) != bfd_object)
2007 bfd_set_error (bfd_error_invalid_operation);
2010 return (asect->reloc_count + 1) * sizeof (arelent *);
2014 coff_make_empty_symbol (bfd *abfd)
2016 bfd_size_type amt = sizeof (coff_symbol_type);
2017 coff_symbol_type *new_symbol = (coff_symbol_type *) bfd_zalloc (abfd, amt);
2019 if (new_symbol == NULL)
2021 new_symbol->symbol.section = 0;
2022 new_symbol->native = NULL;
2023 new_symbol->lineno = NULL;
2024 new_symbol->done_lineno = FALSE;
2025 new_symbol->symbol.the_bfd = abfd;
2027 return & new_symbol->symbol;
2030 /* Make a debugging symbol. */
2033 coff_bfd_make_debug_symbol (bfd *abfd,
2034 void * ptr ATTRIBUTE_UNUSED,
2035 unsigned long sz ATTRIBUTE_UNUSED)
2037 bfd_size_type amt = sizeof (coff_symbol_type);
2038 coff_symbol_type *new_symbol = (coff_symbol_type *) bfd_alloc (abfd, amt);
2040 if (new_symbol == NULL)
2042 /* @@ The 10 is a guess at a plausible maximum number of aux entries
2043 (but shouldn't be a constant). */
2044 amt = sizeof (combined_entry_type) * 10;
2045 new_symbol->native = (combined_entry_type *) bfd_zalloc (abfd, amt);
2046 if (!new_symbol->native)
2048 new_symbol->native->is_sym = TRUE;
2049 new_symbol->symbol.section = bfd_abs_section_ptr;
2050 new_symbol->symbol.flags = BSF_DEBUGGING;
2051 new_symbol->lineno = NULL;
2052 new_symbol->done_lineno = FALSE;
2053 new_symbol->symbol.the_bfd = abfd;
2055 return & new_symbol->symbol;
2059 coff_get_symbol_info (bfd *abfd, asymbol *symbol, symbol_info *ret)
2061 bfd_symbol_info (symbol, ret);
2063 if (coffsymbol (symbol)->native != NULL
2064 && coffsymbol (symbol)->native->fix_value
2065 && coffsymbol (symbol)->native->is_sym)
2066 ret->value = coffsymbol (symbol)->native->u.syment.n_value -
2067 (bfd_hostptr_t) obj_raw_syments (abfd);
2070 /* Print out information about COFF symbol. */
2073 coff_print_symbol (bfd *abfd,
2076 bfd_print_symbol_type how)
2078 FILE * file = (FILE *) filep;
2082 case bfd_print_symbol_name:
2083 fprintf (file, "%s", symbol->name);
2086 case bfd_print_symbol_more:
2087 fprintf (file, "coff %s %s",
2088 coffsymbol (symbol)->native ? "n" : "g",
2089 coffsymbol (symbol)->lineno ? "l" : " ");
2092 case bfd_print_symbol_all:
2093 if (coffsymbol (symbol)->native)
2097 combined_entry_type *combined = coffsymbol (symbol)->native;
2098 combined_entry_type *root = obj_raw_syments (abfd);
2099 struct lineno_cache_entry *l = coffsymbol (symbol)->lineno;
2101 fprintf (file, "[%3ld]", (long) (combined - root));
2103 /* PR 17512: file: 079-33786-0.001:0.1. */
2104 if (combined < obj_raw_syments (abfd)
2105 || combined >= obj_raw_syments (abfd) + obj_raw_syment_count (abfd))
2107 fprintf (file, _("<corrupt info> %s"), symbol->name);
2111 BFD_ASSERT (combined->is_sym);
2112 if (! combined->fix_value)
2113 val = (bfd_vma) combined->u.syment.n_value;
2115 val = combined->u.syment.n_value - (bfd_hostptr_t) root;
2117 fprintf (file, "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x",
2118 combined->u.syment.n_scnum,
2119 combined->u.syment.n_flags,
2120 combined->u.syment.n_type,
2121 combined->u.syment.n_sclass,
2122 combined->u.syment.n_numaux);
2123 bfd_fprintf_vma (abfd, file, val);
2124 fprintf (file, " %s", symbol->name);
2126 for (aux = 0; aux < combined->u.syment.n_numaux; aux++)
2128 combined_entry_type *auxp = combined + aux + 1;
2131 BFD_ASSERT (! auxp->is_sym);
2133 tagndx = auxp->u.auxent.x_sym.x_tagndx.p - root;
2135 tagndx = auxp->u.auxent.x_sym.x_tagndx.l;
2137 fprintf (file, "\n");
2139 if (bfd_coff_print_aux (abfd, file, root, combined, auxp, aux))
2142 switch (combined->u.syment.n_sclass)
2145 fprintf (file, "File ");
2149 if (combined->u.syment.n_type == T_NULL)
2150 /* Probably a section symbol ? */
2152 fprintf (file, "AUX scnlen 0x%lx nreloc %d nlnno %d",
2153 (unsigned long) auxp->u.auxent.x_scn.x_scnlen,
2154 auxp->u.auxent.x_scn.x_nreloc,
2155 auxp->u.auxent.x_scn.x_nlinno);
2156 if (auxp->u.auxent.x_scn.x_checksum != 0
2157 || auxp->u.auxent.x_scn.x_associated != 0
2158 || auxp->u.auxent.x_scn.x_comdat != 0)
2159 fprintf (file, " checksum 0x%lx assoc %d comdat %d",
2160 auxp->u.auxent.x_scn.x_checksum,
2161 auxp->u.auxent.x_scn.x_associated,
2162 auxp->u.auxent.x_scn.x_comdat);
2168 if (ISFCN (combined->u.syment.n_type))
2173 next = (auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p
2176 next = auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l;
2177 llnos = auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_lnnoptr;
2179 "AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld",
2181 (unsigned long) auxp->u.auxent.x_sym.x_misc.x_fsize,
2187 fprintf (file, "AUX lnno %d size 0x%x tagndx %ld",
2188 auxp->u.auxent.x_sym.x_misc.x_lnsz.x_lnno,
2189 auxp->u.auxent.x_sym.x_misc.x_lnsz.x_size,
2192 fprintf (file, " endndx %ld",
2194 (auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p
2202 fprintf (file, "\n%s :", l->u.sym->name);
2204 while (l->line_number)
2206 if (l->line_number > 0)
2208 fprintf (file, "\n%4d : ", l->line_number);
2209 bfd_fprintf_vma (abfd, file, l->u.offset + symbol->section->vma);
2217 bfd_print_symbol_vandf (abfd, (void *) file, symbol);
2218 fprintf (file, " %-5s %s %s %s",
2219 symbol->section->name,
2220 coffsymbol (symbol)->native ? "n" : "g",
2221 coffsymbol (symbol)->lineno ? "l" : " ",
2227 /* Return whether a symbol name implies a local symbol. In COFF,
2228 local symbols generally start with ``.L''. Most targets use this
2229 function for the is_local_label_name entry point, but some may
2233 _bfd_coff_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
2236 return name[0] == '.' && name[1] == 'L';
2239 /* Provided a BFD, a section and an offset (in bytes, not octets) into the
2240 section, calculate and return the name of the source file and the line
2241 nearest to the wanted location. */
2244 coff_find_nearest_line_with_names (bfd *abfd,
2248 const char **filename_ptr,
2249 const char **functionname_ptr,
2250 unsigned int *line_ptr,
2251 const struct dwarf_debug_section *debug_sections)
2255 unsigned int line_base;
2256 coff_data_type *cof = coff_data (abfd);
2257 /* Run through the raw syments if available. */
2258 combined_entry_type *p;
2259 combined_entry_type *pend;
2261 struct coff_section_tdata *sec_data;
2264 /* Before looking through the symbol table, try to use a .stab
2265 section to find the information. */
2266 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
2267 &found, filename_ptr,
2268 functionname_ptr, line_ptr,
2269 &coff_data(abfd)->line_info))
2275 /* Also try examining DWARF2 debugging information. */
2276 if (_bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset,
2277 filename_ptr, functionname_ptr,
2278 line_ptr, NULL, debug_sections, 0,
2279 &coff_data(abfd)->dwarf2_find_line_info))
2282 sec_data = coff_section_data (abfd, section);
2284 /* If the DWARF lookup failed, but there is DWARF information available
2285 then the problem might be that the file has been rebased. This tool
2286 changes the VMAs of all the sections, but it does not update the DWARF
2287 information. So try again, using a bias against the address sought. */
2288 if (coff_data (abfd)->dwarf2_find_line_info != NULL)
2290 bfd_signed_vma bias;
2292 /* Create a cache of the result for the next call. */
2293 if (sec_data == NULL && section->owner == abfd)
2295 amt = sizeof (struct coff_section_tdata);
2296 section->used_by_bfd = bfd_zalloc (abfd, amt);
2297 sec_data = (struct coff_section_tdata *) section->used_by_bfd;
2300 if (sec_data != NULL && sec_data->saved_bias)
2301 bias = sec_data->saved_bias;
2304 bias = _bfd_dwarf2_find_symbol_bias (symbols,
2305 & coff_data (abfd)->dwarf2_find_line_info);
2308 sec_data->saved_bias = TRUE;
2309 sec_data->bias = bias;
2314 && _bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section,
2316 filename_ptr, functionname_ptr,
2317 line_ptr, NULL, debug_sections, 0,
2318 &coff_data(abfd)->dwarf2_find_line_info))
2323 *functionname_ptr = 0;
2326 /* Don't try and find line numbers in a non coff file. */
2327 if (!bfd_family_coff (abfd))
2333 /* Find the first C_FILE symbol. */
2334 p = cof->raw_syments;
2338 pend = p + cof->raw_syment_count;
2341 BFD_ASSERT (p->is_sym);
2342 if (p->u.syment.n_sclass == C_FILE)
2344 p += 1 + p->u.syment.n_numaux;
2352 /* Look through the C_FILE symbols to find the best one. */
2353 sec_vma = bfd_get_section_vma (abfd, section);
2354 *filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
2355 maxdiff = (bfd_vma) 0 - (bfd_vma) 1;
2359 combined_entry_type *p2;
2361 for (p2 = p + 1 + p->u.syment.n_numaux;
2363 p2 += 1 + p2->u.syment.n_numaux)
2365 BFD_ASSERT (p2->is_sym);
2366 if (p2->u.syment.n_scnum > 0
2368 == coff_section_from_bfd_index (abfd,
2369 p2->u.syment.n_scnum)))
2371 if (p2->u.syment.n_sclass == C_FILE)
2380 file_addr = (bfd_vma) p2->u.syment.n_value;
2381 /* PR 11512: Include the section address of the function name symbol. */
2382 if (p2->u.syment.n_scnum > 0)
2383 file_addr += coff_section_from_bfd_index (abfd,
2384 p2->u.syment.n_scnum)->vma;
2385 /* We use <= MAXDIFF here so that if we get a zero length
2386 file, we actually use the next file entry. */
2388 && offset + sec_vma >= file_addr
2389 && offset + sec_vma - file_addr <= maxdiff)
2391 *filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
2392 maxdiff = offset + sec_vma - p2->u.syment.n_value;
2395 /* Avoid endless loops on erroneous files by ensuring that
2396 we always move forward in the file. */
2397 if (p >= cof->raw_syments + p->u.syment.n_value)
2400 p = cof->raw_syments + p->u.syment.n_value;
2401 if (p > pend || p->u.syment.n_sclass != C_FILE)
2406 if (section->lineno_count == 0)
2408 *functionname_ptr = NULL;
2413 /* Now wander though the raw linenumbers of the section.
2414 If we have been called on this section before, and the offset
2415 we want is further down then we can prime the lookup loop. */
2416 if (sec_data != NULL
2418 && offset >= sec_data->offset)
2421 *functionname_ptr = sec_data->function;
2422 line_base = sec_data->line_base;
2430 if (section->lineno != NULL)
2432 bfd_vma last_value = 0;
2434 l = §ion->lineno[i];
2436 for (; i < section->lineno_count; i++)
2438 if (l->line_number == 0)
2440 /* Get the symbol this line number points at. */
2441 coff_symbol_type *coff = (coff_symbol_type *) (l->u.sym);
2442 if (coff->symbol.value > offset)
2445 *functionname_ptr = coff->symbol.name;
2446 last_value = coff->symbol.value;
2449 combined_entry_type *s = coff->native;
2451 BFD_ASSERT (s->is_sym);
2452 s = s + 1 + s->u.syment.n_numaux;
2454 /* In XCOFF a debugging symbol can follow the
2456 if (s->u.syment.n_scnum == N_DEBUG)
2457 s = s + 1 + s->u.syment.n_numaux;
2459 /* S should now point to the .bf of the function. */
2460 if (s->u.syment.n_numaux)
2462 /* The linenumber is stored in the auxent. */
2463 union internal_auxent *a = &((s + 1)->u.auxent);
2465 line_base = a->x_sym.x_misc.x_lnsz.x_lnno;
2466 *line_ptr = line_base;
2472 if (l->u.offset > offset)
2474 *line_ptr = l->line_number + line_base - 1;
2479 /* If we fell off the end of the loop, then assume that this
2480 symbol has no line number info. Otherwise, symbols with no
2481 line number info get reported with the line number of the
2482 last line of the last symbol which does have line number
2483 info. We use 0x100 as a slop to account for cases where the
2484 last line has executable code. */
2485 if (i >= section->lineno_count
2487 && offset - last_value > 0x100)
2489 *functionname_ptr = NULL;
2494 /* Cache the results for the next call. */
2495 if (sec_data == NULL && section->owner == abfd)
2497 amt = sizeof (struct coff_section_tdata);
2498 section->used_by_bfd = bfd_zalloc (abfd, amt);
2499 sec_data = (struct coff_section_tdata *) section->used_by_bfd;
2502 if (sec_data != NULL)
2504 sec_data->offset = offset;
2505 sec_data->i = i - 1;
2506 sec_data->function = *functionname_ptr;
2507 sec_data->line_base = line_base;
2514 coff_find_nearest_line (bfd *abfd,
2518 const char **filename_ptr,
2519 const char **functionname_ptr,
2520 unsigned int *line_ptr,
2521 unsigned int *discriminator_ptr)
2523 if (discriminator_ptr)
2524 *discriminator_ptr = 0;
2525 return coff_find_nearest_line_with_names (abfd, symbols, section, offset,
2526 filename_ptr, functionname_ptr,
2527 line_ptr, dwarf_debug_sections);
2531 coff_find_inliner_info (bfd *abfd,
2532 const char **filename_ptr,
2533 const char **functionname_ptr,
2534 unsigned int *line_ptr)
2538 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
2539 functionname_ptr, line_ptr,
2540 &coff_data(abfd)->dwarf2_find_line_info);
2545 coff_sizeof_headers (bfd *abfd, struct bfd_link_info *info)
2549 if (!bfd_link_relocatable (info))
2550 size = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
2552 size = bfd_coff_filhsz (abfd);
2554 size += abfd->section_count * bfd_coff_scnhsz (abfd);
2558 /* Change the class of a coff symbol held by BFD. */
2561 bfd_coff_set_symbol_class (bfd * abfd,
2563 unsigned int symbol_class)
2565 coff_symbol_type * csym;
2567 csym = coff_symbol_from (symbol);
2570 bfd_set_error (bfd_error_invalid_operation);
2573 else if (csym->native == NULL)
2575 /* This is an alien symbol which no native coff backend data.
2576 We cheat here by creating a fake native entry for it and
2577 then filling in the class. This code is based on that in
2578 coff_write_alien_symbol(). */
2580 combined_entry_type * native;
2581 bfd_size_type amt = sizeof (* native);
2583 native = (combined_entry_type *) bfd_zalloc (abfd, amt);
2587 native->is_sym = TRUE;
2588 native->u.syment.n_type = T_NULL;
2589 native->u.syment.n_sclass = symbol_class;
2591 if (bfd_is_und_section (symbol->section))
2593 native->u.syment.n_scnum = N_UNDEF;
2594 native->u.syment.n_value = symbol->value;
2596 else if (bfd_is_com_section (symbol->section))
2598 native->u.syment.n_scnum = N_UNDEF;
2599 native->u.syment.n_value = symbol->value;
2603 native->u.syment.n_scnum =
2604 symbol->section->output_section->target_index;
2605 native->u.syment.n_value = (symbol->value
2606 + symbol->section->output_offset);
2607 if (! obj_pe (abfd))
2608 native->u.syment.n_value += symbol->section->output_section->vma;
2610 /* Copy the any flags from the file header into the symbol.
2612 native->u.syment.n_flags = bfd_asymbol_bfd (& csym->symbol)->flags;
2615 csym->native = native;
2618 csym->native->u.syment.n_sclass = symbol_class;
2624 _bfd_coff_section_already_linked (bfd *abfd,
2626 struct bfd_link_info *info)
2629 const char *name, *key;
2630 struct bfd_section_already_linked *l;
2631 struct bfd_section_already_linked_hash_entry *already_linked_list;
2632 struct coff_comdat_info *s_comdat;
2635 if ((flags & SEC_LINK_ONCE) == 0)
2638 /* The COFF backend linker doesn't support group sections. */
2639 if ((flags & SEC_GROUP) != 0)
2642 name = bfd_get_section_name (abfd, sec);
2643 s_comdat = bfd_coff_get_comdat_section (abfd, sec);
2645 if (s_comdat != NULL)
2646 key = s_comdat->name;
2649 if (CONST_STRNEQ (name, ".gnu.linkonce.")
2650 && (key = strchr (name + sizeof (".gnu.linkonce.") - 1, '.')) != NULL)
2653 /* FIXME: gcc as of 2011-09 emits sections like .text$<key>,
2654 .xdata$<key> and .pdata$<key> only the first of which has a
2655 comdat key. Should these all match the LTO IR key? */
2659 already_linked_list = bfd_section_already_linked_table_lookup (key);
2661 for (l = already_linked_list->entry; l != NULL; l = l->next)
2663 struct coff_comdat_info *l_comdat;
2665 l_comdat = bfd_coff_get_comdat_section (l->sec->owner, l->sec);
2667 /* The section names must match, and both sections must be
2668 comdat and have the same comdat name, or both sections must
2669 be non-comdat. LTO IR plugin sections are an exception. They
2670 are always named .gnu.linkonce.t.<key> (<key> is some string)
2671 and match any comdat section with comdat name of <key>, and
2672 any linkonce section with the same suffix, ie.
2673 .gnu.linkonce.*.<key>. */
2674 if (((s_comdat != NULL) == (l_comdat != NULL)
2675 && strcmp (name, l->sec->name) == 0)
2676 || (l->sec->owner->flags & BFD_PLUGIN) != 0)
2678 /* The section has already been linked. See if we should
2680 return _bfd_handle_already_linked (sec, l, info);
2684 /* This is the first section with this name. Record it. */
2685 if (!bfd_section_already_linked_table_insert (already_linked_list, sec))
2686 info->callbacks->einfo (_("%F%P: already_linked_table: %E\n"));
2690 /* Initialize COOKIE for input bfd ABFD. */
2693 init_reloc_cookie (struct coff_reloc_cookie *cookie,
2694 struct bfd_link_info *info ATTRIBUTE_UNUSED,
2697 /* Sometimes the symbol table does not yet have been loaded here. */
2698 bfd_coff_slurp_symbol_table (abfd);
2700 cookie->abfd = abfd;
2701 cookie->sym_hashes = obj_coff_sym_hashes (abfd);
2703 cookie->symbols = obj_symbols (abfd);
2708 /* Free the memory allocated by init_reloc_cookie, if appropriate. */
2711 fini_reloc_cookie (struct coff_reloc_cookie *cookie ATTRIBUTE_UNUSED,
2712 bfd *abfd ATTRIBUTE_UNUSED)
2714 /* Nothing to do. */
2717 /* Initialize the relocation information in COOKIE for input section SEC
2718 of input bfd ABFD. */
2721 init_reloc_cookie_rels (struct coff_reloc_cookie *cookie,
2722 struct bfd_link_info *info ATTRIBUTE_UNUSED,
2726 if (sec->reloc_count == 0)
2728 cookie->rels = NULL;
2729 cookie->relend = NULL;
2734 cookie->rels = _bfd_coff_read_internal_relocs (abfd, sec, FALSE, NULL, 0, NULL);
2736 if (cookie->rels == NULL)
2739 cookie->rel = cookie->rels;
2740 cookie->relend = (cookie->rels + sec->reloc_count);
2744 /* Free the memory allocated by init_reloc_cookie_rels,
2748 fini_reloc_cookie_rels (struct coff_reloc_cookie *cookie,
2752 /* PR 20401. The relocs may not have been cached, so check first.
2753 If the relocs were loaded by init_reloc_cookie_rels() then this
2754 will be the case. FIXME: Would performance be improved if the
2755 relocs *were* cached ? */
2756 && coff_section_data (NULL, sec)
2757 && coff_section_data (NULL, sec)->relocs != cookie->rels)
2758 free (cookie->rels);
2761 /* Initialize the whole of COOKIE for input section SEC. */
2764 init_reloc_cookie_for_section (struct coff_reloc_cookie *cookie,
2765 struct bfd_link_info *info,
2768 if (!init_reloc_cookie (cookie, info, sec->owner))
2771 if (!init_reloc_cookie_rels (cookie, info, sec->owner, sec))
2773 fini_reloc_cookie (cookie, sec->owner);
2779 /* Free the memory allocated by init_reloc_cookie_for_section,
2783 fini_reloc_cookie_for_section (struct coff_reloc_cookie *cookie,
2786 fini_reloc_cookie_rels (cookie, sec);
2787 fini_reloc_cookie (cookie, sec->owner);
2791 _bfd_coff_gc_mark_hook (asection *sec,
2792 struct bfd_link_info *info ATTRIBUTE_UNUSED,
2793 struct internal_reloc *rel ATTRIBUTE_UNUSED,
2794 struct coff_link_hash_entry *h,
2795 struct internal_syment *sym)
2799 switch (h->root.type)
2801 case bfd_link_hash_defined:
2802 case bfd_link_hash_defweak:
2803 return h->root.u.def.section;
2805 case bfd_link_hash_common:
2806 return h->root.u.c.p->section;
2808 case bfd_link_hash_undefweak:
2809 if (h->symbol_class == C_NT_WEAK && h->numaux == 1)
2811 /* PE weak externals. A weak symbol may include an auxiliary
2812 record indicating that if the weak symbol is not resolved,
2813 another external symbol is used instead. */
2814 struct coff_link_hash_entry *h2 =
2815 h->auxbfd->tdata.coff_obj_data->sym_hashes[
2816 h->aux->x_sym.x_tagndx.l];
2818 if (h2 && h2->root.type != bfd_link_hash_undefined)
2819 return h2->root.u.def.section;
2823 case bfd_link_hash_undefined:
2830 return coff_section_from_bfd_index (sec->owner, sym->n_scnum);
2833 /* COOKIE->rel describes a relocation against section SEC, which is
2834 a section we've decided to keep. Return the section that contains
2835 the relocation symbol, or NULL if no section contains it. */
2838 _bfd_coff_gc_mark_rsec (struct bfd_link_info *info, asection *sec,
2839 coff_gc_mark_hook_fn gc_mark_hook,
2840 struct coff_reloc_cookie *cookie)
2842 struct coff_link_hash_entry *h;
2844 h = cookie->sym_hashes[cookie->rel->r_symndx];
2847 while (h->root.type == bfd_link_hash_indirect
2848 || h->root.type == bfd_link_hash_warning)
2849 h = (struct coff_link_hash_entry *) h->root.u.i.link;
2851 return (*gc_mark_hook) (sec, info, cookie->rel, h, NULL);
2854 return (*gc_mark_hook) (sec, info, cookie->rel, NULL,
2856 + obj_convert (sec->owner)[cookie->rel->r_symndx])->native->u.syment);
2859 static bfd_boolean _bfd_coff_gc_mark
2860 (struct bfd_link_info *, asection *, coff_gc_mark_hook_fn);
2862 /* COOKIE->rel describes a relocation against section SEC, which is
2863 a section we've decided to keep. Mark the section that contains
2864 the relocation symbol. */
2867 _bfd_coff_gc_mark_reloc (struct bfd_link_info *info,
2869 coff_gc_mark_hook_fn gc_mark_hook,
2870 struct coff_reloc_cookie *cookie)
2874 rsec = _bfd_coff_gc_mark_rsec (info, sec, gc_mark_hook, cookie);
2875 if (rsec && !rsec->gc_mark)
2877 if (bfd_get_flavour (rsec->owner) != bfd_target_coff_flavour)
2879 else if (!_bfd_coff_gc_mark (info, rsec, gc_mark_hook))
2885 /* The mark phase of garbage collection. For a given section, mark
2886 it and any sections in this section's group, and all the sections
2887 which define symbols to which it refers. */
2890 _bfd_coff_gc_mark (struct bfd_link_info *info,
2892 coff_gc_mark_hook_fn gc_mark_hook)
2894 bfd_boolean ret = TRUE;
2898 /* Look through the section relocs. */
2899 if ((sec->flags & SEC_RELOC) != 0
2900 && sec->reloc_count > 0)
2902 struct coff_reloc_cookie cookie;
2904 if (!init_reloc_cookie_for_section (&cookie, info, sec))
2908 for (; cookie.rel < cookie.relend; cookie.rel++)
2910 if (!_bfd_coff_gc_mark_reloc (info, sec, gc_mark_hook, &cookie))
2916 fini_reloc_cookie_for_section (&cookie, sec);
2924 _bfd_coff_gc_mark_extra_sections (struct bfd_link_info *info,
2925 coff_gc_mark_hook_fn mark_hook ATTRIBUTE_UNUSED)
2929 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2932 bfd_boolean some_kept;
2934 if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour)
2937 /* Ensure all linker created sections are kept, and see whether
2938 any other section is already marked. */
2940 for (isec = ibfd->sections; isec != NULL; isec = isec->next)
2942 if ((isec->flags & SEC_LINKER_CREATED) != 0)
2944 else if (isec->gc_mark)
2948 /* If no section in this file will be kept, then we can
2949 toss out debug sections. */
2953 /* Keep debug and special sections like .comment when they are
2954 not part of a group, or when we have single-member groups. */
2955 for (isec = ibfd->sections; isec != NULL; isec = isec->next)
2956 if ((isec->flags & SEC_DEBUGGING) != 0
2957 || (isec->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) == 0)
2963 /* Sweep symbols in swept sections. Called via coff_link_hash_traverse. */
2966 coff_gc_sweep_symbol (struct coff_link_hash_entry *h,
2967 void *data ATTRIBUTE_UNUSED)
2969 if (h->root.type == bfd_link_hash_warning)
2970 h = (struct coff_link_hash_entry *) h->root.u.i.link;
2972 if ((h->root.type == bfd_link_hash_defined
2973 || h->root.type == bfd_link_hash_defweak)
2974 && !h->root.u.def.section->gc_mark
2975 && !(h->root.u.def.section->owner->flags & DYNAMIC))
2977 /* Do our best to hide the symbol. */
2978 h->root.u.def.section = bfd_und_section_ptr;
2979 h->symbol_class = C_HIDDEN;
2985 /* The sweep phase of garbage collection. Remove all garbage sections. */
2987 typedef bfd_boolean (*gc_sweep_hook_fn)
2988 (bfd *, struct bfd_link_info *, asection *, const struct internal_reloc *);
2991 coff_gc_sweep (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
2995 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
2999 if (bfd_get_flavour (sub) != bfd_target_coff_flavour)
3002 for (o = sub->sections; o != NULL; o = o->next)
3004 /* Keep debug and special sections. */
3005 if ((o->flags & (SEC_DEBUGGING | SEC_LINKER_CREATED)) != 0
3006 || (o->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) == 0)
3008 else if (CONST_STRNEQ (o->name, ".idata")
3009 || CONST_STRNEQ (o->name, ".pdata")
3010 || CONST_STRNEQ (o->name, ".xdata")
3011 || CONST_STRNEQ (o->name, ".rsrc"))
3017 /* Skip sweeping sections already excluded. */
3018 if (o->flags & SEC_EXCLUDE)
3021 /* Since this is early in the link process, it is simple
3022 to remove a section from the output. */
3023 o->flags |= SEC_EXCLUDE;
3025 if (info->print_gc_sections && o->size != 0)
3026 /* xgettext: c-format */
3027 _bfd_error_handler (_("Removing unused section '%pA' in file '%pB'"),
3031 /* But we also have to update some of the relocation
3032 info we collected before. */
3034 && (o->flags & SEC_RELOC) != 0
3035 && o->reloc_count > 0
3036 && !bfd_is_abs_section (o->output_section))
3038 struct internal_reloc *internal_relocs;
3042 = _bfd_coff_link_read_relocs (o->owner, o, NULL, NULL,
3044 if (internal_relocs == NULL)
3047 r = (*gc_sweep_hook) (o->owner, info, o, internal_relocs);
3049 if (coff_section_data (o)->relocs != internal_relocs)
3050 free (internal_relocs);
3059 /* Remove the symbols that were in the swept sections from the dynamic
3061 coff_link_hash_traverse (coff_hash_table (info), coff_gc_sweep_symbol,
3067 /* Keep all sections containing symbols undefined on the command-line,
3068 and the section containing the entry symbol. */
3071 _bfd_coff_gc_keep (struct bfd_link_info *info)
3073 struct bfd_sym_chain *sym;
3075 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
3077 struct coff_link_hash_entry *h;
3079 h = coff_link_hash_lookup (coff_hash_table (info), sym->name,
3080 FALSE, FALSE, FALSE);
3083 && (h->root.type == bfd_link_hash_defined
3084 || h->root.type == bfd_link_hash_defweak)
3085 && !bfd_is_abs_section (h->root.u.def.section))
3086 h->root.u.def.section->flags |= SEC_KEEP;
3090 /* Do mark and sweep of unused sections. */
3093 bfd_coff_gc_sections (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
3097 /* FIXME: Should we implement this? */
3099 const bfd_coff_backend_data *bed = coff_backend_info (abfd);
3101 if (!bed->can_gc_sections
3102 || !is_coff_hash_table (info->hash))
3104 _bfd_error_handler(_("Warning: gc-sections option ignored"));
3109 _bfd_coff_gc_keep (info);
3111 /* Grovel through relocs to find out who stays ... */
3112 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
3116 if (bfd_get_flavour (sub) != bfd_target_coff_flavour)
3119 for (o = sub->sections; o != NULL; o = o->next)
3121 if (((o->flags & (SEC_EXCLUDE | SEC_KEEP)) == SEC_KEEP
3122 || CONST_STRNEQ (o->name, ".vectors")
3123 || CONST_STRNEQ (o->name, ".ctors")
3124 || CONST_STRNEQ (o->name, ".dtors"))
3127 if (!_bfd_coff_gc_mark (info, o, _bfd_coff_gc_mark_hook))
3133 /* Allow the backend to mark additional target specific sections. */
3134 _bfd_coff_gc_mark_extra_sections (info, _bfd_coff_gc_mark_hook);
3136 /* ... and mark SEC_EXCLUDE for those that go. */
3137 return coff_gc_sweep (abfd, info);