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
43 #include "coff/internal.h"
46 /* Take a section header read from a coff file (in HOST byte order),
47 and make a BFD "section" out of it. This is used by ECOFF. */
50 make_a_section_from_file (bfd *abfd,
51 struct internal_scnhdr *hdr,
52 unsigned int target_index)
54 asection *return_section;
56 bfd_boolean result = TRUE;
61 /* Handle long section names as in PE. On reading, we want to
62 accept long names if the format permits them at all, regardless
63 of the current state of the flag that dictates if we would generate
64 them in outputs; this construct checks if that is the case by
65 attempting to set the flag, without changing its state; the call
66 will fail for formats that do not support long names at all. */
67 if (bfd_coff_set_long_section_names (abfd, bfd_coff_long_section_names (abfd))
68 && hdr->s_name[0] == '/')
75 /* Flag that this BFD uses long names, even though the format might
76 expect them to be off by default. This won't directly affect the
77 format of any output BFD created from this one, but the information
78 can be used to decide what to do. */
79 bfd_coff_set_long_section_names (abfd, TRUE);
80 memcpy (buf, hdr->s_name + 1, SCNNMLEN - 1);
81 buf[SCNNMLEN - 1] = '\0';
82 strindex = strtol (buf, &p, 10);
83 if (*p == '\0' && strindex >= 0)
85 strings = _bfd_coff_read_string_table (abfd);
88 if ((bfd_size_type)(strindex + 2) >= obj_coff_strings_len (abfd))
91 name = (char *) bfd_alloc (abfd,
92 (bfd_size_type) strlen (strings) + 1 + 1);
95 strcpy (name, strings);
101 /* Assorted wastage to null-terminate the name, thanks AT&T! */
102 name = (char *) bfd_alloc (abfd,
103 (bfd_size_type) sizeof (hdr->s_name) + 1 + 1);
106 strncpy (name, (char *) &hdr->s_name[0], sizeof (hdr->s_name));
107 name[sizeof (hdr->s_name)] = 0;
110 return_section = bfd_make_section_anyway (abfd, name);
111 if (return_section == NULL)
114 return_section->vma = hdr->s_vaddr;
115 return_section->lma = hdr->s_paddr;
116 return_section->size = hdr->s_size;
117 return_section->filepos = hdr->s_scnptr;
118 return_section->rel_filepos = hdr->s_relptr;
119 return_section->reloc_count = hdr->s_nreloc;
121 bfd_coff_set_alignment_hook (abfd, return_section, hdr);
123 return_section->line_filepos = hdr->s_lnnoptr;
125 return_section->lineno_count = hdr->s_nlnno;
126 return_section->userdata = NULL;
127 return_section->next = NULL;
128 return_section->target_index = target_index;
130 if (! bfd_coff_styp_to_sec_flags_hook (abfd, hdr, name, return_section,
134 return_section->flags = flags;
136 /* At least on i386-coff, the line number count for a shared library
137 section must be ignored. */
138 if ((return_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
139 return_section->lineno_count = 0;
141 if (hdr->s_nreloc != 0)
142 return_section->flags |= SEC_RELOC;
143 /* FIXME: should this check 'hdr->s_size > 0'. */
144 if (hdr->s_scnptr != 0)
145 return_section->flags |= SEC_HAS_CONTENTS;
147 /* Compress/decompress DWARF debug sections with names: .debug_* and
148 .zdebug_*, after the section flags is set. */
149 if ((flags & SEC_DEBUGGING)
151 && ((name[1] == 'd' && name[6] == '_')
152 || (strlen (name) > 8 && name[1] == 'z' && name[7] == '_')))
154 enum { nothing, compress, decompress } action = nothing;
155 char *new_name = NULL;
157 if (bfd_is_section_compressed (abfd, return_section))
159 /* Compressed section. Check if we should decompress. */
160 if ((abfd->flags & BFD_DECOMPRESS))
163 else if (!bfd_is_section_compressed (abfd, return_section))
165 /* Normal section. Check if we should compress. */
166 if ((abfd->flags & BFD_COMPRESS) && return_section->size != 0)
175 if (!bfd_init_section_compress_status (abfd, return_section))
178 /* xgettext: c-format */
179 (_("%pB: unable to initialize compress status for section %s"),
183 if (return_section->compress_status == COMPRESS_SECTION_DONE)
187 unsigned int len = strlen (name);
189 new_name = bfd_alloc (abfd, len + 2);
190 if (new_name == NULL)
194 memcpy (new_name + 2, name + 1, len);
199 if (!bfd_init_section_decompress_status (abfd, return_section))
202 /* xgettext: c-format */
203 (_("%pB: unable to initialize decompress status for section %s"),
209 unsigned int len = strlen (name);
211 new_name = bfd_alloc (abfd, len);
212 if (new_name == NULL)
215 memcpy (new_name + 1, name + 2, len - 1);
219 if (new_name != NULL)
220 bfd_rename_section (abfd, return_section, new_name);
226 /* Read in a COFF object and make it into a BFD. This is used by
229 coff_real_object_p (bfd *,
231 struct internal_filehdr *,
232 struct internal_aouthdr *);
234 coff_real_object_p (bfd *abfd,
236 struct internal_filehdr *internal_f,
237 struct internal_aouthdr *internal_a)
239 flagword oflags = abfd->flags;
240 bfd_vma ostart = bfd_get_start_address (abfd);
243 bfd_size_type readsize; /* Length of file_info. */
245 char *external_sections;
247 if (!(internal_f->f_flags & F_RELFLG))
248 abfd->flags |= HAS_RELOC;
249 if ((internal_f->f_flags & F_EXEC))
250 abfd->flags |= EXEC_P;
251 if (!(internal_f->f_flags & F_LNNO))
252 abfd->flags |= HAS_LINENO;
253 if (!(internal_f->f_flags & F_LSYMS))
254 abfd->flags |= HAS_LOCALS;
256 /* FIXME: How can we set D_PAGED correctly? */
257 if ((internal_f->f_flags & F_EXEC) != 0)
258 abfd->flags |= D_PAGED;
260 bfd_get_symcount (abfd) = internal_f->f_nsyms;
261 if (internal_f->f_nsyms)
262 abfd->flags |= HAS_SYMS;
264 if (internal_a != (struct internal_aouthdr *) NULL)
265 bfd_get_start_address (abfd) = internal_a->entry;
267 bfd_get_start_address (abfd) = 0;
269 /* Set up the tdata area. ECOFF uses its own routine, and overrides
271 tdata_save = abfd->tdata.any;
272 tdata = bfd_coff_mkobject_hook (abfd, (void *) internal_f, (void *) internal_a);
276 scnhsz = bfd_coff_scnhsz (abfd);
277 readsize = (bfd_size_type) nscns * scnhsz;
278 external_sections = (char *) bfd_alloc (abfd, readsize);
279 if (!external_sections)
282 if (bfd_bread ((void *) external_sections, readsize, abfd) != readsize)
285 /* Set the arch/mach *before* swapping in sections; section header swapping
286 may depend on arch/mach info. */
287 if (! bfd_coff_set_arch_mach_hook (abfd, (void *) internal_f))
290 /* Now copy data as required; construct all asections etc. */
294 for (i = 0; i < nscns; i++)
296 struct internal_scnhdr tmp;
297 bfd_coff_swap_scnhdr_in (abfd,
298 (void *) (external_sections + i * scnhsz),
300 if (! make_a_section_from_file (abfd, &tmp, i + 1))
308 bfd_release (abfd, tdata);
310 abfd->tdata.any = tdata_save;
311 abfd->flags = oflags;
312 bfd_get_start_address (abfd) = ostart;
313 return (const bfd_target *) NULL;
316 /* Turn a COFF file into a BFD, but fail with bfd_error_wrong_format if it is
317 not a COFF file. This is also used by ECOFF. */
320 coff_object_p (bfd *abfd)
322 bfd_size_type filhsz;
323 bfd_size_type aoutsz;
326 struct internal_filehdr internal_f;
327 struct internal_aouthdr internal_a;
329 /* Figure out how much to read. */
330 filhsz = bfd_coff_filhsz (abfd);
331 aoutsz = bfd_coff_aoutsz (abfd);
333 filehdr = bfd_alloc (abfd, filhsz);
336 if (bfd_bread (filehdr, filhsz, abfd) != filhsz)
338 if (bfd_get_error () != bfd_error_system_call)
339 bfd_set_error (bfd_error_wrong_format);
340 bfd_release (abfd, filehdr);
343 bfd_coff_swap_filehdr_in (abfd, filehdr, &internal_f);
344 bfd_release (abfd, filehdr);
346 /* The XCOFF format has two sizes for the f_opthdr. SMALL_AOUTSZ
347 (less than aoutsz) used in object files and AOUTSZ (equal to
348 aoutsz) in executables. The bfd_coff_swap_aouthdr_in function
349 expects this header to be aoutsz bytes in length, so we use that
350 value in the call to bfd_alloc below. But we must be careful to
351 only read in f_opthdr bytes in the call to bfd_bread. We should
352 also attempt to catch corrupt or non-COFF binaries with a strange
353 value for f_opthdr. */
354 if (! bfd_coff_bad_format_hook (abfd, &internal_f)
355 || internal_f.f_opthdr > aoutsz)
357 bfd_set_error (bfd_error_wrong_format);
360 nscns = internal_f.f_nscns;
362 if (internal_f.f_opthdr)
366 opthdr = bfd_alloc (abfd, aoutsz);
369 if (bfd_bread (opthdr, (bfd_size_type) internal_f.f_opthdr, abfd)
370 != internal_f.f_opthdr)
372 bfd_release (abfd, opthdr);
375 /* PR 17512: file: 11056-1136-0.004. */
376 if (internal_f.f_opthdr < aoutsz)
377 memset (((char *) opthdr) + internal_f.f_opthdr, 0, aoutsz - internal_f.f_opthdr);
379 bfd_coff_swap_aouthdr_in (abfd, opthdr, (void *) &internal_a);
380 bfd_release (abfd, opthdr);
383 return coff_real_object_p (abfd, nscns, &internal_f,
384 (internal_f.f_opthdr != 0
386 : (struct internal_aouthdr *) NULL));
389 /* Get the BFD section from a COFF symbol section number. */
392 coff_section_from_bfd_index (bfd *abfd, int section_index)
394 struct bfd_section *answer = abfd->sections;
396 if (section_index == N_ABS)
397 return bfd_abs_section_ptr;
398 if (section_index == N_UNDEF)
399 return bfd_und_section_ptr;
400 if (section_index == N_DEBUG)
401 return bfd_abs_section_ptr;
405 if (answer->target_index == section_index)
407 answer = answer->next;
410 /* We should not reach this point, but the SCO 3.2v4 /lib/libc_s.a
411 has a bad symbol table in biglitpow.o. */
412 return bfd_und_section_ptr;
415 /* Get the upper bound of a COFF symbol table. */
418 coff_get_symtab_upper_bound (bfd *abfd)
420 if (!bfd_coff_slurp_symbol_table (abfd))
423 return (bfd_get_symcount (abfd) + 1) * (sizeof (coff_symbol_type *));
426 /* Canonicalize a COFF symbol table. */
429 coff_canonicalize_symtab (bfd *abfd, asymbol **alocation)
431 unsigned int counter;
432 coff_symbol_type *symbase;
433 coff_symbol_type **location = (coff_symbol_type **) alocation;
435 if (!bfd_coff_slurp_symbol_table (abfd))
438 symbase = obj_symbols (abfd);
439 counter = bfd_get_symcount (abfd);
440 while (counter-- > 0)
441 *location++ = symbase++;
445 return bfd_get_symcount (abfd);
448 /* Get the name of a symbol. The caller must pass in a buffer of size
452 _bfd_coff_internal_syment_name (bfd *abfd,
453 const struct internal_syment *sym,
456 /* FIXME: It's not clear this will work correctly if sizeof
458 if (sym->_n._n_n._n_zeroes != 0
459 || sym->_n._n_n._n_offset == 0)
461 memcpy (buf, sym->_n._n_name, SYMNMLEN);
462 buf[SYMNMLEN] = '\0';
469 BFD_ASSERT (sym->_n._n_n._n_offset >= STRING_SIZE_SIZE);
470 strings = obj_coff_strings (abfd);
473 strings = _bfd_coff_read_string_table (abfd);
477 /* PR 17910: Only check for string overflow if the length has been set.
478 Some DLLs, eg those produced by Visual Studio, may not set the length field. */
479 if (obj_coff_strings_len (abfd) > 0
480 && sym->_n._n_n._n_offset >= obj_coff_strings_len (abfd))
482 return strings + sym->_n._n_n._n_offset;
486 /* Read in and swap the relocs. This returns a buffer holding the
487 relocs for section SEC in file ABFD. If CACHE is TRUE and
488 INTERNAL_RELOCS is NULL, the relocs read in will be saved in case
489 the function is called again. If EXTERNAL_RELOCS is not NULL, it
490 is a buffer large enough to hold the unswapped relocs. If
491 INTERNAL_RELOCS is not NULL, it is a buffer large enough to hold
492 the swapped relocs. If REQUIRE_INTERNAL is TRUE, then the return
493 value must be INTERNAL_RELOCS. The function returns NULL on error. */
495 struct internal_reloc *
496 _bfd_coff_read_internal_relocs (bfd *abfd,
499 bfd_byte *external_relocs,
500 bfd_boolean require_internal,
501 struct internal_reloc *internal_relocs)
504 bfd_byte *free_external = NULL;
505 struct internal_reloc *free_internal = NULL;
508 struct internal_reloc *irel;
511 if (sec->reloc_count == 0)
512 return internal_relocs; /* Nothing to do. */
514 if (coff_section_data (abfd, sec) != NULL
515 && coff_section_data (abfd, sec)->relocs != NULL)
517 if (! require_internal)
518 return coff_section_data (abfd, sec)->relocs;
519 memcpy (internal_relocs, coff_section_data (abfd, sec)->relocs,
520 sec->reloc_count * sizeof (struct internal_reloc));
521 return internal_relocs;
524 relsz = bfd_coff_relsz (abfd);
526 amt = sec->reloc_count * relsz;
527 if (external_relocs == NULL)
529 free_external = (bfd_byte *) bfd_malloc (amt);
530 if (free_external == NULL)
532 external_relocs = free_external;
535 if (bfd_seek (abfd, sec->rel_filepos, SEEK_SET) != 0
536 || bfd_bread (external_relocs, amt, abfd) != amt)
539 if (internal_relocs == NULL)
541 amt = sec->reloc_count;
542 amt *= sizeof (struct internal_reloc);
543 free_internal = (struct internal_reloc *) bfd_malloc (amt);
544 if (free_internal == NULL)
546 internal_relocs = free_internal;
549 /* Swap in the relocs. */
550 erel = external_relocs;
551 erel_end = erel + relsz * sec->reloc_count;
552 irel = internal_relocs;
553 for (; erel < erel_end; erel += relsz, irel++)
554 bfd_coff_swap_reloc_in (abfd, (void *) erel, (void *) irel);
556 if (free_external != NULL)
558 free (free_external);
559 free_external = NULL;
562 if (cache && free_internal != NULL)
564 if (coff_section_data (abfd, sec) == NULL)
566 amt = sizeof (struct coff_section_tdata);
567 sec->used_by_bfd = bfd_zalloc (abfd, amt);
568 if (sec->used_by_bfd == NULL)
570 coff_section_data (abfd, sec)->contents = NULL;
572 coff_section_data (abfd, sec)->relocs = free_internal;
575 return internal_relocs;
578 if (free_external != NULL)
579 free (free_external);
580 if (free_internal != NULL)
581 free (free_internal);
585 /* Set lineno_count for the output sections of a COFF file. */
588 coff_count_linenumbers (bfd *abfd)
590 unsigned int limit = bfd_get_symcount (abfd);
598 /* This may be from the backend linker, in which case the
599 lineno_count in the sections is correct. */
600 for (s = abfd->sections; s != NULL; s = s->next)
601 total += s->lineno_count;
605 for (s = abfd->sections; s != NULL; s = s->next)
606 BFD_ASSERT (s->lineno_count == 0);
608 for (p = abfd->outsymbols, i = 0; i < limit; i++, p++)
610 asymbol *q_maybe = *p;
612 if (bfd_family_coff (bfd_asymbol_bfd (q_maybe)))
614 coff_symbol_type *q = coffsymbol (q_maybe);
616 /* The AIX 4.1 compiler can sometimes generate line numbers
617 attached to debugging symbols. We try to simply ignore
619 if (q->lineno != NULL
620 && q->symbol.section->owner != NULL)
622 /* This symbol has line numbers. Increment the owning
623 section's linenumber count. */
624 alent *l = q->lineno;
628 asection * sec = q->symbol.section->output_section;
630 /* Do not try to update fields in read-only sections. */
631 if (! bfd_is_const_section (sec))
632 sec->lineno_count ++;
637 while (l->line_number != 0);
646 fixup_symbol_value (bfd *abfd,
647 coff_symbol_type *coff_symbol_ptr,
648 struct internal_syment *syment)
650 /* Normalize the symbol flags. */
651 if (coff_symbol_ptr->symbol.section
652 && bfd_is_com_section (coff_symbol_ptr->symbol.section))
654 /* A common symbol is undefined with a value. */
655 syment->n_scnum = N_UNDEF;
656 syment->n_value = coff_symbol_ptr->symbol.value;
658 else if ((coff_symbol_ptr->symbol.flags & BSF_DEBUGGING) != 0
659 && (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING_RELOC) == 0)
661 syment->n_value = coff_symbol_ptr->symbol.value;
663 else if (bfd_is_und_section (coff_symbol_ptr->symbol.section))
665 syment->n_scnum = N_UNDEF;
668 /* FIXME: Do we need to handle the absolute section here? */
671 if (coff_symbol_ptr->symbol.section)
674 coff_symbol_ptr->symbol.section->output_section->target_index;
676 syment->n_value = (coff_symbol_ptr->symbol.value
677 + coff_symbol_ptr->symbol.section->output_offset);
680 syment->n_value += (syment->n_sclass == C_STATLAB)
681 ? coff_symbol_ptr->symbol.section->output_section->lma
682 : coff_symbol_ptr->symbol.section->output_section->vma;
688 /* This can happen, but I don't know why yet (steve@cygnus.com) */
689 syment->n_scnum = N_ABS;
690 syment->n_value = coff_symbol_ptr->symbol.value;
695 /* Run through all the symbols in the symbol table and work out what
696 their indexes into the symbol table will be when output.
698 Coff requires that each C_FILE symbol points to the next one in the
699 chain, and that the last one points to the first external symbol. We
703 coff_renumber_symbols (bfd *bfd_ptr, int *first_undef)
705 unsigned int symbol_count = bfd_get_symcount (bfd_ptr);
706 asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
707 unsigned int native_index = 0;
708 struct internal_syment *last_file = NULL;
709 unsigned int symbol_index;
711 /* COFF demands that undefined symbols come after all other symbols.
712 Since we don't need to impose this extra knowledge on all our
713 client programs, deal with that here. Sort the symbol table;
714 just move the undefined symbols to the end, leaving the rest
715 alone. The O'Reilly book says that defined global symbols come
716 at the end before the undefined symbols, so we do that here as
718 /* @@ Do we have some condition we could test for, so we don't always
719 have to do this? I don't think relocatability is quite right, but
720 I'm not certain. [raeburn:19920508.1711EST] */
726 amt = sizeof (asymbol *) * ((bfd_size_type) symbol_count + 1);
727 newsyms = (asymbol **) bfd_alloc (bfd_ptr, amt);
730 bfd_ptr->outsymbols = newsyms;
731 for (i = 0; i < symbol_count; i++)
732 if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) != 0
733 || (!bfd_is_und_section (symbol_ptr_ptr[i]->section)
734 && !bfd_is_com_section (symbol_ptr_ptr[i]->section)
735 && ((symbol_ptr_ptr[i]->flags & BSF_FUNCTION) != 0
736 || ((symbol_ptr_ptr[i]->flags & (BSF_GLOBAL | BSF_WEAK))
738 *newsyms++ = symbol_ptr_ptr[i];
740 for (i = 0; i < symbol_count; i++)
741 if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) == 0
742 && !bfd_is_und_section (symbol_ptr_ptr[i]->section)
743 && (bfd_is_com_section (symbol_ptr_ptr[i]->section)
744 || ((symbol_ptr_ptr[i]->flags & BSF_FUNCTION) == 0
745 && ((symbol_ptr_ptr[i]->flags & (BSF_GLOBAL | BSF_WEAK))
747 *newsyms++ = symbol_ptr_ptr[i];
749 *first_undef = newsyms - bfd_ptr->outsymbols;
751 for (i = 0; i < symbol_count; i++)
752 if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) == 0
753 && bfd_is_und_section (symbol_ptr_ptr[i]->section))
754 *newsyms++ = symbol_ptr_ptr[i];
755 *newsyms = (asymbol *) NULL;
756 symbol_ptr_ptr = bfd_ptr->outsymbols;
759 for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
761 coff_symbol_type *coff_symbol_ptr;
763 coff_symbol_ptr = coff_symbol_from (symbol_ptr_ptr[symbol_index]);
764 symbol_ptr_ptr[symbol_index]->udata.i = symbol_index;
765 if (coff_symbol_ptr && coff_symbol_ptr->native)
767 combined_entry_type *s = coff_symbol_ptr->native;
770 BFD_ASSERT (s->is_sym);
771 if (s->u.syment.n_sclass == C_FILE)
773 if (last_file != NULL)
774 last_file->n_value = native_index;
775 last_file = &(s->u.syment);
778 /* Modify the symbol values according to their section and
780 fixup_symbol_value (bfd_ptr, coff_symbol_ptr, &(s->u.syment));
782 for (i = 0; i < s->u.syment.n_numaux + 1; i++)
783 s[i].offset = native_index++;
789 obj_conv_table_size (bfd_ptr) = native_index;
794 /* Run thorough the symbol table again, and fix it so that all
795 pointers to entries are changed to the entries' index in the output
799 coff_mangle_symbols (bfd *bfd_ptr)
801 unsigned int symbol_count = bfd_get_symcount (bfd_ptr);
802 asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
803 unsigned int symbol_index;
805 for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
807 coff_symbol_type *coff_symbol_ptr;
809 coff_symbol_ptr = coff_symbol_from (symbol_ptr_ptr[symbol_index]);
810 if (coff_symbol_ptr && coff_symbol_ptr->native)
813 combined_entry_type *s = coff_symbol_ptr->native;
815 BFD_ASSERT (s->is_sym);
818 /* FIXME: We should use a union here. */
819 s->u.syment.n_value =
820 (bfd_hostptr_t) ((combined_entry_type *)
821 ((bfd_hostptr_t) s->u.syment.n_value))->offset;
826 /* The value is the offset into the line number entries
827 for the symbol's section. On output, the symbol's
828 section should be N_DEBUG. */
829 s->u.syment.n_value =
830 (coff_symbol_ptr->symbol.section->output_section->line_filepos
831 + s->u.syment.n_value * bfd_coff_linesz (bfd_ptr));
832 coff_symbol_ptr->symbol.section =
833 coff_section_from_bfd_index (bfd_ptr, N_DEBUG);
834 BFD_ASSERT (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING);
836 for (i = 0; i < s->u.syment.n_numaux; i++)
838 combined_entry_type *a = s + i + 1;
840 BFD_ASSERT (! a->is_sym);
843 a->u.auxent.x_sym.x_tagndx.l =
844 a->u.auxent.x_sym.x_tagndx.p->offset;
849 a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l =
850 a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p->offset;
855 a->u.auxent.x_csect.x_scnlen.l =
856 a->u.auxent.x_csect.x_scnlen.p->offset;
865 coff_fix_symbol_name (bfd *abfd,
867 combined_entry_type *native,
868 bfd_size_type *string_size_p,
869 asection **debug_string_section_p,
870 bfd_size_type *debug_string_size_p)
872 unsigned int name_length;
873 union internal_auxent *auxent;
874 char *name = (char *) (symbol->name);
878 /* COFF symbols always have names, so we'll make one up. */
879 symbol->name = "strange";
880 name = (char *) symbol->name;
882 name_length = strlen (name);
884 BFD_ASSERT (native->is_sym);
885 if (native->u.syment.n_sclass == C_FILE
886 && native->u.syment.n_numaux > 0)
888 unsigned int filnmlen;
890 if (bfd_coff_force_symnames_in_strings (abfd))
892 native->u.syment._n._n_n._n_offset =
893 (*string_size_p + STRING_SIZE_SIZE);
894 native->u.syment._n._n_n._n_zeroes = 0;
895 *string_size_p += 6; /* strlen(".file") + 1 */
898 strncpy (native->u.syment._n._n_name, ".file", SYMNMLEN);
900 BFD_ASSERT (! (native + 1)->is_sym);
901 auxent = &(native + 1)->u.auxent;
903 filnmlen = bfd_coff_filnmlen (abfd);
905 if (bfd_coff_long_filenames (abfd))
907 if (name_length <= filnmlen)
908 strncpy (auxent->x_file.x_fname, name, filnmlen);
911 auxent->x_file.x_n.x_offset = *string_size_p + STRING_SIZE_SIZE;
912 auxent->x_file.x_n.x_zeroes = 0;
913 *string_size_p += name_length + 1;
918 strncpy (auxent->x_file.x_fname, name, filnmlen);
919 if (name_length > filnmlen)
920 name[filnmlen] = '\0';
925 if (name_length <= SYMNMLEN && !bfd_coff_force_symnames_in_strings (abfd))
926 /* This name will fit into the symbol neatly. */
927 strncpy (native->u.syment._n._n_name, symbol->name, SYMNMLEN);
929 else if (!bfd_coff_symname_in_debug (abfd, &native->u.syment))
931 native->u.syment._n._n_n._n_offset = (*string_size_p
933 native->u.syment._n._n_n._n_zeroes = 0;
934 *string_size_p += name_length + 1;
940 int prefix_len = bfd_coff_debug_string_prefix_length (abfd);
942 /* This name should be written into the .debug section. For
943 some reason each name is preceded by a two byte length
944 and also followed by a null byte. FIXME: We assume that
945 the .debug section has already been created, and that it
947 if (*debug_string_section_p == (asection *) NULL)
948 *debug_string_section_p = bfd_get_section_by_name (abfd, ".debug");
949 filepos = bfd_tell (abfd);
951 bfd_put_32 (abfd, (bfd_vma) (name_length + 1), buf);
953 bfd_put_16 (abfd, (bfd_vma) (name_length + 1), buf);
955 if (!bfd_set_section_contents (abfd,
956 *debug_string_section_p,
958 (file_ptr) *debug_string_size_p,
959 (bfd_size_type) prefix_len)
960 || !bfd_set_section_contents (abfd,
961 *debug_string_section_p,
962 (void *) symbol->name,
963 (file_ptr) (*debug_string_size_p
965 (bfd_size_type) name_length + 1))
967 if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
969 native->u.syment._n._n_n._n_offset =
970 *debug_string_size_p + prefix_len;
971 native->u.syment._n._n_n._n_zeroes = 0;
972 *debug_string_size_p += name_length + 1 + prefix_len;
977 /* We need to keep track of the symbol index so that when we write out
978 the relocs we can get the index for a symbol. This method is a
981 #define set_index(symbol, idx) ((symbol)->udata.i = (idx))
983 /* Write a symbol out to a COFF file. */
986 coff_write_symbol (bfd *abfd,
988 combined_entry_type *native,
990 bfd_size_type *string_size_p,
991 asection **debug_string_section_p,
992 bfd_size_type *debug_string_size_p)
994 unsigned int numaux = native->u.syment.n_numaux;
995 int type = native->u.syment.n_type;
996 int n_sclass = (int) native->u.syment.n_sclass;
997 asection *output_section = symbol->section->output_section
998 ? symbol->section->output_section
1001 bfd_size_type symesz;
1003 BFD_ASSERT (native->is_sym);
1005 if (native->u.syment.n_sclass == C_FILE)
1006 symbol->flags |= BSF_DEBUGGING;
1008 if (symbol->flags & BSF_DEBUGGING
1009 && bfd_is_abs_section (symbol->section))
1010 native->u.syment.n_scnum = N_DEBUG;
1012 else if (bfd_is_abs_section (symbol->section))
1013 native->u.syment.n_scnum = N_ABS;
1015 else if (bfd_is_und_section (symbol->section))
1016 native->u.syment.n_scnum = N_UNDEF;
1019 native->u.syment.n_scnum =
1020 output_section->target_index;
1022 coff_fix_symbol_name (abfd, symbol, native, string_size_p,
1023 debug_string_section_p, debug_string_size_p);
1025 symesz = bfd_coff_symesz (abfd);
1026 buf = bfd_alloc (abfd, symesz);
1029 bfd_coff_swap_sym_out (abfd, &native->u.syment, buf);
1030 if (bfd_bwrite (buf, symesz, abfd) != symesz)
1032 bfd_release (abfd, buf);
1034 if (native->u.syment.n_numaux > 0)
1036 bfd_size_type auxesz;
1039 auxesz = bfd_coff_auxesz (abfd);
1040 buf = bfd_alloc (abfd, auxesz);
1043 for (j = 0; j < native->u.syment.n_numaux; j++)
1045 BFD_ASSERT (! (native + j + 1)->is_sym);
1046 bfd_coff_swap_aux_out (abfd,
1047 &((native + j + 1)->u.auxent),
1048 type, n_sclass, (int) j,
1049 native->u.syment.n_numaux,
1051 if (bfd_bwrite (buf, auxesz, abfd) != auxesz)
1054 bfd_release (abfd, buf);
1057 /* Store the index for use when we write out the relocs. */
1058 set_index (symbol, *written);
1060 *written += numaux + 1;
1064 /* Write out a symbol to a COFF file that does not come from a COFF
1065 file originally. This symbol may have been created by the linker,
1066 or we may be linking a non COFF file to a COFF file. */
1069 coff_write_alien_symbol (bfd *abfd,
1071 struct internal_syment *isym,
1072 union internal_auxent *iaux,
1074 bfd_size_type *string_size_p,
1075 asection **debug_string_section_p,
1076 bfd_size_type *debug_string_size_p)
1078 combined_entry_type *native;
1079 combined_entry_type dummy[2];
1080 asection *output_section = symbol->section->output_section
1081 ? symbol->section->output_section
1083 struct bfd_link_info *link_info = coff_data (abfd)->link_info;
1086 if ((!link_info || link_info->strip_discarded)
1087 && !bfd_is_abs_section (symbol->section)
1088 && symbol->section->output_section == bfd_abs_section_ptr)
1092 memset (isym, 0, sizeof (*isym));
1096 native->is_sym = TRUE;
1097 native[1].is_sym = FALSE;
1098 native->u.syment.n_type = T_NULL;
1099 native->u.syment.n_flags = 0;
1100 native->u.syment.n_numaux = 0;
1101 if (bfd_is_und_section (symbol->section))
1103 native->u.syment.n_scnum = N_UNDEF;
1104 native->u.syment.n_value = symbol->value;
1106 else if (bfd_is_com_section (symbol->section))
1108 native->u.syment.n_scnum = N_UNDEF;
1109 native->u.syment.n_value = symbol->value;
1111 else if (symbol->flags & BSF_FILE)
1113 native->u.syment.n_scnum = N_DEBUG;
1114 native->u.syment.n_numaux = 1;
1116 else if (symbol->flags & BSF_DEBUGGING)
1118 /* There isn't much point to writing out a debugging symbol
1119 unless we are prepared to convert it into COFF debugging
1120 format. So, we just ignore them. We must clobber the symbol
1121 name to keep it from being put in the string table. */
1124 memset (isym, 0, sizeof (*isym));
1129 native->u.syment.n_scnum = output_section->target_index;
1130 native->u.syment.n_value = (symbol->value
1131 + symbol->section->output_offset);
1132 if (! obj_pe (abfd))
1133 native->u.syment.n_value += output_section->vma;
1135 /* Copy the any flags from the file header into the symbol.
1138 coff_symbol_type *c = coff_symbol_from (symbol);
1139 if (c != (coff_symbol_type *) NULL)
1140 native->u.syment.n_flags = bfd_asymbol_bfd (&c->symbol)->flags;
1144 native->u.syment.n_type = 0;
1145 if (symbol->flags & BSF_FILE)
1146 native->u.syment.n_sclass = C_FILE;
1147 else if (symbol->flags & BSF_LOCAL)
1148 native->u.syment.n_sclass = C_STAT;
1149 else if (symbol->flags & BSF_WEAK)
1150 native->u.syment.n_sclass = obj_pe (abfd) ? C_NT_WEAK : C_WEAKEXT;
1152 native->u.syment.n_sclass = C_EXT;
1154 ret = coff_write_symbol (abfd, symbol, native, written, string_size_p,
1155 debug_string_section_p, debug_string_size_p);
1157 *isym = native->u.syment;
1158 if (iaux != NULL && native->u.syment.n_numaux)
1159 *iaux = native[1].u.auxent;
1163 /* Write a native symbol to a COFF file. */
1166 coff_write_native_symbol (bfd *abfd,
1167 coff_symbol_type *symbol,
1169 bfd_size_type *string_size_p,
1170 asection **debug_string_section_p,
1171 bfd_size_type *debug_string_size_p)
1173 combined_entry_type *native = symbol->native;
1174 alent *lineno = symbol->lineno;
1175 struct bfd_link_info *link_info = coff_data (abfd)->link_info;
1177 if ((!link_info || link_info->strip_discarded)
1178 && !bfd_is_abs_section (symbol->symbol.section)
1179 && symbol->symbol.section->output_section == bfd_abs_section_ptr)
1181 symbol->symbol.name = "";
1185 BFD_ASSERT (native->is_sym);
1186 /* If this symbol has an associated line number, we must store the
1187 symbol index in the line number field. We also tag the auxent to
1188 point to the right place in the lineno table. */
1189 if (lineno && !symbol->done_lineno && symbol->symbol.section->owner != NULL)
1191 unsigned int count = 0;
1193 lineno[count].u.offset = *written;
1194 if (native->u.syment.n_numaux)
1196 union internal_auxent *a = &((native + 1)->u.auxent);
1198 a->x_sym.x_fcnary.x_fcn.x_lnnoptr =
1199 symbol->symbol.section->output_section->moving_line_filepos;
1202 /* Count and relocate all other linenumbers. */
1204 while (lineno[count].line_number != 0)
1206 lineno[count].u.offset +=
1207 (symbol->symbol.section->output_section->vma
1208 + symbol->symbol.section->output_offset);
1211 symbol->done_lineno = TRUE;
1213 if (! bfd_is_const_section (symbol->symbol.section->output_section))
1214 symbol->symbol.section->output_section->moving_line_filepos +=
1215 count * bfd_coff_linesz (abfd);
1218 return coff_write_symbol (abfd, &(symbol->symbol), native, written,
1219 string_size_p, debug_string_section_p,
1220 debug_string_size_p);
1224 null_error_handler (const char *fmt ATTRIBUTE_UNUSED,
1225 va_list ap ATTRIBUTE_UNUSED)
1229 /* Write out the COFF symbols. */
1232 coff_write_symbols (bfd *abfd)
1234 bfd_size_type string_size;
1235 asection *debug_string_section;
1236 bfd_size_type debug_string_size;
1238 unsigned int limit = bfd_get_symcount (abfd);
1239 bfd_vma written = 0;
1243 debug_string_section = NULL;
1244 debug_string_size = 0;
1246 /* If this target supports long section names, they must be put into
1247 the string table. This is supported by PE. This code must
1248 handle section names just as they are handled in
1249 coff_write_object_contents. */
1250 if (bfd_coff_long_section_names (abfd))
1254 for (o = abfd->sections; o != NULL; o = o->next)
1258 len = strlen (o->name);
1260 string_size += len + 1;
1264 /* Seek to the right place. */
1265 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0)
1268 /* Output all the symbols we have. */
1270 for (p = abfd->outsymbols, i = 0; i < limit; i++, p++)
1272 asymbol *symbol = *p;
1273 coff_symbol_type *c_symbol = coff_symbol_from (symbol);
1275 if (c_symbol == (coff_symbol_type *) NULL
1276 || c_symbol->native == (combined_entry_type *) NULL)
1278 if (!coff_write_alien_symbol (abfd, symbol, NULL, NULL, &written,
1279 &string_size, &debug_string_section,
1280 &debug_string_size))
1285 if (coff_backend_info (abfd)->_bfd_coff_classify_symbol != NULL)
1287 bfd_error_handler_type current_error_handler;
1288 enum coff_symbol_classification sym_class;
1289 unsigned char *n_sclass;
1291 /* Suppress error reporting by bfd_coff_classify_symbol.
1292 Error messages can be generated when we are processing a local
1293 symbol which has no associated section and we do not have to
1294 worry about this, all we need to know is that it is local. */
1295 current_error_handler = bfd_set_error_handler (null_error_handler);
1296 BFD_ASSERT (c_symbol->native->is_sym);
1297 sym_class = bfd_coff_classify_symbol (abfd,
1298 &c_symbol->native->u.syment);
1299 (void) bfd_set_error_handler (current_error_handler);
1301 n_sclass = &c_symbol->native->u.syment.n_sclass;
1303 /* If the symbol class has been changed (eg objcopy/ld script/etc)
1304 we cannot retain the existing sclass from the original symbol.
1305 Weak symbols only have one valid sclass, so just set it always.
1306 If it is not local class and should be, set it C_STAT.
1307 If it is global and not classified as global, or if it is
1308 weak (which is also classified as global), set it C_EXT. */
1310 if (symbol->flags & BSF_WEAK)
1311 *n_sclass = obj_pe (abfd) ? C_NT_WEAK : C_WEAKEXT;
1312 else if (symbol->flags & BSF_LOCAL && sym_class != COFF_SYMBOL_LOCAL)
1314 else if (symbol->flags & BSF_GLOBAL
1315 && (sym_class != COFF_SYMBOL_GLOBAL
1317 || *n_sclass == C_NT_WEAK
1319 || *n_sclass == C_WEAKEXT))
1320 c_symbol->native->u.syment.n_sclass = C_EXT;
1323 if (!coff_write_native_symbol (abfd, c_symbol, &written,
1324 &string_size, &debug_string_section,
1325 &debug_string_size))
1330 obj_raw_syment_count (abfd) = written;
1332 /* Now write out strings. */
1333 if (string_size != 0)
1335 unsigned int size = string_size + STRING_SIZE_SIZE;
1336 bfd_byte buffer[STRING_SIZE_SIZE];
1338 #if STRING_SIZE_SIZE == 4
1339 H_PUT_32 (abfd, size, buffer);
1341 #error Change H_PUT_32
1343 if (bfd_bwrite ((void *) buffer, (bfd_size_type) sizeof (buffer), abfd)
1347 /* Handle long section names. This code must handle section
1348 names just as they are handled in coff_write_object_contents. */
1349 if (bfd_coff_long_section_names (abfd))
1353 for (o = abfd->sections; o != NULL; o = o->next)
1357 len = strlen (o->name);
1360 if (bfd_bwrite (o->name, (bfd_size_type) (len + 1), abfd)
1367 for (p = abfd->outsymbols, i = 0;
1372 size_t name_length = strlen (q->name);
1373 coff_symbol_type *c_symbol = coff_symbol_from (q);
1376 /* Figure out whether the symbol name should go in the string
1377 table. Symbol names that are short enough are stored
1378 directly in the syment structure. File names permit a
1379 different, longer, length in the syment structure. On
1380 XCOFF, some symbol names are stored in the .debug section
1381 rather than in the string table. */
1383 if (c_symbol == NULL
1384 || c_symbol->native == NULL)
1385 /* This is not a COFF symbol, so it certainly is not a
1386 file name, nor does it go in the .debug section. */
1387 maxlen = bfd_coff_force_symnames_in_strings (abfd) ? 0 : SYMNMLEN;
1389 else if (! c_symbol->native->is_sym)
1390 maxlen = bfd_coff_force_symnames_in_strings (abfd) ? 0 : SYMNMLEN;
1392 else if (bfd_coff_symname_in_debug (abfd,
1393 &c_symbol->native->u.syment))
1394 /* This symbol name is in the XCOFF .debug section.
1395 Don't write it into the string table. */
1396 maxlen = name_length;
1398 else if (c_symbol->native->u.syment.n_sclass == C_FILE
1399 && c_symbol->native->u.syment.n_numaux > 0)
1401 if (bfd_coff_force_symnames_in_strings (abfd))
1403 if (bfd_bwrite (".file", (bfd_size_type) 6, abfd) != 6)
1406 maxlen = bfd_coff_filnmlen (abfd);
1409 maxlen = bfd_coff_force_symnames_in_strings (abfd) ? 0 : SYMNMLEN;
1411 if (name_length > maxlen)
1413 if (bfd_bwrite ((void *) (q->name), (bfd_size_type) name_length + 1,
1414 abfd) != name_length + 1)
1421 /* We would normally not write anything here, but we'll write
1422 out 4 so that any stupid coff reader which tries to read the
1423 string table even when there isn't one won't croak. */
1424 unsigned int size = STRING_SIZE_SIZE;
1425 bfd_byte buffer[STRING_SIZE_SIZE];
1427 #if STRING_SIZE_SIZE == 4
1428 H_PUT_32 (abfd, size, buffer);
1430 #error Change H_PUT_32
1432 if (bfd_bwrite ((void *) buffer, (bfd_size_type) STRING_SIZE_SIZE, abfd)
1433 != STRING_SIZE_SIZE)
1437 /* Make sure the .debug section was created to be the correct size.
1438 We should create it ourselves on the fly, but we don't because
1439 BFD won't let us write to any section until we know how large all
1440 the sections are. We could still do it by making another pass
1441 over the symbols. FIXME. */
1442 BFD_ASSERT (debug_string_size == 0
1443 || (debug_string_section != (asection *) NULL
1444 && (BFD_ALIGN (debug_string_size,
1445 1 << debug_string_section->alignment_power)
1446 == debug_string_section->size)));
1452 coff_write_linenumbers (bfd *abfd)
1455 bfd_size_type linesz;
1458 linesz = bfd_coff_linesz (abfd);
1459 buff = bfd_alloc (abfd, linesz);
1462 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
1464 if (s->lineno_count)
1466 asymbol **q = abfd->outsymbols;
1467 if (bfd_seek (abfd, s->line_filepos, SEEK_SET) != 0)
1469 /* Find all the linenumbers in this section. */
1473 if (p->section->output_section == s)
1476 BFD_SEND (bfd_asymbol_bfd (p), _get_lineno,
1477 (bfd_asymbol_bfd (p), p));
1480 /* Found a linenumber entry, output. */
1481 struct internal_lineno out;
1483 memset ((void *) & out, 0, sizeof (out));
1485 out.l_addr.l_symndx = l->u.offset;
1486 bfd_coff_swap_lineno_out (abfd, &out, buff);
1487 if (bfd_bwrite (buff, (bfd_size_type) linesz, abfd)
1491 while (l->line_number)
1493 out.l_lnno = l->line_number;
1494 out.l_addr.l_symndx = l->u.offset;
1495 bfd_coff_swap_lineno_out (abfd, &out, buff);
1496 if (bfd_bwrite (buff, (bfd_size_type) linesz, abfd)
1507 bfd_release (abfd, buff);
1512 coff_get_lineno (bfd *ignore_abfd ATTRIBUTE_UNUSED, asymbol *symbol)
1514 return coffsymbol (symbol)->lineno;
1517 /* This function transforms the offsets into the symbol table into
1518 pointers to syments. */
1521 coff_pointerize_aux (bfd *abfd,
1522 combined_entry_type *table_base,
1523 combined_entry_type *symbol,
1524 unsigned int indaux,
1525 combined_entry_type *auxent,
1526 combined_entry_type *table_end)
1528 unsigned int type = symbol->u.syment.n_type;
1529 unsigned int n_sclass = symbol->u.syment.n_sclass;
1531 BFD_ASSERT (symbol->is_sym);
1532 if (coff_backend_info (abfd)->_bfd_coff_pointerize_aux_hook)
1534 if ((*coff_backend_info (abfd)->_bfd_coff_pointerize_aux_hook)
1535 (abfd, table_base, symbol, indaux, auxent))
1539 /* Don't bother if this is a file or a section. */
1540 if (n_sclass == C_STAT && type == T_NULL)
1542 if (n_sclass == C_FILE)
1545 BFD_ASSERT (! auxent->is_sym);
1546 /* Otherwise patch up. */
1547 #define N_TMASK coff_data (abfd)->local_n_tmask
1548 #define N_BTSHFT coff_data (abfd)->local_n_btshft
1550 if ((ISFCN (type) || ISTAG (n_sclass) || n_sclass == C_BLOCK
1551 || n_sclass == C_FCN)
1552 && auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l > 0
1553 && auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l
1554 < (long) obj_raw_syment_count (abfd)
1555 && table_base + auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l
1558 auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p =
1559 table_base + auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l;
1560 auxent->fix_end = 1;
1563 /* A negative tagndx is meaningless, but the SCO 3.2v4 cc can
1564 generate one, so we must be careful to ignore it. */
1565 if ((unsigned long) auxent->u.auxent.x_sym.x_tagndx.l
1566 < obj_raw_syment_count (abfd)
1567 && table_base + auxent->u.auxent.x_sym.x_tagndx.l < table_end)
1569 auxent->u.auxent.x_sym.x_tagndx.p =
1570 table_base + auxent->u.auxent.x_sym.x_tagndx.l;
1571 auxent->fix_tag = 1;
1575 /* Allocate space for the ".debug" section, and read it.
1576 We did not read the debug section until now, because
1577 we didn't want to go to the trouble until someone needed it. */
1580 build_debug_section (bfd *abfd, asection ** sect_return)
1582 char *debug_section;
1584 bfd_size_type sec_size;
1586 asection *sect = bfd_get_section_by_name (abfd, ".debug");
1590 bfd_set_error (bfd_error_no_debug_section);
1594 sec_size = sect->size;
1595 debug_section = (char *) bfd_alloc (abfd, sec_size);
1596 if (debug_section == NULL)
1599 /* Seek to the beginning of the `.debug' section and read it.
1600 Save the current position first; it is needed by our caller.
1601 Then read debug section and reset the file pointer. */
1603 position = bfd_tell (abfd);
1604 if (bfd_seek (abfd, sect->filepos, SEEK_SET) != 0
1605 || bfd_bread (debug_section, sec_size, abfd) != sec_size
1606 || bfd_seek (abfd, position, SEEK_SET) != 0)
1609 * sect_return = sect;
1610 return debug_section;
1613 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
1614 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
1615 be \0-terminated. */
1618 copy_name (bfd *abfd, char *name, size_t maxlen)
1623 for (len = 0; len < maxlen; ++len)
1624 if (name[len] == '\0')
1627 if ((newname = (char *) bfd_alloc (abfd, (bfd_size_type) len + 1)) == NULL)
1630 strncpy (newname, name, len);
1631 newname[len] = '\0';
1635 /* Read in the external symbols. */
1638 _bfd_coff_get_external_symbols (bfd *abfd)
1640 bfd_size_type symesz;
1644 if (obj_coff_external_syms (abfd) != NULL)
1647 symesz = bfd_coff_symesz (abfd);
1649 size = obj_raw_syment_count (abfd) * symesz;
1652 /* Check for integer overflow and for unreasonable symbol counts. */
1653 if (size < obj_raw_syment_count (abfd)
1654 || (bfd_get_file_size (abfd) > 0
1655 && size > bfd_get_file_size (abfd)))
1658 _bfd_error_handler (_("%pB: corrupt symbol count: %#" PRIx64 ""),
1659 abfd, (uint64_t) obj_raw_syment_count (abfd));
1663 syms = bfd_malloc (size);
1666 /* PR 21013: Provide an error message when the alloc fails. */
1667 _bfd_error_handler (_("%pB: not enough memory to allocate space "
1668 "for %#" PRIx64 " symbols of size %#" PRIx64),
1669 abfd, (uint64_t) obj_raw_syment_count (abfd),
1674 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
1675 || bfd_bread (syms, size, abfd) != size)
1682 obj_coff_external_syms (abfd) = syms;
1686 /* Read in the external strings. The strings are not loaded until
1687 they are needed. This is because we have no simple way of
1688 detecting a missing string table in an archive. If the strings
1689 are loaded then the STRINGS and STRINGS_LEN fields in the
1690 coff_tdata structure will be set. */
1693 _bfd_coff_read_string_table (bfd *abfd)
1695 char extstrsize[STRING_SIZE_SIZE];
1696 bfd_size_type strsize;
1700 if (obj_coff_strings (abfd) != NULL)
1701 return obj_coff_strings (abfd);
1703 if (obj_sym_filepos (abfd) == 0)
1705 bfd_set_error (bfd_error_no_symbols);
1709 pos = obj_sym_filepos (abfd);
1710 pos += obj_raw_syment_count (abfd) * bfd_coff_symesz (abfd);
1711 if (bfd_seek (abfd, pos, SEEK_SET) != 0)
1714 if (bfd_bread (extstrsize, (bfd_size_type) sizeof extstrsize, abfd)
1715 != sizeof extstrsize)
1717 if (bfd_get_error () != bfd_error_file_truncated)
1720 /* There is no string table. */
1721 strsize = STRING_SIZE_SIZE;
1725 #if STRING_SIZE_SIZE == 4
1726 strsize = H_GET_32 (abfd, extstrsize);
1728 #error Change H_GET_32
1732 if (strsize < STRING_SIZE_SIZE || strsize > bfd_get_file_size (abfd))
1735 /* xgettext: c-format */
1736 (_("%pB: bad string table size %" PRIu64), abfd, (uint64_t) strsize);
1737 bfd_set_error (bfd_error_bad_value);
1741 strings = (char *) bfd_malloc (strsize + 1);
1742 if (strings == NULL)
1745 /* PR 17521 file: 079-54929-0.004.
1746 A corrupt file could contain an index that points into the first
1747 STRING_SIZE_SIZE bytes of the string table, so make sure that
1749 memset (strings, 0, STRING_SIZE_SIZE);
1751 if (bfd_bread (strings + STRING_SIZE_SIZE, strsize - STRING_SIZE_SIZE, abfd)
1752 != strsize - STRING_SIZE_SIZE)
1758 obj_coff_strings (abfd) = strings;
1759 obj_coff_strings_len (abfd) = strsize;
1760 /* Terminate the string table, just in case. */
1761 strings[strsize] = 0;
1765 /* Free up the external symbols and strings read from a COFF file. */
1768 _bfd_coff_free_symbols (bfd *abfd)
1770 if (! bfd_family_coff (abfd))
1773 if (obj_coff_external_syms (abfd) != NULL
1774 && ! obj_coff_keep_syms (abfd))
1776 free (obj_coff_external_syms (abfd));
1777 obj_coff_external_syms (abfd) = NULL;
1780 if (obj_coff_strings (abfd) != NULL
1781 && ! obj_coff_keep_strings (abfd))
1783 free (obj_coff_strings (abfd));
1784 obj_coff_strings (abfd) = NULL;
1785 obj_coff_strings_len (abfd) = 0;
1791 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
1792 knit the symbol names into a normalized form. By normalized here I
1793 mean that all symbols have an n_offset pointer that points to a null-
1794 terminated string. */
1796 combined_entry_type *
1797 coff_get_normalized_symtab (bfd *abfd)
1799 combined_entry_type *internal;
1800 combined_entry_type *internal_ptr;
1801 combined_entry_type *symbol_ptr;
1802 combined_entry_type *internal_end;
1806 const char *string_table = NULL;
1807 asection * debug_sec = NULL;
1808 char *debug_sec_data = NULL;
1811 if (obj_raw_syments (abfd) != NULL)
1812 return obj_raw_syments (abfd);
1814 if (! _bfd_coff_get_external_symbols (abfd))
1817 size = obj_raw_syment_count (abfd) * sizeof (combined_entry_type);
1818 /* Check for integer overflow. */
1819 if (size < obj_raw_syment_count (abfd))
1821 internal = (combined_entry_type *) bfd_zalloc (abfd, size);
1822 if (internal == NULL && size != 0)
1824 internal_end = internal + obj_raw_syment_count (abfd);
1826 raw_src = (char *) obj_coff_external_syms (abfd);
1828 /* Mark the end of the symbols. */
1829 symesz = bfd_coff_symesz (abfd);
1830 raw_end = (char *) raw_src + obj_raw_syment_count (abfd) * symesz;
1832 /* FIXME SOMEDAY. A string table size of zero is very weird, but
1833 probably possible. If one shows up, it will probably kill us. */
1835 /* Swap all the raw entries. */
1836 for (internal_ptr = internal;
1838 raw_src += symesz, internal_ptr++)
1842 bfd_coff_swap_sym_in (abfd, (void *) raw_src,
1843 (void *) & internal_ptr->u.syment);
1844 symbol_ptr = internal_ptr;
1845 internal_ptr->is_sym = TRUE;
1847 /* PR 17512: file: 1353-1166-0.004. */
1848 if (symbol_ptr->u.syment.n_sclass == C_FILE
1849 && symbol_ptr->u.syment.n_numaux > 0
1850 && raw_src + symesz + symbol_ptr->u.syment.n_numaux
1853 bfd_release (abfd, internal);
1858 i < symbol_ptr->u.syment.n_numaux;
1862 /* PR 17512: Prevent buffer overrun. */
1863 if (internal_ptr >= internal_end)
1865 bfd_release (abfd, internal);
1870 bfd_coff_swap_aux_in (abfd, (void *) raw_src,
1871 symbol_ptr->u.syment.n_type,
1872 symbol_ptr->u.syment.n_sclass,
1873 (int) i, symbol_ptr->u.syment.n_numaux,
1874 &(internal_ptr->u.auxent));
1876 internal_ptr->is_sym = FALSE;
1877 coff_pointerize_aux (abfd, internal, symbol_ptr, i,
1878 internal_ptr, internal_end);
1882 /* Free the raw symbols, but not the strings (if we have them). */
1883 obj_coff_keep_strings (abfd) = TRUE;
1884 if (! _bfd_coff_free_symbols (abfd))
1887 for (internal_ptr = internal; internal_ptr < internal_end;
1890 BFD_ASSERT (internal_ptr->is_sym);
1892 if (internal_ptr->u.syment.n_sclass == C_FILE
1893 && internal_ptr->u.syment.n_numaux > 0)
1895 combined_entry_type * aux = internal_ptr + 1;
1897 /* Make a file symbol point to the name in the auxent, since
1898 the text ".file" is redundant. */
1899 BFD_ASSERT (! aux->is_sym);
1901 if (aux->u.auxent.x_file.x_n.x_zeroes == 0)
1903 /* The filename is a long one, point into the string table. */
1904 if (string_table == NULL)
1906 string_table = _bfd_coff_read_string_table (abfd);
1907 if (string_table == NULL)
1911 if ((bfd_size_type)(aux->u.auxent.x_file.x_n.x_offset)
1912 >= obj_coff_strings_len (abfd))
1913 internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) _("<corrupt>");
1915 internal_ptr->u.syment._n._n_n._n_offset =
1916 (bfd_hostptr_t) (string_table + (aux->u.auxent.x_file.x_n.x_offset));
1920 /* Ordinary short filename, put into memory anyway. The
1921 Microsoft PE tools sometimes store a filename in
1922 multiple AUX entries. */
1923 if (internal_ptr->u.syment.n_numaux > 1
1924 && coff_data (abfd)->pe)
1925 internal_ptr->u.syment._n._n_n._n_offset =
1928 aux->u.auxent.x_file.x_fname,
1929 internal_ptr->u.syment.n_numaux * symesz);
1931 internal_ptr->u.syment._n._n_n._n_offset =
1934 aux->u.auxent.x_file.x_fname,
1935 (size_t) bfd_coff_filnmlen (abfd)));
1940 if (internal_ptr->u.syment._n._n_n._n_zeroes != 0)
1942 /* This is a "short" name. Make it long. */
1946 /* Find the length of this string without walking into memory
1948 for (i = 0; i < 8; ++i)
1949 if (internal_ptr->u.syment._n._n_name[i] == '\0')
1952 newstring = (char *) bfd_zalloc (abfd, (bfd_size_type) (i + 1));
1953 if (newstring == NULL)
1955 strncpy (newstring, internal_ptr->u.syment._n._n_name, i);
1956 internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) newstring;
1957 internal_ptr->u.syment._n._n_n._n_zeroes = 0;
1959 else if (internal_ptr->u.syment._n._n_n._n_offset == 0)
1960 internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) "";
1961 else if (!bfd_coff_symname_in_debug (abfd, &internal_ptr->u.syment))
1963 /* Long name already. Point symbol at the string in the
1965 if (string_table == NULL)
1967 string_table = _bfd_coff_read_string_table (abfd);
1968 if (string_table == NULL)
1971 if (internal_ptr->u.syment._n._n_n._n_offset >= obj_coff_strings_len (abfd)
1972 || string_table + internal_ptr->u.syment._n._n_n._n_offset < string_table)
1973 internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) _("<corrupt>");
1975 internal_ptr->u.syment._n._n_n._n_offset =
1978 + internal_ptr->u.syment._n._n_n._n_offset));
1982 /* Long name in debug section. Very similar. */
1983 if (debug_sec_data == NULL)
1984 debug_sec_data = build_debug_section (abfd, & debug_sec);
1985 if (debug_sec_data != NULL)
1987 BFD_ASSERT (debug_sec != NULL);
1988 /* PR binutils/17512: Catch out of range offsets into the debug data. */
1989 if (internal_ptr->u.syment._n._n_n._n_offset > debug_sec->size
1990 || debug_sec_data + internal_ptr->u.syment._n._n_n._n_offset < debug_sec_data)
1991 internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) _("<corrupt>");
1993 internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t)
1994 (debug_sec_data + internal_ptr->u.syment._n._n_n._n_offset);
1997 internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) "";
2000 internal_ptr += internal_ptr->u.syment.n_numaux;
2003 obj_raw_syments (abfd) = internal;
2004 BFD_ASSERT (obj_raw_syment_count (abfd)
2005 == (unsigned int) (internal_ptr - internal));
2010 #if GCC_VERSION >= 4003
2011 # pragma GCC diagnostic push
2012 # pragma GCC diagnostic ignored "-Wtype-limits"
2015 coff_get_reloc_upper_bound (bfd *abfd, sec_ptr asect)
2017 if (bfd_get_format (abfd) != bfd_object)
2019 bfd_set_error (bfd_error_invalid_operation);
2022 if (asect->reloc_count >= LONG_MAX / sizeof (arelent *))
2024 bfd_set_error (bfd_error_file_too_big);
2027 return (asect->reloc_count + 1) * sizeof (arelent *);
2029 #if GCC_VERSION >= 4003
2030 # pragma GCC diagnostic pop
2034 coff_make_empty_symbol (bfd *abfd)
2036 bfd_size_type amt = sizeof (coff_symbol_type);
2037 coff_symbol_type *new_symbol = (coff_symbol_type *) bfd_zalloc (abfd, amt);
2039 if (new_symbol == NULL)
2041 new_symbol->symbol.section = 0;
2042 new_symbol->native = NULL;
2043 new_symbol->lineno = NULL;
2044 new_symbol->done_lineno = FALSE;
2045 new_symbol->symbol.the_bfd = abfd;
2047 return & new_symbol->symbol;
2050 /* Make a debugging symbol. */
2053 coff_bfd_make_debug_symbol (bfd *abfd,
2054 void * ptr ATTRIBUTE_UNUSED,
2055 unsigned long sz ATTRIBUTE_UNUSED)
2057 bfd_size_type amt = sizeof (coff_symbol_type);
2058 coff_symbol_type *new_symbol = (coff_symbol_type *) bfd_alloc (abfd, amt);
2060 if (new_symbol == NULL)
2062 /* @@ The 10 is a guess at a plausible maximum number of aux entries
2063 (but shouldn't be a constant). */
2064 amt = sizeof (combined_entry_type) * 10;
2065 new_symbol->native = (combined_entry_type *) bfd_zalloc (abfd, amt);
2066 if (!new_symbol->native)
2068 new_symbol->native->is_sym = TRUE;
2069 new_symbol->symbol.section = bfd_abs_section_ptr;
2070 new_symbol->symbol.flags = BSF_DEBUGGING;
2071 new_symbol->lineno = NULL;
2072 new_symbol->done_lineno = FALSE;
2073 new_symbol->symbol.the_bfd = abfd;
2075 return & new_symbol->symbol;
2079 coff_get_symbol_info (bfd *abfd, asymbol *symbol, symbol_info *ret)
2081 bfd_symbol_info (symbol, ret);
2083 if (coffsymbol (symbol)->native != NULL
2084 && coffsymbol (symbol)->native->fix_value
2085 && coffsymbol (symbol)->native->is_sym)
2086 ret->value = coffsymbol (symbol)->native->u.syment.n_value -
2087 (bfd_hostptr_t) obj_raw_syments (abfd);
2090 /* Print out information about COFF symbol. */
2093 coff_print_symbol (bfd *abfd,
2096 bfd_print_symbol_type how)
2098 FILE * file = (FILE *) filep;
2102 case bfd_print_symbol_name:
2103 fprintf (file, "%s", symbol->name);
2106 case bfd_print_symbol_more:
2107 fprintf (file, "coff %s %s",
2108 coffsymbol (symbol)->native ? "n" : "g",
2109 coffsymbol (symbol)->lineno ? "l" : " ");
2112 case bfd_print_symbol_all:
2113 if (coffsymbol (symbol)->native)
2117 combined_entry_type *combined = coffsymbol (symbol)->native;
2118 combined_entry_type *root = obj_raw_syments (abfd);
2119 struct lineno_cache_entry *l = coffsymbol (symbol)->lineno;
2121 fprintf (file, "[%3ld]", (long) (combined - root));
2123 /* PR 17512: file: 079-33786-0.001:0.1. */
2124 if (combined < obj_raw_syments (abfd)
2125 || combined >= obj_raw_syments (abfd) + obj_raw_syment_count (abfd))
2127 fprintf (file, _("<corrupt info> %s"), symbol->name);
2131 BFD_ASSERT (combined->is_sym);
2132 if (! combined->fix_value)
2133 val = (bfd_vma) combined->u.syment.n_value;
2135 val = combined->u.syment.n_value - (bfd_hostptr_t) root;
2137 fprintf (file, "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x",
2138 combined->u.syment.n_scnum,
2139 combined->u.syment.n_flags,
2140 combined->u.syment.n_type,
2141 combined->u.syment.n_sclass,
2142 combined->u.syment.n_numaux);
2143 bfd_fprintf_vma (abfd, file, val);
2144 fprintf (file, " %s", symbol->name);
2146 for (aux = 0; aux < combined->u.syment.n_numaux; aux++)
2148 combined_entry_type *auxp = combined + aux + 1;
2151 BFD_ASSERT (! auxp->is_sym);
2153 tagndx = auxp->u.auxent.x_sym.x_tagndx.p - root;
2155 tagndx = auxp->u.auxent.x_sym.x_tagndx.l;
2157 fprintf (file, "\n");
2159 if (bfd_coff_print_aux (abfd, file, root, combined, auxp, aux))
2162 switch (combined->u.syment.n_sclass)
2165 fprintf (file, "File ");
2169 if (combined->u.syment.n_type == T_NULL)
2170 /* Probably a section symbol ? */
2172 fprintf (file, "AUX scnlen 0x%lx nreloc %d nlnno %d",
2173 (unsigned long) auxp->u.auxent.x_scn.x_scnlen,
2174 auxp->u.auxent.x_scn.x_nreloc,
2175 auxp->u.auxent.x_scn.x_nlinno);
2176 if (auxp->u.auxent.x_scn.x_checksum != 0
2177 || auxp->u.auxent.x_scn.x_associated != 0
2178 || auxp->u.auxent.x_scn.x_comdat != 0)
2179 fprintf (file, " checksum 0x%lx assoc %d comdat %d",
2180 auxp->u.auxent.x_scn.x_checksum,
2181 auxp->u.auxent.x_scn.x_associated,
2182 auxp->u.auxent.x_scn.x_comdat);
2188 if (ISFCN (combined->u.syment.n_type))
2193 next = (auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p
2196 next = auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l;
2197 llnos = auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_lnnoptr;
2199 "AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld",
2201 (unsigned long) auxp->u.auxent.x_sym.x_misc.x_fsize,
2207 fprintf (file, "AUX lnno %d size 0x%x tagndx %ld",
2208 auxp->u.auxent.x_sym.x_misc.x_lnsz.x_lnno,
2209 auxp->u.auxent.x_sym.x_misc.x_lnsz.x_size,
2212 fprintf (file, " endndx %ld",
2214 (auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p
2222 fprintf (file, "\n%s :", l->u.sym->name);
2224 while (l->line_number)
2226 if (l->line_number > 0)
2228 fprintf (file, "\n%4d : ", l->line_number);
2229 bfd_fprintf_vma (abfd, file, l->u.offset + symbol->section->vma);
2237 bfd_print_symbol_vandf (abfd, (void *) file, symbol);
2238 fprintf (file, " %-5s %s %s %s",
2239 symbol->section->name,
2240 coffsymbol (symbol)->native ? "n" : "g",
2241 coffsymbol (symbol)->lineno ? "l" : " ",
2247 /* Return whether a symbol name implies a local symbol. In COFF,
2248 local symbols generally start with ``.L''. Most targets use this
2249 function for the is_local_label_name entry point, but some may
2253 _bfd_coff_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
2256 return name[0] == '.' && name[1] == 'L';
2259 /* Provided a BFD, a section and an offset (in bytes, not octets) into the
2260 section, calculate and return the name of the source file and the line
2261 nearest to the wanted location. */
2264 coff_find_nearest_line_with_names (bfd *abfd,
2268 const char **filename_ptr,
2269 const char **functionname_ptr,
2270 unsigned int *line_ptr,
2271 const struct dwarf_debug_section *debug_sections)
2275 unsigned int line_base;
2276 coff_data_type *cof = coff_data (abfd);
2277 /* Run through the raw syments if available. */
2278 combined_entry_type *p;
2279 combined_entry_type *pend;
2281 struct coff_section_tdata *sec_data;
2284 /* Before looking through the symbol table, try to use a .stab
2285 section to find the information. */
2286 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
2287 &found, filename_ptr,
2288 functionname_ptr, line_ptr,
2289 &coff_data(abfd)->line_info))
2295 /* Also try examining DWARF2 debugging information. */
2296 if (_bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset,
2297 filename_ptr, functionname_ptr,
2298 line_ptr, NULL, debug_sections, 0,
2299 &coff_data(abfd)->dwarf2_find_line_info))
2302 sec_data = coff_section_data (abfd, section);
2304 /* If the DWARF lookup failed, but there is DWARF information available
2305 then the problem might be that the file has been rebased. This tool
2306 changes the VMAs of all the sections, but it does not update the DWARF
2307 information. So try again, using a bias against the address sought. */
2308 if (coff_data (abfd)->dwarf2_find_line_info != NULL)
2310 bfd_signed_vma bias = 0;
2312 /* Create a cache of the result for the next call. */
2313 if (sec_data == NULL && section->owner == abfd)
2315 amt = sizeof (struct coff_section_tdata);
2316 section->used_by_bfd = bfd_zalloc (abfd, amt);
2317 sec_data = (struct coff_section_tdata *) section->used_by_bfd;
2320 if (sec_data != NULL && sec_data->saved_bias)
2321 bias = sec_data->saved_bias;
2324 bias = _bfd_dwarf2_find_symbol_bias (symbols,
2325 & coff_data (abfd)->dwarf2_find_line_info);
2329 sec_data->saved_bias = TRUE;
2330 sec_data->bias = bias;
2335 && _bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section,
2337 filename_ptr, functionname_ptr,
2338 line_ptr, NULL, debug_sections, 0,
2339 &coff_data(abfd)->dwarf2_find_line_info))
2344 *functionname_ptr = 0;
2347 /* Don't try and find line numbers in a non coff file. */
2348 if (!bfd_family_coff (abfd))
2354 /* Find the first C_FILE symbol. */
2355 p = cof->raw_syments;
2359 pend = p + cof->raw_syment_count;
2362 BFD_ASSERT (p->is_sym);
2363 if (p->u.syment.n_sclass == C_FILE)
2365 p += 1 + p->u.syment.n_numaux;
2373 /* Look through the C_FILE symbols to find the best one. */
2374 sec_vma = bfd_get_section_vma (abfd, section);
2375 *filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
2376 maxdiff = (bfd_vma) 0 - (bfd_vma) 1;
2380 combined_entry_type *p2;
2382 for (p2 = p + 1 + p->u.syment.n_numaux;
2384 p2 += 1 + p2->u.syment.n_numaux)
2386 BFD_ASSERT (p2->is_sym);
2387 if (p2->u.syment.n_scnum > 0
2389 == coff_section_from_bfd_index (abfd,
2390 p2->u.syment.n_scnum)))
2392 if (p2->u.syment.n_sclass == C_FILE)
2401 file_addr = (bfd_vma) p2->u.syment.n_value;
2402 /* PR 11512: Include the section address of the function name symbol. */
2403 if (p2->u.syment.n_scnum > 0)
2404 file_addr += coff_section_from_bfd_index (abfd,
2405 p2->u.syment.n_scnum)->vma;
2406 /* We use <= MAXDIFF here so that if we get a zero length
2407 file, we actually use the next file entry. */
2409 && offset + sec_vma >= file_addr
2410 && offset + sec_vma - file_addr <= maxdiff)
2412 *filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
2413 maxdiff = offset + sec_vma - p2->u.syment.n_value;
2416 /* Avoid endless loops on erroneous files by ensuring that
2417 we always move forward in the file. */
2418 if (p >= cof->raw_syments + p->u.syment.n_value)
2421 p = cof->raw_syments + p->u.syment.n_value;
2422 if (p > pend || p->u.syment.n_sclass != C_FILE)
2427 if (section->lineno_count == 0)
2429 *functionname_ptr = NULL;
2434 /* Now wander though the raw linenumbers of the section.
2435 If we have been called on this section before, and the offset
2436 we want is further down then we can prime the lookup loop. */
2437 if (sec_data != NULL
2439 && offset >= sec_data->offset)
2442 *functionname_ptr = sec_data->function;
2443 line_base = sec_data->line_base;
2451 if (section->lineno != NULL)
2453 bfd_vma last_value = 0;
2455 l = §ion->lineno[i];
2457 for (; i < section->lineno_count; i++)
2459 if (l->line_number == 0)
2461 /* Get the symbol this line number points at. */
2462 coff_symbol_type *coff = (coff_symbol_type *) (l->u.sym);
2463 if (coff->symbol.value > offset)
2466 *functionname_ptr = coff->symbol.name;
2467 last_value = coff->symbol.value;
2470 combined_entry_type *s = coff->native;
2472 BFD_ASSERT (s->is_sym);
2473 s = s + 1 + s->u.syment.n_numaux;
2475 /* In XCOFF a debugging symbol can follow the
2477 if (s->u.syment.n_scnum == N_DEBUG)
2478 s = s + 1 + s->u.syment.n_numaux;
2480 /* S should now point to the .bf of the function. */
2481 if (s->u.syment.n_numaux)
2483 /* The linenumber is stored in the auxent. */
2484 union internal_auxent *a = &((s + 1)->u.auxent);
2486 line_base = a->x_sym.x_misc.x_lnsz.x_lnno;
2487 *line_ptr = line_base;
2493 if (l->u.offset > offset)
2495 *line_ptr = l->line_number + line_base - 1;
2500 /* If we fell off the end of the loop, then assume that this
2501 symbol has no line number info. Otherwise, symbols with no
2502 line number info get reported with the line number of the
2503 last line of the last symbol which does have line number
2504 info. We use 0x100 as a slop to account for cases where the
2505 last line has executable code. */
2506 if (i >= section->lineno_count
2508 && offset - last_value > 0x100)
2510 *functionname_ptr = NULL;
2515 /* Cache the results for the next call. */
2516 if (sec_data == NULL && section->owner == abfd)
2518 amt = sizeof (struct coff_section_tdata);
2519 section->used_by_bfd = bfd_zalloc (abfd, amt);
2520 sec_data = (struct coff_section_tdata *) section->used_by_bfd;
2523 if (sec_data != NULL)
2525 sec_data->offset = offset;
2526 sec_data->i = i - 1;
2527 sec_data->function = *functionname_ptr;
2528 sec_data->line_base = line_base;
2535 coff_find_nearest_line (bfd *abfd,
2539 const char **filename_ptr,
2540 const char **functionname_ptr,
2541 unsigned int *line_ptr,
2542 unsigned int *discriminator_ptr)
2544 if (discriminator_ptr)
2545 *discriminator_ptr = 0;
2546 return coff_find_nearest_line_with_names (abfd, symbols, section, offset,
2547 filename_ptr, functionname_ptr,
2548 line_ptr, dwarf_debug_sections);
2552 coff_find_inliner_info (bfd *abfd,
2553 const char **filename_ptr,
2554 const char **functionname_ptr,
2555 unsigned int *line_ptr)
2559 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
2560 functionname_ptr, line_ptr,
2561 &coff_data(abfd)->dwarf2_find_line_info);
2566 coff_sizeof_headers (bfd *abfd, struct bfd_link_info *info)
2570 if (!bfd_link_relocatable (info))
2571 size = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
2573 size = bfd_coff_filhsz (abfd);
2575 size += abfd->section_count * bfd_coff_scnhsz (abfd);
2579 /* Change the class of a coff symbol held by BFD. */
2582 bfd_coff_set_symbol_class (bfd * abfd,
2584 unsigned int symbol_class)
2586 coff_symbol_type * csym;
2588 csym = coff_symbol_from (symbol);
2591 bfd_set_error (bfd_error_invalid_operation);
2594 else if (csym->native == NULL)
2596 /* This is an alien symbol which no native coff backend data.
2597 We cheat here by creating a fake native entry for it and
2598 then filling in the class. This code is based on that in
2599 coff_write_alien_symbol(). */
2601 combined_entry_type * native;
2602 bfd_size_type amt = sizeof (* native);
2604 native = (combined_entry_type *) bfd_zalloc (abfd, amt);
2608 native->is_sym = TRUE;
2609 native->u.syment.n_type = T_NULL;
2610 native->u.syment.n_sclass = symbol_class;
2612 if (bfd_is_und_section (symbol->section))
2614 native->u.syment.n_scnum = N_UNDEF;
2615 native->u.syment.n_value = symbol->value;
2617 else if (bfd_is_com_section (symbol->section))
2619 native->u.syment.n_scnum = N_UNDEF;
2620 native->u.syment.n_value = symbol->value;
2624 native->u.syment.n_scnum =
2625 symbol->section->output_section->target_index;
2626 native->u.syment.n_value = (symbol->value
2627 + symbol->section->output_offset);
2628 if (! obj_pe (abfd))
2629 native->u.syment.n_value += symbol->section->output_section->vma;
2631 /* Copy the any flags from the file header into the symbol.
2633 native->u.syment.n_flags = bfd_asymbol_bfd (& csym->symbol)->flags;
2636 csym->native = native;
2639 csym->native->u.syment.n_sclass = symbol_class;
2645 _bfd_coff_section_already_linked (bfd *abfd,
2647 struct bfd_link_info *info)
2650 const char *name, *key;
2651 struct bfd_section_already_linked *l;
2652 struct bfd_section_already_linked_hash_entry *already_linked_list;
2653 struct coff_comdat_info *s_comdat;
2656 if ((flags & SEC_LINK_ONCE) == 0)
2659 /* The COFF backend linker doesn't support group sections. */
2660 if ((flags & SEC_GROUP) != 0)
2663 name = bfd_get_section_name (abfd, sec);
2664 s_comdat = bfd_coff_get_comdat_section (abfd, sec);
2666 if (s_comdat != NULL)
2667 key = s_comdat->name;
2670 if (CONST_STRNEQ (name, ".gnu.linkonce.")
2671 && (key = strchr (name + sizeof (".gnu.linkonce.") - 1, '.')) != NULL)
2674 /* FIXME: gcc as of 2011-09 emits sections like .text$<key>,
2675 .xdata$<key> and .pdata$<key> only the first of which has a
2676 comdat key. Should these all match the LTO IR key? */
2680 already_linked_list = bfd_section_already_linked_table_lookup (key);
2682 for (l = already_linked_list->entry; l != NULL; l = l->next)
2684 struct coff_comdat_info *l_comdat;
2686 l_comdat = bfd_coff_get_comdat_section (l->sec->owner, l->sec);
2688 /* The section names must match, and both sections must be
2689 comdat and have the same comdat name, or both sections must
2690 be non-comdat. LTO IR plugin sections are an exception. They
2691 are always named .gnu.linkonce.t.<key> (<key> is some string)
2692 and match any comdat section with comdat name of <key>, and
2693 any linkonce section with the same suffix, ie.
2694 .gnu.linkonce.*.<key>. */
2695 if (((s_comdat != NULL) == (l_comdat != NULL)
2696 && strcmp (name, l->sec->name) == 0)
2697 || (l->sec->owner->flags & BFD_PLUGIN) != 0)
2699 /* The section has already been linked. See if we should
2701 return _bfd_handle_already_linked (sec, l, info);
2705 /* This is the first section with this name. Record it. */
2706 if (!bfd_section_already_linked_table_insert (already_linked_list, sec))
2707 info->callbacks->einfo (_("%F%P: already_linked_table: %E\n"));
2711 /* Initialize COOKIE for input bfd ABFD. */
2714 init_reloc_cookie (struct coff_reloc_cookie *cookie,
2715 struct bfd_link_info *info ATTRIBUTE_UNUSED,
2718 /* Sometimes the symbol table does not yet have been loaded here. */
2719 bfd_coff_slurp_symbol_table (abfd);
2721 cookie->abfd = abfd;
2722 cookie->sym_hashes = obj_coff_sym_hashes (abfd);
2724 cookie->symbols = obj_symbols (abfd);
2729 /* Free the memory allocated by init_reloc_cookie, if appropriate. */
2732 fini_reloc_cookie (struct coff_reloc_cookie *cookie ATTRIBUTE_UNUSED,
2733 bfd *abfd ATTRIBUTE_UNUSED)
2735 /* Nothing to do. */
2738 /* Initialize the relocation information in COOKIE for input section SEC
2739 of input bfd ABFD. */
2742 init_reloc_cookie_rels (struct coff_reloc_cookie *cookie,
2743 struct bfd_link_info *info ATTRIBUTE_UNUSED,
2747 if (sec->reloc_count == 0)
2749 cookie->rels = NULL;
2750 cookie->relend = NULL;
2755 cookie->rels = _bfd_coff_read_internal_relocs (abfd, sec, FALSE, NULL, 0, NULL);
2757 if (cookie->rels == NULL)
2760 cookie->rel = cookie->rels;
2761 cookie->relend = (cookie->rels + sec->reloc_count);
2765 /* Free the memory allocated by init_reloc_cookie_rels,
2769 fini_reloc_cookie_rels (struct coff_reloc_cookie *cookie,
2773 /* PR 20401. The relocs may not have been cached, so check first.
2774 If the relocs were loaded by init_reloc_cookie_rels() then this
2775 will be the case. FIXME: Would performance be improved if the
2776 relocs *were* cached ? */
2777 && coff_section_data (NULL, sec)
2778 && coff_section_data (NULL, sec)->relocs != cookie->rels)
2779 free (cookie->rels);
2782 /* Initialize the whole of COOKIE for input section SEC. */
2785 init_reloc_cookie_for_section (struct coff_reloc_cookie *cookie,
2786 struct bfd_link_info *info,
2789 if (!init_reloc_cookie (cookie, info, sec->owner))
2792 if (!init_reloc_cookie_rels (cookie, info, sec->owner, sec))
2794 fini_reloc_cookie (cookie, sec->owner);
2800 /* Free the memory allocated by init_reloc_cookie_for_section,
2804 fini_reloc_cookie_for_section (struct coff_reloc_cookie *cookie,
2807 fini_reloc_cookie_rels (cookie, sec);
2808 fini_reloc_cookie (cookie, sec->owner);
2812 _bfd_coff_gc_mark_hook (asection *sec,
2813 struct bfd_link_info *info ATTRIBUTE_UNUSED,
2814 struct internal_reloc *rel ATTRIBUTE_UNUSED,
2815 struct coff_link_hash_entry *h,
2816 struct internal_syment *sym)
2820 switch (h->root.type)
2822 case bfd_link_hash_defined:
2823 case bfd_link_hash_defweak:
2824 return h->root.u.def.section;
2826 case bfd_link_hash_common:
2827 return h->root.u.c.p->section;
2829 case bfd_link_hash_undefweak:
2830 if (h->symbol_class == C_NT_WEAK && h->numaux == 1)
2832 /* PE weak externals. A weak symbol may include an auxiliary
2833 record indicating that if the weak symbol is not resolved,
2834 another external symbol is used instead. */
2835 struct coff_link_hash_entry *h2 =
2836 h->auxbfd->tdata.coff_obj_data->sym_hashes[
2837 h->aux->x_sym.x_tagndx.l];
2839 if (h2 && h2->root.type != bfd_link_hash_undefined)
2840 return h2->root.u.def.section;
2844 case bfd_link_hash_undefined:
2851 return coff_section_from_bfd_index (sec->owner, sym->n_scnum);
2854 /* COOKIE->rel describes a relocation against section SEC, which is
2855 a section we've decided to keep. Return the section that contains
2856 the relocation symbol, or NULL if no section contains it. */
2859 _bfd_coff_gc_mark_rsec (struct bfd_link_info *info, asection *sec,
2860 coff_gc_mark_hook_fn gc_mark_hook,
2861 struct coff_reloc_cookie *cookie)
2863 struct coff_link_hash_entry *h;
2865 h = cookie->sym_hashes[cookie->rel->r_symndx];
2868 while (h->root.type == bfd_link_hash_indirect
2869 || h->root.type == bfd_link_hash_warning)
2870 h = (struct coff_link_hash_entry *) h->root.u.i.link;
2872 return (*gc_mark_hook) (sec, info, cookie->rel, h, NULL);
2875 return (*gc_mark_hook) (sec, info, cookie->rel, NULL,
2877 + obj_convert (sec->owner)[cookie->rel->r_symndx])->native->u.syment);
2880 static bfd_boolean _bfd_coff_gc_mark
2881 (struct bfd_link_info *, asection *, coff_gc_mark_hook_fn);
2883 /* COOKIE->rel describes a relocation against section SEC, which is
2884 a section we've decided to keep. Mark the section that contains
2885 the relocation symbol. */
2888 _bfd_coff_gc_mark_reloc (struct bfd_link_info *info,
2890 coff_gc_mark_hook_fn gc_mark_hook,
2891 struct coff_reloc_cookie *cookie)
2895 rsec = _bfd_coff_gc_mark_rsec (info, sec, gc_mark_hook, cookie);
2896 if (rsec && !rsec->gc_mark)
2898 if (bfd_get_flavour (rsec->owner) != bfd_target_coff_flavour)
2900 else if (!_bfd_coff_gc_mark (info, rsec, gc_mark_hook))
2906 /* The mark phase of garbage collection. For a given section, mark
2907 it and any sections in this section's group, and all the sections
2908 which define symbols to which it refers. */
2911 _bfd_coff_gc_mark (struct bfd_link_info *info,
2913 coff_gc_mark_hook_fn gc_mark_hook)
2915 bfd_boolean ret = TRUE;
2919 /* Look through the section relocs. */
2920 if ((sec->flags & SEC_RELOC) != 0
2921 && sec->reloc_count > 0)
2923 struct coff_reloc_cookie cookie;
2925 if (!init_reloc_cookie_for_section (&cookie, info, sec))
2929 for (; cookie.rel < cookie.relend; cookie.rel++)
2931 if (!_bfd_coff_gc_mark_reloc (info, sec, gc_mark_hook, &cookie))
2937 fini_reloc_cookie_for_section (&cookie, sec);
2945 _bfd_coff_gc_mark_extra_sections (struct bfd_link_info *info,
2946 coff_gc_mark_hook_fn mark_hook ATTRIBUTE_UNUSED)
2950 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2953 bfd_boolean some_kept;
2955 if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour)
2958 /* Ensure all linker created sections are kept, and see whether
2959 any other section is already marked. */
2961 for (isec = ibfd->sections; isec != NULL; isec = isec->next)
2963 if ((isec->flags & SEC_LINKER_CREATED) != 0)
2965 else if (isec->gc_mark)
2969 /* If no section in this file will be kept, then we can
2970 toss out debug sections. */
2974 /* Keep debug and special sections like .comment when they are
2975 not part of a group, or when we have single-member groups. */
2976 for (isec = ibfd->sections; isec != NULL; isec = isec->next)
2977 if ((isec->flags & SEC_DEBUGGING) != 0
2978 || (isec->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) == 0)
2984 /* Sweep symbols in swept sections. Called via coff_link_hash_traverse. */
2987 coff_gc_sweep_symbol (struct coff_link_hash_entry *h,
2988 void *data ATTRIBUTE_UNUSED)
2990 if (h->root.type == bfd_link_hash_warning)
2991 h = (struct coff_link_hash_entry *) h->root.u.i.link;
2993 if ((h->root.type == bfd_link_hash_defined
2994 || h->root.type == bfd_link_hash_defweak)
2995 && !h->root.u.def.section->gc_mark
2996 && !(h->root.u.def.section->owner->flags & DYNAMIC))
2998 /* Do our best to hide the symbol. */
2999 h->root.u.def.section = bfd_und_section_ptr;
3000 h->symbol_class = C_HIDDEN;
3006 /* The sweep phase of garbage collection. Remove all garbage sections. */
3008 typedef bfd_boolean (*gc_sweep_hook_fn)
3009 (bfd *, struct bfd_link_info *, asection *, const struct internal_reloc *);
3012 coff_gc_sweep (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
3016 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
3020 if (bfd_get_flavour (sub) != bfd_target_coff_flavour)
3023 for (o = sub->sections; o != NULL; o = o->next)
3025 /* Keep debug and special sections. */
3026 if ((o->flags & (SEC_DEBUGGING | SEC_LINKER_CREATED)) != 0
3027 || (o->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) == 0)
3029 else if (CONST_STRNEQ (o->name, ".idata")
3030 || CONST_STRNEQ (o->name, ".pdata")
3031 || CONST_STRNEQ (o->name, ".xdata")
3032 || CONST_STRNEQ (o->name, ".rsrc"))
3038 /* Skip sweeping sections already excluded. */
3039 if (o->flags & SEC_EXCLUDE)
3042 /* Since this is early in the link process, it is simple
3043 to remove a section from the output. */
3044 o->flags |= SEC_EXCLUDE;
3046 if (info->print_gc_sections && o->size != 0)
3047 /* xgettext: c-format */
3048 _bfd_error_handler (_("removing unused section '%pA' in file '%pB'"),
3052 /* But we also have to update some of the relocation
3053 info we collected before. */
3055 && (o->flags & SEC_RELOC) != 0
3056 && o->reloc_count > 0
3057 && !bfd_is_abs_section (o->output_section))
3059 struct internal_reloc *internal_relocs;
3063 = _bfd_coff_link_read_relocs (o->owner, o, NULL, NULL,
3065 if (internal_relocs == NULL)
3068 r = (*gc_sweep_hook) (o->owner, info, o, internal_relocs);
3070 if (coff_section_data (o)->relocs != internal_relocs)
3071 free (internal_relocs);
3080 /* Remove the symbols that were in the swept sections from the dynamic
3082 coff_link_hash_traverse (coff_hash_table (info), coff_gc_sweep_symbol,
3088 /* Keep all sections containing symbols undefined on the command-line,
3089 and the section containing the entry symbol. */
3092 _bfd_coff_gc_keep (struct bfd_link_info *info)
3094 struct bfd_sym_chain *sym;
3096 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
3098 struct coff_link_hash_entry *h;
3100 h = coff_link_hash_lookup (coff_hash_table (info), sym->name,
3101 FALSE, FALSE, FALSE);
3104 && (h->root.type == bfd_link_hash_defined
3105 || h->root.type == bfd_link_hash_defweak)
3106 && !bfd_is_abs_section (h->root.u.def.section))
3107 h->root.u.def.section->flags |= SEC_KEEP;
3111 /* Do mark and sweep of unused sections. */
3114 bfd_coff_gc_sections (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
3118 /* FIXME: Should we implement this? */
3120 const bfd_coff_backend_data *bed = coff_backend_info (abfd);
3122 if (!bed->can_gc_sections
3123 || !is_coff_hash_table (info->hash))
3125 _bfd_error_handler(_("warning: gc-sections option ignored"));
3130 _bfd_coff_gc_keep (info);
3132 /* Grovel through relocs to find out who stays ... */
3133 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
3137 if (bfd_get_flavour (sub) != bfd_target_coff_flavour)
3140 for (o = sub->sections; o != NULL; o = o->next)
3142 if (((o->flags & (SEC_EXCLUDE | SEC_KEEP)) == SEC_KEEP
3143 || CONST_STRNEQ (o->name, ".vectors")
3144 || CONST_STRNEQ (o->name, ".ctors")
3145 || CONST_STRNEQ (o->name, ".dtors"))
3148 if (!_bfd_coff_gc_mark (info, o, _bfd_coff_gc_mark_hook))
3154 /* Allow the backend to mark additional target specific sections. */
3155 _bfd_coff_gc_mark_extra_sections (info, _bfd_coff_gc_mark_hook);
3157 /* ... and mark SEC_EXCLUDE for those that go. */
3158 return coff_gc_sweep (abfd, info);