1 /* Support for the generic parts of COFF, for BFD.
2 Copyright 1990, 91, 92, 93, 94, 1995 Free Software Foundation, Inc.
3 Written by Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21 /* Most of this hacked by Steve Chamberlain, sac@cygnus.com.
22 Split out of coffcode.h by Ian Taylor, ian@cygnus.com. */
24 /* This file contains COFF code that is not dependent on any
25 particular COFF target. There is only one version of this file in
26 libbfd.a, so no target specific code may be put in here. Or, to
29 ********** DO NOT PUT TARGET SPECIFIC CODE IN THIS FILE **********
31 If you need to add some target specific behaviour, add a new hook
32 function to bfd_coff_backend_data.
34 Some of these functions are also called by the ECOFF routines.
35 Those functions may not use any COFF specific information, such as
41 #include "coff/internal.h"
44 static void coff_fix_symbol_name
45 PARAMS ((bfd *, asymbol *, combined_entry_type *, bfd_size_type *,
46 asection **, bfd_size_type *));
47 static boolean coff_write_symbol
48 PARAMS ((bfd *, asymbol *, combined_entry_type *, unsigned int *,
49 bfd_size_type *, asection **, bfd_size_type *));
50 static boolean coff_write_alien_symbol
51 PARAMS ((bfd *, asymbol *, unsigned int *, bfd_size_type *,
52 asection **, bfd_size_type *));
53 static boolean coff_write_native_symbol
54 PARAMS ((bfd *, coff_symbol_type *, unsigned int *, bfd_size_type *,
55 asection **, bfd_size_type *));
56 static void coff_pointerize_aux
57 PARAMS ((bfd *, combined_entry_type *, combined_entry_type *,
58 unsigned int, combined_entry_type *));
60 #define STRING_SIZE_SIZE (4)
62 /* Take a section header read from a coff file (in HOST byte order),
63 and make a BFD "section" out of it. This is used by ECOFF. */
65 make_a_section_from_file (abfd, hdr, target_index)
67 struct internal_scnhdr *hdr;
68 unsigned int target_index;
70 asection *return_section;
73 /* Assorted wastage to null-terminate the name, thanks AT&T! */
74 name = bfd_alloc (abfd, sizeof (hdr->s_name) + 1);
77 bfd_set_error (bfd_error_no_memory);
80 strncpy (name, (char *) &hdr->s_name[0], sizeof (hdr->s_name));
81 name[sizeof (hdr->s_name)] = 0;
83 return_section = bfd_make_section_anyway (abfd, name);
84 if (return_section == NULL)
87 /* s_paddr is presumed to be = to s_vaddr */
89 return_section->vma = hdr->s_vaddr;
90 return_section->lma = return_section->vma;
91 return_section->_raw_size = hdr->s_size;
92 return_section->filepos = hdr->s_scnptr;
93 return_section->rel_filepos = hdr->s_relptr;
94 return_section->reloc_count = hdr->s_nreloc;
96 bfd_coff_set_alignment_hook (abfd, return_section, hdr);
98 return_section->line_filepos = hdr->s_lnnoptr;
100 return_section->lineno_count = hdr->s_nlnno;
101 return_section->userdata = NULL;
102 return_section->next = (asection *) NULL;
103 return_section->flags = bfd_coff_styp_to_sec_flags_hook (abfd, hdr, name);
105 return_section->target_index = target_index;
107 /* At least on i386-coff, the line number count for a shared library
108 section must be ignored. */
109 if ((return_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
110 return_section->lineno_count = 0;
112 if (hdr->s_nreloc != 0)
113 return_section->flags |= SEC_RELOC;
114 /* FIXME: should this check 'hdr->s_size > 0' */
115 if (hdr->s_scnptr != 0)
116 return_section->flags |= SEC_HAS_CONTENTS;
120 /* Read in a COFF object and make it into a BFD. This is used by
123 static const bfd_target *
124 coff_real_object_p (abfd, nscns, internal_f, internal_a)
127 struct internal_filehdr *internal_f;
128 struct internal_aouthdr *internal_a;
130 flagword oflags = abfd->flags;
131 bfd_vma ostart = bfd_get_start_address (abfd);
133 size_t readsize; /* length of file_info */
135 char *external_sections;
137 if (!(internal_f->f_flags & F_RELFLG))
138 abfd->flags |= HAS_RELOC;
139 if ((internal_f->f_flags & F_EXEC))
140 abfd->flags |= EXEC_P;
141 if (!(internal_f->f_flags & F_LNNO))
142 abfd->flags |= HAS_LINENO;
143 if (!(internal_f->f_flags & F_LSYMS))
144 abfd->flags |= HAS_LOCALS;
146 /* FIXME: How can we set D_PAGED correctly? */
147 if ((internal_f->f_flags & F_EXEC) != 0)
148 abfd->flags |= D_PAGED;
150 bfd_get_symcount (abfd) = internal_f->f_nsyms;
151 if (internal_f->f_nsyms)
152 abfd->flags |= HAS_SYMS;
154 if (internal_a != (struct internal_aouthdr *) NULL)
155 bfd_get_start_address (abfd) = internal_a->entry;
157 bfd_get_start_address (abfd) = 0;
159 /* Set up the tdata area. ECOFF uses its own routine, and overrides
161 tdata = bfd_coff_mkobject_hook (abfd, (PTR) internal_f, (PTR) internal_a);
165 scnhsz = bfd_coff_scnhsz (abfd);
166 readsize = nscns * scnhsz;
167 external_sections = (char *) bfd_alloc (abfd, readsize);
168 if (!external_sections)
170 bfd_set_error (bfd_error_no_memory);
174 if (bfd_read ((PTR) external_sections, 1, readsize, abfd) != readsize)
177 /* Now copy data as required; construct all asections etc */
181 for (i = 0; i < nscns; i++)
183 struct internal_scnhdr tmp;
184 bfd_coff_swap_scnhdr_in (abfd,
185 (PTR) (external_sections + i * scnhsz),
187 make_a_section_from_file (abfd, &tmp, i + 1);
191 /* make_abs_section (abfd); */
193 if (bfd_coff_set_arch_mach_hook (abfd, (PTR) internal_f) == false)
199 bfd_release (abfd, tdata);
200 abfd->flags = oflags;
201 bfd_get_start_address (abfd) = ostart;
202 return (const bfd_target *) NULL;
205 /* Turn a COFF file into a BFD, but fail with bfd_error_wrong_format if it is
206 not a COFF file. This is also used by ECOFF. */
216 struct internal_filehdr internal_f;
217 struct internal_aouthdr internal_a;
219 /* figure out how much to read */
220 filhsz = bfd_coff_filhsz (abfd);
221 aoutsz = bfd_coff_aoutsz (abfd);
223 filehdr = bfd_alloc (abfd, filhsz);
226 if (bfd_read (filehdr, 1, filhsz, abfd) != filhsz)
228 if (bfd_get_error () != bfd_error_system_call)
229 bfd_set_error (bfd_error_wrong_format);
232 bfd_coff_swap_filehdr_in (abfd, filehdr, &internal_f);
233 bfd_release (abfd, filehdr);
235 if (bfd_coff_bad_format_hook (abfd, &internal_f) == false)
237 bfd_set_error (bfd_error_wrong_format);
240 nscns = internal_f.f_nscns;
242 if (internal_f.f_opthdr)
246 opthdr = bfd_alloc (abfd, aoutsz);
249 if (bfd_read (opthdr, 1, aoutsz, abfd) != aoutsz)
253 bfd_coff_swap_aouthdr_in (abfd, opthdr, (PTR) & internal_a);
256 /* Seek past the opt hdr stuff */
257 if (bfd_seek (abfd, (file_ptr) (internal_f.f_opthdr + filhsz), SEEK_SET)
261 return coff_real_object_p (abfd, nscns, &internal_f,
262 (internal_f.f_opthdr != 0
264 : (struct internal_aouthdr *) NULL));
267 /* Get the BFD section from a COFF symbol section number. */
270 coff_section_from_bfd_index (abfd, index)
274 struct sec *answer = abfd->sections;
277 return bfd_abs_section_ptr;
278 if (index == N_UNDEF)
279 return bfd_und_section_ptr;
280 if (index == N_DEBUG)
281 return bfd_abs_section_ptr;
285 if (answer->target_index == index)
287 answer = answer->next;
290 /* We should not reach this point, but the SCO 3.2v4 /lib/libc_s.a
291 has a bad symbol table in biglitpow.o. */
292 return bfd_und_section_ptr;
295 /* Get the upper bound of a COFF symbol table. */
298 coff_get_symtab_upper_bound (abfd)
301 if (!bfd_coff_slurp_symbol_table (abfd))
304 return (bfd_get_symcount (abfd) + 1) * (sizeof (coff_symbol_type *));
308 /* Canonicalize a COFF symbol table. */
311 coff_get_symtab (abfd, alocation)
315 unsigned int counter;
316 coff_symbol_type *symbase;
317 coff_symbol_type **location = (coff_symbol_type **) alocation;
319 if (!bfd_coff_slurp_symbol_table (abfd))
322 symbase = obj_symbols (abfd);
323 counter = bfd_get_symcount (abfd);
324 while (counter-- > 0)
325 *location++ = symbase++;
329 return bfd_get_symcount (abfd);
332 /* Set lineno_count for the output sections of a COFF file. */
335 coff_count_linenumbers (abfd)
338 unsigned int limit = bfd_get_symcount (abfd);
346 /* This may be from the backend linker, in which case the
347 lineno_count in the sections is correct. */
348 for (s = abfd->sections; s != NULL; s = s->next)
349 total += s->lineno_count;
353 for (s = abfd->sections; s != NULL; s = s->next)
354 BFD_ASSERT (s->lineno_count == 0);
356 for (p = abfd->outsymbols, i = 0; i < limit; i++, p++)
358 asymbol *q_maybe = *p;
360 if (bfd_asymbol_flavour (q_maybe) == bfd_target_coff_flavour)
362 coff_symbol_type *q = coffsymbol (q_maybe);
364 if (q->lineno != NULL)
366 /* This symbol has line numbers. Increment the owning
367 section's linenumber count. */
368 alent *l = q->lineno;
370 ++q->symbol.section->output_section->lineno_count;
373 while (l->line_number != 0)
376 ++q->symbol.section->output_section->lineno_count;
386 /* Takes a bfd and a symbol, returns a pointer to the coff specific
387 area of the symbol if there is one. */
391 coff_symbol_from (ignore_abfd, symbol)
395 if (bfd_asymbol_flavour (symbol) != bfd_target_coff_flavour)
396 return (coff_symbol_type *) NULL;
398 if (bfd_asymbol_bfd (symbol)->tdata.coff_obj_data == (coff_data_type *) NULL)
399 return (coff_symbol_type *) NULL;
401 return (coff_symbol_type *) symbol;
405 fixup_symbol_value (coff_symbol_ptr, syment)
406 coff_symbol_type *coff_symbol_ptr;
407 struct internal_syment *syment;
410 /* Normalize the symbol flags */
411 if (bfd_is_com_section (coff_symbol_ptr->symbol.section))
413 /* a common symbol is undefined with a value */
414 syment->n_scnum = N_UNDEF;
415 syment->n_value = coff_symbol_ptr->symbol.value;
417 else if (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING)
419 syment->n_value = coff_symbol_ptr->symbol.value;
421 else if (bfd_is_und_section (coff_symbol_ptr->symbol.section))
423 syment->n_scnum = N_UNDEF;
428 if (coff_symbol_ptr->symbol.section)
431 coff_symbol_ptr->symbol.section->output_section->target_index;
434 coff_symbol_ptr->symbol.value +
435 coff_symbol_ptr->symbol.section->output_offset +
436 coff_symbol_ptr->symbol.section->output_section->vma;
441 /* This can happen, but I don't know why yet (steve@cygnus.com) */
442 syment->n_scnum = N_ABS;
443 syment->n_value = coff_symbol_ptr->symbol.value;
448 /* Run through all the symbols in the symbol table and work out what
449 their indexes into the symbol table will be when output.
451 Coff requires that each C_FILE symbol points to the next one in the
452 chain, and that the last one points to the first external symbol. We
456 coff_renumber_symbols (bfd_ptr, first_undef)
460 unsigned int symbol_count = bfd_get_symcount (bfd_ptr);
461 asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
462 unsigned int native_index = 0;
463 struct internal_syment *last_file = (struct internal_syment *) NULL;
464 unsigned int symbol_index;
466 /* COFF demands that undefined symbols come after all other symbols.
467 Since we don't need to impose this extra knowledge on all our
468 client programs, deal with that here. Sort the symbol table;
469 just move the undefined symbols to the end, leaving the rest
470 alone. The O'Reilly book says that defined global symbols come
471 at the end before the undefined symbols, so we do that here as
473 /* @@ Do we have some condition we could test for, so we don't always
474 have to do this? I don't think relocatability is quite right, but
475 I'm not certain. [raeburn:19920508.1711EST] */
480 newsyms = (asymbol **) bfd_alloc_by_size_t (bfd_ptr,
482 * (symbol_count + 1));
485 bfd_set_error (bfd_error_no_memory);
488 bfd_ptr->outsymbols = newsyms;
489 for (i = 0; i < symbol_count; i++)
490 if (!bfd_is_und_section (symbol_ptr_ptr[i]->section)
491 && ((symbol_ptr_ptr[i]->flags & (BSF_GLOBAL
495 *newsyms++ = symbol_ptr_ptr[i];
497 for (i = 0; i < symbol_count; i++)
498 if (!bfd_is_und_section (symbol_ptr_ptr[i]->section)
499 && ((symbol_ptr_ptr[i]->flags & (BSF_GLOBAL
503 *newsyms++ = symbol_ptr_ptr[i];
505 *first_undef = newsyms - bfd_ptr->outsymbols;
507 for (i = 0; i < symbol_count; i++)
508 if (bfd_is_und_section (symbol_ptr_ptr[i]->section))
509 *newsyms++ = symbol_ptr_ptr[i];
510 *newsyms = (asymbol *) NULL;
511 symbol_ptr_ptr = bfd_ptr->outsymbols;
514 for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
516 coff_symbol_type *coff_symbol_ptr = coff_symbol_from (bfd_ptr, symbol_ptr_ptr[symbol_index]);
517 symbol_ptr_ptr[symbol_index]->udata.i = symbol_index;
518 if (coff_symbol_ptr && coff_symbol_ptr->native)
520 combined_entry_type *s = coff_symbol_ptr->native;
523 if (s->u.syment.n_sclass == C_FILE)
525 if (last_file != (struct internal_syment *) NULL)
526 last_file->n_value = native_index;
527 last_file = &(s->u.syment);
532 /* Modify the symbol values according to their section and
535 fixup_symbol_value (coff_symbol_ptr, &(s->u.syment));
537 for (i = 0; i < s->u.syment.n_numaux + 1; i++)
538 s[i].offset = native_index++;
545 obj_conv_table_size (bfd_ptr) = native_index;
550 /* Run thorough the symbol table again, and fix it so that all
551 pointers to entries are changed to the entries' index in the output
555 coff_mangle_symbols (bfd_ptr)
558 unsigned int symbol_count = bfd_get_symcount (bfd_ptr);
559 asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
560 unsigned int symbol_index;
562 for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
564 coff_symbol_type *coff_symbol_ptr =
565 coff_symbol_from (bfd_ptr, symbol_ptr_ptr[symbol_index]);
567 if (coff_symbol_ptr && coff_symbol_ptr->native)
570 combined_entry_type *s = coff_symbol_ptr->native;
574 /* FIXME: We should use a union here. */
575 s->u.syment.n_value =
576 ((combined_entry_type *) s->u.syment.n_value)->offset;
579 for (i = 0; i < s->u.syment.n_numaux; i++)
581 combined_entry_type *a = s + i + 1;
584 a->u.auxent.x_sym.x_tagndx.l =
585 a->u.auxent.x_sym.x_tagndx.p->offset;
590 a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l =
591 a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p->offset;
596 a->u.auxent.x_csect.x_scnlen.l =
597 a->u.auxent.x_csect.x_scnlen.p->offset;
606 coff_fix_symbol_name (abfd, symbol, native, string_size_p,
607 debug_string_section_p, debug_string_size_p)
610 combined_entry_type *native;
611 bfd_size_type *string_size_p;
612 asection **debug_string_section_p;
613 bfd_size_type *debug_string_size_p;
615 unsigned int name_length;
616 union internal_auxent *auxent;
617 char *name = (char *) (symbol->name);
619 if (name == (char *) NULL)
621 /* coff symbols always have names, so we'll make one up */
622 symbol->name = "strange";
623 name = (char *) symbol->name;
625 name_length = strlen (name);
627 if (native->u.syment.n_sclass == C_FILE)
629 strncpy (native->u.syment._n._n_name, ".file", SYMNMLEN);
630 auxent = &(native + 1)->u.auxent;
632 if (bfd_coff_long_filenames (abfd))
634 if (name_length <= FILNMLEN)
636 strncpy (auxent->x_file.x_fname, name, FILNMLEN);
640 auxent->x_file.x_n.x_offset = *string_size_p + STRING_SIZE_SIZE;
641 auxent->x_file.x_n.x_zeroes = 0;
642 *string_size_p += name_length + 1;
647 strncpy (auxent->x_file.x_fname, name, FILNMLEN);
648 if (name_length > FILNMLEN)
650 name[FILNMLEN] = '\0';
655 { /* NOT A C_FILE SYMBOL */
656 if (name_length <= SYMNMLEN)
658 /* This name will fit into the symbol neatly */
659 strncpy (native->u.syment._n._n_name, symbol->name, SYMNMLEN);
661 else if (!bfd_coff_symname_in_debug (abfd, &native->u.syment))
663 native->u.syment._n._n_n._n_offset = (*string_size_p
665 native->u.syment._n._n_n._n_zeroes = 0;
666 *string_size_p += name_length + 1;
673 /* This name should be written into the .debug section. For
674 some reason each name is preceded by a two byte length
675 and also followed by a null byte. FIXME: We assume that
676 the .debug section has already been created, and that it
678 if (*debug_string_section_p == (asection *) NULL)
679 *debug_string_section_p = bfd_get_section_by_name (abfd, ".debug");
680 filepos = bfd_tell (abfd);
681 bfd_put_16 (abfd, name_length + 1, buf);
682 if (!bfd_set_section_contents (abfd,
683 *debug_string_section_p,
685 (file_ptr) *debug_string_size_p,
687 || !bfd_set_section_contents (abfd,
688 *debug_string_section_p,
690 ((file_ptr) *debug_string_size_p
692 (bfd_size_type) name_length + 1))
694 if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
696 native->u.syment._n._n_n._n_offset = *debug_string_size_p + 2;
697 native->u.syment._n._n_n._n_zeroes = 0;
698 *debug_string_size_p += name_length + 3;
703 /* We need to keep track of the symbol index so that when we write out
704 the relocs we can get the index for a symbol. This method is a
707 #define set_index(symbol, idx) ((symbol)->udata.i = (idx))
709 /* Write a symbol out to a COFF file. */
712 coff_write_symbol (abfd, symbol, native, written, string_size_p,
713 debug_string_section_p, debug_string_size_p)
716 combined_entry_type *native;
717 unsigned int *written;
718 bfd_size_type *string_size_p;
719 asection **debug_string_section_p;
720 bfd_size_type *debug_string_size_p;
722 unsigned int numaux = native->u.syment.n_numaux;
723 int type = native->u.syment.n_type;
724 int class = native->u.syment.n_sclass;
726 bfd_size_type symesz;
728 if (native->u.syment.n_sclass == C_FILE)
729 symbol->flags |= BSF_DEBUGGING;
731 if (symbol->flags & BSF_DEBUGGING)
733 native->u.syment.n_scnum = N_DEBUG;
735 else if (bfd_is_abs_section (symbol->section))
737 native->u.syment.n_scnum = N_ABS;
739 else if (bfd_is_und_section (symbol->section))
741 native->u.syment.n_scnum = N_UNDEF;
745 native->u.syment.n_scnum =
746 symbol->section->output_section->target_index;
749 coff_fix_symbol_name (abfd, symbol, native, string_size_p,
750 debug_string_section_p, debug_string_size_p);
752 symesz = bfd_coff_symesz (abfd);
753 buf = bfd_alloc (abfd, symesz);
756 bfd_set_error (bfd_error_no_memory);
759 bfd_coff_swap_sym_out (abfd, &native->u.syment, buf);
760 if (bfd_write (buf, 1, symesz, abfd) != symesz)
762 bfd_release (abfd, buf);
764 if (native->u.syment.n_numaux > 0)
766 bfd_size_type auxesz;
769 auxesz = bfd_coff_auxesz (abfd);
770 buf = bfd_alloc (abfd, auxesz);
773 bfd_set_error (bfd_error_no_memory);
776 for (j = 0; j < native->u.syment.n_numaux; j++)
778 bfd_coff_swap_aux_out (abfd,
779 &((native + j + 1)->u.auxent),
783 native->u.syment.n_numaux,
785 if (bfd_write (buf, 1, auxesz, abfd) != auxesz)
788 bfd_release (abfd, buf);
791 /* Store the index for use when we write out the relocs. */
792 set_index (symbol, *written);
794 *written += numaux + 1;
798 /* Write out a symbol to a COFF file that does not come from a COFF
799 file originally. This symbol may have been created by the linker,
800 or we may be linking a non COFF file to a COFF file. */
803 coff_write_alien_symbol (abfd, symbol, written, string_size_p,
804 debug_string_section_p, debug_string_size_p)
807 unsigned int *written;
808 bfd_size_type *string_size_p;
809 asection **debug_string_section_p;
810 bfd_size_type *debug_string_size_p;
812 combined_entry_type *native;
813 combined_entry_type dummy;
816 native->u.syment.n_type = T_NULL;
817 native->u.syment.n_flags = 0;
818 if (bfd_is_und_section (symbol->section))
820 native->u.syment.n_scnum = N_UNDEF;
821 native->u.syment.n_value = symbol->value;
823 else if (bfd_is_com_section (symbol->section))
825 native->u.syment.n_scnum = N_UNDEF;
826 native->u.syment.n_value = symbol->value;
828 else if (symbol->flags & BSF_DEBUGGING)
830 /* There isn't much point to writing out a debugging symbol
831 unless we are prepared to convert it into COFF debugging
832 format. So, we just ignore them. We must clobber the symbol
833 name to keep it from being put in the string table. */
839 native->u.syment.n_scnum =
840 symbol->section->output_section->target_index;
841 native->u.syment.n_value = (symbol->value
842 + symbol->section->output_section->vma
843 + symbol->section->output_offset);
845 /* Copy the any flags from the the file header into the symbol.
848 coff_symbol_type *c = coff_symbol_from (abfd, symbol);
849 if (c != (coff_symbol_type *) NULL)
850 native->u.syment.n_flags = bfd_asymbol_bfd (&c->symbol)->flags;
854 native->u.syment.n_type = 0;
855 if (symbol->flags & BSF_LOCAL)
856 native->u.syment.n_sclass = C_STAT;
858 native->u.syment.n_sclass = C_EXT;
859 native->u.syment.n_numaux = 0;
861 return coff_write_symbol (abfd, symbol, native, written, string_size_p,
862 debug_string_section_p, debug_string_size_p);
865 /* Write a native symbol to a COFF file. */
868 coff_write_native_symbol (abfd, symbol, written, string_size_p,
869 debug_string_section_p, debug_string_size_p)
871 coff_symbol_type *symbol;
872 unsigned int *written;
873 bfd_size_type *string_size_p;
874 asection **debug_string_section_p;
875 bfd_size_type *debug_string_size_p;
877 combined_entry_type *native = symbol->native;
878 alent *lineno = symbol->lineno;
880 /* If this symbol has an associated line number, we must store the
881 symbol index in the line number field. We also tag the auxent to
882 point to the right place in the lineno table. */
883 if (lineno && !symbol->done_lineno)
885 unsigned int count = 0;
886 lineno[count].u.offset = *written;
887 if (native->u.syment.n_numaux)
889 union internal_auxent *a = &((native + 1)->u.auxent);
891 a->x_sym.x_fcnary.x_fcn.x_lnnoptr =
892 symbol->symbol.section->output_section->moving_line_filepos;
895 /* Count and relocate all other linenumbers. */
897 while (lineno[count].line_number != 0)
901 I've been told this, but still need proof:
902 > The second bug is also in `bfd/coffcode.h'. This bug
903 > causes the linker to screw up the pc-relocations for
904 > all the line numbers in COFF code. This bug isn't only
905 > specific to A29K implementations, but affects all
906 > systems using COFF format binaries. Note that in COFF
907 > object files, the line number core offsets output by
908 > the assembler are relative to the start of each
909 > procedure, not to the start of the .text section. This
910 > patch relocates the line numbers relative to the
911 > `native->u.syment.n_value' instead of the section
913 > modular!olson@cs.arizona.edu (Jon Olson)
915 lineno[count].u.offset += native->u.syment.n_value;
917 lineno[count].u.offset +=
918 (symbol->symbol.section->output_section->vma
919 + symbol->symbol.section->output_offset);
923 symbol->done_lineno = true;
925 symbol->symbol.section->output_section->moving_line_filepos +=
926 count * bfd_coff_linesz (abfd);
929 return coff_write_symbol (abfd, &(symbol->symbol), native, written,
930 string_size_p, debug_string_section_p,
931 debug_string_size_p);
934 /* Write out the COFF symbols. */
937 coff_write_symbols (abfd)
940 bfd_size_type string_size;
941 asection *debug_string_section;
942 bfd_size_type debug_string_size;
944 unsigned int limit = bfd_get_symcount (abfd);
945 unsigned int written = 0;
949 debug_string_section = NULL;
950 debug_string_size = 0;
952 /* Seek to the right place */
953 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0)
956 /* Output all the symbols we have */
959 for (p = abfd->outsymbols, i = 0; i < limit; i++, p++)
961 asymbol *symbol = *p;
962 coff_symbol_type *c_symbol = coff_symbol_from (abfd, symbol);
964 if (c_symbol == (coff_symbol_type *) NULL
965 || c_symbol->native == (combined_entry_type *) NULL)
967 if (!coff_write_alien_symbol (abfd, symbol, &written, &string_size,
968 &debug_string_section,
974 if (!coff_write_native_symbol (abfd, c_symbol, &written,
975 &string_size, &debug_string_section,
981 obj_raw_syment_count (abfd) = written;
983 /* Now write out strings */
985 if (string_size != 0)
987 unsigned int size = string_size + STRING_SIZE_SIZE;
988 bfd_byte buffer[STRING_SIZE_SIZE];
990 #if STRING_SIZE_SIZE == 4
991 bfd_h_put_32 (abfd, size, buffer);
993 #error Change bfd_h_put_32
995 if (bfd_write ((PTR) buffer, 1, sizeof (buffer), abfd) != sizeof (buffer))
997 for (p = abfd->outsymbols, i = 0;
1002 size_t name_length = strlen (q->name);
1003 coff_symbol_type *c_symbol = coff_symbol_from (abfd, q);
1006 /* Figure out whether the symbol name should go in the string
1007 table. Symbol names that are short enough are stored
1008 directly in the syment structure. File names permit a
1009 different, longer, length in the syment structure. On
1010 XCOFF, some symbol names are stored in the .debug section
1011 rather than in the string table. */
1013 if (c_symbol == NULL
1014 || c_symbol->native == NULL)
1016 /* This is not a COFF symbol, so it certainly is not a
1017 file name, nor does it go in the .debug section. */
1020 else if (bfd_coff_symname_in_debug (abfd,
1021 &c_symbol->native->u.syment))
1023 /* This symbol name is in the XCOFF .debug section.
1024 Don't write it into the string table. */
1025 maxlen = name_length;
1027 else if (c_symbol->native->u.syment.n_sclass == C_FILE)
1032 if (name_length > maxlen)
1034 if (bfd_write ((PTR) (q->name), 1, name_length + 1, abfd)
1042 /* We would normally not write anything here, but we'll write
1043 out 4 so that any stupid coff reader which tries to read the
1044 string table even when there isn't one won't croak. */
1045 unsigned int size = STRING_SIZE_SIZE;
1046 bfd_byte buffer[STRING_SIZE_SIZE];
1048 #if STRING_SIZE_SIZE == 4
1049 bfd_h_put_32 (abfd, size, buffer);
1051 #error Change bfd_h_put_32
1053 if (bfd_write ((PTR) buffer, 1, STRING_SIZE_SIZE, abfd)
1054 != STRING_SIZE_SIZE)
1058 /* Make sure the .debug section was created to be the correct size.
1059 We should create it ourselves on the fly, but we don't because
1060 BFD won't let us write to any section until we know how large all
1061 the sections are. We could still do it by making another pass
1062 over the symbols. FIXME. */
1063 BFD_ASSERT (debug_string_size == 0
1064 || (debug_string_section != (asection *) NULL
1065 && (BFD_ALIGN (debug_string_size,
1066 1 << debug_string_section->alignment_power)
1067 == bfd_section_size (abfd, debug_string_section))));
1073 coff_write_linenumbers (abfd)
1077 bfd_size_type linesz;
1080 linesz = bfd_coff_linesz (abfd);
1081 buff = bfd_alloc (abfd, linesz);
1084 bfd_set_error (bfd_error_no_memory);
1087 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
1089 if (s->lineno_count)
1091 asymbol **q = abfd->outsymbols;
1092 if (bfd_seek (abfd, s->line_filepos, SEEK_SET) != 0)
1094 /* Find all the linenumbers in this section */
1098 if (p->section->output_section == s)
1101 BFD_SEND (bfd_asymbol_bfd (p), _get_lineno,
1102 (bfd_asymbol_bfd (p), p));
1105 /* Found a linenumber entry, output */
1106 struct internal_lineno out;
1107 memset ((PTR) & out, 0, sizeof (out));
1109 out.l_addr.l_symndx = l->u.offset;
1110 bfd_coff_swap_lineno_out (abfd, &out, buff);
1111 if (bfd_write (buff, 1, linesz, abfd) != linesz)
1114 while (l->line_number)
1116 out.l_lnno = l->line_number;
1117 out.l_addr.l_symndx = l->u.offset;
1118 bfd_coff_swap_lineno_out (abfd, &out, buff);
1119 if (bfd_write (buff, 1, linesz, abfd) != linesz)
1129 bfd_release (abfd, buff);
1135 coff_get_lineno (ignore_abfd, symbol)
1139 return coffsymbol (symbol)->lineno;
1143 coff_section_symbol (abfd, name)
1147 asection *sec = bfd_make_section_old_way (abfd, name);
1149 combined_entry_type *csym;
1152 csym = coff_symbol_from (abfd, sym)->native;
1153 /* Make sure back-end COFF stuff is there. */
1158 coff_symbol_type sym;
1159 /* @@FIXME This shouldn't use a fixed size!! */
1160 combined_entry_type e[10];
1163 f = (struct foo *) bfd_alloc_by_size_t (abfd, sizeof (*f));
1166 bfd_set_error (bfd_error_no_error);
1169 memset ((char *) f, 0, sizeof (*f));
1170 coff_symbol_from (abfd, sym)->native = csym = f->e;
1172 csym[0].u.syment.n_sclass = C_STAT;
1173 csym[0].u.syment.n_numaux = 1;
1174 /* SF_SET_STATICS (sym); @@ ??? */
1175 csym[1].u.auxent.x_scn.x_scnlen = sec->_raw_size;
1176 csym[1].u.auxent.x_scn.x_nreloc = sec->reloc_count;
1177 csym[1].u.auxent.x_scn.x_nlinno = sec->lineno_count;
1179 if (sec->output_section == NULL)
1181 sec->output_section = sec;
1182 sec->output_offset = 0;
1188 /* This function transforms the offsets into the symbol table into
1189 pointers to syments. */
1192 coff_pointerize_aux (abfd, table_base, symbol, indaux, auxent)
1194 combined_entry_type *table_base;
1195 combined_entry_type *symbol;
1196 unsigned int indaux;
1197 combined_entry_type *auxent;
1199 int type = symbol->u.syment.n_type;
1200 int class = symbol->u.syment.n_sclass;
1202 if (coff_backend_info (abfd)->_bfd_coff_pointerize_aux_hook)
1204 if ((*coff_backend_info (abfd)->_bfd_coff_pointerize_aux_hook)
1205 (abfd, table_base, symbol, indaux, auxent))
1209 /* Don't bother if this is a file or a section */
1210 if (class == C_STAT && type == T_NULL)
1212 if (class == C_FILE)
1215 /* Otherwise patch up */
1216 #define N_TMASK coff_data (abfd)->local_n_tmask
1217 #define N_BTSHFT coff_data (abfd)->local_n_btshft
1218 if ((ISFCN (type) || ISTAG (class) || class == C_BLOCK)
1219 && auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l > 0)
1221 auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p =
1222 table_base + auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l;
1223 auxent->fix_end = 1;
1225 /* A negative tagndx is meaningless, but the SCO 3.2v4 cc can
1226 generate one, so we must be careful to ignore it. */
1227 if (auxent->u.auxent.x_sym.x_tagndx.l > 0)
1229 auxent->u.auxent.x_sym.x_tagndx.p =
1230 table_base + auxent->u.auxent.x_sym.x_tagndx.l;
1231 auxent->fix_tag = 1;
1235 /* Allocate space for the ".debug" section, and read it.
1236 We did not read the debug section until now, because
1237 we didn't want to go to the trouble until someone needed it. */
1240 build_debug_section (abfd)
1243 char *debug_section;
1246 asection *sect = bfd_get_section_by_name (abfd, ".debug");
1250 bfd_set_error (bfd_error_no_debug_section);
1254 debug_section = (PTR) bfd_alloc (abfd,
1255 bfd_get_section_size_before_reloc (sect));
1256 if (debug_section == NULL)
1258 bfd_set_error (bfd_error_no_memory);
1262 /* Seek to the beginning of the `.debug' section and read it.
1263 Save the current position first; it is needed by our caller.
1264 Then read debug section and reset the file pointer. */
1266 position = bfd_tell (abfd);
1267 if (bfd_seek (abfd, sect->filepos, SEEK_SET) != 0
1268 || (bfd_read (debug_section,
1269 bfd_get_section_size_before_reloc (sect), 1, abfd)
1270 != bfd_get_section_size_before_reloc (sect))
1271 || bfd_seek (abfd, position, SEEK_SET) != 0)
1273 return debug_section;
1277 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
1278 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
1279 be \0-terminated. */
1281 copy_name (abfd, name, maxlen)
1289 for (len = 0; len < maxlen; ++len)
1291 if (name[len] == '\0')
1297 if ((newname = (PTR) bfd_alloc (abfd, len + 1)) == NULL)
1299 bfd_set_error (bfd_error_no_memory);
1302 strncpy (newname, name, len);
1303 newname[len] = '\0';
1307 /* Read in the external symbols. */
1310 _bfd_coff_get_external_symbols (abfd)
1313 bfd_size_type symesz;
1317 if (obj_coff_external_syms (abfd) != NULL)
1320 symesz = bfd_coff_symesz (abfd);
1322 size = obj_raw_syment_count (abfd) * symesz;
1324 syms = malloc (size);
1325 if (syms == NULL && size != 0)
1327 bfd_set_error (bfd_error_no_memory);
1331 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
1332 || bfd_read (syms, size, 1, abfd) != size)
1339 obj_coff_external_syms (abfd) = syms;
1344 /* Read in the external strings. The strings are not loaded until
1345 they are needed. This is because we have no simple way of
1346 detecting a missing string table in an archive. */
1349 _bfd_coff_read_string_table (abfd)
1352 char extstrsize[STRING_SIZE_SIZE];
1356 if (obj_coff_strings (abfd) != NULL)
1357 return obj_coff_strings (abfd);
1360 (obj_sym_filepos (abfd)
1361 + obj_raw_syment_count (abfd) * bfd_coff_symesz (abfd)),
1365 if (bfd_read (extstrsize, sizeof extstrsize, 1, abfd) != sizeof extstrsize)
1367 if (bfd_get_error () != bfd_error_file_truncated)
1370 /* There is no string table. */
1371 strsize = STRING_SIZE_SIZE;
1375 #if STRING_SIZE_SIZE == 4
1376 strsize = bfd_h_get_32 (abfd, (bfd_byte *) extstrsize);
1378 #error Change bfd_h_get_32
1382 strings = malloc (strsize);
1383 if (strings == NULL)
1385 bfd_set_error (bfd_error_no_memory);
1389 if (bfd_read (strings + STRING_SIZE_SIZE,
1390 strsize - STRING_SIZE_SIZE, 1, abfd)
1391 != strsize - STRING_SIZE_SIZE)
1397 obj_coff_strings (abfd) = strings;
1402 /* Free up the external symbols and strings read from a COFF file. */
1405 _bfd_coff_free_symbols (abfd)
1408 if (obj_coff_external_syms (abfd) != NULL
1409 && ! obj_coff_keep_syms (abfd))
1411 free (obj_coff_external_syms (abfd));
1412 obj_coff_external_syms (abfd) = NULL;
1414 if (obj_coff_strings (abfd) != NULL
1415 && ! obj_coff_keep_strings (abfd))
1417 free (obj_coff_strings (abfd));
1418 obj_coff_strings (abfd) = NULL;
1423 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
1424 knit the symbol names into a normalized form. By normalized here I
1425 mean that all symbols have an n_offset pointer that points to a null-
1426 terminated string. */
1428 combined_entry_type *
1429 coff_get_normalized_symtab (abfd)
1432 combined_entry_type *internal;
1433 combined_entry_type *internal_ptr;
1434 combined_entry_type *symbol_ptr;
1435 combined_entry_type *internal_end;
1436 bfd_size_type symesz;
1439 const char *string_table = NULL;
1440 char *debug_section = NULL;
1443 if (obj_raw_syments (abfd) != NULL)
1444 return obj_raw_syments (abfd);
1446 size = obj_raw_syment_count (abfd) * sizeof (combined_entry_type);
1447 internal = (combined_entry_type *) bfd_alloc (abfd, size);
1448 if (internal == NULL && size != 0)
1450 bfd_set_error (bfd_error_no_memory);
1453 internal_end = internal + obj_raw_syment_count (abfd);
1455 if (! _bfd_coff_get_external_symbols (abfd))
1458 raw_src = (char *) obj_coff_external_syms (abfd);
1460 /* mark the end of the symbols */
1461 symesz = bfd_coff_symesz (abfd);
1462 raw_end = (char *) raw_src + obj_raw_syment_count (abfd) * symesz;
1464 /* FIXME SOMEDAY. A string table size of zero is very weird, but
1465 probably possible. If one shows up, it will probably kill us. */
1467 /* Swap all the raw entries */
1468 for (internal_ptr = internal;
1470 raw_src += symesz, internal_ptr++)
1474 bfd_coff_swap_sym_in (abfd, (PTR) raw_src,
1475 (PTR) & internal_ptr->u.syment);
1476 internal_ptr->fix_value = 0;
1477 internal_ptr->fix_tag = 0;
1478 internal_ptr->fix_end = 0;
1479 internal_ptr->fix_scnlen = 0;
1480 symbol_ptr = internal_ptr;
1483 i < symbol_ptr->u.syment.n_numaux;
1489 internal_ptr->fix_value = 0;
1490 internal_ptr->fix_tag = 0;
1491 internal_ptr->fix_end = 0;
1492 internal_ptr->fix_scnlen = 0;
1493 bfd_coff_swap_aux_in (abfd, (PTR) raw_src,
1494 symbol_ptr->u.syment.n_type,
1495 symbol_ptr->u.syment.n_sclass,
1496 i, symbol_ptr->u.syment.n_numaux,
1497 &(internal_ptr->u.auxent));
1498 coff_pointerize_aux (abfd, internal, symbol_ptr, i,
1503 /* Free the raw symbols, but not the strings (if we have them). */
1504 obj_coff_keep_strings (abfd) = true;
1505 if (! _bfd_coff_free_symbols (abfd))
1508 for (internal_ptr = internal; internal_ptr < internal_end;
1511 if (internal_ptr->u.syment.n_sclass == C_FILE
1512 && internal_ptr->u.syment.n_numaux > 0)
1514 /* make a file symbol point to the name in the auxent, since
1515 the text ".file" is redundant */
1516 if ((internal_ptr + 1)->u.auxent.x_file.x_n.x_zeroes == 0)
1518 /* the filename is a long one, point into the string table */
1519 if (string_table == NULL)
1521 string_table = _bfd_coff_read_string_table (abfd);
1522 if (string_table == NULL)
1526 internal_ptr->u.syment._n._n_n._n_offset =
1529 + (internal_ptr + 1)->u.auxent.x_file.x_n.x_offset));
1533 /* ordinary short filename, put into memory anyway */
1534 internal_ptr->u.syment._n._n_n._n_offset = (long)
1535 copy_name (abfd, (internal_ptr + 1)->u.auxent.x_file.x_fname,
1541 if (internal_ptr->u.syment._n._n_n._n_zeroes != 0)
1543 /* This is a "short" name. Make it long. */
1544 unsigned long i = 0;
1545 char *newstring = NULL;
1547 /* find the length of this string without walking into memory
1549 for (i = 0; i < 8; ++i)
1551 if (internal_ptr->u.syment._n._n_name[i] == '\0')
1554 } /* if end of string */
1555 } /* possible lengths of this string. */
1557 if ((newstring = (PTR) bfd_alloc (abfd, ++i)) == NULL)
1559 bfd_set_error (bfd_error_no_memory);
1562 memset (newstring, 0, i);
1563 strncpy (newstring, internal_ptr->u.syment._n._n_name, i - 1);
1564 internal_ptr->u.syment._n._n_n._n_offset = (long int) newstring;
1565 internal_ptr->u.syment._n._n_n._n_zeroes = 0;
1567 else if (internal_ptr->u.syment._n._n_n._n_offset == 0)
1568 internal_ptr->u.syment._n._n_n._n_offset = (long int) "";
1569 else if (!bfd_coff_symname_in_debug (abfd, &internal_ptr->u.syment))
1571 /* Long name already. Point symbol at the string in the
1573 if (string_table == NULL)
1575 string_table = _bfd_coff_read_string_table (abfd);
1576 if (string_table == NULL)
1579 internal_ptr->u.syment._n._n_n._n_offset =
1582 + internal_ptr->u.syment._n._n_n._n_offset));
1586 /* Long name in debug section. Very similar. */
1587 if (debug_section == NULL)
1588 debug_section = build_debug_section (abfd);
1589 internal_ptr->u.syment._n._n_n._n_offset = (long int)
1590 (debug_section + internal_ptr->u.syment._n._n_n._n_offset);
1593 internal_ptr += internal_ptr->u.syment.n_numaux;
1596 obj_raw_syments (abfd) = internal;
1597 BFD_ASSERT (obj_raw_syment_count (abfd)
1598 == (unsigned int) (internal_ptr - internal));
1601 } /* coff_get_normalized_symtab() */
1604 coff_get_reloc_upper_bound (abfd, asect)
1608 if (bfd_get_format (abfd) != bfd_object)
1610 bfd_set_error (bfd_error_invalid_operation);
1613 return (asect->reloc_count + 1) * sizeof (arelent *);
1617 coff_make_empty_symbol (abfd)
1620 coff_symbol_type *new = (coff_symbol_type *) bfd_alloc (abfd, sizeof (coff_symbol_type));
1623 bfd_set_error (bfd_error_no_memory);
1626 memset (new, 0, sizeof *new);
1627 new->symbol.section = 0;
1629 new->lineno = (alent *) NULL;
1630 new->done_lineno = false;
1631 new->symbol.the_bfd = abfd;
1632 return &new->symbol;
1635 /* Make a debugging symbol. */
1638 coff_bfd_make_debug_symbol (abfd, ptr, sz)
1643 coff_symbol_type *new = (coff_symbol_type *) bfd_alloc (abfd, sizeof (coff_symbol_type));
1646 bfd_set_error (bfd_error_no_memory);
1649 /* @@ This shouldn't be using a constant multiplier. */
1650 new->native = (combined_entry_type *) bfd_zalloc (abfd, sizeof (combined_entry_type) * 10);
1653 bfd_set_error (bfd_error_no_memory);
1656 new->symbol.section = bfd_abs_section_ptr;
1657 new->symbol.flags = BSF_DEBUGGING;
1658 new->lineno = (alent *) NULL;
1659 new->done_lineno = false;
1660 new->symbol.the_bfd = abfd;
1661 return &new->symbol;
1666 coff_get_symbol_info (abfd, symbol, ret)
1671 bfd_symbol_info (symbol, ret);
1674 /* Print out information about COFF symbol. */
1677 coff_print_symbol (abfd, filep, symbol, how)
1681 bfd_print_symbol_type how;
1683 FILE *file = (FILE *) filep;
1687 case bfd_print_symbol_name:
1688 fprintf (file, "%s", symbol->name);
1691 case bfd_print_symbol_more:
1692 fprintf (file, "coff %s %s",
1693 coffsymbol (symbol)->native ? "n" : "g",
1694 coffsymbol (symbol)->lineno ? "l" : " ");
1697 case bfd_print_symbol_all:
1698 if (coffsymbol (symbol)->native)
1701 combined_entry_type *combined = coffsymbol (symbol)->native;
1702 combined_entry_type *root = obj_raw_syments (abfd);
1703 struct lineno_cache_entry *l = coffsymbol (symbol)->lineno;
1705 fprintf (file, "[%3ld]", (long) (combined - root));
1708 "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x%08lx %s",
1709 combined->u.syment.n_scnum,
1710 combined->u.syment.n_flags,
1711 combined->u.syment.n_type,
1712 combined->u.syment.n_sclass,
1713 combined->u.syment.n_numaux,
1714 (unsigned long) combined->u.syment.n_value,
1717 for (aux = 0; aux < combined->u.syment.n_numaux; aux++)
1719 combined_entry_type *auxp = combined + aux + 1;
1723 tagndx = auxp->u.auxent.x_sym.x_tagndx.p - root;
1725 tagndx = auxp->u.auxent.x_sym.x_tagndx.l;
1727 fprintf (file, "\n");
1728 switch (combined->u.syment.n_sclass)
1731 fprintf (file, "File ");
1735 if (combined->u.syment.n_type == T_NULL)
1736 /* probably a section symbol? */
1738 fprintf (file, "AUX scnlen 0x%lx nreloc %d nlnno %d",
1739 (long) auxp->u.auxent.x_scn.x_scnlen,
1740 auxp->u.auxent.x_scn.x_nreloc,
1741 auxp->u.auxent.x_scn.x_nlinno);
1744 /* else fall through */
1747 fprintf (file, "AUX lnno %d size 0x%x tagndx %ld",
1748 auxp->u.auxent.x_sym.x_misc.x_lnsz.x_lnno,
1749 auxp->u.auxent.x_sym.x_misc.x_lnsz.x_size,
1752 fprintf (file, " endndx %ld",
1754 (auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p
1762 fprintf (file, "\n%s :", l->u.sym->name);
1764 while (l->line_number)
1766 fprintf (file, "\n%4d : 0x%lx",
1769 (l->u.offset + symbol->section->vma)));
1776 bfd_print_symbol_vandf ((PTR) file, symbol);
1777 fprintf (file, " %-5s %s %s %s",
1778 symbol->section->name,
1779 coffsymbol (symbol)->native ? "n" : "g",
1780 coffsymbol (symbol)->lineno ? "l" : " ",
1786 /* Provided a BFD, a section and an offset into the section, calculate
1787 and return the name of the source file and the line nearest to the
1792 coff_find_nearest_line (abfd, section, ignore_symbols, offset, filename_ptr,
1793 functionname_ptr, line_ptr)
1796 asymbol **ignore_symbols;
1798 CONST char **filename_ptr;
1799 CONST char **functionname_ptr;
1800 unsigned int *line_ptr;
1803 unsigned int line_base;
1804 coff_data_type *cof = coff_data (abfd);
1805 /* Run through the raw syments if available */
1806 combined_entry_type *p;
1807 combined_entry_type *pend;
1809 struct coff_section_tdata *sec_data;
1812 *functionname_ptr = 0;
1815 /* Don't try and find line numbers in a non coff file */
1816 if (abfd->xvec->flavour != bfd_target_coff_flavour)
1822 /* Find the first C_FILE symbol. */
1823 p = cof->raw_syments;
1824 pend = p + cof->raw_syment_count;
1827 if (p->u.syment.n_sclass == C_FILE)
1829 p += 1 + p->u.syment.n_numaux;
1836 /* Look through the C_FILE symbols to find the best one. */
1837 *filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
1838 maxdiff = (bfd_vma) 0 - (bfd_vma) 1;
1841 combined_entry_type *p2;
1843 for (p2 = p + 1 + p->u.syment.n_numaux;
1845 p2 += 1 + p2->u.syment.n_numaux)
1847 if (p2->u.syment.n_scnum > 0
1849 == coff_section_from_bfd_index (abfd,
1850 p2->u.syment.n_scnum)))
1852 if (p2->u.syment.n_sclass == C_FILE)
1860 && offset >= (bfd_vma) p2->u.syment.n_value
1861 && offset - (bfd_vma) p2->u.syment.n_value < maxdiff)
1863 *filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
1864 maxdiff = offset - p2->u.syment.n_value;
1867 /* Avoid endless loops on erroneous files by ensuring that
1868 we always move forward in the file. */
1869 if (p - cof->raw_syments >= p->u.syment.n_value)
1872 p = cof->raw_syments + p->u.syment.n_value;
1873 if (p > pend || p->u.syment.n_sclass != C_FILE)
1878 /* Now wander though the raw linenumbers of the section */
1879 /* If we have been called on this section before, and the offset we
1880 want is further down then we can prime the lookup loop. */
1881 sec_data = coff_section_data (abfd, section);
1882 if (sec_data != NULL
1884 && offset >= sec_data->offset)
1887 *functionname_ptr = sec_data->function;
1888 line_base = sec_data->line_base;
1896 l = §ion->lineno[i];
1898 for (; i < section->lineno_count; i++)
1900 if (l->line_number == 0)
1902 /* Get the symbol this line number points at */
1903 coff_symbol_type *coff = (coff_symbol_type *) (l->u.sym);
1904 if (coff->symbol.value > offset)
1906 *functionname_ptr = coff->symbol.name;
1909 combined_entry_type *s = coff->native;
1910 s = s + 1 + s->u.syment.n_numaux;
1912 /* In XCOFF a debugging symbol can follow the function
1914 if (s->u.syment.n_scnum == N_DEBUG)
1915 s = s + 1 + s->u.syment.n_numaux;
1918 S should now point to the .bf of the function
1920 if (s->u.syment.n_numaux)
1923 The linenumber is stored in the auxent
1925 union internal_auxent *a = &((s + 1)->u.auxent);
1926 line_base = a->x_sym.x_misc.x_lnsz.x_lnno;
1927 *line_ptr = line_base;
1933 if (l->u.offset + bfd_get_section_vma (abfd, section) > offset)
1935 *line_ptr = l->line_number + line_base - 1;
1940 /* Cache the results for the next call. */
1941 if (sec_data == NULL)
1943 section->used_by_bfd =
1944 ((PTR) bfd_zalloc (abfd,
1945 sizeof (struct coff_section_tdata)));
1946 sec_data = section->used_by_bfd;
1948 if (sec_data != NULL)
1950 sec_data->offset = offset;
1952 sec_data->function = *functionname_ptr;
1953 sec_data->line_base = line_base;
1960 coff_sizeof_headers (abfd, reloc)
1968 size = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
1972 size = bfd_coff_filhsz (abfd);
1975 size += abfd->section_count * bfd_coff_scnhsz (abfd);