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 *, int));
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, strlen (strings) + 1);
114 strcpy (name, strings);
120 /* Assorted wastage to null-terminate the name, thanks AT&T! */
121 name = bfd_alloc (abfd, 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 size_t 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 = nscns * scnhsz;
215 external_sections = (char *) bfd_alloc (abfd, readsize);
216 if (!external_sections)
219 if (bfd_read ((PTR) external_sections, 1, 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. */
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_read (filehdr, 1, 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 if (bfd_coff_bad_format_hook (abfd, &internal_f) == false)
285 bfd_set_error (bfd_error_wrong_format);
288 nscns = internal_f.f_nscns;
290 if (internal_f.f_opthdr)
294 opthdr = bfd_alloc (abfd, aoutsz);
297 if (bfd_read (opthdr, 1, internal_f.f_opthdr, abfd)
298 != internal_f.f_opthdr)
302 bfd_coff_swap_aouthdr_in (abfd, opthdr, (PTR) &internal_a);
305 return coff_real_object_p (abfd, nscns, &internal_f,
306 (internal_f.f_opthdr != 0
308 : (struct internal_aouthdr *) NULL));
311 /* Get the BFD section from a COFF symbol section number. */
314 coff_section_from_bfd_index (abfd, index)
318 struct sec *answer = abfd->sections;
321 return bfd_abs_section_ptr;
322 if (index == N_UNDEF)
323 return bfd_und_section_ptr;
324 if (index == N_DEBUG)
325 return bfd_abs_section_ptr;
329 if (answer->target_index == index)
331 answer = answer->next;
334 /* We should not reach this point, but the SCO 3.2v4 /lib/libc_s.a
335 has a bad symbol table in biglitpow.o. */
336 return bfd_und_section_ptr;
339 /* Get the upper bound of a COFF symbol table. */
342 coff_get_symtab_upper_bound (abfd)
345 if (!bfd_coff_slurp_symbol_table (abfd))
348 return (bfd_get_symcount (abfd) + 1) * (sizeof (coff_symbol_type *));
351 /* Canonicalize a COFF symbol table. */
354 coff_get_symtab (abfd, alocation)
358 unsigned int counter;
359 coff_symbol_type *symbase;
360 coff_symbol_type **location = (coff_symbol_type **) alocation;
362 if (!bfd_coff_slurp_symbol_table (abfd))
365 symbase = obj_symbols (abfd);
366 counter = bfd_get_symcount (abfd);
367 while (counter-- > 0)
368 *location++ = symbase++;
372 return bfd_get_symcount (abfd);
375 /* Get the name of a symbol. The caller must pass in a buffer of size
379 _bfd_coff_internal_syment_name (abfd, sym, buf)
381 const struct internal_syment *sym;
384 /* FIXME: It's not clear this will work correctly if sizeof
386 if (sym->_n._n_n._n_zeroes != 0
387 || sym->_n._n_n._n_offset == 0)
389 memcpy (buf, sym->_n._n_name, SYMNMLEN);
390 buf[SYMNMLEN] = '\0';
397 BFD_ASSERT (sym->_n._n_n._n_offset >= STRING_SIZE_SIZE);
398 strings = obj_coff_strings (abfd);
401 strings = _bfd_coff_read_string_table (abfd);
405 return strings + sym->_n._n_n._n_offset;
409 /* Read in and swap the relocs. This returns a buffer holding the
410 relocs for section SEC in file ABFD. If CACHE is true and
411 INTERNAL_RELOCS is NULL, the relocs read in will be saved in case
412 the function is called again. If EXTERNAL_RELOCS is not NULL, it
413 is a buffer large enough to hold the unswapped relocs. If
414 INTERNAL_RELOCS is not NULL, it is a buffer large enough to hold
415 the swapped relocs. If REQUIRE_INTERNAL is true, then the return
416 value must be INTERNAL_RELOCS. The function returns NULL on error. */
418 struct internal_reloc *
419 _bfd_coff_read_internal_relocs (abfd, sec, cache, external_relocs,
420 require_internal, internal_relocs)
424 bfd_byte *external_relocs;
425 boolean require_internal;
426 struct internal_reloc *internal_relocs;
429 bfd_byte *free_external = NULL;
430 struct internal_reloc *free_internal = NULL;
433 struct internal_reloc *irel;
435 if (coff_section_data (abfd, sec) != NULL
436 && coff_section_data (abfd, sec)->relocs != NULL)
438 if (! require_internal)
439 return coff_section_data (abfd, sec)->relocs;
440 memcpy (internal_relocs, coff_section_data (abfd, sec)->relocs,
441 sec->reloc_count * sizeof (struct internal_reloc));
442 return internal_relocs;
445 relsz = bfd_coff_relsz (abfd);
447 if (external_relocs == NULL)
449 free_external = (bfd_byte *) bfd_malloc (sec->reloc_count * relsz);
450 if (free_external == NULL && sec->reloc_count > 0)
452 external_relocs = free_external;
455 if (bfd_seek (abfd, sec->rel_filepos, SEEK_SET) != 0
456 || (bfd_read (external_relocs, relsz, sec->reloc_count, abfd)
457 != relsz * sec->reloc_count))
460 if (internal_relocs == NULL)
462 free_internal = ((struct internal_reloc *)
463 bfd_malloc (sec->reloc_count
464 * sizeof (struct internal_reloc)));
465 if (free_internal == NULL && sec->reloc_count > 0)
467 internal_relocs = free_internal;
470 /* Swap in the relocs. */
471 erel = external_relocs;
472 erel_end = erel + relsz * sec->reloc_count;
473 irel = internal_relocs;
474 for (; erel < erel_end; erel += relsz, irel++)
475 bfd_coff_swap_reloc_in (abfd, (PTR) erel, (PTR) irel);
477 if (free_external != NULL)
479 free (free_external);
480 free_external = NULL;
483 if (cache && free_internal != NULL)
485 if (coff_section_data (abfd, sec) == NULL)
488 (PTR) bfd_zalloc (abfd,
489 sizeof (struct coff_section_tdata));
490 if (sec->used_by_bfd == NULL)
492 coff_section_data (abfd, sec)->contents = NULL;
494 coff_section_data (abfd, sec)->relocs = free_internal;
497 return internal_relocs;
500 if (free_external != NULL)
501 free (free_external);
502 if (free_internal != NULL)
503 free (free_internal);
507 /* Set lineno_count for the output sections of a COFF file. */
510 coff_count_linenumbers (abfd)
513 unsigned int limit = bfd_get_symcount (abfd);
521 /* This may be from the backend linker, in which case the
522 lineno_count in the sections is correct. */
523 for (s = abfd->sections; s != NULL; s = s->next)
524 total += s->lineno_count;
528 for (s = abfd->sections; s != NULL; s = s->next)
529 BFD_ASSERT (s->lineno_count == 0);
531 for (p = abfd->outsymbols, i = 0; i < limit; i++, p++)
533 asymbol *q_maybe = *p;
535 if (bfd_family_coff (bfd_asymbol_bfd (q_maybe)))
537 coff_symbol_type *q = coffsymbol (q_maybe);
539 /* The AIX 4.1 compiler can sometimes generate line numbers
540 attached to debugging symbols. We try to simply ignore
542 if (q->lineno != NULL
543 && q->symbol.section->owner != NULL)
545 /* This symbol has line numbers. Increment the owning
546 section's linenumber count. */
547 alent *l = q->lineno;
549 ++q->symbol.section->output_section->lineno_count;
552 while (l->line_number != 0)
555 ++q->symbol.section->output_section->lineno_count;
565 /* Takes a bfd and a symbol, returns a pointer to the coff specific
566 area of the symbol if there is one. */
569 coff_symbol_from (ignore_abfd, symbol)
570 bfd *ignore_abfd ATTRIBUTE_UNUSED;
573 if (!bfd_family_coff (bfd_asymbol_bfd (symbol)))
574 return (coff_symbol_type *) NULL;
576 if (bfd_asymbol_bfd (symbol)->tdata.coff_obj_data == (coff_data_type *) NULL)
577 return (coff_symbol_type *) NULL;
579 return (coff_symbol_type *) symbol;
583 fixup_symbol_value (abfd, coff_symbol_ptr, syment)
585 coff_symbol_type *coff_symbol_ptr;
586 struct internal_syment *syment;
589 /* Normalize the symbol flags */
590 if (bfd_is_com_section (coff_symbol_ptr->symbol.section))
592 /* a common symbol is undefined with a value */
593 syment->n_scnum = N_UNDEF;
594 syment->n_value = coff_symbol_ptr->symbol.value;
596 else if ((coff_symbol_ptr->symbol.flags & BSF_DEBUGGING) != 0
597 && (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING_RELOC) == 0)
599 syment->n_value = coff_symbol_ptr->symbol.value;
601 else if (bfd_is_und_section (coff_symbol_ptr->symbol.section))
603 syment->n_scnum = N_UNDEF;
606 /* FIXME: Do we need to handle the absolute section here? */
609 if (coff_symbol_ptr->symbol.section)
612 coff_symbol_ptr->symbol.section->output_section->target_index;
614 syment->n_value = (coff_symbol_ptr->symbol.value
615 + coff_symbol_ptr->symbol.section->output_offset);
618 syment->n_value += (syment->n_sclass == C_STATLAB)
619 ? coff_symbol_ptr->symbol.section->output_section->lma
620 : coff_symbol_ptr->symbol.section->output_section->vma;
626 /* This can happen, but I don't know why yet (steve@cygnus.com) */
627 syment->n_scnum = N_ABS;
628 syment->n_value = coff_symbol_ptr->symbol.value;
633 /* Run through all the symbols in the symbol table and work out what
634 their indexes into the symbol table will be when output.
636 Coff requires that each C_FILE symbol points to the next one in the
637 chain, and that the last one points to the first external symbol. We
641 coff_renumber_symbols (bfd_ptr, first_undef)
645 unsigned int symbol_count = bfd_get_symcount (bfd_ptr);
646 asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
647 unsigned int native_index = 0;
648 struct internal_syment *last_file = (struct internal_syment *) NULL;
649 unsigned int symbol_index;
651 /* COFF demands that undefined symbols come after all other symbols.
652 Since we don't need to impose this extra knowledge on all our
653 client programs, deal with that here. Sort the symbol table;
654 just move the undefined symbols to the end, leaving the rest
655 alone. The O'Reilly book says that defined global symbols come
656 at the end before the undefined symbols, so we do that here as
658 /* @@ Do we have some condition we could test for, so we don't always
659 have to do this? I don't think relocatability is quite right, but
660 I'm not certain. [raeburn:19920508.1711EST] */
665 newsyms = (asymbol **) bfd_alloc (bfd_ptr,
666 sizeof (asymbol *) * (symbol_count + 1));
669 bfd_ptr->outsymbols = newsyms;
670 for (i = 0; i < symbol_count; i++)
671 if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) != 0
672 || (!bfd_is_und_section (symbol_ptr_ptr[i]->section)
673 && !bfd_is_com_section (symbol_ptr_ptr[i]->section)
674 && ((symbol_ptr_ptr[i]->flags & BSF_FUNCTION) != 0
675 || ((symbol_ptr_ptr[i]->flags & (BSF_GLOBAL | BSF_WEAK))
677 *newsyms++ = symbol_ptr_ptr[i];
679 for (i = 0; i < symbol_count; i++)
680 if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) == 0
681 && !bfd_is_und_section (symbol_ptr_ptr[i]->section)
682 && (bfd_is_com_section (symbol_ptr_ptr[i]->section)
683 || ((symbol_ptr_ptr[i]->flags & BSF_FUNCTION) == 0
684 && ((symbol_ptr_ptr[i]->flags & (BSF_GLOBAL | BSF_WEAK))
686 *newsyms++ = symbol_ptr_ptr[i];
688 *first_undef = newsyms - bfd_ptr->outsymbols;
690 for (i = 0; i < symbol_count; i++)
691 if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) == 0
692 && bfd_is_und_section (symbol_ptr_ptr[i]->section))
693 *newsyms++ = symbol_ptr_ptr[i];
694 *newsyms = (asymbol *) NULL;
695 symbol_ptr_ptr = bfd_ptr->outsymbols;
698 for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
700 coff_symbol_type *coff_symbol_ptr = coff_symbol_from (bfd_ptr, symbol_ptr_ptr[symbol_index]);
701 symbol_ptr_ptr[symbol_index]->udata.i = symbol_index;
702 if (coff_symbol_ptr && coff_symbol_ptr->native)
704 combined_entry_type *s = coff_symbol_ptr->native;
707 if (s->u.syment.n_sclass == C_FILE)
709 if (last_file != (struct internal_syment *) NULL)
710 last_file->n_value = native_index;
711 last_file = &(s->u.syment);
716 /* Modify the symbol values according to their section and
719 fixup_symbol_value (bfd_ptr, coff_symbol_ptr, &(s->u.syment));
721 for (i = 0; i < s->u.syment.n_numaux + 1; i++)
722 s[i].offset = native_index++;
729 obj_conv_table_size (bfd_ptr) = native_index;
734 /* Run thorough the symbol table again, and fix it so that all
735 pointers to entries are changed to the entries' index in the output
739 coff_mangle_symbols (bfd_ptr)
742 unsigned int symbol_count = bfd_get_symcount (bfd_ptr);
743 asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
744 unsigned int symbol_index;
746 for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
748 coff_symbol_type *coff_symbol_ptr =
749 coff_symbol_from (bfd_ptr, symbol_ptr_ptr[symbol_index]);
751 if (coff_symbol_ptr && coff_symbol_ptr->native)
754 combined_entry_type *s = coff_symbol_ptr->native;
758 /* FIXME: We should use a union here. */
759 s->u.syment.n_value =
760 (bfd_vma)((combined_entry_type *)
761 ((unsigned long) s->u.syment.n_value))->offset;
766 /* The value is the offset into the line number entries
767 for the symbol's section. On output, the symbol's
768 section should be N_DEBUG. */
769 s->u.syment.n_value =
770 (coff_symbol_ptr->symbol.section->output_section->line_filepos
771 + s->u.syment.n_value * bfd_coff_linesz (bfd_ptr));
772 coff_symbol_ptr->symbol.section =
773 coff_section_from_bfd_index (bfd_ptr, N_DEBUG);
774 BFD_ASSERT (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING);
776 for (i = 0; i < s->u.syment.n_numaux; i++)
778 combined_entry_type *a = s + i + 1;
781 a->u.auxent.x_sym.x_tagndx.l =
782 a->u.auxent.x_sym.x_tagndx.p->offset;
787 a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l =
788 a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p->offset;
793 a->u.auxent.x_csect.x_scnlen.l =
794 a->u.auxent.x_csect.x_scnlen.p->offset;
803 coff_fix_symbol_name (abfd, symbol, native, string_size_p,
804 debug_string_section_p, debug_string_size_p)
807 combined_entry_type *native;
808 bfd_size_type *string_size_p;
809 asection **debug_string_section_p;
810 bfd_size_type *debug_string_size_p;
812 unsigned int name_length;
813 union internal_auxent *auxent;
814 char *name = (char *) (symbol->name);
816 if (name == (char *) NULL)
818 /* coff symbols always have names, so we'll make one up */
819 symbol->name = "strange";
820 name = (char *) symbol->name;
822 name_length = strlen (name);
824 if (native->u.syment.n_sclass == C_FILE
825 && native->u.syment.n_numaux > 0)
827 unsigned int filnmlen;
829 if (bfd_coff_force_symnames_in_strings (abfd))
831 native->u.syment._n._n_n._n_offset =
832 (*string_size_p + STRING_SIZE_SIZE);
833 native->u.syment._n._n_n._n_zeroes = 0;
834 *string_size_p += 6; /* strlen(".file") + 1 */
837 strncpy (native->u.syment._n._n_name, ".file", SYMNMLEN);
839 auxent = &(native + 1)->u.auxent;
841 filnmlen = bfd_coff_filnmlen (abfd);
843 if (bfd_coff_long_filenames (abfd))
845 if (name_length <= filnmlen)
847 strncpy (auxent->x_file.x_fname, name, filnmlen);
851 auxent->x_file.x_n.x_offset = *string_size_p + STRING_SIZE_SIZE;
852 auxent->x_file.x_n.x_zeroes = 0;
853 *string_size_p += name_length + 1;
858 strncpy (auxent->x_file.x_fname, name, filnmlen);
859 if (name_length > filnmlen)
860 name[filnmlen] = '\0';
865 if (name_length <= SYMNMLEN && !bfd_coff_force_symnames_in_strings (abfd))
867 /* This name will fit into the symbol neatly */
868 strncpy (native->u.syment._n._n_name, symbol->name, SYMNMLEN);
870 else if (!bfd_coff_symname_in_debug (abfd, &native->u.syment))
872 native->u.syment._n._n_n._n_offset = (*string_size_p
874 native->u.syment._n._n_n._n_zeroes = 0;
875 *string_size_p += name_length + 1;
881 int prefix_len = bfd_coff_debug_string_prefix_length (abfd);
883 /* This name should be written into the .debug section. For
884 some reason each name is preceded by a two byte length
885 and also followed by a null byte. FIXME: We assume that
886 the .debug section has already been created, and that it
888 if (*debug_string_section_p == (asection *) NULL)
889 *debug_string_section_p = bfd_get_section_by_name (abfd, ".debug");
890 filepos = bfd_tell (abfd);
892 bfd_put_32 (abfd, name_length + 1, buf);
894 bfd_put_16 (abfd, name_length + 1, buf);
896 if (!bfd_set_section_contents (abfd,
897 *debug_string_section_p,
899 (file_ptr) *debug_string_size_p,
900 (bfd_size_type) prefix_len)
901 || !bfd_set_section_contents (abfd,
902 *debug_string_section_p,
904 ((file_ptr) *debug_string_size_p
906 (bfd_size_type) name_length + 1))
908 if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
910 native->u.syment._n._n_n._n_offset =
911 *debug_string_size_p + prefix_len;
912 native->u.syment._n._n_n._n_zeroes = 0;
913 *debug_string_size_p += name_length + 1 + prefix_len;
918 /* We need to keep track of the symbol index so that when we write out
919 the relocs we can get the index for a symbol. This method is a
922 #define set_index(symbol, idx) ((symbol)->udata.i = (idx))
924 /* Write a symbol out to a COFF file. */
927 coff_write_symbol (abfd, symbol, native, written, string_size_p,
928 debug_string_section_p, debug_string_size_p)
931 combined_entry_type *native;
933 bfd_size_type *string_size_p;
934 asection **debug_string_section_p;
935 bfd_size_type *debug_string_size_p;
937 unsigned int numaux = native->u.syment.n_numaux;
938 int type = native->u.syment.n_type;
939 int class = native->u.syment.n_sclass;
941 bfd_size_type symesz;
943 if (native->u.syment.n_sclass == C_FILE)
944 symbol->flags |= BSF_DEBUGGING;
946 if (symbol->flags & BSF_DEBUGGING
947 && bfd_is_abs_section (symbol->section))
949 native->u.syment.n_scnum = N_DEBUG;
951 else if (bfd_is_abs_section (symbol->section))
953 native->u.syment.n_scnum = N_ABS;
955 else if (bfd_is_und_section (symbol->section))
957 native->u.syment.n_scnum = N_UNDEF;
961 native->u.syment.n_scnum =
962 symbol->section->output_section->target_index;
965 coff_fix_symbol_name (abfd, symbol, native, string_size_p,
966 debug_string_section_p, debug_string_size_p);
968 symesz = bfd_coff_symesz (abfd);
969 buf = bfd_alloc (abfd, symesz);
972 bfd_coff_swap_sym_out (abfd, &native->u.syment, buf);
973 if (bfd_write (buf, 1, symesz, abfd) != symesz)
975 bfd_release (abfd, buf);
977 if (native->u.syment.n_numaux > 0)
979 bfd_size_type auxesz;
982 auxesz = bfd_coff_auxesz (abfd);
983 buf = bfd_alloc (abfd, auxesz);
986 for (j = 0; j < native->u.syment.n_numaux; j++)
988 bfd_coff_swap_aux_out (abfd,
989 &((native + j + 1)->u.auxent),
993 native->u.syment.n_numaux,
995 if (bfd_write (buf, 1, auxesz, abfd) != auxesz)
998 bfd_release (abfd, buf);
1001 /* Store the index for use when we write out the relocs. */
1002 set_index (symbol, *written);
1004 *written += numaux + 1;
1008 /* Write out a symbol to a COFF file that does not come from a COFF
1009 file originally. This symbol may have been created by the linker,
1010 or we may be linking a non COFF file to a COFF file. */
1013 coff_write_alien_symbol (abfd, symbol, written, string_size_p,
1014 debug_string_section_p, debug_string_size_p)
1018 bfd_size_type *string_size_p;
1019 asection **debug_string_section_p;
1020 bfd_size_type *debug_string_size_p;
1022 combined_entry_type *native;
1023 combined_entry_type dummy;
1026 native->u.syment.n_type = T_NULL;
1027 native->u.syment.n_flags = 0;
1028 if (bfd_is_und_section (symbol->section))
1030 native->u.syment.n_scnum = N_UNDEF;
1031 native->u.syment.n_value = symbol->value;
1033 else if (bfd_is_com_section (symbol->section))
1035 native->u.syment.n_scnum = N_UNDEF;
1036 native->u.syment.n_value = symbol->value;
1038 else if (symbol->flags & BSF_DEBUGGING)
1040 /* There isn't much point to writing out a debugging symbol
1041 unless we are prepared to convert it into COFF debugging
1042 format. So, we just ignore them. We must clobber the symbol
1043 name to keep it from being put in the string table. */
1049 native->u.syment.n_scnum =
1050 symbol->section->output_section->target_index;
1051 native->u.syment.n_value = (symbol->value
1052 + symbol->section->output_offset);
1053 if (! obj_pe (abfd))
1054 native->u.syment.n_value += symbol->section->output_section->vma;
1056 /* Copy the any flags from the the file header into the symbol.
1059 coff_symbol_type *c = coff_symbol_from (abfd, symbol);
1060 if (c != (coff_symbol_type *) NULL)
1061 native->u.syment.n_flags = bfd_asymbol_bfd (&c->symbol)->flags;
1065 native->u.syment.n_type = 0;
1066 if (symbol->flags & BSF_LOCAL)
1067 native->u.syment.n_sclass = C_STAT;
1068 else if (symbol->flags & BSF_WEAK)
1069 native->u.syment.n_sclass = obj_pe (abfd) ? C_NT_WEAK : C_WEAKEXT;
1071 native->u.syment.n_sclass = C_EXT;
1072 native->u.syment.n_numaux = 0;
1074 return coff_write_symbol (abfd, symbol, native, written, string_size_p,
1075 debug_string_section_p, debug_string_size_p);
1078 /* Write a native symbol to a COFF file. */
1081 coff_write_native_symbol (abfd, symbol, written, string_size_p,
1082 debug_string_section_p, debug_string_size_p)
1084 coff_symbol_type *symbol;
1086 bfd_size_type *string_size_p;
1087 asection **debug_string_section_p;
1088 bfd_size_type *debug_string_size_p;
1090 combined_entry_type *native = symbol->native;
1091 alent *lineno = symbol->lineno;
1093 /* If this symbol has an associated line number, we must store the
1094 symbol index in the line number field. We also tag the auxent to
1095 point to the right place in the lineno table. */
1096 if (lineno && !symbol->done_lineno && symbol->symbol.section->owner != NULL)
1098 unsigned int count = 0;
1099 lineno[count].u.offset = *written;
1100 if (native->u.syment.n_numaux)
1102 union internal_auxent *a = &((native + 1)->u.auxent);
1104 a->x_sym.x_fcnary.x_fcn.x_lnnoptr =
1105 symbol->symbol.section->output_section->moving_line_filepos;
1108 /* Count and relocate all other linenumbers. */
1110 while (lineno[count].line_number != 0)
1114 I've been told this, but still need proof:
1115 > The second bug is also in `bfd/coffcode.h'. This bug
1116 > causes the linker to screw up the pc-relocations for
1117 > all the line numbers in COFF code. This bug isn't only
1118 > specific to A29K implementations, but affects all
1119 > systems using COFF format binaries. Note that in COFF
1120 > object files, the line number core offsets output by
1121 > the assembler are relative to the start of each
1122 > procedure, not to the start of the .text section. This
1123 > patch relocates the line numbers relative to the
1124 > `native->u.syment.n_value' instead of the section
1126 > modular!olson@cs.arizona.edu (Jon Olson)
1128 lineno[count].u.offset += native->u.syment.n_value;
1130 lineno[count].u.offset +=
1131 (symbol->symbol.section->output_section->vma
1132 + symbol->symbol.section->output_offset);
1136 symbol->done_lineno = true;
1138 symbol->symbol.section->output_section->moving_line_filepos +=
1139 count * bfd_coff_linesz (abfd);
1142 return coff_write_symbol (abfd, &(symbol->symbol), native, written,
1143 string_size_p, debug_string_section_p,
1144 debug_string_size_p);
1147 /* Write out the COFF symbols. */
1150 coff_write_symbols (abfd)
1153 bfd_size_type string_size;
1154 asection *debug_string_section;
1155 bfd_size_type debug_string_size;
1157 unsigned int limit = bfd_get_symcount (abfd);
1158 bfd_signed_vma written = 0;
1162 debug_string_section = NULL;
1163 debug_string_size = 0;
1165 /* If this target supports long section names, they must be put into
1166 the string table. This is supported by PE. This code must
1167 handle section names just as they are handled in
1168 coff_write_object_contents. */
1169 if (bfd_coff_long_section_names (abfd))
1173 for (o = abfd->sections; o != NULL; o = o->next)
1177 len = strlen (o->name);
1179 string_size += len + 1;
1183 /* Seek to the right place */
1184 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0)
1187 /* Output all the symbols we have */
1190 for (p = abfd->outsymbols, i = 0; i < limit; i++, p++)
1192 asymbol *symbol = *p;
1193 coff_symbol_type *c_symbol = coff_symbol_from (abfd, symbol);
1195 if (c_symbol == (coff_symbol_type *) NULL
1196 || c_symbol->native == (combined_entry_type *) NULL)
1198 if (!coff_write_alien_symbol (abfd, symbol, &written, &string_size,
1199 &debug_string_section,
1200 &debug_string_size))
1205 if (!coff_write_native_symbol (abfd, c_symbol, &written,
1206 &string_size, &debug_string_section,
1207 &debug_string_size))
1212 obj_raw_syment_count (abfd) = written;
1214 /* Now write out strings */
1216 if (string_size != 0)
1218 unsigned int size = string_size + STRING_SIZE_SIZE;
1219 bfd_byte buffer[STRING_SIZE_SIZE];
1221 #if STRING_SIZE_SIZE == 4
1222 bfd_h_put_32 (abfd, size, buffer);
1224 #error Change bfd_h_put_32
1226 if (bfd_write ((PTR) buffer, 1, sizeof (buffer), abfd) != sizeof (buffer))
1229 /* Handle long section names. This code must handle section
1230 names just as they are handled in coff_write_object_contents. */
1231 if (bfd_coff_long_section_names (abfd))
1235 for (o = abfd->sections; o != NULL; o = o->next)
1239 len = strlen (o->name);
1242 if (bfd_write (o->name, 1, len + 1, abfd) != len + 1)
1248 for (p = abfd->outsymbols, i = 0;
1253 size_t name_length = strlen (q->name);
1254 coff_symbol_type *c_symbol = coff_symbol_from (abfd, q);
1257 /* Figure out whether the symbol name should go in the string
1258 table. Symbol names that are short enough are stored
1259 directly in the syment structure. File names permit a
1260 different, longer, length in the syment structure. On
1261 XCOFF, some symbol names are stored in the .debug section
1262 rather than in the string table. */
1264 if (c_symbol == NULL
1265 || c_symbol->native == NULL)
1267 /* This is not a COFF symbol, so it certainly is not a
1268 file name, nor does it go in the .debug section. */
1269 maxlen = bfd_coff_force_symnames_in_strings (abfd) ? 0 : SYMNMLEN;
1271 else if (bfd_coff_symname_in_debug (abfd,
1272 &c_symbol->native->u.syment))
1274 /* This symbol name is in the XCOFF .debug section.
1275 Don't write it into the string table. */
1276 maxlen = name_length;
1278 else if (c_symbol->native->u.syment.n_sclass == C_FILE
1279 && c_symbol->native->u.syment.n_numaux > 0)
1281 if (bfd_coff_force_symnames_in_strings (abfd))
1282 bfd_write (".file", 1, 6, abfd);
1283 maxlen = bfd_coff_filnmlen (abfd);
1286 maxlen = bfd_coff_force_symnames_in_strings (abfd) ? 0 : SYMNMLEN;
1288 if (name_length > maxlen)
1290 if (bfd_write ((PTR) (q->name), 1, name_length + 1, abfd)
1298 /* We would normally not write anything here, but we'll write
1299 out 4 so that any stupid coff reader which tries to read the
1300 string table even when there isn't one won't croak. */
1301 unsigned int size = STRING_SIZE_SIZE;
1302 bfd_byte buffer[STRING_SIZE_SIZE];
1304 #if STRING_SIZE_SIZE == 4
1305 bfd_h_put_32 (abfd, size, buffer);
1307 #error Change bfd_h_put_32
1309 if (bfd_write ((PTR) buffer, 1, STRING_SIZE_SIZE, abfd)
1310 != STRING_SIZE_SIZE)
1314 /* Make sure the .debug section was created to be the correct size.
1315 We should create it ourselves on the fly, but we don't because
1316 BFD won't let us write to any section until we know how large all
1317 the sections are. We could still do it by making another pass
1318 over the symbols. FIXME. */
1319 BFD_ASSERT (debug_string_size == 0
1320 || (debug_string_section != (asection *) NULL
1321 && (BFD_ALIGN (debug_string_size,
1322 1 << debug_string_section->alignment_power)
1323 == bfd_section_size (abfd, debug_string_section))));
1329 coff_write_linenumbers (abfd)
1333 bfd_size_type linesz;
1336 linesz = bfd_coff_linesz (abfd);
1337 buff = bfd_alloc (abfd, linesz);
1340 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
1342 if (s->lineno_count)
1344 asymbol **q = abfd->outsymbols;
1345 if (bfd_seek (abfd, s->line_filepos, SEEK_SET) != 0)
1347 /* Find all the linenumbers in this section */
1351 if (p->section->output_section == s)
1354 BFD_SEND (bfd_asymbol_bfd (p), _get_lineno,
1355 (bfd_asymbol_bfd (p), p));
1358 /* Found a linenumber entry, output */
1359 struct internal_lineno out;
1360 memset ((PTR) & out, 0, sizeof (out));
1362 out.l_addr.l_symndx = l->u.offset;
1363 bfd_coff_swap_lineno_out (abfd, &out, buff);
1364 if (bfd_write (buff, 1, linesz, abfd) != linesz)
1367 while (l->line_number)
1369 out.l_lnno = l->line_number;
1370 out.l_addr.l_symndx = l->u.offset;
1371 bfd_coff_swap_lineno_out (abfd, &out, buff);
1372 if (bfd_write (buff, 1, linesz, abfd) != linesz)
1382 bfd_release (abfd, buff);
1387 coff_get_lineno (ignore_abfd, symbol)
1388 bfd *ignore_abfd ATTRIBUTE_UNUSED;
1391 return coffsymbol (symbol)->lineno;
1396 /* This is only called from coff_add_missing_symbols, which has been
1400 coff_section_symbol (abfd, name)
1404 asection *sec = bfd_make_section_old_way (abfd, name);
1406 combined_entry_type *csym;
1409 csym = coff_symbol_from (abfd, sym)->native;
1410 /* Make sure back-end COFF stuff is there. */
1415 coff_symbol_type sym;
1416 /* @@FIXME This shouldn't use a fixed size!! */
1417 combined_entry_type e[10];
1420 f = (struct foo *) bfd_alloc (abfd, sizeof (*f));
1423 bfd_set_error (bfd_error_no_error);
1426 memset ((char *) f, 0, sizeof (*f));
1427 coff_symbol_from (abfd, sym)->native = csym = f->e;
1429 csym[0].u.syment.n_sclass = C_STAT;
1430 csym[0].u.syment.n_numaux = 1;
1431 /* SF_SET_STATICS (sym); @@ ??? */
1432 csym[1].u.auxent.x_scn.x_scnlen = sec->_raw_size;
1433 csym[1].u.auxent.x_scn.x_nreloc = sec->reloc_count;
1434 csym[1].u.auxent.x_scn.x_nlinno = sec->lineno_count;
1436 if (sec->output_section == NULL)
1438 sec->output_section = sec;
1439 sec->output_offset = 0;
1447 /* This function transforms the offsets into the symbol table into
1448 pointers to syments. */
1451 coff_pointerize_aux (abfd, table_base, symbol, indaux, auxent)
1453 combined_entry_type *table_base;
1454 combined_entry_type *symbol;
1455 unsigned int indaux;
1456 combined_entry_type *auxent;
1458 unsigned int type = symbol->u.syment.n_type;
1459 unsigned int class = symbol->u.syment.n_sclass;
1461 if (coff_backend_info (abfd)->_bfd_coff_pointerize_aux_hook)
1463 if ((*coff_backend_info (abfd)->_bfd_coff_pointerize_aux_hook)
1464 (abfd, table_base, symbol, indaux, auxent))
1468 /* Don't bother if this is a file or a section */
1469 if (class == C_STAT && type == T_NULL)
1471 if (class == C_FILE)
1474 /* Otherwise patch up */
1475 #define N_TMASK coff_data (abfd)->local_n_tmask
1476 #define N_BTSHFT coff_data (abfd)->local_n_btshft
1477 if ((ISFCN (type) || ISTAG (class) || class == C_BLOCK || class == C_FCN)
1478 && auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l > 0)
1480 auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p =
1481 table_base + auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l;
1482 auxent->fix_end = 1;
1484 /* A negative tagndx is meaningless, but the SCO 3.2v4 cc can
1485 generate one, so we must be careful to ignore it. */
1486 if (auxent->u.auxent.x_sym.x_tagndx.l > 0)
1488 auxent->u.auxent.x_sym.x_tagndx.p =
1489 table_base + auxent->u.auxent.x_sym.x_tagndx.l;
1490 auxent->fix_tag = 1;
1494 /* Allocate space for the ".debug" section, and read it.
1495 We did not read the debug section until now, because
1496 we didn't want to go to the trouble until someone needed it. */
1499 build_debug_section (abfd)
1502 char *debug_section;
1505 asection *sect = bfd_get_section_by_name (abfd, ".debug");
1509 bfd_set_error (bfd_error_no_debug_section);
1513 debug_section = (PTR) bfd_alloc (abfd,
1514 bfd_get_section_size_before_reloc (sect));
1515 if (debug_section == NULL)
1518 /* Seek to the beginning of the `.debug' section and read it.
1519 Save the current position first; it is needed by our caller.
1520 Then read debug section and reset the file pointer. */
1522 position = bfd_tell (abfd);
1523 if (bfd_seek (abfd, sect->filepos, SEEK_SET) != 0
1524 || (bfd_read (debug_section,
1525 bfd_get_section_size_before_reloc (sect), 1, abfd)
1526 != bfd_get_section_size_before_reloc (sect))
1527 || bfd_seek (abfd, position, SEEK_SET) != 0)
1529 return debug_section;
1532 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
1533 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
1534 be \0-terminated. */
1536 copy_name (abfd, name, maxlen)
1544 for (len = 0; len < maxlen; ++len)
1546 if (name[len] == '\0')
1552 if ((newname = (PTR) bfd_alloc (abfd, len + 1)) == NULL)
1554 strncpy (newname, name, len);
1555 newname[len] = '\0';
1559 /* Read in the external symbols. */
1562 _bfd_coff_get_external_symbols (abfd)
1565 bfd_size_type symesz;
1569 if (obj_coff_external_syms (abfd) != NULL)
1572 symesz = bfd_coff_symesz (abfd);
1574 size = obj_raw_syment_count (abfd) * symesz;
1576 syms = (PTR) bfd_malloc (size);
1577 if (syms == NULL && size != 0)
1580 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
1581 || bfd_read (syms, size, 1, abfd) != size)
1588 obj_coff_external_syms (abfd) = syms;
1593 /* Read in the external strings. The strings are not loaded until
1594 they are needed. This is because we have no simple way of
1595 detecting a missing string table in an archive. */
1598 _bfd_coff_read_string_table (abfd)
1601 char extstrsize[STRING_SIZE_SIZE];
1605 if (obj_coff_strings (abfd) != NULL)
1606 return obj_coff_strings (abfd);
1608 if (obj_sym_filepos (abfd) == 0)
1610 bfd_set_error (bfd_error_no_symbols);
1615 (obj_sym_filepos (abfd)
1616 + obj_raw_syment_count (abfd) * bfd_coff_symesz (abfd)),
1620 if (bfd_read (extstrsize, sizeof extstrsize, 1, abfd) != sizeof extstrsize)
1622 if (bfd_get_error () != bfd_error_file_truncated)
1625 /* There is no string table. */
1626 strsize = STRING_SIZE_SIZE;
1630 #if STRING_SIZE_SIZE == 4
1631 strsize = bfd_h_get_32 (abfd, (bfd_byte *) extstrsize);
1633 #error Change bfd_h_get_32
1637 if (strsize < STRING_SIZE_SIZE)
1639 (*_bfd_error_handler)
1640 (_("%s: bad string table size %lu"), bfd_get_filename (abfd),
1641 (unsigned long) strsize);
1642 bfd_set_error (bfd_error_bad_value);
1646 strings = (char *) bfd_malloc (strsize);
1647 if (strings == NULL)
1650 if (bfd_read (strings + STRING_SIZE_SIZE,
1651 strsize - STRING_SIZE_SIZE, 1, abfd)
1652 != strsize - STRING_SIZE_SIZE)
1658 obj_coff_strings (abfd) = strings;
1663 /* Free up the external symbols and strings read from a COFF file. */
1666 _bfd_coff_free_symbols (abfd)
1669 if (obj_coff_external_syms (abfd) != NULL
1670 && ! obj_coff_keep_syms (abfd))
1672 free (obj_coff_external_syms (abfd));
1673 obj_coff_external_syms (abfd) = NULL;
1675 if (obj_coff_strings (abfd) != NULL
1676 && ! obj_coff_keep_strings (abfd))
1678 free (obj_coff_strings (abfd));
1679 obj_coff_strings (abfd) = NULL;
1684 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
1685 knit the symbol names into a normalized form. By normalized here I
1686 mean that all symbols have an n_offset pointer that points to a null-
1687 terminated string. */
1689 combined_entry_type *
1690 coff_get_normalized_symtab (abfd)
1693 combined_entry_type *internal;
1694 combined_entry_type *internal_ptr;
1695 combined_entry_type *symbol_ptr;
1696 combined_entry_type *internal_end;
1697 bfd_size_type symesz;
1700 const char *string_table = NULL;
1701 char *debug_section = NULL;
1704 if (obj_raw_syments (abfd) != NULL)
1705 return obj_raw_syments (abfd);
1707 size = obj_raw_syment_count (abfd) * sizeof (combined_entry_type);
1708 internal = (combined_entry_type *) bfd_zalloc (abfd, size);
1709 if (internal == NULL && size != 0)
1711 internal_end = internal + obj_raw_syment_count (abfd);
1713 if (! _bfd_coff_get_external_symbols (abfd))
1716 raw_src = (char *) obj_coff_external_syms (abfd);
1718 /* mark the end of the symbols */
1719 symesz = bfd_coff_symesz (abfd);
1720 raw_end = (char *) raw_src + obj_raw_syment_count (abfd) * symesz;
1722 /* FIXME SOMEDAY. A string table size of zero is very weird, but
1723 probably possible. If one shows up, it will probably kill us. */
1725 /* Swap all the raw entries */
1726 for (internal_ptr = internal;
1728 raw_src += symesz, internal_ptr++)
1732 bfd_coff_swap_sym_in (abfd, (PTR) raw_src,
1733 (PTR) & internal_ptr->u.syment);
1734 symbol_ptr = internal_ptr;
1737 i < symbol_ptr->u.syment.n_numaux;
1742 bfd_coff_swap_aux_in (abfd, (PTR) raw_src,
1743 symbol_ptr->u.syment.n_type,
1744 symbol_ptr->u.syment.n_sclass,
1745 i, symbol_ptr->u.syment.n_numaux,
1746 &(internal_ptr->u.auxent));
1747 coff_pointerize_aux (abfd, internal, symbol_ptr, i,
1752 /* Free the raw symbols, but not the strings (if we have them). */
1753 obj_coff_keep_strings (abfd) = true;
1754 if (! _bfd_coff_free_symbols (abfd))
1757 for (internal_ptr = internal; internal_ptr < internal_end;
1760 if (internal_ptr->u.syment.n_sclass == C_FILE
1761 && internal_ptr->u.syment.n_numaux > 0)
1763 /* make a file symbol point to the name in the auxent, since
1764 the text ".file" is redundant */
1765 if ((internal_ptr + 1)->u.auxent.x_file.x_n.x_zeroes == 0)
1767 /* the filename is a long one, point into the string table */
1768 if (string_table == NULL)
1770 string_table = _bfd_coff_read_string_table (abfd);
1771 if (string_table == NULL)
1775 internal_ptr->u.syment._n._n_n._n_offset =
1778 + (internal_ptr + 1)->u.auxent.x_file.x_n.x_offset));
1782 /* Ordinary short filename, put into memory anyway. The
1783 Microsoft PE tools sometimes store a filename in
1784 multiple AUX entries. */
1785 if (internal_ptr->u.syment.n_numaux > 1
1786 && coff_data (abfd)->pe)
1788 internal_ptr->u.syment._n._n_n._n_offset =
1791 (internal_ptr + 1)->u.auxent.x_file.x_fname,
1792 internal_ptr->u.syment.n_numaux * symesz));
1796 internal_ptr->u.syment._n._n_n._n_offset =
1799 (internal_ptr + 1)->u.auxent.x_file.x_fname,
1800 bfd_coff_filnmlen (abfd)));
1806 if (internal_ptr->u.syment._n._n_n._n_zeroes != 0)
1808 /* This is a "short" name. Make it long. */
1809 unsigned long i = 0;
1810 char *newstring = NULL;
1812 /* find the length of this string without walking into memory
1814 for (i = 0; i < 8; ++i)
1816 if (internal_ptr->u.syment._n._n_name[i] == '\0')
1819 } /* if end of string */
1820 } /* possible lengths of this string. */
1822 if ((newstring = (PTR) bfd_alloc (abfd, ++i)) == NULL)
1824 memset (newstring, 0, i);
1825 strncpy (newstring, internal_ptr->u.syment._n._n_name, i - 1);
1826 internal_ptr->u.syment._n._n_n._n_offset = (long int) newstring;
1827 internal_ptr->u.syment._n._n_n._n_zeroes = 0;
1829 else if (internal_ptr->u.syment._n._n_n._n_offset == 0)
1830 internal_ptr->u.syment._n._n_n._n_offset = (long int) "";
1831 else if (!bfd_coff_symname_in_debug (abfd, &internal_ptr->u.syment))
1833 /* Long name already. Point symbol at the string in the
1835 if (string_table == NULL)
1837 string_table = _bfd_coff_read_string_table (abfd);
1838 if (string_table == NULL)
1841 internal_ptr->u.syment._n._n_n._n_offset =
1844 + internal_ptr->u.syment._n._n_n._n_offset));
1848 /* Long name in debug section. Very similar. */
1849 if (debug_section == NULL)
1850 debug_section = build_debug_section (abfd);
1851 internal_ptr->u.syment._n._n_n._n_offset = (long int)
1852 (debug_section + internal_ptr->u.syment._n._n_n._n_offset);
1855 internal_ptr += internal_ptr->u.syment.n_numaux;
1858 obj_raw_syments (abfd) = internal;
1859 BFD_ASSERT (obj_raw_syment_count (abfd)
1860 == (unsigned int) (internal_ptr - internal));
1863 } /* coff_get_normalized_symtab() */
1866 coff_get_reloc_upper_bound (abfd, asect)
1870 if (bfd_get_format (abfd) != bfd_object)
1872 bfd_set_error (bfd_error_invalid_operation);
1875 return (asect->reloc_count + 1) * sizeof (arelent *);
1879 coff_make_empty_symbol (abfd)
1882 coff_symbol_type *new = (coff_symbol_type *) bfd_alloc (abfd, sizeof (coff_symbol_type));
1885 memset (new, 0, sizeof *new);
1886 new->symbol.section = 0;
1888 new->lineno = (alent *) NULL;
1889 new->done_lineno = false;
1890 new->symbol.the_bfd = abfd;
1891 return &new->symbol;
1894 /* Make a debugging symbol. */
1897 coff_bfd_make_debug_symbol (abfd, ptr, sz)
1899 PTR ptr ATTRIBUTE_UNUSED;
1900 unsigned long sz ATTRIBUTE_UNUSED;
1902 coff_symbol_type *new = (coff_symbol_type *) bfd_alloc (abfd, sizeof (coff_symbol_type));
1905 /* @@ The 10 is a guess at a plausible maximum number of aux entries
1906 (but shouldn't be a constant). */
1907 new->native = (combined_entry_type *) bfd_zalloc (abfd, sizeof (combined_entry_type) * 10);
1910 new->symbol.section = bfd_abs_section_ptr;
1911 new->symbol.flags = BSF_DEBUGGING;
1912 new->lineno = (alent *) NULL;
1913 new->done_lineno = false;
1914 new->symbol.the_bfd = abfd;
1915 return &new->symbol;
1919 coff_get_symbol_info (abfd, symbol, ret)
1924 bfd_symbol_info (symbol, ret);
1925 if (coffsymbol (symbol)->native != NULL
1926 && coffsymbol (symbol)->native->fix_value)
1928 ret->value = coffsymbol (symbol)->native->u.syment.n_value -
1929 (unsigned long) obj_raw_syments (abfd);
1933 /* Return the COFF syment for a symbol. */
1936 bfd_coff_get_syment (abfd, symbol, psyment)
1939 struct internal_syment *psyment;
1941 coff_symbol_type *csym;
1943 csym = coff_symbol_from (abfd, symbol);
1944 if (csym == NULL || csym->native == NULL)
1946 bfd_set_error (bfd_error_invalid_operation);
1950 *psyment = csym->native->u.syment;
1952 if (csym->native->fix_value)
1953 psyment->n_value = psyment->n_value -
1954 (unsigned long) obj_raw_syments (abfd);
1956 /* FIXME: We should handle fix_line here. */
1961 /* Return the COFF auxent for a symbol. */
1964 bfd_coff_get_auxent (abfd, symbol, indx, pauxent)
1968 union internal_auxent *pauxent;
1970 coff_symbol_type *csym;
1971 combined_entry_type *ent;
1973 csym = coff_symbol_from (abfd, symbol);
1976 || csym->native == NULL
1977 || indx >= csym->native->u.syment.n_numaux)
1979 bfd_set_error (bfd_error_invalid_operation);
1983 ent = csym->native + indx + 1;
1985 *pauxent = ent->u.auxent;
1988 pauxent->x_sym.x_tagndx.l =
1989 ((combined_entry_type *) pauxent->x_sym.x_tagndx.p
1990 - obj_raw_syments (abfd));
1993 pauxent->x_sym.x_fcnary.x_fcn.x_endndx.l =
1994 ((combined_entry_type *) pauxent->x_sym.x_fcnary.x_fcn.x_endndx.p
1995 - obj_raw_syments (abfd));
1997 if (ent->fix_scnlen)
1998 pauxent->x_csect.x_scnlen.l =
1999 ((combined_entry_type *) pauxent->x_csect.x_scnlen.p
2000 - obj_raw_syments (abfd));
2005 /* Print out information about COFF symbol. */
2008 coff_print_symbol (abfd, filep, symbol, how)
2012 bfd_print_symbol_type how;
2014 FILE *file = (FILE *) filep;
2018 case bfd_print_symbol_name:
2019 fprintf (file, "%s", symbol->name);
2022 case bfd_print_symbol_more:
2023 fprintf (file, "coff %s %s",
2024 coffsymbol (symbol)->native ? "n" : "g",
2025 coffsymbol (symbol)->lineno ? "l" : " ");
2028 case bfd_print_symbol_all:
2029 if (coffsymbol (symbol)->native)
2033 combined_entry_type *combined = coffsymbol (symbol)->native;
2034 combined_entry_type *root = obj_raw_syments (abfd);
2035 struct lineno_cache_entry *l = coffsymbol (symbol)->lineno;
2037 fprintf (file, "[%3ld]", (long) (combined - root));
2039 if (! combined->fix_value)
2040 val = (bfd_vma) combined->u.syment.n_value;
2042 val = combined->u.syment.n_value - (unsigned long) root;
2046 "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x%08lx %s",
2047 combined->u.syment.n_scnum,
2048 combined->u.syment.n_flags,
2049 combined->u.syment.n_type,
2050 combined->u.syment.n_sclass,
2051 combined->u.syment.n_numaux,
2052 (unsigned long) val,
2055 /* Print out the wide, 64 bit, symbol value */
2057 "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x%016llx %s",
2058 combined->u.syment.n_scnum,
2059 combined->u.syment.n_flags,
2060 combined->u.syment.n_type,
2061 combined->u.syment.n_sclass,
2062 combined->u.syment.n_numaux,
2067 for (aux = 0; aux < combined->u.syment.n_numaux; aux++)
2069 combined_entry_type *auxp = combined + aux + 1;
2073 tagndx = auxp->u.auxent.x_sym.x_tagndx.p - root;
2075 tagndx = auxp->u.auxent.x_sym.x_tagndx.l;
2077 fprintf (file, "\n");
2079 if (bfd_coff_print_aux (abfd, file, root, combined, auxp, aux))
2082 switch (combined->u.syment.n_sclass)
2085 fprintf (file, "File ");
2089 if (combined->u.syment.n_type == T_NULL)
2090 /* probably a section symbol? */
2092 fprintf (file, "AUX scnlen 0x%lx nreloc %d nlnno %d",
2093 (long) auxp->u.auxent.x_scn.x_scnlen,
2094 auxp->u.auxent.x_scn.x_nreloc,
2095 auxp->u.auxent.x_scn.x_nlinno);
2096 if (auxp->u.auxent.x_scn.x_checksum != 0
2097 || auxp->u.auxent.x_scn.x_associated != 0
2098 || auxp->u.auxent.x_scn.x_comdat != 0)
2099 fprintf (file, " checksum 0x%lx assoc %d comdat %d",
2100 auxp->u.auxent.x_scn.x_checksum,
2101 auxp->u.auxent.x_scn.x_associated,
2102 auxp->u.auxent.x_scn.x_comdat);
2105 /* else fall through */
2107 if (ISFCN (combined->u.syment.n_type))
2110 _("AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld"),
2112 auxp->u.auxent.x_sym.x_misc.x_fsize,
2113 auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_lnnoptr,
2116 (auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p
2118 : auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l));
2121 /* else fall through */
2123 fprintf (file, "AUX lnno %d size 0x%x tagndx %ld",
2124 auxp->u.auxent.x_sym.x_misc.x_lnsz.x_lnno,
2125 auxp->u.auxent.x_sym.x_misc.x_lnsz.x_size,
2128 fprintf (file, " endndx %ld",
2130 (auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p
2138 fprintf (file, "\n%s :", l->u.sym->name);
2140 while (l->line_number)
2142 fprintf (file, "\n%4d : 0x%lx",
2145 (l->u.offset + symbol->section->vma)));
2152 bfd_print_symbol_vandf ((PTR) file, symbol);
2153 fprintf (file, " %-5s %s %s %s",
2154 symbol->section->name,
2155 coffsymbol (symbol)->native ? "n" : "g",
2156 coffsymbol (symbol)->lineno ? "l" : " ",
2162 /* Return whether a symbol name implies a local symbol. In COFF,
2163 local symbols generally start with ``.L''. Most targets use this
2164 function for the is_local_label_name entry point, but some may
2168 _bfd_coff_is_local_label_name (abfd, name)
2169 bfd *abfd ATTRIBUTE_UNUSED;
2172 return name[0] == '.' && name[1] == 'L';
2175 /* Provided a BFD, a section and an offset (in bytes, not octets) into the
2176 section, calculate and return the name of the source file and the line
2177 nearest to the wanted location. */
2180 coff_find_nearest_line (abfd, section, symbols, offset, filename_ptr,
2181 functionname_ptr, line_ptr)
2186 CONST char **filename_ptr;
2187 CONST char **functionname_ptr;
2188 unsigned int *line_ptr;
2192 unsigned int line_base;
2193 coff_data_type *cof = coff_data (abfd);
2194 /* Run through the raw syments if available */
2195 combined_entry_type *p;
2196 combined_entry_type *pend;
2198 struct coff_section_tdata *sec_data;
2200 /* Before looking through the symbol table, try to use a .stab
2201 section to find the information. */
2202 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
2203 &found, filename_ptr,
2204 functionname_ptr, line_ptr,
2205 &coff_data(abfd)->line_info))
2211 /* Also try examining DWARF2 debugging information. */
2212 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
2213 filename_ptr, functionname_ptr,
2215 &coff_data(abfd)->dwarf2_find_line_info))
2219 *functionname_ptr = 0;
2222 /* Don't try and find line numbers in a non coff file */
2223 if (!bfd_family_coff (abfd))
2229 /* Find the first C_FILE symbol. */
2230 p = cof->raw_syments;
2234 pend = p + cof->raw_syment_count;
2237 if (p->u.syment.n_sclass == C_FILE)
2239 p += 1 + p->u.syment.n_numaux;
2247 /* Look through the C_FILE symbols to find the best one. */
2248 sec_vma = bfd_get_section_vma (abfd, section);
2249 *filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
2250 maxdiff = (bfd_vma) 0 - (bfd_vma) 1;
2253 combined_entry_type *p2;
2255 for (p2 = p + 1 + p->u.syment.n_numaux;
2257 p2 += 1 + p2->u.syment.n_numaux)
2259 if (p2->u.syment.n_scnum > 0
2261 == coff_section_from_bfd_index (abfd,
2262 p2->u.syment.n_scnum)))
2264 if (p2->u.syment.n_sclass == C_FILE)
2271 /* We use <= MAXDIFF here so that if we get a zero length
2272 file, we actually use the next file entry. */
2274 && offset + sec_vma >= (bfd_vma) p2->u.syment.n_value
2275 && offset + sec_vma - (bfd_vma) p2->u.syment.n_value <= maxdiff)
2277 *filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
2278 maxdiff = offset + sec_vma - p2->u.syment.n_value;
2281 /* Avoid endless loops on erroneous files by ensuring that
2282 we always move forward in the file. */
2283 if (p - cof->raw_syments >= p->u.syment.n_value)
2286 p = cof->raw_syments + p->u.syment.n_value;
2287 if (p > pend || p->u.syment.n_sclass != C_FILE)
2292 /* Now wander though the raw linenumbers of the section */
2293 /* If we have been called on this section before, and the offset we
2294 want is further down then we can prime the lookup loop. */
2295 sec_data = coff_section_data (abfd, section);
2296 if (sec_data != NULL
2298 && offset >= sec_data->offset)
2301 *functionname_ptr = sec_data->function;
2302 line_base = sec_data->line_base;
2310 if (section->lineno != NULL)
2312 bfd_vma last_value = 0;
2314 l = §ion->lineno[i];
2316 for (; i < section->lineno_count; i++)
2318 if (l->line_number == 0)
2320 /* Get the symbol this line number points at */
2321 coff_symbol_type *coff = (coff_symbol_type *) (l->u.sym);
2322 if (coff->symbol.value > offset)
2324 *functionname_ptr = coff->symbol.name;
2325 last_value = coff->symbol.value;
2328 combined_entry_type *s = coff->native;
2329 s = s + 1 + s->u.syment.n_numaux;
2331 /* In XCOFF a debugging symbol can follow the
2333 if (s->u.syment.n_scnum == N_DEBUG)
2334 s = s + 1 + s->u.syment.n_numaux;
2336 /* S should now point to the .bf of the function. */
2337 if (s->u.syment.n_numaux)
2339 /* The linenumber is stored in the auxent. */
2340 union internal_auxent *a = &((s + 1)->u.auxent);
2341 line_base = a->x_sym.x_misc.x_lnsz.x_lnno;
2342 *line_ptr = line_base;
2348 if (l->u.offset > offset)
2350 *line_ptr = l->line_number + line_base - 1;
2355 /* If we fell off the end of the loop, then assume that this
2356 symbol has no line number info. Otherwise, symbols with no
2357 line number info get reported with the line number of the
2358 last line of the last symbol which does have line number
2359 info. We use 0x100 as a slop to account for cases where the
2360 last line has executable code. */
2361 if (i >= section->lineno_count
2363 && offset - last_value > 0x100)
2365 *functionname_ptr = NULL;
2370 /* Cache the results for the next call. */
2371 if (sec_data == NULL && section->owner == abfd)
2373 section->used_by_bfd =
2374 ((PTR) bfd_zalloc (abfd,
2375 sizeof (struct coff_section_tdata)));
2376 sec_data = (struct coff_section_tdata *) section->used_by_bfd;
2378 if (sec_data != NULL)
2380 sec_data->offset = offset;
2382 sec_data->function = *functionname_ptr;
2383 sec_data->line_base = line_base;
2390 coff_sizeof_headers (abfd, reloc)
2398 size = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
2402 size = bfd_coff_filhsz (abfd);
2405 size += abfd->section_count * bfd_coff_scnhsz (abfd);
2409 /* Change the class of a coff symbol held by BFD. */
2411 bfd_coff_set_symbol_class (abfd, symbol, class)
2416 coff_symbol_type * csym;
2418 csym = coff_symbol_from (abfd, symbol);
2421 bfd_set_error (bfd_error_invalid_operation);
2424 else if (csym->native == NULL)
2426 /* This is an alien symbol which no native coff backend data.
2427 We cheat here by creating a fake native entry for it and
2428 then filling in the class. This code is based on that in
2429 coff_write_alien_symbol(). */
2431 combined_entry_type * native;
2433 native = (combined_entry_type *) bfd_alloc (abfd, sizeof (* native));
2437 memset (native, 0, sizeof (* native));
2439 native->u.syment.n_type = T_NULL;
2440 native->u.syment.n_sclass = class;
2442 if (bfd_is_und_section (symbol->section))
2444 native->u.syment.n_scnum = N_UNDEF;
2445 native->u.syment.n_value = symbol->value;
2447 else if (bfd_is_com_section (symbol->section))
2449 native->u.syment.n_scnum = N_UNDEF;
2450 native->u.syment.n_value = symbol->value;
2454 native->u.syment.n_scnum =
2455 symbol->section->output_section->target_index;
2456 native->u.syment.n_value = (symbol->value
2457 + symbol->section->output_offset);
2458 if (! obj_pe (abfd))
2459 native->u.syment.n_value += symbol->section->output_section->vma;
2461 /* Copy the any flags from the the file header into the symbol.
2463 native->u.syment.n_flags = bfd_asymbol_bfd (& csym->symbol)->flags;
2466 csym->native = native;
2470 csym->native->u.syment.n_sclass = class;