1 /* Support for the generic parts of COFF, for BFD.
2 Copyright (C) 1990-2019 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,
1525 combined_entry_type *table_end)
1527 unsigned int type = symbol->u.syment.n_type;
1528 unsigned int n_sclass = symbol->u.syment.n_sclass;
1530 BFD_ASSERT (symbol->is_sym);
1531 if (coff_backend_info (abfd)->_bfd_coff_pointerize_aux_hook)
1533 if ((*coff_backend_info (abfd)->_bfd_coff_pointerize_aux_hook)
1534 (abfd, table_base, symbol, indaux, auxent))
1538 /* Don't bother if this is a file or a section. */
1539 if (n_sclass == C_STAT && type == T_NULL)
1541 if (n_sclass == C_FILE)
1544 BFD_ASSERT (! auxent->is_sym);
1545 /* Otherwise patch up. */
1546 #define N_TMASK coff_data (abfd)->local_n_tmask
1547 #define N_BTSHFT coff_data (abfd)->local_n_btshft
1549 if ((ISFCN (type) || ISTAG (n_sclass) || n_sclass == C_BLOCK
1550 || n_sclass == C_FCN)
1551 && 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.l
1553 < (long) obj_raw_syment_count (abfd)
1554 && table_base + auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l
1557 auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p =
1558 table_base + auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l;
1559 auxent->fix_end = 1;
1562 /* A negative tagndx is meaningless, but the SCO 3.2v4 cc can
1563 generate one, so we must be careful to ignore it. */
1564 if ((unsigned long) auxent->u.auxent.x_sym.x_tagndx.l
1565 < obj_raw_syment_count (abfd)
1566 && table_base + auxent->u.auxent.x_sym.x_tagndx.l < table_end)
1568 auxent->u.auxent.x_sym.x_tagndx.p =
1569 table_base + auxent->u.auxent.x_sym.x_tagndx.l;
1570 auxent->fix_tag = 1;
1574 /* Allocate space for the ".debug" section, and read it.
1575 We did not read the debug section until now, because
1576 we didn't want to go to the trouble until someone needed it. */
1579 build_debug_section (bfd *abfd, asection ** sect_return)
1581 char *debug_section;
1583 bfd_size_type sec_size;
1585 asection *sect = bfd_get_section_by_name (abfd, ".debug");
1589 bfd_set_error (bfd_error_no_debug_section);
1593 sec_size = sect->size;
1594 debug_section = (char *) bfd_alloc (abfd, sec_size);
1595 if (debug_section == NULL)
1598 /* Seek to the beginning of the `.debug' section and read it.
1599 Save the current position first; it is needed by our caller.
1600 Then read debug section and reset the file pointer. */
1602 position = bfd_tell (abfd);
1603 if (bfd_seek (abfd, sect->filepos, SEEK_SET) != 0
1604 || bfd_bread (debug_section, sec_size, abfd) != sec_size
1605 || bfd_seek (abfd, position, SEEK_SET) != 0)
1608 * sect_return = sect;
1609 return debug_section;
1612 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
1613 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
1614 be \0-terminated. */
1617 copy_name (bfd *abfd, char *name, size_t maxlen)
1622 for (len = 0; len < maxlen; ++len)
1623 if (name[len] == '\0')
1626 if ((newname = (char *) bfd_alloc (abfd, (bfd_size_type) len + 1)) == NULL)
1629 strncpy (newname, name, len);
1630 newname[len] = '\0';
1634 /* Read in the external symbols. */
1637 _bfd_coff_get_external_symbols (bfd *abfd)
1639 bfd_size_type symesz;
1643 if (obj_coff_external_syms (abfd) != NULL)
1646 symesz = bfd_coff_symesz (abfd);
1648 size = obj_raw_syment_count (abfd) * symesz;
1651 /* Check for integer overflow and for unreasonable symbol counts. */
1652 if (size < obj_raw_syment_count (abfd)
1653 || (bfd_get_file_size (abfd) > 0
1654 && size > bfd_get_file_size (abfd)))
1657 _bfd_error_handler (_("%pB: corrupt symbol count: %#" PRIx64 ""),
1658 abfd, (uint64_t) obj_raw_syment_count (abfd));
1662 syms = bfd_malloc (size);
1665 /* PR 21013: Provide an error message when the alloc fails. */
1666 _bfd_error_handler (_("%pB: not enough memory to allocate space "
1667 "for %#" PRIx64 " symbols of size %#" PRIx64),
1668 abfd, (uint64_t) obj_raw_syment_count (abfd),
1673 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
1674 || bfd_bread (syms, size, abfd) != size)
1681 obj_coff_external_syms (abfd) = syms;
1685 /* Read in the external strings. The strings are not loaded until
1686 they are needed. This is because we have no simple way of
1687 detecting a missing string table in an archive. If the strings
1688 are loaded then the STRINGS and STRINGS_LEN fields in the
1689 coff_tdata structure will be set. */
1692 _bfd_coff_read_string_table (bfd *abfd)
1694 char extstrsize[STRING_SIZE_SIZE];
1695 bfd_size_type strsize;
1699 if (obj_coff_strings (abfd) != NULL)
1700 return obj_coff_strings (abfd);
1702 if (obj_sym_filepos (abfd) == 0)
1704 bfd_set_error (bfd_error_no_symbols);
1708 pos = obj_sym_filepos (abfd);
1709 pos += obj_raw_syment_count (abfd) * bfd_coff_symesz (abfd);
1710 if (bfd_seek (abfd, pos, SEEK_SET) != 0)
1713 if (bfd_bread (extstrsize, (bfd_size_type) sizeof extstrsize, abfd)
1714 != sizeof extstrsize)
1716 if (bfd_get_error () != bfd_error_file_truncated)
1719 /* There is no string table. */
1720 strsize = STRING_SIZE_SIZE;
1724 #if STRING_SIZE_SIZE == 4
1725 strsize = H_GET_32 (abfd, extstrsize);
1727 #error Change H_GET_32
1731 if (strsize < STRING_SIZE_SIZE || strsize > bfd_get_file_size (abfd))
1734 /* xgettext: c-format */
1735 (_("%pB: bad string table size %" PRIu64), abfd, (uint64_t) strsize);
1736 bfd_set_error (bfd_error_bad_value);
1740 strings = (char *) bfd_malloc (strsize + 1);
1741 if (strings == NULL)
1744 /* PR 17521 file: 079-54929-0.004.
1745 A corrupt file could contain an index that points into the first
1746 STRING_SIZE_SIZE bytes of the string table, so make sure that
1748 memset (strings, 0, STRING_SIZE_SIZE);
1750 if (bfd_bread (strings + STRING_SIZE_SIZE, strsize - STRING_SIZE_SIZE, abfd)
1751 != strsize - STRING_SIZE_SIZE)
1757 obj_coff_strings (abfd) = strings;
1758 obj_coff_strings_len (abfd) = strsize;
1759 /* Terminate the string table, just in case. */
1760 strings[strsize] = 0;
1764 /* Free up the external symbols and strings read from a COFF file. */
1767 _bfd_coff_free_symbols (bfd *abfd)
1769 if (! bfd_family_coff (abfd))
1772 if (obj_coff_external_syms (abfd) != NULL
1773 && ! obj_coff_keep_syms (abfd))
1775 free (obj_coff_external_syms (abfd));
1776 obj_coff_external_syms (abfd) = NULL;
1779 if (obj_coff_strings (abfd) != NULL
1780 && ! obj_coff_keep_strings (abfd))
1782 free (obj_coff_strings (abfd));
1783 obj_coff_strings (abfd) = NULL;
1784 obj_coff_strings_len (abfd) = 0;
1790 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
1791 knit the symbol names into a normalized form. By normalized here I
1792 mean that all symbols have an n_offset pointer that points to a null-
1793 terminated string. */
1795 combined_entry_type *
1796 coff_get_normalized_symtab (bfd *abfd)
1798 combined_entry_type *internal;
1799 combined_entry_type *internal_ptr;
1800 combined_entry_type *symbol_ptr;
1801 combined_entry_type *internal_end;
1805 const char *string_table = NULL;
1806 asection * debug_sec = NULL;
1807 char *debug_sec_data = NULL;
1810 if (obj_raw_syments (abfd) != NULL)
1811 return obj_raw_syments (abfd);
1813 if (! _bfd_coff_get_external_symbols (abfd))
1816 size = obj_raw_syment_count (abfd) * sizeof (combined_entry_type);
1817 /* Check for integer overflow. */
1818 if (size < obj_raw_syment_count (abfd))
1820 internal = (combined_entry_type *) bfd_zalloc (abfd, size);
1821 if (internal == NULL && size != 0)
1823 internal_end = internal + obj_raw_syment_count (abfd);
1825 raw_src = (char *) obj_coff_external_syms (abfd);
1827 /* Mark the end of the symbols. */
1828 symesz = bfd_coff_symesz (abfd);
1829 raw_end = (char *) raw_src + obj_raw_syment_count (abfd) * symesz;
1831 /* FIXME SOMEDAY. A string table size of zero is very weird, but
1832 probably possible. If one shows up, it will probably kill us. */
1834 /* Swap all the raw entries. */
1835 for (internal_ptr = internal;
1837 raw_src += symesz, internal_ptr++)
1841 bfd_coff_swap_sym_in (abfd, (void *) raw_src,
1842 (void *) & internal_ptr->u.syment);
1843 symbol_ptr = internal_ptr;
1844 internal_ptr->is_sym = TRUE;
1846 /* PR 17512: file: 1353-1166-0.004. */
1847 if (symbol_ptr->u.syment.n_sclass == C_FILE
1848 && symbol_ptr->u.syment.n_numaux > 0
1849 && raw_src + symesz + symbol_ptr->u.syment.n_numaux
1852 bfd_release (abfd, internal);
1857 i < symbol_ptr->u.syment.n_numaux;
1861 /* PR 17512: Prevent buffer overrun. */
1862 if (internal_ptr >= internal_end)
1864 bfd_release (abfd, internal);
1869 bfd_coff_swap_aux_in (abfd, (void *) raw_src,
1870 symbol_ptr->u.syment.n_type,
1871 symbol_ptr->u.syment.n_sclass,
1872 (int) i, symbol_ptr->u.syment.n_numaux,
1873 &(internal_ptr->u.auxent));
1875 internal_ptr->is_sym = FALSE;
1876 coff_pointerize_aux (abfd, internal, symbol_ptr, i,
1877 internal_ptr, internal_end);
1881 /* Free the raw symbols, but not the strings (if we have them). */
1882 obj_coff_keep_strings (abfd) = TRUE;
1883 if (! _bfd_coff_free_symbols (abfd))
1886 for (internal_ptr = internal; internal_ptr < internal_end;
1889 BFD_ASSERT (internal_ptr->is_sym);
1891 if (internal_ptr->u.syment.n_sclass == C_FILE
1892 && internal_ptr->u.syment.n_numaux > 0)
1894 combined_entry_type * aux = internal_ptr + 1;
1896 /* Make a file symbol point to the name in the auxent, since
1897 the text ".file" is redundant. */
1898 BFD_ASSERT (! aux->is_sym);
1900 if (aux->u.auxent.x_file.x_n.x_zeroes == 0)
1902 /* The filename is a long one, point into the string table. */
1903 if (string_table == NULL)
1905 string_table = _bfd_coff_read_string_table (abfd);
1906 if (string_table == NULL)
1910 if ((bfd_size_type)(aux->u.auxent.x_file.x_n.x_offset)
1911 >= obj_coff_strings_len (abfd))
1912 internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) _("<corrupt>");
1914 internal_ptr->u.syment._n._n_n._n_offset =
1915 (bfd_hostptr_t) (string_table + (aux->u.auxent.x_file.x_n.x_offset));
1919 /* Ordinary short filename, put into memory anyway. The
1920 Microsoft PE tools sometimes store a filename in
1921 multiple AUX entries. */
1922 if (internal_ptr->u.syment.n_numaux > 1
1923 && coff_data (abfd)->pe)
1924 internal_ptr->u.syment._n._n_n._n_offset =
1927 aux->u.auxent.x_file.x_fname,
1928 internal_ptr->u.syment.n_numaux * symesz);
1930 internal_ptr->u.syment._n._n_n._n_offset =
1933 aux->u.auxent.x_file.x_fname,
1934 (size_t) bfd_coff_filnmlen (abfd)));
1939 if (internal_ptr->u.syment._n._n_n._n_zeroes != 0)
1941 /* This is a "short" name. Make it long. */
1945 /* Find the length of this string without walking into memory
1947 for (i = 0; i < 8; ++i)
1948 if (internal_ptr->u.syment._n._n_name[i] == '\0')
1951 newstring = (char *) bfd_zalloc (abfd, (bfd_size_type) (i + 1));
1952 if (newstring == NULL)
1954 strncpy (newstring, internal_ptr->u.syment._n._n_name, i);
1955 internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) newstring;
1956 internal_ptr->u.syment._n._n_n._n_zeroes = 0;
1958 else if (internal_ptr->u.syment._n._n_n._n_offset == 0)
1959 internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) "";
1960 else if (!bfd_coff_symname_in_debug (abfd, &internal_ptr->u.syment))
1962 /* Long name already. Point symbol at the string in the
1964 if (string_table == NULL)
1966 string_table = _bfd_coff_read_string_table (abfd);
1967 if (string_table == NULL)
1970 if (internal_ptr->u.syment._n._n_n._n_offset >= obj_coff_strings_len (abfd)
1971 || string_table + internal_ptr->u.syment._n._n_n._n_offset < string_table)
1972 internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) _("<corrupt>");
1974 internal_ptr->u.syment._n._n_n._n_offset =
1977 + internal_ptr->u.syment._n._n_n._n_offset));
1981 /* Long name in debug section. Very similar. */
1982 if (debug_sec_data == NULL)
1983 debug_sec_data = build_debug_section (abfd, & debug_sec);
1984 if (debug_sec_data != NULL)
1986 BFD_ASSERT (debug_sec != NULL);
1987 /* PR binutils/17512: Catch out of range offsets into the debug data. */
1988 if (internal_ptr->u.syment._n._n_n._n_offset > debug_sec->size
1989 || debug_sec_data + internal_ptr->u.syment._n._n_n._n_offset < debug_sec_data)
1990 internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) _("<corrupt>");
1992 internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t)
1993 (debug_sec_data + internal_ptr->u.syment._n._n_n._n_offset);
1996 internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) "";
1999 internal_ptr += internal_ptr->u.syment.n_numaux;
2002 obj_raw_syments (abfd) = internal;
2003 BFD_ASSERT (obj_raw_syment_count (abfd)
2004 == (unsigned int) (internal_ptr - internal));
2010 coff_get_reloc_upper_bound (bfd *abfd, sec_ptr asect)
2012 if (bfd_get_format (abfd) != bfd_object)
2014 bfd_set_error (bfd_error_invalid_operation);
2017 return (asect->reloc_count + 1) * sizeof (arelent *);
2021 coff_make_empty_symbol (bfd *abfd)
2023 bfd_size_type amt = sizeof (coff_symbol_type);
2024 coff_symbol_type *new_symbol = (coff_symbol_type *) bfd_zalloc (abfd, amt);
2026 if (new_symbol == NULL)
2028 new_symbol->symbol.section = 0;
2029 new_symbol->native = NULL;
2030 new_symbol->lineno = NULL;
2031 new_symbol->done_lineno = FALSE;
2032 new_symbol->symbol.the_bfd = abfd;
2034 return & new_symbol->symbol;
2037 /* Make a debugging symbol. */
2040 coff_bfd_make_debug_symbol (bfd *abfd,
2041 void * ptr ATTRIBUTE_UNUSED,
2042 unsigned long sz ATTRIBUTE_UNUSED)
2044 bfd_size_type amt = sizeof (coff_symbol_type);
2045 coff_symbol_type *new_symbol = (coff_symbol_type *) bfd_alloc (abfd, amt);
2047 if (new_symbol == NULL)
2049 /* @@ The 10 is a guess at a plausible maximum number of aux entries
2050 (but shouldn't be a constant). */
2051 amt = sizeof (combined_entry_type) * 10;
2052 new_symbol->native = (combined_entry_type *) bfd_zalloc (abfd, amt);
2053 if (!new_symbol->native)
2055 new_symbol->native->is_sym = TRUE;
2056 new_symbol->symbol.section = bfd_abs_section_ptr;
2057 new_symbol->symbol.flags = BSF_DEBUGGING;
2058 new_symbol->lineno = NULL;
2059 new_symbol->done_lineno = FALSE;
2060 new_symbol->symbol.the_bfd = abfd;
2062 return & new_symbol->symbol;
2066 coff_get_symbol_info (bfd *abfd, asymbol *symbol, symbol_info *ret)
2068 bfd_symbol_info (symbol, ret);
2070 if (coffsymbol (symbol)->native != NULL
2071 && coffsymbol (symbol)->native->fix_value
2072 && coffsymbol (symbol)->native->is_sym)
2073 ret->value = coffsymbol (symbol)->native->u.syment.n_value -
2074 (bfd_hostptr_t) obj_raw_syments (abfd);
2077 /* Print out information about COFF symbol. */
2080 coff_print_symbol (bfd *abfd,
2083 bfd_print_symbol_type how)
2085 FILE * file = (FILE *) filep;
2089 case bfd_print_symbol_name:
2090 fprintf (file, "%s", symbol->name);
2093 case bfd_print_symbol_more:
2094 fprintf (file, "coff %s %s",
2095 coffsymbol (symbol)->native ? "n" : "g",
2096 coffsymbol (symbol)->lineno ? "l" : " ");
2099 case bfd_print_symbol_all:
2100 if (coffsymbol (symbol)->native)
2104 combined_entry_type *combined = coffsymbol (symbol)->native;
2105 combined_entry_type *root = obj_raw_syments (abfd);
2106 struct lineno_cache_entry *l = coffsymbol (symbol)->lineno;
2108 fprintf (file, "[%3ld]", (long) (combined - root));
2110 /* PR 17512: file: 079-33786-0.001:0.1. */
2111 if (combined < obj_raw_syments (abfd)
2112 || combined >= obj_raw_syments (abfd) + obj_raw_syment_count (abfd))
2114 fprintf (file, _("<corrupt info> %s"), symbol->name);
2118 BFD_ASSERT (combined->is_sym);
2119 if (! combined->fix_value)
2120 val = (bfd_vma) combined->u.syment.n_value;
2122 val = combined->u.syment.n_value - (bfd_hostptr_t) root;
2124 fprintf (file, "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x",
2125 combined->u.syment.n_scnum,
2126 combined->u.syment.n_flags,
2127 combined->u.syment.n_type,
2128 combined->u.syment.n_sclass,
2129 combined->u.syment.n_numaux);
2130 bfd_fprintf_vma (abfd, file, val);
2131 fprintf (file, " %s", symbol->name);
2133 for (aux = 0; aux < combined->u.syment.n_numaux; aux++)
2135 combined_entry_type *auxp = combined + aux + 1;
2138 BFD_ASSERT (! auxp->is_sym);
2140 tagndx = auxp->u.auxent.x_sym.x_tagndx.p - root;
2142 tagndx = auxp->u.auxent.x_sym.x_tagndx.l;
2144 fprintf (file, "\n");
2146 if (bfd_coff_print_aux (abfd, file, root, combined, auxp, aux))
2149 switch (combined->u.syment.n_sclass)
2152 fprintf (file, "File ");
2156 if (combined->u.syment.n_type == T_NULL)
2157 /* Probably a section symbol ? */
2159 fprintf (file, "AUX scnlen 0x%lx nreloc %d nlnno %d",
2160 (unsigned long) auxp->u.auxent.x_scn.x_scnlen,
2161 auxp->u.auxent.x_scn.x_nreloc,
2162 auxp->u.auxent.x_scn.x_nlinno);
2163 if (auxp->u.auxent.x_scn.x_checksum != 0
2164 || auxp->u.auxent.x_scn.x_associated != 0
2165 || auxp->u.auxent.x_scn.x_comdat != 0)
2166 fprintf (file, " checksum 0x%lx assoc %d comdat %d",
2167 auxp->u.auxent.x_scn.x_checksum,
2168 auxp->u.auxent.x_scn.x_associated,
2169 auxp->u.auxent.x_scn.x_comdat);
2175 if (ISFCN (combined->u.syment.n_type))
2180 next = (auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p
2183 next = auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l;
2184 llnos = auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_lnnoptr;
2186 "AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld",
2188 (unsigned long) auxp->u.auxent.x_sym.x_misc.x_fsize,
2194 fprintf (file, "AUX lnno %d size 0x%x tagndx %ld",
2195 auxp->u.auxent.x_sym.x_misc.x_lnsz.x_lnno,
2196 auxp->u.auxent.x_sym.x_misc.x_lnsz.x_size,
2199 fprintf (file, " endndx %ld",
2201 (auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p
2209 fprintf (file, "\n%s :", l->u.sym->name);
2211 while (l->line_number)
2213 if (l->line_number > 0)
2215 fprintf (file, "\n%4d : ", l->line_number);
2216 bfd_fprintf_vma (abfd, file, l->u.offset + symbol->section->vma);
2224 bfd_print_symbol_vandf (abfd, (void *) file, symbol);
2225 fprintf (file, " %-5s %s %s %s",
2226 symbol->section->name,
2227 coffsymbol (symbol)->native ? "n" : "g",
2228 coffsymbol (symbol)->lineno ? "l" : " ",
2234 /* Return whether a symbol name implies a local symbol. In COFF,
2235 local symbols generally start with ``.L''. Most targets use this
2236 function for the is_local_label_name entry point, but some may
2240 _bfd_coff_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
2243 return name[0] == '.' && name[1] == 'L';
2246 /* Provided a BFD, a section and an offset (in bytes, not octets) into the
2247 section, calculate and return the name of the source file and the line
2248 nearest to the wanted location. */
2251 coff_find_nearest_line_with_names (bfd *abfd,
2255 const char **filename_ptr,
2256 const char **functionname_ptr,
2257 unsigned int *line_ptr,
2258 const struct dwarf_debug_section *debug_sections)
2262 unsigned int line_base;
2263 coff_data_type *cof = coff_data (abfd);
2264 /* Run through the raw syments if available. */
2265 combined_entry_type *p;
2266 combined_entry_type *pend;
2268 struct coff_section_tdata *sec_data;
2271 /* Before looking through the symbol table, try to use a .stab
2272 section to find the information. */
2273 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
2274 &found, filename_ptr,
2275 functionname_ptr, line_ptr,
2276 &coff_data(abfd)->line_info))
2282 /* Also try examining DWARF2 debugging information. */
2283 if (_bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset,
2284 filename_ptr, functionname_ptr,
2285 line_ptr, NULL, debug_sections, 0,
2286 &coff_data(abfd)->dwarf2_find_line_info))
2289 sec_data = coff_section_data (abfd, section);
2291 /* If the DWARF lookup failed, but there is DWARF information available
2292 then the problem might be that the file has been rebased. This tool
2293 changes the VMAs of all the sections, but it does not update the DWARF
2294 information. So try again, using a bias against the address sought. */
2295 if (coff_data (abfd)->dwarf2_find_line_info != NULL)
2297 bfd_signed_vma bias = 0;
2299 /* Create a cache of the result for the next call. */
2300 if (sec_data == NULL && section->owner == abfd)
2302 amt = sizeof (struct coff_section_tdata);
2303 section->used_by_bfd = bfd_zalloc (abfd, amt);
2304 sec_data = (struct coff_section_tdata *) section->used_by_bfd;
2307 if (sec_data != NULL && sec_data->saved_bias)
2308 bias = sec_data->saved_bias;
2311 bias = _bfd_dwarf2_find_symbol_bias (symbols,
2312 & coff_data (abfd)->dwarf2_find_line_info);
2316 sec_data->saved_bias = TRUE;
2317 sec_data->bias = bias;
2322 && _bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section,
2324 filename_ptr, functionname_ptr,
2325 line_ptr, NULL, debug_sections, 0,
2326 &coff_data(abfd)->dwarf2_find_line_info))
2331 *functionname_ptr = 0;
2334 /* Don't try and find line numbers in a non coff file. */
2335 if (!bfd_family_coff (abfd))
2341 /* Find the first C_FILE symbol. */
2342 p = cof->raw_syments;
2346 pend = p + cof->raw_syment_count;
2349 BFD_ASSERT (p->is_sym);
2350 if (p->u.syment.n_sclass == C_FILE)
2352 p += 1 + p->u.syment.n_numaux;
2360 /* Look through the C_FILE symbols to find the best one. */
2361 sec_vma = bfd_get_section_vma (abfd, section);
2362 *filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
2363 maxdiff = (bfd_vma) 0 - (bfd_vma) 1;
2367 combined_entry_type *p2;
2369 for (p2 = p + 1 + p->u.syment.n_numaux;
2371 p2 += 1 + p2->u.syment.n_numaux)
2373 BFD_ASSERT (p2->is_sym);
2374 if (p2->u.syment.n_scnum > 0
2376 == coff_section_from_bfd_index (abfd,
2377 p2->u.syment.n_scnum)))
2379 if (p2->u.syment.n_sclass == C_FILE)
2388 file_addr = (bfd_vma) p2->u.syment.n_value;
2389 /* PR 11512: Include the section address of the function name symbol. */
2390 if (p2->u.syment.n_scnum > 0)
2391 file_addr += coff_section_from_bfd_index (abfd,
2392 p2->u.syment.n_scnum)->vma;
2393 /* We use <= MAXDIFF here so that if we get a zero length
2394 file, we actually use the next file entry. */
2396 && offset + sec_vma >= file_addr
2397 && offset + sec_vma - file_addr <= maxdiff)
2399 *filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
2400 maxdiff = offset + sec_vma - p2->u.syment.n_value;
2403 /* Avoid endless loops on erroneous files by ensuring that
2404 we always move forward in the file. */
2405 if (p >= cof->raw_syments + p->u.syment.n_value)
2408 p = cof->raw_syments + p->u.syment.n_value;
2409 if (p > pend || p->u.syment.n_sclass != C_FILE)
2414 if (section->lineno_count == 0)
2416 *functionname_ptr = NULL;
2421 /* Now wander though the raw linenumbers of the section.
2422 If we have been called on this section before, and the offset
2423 we want is further down then we can prime the lookup loop. */
2424 if (sec_data != NULL
2426 && offset >= sec_data->offset)
2429 *functionname_ptr = sec_data->function;
2430 line_base = sec_data->line_base;
2438 if (section->lineno != NULL)
2440 bfd_vma last_value = 0;
2442 l = §ion->lineno[i];
2444 for (; i < section->lineno_count; i++)
2446 if (l->line_number == 0)
2448 /* Get the symbol this line number points at. */
2449 coff_symbol_type *coff = (coff_symbol_type *) (l->u.sym);
2450 if (coff->symbol.value > offset)
2453 *functionname_ptr = coff->symbol.name;
2454 last_value = coff->symbol.value;
2457 combined_entry_type *s = coff->native;
2459 BFD_ASSERT (s->is_sym);
2460 s = s + 1 + s->u.syment.n_numaux;
2462 /* In XCOFF a debugging symbol can follow the
2464 if (s->u.syment.n_scnum == N_DEBUG)
2465 s = s + 1 + s->u.syment.n_numaux;
2467 /* S should now point to the .bf of the function. */
2468 if (s->u.syment.n_numaux)
2470 /* The linenumber is stored in the auxent. */
2471 union internal_auxent *a = &((s + 1)->u.auxent);
2473 line_base = a->x_sym.x_misc.x_lnsz.x_lnno;
2474 *line_ptr = line_base;
2480 if (l->u.offset > offset)
2482 *line_ptr = l->line_number + line_base - 1;
2487 /* If we fell off the end of the loop, then assume that this
2488 symbol has no line number info. Otherwise, symbols with no
2489 line number info get reported with the line number of the
2490 last line of the last symbol which does have line number
2491 info. We use 0x100 as a slop to account for cases where the
2492 last line has executable code. */
2493 if (i >= section->lineno_count
2495 && offset - last_value > 0x100)
2497 *functionname_ptr = NULL;
2502 /* Cache the results for the next call. */
2503 if (sec_data == NULL && section->owner == abfd)
2505 amt = sizeof (struct coff_section_tdata);
2506 section->used_by_bfd = bfd_zalloc (abfd, amt);
2507 sec_data = (struct coff_section_tdata *) section->used_by_bfd;
2510 if (sec_data != NULL)
2512 sec_data->offset = offset;
2513 sec_data->i = i - 1;
2514 sec_data->function = *functionname_ptr;
2515 sec_data->line_base = line_base;
2522 coff_find_nearest_line (bfd *abfd,
2526 const char **filename_ptr,
2527 const char **functionname_ptr,
2528 unsigned int *line_ptr,
2529 unsigned int *discriminator_ptr)
2531 if (discriminator_ptr)
2532 *discriminator_ptr = 0;
2533 return coff_find_nearest_line_with_names (abfd, symbols, section, offset,
2534 filename_ptr, functionname_ptr,
2535 line_ptr, dwarf_debug_sections);
2539 coff_find_inliner_info (bfd *abfd,
2540 const char **filename_ptr,
2541 const char **functionname_ptr,
2542 unsigned int *line_ptr)
2546 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
2547 functionname_ptr, line_ptr,
2548 &coff_data(abfd)->dwarf2_find_line_info);
2553 coff_sizeof_headers (bfd *abfd, struct bfd_link_info *info)
2557 if (!bfd_link_relocatable (info))
2558 size = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
2560 size = bfd_coff_filhsz (abfd);
2562 size += abfd->section_count * bfd_coff_scnhsz (abfd);
2566 /* Change the class of a coff symbol held by BFD. */
2569 bfd_coff_set_symbol_class (bfd * abfd,
2571 unsigned int symbol_class)
2573 coff_symbol_type * csym;
2575 csym = coff_symbol_from (symbol);
2578 bfd_set_error (bfd_error_invalid_operation);
2581 else if (csym->native == NULL)
2583 /* This is an alien symbol which no native coff backend data.
2584 We cheat here by creating a fake native entry for it and
2585 then filling in the class. This code is based on that in
2586 coff_write_alien_symbol(). */
2588 combined_entry_type * native;
2589 bfd_size_type amt = sizeof (* native);
2591 native = (combined_entry_type *) bfd_zalloc (abfd, amt);
2595 native->is_sym = TRUE;
2596 native->u.syment.n_type = T_NULL;
2597 native->u.syment.n_sclass = symbol_class;
2599 if (bfd_is_und_section (symbol->section))
2601 native->u.syment.n_scnum = N_UNDEF;
2602 native->u.syment.n_value = symbol->value;
2604 else if (bfd_is_com_section (symbol->section))
2606 native->u.syment.n_scnum = N_UNDEF;
2607 native->u.syment.n_value = symbol->value;
2611 native->u.syment.n_scnum =
2612 symbol->section->output_section->target_index;
2613 native->u.syment.n_value = (symbol->value
2614 + symbol->section->output_offset);
2615 if (! obj_pe (abfd))
2616 native->u.syment.n_value += symbol->section->output_section->vma;
2618 /* Copy the any flags from the file header into the symbol.
2620 native->u.syment.n_flags = bfd_asymbol_bfd (& csym->symbol)->flags;
2623 csym->native = native;
2626 csym->native->u.syment.n_sclass = symbol_class;
2632 _bfd_coff_section_already_linked (bfd *abfd,
2634 struct bfd_link_info *info)
2637 const char *name, *key;
2638 struct bfd_section_already_linked *l;
2639 struct bfd_section_already_linked_hash_entry *already_linked_list;
2640 struct coff_comdat_info *s_comdat;
2643 if ((flags & SEC_LINK_ONCE) == 0)
2646 /* The COFF backend linker doesn't support group sections. */
2647 if ((flags & SEC_GROUP) != 0)
2650 name = bfd_get_section_name (abfd, sec);
2651 s_comdat = bfd_coff_get_comdat_section (abfd, sec);
2653 if (s_comdat != NULL)
2654 key = s_comdat->name;
2657 if (CONST_STRNEQ (name, ".gnu.linkonce.")
2658 && (key = strchr (name + sizeof (".gnu.linkonce.") - 1, '.')) != NULL)
2661 /* FIXME: gcc as of 2011-09 emits sections like .text$<key>,
2662 .xdata$<key> and .pdata$<key> only the first of which has a
2663 comdat key. Should these all match the LTO IR key? */
2667 already_linked_list = bfd_section_already_linked_table_lookup (key);
2669 for (l = already_linked_list->entry; l != NULL; l = l->next)
2671 struct coff_comdat_info *l_comdat;
2673 l_comdat = bfd_coff_get_comdat_section (l->sec->owner, l->sec);
2675 /* The section names must match, and both sections must be
2676 comdat and have the same comdat name, or both sections must
2677 be non-comdat. LTO IR plugin sections are an exception. They
2678 are always named .gnu.linkonce.t.<key> (<key> is some string)
2679 and match any comdat section with comdat name of <key>, and
2680 any linkonce section with the same suffix, ie.
2681 .gnu.linkonce.*.<key>. */
2682 if (((s_comdat != NULL) == (l_comdat != NULL)
2683 && strcmp (name, l->sec->name) == 0)
2684 || (l->sec->owner->flags & BFD_PLUGIN) != 0)
2686 /* The section has already been linked. See if we should
2688 return _bfd_handle_already_linked (sec, l, info);
2692 /* This is the first section with this name. Record it. */
2693 if (!bfd_section_already_linked_table_insert (already_linked_list, sec))
2694 info->callbacks->einfo (_("%F%P: already_linked_table: %E\n"));
2698 /* Initialize COOKIE for input bfd ABFD. */
2701 init_reloc_cookie (struct coff_reloc_cookie *cookie,
2702 struct bfd_link_info *info ATTRIBUTE_UNUSED,
2705 /* Sometimes the symbol table does not yet have been loaded here. */
2706 bfd_coff_slurp_symbol_table (abfd);
2708 cookie->abfd = abfd;
2709 cookie->sym_hashes = obj_coff_sym_hashes (abfd);
2711 cookie->symbols = obj_symbols (abfd);
2716 /* Free the memory allocated by init_reloc_cookie, if appropriate. */
2719 fini_reloc_cookie (struct coff_reloc_cookie *cookie ATTRIBUTE_UNUSED,
2720 bfd *abfd ATTRIBUTE_UNUSED)
2722 /* Nothing to do. */
2725 /* Initialize the relocation information in COOKIE for input section SEC
2726 of input bfd ABFD. */
2729 init_reloc_cookie_rels (struct coff_reloc_cookie *cookie,
2730 struct bfd_link_info *info ATTRIBUTE_UNUSED,
2734 if (sec->reloc_count == 0)
2736 cookie->rels = NULL;
2737 cookie->relend = NULL;
2742 cookie->rels = _bfd_coff_read_internal_relocs (abfd, sec, FALSE, NULL, 0, NULL);
2744 if (cookie->rels == NULL)
2747 cookie->rel = cookie->rels;
2748 cookie->relend = (cookie->rels + sec->reloc_count);
2752 /* Free the memory allocated by init_reloc_cookie_rels,
2756 fini_reloc_cookie_rels (struct coff_reloc_cookie *cookie,
2760 /* PR 20401. The relocs may not have been cached, so check first.
2761 If the relocs were loaded by init_reloc_cookie_rels() then this
2762 will be the case. FIXME: Would performance be improved if the
2763 relocs *were* cached ? */
2764 && coff_section_data (NULL, sec)
2765 && coff_section_data (NULL, sec)->relocs != cookie->rels)
2766 free (cookie->rels);
2769 /* Initialize the whole of COOKIE for input section SEC. */
2772 init_reloc_cookie_for_section (struct coff_reloc_cookie *cookie,
2773 struct bfd_link_info *info,
2776 if (!init_reloc_cookie (cookie, info, sec->owner))
2779 if (!init_reloc_cookie_rels (cookie, info, sec->owner, sec))
2781 fini_reloc_cookie (cookie, sec->owner);
2787 /* Free the memory allocated by init_reloc_cookie_for_section,
2791 fini_reloc_cookie_for_section (struct coff_reloc_cookie *cookie,
2794 fini_reloc_cookie_rels (cookie, sec);
2795 fini_reloc_cookie (cookie, sec->owner);
2799 _bfd_coff_gc_mark_hook (asection *sec,
2800 struct bfd_link_info *info ATTRIBUTE_UNUSED,
2801 struct internal_reloc *rel ATTRIBUTE_UNUSED,
2802 struct coff_link_hash_entry *h,
2803 struct internal_syment *sym)
2807 switch (h->root.type)
2809 case bfd_link_hash_defined:
2810 case bfd_link_hash_defweak:
2811 return h->root.u.def.section;
2813 case bfd_link_hash_common:
2814 return h->root.u.c.p->section;
2816 case bfd_link_hash_undefweak:
2817 if (h->symbol_class == C_NT_WEAK && h->numaux == 1)
2819 /* PE weak externals. A weak symbol may include an auxiliary
2820 record indicating that if the weak symbol is not resolved,
2821 another external symbol is used instead. */
2822 struct coff_link_hash_entry *h2 =
2823 h->auxbfd->tdata.coff_obj_data->sym_hashes[
2824 h->aux->x_sym.x_tagndx.l];
2826 if (h2 && h2->root.type != bfd_link_hash_undefined)
2827 return h2->root.u.def.section;
2831 case bfd_link_hash_undefined:
2838 return coff_section_from_bfd_index (sec->owner, sym->n_scnum);
2841 /* COOKIE->rel describes a relocation against section SEC, which is
2842 a section we've decided to keep. Return the section that contains
2843 the relocation symbol, or NULL if no section contains it. */
2846 _bfd_coff_gc_mark_rsec (struct bfd_link_info *info, asection *sec,
2847 coff_gc_mark_hook_fn gc_mark_hook,
2848 struct coff_reloc_cookie *cookie)
2850 struct coff_link_hash_entry *h;
2852 h = cookie->sym_hashes[cookie->rel->r_symndx];
2855 while (h->root.type == bfd_link_hash_indirect
2856 || h->root.type == bfd_link_hash_warning)
2857 h = (struct coff_link_hash_entry *) h->root.u.i.link;
2859 return (*gc_mark_hook) (sec, info, cookie->rel, h, NULL);
2862 return (*gc_mark_hook) (sec, info, cookie->rel, NULL,
2864 + obj_convert (sec->owner)[cookie->rel->r_symndx])->native->u.syment);
2867 static bfd_boolean _bfd_coff_gc_mark
2868 (struct bfd_link_info *, asection *, coff_gc_mark_hook_fn);
2870 /* COOKIE->rel describes a relocation against section SEC, which is
2871 a section we've decided to keep. Mark the section that contains
2872 the relocation symbol. */
2875 _bfd_coff_gc_mark_reloc (struct bfd_link_info *info,
2877 coff_gc_mark_hook_fn gc_mark_hook,
2878 struct coff_reloc_cookie *cookie)
2882 rsec = _bfd_coff_gc_mark_rsec (info, sec, gc_mark_hook, cookie);
2883 if (rsec && !rsec->gc_mark)
2885 if (bfd_get_flavour (rsec->owner) != bfd_target_coff_flavour)
2887 else if (!_bfd_coff_gc_mark (info, rsec, gc_mark_hook))
2893 /* The mark phase of garbage collection. For a given section, mark
2894 it and any sections in this section's group, and all the sections
2895 which define symbols to which it refers. */
2898 _bfd_coff_gc_mark (struct bfd_link_info *info,
2900 coff_gc_mark_hook_fn gc_mark_hook)
2902 bfd_boolean ret = TRUE;
2906 /* Look through the section relocs. */
2907 if ((sec->flags & SEC_RELOC) != 0
2908 && sec->reloc_count > 0)
2910 struct coff_reloc_cookie cookie;
2912 if (!init_reloc_cookie_for_section (&cookie, info, sec))
2916 for (; cookie.rel < cookie.relend; cookie.rel++)
2918 if (!_bfd_coff_gc_mark_reloc (info, sec, gc_mark_hook, &cookie))
2924 fini_reloc_cookie_for_section (&cookie, sec);
2932 _bfd_coff_gc_mark_extra_sections (struct bfd_link_info *info,
2933 coff_gc_mark_hook_fn mark_hook ATTRIBUTE_UNUSED)
2937 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2940 bfd_boolean some_kept;
2942 if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour)
2945 /* Ensure all linker created sections are kept, and see whether
2946 any other section is already marked. */
2948 for (isec = ibfd->sections; isec != NULL; isec = isec->next)
2950 if ((isec->flags & SEC_LINKER_CREATED) != 0)
2952 else if (isec->gc_mark)
2956 /* If no section in this file will be kept, then we can
2957 toss out debug sections. */
2961 /* Keep debug and special sections like .comment when they are
2962 not part of a group, or when we have single-member groups. */
2963 for (isec = ibfd->sections; isec != NULL; isec = isec->next)
2964 if ((isec->flags & SEC_DEBUGGING) != 0
2965 || (isec->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) == 0)
2971 /* Sweep symbols in swept sections. Called via coff_link_hash_traverse. */
2974 coff_gc_sweep_symbol (struct coff_link_hash_entry *h,
2975 void *data ATTRIBUTE_UNUSED)
2977 if (h->root.type == bfd_link_hash_warning)
2978 h = (struct coff_link_hash_entry *) h->root.u.i.link;
2980 if ((h->root.type == bfd_link_hash_defined
2981 || h->root.type == bfd_link_hash_defweak)
2982 && !h->root.u.def.section->gc_mark
2983 && !(h->root.u.def.section->owner->flags & DYNAMIC))
2985 /* Do our best to hide the symbol. */
2986 h->root.u.def.section = bfd_und_section_ptr;
2987 h->symbol_class = C_HIDDEN;
2993 /* The sweep phase of garbage collection. Remove all garbage sections. */
2995 typedef bfd_boolean (*gc_sweep_hook_fn)
2996 (bfd *, struct bfd_link_info *, asection *, const struct internal_reloc *);
2999 coff_gc_sweep (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
3003 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
3007 if (bfd_get_flavour (sub) != bfd_target_coff_flavour)
3010 for (o = sub->sections; o != NULL; o = o->next)
3012 /* Keep debug and special sections. */
3013 if ((o->flags & (SEC_DEBUGGING | SEC_LINKER_CREATED)) != 0
3014 || (o->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) == 0)
3016 else if (CONST_STRNEQ (o->name, ".idata")
3017 || CONST_STRNEQ (o->name, ".pdata")
3018 || CONST_STRNEQ (o->name, ".xdata")
3019 || CONST_STRNEQ (o->name, ".rsrc"))
3025 /* Skip sweeping sections already excluded. */
3026 if (o->flags & SEC_EXCLUDE)
3029 /* Since this is early in the link process, it is simple
3030 to remove a section from the output. */
3031 o->flags |= SEC_EXCLUDE;
3033 if (info->print_gc_sections && o->size != 0)
3034 /* xgettext: c-format */
3035 _bfd_error_handler (_("removing unused section '%pA' in file '%pB'"),
3039 /* But we also have to update some of the relocation
3040 info we collected before. */
3042 && (o->flags & SEC_RELOC) != 0
3043 && o->reloc_count > 0
3044 && !bfd_is_abs_section (o->output_section))
3046 struct internal_reloc *internal_relocs;
3050 = _bfd_coff_link_read_relocs (o->owner, o, NULL, NULL,
3052 if (internal_relocs == NULL)
3055 r = (*gc_sweep_hook) (o->owner, info, o, internal_relocs);
3057 if (coff_section_data (o)->relocs != internal_relocs)
3058 free (internal_relocs);
3067 /* Remove the symbols that were in the swept sections from the dynamic
3069 coff_link_hash_traverse (coff_hash_table (info), coff_gc_sweep_symbol,
3075 /* Keep all sections containing symbols undefined on the command-line,
3076 and the section containing the entry symbol. */
3079 _bfd_coff_gc_keep (struct bfd_link_info *info)
3081 struct bfd_sym_chain *sym;
3083 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
3085 struct coff_link_hash_entry *h;
3087 h = coff_link_hash_lookup (coff_hash_table (info), sym->name,
3088 FALSE, FALSE, FALSE);
3091 && (h->root.type == bfd_link_hash_defined
3092 || h->root.type == bfd_link_hash_defweak)
3093 && !bfd_is_abs_section (h->root.u.def.section))
3094 h->root.u.def.section->flags |= SEC_KEEP;
3098 /* Do mark and sweep of unused sections. */
3101 bfd_coff_gc_sections (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
3105 /* FIXME: Should we implement this? */
3107 const bfd_coff_backend_data *bed = coff_backend_info (abfd);
3109 if (!bed->can_gc_sections
3110 || !is_coff_hash_table (info->hash))
3112 _bfd_error_handler(_("warning: gc-sections option ignored"));
3117 _bfd_coff_gc_keep (info);
3119 /* Grovel through relocs to find out who stays ... */
3120 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
3124 if (bfd_get_flavour (sub) != bfd_target_coff_flavour)
3127 for (o = sub->sections; o != NULL; o = o->next)
3129 if (((o->flags & (SEC_EXCLUDE | SEC_KEEP)) == SEC_KEEP
3130 || CONST_STRNEQ (o->name, ".vectors")
3131 || CONST_STRNEQ (o->name, ".ctors")
3132 || CONST_STRNEQ (o->name, ".dtors"))
3135 if (!_bfd_coff_gc_mark (info, o, _bfd_coff_gc_mark_hook))
3141 /* Allow the backend to mark additional target specific sections. */
3142 _bfd_coff_gc_mark_extra_sections (info, _bfd_coff_gc_mark_hook);
3144 /* ... and mark SEC_EXCLUDE for those that go. */
3145 return coff_gc_sweep (abfd, info);