1 /* Support for the generic parts of COFF, for BFD.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4 Free Software Foundation, Inc.
5 Written by Cygnus Support.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
23 /* Most of this hacked by Steve Chamberlain, sac@cygnus.com.
24 Split out of coffcode.h by Ian Taylor, ian@cygnus.com. */
26 /* This file contains COFF code that is not dependent on any
27 particular COFF target. There is only one version of this file in
28 libbfd.a, so no target specific code may be put in here. Or, to
31 ********** DO NOT PUT TARGET SPECIFIC CODE IN THIS FILE **********
33 If you need to add some target specific behaviour, add a new hook
34 function to bfd_coff_backend_data.
36 Some of these functions are also called by the ECOFF routines.
37 Those functions may not use any COFF specific information, such as
43 #include "coff/internal.h"
46 static void coff_fix_symbol_name
47 PARAMS ((bfd *, asymbol *, combined_entry_type *, bfd_size_type *,
48 asection **, bfd_size_type *));
49 static boolean coff_write_symbol
50 PARAMS ((bfd *, asymbol *, combined_entry_type *, bfd_vma *,
51 bfd_size_type *, asection **, bfd_size_type *));
52 static boolean coff_write_alien_symbol
53 PARAMS ((bfd *, asymbol *, bfd_vma *, bfd_size_type *,
54 asection **, bfd_size_type *));
55 static boolean coff_write_native_symbol
56 PARAMS ((bfd *, coff_symbol_type *, bfd_vma *, bfd_size_type *,
57 asection **, bfd_size_type *));
58 static void coff_pointerize_aux
59 PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
60 unsigned int, combined_entry_type *));
61 static boolean make_a_section_from_file
62 PARAMS ((bfd *, struct internal_scnhdr *, unsigned int));
63 static const bfd_target *coff_real_object_p
64 PARAMS ((bfd *, unsigned, struct internal_filehdr *,
65 struct internal_aouthdr *));
66 static void fixup_symbol_value
67 PARAMS ((bfd *, coff_symbol_type *, struct internal_syment *));
68 static char *build_debug_section
70 static char *copy_name
71 PARAMS ((bfd *, char *, size_t));
73 #define STRING_SIZE_SIZE (4)
75 /* Take a section header read from a coff file (in HOST byte order),
76 and make a BFD "section" out of it. This is used by ECOFF. */
78 make_a_section_from_file (abfd, hdr, target_index)
80 struct internal_scnhdr *hdr;
81 unsigned int target_index;
83 asection *return_section;
85 boolean result = true;
90 /* Handle long section names as in PE. */
91 if (bfd_coff_long_section_names (abfd)
92 && hdr->s_name[0] == '/')
99 memcpy (buf, hdr->s_name + 1, SCNNMLEN - 1);
100 buf[SCNNMLEN - 1] = '\0';
101 strindex = strtol (buf, &p, 10);
102 if (*p == '\0' && strindex >= 0)
104 strings = _bfd_coff_read_string_table (abfd);
107 /* FIXME: For extra safety, we should make sure that
108 strindex does not run us past the end, but right now we
109 don't know the length of the string table. */
111 name = bfd_alloc (abfd, (bfd_size_type) strlen (strings) + 1);
114 strcpy (name, strings);
120 /* Assorted wastage to null-terminate the name, thanks AT&T! */
121 name = bfd_alloc (abfd, (bfd_size_type) sizeof (hdr->s_name) + 1);
124 strncpy (name, (char *) &hdr->s_name[0], sizeof (hdr->s_name));
125 name[sizeof (hdr->s_name)] = 0;
128 return_section = bfd_make_section_anyway (abfd, name);
129 if (return_section == NULL)
132 return_section->vma = hdr->s_vaddr;
133 return_section->lma = hdr->s_paddr;
134 return_section->_raw_size = hdr->s_size;
135 return_section->filepos = hdr->s_scnptr;
136 return_section->rel_filepos = hdr->s_relptr;
137 return_section->reloc_count = hdr->s_nreloc;
139 bfd_coff_set_alignment_hook (abfd, return_section, hdr);
141 return_section->line_filepos = hdr->s_lnnoptr;
143 return_section->lineno_count = hdr->s_nlnno;
144 return_section->userdata = NULL;
145 return_section->next = (asection *) NULL;
146 return_section->target_index = target_index;
148 if (! bfd_coff_styp_to_sec_flags_hook (abfd, hdr, name, return_section,
152 return_section->flags = flags;
154 /* At least on i386-coff, the line number count for a shared library
155 section must be ignored. */
156 if ((return_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
157 return_section->lineno_count = 0;
159 if (hdr->s_nreloc != 0)
160 return_section->flags |= SEC_RELOC;
161 /* FIXME: should this check 'hdr->s_size > 0' */
162 if (hdr->s_scnptr != 0)
163 return_section->flags |= SEC_HAS_CONTENTS;
168 /* Read in a COFF object and make it into a BFD. This is used by
171 static const bfd_target *
172 coff_real_object_p (abfd, nscns, internal_f, internal_a)
175 struct internal_filehdr *internal_f;
176 struct internal_aouthdr *internal_a;
178 flagword oflags = abfd->flags;
179 bfd_vma ostart = bfd_get_start_address (abfd);
181 bfd_size_type readsize; /* length of file_info */
183 char *external_sections;
185 if (!(internal_f->f_flags & F_RELFLG))
186 abfd->flags |= HAS_RELOC;
187 if ((internal_f->f_flags & F_EXEC))
188 abfd->flags |= EXEC_P;
189 if (!(internal_f->f_flags & F_LNNO))
190 abfd->flags |= HAS_LINENO;
191 if (!(internal_f->f_flags & F_LSYMS))
192 abfd->flags |= HAS_LOCALS;
194 /* FIXME: How can we set D_PAGED correctly? */
195 if ((internal_f->f_flags & F_EXEC) != 0)
196 abfd->flags |= D_PAGED;
198 bfd_get_symcount (abfd) = internal_f->f_nsyms;
199 if (internal_f->f_nsyms)
200 abfd->flags |= HAS_SYMS;
202 if (internal_a != (struct internal_aouthdr *) NULL)
203 bfd_get_start_address (abfd) = internal_a->entry;
205 bfd_get_start_address (abfd) = 0;
207 /* Set up the tdata area. ECOFF uses its own routine, and overrides
209 tdata = bfd_coff_mkobject_hook (abfd, (PTR) internal_f, (PTR) internal_a);
213 scnhsz = bfd_coff_scnhsz (abfd);
214 readsize = (bfd_size_type) nscns * scnhsz;
215 external_sections = (char *) bfd_alloc (abfd, readsize);
216 if (!external_sections)
219 if (bfd_bread ((PTR) external_sections, readsize, abfd) != readsize)
222 /* Set the arch/mach *before* swapping in sections; section header swapping
223 may depend on arch/mach info. */
224 if (bfd_coff_set_arch_mach_hook (abfd, (PTR) internal_f) == false)
227 /* Now copy data as required; construct all asections etc */
231 for (i = 0; i < nscns; i++)
233 struct internal_scnhdr tmp;
234 bfd_coff_swap_scnhdr_in (abfd,
235 (PTR) (external_sections + i * scnhsz),
237 if (! make_a_section_from_file (abfd, &tmp, i + 1))
242 /* make_abs_section (abfd); */
247 bfd_release (abfd, tdata);
248 abfd->flags = oflags;
249 bfd_get_start_address (abfd) = ostart;
250 return (const bfd_target *) NULL;
253 /* Turn a COFF file into a BFD, but fail with bfd_error_wrong_format if it is
254 not a COFF file. This is also used by ECOFF. */
260 bfd_size_type filhsz;
261 bfd_size_type aoutsz;
264 struct internal_filehdr internal_f;
265 struct internal_aouthdr internal_a;
267 /* figure out how much to read */
268 filhsz = bfd_coff_filhsz (abfd);
269 aoutsz = bfd_coff_aoutsz (abfd);
271 filehdr = bfd_alloc (abfd, filhsz);
274 if (bfd_bread (filehdr, filhsz, abfd) != filhsz)
276 if (bfd_get_error () != bfd_error_system_call)
277 bfd_set_error (bfd_error_wrong_format);
280 bfd_coff_swap_filehdr_in (abfd, filehdr, &internal_f);
281 bfd_release (abfd, filehdr);
283 /* The XCOFF format has two sizes for the f_opthdr. SMALL_AOUTSZ
284 (less than aoutsz) used in object files and AOUTSZ (equal to
285 aoutsz) in executables. The bfd_coff_swap_aouthdr_in function
286 expects this header to be aoutsz bytes in length, so we use that
287 value in the call to bfd_alloc below. But we must be careful to
288 only read in f_opthdr bytes in the call to bfd_bread. We should
289 also attempt to catch corrupt or non-COFF binaries with a strange
290 value for f_opthdr. */
291 if (bfd_coff_bad_format_hook (abfd, &internal_f) == false
292 || internal_f.f_opthdr > aoutsz)
294 bfd_set_error (bfd_error_wrong_format);
297 nscns = internal_f.f_nscns;
299 if (internal_f.f_opthdr)
303 opthdr = bfd_alloc (abfd, aoutsz);
306 if (bfd_bread (opthdr, (bfd_size_type) internal_f.f_opthdr, abfd)
307 != internal_f.f_opthdr)
311 bfd_coff_swap_aouthdr_in (abfd, opthdr, (PTR) &internal_a);
314 return coff_real_object_p (abfd, nscns, &internal_f,
315 (internal_f.f_opthdr != 0
317 : (struct internal_aouthdr *) NULL));
320 /* Get the BFD section from a COFF symbol section number. */
323 coff_section_from_bfd_index (abfd, index)
327 struct sec *answer = abfd->sections;
330 return bfd_abs_section_ptr;
331 if (index == N_UNDEF)
332 return bfd_und_section_ptr;
333 if (index == N_DEBUG)
334 return bfd_abs_section_ptr;
338 if (answer->target_index == index)
340 answer = answer->next;
343 /* We should not reach this point, but the SCO 3.2v4 /lib/libc_s.a
344 has a bad symbol table in biglitpow.o. */
345 return bfd_und_section_ptr;
348 /* Get the upper bound of a COFF symbol table. */
351 coff_get_symtab_upper_bound (abfd)
354 if (!bfd_coff_slurp_symbol_table (abfd))
357 return (bfd_get_symcount (abfd) + 1) * (sizeof (coff_symbol_type *));
360 /* Canonicalize a COFF symbol table. */
363 coff_get_symtab (abfd, alocation)
367 unsigned int counter;
368 coff_symbol_type *symbase;
369 coff_symbol_type **location = (coff_symbol_type **) alocation;
371 if (!bfd_coff_slurp_symbol_table (abfd))
374 symbase = obj_symbols (abfd);
375 counter = bfd_get_symcount (abfd);
376 while (counter-- > 0)
377 *location++ = symbase++;
381 return bfd_get_symcount (abfd);
384 /* Get the name of a symbol. The caller must pass in a buffer of size
388 _bfd_coff_internal_syment_name (abfd, sym, buf)
390 const struct internal_syment *sym;
393 /* FIXME: It's not clear this will work correctly if sizeof
395 if (sym->_n._n_n._n_zeroes != 0
396 || sym->_n._n_n._n_offset == 0)
398 memcpy (buf, sym->_n._n_name, SYMNMLEN);
399 buf[SYMNMLEN] = '\0';
406 BFD_ASSERT (sym->_n._n_n._n_offset >= STRING_SIZE_SIZE);
407 strings = obj_coff_strings (abfd);
410 strings = _bfd_coff_read_string_table (abfd);
414 return strings + sym->_n._n_n._n_offset;
418 /* Read in and swap the relocs. This returns a buffer holding the
419 relocs for section SEC in file ABFD. If CACHE is true and
420 INTERNAL_RELOCS is NULL, the relocs read in will be saved in case
421 the function is called again. If EXTERNAL_RELOCS is not NULL, it
422 is a buffer large enough to hold the unswapped relocs. If
423 INTERNAL_RELOCS is not NULL, it is a buffer large enough to hold
424 the swapped relocs. If REQUIRE_INTERNAL is true, then the return
425 value must be INTERNAL_RELOCS. The function returns NULL on error. */
427 struct internal_reloc *
428 _bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs,
429 require_internal, internal_relocs)
433 bfd_byte *external_relocs;
434 boolean require_internal;
435 struct internal_reloc *internal_relocs;
438 bfd_byte *free_external = NULL;
439 struct internal_reloc *free_internal = NULL;
442 struct internal_reloc *irel;
445 if (coff_section_data (abfd, sec) != NULL
446 && coff_section_data (abfd, sec)->relocs != NULL)
448 if (! require_internal)
449 return coff_section_data (abfd, sec)->relocs;
450 memcpy (internal_relocs, coff_section_data (abfd, sec)->relocs,
451 sec->reloc_count * sizeof (struct internal_reloc));
452 return internal_relocs;
455 relsz = bfd_coff_relsz (abfd);
457 amt = sec->reloc_count * relsz;
458 if (external_relocs == NULL)
460 free_external = (bfd_byte *) bfd_malloc (amt);
461 if (free_external == NULL && sec->reloc_count > 0)
463 external_relocs = free_external;
466 if (bfd_seek (abfd, sec->rel_filepos, SEEK_SET) != 0
467 || bfd_bread (external_relocs, amt, abfd) != amt)
470 if (internal_relocs == NULL)
472 amt = sec->reloc_count;
473 amt *= sizeof (struct internal_reloc);
474 free_internal = (struct internal_reloc *) bfd_malloc (amt);
475 if (free_internal == NULL && sec->reloc_count > 0)
477 internal_relocs = free_internal;
480 /* Swap in the relocs. */
481 erel = external_relocs;
482 erel_end = erel + relsz * sec->reloc_count;
483 irel = internal_relocs;
484 for (; erel < erel_end; erel += relsz, irel++)
485 bfd_coff_swap_reloc_in (abfd, (PTR) erel, (PTR) irel);
487 if (free_external != NULL)
489 free (free_external);
490 free_external = NULL;
493 if (cache && free_internal != NULL)
495 if (coff_section_data (abfd, sec) == NULL)
497 amt = sizeof (struct coff_section_tdata);
498 sec->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
499 if (sec->used_by_bfd == NULL)
501 coff_section_data (abfd, sec)->contents = NULL;
503 coff_section_data (abfd, sec)->relocs = free_internal;
506 return internal_relocs;
509 if (free_external != NULL)
510 free (free_external);
511 if (free_internal != NULL)
512 free (free_internal);
516 /* Set lineno_count for the output sections of a COFF file. */
519 coff_count_linenumbers (abfd)
522 unsigned int limit = bfd_get_symcount (abfd);
530 /* This may be from the backend linker, in which case the
531 lineno_count in the sections is correct. */
532 for (s = abfd->sections; s != NULL; s = s->next)
533 total += s->lineno_count;
537 for (s = abfd->sections; s != NULL; s = s->next)
538 BFD_ASSERT (s->lineno_count == 0);
540 for (p = abfd->outsymbols, i = 0; i < limit; i++, p++)
542 asymbol *q_maybe = *p;
544 if (bfd_family_coff (bfd_asymbol_bfd (q_maybe)))
546 coff_symbol_type *q = coffsymbol (q_maybe);
548 /* The AIX 4.1 compiler can sometimes generate line numbers
549 attached to debugging symbols. We try to simply ignore
551 if (q->lineno != NULL
552 && q->symbol.section->owner != NULL)
554 /* This symbol has line numbers. Increment the owning
555 section's linenumber count. */
556 alent *l = q->lineno;
558 ++q->symbol.section->output_section->lineno_count;
561 while (l->line_number != 0)
564 ++q->symbol.section->output_section->lineno_count;
574 /* Takes a bfd and a symbol, returns a pointer to the coff specific
575 area of the symbol if there is one. */
578 coff_symbol_from (ignore_abfd, symbol)
579 bfd *ignore_abfd ATTRIBUTE_UNUSED;
582 if (!bfd_family_coff (bfd_asymbol_bfd (symbol)))
583 return (coff_symbol_type *) NULL;
585 if (bfd_asymbol_bfd (symbol)->tdata.coff_obj_data == (coff_data_type *) NULL)
586 return (coff_symbol_type *) NULL;
588 return (coff_symbol_type *) symbol;
592 fixup_symbol_value (abfd, coff_symbol_ptr, syment)
594 coff_symbol_type *coff_symbol_ptr;
595 struct internal_syment *syment;
598 /* Normalize the symbol flags */
599 if (bfd_is_com_section (coff_symbol_ptr->symbol.section))
601 /* a common symbol is undefined with a value */
602 syment->n_scnum = N_UNDEF;
603 syment->n_value = coff_symbol_ptr->symbol.value;
605 else if ((coff_symbol_ptr->symbol.flags & BSF_DEBUGGING) != 0
606 && (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING_RELOC) == 0)
608 syment->n_value = coff_symbol_ptr->symbol.value;
610 else if (bfd_is_und_section (coff_symbol_ptr->symbol.section))
612 syment->n_scnum = N_UNDEF;
615 /* FIXME: Do we need to handle the absolute section here? */
618 if (coff_symbol_ptr->symbol.section)
621 coff_symbol_ptr->symbol.section->output_section->target_index;
623 syment->n_value = (coff_symbol_ptr->symbol.value
624 + coff_symbol_ptr->symbol.section->output_offset);
627 syment->n_value += (syment->n_sclass == C_STATLAB)
628 ? coff_symbol_ptr->symbol.section->output_section->lma
629 : coff_symbol_ptr->symbol.section->output_section->vma;
635 /* This can happen, but I don't know why yet (steve@cygnus.com) */
636 syment->n_scnum = N_ABS;
637 syment->n_value = coff_symbol_ptr->symbol.value;
642 /* Run through all the symbols in the symbol table and work out what
643 their indexes into the symbol table will be when output.
645 Coff requires that each C_FILE symbol points to the next one in the
646 chain, and that the last one points to the first external symbol. We
650 coff_renumber_symbols (bfd_ptr, first_undef)
654 unsigned int symbol_count = bfd_get_symcount (bfd_ptr);
655 asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
656 unsigned int native_index = 0;
657 struct internal_syment *last_file = (struct internal_syment *) NULL;
658 unsigned int symbol_index;
660 /* COFF demands that undefined symbols come after all other symbols.
661 Since we don't need to impose this extra knowledge on all our
662 client programs, deal with that here. Sort the symbol table;
663 just move the undefined symbols to the end, leaving the rest
664 alone. The O'Reilly book says that defined global symbols come
665 at the end before the undefined symbols, so we do that here as
667 /* @@ Do we have some condition we could test for, so we don't always
668 have to do this? I don't think relocatability is quite right, but
669 I'm not certain. [raeburn:19920508.1711EST] */
675 amt = sizeof (asymbol *) * ((bfd_size_type) symbol_count + 1);
676 newsyms = (asymbol **) bfd_alloc (bfd_ptr, amt);
679 bfd_ptr->outsymbols = newsyms;
680 for (i = 0; i < symbol_count; i++)
681 if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) != 0
682 || (!bfd_is_und_section (symbol_ptr_ptr[i]->section)
683 && !bfd_is_com_section (symbol_ptr_ptr[i]->section)
684 && ((symbol_ptr_ptr[i]->flags & BSF_FUNCTION) != 0
685 || ((symbol_ptr_ptr[i]->flags & (BSF_GLOBAL | BSF_WEAK))
687 *newsyms++ = symbol_ptr_ptr[i];
689 for (i = 0; i < symbol_count; i++)
690 if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) == 0
691 && !bfd_is_und_section (symbol_ptr_ptr[i]->section)
692 && (bfd_is_com_section (symbol_ptr_ptr[i]->section)
693 || ((symbol_ptr_ptr[i]->flags & BSF_FUNCTION) == 0
694 && ((symbol_ptr_ptr[i]->flags & (BSF_GLOBAL | BSF_WEAK))
696 *newsyms++ = symbol_ptr_ptr[i];
698 *first_undef = newsyms - bfd_ptr->outsymbols;
700 for (i = 0; i < symbol_count; i++)
701 if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) == 0
702 && bfd_is_und_section (symbol_ptr_ptr[i]->section))
703 *newsyms++ = symbol_ptr_ptr[i];
704 *newsyms = (asymbol *) NULL;
705 symbol_ptr_ptr = bfd_ptr->outsymbols;
708 for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
710 coff_symbol_type *coff_symbol_ptr = coff_symbol_from (bfd_ptr, symbol_ptr_ptr[symbol_index]);
711 symbol_ptr_ptr[symbol_index]->udata.i = symbol_index;
712 if (coff_symbol_ptr && coff_symbol_ptr->native)
714 combined_entry_type *s = coff_symbol_ptr->native;
717 if (s->u.syment.n_sclass == C_FILE)
719 if (last_file != (struct internal_syment *) NULL)
720 last_file->n_value = native_index;
721 last_file = &(s->u.syment);
726 /* Modify the symbol values according to their section and
729 fixup_symbol_value (bfd_ptr, coff_symbol_ptr, &(s->u.syment));
731 for (i = 0; i < s->u.syment.n_numaux + 1; i++)
732 s[i].offset = native_index++;
739 obj_conv_table_size (bfd_ptr) = native_index;
744 /* Run thorough the symbol table again, and fix it so that all
745 pointers to entries are changed to the entries' index in the output
749 coff_mangle_symbols (bfd_ptr)
752 unsigned int symbol_count = bfd_get_symcount (bfd_ptr);
753 asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
754 unsigned int symbol_index;
756 for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
758 coff_symbol_type *coff_symbol_ptr =
759 coff_symbol_from (bfd_ptr, symbol_ptr_ptr[symbol_index]);
761 if (coff_symbol_ptr && coff_symbol_ptr->native)
764 combined_entry_type *s = coff_symbol_ptr->native;
768 /* FIXME: We should use a union here. */
769 s->u.syment.n_value =
770 (bfd_vma)((combined_entry_type *)
771 ((unsigned long) s->u.syment.n_value))->offset;
776 /* The value is the offset into the line number entries
777 for the symbol's section. On output, the symbol's
778 section should be N_DEBUG. */
779 s->u.syment.n_value =
780 (coff_symbol_ptr->symbol.section->output_section->line_filepos
781 + s->u.syment.n_value * bfd_coff_linesz (bfd_ptr));
782 coff_symbol_ptr->symbol.section =
783 coff_section_from_bfd_index (bfd_ptr, N_DEBUG);
784 BFD_ASSERT (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING);
786 for (i = 0; i < s->u.syment.n_numaux; i++)
788 combined_entry_type *a = s + i + 1;
791 a->u.auxent.x_sym.x_tagndx.l =
792 a->u.auxent.x_sym.x_tagndx.p->offset;
797 a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l =
798 a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p->offset;
803 a->u.auxent.x_csect.x_scnlen.l =
804 a->u.auxent.x_csect.x_scnlen.p->offset;
813 coff_fix_symbol_name (abfd, symbol, native, string_size_p,
814 debug_string_section_p, debug_string_size_p)
817 combined_entry_type *native;
818 bfd_size_type *string_size_p;
819 asection **debug_string_section_p;
820 bfd_size_type *debug_string_size_p;
822 unsigned int name_length;
823 union internal_auxent *auxent;
824 char *name = (char *) (symbol->name);
826 if (name == (char *) NULL)
828 /* coff symbols always have names, so we'll make one up */
829 symbol->name = "strange";
830 name = (char *) symbol->name;
832 name_length = strlen (name);
834 if (native->u.syment.n_sclass == C_FILE
835 && native->u.syment.n_numaux > 0)
837 unsigned int filnmlen;
839 if (bfd_coff_force_symnames_in_strings (abfd))
841 native->u.syment._n._n_n._n_offset =
842 (*string_size_p + STRING_SIZE_SIZE);
843 native->u.syment._n._n_n._n_zeroes = 0;
844 *string_size_p += 6; /* strlen(".file") + 1 */
847 strncpy (native->u.syment._n._n_name, ".file", SYMNMLEN);
849 auxent = &(native + 1)->u.auxent;
851 filnmlen = bfd_coff_filnmlen (abfd);
853 if (bfd_coff_long_filenames (abfd))
855 if (name_length <= filnmlen)
857 strncpy (auxent->x_file.x_fname, name, filnmlen);
861 auxent->x_file.x_n.x_offset = *string_size_p + STRING_SIZE_SIZE;
862 auxent->x_file.x_n.x_zeroes = 0;
863 *string_size_p += name_length + 1;
868 strncpy (auxent->x_file.x_fname, name, filnmlen);
869 if (name_length > filnmlen)
870 name[filnmlen] = '\0';
875 if (name_length <= SYMNMLEN && !bfd_coff_force_symnames_in_strings (abfd))
877 /* This name will fit into the symbol neatly */
878 strncpy (native->u.syment._n._n_name, symbol->name, SYMNMLEN);
880 else if (!bfd_coff_symname_in_debug (abfd, &native->u.syment))
882 native->u.syment._n._n_n._n_offset = (*string_size_p
884 native->u.syment._n._n_n._n_zeroes = 0;
885 *string_size_p += name_length + 1;
891 int prefix_len = bfd_coff_debug_string_prefix_length (abfd);
893 /* This name should be written into the .debug section. For
894 some reason each name is preceded by a two byte length
895 and also followed by a null byte. FIXME: We assume that
896 the .debug section has already been created, and that it
898 if (*debug_string_section_p == (asection *) NULL)
899 *debug_string_section_p = bfd_get_section_by_name (abfd, ".debug");
900 filepos = bfd_tell (abfd);
902 bfd_put_32 (abfd, (bfd_vma) (name_length + 1), buf);
904 bfd_put_16 (abfd, (bfd_vma) (name_length + 1), buf);
906 if (!bfd_set_section_contents (abfd,
907 *debug_string_section_p,
909 (file_ptr) *debug_string_size_p,
910 (bfd_size_type) prefix_len)
911 || !bfd_set_section_contents (abfd,
912 *debug_string_section_p,
914 (file_ptr) (*debug_string_size_p
916 (bfd_size_type) name_length + 1))
918 if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
920 native->u.syment._n._n_n._n_offset =
921 *debug_string_size_p + prefix_len;
922 native->u.syment._n._n_n._n_zeroes = 0;
923 *debug_string_size_p += name_length + 1 + prefix_len;
928 /* We need to keep track of the symbol index so that when we write out
929 the relocs we can get the index for a symbol. This method is a
932 #define set_index(symbol, idx) ((symbol)->udata.i = (idx))
934 /* Write a symbol out to a COFF file. */
937 coff_write_symbol (abfd, symbol, native, written, string_size_p,
938 debug_string_section_p, debug_string_size_p)
941 combined_entry_type *native;
943 bfd_size_type *string_size_p;
944 asection **debug_string_section_p;
945 bfd_size_type *debug_string_size_p;
947 unsigned int numaux = native->u.syment.n_numaux;
948 int type = native->u.syment.n_type;
949 int class = native->u.syment.n_sclass;
951 bfd_size_type symesz;
953 if (native->u.syment.n_sclass == C_FILE)
954 symbol->flags |= BSF_DEBUGGING;
956 if (symbol->flags & BSF_DEBUGGING
957 && bfd_is_abs_section (symbol->section))
959 native->u.syment.n_scnum = N_DEBUG;
961 else if (bfd_is_abs_section (symbol->section))
963 native->u.syment.n_scnum = N_ABS;
965 else if (bfd_is_und_section (symbol->section))
967 native->u.syment.n_scnum = N_UNDEF;
971 native->u.syment.n_scnum =
972 symbol->section->output_section->target_index;
975 coff_fix_symbol_name (abfd, symbol, native, string_size_p,
976 debug_string_section_p, debug_string_size_p);
978 symesz = bfd_coff_symesz (abfd);
979 buf = bfd_alloc (abfd, symesz);
982 bfd_coff_swap_sym_out (abfd, &native->u.syment, buf);
983 if (bfd_bwrite (buf, symesz, abfd) != symesz)
985 bfd_release (abfd, buf);
987 if (native->u.syment.n_numaux > 0)
989 bfd_size_type auxesz;
992 auxesz = bfd_coff_auxesz (abfd);
993 buf = bfd_alloc (abfd, auxesz);
996 for (j = 0; j < native->u.syment.n_numaux; j++)
998 bfd_coff_swap_aux_out (abfd,
999 &((native + j + 1)->u.auxent),
1003 native->u.syment.n_numaux,
1005 if (bfd_bwrite (buf, auxesz, abfd) != auxesz)
1008 bfd_release (abfd, buf);
1011 /* Store the index for use when we write out the relocs. */
1012 set_index (symbol, *written);
1014 *written += numaux + 1;
1018 /* Write out a symbol to a COFF file that does not come from a COFF
1019 file originally. This symbol may have been created by the linker,
1020 or we may be linking a non COFF file to a COFF file. */
1023 coff_write_alien_symbol (abfd, symbol, written, string_size_p,
1024 debug_string_section_p, debug_string_size_p)
1028 bfd_size_type *string_size_p;
1029 asection **debug_string_section_p;
1030 bfd_size_type *debug_string_size_p;
1032 combined_entry_type *native;
1033 combined_entry_type dummy;
1036 native->u.syment.n_type = T_NULL;
1037 native->u.syment.n_flags = 0;
1038 if (bfd_is_und_section (symbol->section))
1040 native->u.syment.n_scnum = N_UNDEF;
1041 native->u.syment.n_value = symbol->value;
1043 else if (bfd_is_com_section (symbol->section))
1045 native->u.syment.n_scnum = N_UNDEF;
1046 native->u.syment.n_value = symbol->value;
1048 else if (symbol->flags & BSF_DEBUGGING)
1050 /* There isn't much point to writing out a debugging symbol
1051 unless we are prepared to convert it into COFF debugging
1052 format. So, we just ignore them. We must clobber the symbol
1053 name to keep it from being put in the string table. */
1059 native->u.syment.n_scnum =
1060 symbol->section->output_section->target_index;
1061 native->u.syment.n_value = (symbol->value
1062 + symbol->section->output_offset);
1063 if (! obj_pe (abfd))
1064 native->u.syment.n_value += symbol->section->output_section->vma;
1066 /* Copy the any flags from the file header into the symbol.
1069 coff_symbol_type *c = coff_symbol_from (abfd, symbol);
1070 if (c != (coff_symbol_type *) NULL)
1071 native->u.syment.n_flags = bfd_asymbol_bfd (&c->symbol)->flags;
1075 native->u.syment.n_type = 0;
1076 if (symbol->flags & BSF_LOCAL)
1077 native->u.syment.n_sclass = C_STAT;
1078 else if (symbol->flags & BSF_WEAK)
1079 native->u.syment.n_sclass = obj_pe (abfd) ? C_NT_WEAK : C_WEAKEXT;
1081 native->u.syment.n_sclass = C_EXT;
1082 native->u.syment.n_numaux = 0;
1084 return coff_write_symbol (abfd, symbol, native, written, string_size_p,
1085 debug_string_section_p, debug_string_size_p);
1088 /* Write a native symbol to a COFF file. */
1091 coff_write_native_symbol (abfd, symbol, written, string_size_p,
1092 debug_string_section_p, debug_string_size_p)
1094 coff_symbol_type *symbol;
1096 bfd_size_type *string_size_p;
1097 asection **debug_string_section_p;
1098 bfd_size_type *debug_string_size_p;
1100 combined_entry_type *native = symbol->native;
1101 alent *lineno = symbol->lineno;
1103 /* If this symbol has an associated line number, we must store the
1104 symbol index in the line number field. We also tag the auxent to
1105 point to the right place in the lineno table. */
1106 if (lineno && !symbol->done_lineno && symbol->symbol.section->owner != NULL)
1108 unsigned int count = 0;
1109 lineno[count].u.offset = *written;
1110 if (native->u.syment.n_numaux)
1112 union internal_auxent *a = &((native + 1)->u.auxent);
1114 a->x_sym.x_fcnary.x_fcn.x_lnnoptr =
1115 symbol->symbol.section->output_section->moving_line_filepos;
1118 /* Count and relocate all other linenumbers. */
1120 while (lineno[count].line_number != 0)
1124 I've been told this, but still need proof:
1125 > The second bug is also in `bfd/coffcode.h'. This bug
1126 > causes the linker to screw up the pc-relocations for
1127 > all the line numbers in COFF code. This bug isn't only
1128 > specific to A29K implementations, but affects all
1129 > systems using COFF format binaries. Note that in COFF
1130 > object files, the line number core offsets output by
1131 > the assembler are relative to the start of each
1132 > procedure, not to the start of the .text section. This
1133 > patch relocates the line numbers relative to the
1134 > `native->u.syment.n_value' instead of the section
1136 > modular!olson@cs.arizona.edu (Jon Olson)
1138 lineno[count].u.offset += native->u.syment.n_value;
1140 lineno[count].u.offset +=
1141 (symbol->symbol.section->output_section->vma
1142 + symbol->symbol.section->output_offset);
1146 symbol->done_lineno = true;
1148 symbol->symbol.section->output_section->moving_line_filepos +=
1149 count * bfd_coff_linesz (abfd);
1152 return coff_write_symbol (abfd, &(symbol->symbol), native, written,
1153 string_size_p, debug_string_section_p,
1154 debug_string_size_p);
1157 /* Write out the COFF symbols. */
1160 coff_write_symbols (abfd)
1163 bfd_size_type string_size;
1164 asection *debug_string_section;
1165 bfd_size_type debug_string_size;
1167 unsigned int limit = bfd_get_symcount (abfd);
1168 bfd_signed_vma written = 0;
1172 debug_string_section = NULL;
1173 debug_string_size = 0;
1175 /* If this target supports long section names, they must be put into
1176 the string table. This is supported by PE. This code must
1177 handle section names just as they are handled in
1178 coff_write_object_contents. */
1179 if (bfd_coff_long_section_names (abfd))
1183 for (o = abfd->sections; o != NULL; o = o->next)
1187 len = strlen (o->name);
1189 string_size += len + 1;
1193 /* Seek to the right place */
1194 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0)
1197 /* Output all the symbols we have */
1200 for (p = abfd->outsymbols, i = 0; i < limit; i++, p++)
1202 asymbol *symbol = *p;
1203 coff_symbol_type *c_symbol = coff_symbol_from (abfd, symbol);
1205 if (c_symbol == (coff_symbol_type *) NULL
1206 || c_symbol->native == (combined_entry_type *) NULL)
1208 if (!coff_write_alien_symbol (abfd, symbol, &written, &string_size,
1209 &debug_string_section,
1210 &debug_string_size))
1215 if (!coff_write_native_symbol (abfd, c_symbol, &written,
1216 &string_size, &debug_string_section,
1217 &debug_string_size))
1222 obj_raw_syment_count (abfd) = written;
1224 /* Now write out strings */
1226 if (string_size != 0)
1228 unsigned int size = string_size + STRING_SIZE_SIZE;
1229 bfd_byte buffer[STRING_SIZE_SIZE];
1231 #if STRING_SIZE_SIZE == 4
1232 H_PUT_32 (abfd, size, buffer);
1234 #error Change H_PUT_32
1236 if (bfd_bwrite ((PTR) buffer, (bfd_size_type) sizeof (buffer), abfd)
1240 /* Handle long section names. This code must handle section
1241 names just as they are handled in coff_write_object_contents. */
1242 if (bfd_coff_long_section_names (abfd))
1246 for (o = abfd->sections; o != NULL; o = o->next)
1250 len = strlen (o->name);
1253 if (bfd_bwrite (o->name, (bfd_size_type) (len + 1), abfd)
1260 for (p = abfd->outsymbols, i = 0;
1265 size_t name_length = strlen (q->name);
1266 coff_symbol_type *c_symbol = coff_symbol_from (abfd, q);
1269 /* Figure out whether the symbol name should go in the string
1270 table. Symbol names that are short enough are stored
1271 directly in the syment structure. File names permit a
1272 different, longer, length in the syment structure. On
1273 XCOFF, some symbol names are stored in the .debug section
1274 rather than in the string table. */
1276 if (c_symbol == NULL
1277 || c_symbol->native == NULL)
1279 /* This is not a COFF symbol, so it certainly is not a
1280 file name, nor does it go in the .debug section. */
1281 maxlen = bfd_coff_force_symnames_in_strings (abfd) ? 0 : SYMNMLEN;
1283 else if (bfd_coff_symname_in_debug (abfd,
1284 &c_symbol->native->u.syment))
1286 /* This symbol name is in the XCOFF .debug section.
1287 Don't write it into the string table. */
1288 maxlen = name_length;
1290 else if (c_symbol->native->u.syment.n_sclass == C_FILE
1291 && c_symbol->native->u.syment.n_numaux > 0)
1293 if (bfd_coff_force_symnames_in_strings (abfd))
1295 if (bfd_bwrite (".file", (bfd_size_type) 6, abfd) != 6)
1298 maxlen = bfd_coff_filnmlen (abfd);
1301 maxlen = bfd_coff_force_symnames_in_strings (abfd) ? 0 : SYMNMLEN;
1303 if (name_length > maxlen)
1305 if (bfd_bwrite ((PTR) (q->name), (bfd_size_type) name_length + 1,
1306 abfd) != name_length + 1)
1313 /* We would normally not write anything here, but we'll write
1314 out 4 so that any stupid coff reader which tries to read the
1315 string table even when there isn't one won't croak. */
1316 unsigned int size = STRING_SIZE_SIZE;
1317 bfd_byte buffer[STRING_SIZE_SIZE];
1319 #if STRING_SIZE_SIZE == 4
1320 H_PUT_32 (abfd, size, buffer);
1322 #error Change H_PUT_32
1324 if (bfd_bwrite ((PTR) buffer, (bfd_size_type) STRING_SIZE_SIZE, abfd)
1325 != STRING_SIZE_SIZE)
1329 /* Make sure the .debug section was created to be the correct size.
1330 We should create it ourselves on the fly, but we don't because
1331 BFD won't let us write to any section until we know how large all
1332 the sections are. We could still do it by making another pass
1333 over the symbols. FIXME. */
1334 BFD_ASSERT (debug_string_size == 0
1335 || (debug_string_section != (asection *) NULL
1336 && (BFD_ALIGN (debug_string_size,
1337 1 << debug_string_section->alignment_power)
1338 == bfd_section_size (abfd, debug_string_section))));
1344 coff_write_linenumbers (abfd)
1348 bfd_size_type linesz;
1351 linesz = bfd_coff_linesz (abfd);
1352 buff = bfd_alloc (abfd, linesz);
1355 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
1357 if (s->lineno_count)
1359 asymbol **q = abfd->outsymbols;
1360 if (bfd_seek (abfd, s->line_filepos, SEEK_SET) != 0)
1362 /* Find all the linenumbers in this section */
1366 if (p->section->output_section == s)
1369 BFD_SEND (bfd_asymbol_bfd (p), _get_lineno,
1370 (bfd_asymbol_bfd (p), p));
1373 /* Found a linenumber entry, output */
1374 struct internal_lineno out;
1375 memset ((PTR) & out, 0, sizeof (out));
1377 out.l_addr.l_symndx = l->u.offset;
1378 bfd_coff_swap_lineno_out (abfd, &out, buff);
1379 if (bfd_bwrite (buff, (bfd_size_type) linesz, abfd)
1383 while (l->line_number)
1385 out.l_lnno = l->line_number;
1386 out.l_addr.l_symndx = l->u.offset;
1387 bfd_coff_swap_lineno_out (abfd, &out, buff);
1388 if (bfd_bwrite (buff, (bfd_size_type) linesz, abfd)
1399 bfd_release (abfd, buff);
1404 coff_get_lineno (ignore_abfd, symbol)
1405 bfd *ignore_abfd ATTRIBUTE_UNUSED;
1408 return coffsymbol (symbol)->lineno;
1413 /* This is only called from coff_add_missing_symbols, which has been
1417 coff_section_symbol (abfd, name)
1421 asection *sec = bfd_make_section_old_way (abfd, name);
1423 combined_entry_type *csym;
1426 csym = coff_symbol_from (abfd, sym)->native;
1427 /* Make sure back-end COFF stuff is there. */
1432 coff_symbol_type sym;
1433 /* @@FIXME This shouldn't use a fixed size!! */
1434 combined_entry_type e[10];
1437 f = (struct foo *) bfd_alloc (abfd, (bfd_size_type) sizeof (*f));
1440 bfd_set_error (bfd_error_no_error);
1443 memset ((char *) f, 0, sizeof (*f));
1444 coff_symbol_from (abfd, sym)->native = csym = f->e;
1446 csym[0].u.syment.n_sclass = C_STAT;
1447 csym[0].u.syment.n_numaux = 1;
1448 /* SF_SET_STATICS (sym); @@ ??? */
1449 csym[1].u.auxent.x_scn.x_scnlen = sec->_raw_size;
1450 csym[1].u.auxent.x_scn.x_nreloc = sec->reloc_count;
1451 csym[1].u.auxent.x_scn.x_nlinno = sec->lineno_count;
1453 if (sec->output_section == NULL)
1455 sec->output_section = sec;
1456 sec->output_offset = 0;
1464 /* This function transforms the offsets into the symbol table into
1465 pointers to syments. */
1468 coff_pointerize_aux (abfd, table_base, symbol, indaux, auxent)
1470 combined_entry_type *table_base;
1471 combined_entry_type *symbol;
1472 unsigned int indaux;
1473 combined_entry_type *auxent;
1475 unsigned int type = symbol->u.syment.n_type;
1476 unsigned int class = symbol->u.syment.n_sclass;
1478 if (coff_backend_info (abfd)->_bfd_coff_pointerize_aux_hook)
1480 if ((*coff_backend_info (abfd)->_bfd_coff_pointerize_aux_hook)
1481 (abfd, table_base, symbol, indaux, auxent))
1485 /* Don't bother if this is a file or a section */
1486 if (class == C_STAT && type == T_NULL)
1488 if (class == C_FILE)
1491 /* Otherwise patch up */
1492 #define N_TMASK coff_data (abfd)->local_n_tmask
1493 #define N_BTSHFT coff_data (abfd)->local_n_btshft
1494 if ((ISFCN (type) || ISTAG (class) || class == C_BLOCK || class == C_FCN)
1495 && auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l > 0)
1497 auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p =
1498 table_base + auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l;
1499 auxent->fix_end = 1;
1501 /* A negative tagndx is meaningless, but the SCO 3.2v4 cc can
1502 generate one, so we must be careful to ignore it. */
1503 if (auxent->u.auxent.x_sym.x_tagndx.l > 0)
1505 auxent->u.auxent.x_sym.x_tagndx.p =
1506 table_base + auxent->u.auxent.x_sym.x_tagndx.l;
1507 auxent->fix_tag = 1;
1511 /* Allocate space for the ".debug" section, and read it.
1512 We did not read the debug section until now, because
1513 we didn't want to go to the trouble until someone needed it. */
1516 build_debug_section (abfd)
1519 char *debug_section;
1521 bfd_size_type sec_size;
1523 asection *sect = bfd_get_section_by_name (abfd, ".debug");
1527 bfd_set_error (bfd_error_no_debug_section);
1531 sec_size = bfd_get_section_size_before_reloc (sect);
1532 debug_section = (PTR) bfd_alloc (abfd, sec_size);
1533 if (debug_section == NULL)
1536 /* Seek to the beginning of the `.debug' section and read it.
1537 Save the current position first; it is needed by our caller.
1538 Then read debug section and reset the file pointer. */
1540 position = bfd_tell (abfd);
1541 if (bfd_seek (abfd, sect->filepos, SEEK_SET) != 0
1542 || bfd_bread (debug_section, sec_size, abfd) != sec_size
1543 || bfd_seek (abfd, position, SEEK_SET) != 0)
1545 return debug_section;
1548 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
1549 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
1550 be \0-terminated. */
1552 copy_name (abfd, name, maxlen)
1560 for (len = 0; len < maxlen; ++len)
1562 if (name[len] == '\0')
1568 if ((newname = (PTR) bfd_alloc (abfd, (bfd_size_type) len + 1)) == NULL)
1570 strncpy (newname, name, len);
1571 newname[len] = '\0';
1575 /* Read in the external symbols. */
1578 _bfd_coff_get_external_symbols (abfd)
1581 bfd_size_type symesz;
1585 if (obj_coff_external_syms (abfd) != NULL)
1588 symesz = bfd_coff_symesz (abfd);
1590 size = obj_raw_syment_count (abfd) * symesz;
1592 syms = (PTR) bfd_malloc (size);
1593 if (syms == NULL && size != 0)
1596 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
1597 || bfd_bread (syms, size, abfd) != size)
1604 obj_coff_external_syms (abfd) = syms;
1609 /* Read in the external strings. The strings are not loaded until
1610 they are needed. This is because we have no simple way of
1611 detecting a missing string table in an archive. */
1614 _bfd_coff_read_string_table (abfd)
1617 char extstrsize[STRING_SIZE_SIZE];
1618 bfd_size_type strsize;
1622 if (obj_coff_strings (abfd) != NULL)
1623 return obj_coff_strings (abfd);
1625 if (obj_sym_filepos (abfd) == 0)
1627 bfd_set_error (bfd_error_no_symbols);
1631 pos = obj_sym_filepos (abfd);
1632 pos += obj_raw_syment_count (abfd) * bfd_coff_symesz (abfd);
1633 if (bfd_seek (abfd, pos, SEEK_SET) != 0)
1636 if (bfd_bread (extstrsize, (bfd_size_type) sizeof extstrsize, abfd)
1637 != sizeof extstrsize)
1639 if (bfd_get_error () != bfd_error_file_truncated)
1642 /* There is no string table. */
1643 strsize = STRING_SIZE_SIZE;
1647 #if STRING_SIZE_SIZE == 4
1648 strsize = H_GET_32 (abfd, extstrsize);
1650 #error Change H_GET_32
1654 if (strsize < STRING_SIZE_SIZE)
1656 (*_bfd_error_handler)
1657 (_("%s: bad string table size %lu"), bfd_archive_filename (abfd),
1658 (unsigned long) strsize);
1659 bfd_set_error (bfd_error_bad_value);
1663 strings = (char *) bfd_malloc (strsize);
1664 if (strings == NULL)
1667 if (bfd_bread (strings + STRING_SIZE_SIZE, strsize - STRING_SIZE_SIZE, abfd)
1668 != strsize - STRING_SIZE_SIZE)
1674 obj_coff_strings (abfd) = strings;
1679 /* Free up the external symbols and strings read from a COFF file. */
1682 _bfd_coff_free_symbols (abfd)
1685 if (obj_coff_external_syms (abfd) != NULL
1686 && ! obj_coff_keep_syms (abfd))
1688 free (obj_coff_external_syms (abfd));
1689 obj_coff_external_syms (abfd) = NULL;
1691 if (obj_coff_strings (abfd) != NULL
1692 && ! obj_coff_keep_strings (abfd))
1694 free (obj_coff_strings (abfd));
1695 obj_coff_strings (abfd) = NULL;
1700 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
1701 knit the symbol names into a normalized form. By normalized here I
1702 mean that all symbols have an n_offset pointer that points to a null-
1703 terminated string. */
1705 combined_entry_type *
1706 coff_get_normalized_symtab (abfd)
1709 combined_entry_type *internal;
1710 combined_entry_type *internal_ptr;
1711 combined_entry_type *symbol_ptr;
1712 combined_entry_type *internal_end;
1716 const char *string_table = NULL;
1717 char *debug_section = NULL;
1720 if (obj_raw_syments (abfd) != NULL)
1721 return obj_raw_syments (abfd);
1723 size = obj_raw_syment_count (abfd) * sizeof (combined_entry_type);
1724 internal = (combined_entry_type *) bfd_zalloc (abfd, size);
1725 if (internal == NULL && size != 0)
1727 internal_end = internal + obj_raw_syment_count (abfd);
1729 if (! _bfd_coff_get_external_symbols (abfd))
1732 raw_src = (char *) obj_coff_external_syms (abfd);
1734 /* mark the end of the symbols */
1735 symesz = bfd_coff_symesz (abfd);
1736 raw_end = (char *) raw_src + obj_raw_syment_count (abfd) * symesz;
1738 /* FIXME SOMEDAY. A string table size of zero is very weird, but
1739 probably possible. If one shows up, it will probably kill us. */
1741 /* Swap all the raw entries */
1742 for (internal_ptr = internal;
1744 raw_src += symesz, internal_ptr++)
1748 bfd_coff_swap_sym_in (abfd, (PTR) raw_src,
1749 (PTR) & internal_ptr->u.syment);
1750 symbol_ptr = internal_ptr;
1753 i < symbol_ptr->u.syment.n_numaux;
1758 bfd_coff_swap_aux_in (abfd, (PTR) raw_src,
1759 symbol_ptr->u.syment.n_type,
1760 symbol_ptr->u.syment.n_sclass,
1761 (int) i, symbol_ptr->u.syment.n_numaux,
1762 &(internal_ptr->u.auxent));
1763 coff_pointerize_aux (abfd, internal, symbol_ptr, i,
1768 /* Free the raw symbols, but not the strings (if we have them). */
1769 obj_coff_keep_strings (abfd) = true;
1770 if (! _bfd_coff_free_symbols (abfd))
1773 for (internal_ptr = internal; internal_ptr < internal_end;
1776 if (internal_ptr->u.syment.n_sclass == C_FILE
1777 && internal_ptr->u.syment.n_numaux > 0)
1779 /* make a file symbol point to the name in the auxent, since
1780 the text ".file" is redundant */
1781 if ((internal_ptr + 1)->u.auxent.x_file.x_n.x_zeroes == 0)
1783 /* the filename is a long one, point into the string table */
1784 if (string_table == NULL)
1786 string_table = _bfd_coff_read_string_table (abfd);
1787 if (string_table == NULL)
1791 internal_ptr->u.syment._n._n_n._n_offset =
1794 + (internal_ptr + 1)->u.auxent.x_file.x_n.x_offset));
1798 /* Ordinary short filename, put into memory anyway. The
1799 Microsoft PE tools sometimes store a filename in
1800 multiple AUX entries. */
1801 if (internal_ptr->u.syment.n_numaux > 1
1802 && coff_data (abfd)->pe)
1804 internal_ptr->u.syment._n._n_n._n_offset =
1807 (internal_ptr + 1)->u.auxent.x_file.x_fname,
1808 internal_ptr->u.syment.n_numaux * symesz));
1812 internal_ptr->u.syment._n._n_n._n_offset =
1815 (internal_ptr + 1)->u.auxent.x_file.x_fname,
1816 (size_t) bfd_coff_filnmlen (abfd)));
1822 if (internal_ptr->u.syment._n._n_n._n_zeroes != 0)
1824 /* This is a "short" name. Make it long. */
1828 /* find the length of this string without walking into memory
1830 for (i = 0; i < 8; ++i)
1831 if (internal_ptr->u.syment._n._n_name[i] == '\0')
1834 newstring = (PTR) bfd_alloc (abfd, (bfd_size_type) (i + 1));
1835 if (newstring == NULL)
1837 memset (newstring, 0, i + 1);
1838 strncpy (newstring, internal_ptr->u.syment._n._n_name, i);
1839 internal_ptr->u.syment._n._n_n._n_offset = (long int) newstring;
1840 internal_ptr->u.syment._n._n_n._n_zeroes = 0;
1842 else if (internal_ptr->u.syment._n._n_n._n_offset == 0)
1843 internal_ptr->u.syment._n._n_n._n_offset = (long int) "";
1844 else if (!bfd_coff_symname_in_debug (abfd, &internal_ptr->u.syment))
1846 /* Long name already. Point symbol at the string in the
1848 if (string_table == NULL)
1850 string_table = _bfd_coff_read_string_table (abfd);
1851 if (string_table == NULL)
1854 internal_ptr->u.syment._n._n_n._n_offset =
1857 + internal_ptr->u.syment._n._n_n._n_offset));
1861 /* Long name in debug section. Very similar. */
1862 if (debug_section == NULL)
1863 debug_section = build_debug_section (abfd);
1864 internal_ptr->u.syment._n._n_n._n_offset = (long int)
1865 (debug_section + internal_ptr->u.syment._n._n_n._n_offset);
1868 internal_ptr += internal_ptr->u.syment.n_numaux;
1871 obj_raw_syments (abfd) = internal;
1872 BFD_ASSERT (obj_raw_syment_count (abfd)
1873 == (unsigned int) (internal_ptr - internal));
1876 } /* coff_get_normalized_symtab() */
1879 coff_get_reloc_upper_bound (abfd, asect)
1883 if (bfd_get_format (abfd) != bfd_object)
1885 bfd_set_error (bfd_error_invalid_operation);
1888 return (asect->reloc_count + 1) * sizeof (arelent *);
1892 coff_make_empty_symbol (abfd)
1895 bfd_size_type amt = sizeof (coff_symbol_type);
1896 coff_symbol_type *new = (coff_symbol_type *) bfd_alloc (abfd, amt);
1899 memset (new, 0, sizeof *new);
1900 new->symbol.section = 0;
1902 new->lineno = (alent *) NULL;
1903 new->done_lineno = false;
1904 new->symbol.the_bfd = abfd;
1905 return &new->symbol;
1908 /* Make a debugging symbol. */
1911 coff_bfd_make_debug_symbol (abfd, ptr, sz)
1913 PTR ptr ATTRIBUTE_UNUSED;
1914 unsigned long sz ATTRIBUTE_UNUSED;
1916 bfd_size_type amt = sizeof (coff_symbol_type);
1917 coff_symbol_type *new = (coff_symbol_type *) bfd_alloc (abfd, amt);
1920 /* @@ The 10 is a guess at a plausible maximum number of aux entries
1921 (but shouldn't be a constant). */
1922 amt = sizeof (combined_entry_type) * 10;
1923 new->native = (combined_entry_type *) bfd_zalloc (abfd, amt);
1926 new->symbol.section = bfd_abs_section_ptr;
1927 new->symbol.flags = BSF_DEBUGGING;
1928 new->lineno = (alent *) NULL;
1929 new->done_lineno = false;
1930 new->symbol.the_bfd = abfd;
1931 return &new->symbol;
1935 coff_get_symbol_info (abfd, symbol, ret)
1940 bfd_symbol_info (symbol, ret);
1941 if (coffsymbol (symbol)->native != NULL
1942 && coffsymbol (symbol)->native->fix_value)
1944 ret->value = coffsymbol (symbol)->native->u.syment.n_value -
1945 (unsigned long) obj_raw_syments (abfd);
1949 /* Return the COFF syment for a symbol. */
1952 bfd_coff_get_syment (abfd, symbol, psyment)
1955 struct internal_syment *psyment;
1957 coff_symbol_type *csym;
1959 csym = coff_symbol_from (abfd, symbol);
1960 if (csym == NULL || csym->native == NULL)
1962 bfd_set_error (bfd_error_invalid_operation);
1966 *psyment = csym->native->u.syment;
1968 if (csym->native->fix_value)
1969 psyment->n_value = psyment->n_value -
1970 (unsigned long) obj_raw_syments (abfd);
1972 /* FIXME: We should handle fix_line here. */
1977 /* Return the COFF auxent for a symbol. */
1980 bfd_coff_get_auxent (abfd, symbol, indx, pauxent)
1984 union internal_auxent *pauxent;
1986 coff_symbol_type *csym;
1987 combined_entry_type *ent;
1989 csym = coff_symbol_from (abfd, symbol);
1992 || csym->native == NULL
1993 || indx >= csym->native->u.syment.n_numaux)
1995 bfd_set_error (bfd_error_invalid_operation);
1999 ent = csym->native + indx + 1;
2001 *pauxent = ent->u.auxent;
2004 pauxent->x_sym.x_tagndx.l =
2005 ((combined_entry_type *) pauxent->x_sym.x_tagndx.p
2006 - obj_raw_syments (abfd));
2009 pauxent->x_sym.x_fcnary.x_fcn.x_endndx.l =
2010 ((combined_entry_type *) pauxent->x_sym.x_fcnary.x_fcn.x_endndx.p
2011 - obj_raw_syments (abfd));
2013 if (ent->fix_scnlen)
2014 pauxent->x_csect.x_scnlen.l =
2015 ((combined_entry_type *) pauxent->x_csect.x_scnlen.p
2016 - obj_raw_syments (abfd));
2021 /* Print out information about COFF symbol. */
2024 coff_print_symbol (abfd, filep, symbol, how)
2028 bfd_print_symbol_type how;
2030 FILE *file = (FILE *) filep;
2034 case bfd_print_symbol_name:
2035 fprintf (file, "%s", symbol->name);
2038 case bfd_print_symbol_more:
2039 fprintf (file, "coff %s %s",
2040 coffsymbol (symbol)->native ? "n" : "g",
2041 coffsymbol (symbol)->lineno ? "l" : " ");
2044 case bfd_print_symbol_all:
2045 if (coffsymbol (symbol)->native)
2049 combined_entry_type *combined = coffsymbol (symbol)->native;
2050 combined_entry_type *root = obj_raw_syments (abfd);
2051 struct lineno_cache_entry *l = coffsymbol (symbol)->lineno;
2053 fprintf (file, "[%3ld]", (long) (combined - root));
2055 if (! combined->fix_value)
2056 val = (bfd_vma) combined->u.syment.n_value;
2058 val = combined->u.syment.n_value - (unsigned long) root;
2062 "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x%08lx %s",
2063 combined->u.syment.n_scnum,
2064 combined->u.syment.n_flags,
2065 combined->u.syment.n_type,
2066 combined->u.syment.n_sclass,
2067 combined->u.syment.n_numaux,
2068 (unsigned long) val,
2071 /* Print out the wide, 64 bit, symbol value */
2073 "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x%016llx %s",
2074 combined->u.syment.n_scnum,
2075 combined->u.syment.n_flags,
2076 combined->u.syment.n_type,
2077 combined->u.syment.n_sclass,
2078 combined->u.syment.n_numaux,
2083 for (aux = 0; aux < combined->u.syment.n_numaux; aux++)
2085 combined_entry_type *auxp = combined + aux + 1;
2089 tagndx = auxp->u.auxent.x_sym.x_tagndx.p - root;
2091 tagndx = auxp->u.auxent.x_sym.x_tagndx.l;
2093 fprintf (file, "\n");
2095 if (bfd_coff_print_aux (abfd, file, root, combined, auxp, aux))
2098 switch (combined->u.syment.n_sclass)
2101 fprintf (file, "File ");
2105 if (combined->u.syment.n_type == T_NULL)
2106 /* probably a section symbol? */
2108 fprintf (file, "AUX scnlen 0x%lx nreloc %d nlnno %d",
2109 (long) auxp->u.auxent.x_scn.x_scnlen,
2110 auxp->u.auxent.x_scn.x_nreloc,
2111 auxp->u.auxent.x_scn.x_nlinno);
2112 if (auxp->u.auxent.x_scn.x_checksum != 0
2113 || auxp->u.auxent.x_scn.x_associated != 0
2114 || auxp->u.auxent.x_scn.x_comdat != 0)
2115 fprintf (file, " checksum 0x%lx assoc %d comdat %d",
2116 auxp->u.auxent.x_scn.x_checksum,
2117 auxp->u.auxent.x_scn.x_associated,
2118 auxp->u.auxent.x_scn.x_comdat);
2121 /* else fall through */
2123 if (ISFCN (combined->u.syment.n_type))
2128 next = (auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p
2131 next = auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l;
2132 llnos = auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_lnnoptr;
2134 _("AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld"),
2135 tagndx, auxp->u.auxent.x_sym.x_misc.x_fsize,
2139 /* else fall through */
2141 fprintf (file, "AUX lnno %d size 0x%x tagndx %ld",
2142 auxp->u.auxent.x_sym.x_misc.x_lnsz.x_lnno,
2143 auxp->u.auxent.x_sym.x_misc.x_lnsz.x_size,
2146 fprintf (file, " endndx %ld",
2148 (auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p
2156 fprintf (file, "\n%s :", l->u.sym->name);
2158 while (l->line_number)
2160 fprintf (file, "\n%4d : 0x%lx",
2163 (l->u.offset + symbol->section->vma)));
2170 bfd_print_symbol_vandf (abfd, (PTR) file, symbol);
2171 fprintf (file, " %-5s %s %s %s",
2172 symbol->section->name,
2173 coffsymbol (symbol)->native ? "n" : "g",
2174 coffsymbol (symbol)->lineno ? "l" : " ",
2180 /* Return whether a symbol name implies a local symbol. In COFF,
2181 local symbols generally start with ``.L''. Most targets use this
2182 function for the is_local_label_name entry point, but some may
2186 _bfd_coff_is_local_label_name (abfd, name)
2187 bfd *abfd ATTRIBUTE_UNUSED;
2190 return name[0] == '.' && name[1] == 'L';
2193 /* Provided a BFD, a section and an offset (in bytes, not octets) into the
2194 section, calculate and return the name of the source file and the line
2195 nearest to the wanted location. */
2198 coff_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
2199 functionname_ptr, line_ptr)
2204 const char **filename_ptr;
2205 const char **functionname_ptr;
2206 unsigned int *line_ptr;
2210 unsigned int line_base;
2211 coff_data_type *cof = coff_data (abfd);
2212 /* Run through the raw syments if available */
2213 combined_entry_type *p;
2214 combined_entry_type *pend;
2216 struct coff_section_tdata *sec_data;
2219 /* Before looking through the symbol table, try to use a .stab
2220 section to find the information. */
2221 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
2222 &found, filename_ptr,
2223 functionname_ptr, line_ptr,
2224 &coff_data(abfd)->line_info))
2230 /* Also try examining DWARF2 debugging information. */
2231 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
2232 filename_ptr, functionname_ptr,
2234 &coff_data(abfd)->dwarf2_find_line_info))
2238 *functionname_ptr = 0;
2241 /* Don't try and find line numbers in a non coff file */
2242 if (!bfd_family_coff (abfd))
2248 /* Find the first C_FILE symbol. */
2249 p = cof->raw_syments;
2253 pend = p + cof->raw_syment_count;
2256 if (p->u.syment.n_sclass == C_FILE)
2258 p += 1 + p->u.syment.n_numaux;
2266 /* Look through the C_FILE symbols to find the best one. */
2267 sec_vma = bfd_get_section_vma (abfd, section);
2268 *filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
2269 maxdiff = (bfd_vma) 0 - (bfd_vma) 1;
2272 combined_entry_type *p2;
2274 for (p2 = p + 1 + p->u.syment.n_numaux;
2276 p2 += 1 + p2->u.syment.n_numaux)
2278 if (p2->u.syment.n_scnum > 0
2280 == coff_section_from_bfd_index (abfd,
2281 p2->u.syment.n_scnum)))
2283 if (p2->u.syment.n_sclass == C_FILE)
2290 /* We use <= MAXDIFF here so that if we get a zero length
2291 file, we actually use the next file entry. */
2293 && offset + sec_vma >= (bfd_vma) p2->u.syment.n_value
2294 && offset + sec_vma - (bfd_vma) p2->u.syment.n_value <= maxdiff)
2296 *filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
2297 maxdiff = offset + sec_vma - p2->u.syment.n_value;
2300 /* Avoid endless loops on erroneous files by ensuring that
2301 we always move forward in the file. */
2302 if (p >= cof->raw_syments + p->u.syment.n_value)
2305 p = cof->raw_syments + p->u.syment.n_value;
2306 if (p > pend || p->u.syment.n_sclass != C_FILE)
2311 /* Now wander though the raw linenumbers of the section */
2312 /* If we have been called on this section before, and the offset we
2313 want is further down then we can prime the lookup loop. */
2314 sec_data = coff_section_data (abfd, section);
2315 if (sec_data != NULL
2317 && offset >= sec_data->offset)
2320 *functionname_ptr = sec_data->function;
2321 line_base = sec_data->line_base;
2329 if (section->lineno != NULL)
2331 bfd_vma last_value = 0;
2333 l = §ion->lineno[i];
2335 for (; i < section->lineno_count; i++)
2337 if (l->line_number == 0)
2339 /* Get the symbol this line number points at */
2340 coff_symbol_type *coff = (coff_symbol_type *) (l->u.sym);
2341 if (coff->symbol.value > offset)
2343 *functionname_ptr = coff->symbol.name;
2344 last_value = coff->symbol.value;
2347 combined_entry_type *s = coff->native;
2348 s = s + 1 + s->u.syment.n_numaux;
2350 /* In XCOFF a debugging symbol can follow the
2352 if (s->u.syment.n_scnum == N_DEBUG)
2353 s = s + 1 + s->u.syment.n_numaux;
2355 /* S should now point to the .bf of the function. */
2356 if (s->u.syment.n_numaux)
2358 /* The linenumber is stored in the auxent. */
2359 union internal_auxent *a = &((s + 1)->u.auxent);
2360 line_base = a->x_sym.x_misc.x_lnsz.x_lnno;
2361 *line_ptr = line_base;
2367 if (l->u.offset > offset)
2369 *line_ptr = l->line_number + line_base - 1;
2374 /* If we fell off the end of the loop, then assume that this
2375 symbol has no line number info. Otherwise, symbols with no
2376 line number info get reported with the line number of the
2377 last line of the last symbol which does have line number
2378 info. We use 0x100 as a slop to account for cases where the
2379 last line has executable code. */
2380 if (i >= section->lineno_count
2382 && offset - last_value > 0x100)
2384 *functionname_ptr = NULL;
2389 /* Cache the results for the next call. */
2390 if (sec_data == NULL && section->owner == abfd)
2392 amt = sizeof (struct coff_section_tdata);
2393 section->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
2394 sec_data = (struct coff_section_tdata *) section->used_by_bfd;
2396 if (sec_data != NULL)
2398 sec_data->offset = offset;
2400 sec_data->function = *functionname_ptr;
2401 sec_data->line_base = line_base;
2408 coff_sizeof_headers (abfd, reloc)
2416 size = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
2420 size = bfd_coff_filhsz (abfd);
2423 size += abfd->section_count * bfd_coff_scnhsz (abfd);
2427 /* Change the class of a coff symbol held by BFD. */
2429 bfd_coff_set_symbol_class (abfd, symbol, class)
2434 coff_symbol_type * csym;
2436 csym = coff_symbol_from (abfd, symbol);
2439 bfd_set_error (bfd_error_invalid_operation);
2442 else if (csym->native == NULL)
2444 /* This is an alien symbol which no native coff backend data.
2445 We cheat here by creating a fake native entry for it and
2446 then filling in the class. This code is based on that in
2447 coff_write_alien_symbol(). */
2449 combined_entry_type * native;
2450 bfd_size_type amt = sizeof (* native);
2452 native = (combined_entry_type *) bfd_alloc (abfd, amt);
2456 memset (native, 0, sizeof (* native));
2458 native->u.syment.n_type = T_NULL;
2459 native->u.syment.n_sclass = class;
2461 if (bfd_is_und_section (symbol->section))
2463 native->u.syment.n_scnum = N_UNDEF;
2464 native->u.syment.n_value = symbol->value;
2466 else if (bfd_is_com_section (symbol->section))
2468 native->u.syment.n_scnum = N_UNDEF;
2469 native->u.syment.n_value = symbol->value;
2473 native->u.syment.n_scnum =
2474 symbol->section->output_section->target_index;
2475 native->u.syment.n_value = (symbol->value
2476 + symbol->section->output_offset);
2477 if (! obj_pe (abfd))
2478 native->u.syment.n_value += symbol->section->output_section->vma;
2480 /* Copy the any flags from the file header into the symbol.
2482 native->u.syment.n_flags = bfd_asymbol_bfd (& csym->symbol)->flags;
2485 csym->native = native;
2489 csym->native->u.syment.n_sclass = class;