1 /* Support for the generic parts of COFF, for BFD.
2 Copyright 1990, 1991, 1992, 1993, 1994 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., 675 Mass Ave, Cambridge, MA 02139, 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 boolean coff_write_symbol PARAMS ((bfd *, asymbol *,
45 combined_entry_type *,
47 static boolean coff_write_alien_symbol PARAMS ((bfd *, asymbol *,
49 static boolean coff_write_native_symbol PARAMS ((bfd *, coff_symbol_type *,
52 static asection bfd_debug_section = { "*DEBUG*" };
54 #define STRING_SIZE_SIZE (4)
56 /* Take a section header read from a coff file (in HOST byte order),
57 and make a BFD "section" out of it. This is used by ECOFF. */
59 make_a_section_from_file (abfd, hdr, target_index)
61 struct internal_scnhdr *hdr;
62 unsigned int target_index;
64 asection *return_section;
67 /* Assorted wastage to null-terminate the name, thanks AT&T! */
68 name = bfd_alloc(abfd, sizeof (hdr->s_name)+1);
70 bfd_set_error (bfd_error_no_memory);
73 strncpy(name, (char *) &hdr->s_name[0], sizeof (hdr->s_name));
74 name[sizeof (hdr->s_name)] = 0;
76 return_section = bfd_make_section(abfd, name);
77 if (return_section == NULL)
78 return_section = bfd_coff_make_section_hook (abfd, name);
80 /* Handle several sections of the same name. For example, if an executable
81 has two .bss sections, GDB better be able to find both of them
83 if (return_section == NULL)
84 return_section = bfd_make_section_anyway (abfd, name);
86 if (return_section == NULL)
89 /* s_paddr is presumed to be = to s_vaddr */
91 return_section->vma = hdr->s_vaddr;
92 return_section->_raw_size = hdr->s_size;
93 return_section->filepos = hdr->s_scnptr;
94 return_section->rel_filepos = hdr->s_relptr;
95 return_section->reloc_count = hdr->s_nreloc;
97 bfd_coff_set_alignment_hook (abfd, return_section, hdr);
99 return_section->line_filepos = hdr->s_lnnoptr;
101 return_section->lineno_count = hdr->s_nlnno;
102 return_section->userdata = NULL;
103 return_section->next = (asection *) NULL;
104 return_section->flags = bfd_coff_styp_to_sec_flags_hook (abfd, hdr, name);
106 return_section->target_index = target_index;
108 /* At least on i386-coff, the line number count for a shared library
109 section must be ignored. */
110 if ((return_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
111 return_section->lineno_count = 0;
113 if (hdr->s_nreloc != 0)
114 return_section->flags |= SEC_RELOC;
115 /* FIXME: should this check 'hdr->s_size > 0' */
116 if (hdr->s_scnptr != 0)
117 return_section->flags |= SEC_HAS_CONTENTS;
121 /* Read in a COFF object and make it into a BFD. This is used by
124 static const bfd_target *
125 coff_real_object_p (abfd, nscns, internal_f, internal_a)
128 struct internal_filehdr *internal_f;
129 struct internal_aouthdr *internal_a;
132 size_t readsize; /* length of file_info */
134 char *external_sections;
136 /* Build a play area */
137 tdata = bfd_coff_mkobject_hook (abfd, (PTR) internal_f, (PTR) internal_a);
141 scnhsz = bfd_coff_scnhsz (abfd);
142 readsize = nscns * scnhsz;
143 external_sections = (char *)bfd_alloc(abfd, readsize);
144 if (!external_sections)
146 bfd_set_error (bfd_error_no_memory);
150 if (bfd_read((PTR)external_sections, 1, readsize, abfd) != readsize) {
154 /* Now copy data as required; construct all asections etc */
157 for (i = 0; i < nscns; i++) {
158 struct internal_scnhdr tmp;
159 bfd_coff_swap_scnhdr_in(abfd, (PTR) (external_sections + i * scnhsz),
161 make_a_section_from_file(abfd,&tmp, i+1);
165 /* make_abs_section(abfd);*/
167 if (bfd_coff_set_arch_mach_hook (abfd, (PTR) internal_f) == false)
170 if (!(internal_f->f_flags & F_RELFLG))
171 abfd->flags |= HAS_RELOC;
172 if ((internal_f->f_flags & F_EXEC))
173 abfd->flags |= EXEC_P;
174 if (!(internal_f->f_flags & F_LNNO))
175 abfd->flags |= HAS_LINENO;
176 if (!(internal_f->f_flags & F_LSYMS))
177 abfd->flags |= HAS_LOCALS;
179 /* FIXME: How can we set D_PAGED correctly? */
180 if ((internal_f->f_flags & F_EXEC) != 0)
181 abfd->flags |= D_PAGED;
183 bfd_get_symcount(abfd) = internal_f->f_nsyms;
184 if (internal_f->f_nsyms)
185 abfd->flags |= HAS_SYMS;
187 if (internal_a != (struct internal_aouthdr *) NULL)
188 bfd_get_start_address (abfd) = internal_a->entry;
190 bfd_get_start_address (abfd) = 0;
194 bfd_release(abfd, tdata);
195 return (const bfd_target *)NULL;
198 /* Turn a COFF file into a BFD, but fail with bfd_error_wrong_format if it is
199 not a COFF file. This is also used by ECOFF. */
209 struct internal_filehdr internal_f;
210 struct internal_aouthdr internal_a;
212 /* figure out how much to read */
213 filhsz = bfd_coff_filhsz (abfd);
214 aoutsz = bfd_coff_aoutsz (abfd);
216 filehdr = bfd_alloc (abfd, filhsz);
219 if (bfd_read(filehdr, 1, filhsz, abfd) != filhsz)
221 if (bfd_get_error () != bfd_error_system_call)
222 bfd_set_error (bfd_error_wrong_format);
225 bfd_coff_swap_filehdr_in(abfd, filehdr, &internal_f);
226 bfd_release (abfd, filehdr);
228 if (bfd_coff_bad_format_hook (abfd, &internal_f) == false) {
229 bfd_set_error (bfd_error_wrong_format);
232 nscns =internal_f.f_nscns;
234 if (internal_f.f_opthdr) {
237 opthdr = bfd_alloc (abfd, aoutsz);
240 if (bfd_read(opthdr, 1,aoutsz, abfd) != aoutsz) {
243 bfd_coff_swap_aouthdr_in(abfd, opthdr, (PTR)&internal_a);
246 /* Seek past the opt hdr stuff */
247 if (bfd_seek(abfd, (file_ptr) (internal_f.f_opthdr + filhsz), SEEK_SET)
251 return coff_real_object_p(abfd, nscns, &internal_f,
252 (internal_f.f_opthdr != 0
254 : (struct internal_aouthdr *) NULL));
257 /* Get the BFD section from a COFF symbol section number. */
260 coff_section_from_bfd_index (abfd, index)
264 struct sec *answer = abfd->sections;
268 return bfd_abs_section_ptr;
270 if (index == N_UNDEF)
272 return bfd_und_section_ptr;
276 return &bfd_debug_section;
281 if (answer->target_index == index)
283 answer = answer->next;
286 /* We should not reach this point, but the SCO 3.2v4 /lib/libc_s.a
287 has a bad symbol table in biglitpow.o. */
288 return bfd_und_section_ptr;
291 /* Get the upper bound of a COFF symbol table. */
294 coff_get_symtab_upper_bound(abfd)
297 if (!bfd_coff_slurp_symbol_table(abfd))
300 return (bfd_get_symcount(abfd) + 1) * (sizeof(coff_symbol_type *));
304 /* Canonicalize a COFF symbol table. */
307 coff_get_symtab (abfd, alocation)
311 unsigned int counter = 0;
312 coff_symbol_type *symbase;
313 coff_symbol_type **location = (coff_symbol_type **) (alocation);
314 if (!bfd_coff_slurp_symbol_table(abfd))
317 symbase = obj_symbols(abfd);
318 while (counter < bfd_get_symcount(abfd))
320 /* This nasty code looks at the symbol to decide whether or
321 not it is descibes a constructor/destructor entry point. It
322 is structured this way to (hopefully) speed non matches */
324 if (0 && symbase->symbol.name[9] == '$')
326 bfd_constructor_entry(abfd,
327 (asymbol **)location,
328 symbase->symbol.name[10] == 'I' ?
332 *(location++) = symbase++;
336 return bfd_get_symcount(abfd);
339 /* Set lineno_count for the output sections of a COFF file. */
342 coff_count_linenumbers (abfd)
345 unsigned int limit = bfd_get_symcount(abfd);
353 /* This may be from the backend linker, in which case the
354 lineno_count in the sections is correct. */
355 for (s = abfd->sections; s != NULL; s = s->next)
356 total += s->lineno_count;
360 for (s = abfd->sections; s != NULL; s = s->next)
361 BFD_ASSERT (s->lineno_count == 0);
363 for (p = abfd->outsymbols, i = 0; i < limit; i++, p++)
365 asymbol *q_maybe = *p;
367 if (bfd_asymbol_flavour (q_maybe) == bfd_target_coff_flavour)
369 coff_symbol_type *q = coffsymbol (q_maybe);
371 if (q->lineno != NULL)
373 /* This symbol has line numbers. Increment the owning
374 section's linenumber count. */
375 alent *l = q->lineno;
377 ++q->symbol.section->output_section->lineno_count;
380 while (l->line_number != 0)
383 ++q->symbol.section->output_section->lineno_count;
393 /* Takes a bfd and a symbol, returns a pointer to the coff specific
394 area of the symbol if there is one. */
398 coff_symbol_from (ignore_abfd, symbol)
402 if (bfd_asymbol_flavour(symbol) != bfd_target_coff_flavour)
403 return (coff_symbol_type *)NULL;
405 if (bfd_asymbol_bfd(symbol)->tdata.coff_obj_data == (coff_data_type*)NULL)
406 return (coff_symbol_type *)NULL;
408 return (coff_symbol_type *) symbol;
412 fixup_symbol_value (coff_symbol_ptr, syment)
413 coff_symbol_type *coff_symbol_ptr;
414 struct internal_syment *syment;
417 /* Normalize the symbol flags */
418 if (bfd_is_com_section (coff_symbol_ptr->symbol.section)) {
419 /* a common symbol is undefined with a value */
420 syment->n_scnum = N_UNDEF;
421 syment->n_value = coff_symbol_ptr->symbol.value;
423 else if (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING) {
424 syment->n_value = coff_symbol_ptr->symbol.value;
426 else if (bfd_is_und_section (coff_symbol_ptr->symbol.section)) {
427 syment->n_scnum = N_UNDEF;
431 if (coff_symbol_ptr->symbol.section) {
433 coff_symbol_ptr->symbol.section->output_section->target_index;
436 coff_symbol_ptr->symbol.value +
437 coff_symbol_ptr->symbol.section->output_offset +
438 coff_symbol_ptr->symbol.section->output_section->vma;
442 /* This can happen, but I don't know why yet (steve@cygnus.com) */
443 syment->n_scnum = N_ABS;
444 syment->n_value = coff_symbol_ptr->symbol.value;
449 /* run through all the symbols in the symbol table and work out what
450 their indexes into the symbol table will be when output
452 Coff requires that each C_FILE symbol points to the next one in the
453 chain, and that the last one points to the first external symbol. We
458 coff_renumber_symbols (bfd_ptr)
461 unsigned int symbol_count = bfd_get_symcount(bfd_ptr);
462 asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
463 unsigned int native_index = 0;
464 struct internal_syment *last_file = (struct internal_syment *)NULL;
465 unsigned int symbol_index;
467 /* COFF demands that undefined symbols come after all other symbols.
468 Since we don't need to impose this extra knowledge on all our client
469 programs, deal with that here. Sort the symbol table; just move the
470 undefined symbols to the end, leaving the rest alone. */
471 /* @@ Do we have some condition we could test for, so we don't always
472 have to do this? I don't think relocatability is quite right, but
473 I'm not certain. [raeburn:19920508.1711EST] */
478 newsyms = (asymbol **) bfd_alloc_by_size_t (bfd_ptr,
480 * (symbol_count + 1));
483 bfd_set_error (bfd_error_no_memory);
486 bfd_ptr->outsymbols = newsyms;
487 for (i = 0; i < symbol_count; i++)
488 if (! bfd_is_und_section (symbol_ptr_ptr[i]->section))
489 *newsyms++ = symbol_ptr_ptr[i];
490 for (i = 0; i < symbol_count; i++)
491 if (bfd_is_und_section (symbol_ptr_ptr[i]->section))
492 *newsyms++ = symbol_ptr_ptr[i];
493 *newsyms = (asymbol *) NULL;
494 symbol_ptr_ptr = bfd_ptr->outsymbols;
497 for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
499 coff_symbol_type *coff_symbol_ptr = coff_symbol_from(bfd_ptr, symbol_ptr_ptr[symbol_index]);
500 if (coff_symbol_ptr && coff_symbol_ptr->native) {
501 combined_entry_type *s = coff_symbol_ptr->native;
504 if (s->u.syment.n_sclass == C_FILE)
506 if (last_file != (struct internal_syment *)NULL) {
507 last_file->n_value = native_index;
509 last_file = &(s->u.syment);
513 /* Modify the symbol values according to their section and
516 fixup_symbol_value(coff_symbol_ptr, &(s->u.syment));
518 for (i = 0; i < s->u.syment.n_numaux + 1; i++) {
519 s[i].offset = native_index ++;
526 obj_conv_table_size (bfd_ptr) = native_index;
531 Run thorough the symbol table again, and fix it so that all pointers to
532 entries are changed to the entries' index in the output symbol table.
536 coff_mangle_symbols (bfd_ptr)
539 unsigned int symbol_count = bfd_get_symcount (bfd_ptr);
540 asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
541 unsigned int symbol_index;
543 for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
545 coff_symbol_type *coff_symbol_ptr =
546 coff_symbol_from (bfd_ptr, symbol_ptr_ptr[symbol_index]);
548 if (coff_symbol_ptr && coff_symbol_ptr->native)
551 combined_entry_type *s = coff_symbol_ptr->native;
555 /* FIXME: We should use a union here. */
556 s->u.syment.n_value =
557 ((combined_entry_type *) s->u.syment.n_value)->offset;
560 for (i = 0; i < s->u.syment.n_numaux ; i++)
562 combined_entry_type *a = s + i + 1;
565 a->u.auxent.x_sym.x_tagndx.l =
566 a->u.auxent.x_sym.x_tagndx.p->offset;
571 a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l =
572 a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p->offset;
577 a->u.auxent.x_csect.x_scnlen.l =
578 a->u.auxent.x_csect.x_scnlen.p->offset;
586 static bfd_size_type string_size;
587 static bfd_size_type debug_string_size;
588 static asection *debug_string_section;
591 coff_fix_symbol_name (abfd, symbol, native)
594 combined_entry_type *native;
596 unsigned int name_length;
597 union internal_auxent *auxent;
598 char * name = ( char *)(symbol->name);
600 if (name == (char *) NULL) {
601 /* coff symbols always have names, so we'll make one up */
602 symbol->name = "strange";
603 name = (char *)symbol->name;
605 name_length = strlen(name);
607 if (native->u.syment.n_sclass == C_FILE) {
608 strncpy(native->u.syment._n._n_name, ".file", SYMNMLEN);
609 auxent = &(native+1)->u.auxent;
611 if (bfd_coff_long_filenames (abfd)) {
612 if (name_length <= FILNMLEN) {
613 strncpy(auxent->x_file.x_fname, name, FILNMLEN);
616 auxent->x_file.x_n.x_offset = string_size + STRING_SIZE_SIZE;
617 auxent->x_file.x_n.x_zeroes = 0;
618 string_size += name_length + 1;
622 strncpy(auxent->x_file.x_fname, name, FILNMLEN);
623 if (name_length > FILNMLEN) {
624 name[FILNMLEN] = '\0';
629 { /* NOT A C_FILE SYMBOL */
630 if (name_length <= SYMNMLEN)
632 /* This name will fit into the symbol neatly */
633 strncpy(native->u.syment._n._n_name, symbol->name, SYMNMLEN);
635 else if (! bfd_coff_symname_in_debug (abfd, &native->u.syment))
637 native->u.syment._n._n_n._n_offset = string_size + STRING_SIZE_SIZE;
638 native->u.syment._n._n_n._n_zeroes = 0;
639 string_size += name_length + 1;
646 /* This name should be written into the .debug section. For
647 some reason each name is preceded by a two byte length
648 and also followed by a null byte. FIXME: We assume that
649 the .debug section has already been created, and that it
651 if (debug_string_section == (asection *) NULL)
652 debug_string_section = bfd_get_section_by_name (abfd, ".debug");
653 filepos = bfd_tell (abfd);
654 bfd_put_16 (abfd, name_length + 1, buf);
655 if (! bfd_set_section_contents (abfd,
656 debug_string_section,
658 (file_ptr) debug_string_size,
660 || ! bfd_set_section_contents (abfd,
661 debug_string_section,
663 (file_ptr) debug_string_size + 2,
664 (bfd_size_type) name_length + 1))
666 if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
668 native->u.syment._n._n_n._n_offset = debug_string_size + 2;
669 native->u.syment._n._n_n._n_zeroes = 0;
670 debug_string_size += name_length + 3;
675 /* We need to keep track of the symbol index so that when we write out
676 the relocs we can get the index for a symbol. This method is a
679 #define set_index(symbol, idx) ((symbol)->udata = (PTR) (idx))
681 /* Write a symbol out to a COFF file. */
684 coff_write_symbol (abfd, symbol, native, written)
687 combined_entry_type *native;
688 unsigned int *written;
690 unsigned int numaux = native->u.syment.n_numaux;
691 int type = native->u.syment.n_type;
692 int class = native->u.syment.n_sclass;
694 bfd_size_type symesz;
696 /* @@ bfd_debug_section isn't accessible outside this file, but we
697 know that C_FILE symbols belong there. So move them. */
698 if (native->u.syment.n_sclass == C_FILE)
699 symbol->section = &bfd_debug_section;
701 if (bfd_is_abs_section (symbol->section))
703 native->u.syment.n_scnum = N_ABS;
705 else if (symbol->section == &bfd_debug_section)
707 native->u.syment.n_scnum = N_DEBUG;
709 else if (bfd_is_und_section (symbol->section))
711 native->u.syment.n_scnum = N_UNDEF;
715 native->u.syment.n_scnum =
716 symbol->section->output_section->target_index;
719 coff_fix_symbol_name (abfd, symbol, native);
721 symesz = bfd_coff_symesz (abfd);
722 buf = bfd_alloc (abfd, symesz);
725 bfd_set_error (bfd_error_no_memory);
728 bfd_coff_swap_sym_out (abfd, &native->u.syment, buf);
729 if (bfd_write (buf, 1, symesz, abfd) != symesz)
731 bfd_release (abfd, buf);
733 if (native->u.syment.n_numaux > 0)
735 bfd_size_type auxesz;
738 auxesz = bfd_coff_auxesz (abfd);
739 buf = bfd_alloc (abfd, auxesz);
742 bfd_set_error (bfd_error_no_memory);
745 for (j = 0; j < native->u.syment.n_numaux; j++)
747 bfd_coff_swap_aux_out (abfd,
748 &((native + j + 1)->u.auxent),
752 native->u.syment.n_numaux,
754 if (bfd_write (buf, 1, auxesz, abfd)!= auxesz)
757 bfd_release (abfd, buf);
760 /* Store the index for use when we write out the relocs. */
761 set_index (symbol, *written);
763 *written += numaux + 1;
767 /* Write out a symbol to a COFF file that does not come from a COFF
768 file originally. This symbol may have been created by the linker,
769 or we may be linking a non COFF file to a COFF file. */
772 coff_write_alien_symbol (abfd, symbol, written)
775 unsigned int *written;
777 combined_entry_type *native;
778 combined_entry_type dummy;
781 native->u.syment.n_type = T_NULL;
782 native->u.syment.n_flags = 0;
783 if (bfd_is_und_section (symbol->section))
785 native->u.syment.n_scnum = N_UNDEF;
786 native->u.syment.n_value = symbol->value;
788 else if (bfd_is_com_section (symbol->section))
790 native->u.syment.n_scnum = N_UNDEF;
791 native->u.syment.n_value = symbol->value;
793 else if (symbol->flags & BSF_DEBUGGING)
795 /* There isn't much point to writing out a debugging symbol
796 unless we are prepared to convert it into COFF debugging
797 format. So, we just ignore them. We must clobber the symbol
798 name to keep it from being put in the string table. */
804 native->u.syment.n_scnum =
805 symbol->section->output_section->target_index;
806 native->u.syment.n_value = (symbol->value
807 + symbol->section->output_section->vma
808 + symbol->section->output_offset);
810 /* Copy the any flags from the the file header into the symbol.
813 coff_symbol_type *c = coff_symbol_from (abfd, symbol);
814 if (c != (coff_symbol_type *) NULL)
815 native->u.syment.n_flags = bfd_asymbol_bfd (&c->symbol)->flags;
819 native->u.syment.n_type = 0;
820 if (symbol->flags & BSF_LOCAL)
821 native->u.syment.n_sclass = C_STAT;
823 native->u.syment.n_sclass = C_EXT;
824 native->u.syment.n_numaux = 0;
826 return coff_write_symbol (abfd, symbol, native, written);
829 /* Write a native symbol to a COFF file. */
832 coff_write_native_symbol (abfd, symbol, written)
834 coff_symbol_type *symbol;
835 unsigned int *written;
837 combined_entry_type *native = symbol->native;
838 alent *lineno = symbol->lineno;
840 /* If this symbol has an associated line number, we must store the
841 symbol index in the line number field. We also tag the auxent to
842 point to the right place in the lineno table. */
843 if (lineno && !symbol->done_lineno)
845 unsigned int count = 0;
846 lineno[count].u.offset = *written;
847 if (native->u.syment.n_numaux)
849 union internal_auxent *a = &((native+1)->u.auxent);
851 a->x_sym.x_fcnary.x_fcn.x_lnnoptr =
852 symbol->symbol.section->output_section->moving_line_filepos;
855 /* Count and relocate all other linenumbers. */
857 while (lineno[count].line_number != 0)
861 I've been told this, but still need proof:
862 > The second bug is also in `bfd/coffcode.h'. This bug
863 > causes the linker to screw up the pc-relocations for
864 > all the line numbers in COFF code. This bug isn't only
865 > specific to A29K implementations, but affects all
866 > systems using COFF format binaries. Note that in COFF
867 > object files, the line number core offsets output by
868 > the assembler are relative to the start of each
869 > procedure, not to the start of the .text section. This
870 > patch relocates the line numbers relative to the
871 > `native->u.syment.n_value' instead of the section
873 > modular!olson@cs.arizona.edu (Jon Olson)
875 lineno[count].u.offset += native->u.syment.n_value;
877 lineno[count].u.offset +=
878 (symbol->symbol.section->output_section->vma
879 + symbol->symbol.section->output_offset);
883 symbol->done_lineno = true;
885 symbol->symbol.section->output_section->moving_line_filepos +=
886 count * bfd_coff_linesz (abfd);
889 return coff_write_symbol (abfd, &(symbol->symbol), native, written);
892 /* Write out the COFF symbols. */
895 coff_write_symbols (abfd)
899 unsigned int limit = bfd_get_symcount(abfd);
900 unsigned int written = 0;
904 debug_string_size = 0;
906 /* Seek to the right place */
907 if (bfd_seek (abfd, obj_sym_filepos(abfd), SEEK_SET) != 0)
910 /* Output all the symbols we have */
913 for (p = abfd->outsymbols, i = 0; i < limit; i++, p++)
915 asymbol *symbol = *p;
916 coff_symbol_type *c_symbol = coff_symbol_from (abfd, symbol);
918 if (c_symbol == (coff_symbol_type *) NULL
919 || c_symbol->native == (combined_entry_type *)NULL)
921 if (! coff_write_alien_symbol (abfd, symbol, &written))
926 if (! coff_write_native_symbol (abfd, c_symbol, &written))
931 /* Now write out strings */
933 if (string_size != 0)
935 unsigned int size = string_size + STRING_SIZE_SIZE;
936 bfd_byte buffer[STRING_SIZE_SIZE];
938 #if STRING_SIZE_SIZE == 4
939 bfd_h_put_32 (abfd, size, buffer);
941 #error Change bfd_h_put_32
943 if (bfd_write ((PTR) buffer, 1, sizeof (buffer), abfd) != sizeof (buffer))
945 for (p = abfd->outsymbols, i = 0;
950 size_t name_length = strlen (q->name);
951 coff_symbol_type *c_symbol = coff_symbol_from (abfd, q);
954 /* Figure out whether the symbol name should go in the string
955 table. Symbol names that are short enough are stored
956 directly in the syment structure. File names permit a
957 different, longer, length in the syment structure. On
958 XCOFF, some symbol names are stored in the .debug section
959 rather than in the string table. */
962 || c_symbol->native == NULL)
964 /* This is not a COFF symbol, so it certainly is not a
965 file name, nor does it go in the .debug section. */
968 else if (bfd_coff_symname_in_debug (abfd,
969 &c_symbol->native->u.syment))
971 /* This symbol name is in the XCOFF .debug section.
972 Don't write it into the string table. */
973 maxlen = name_length;
975 else if (c_symbol->native->u.syment.n_sclass == C_FILE)
980 if (name_length > maxlen)
982 if (bfd_write ((PTR) (q->name), 1, name_length + 1, abfd)
990 /* We would normally not write anything here, but we'll write
991 out 4 so that any stupid coff reader which tries to read the
992 string table even when there isn't one won't croak. */
993 unsigned int size = STRING_SIZE_SIZE;
994 bfd_byte buffer[STRING_SIZE_SIZE];
996 #if STRING_SIZE_SIZE == 4
997 bfd_h_put_32 (abfd, size, buffer);
999 #error Change bfd_h_put_32
1001 if (bfd_write ((PTR) buffer, 1, STRING_SIZE_SIZE, abfd)
1002 != STRING_SIZE_SIZE)
1006 /* Make sure the .debug section was created to be the correct size.
1007 We should create it ourselves on the fly, but we don't because
1008 BFD won't let us write to any section until we know how large all
1009 the sections are. We could still do it by making another pass
1010 over the symbols. FIXME. */
1011 BFD_ASSERT (debug_string_size == 0
1012 || (debug_string_section != (asection *) NULL
1013 && (BFD_ALIGN (debug_string_size,
1014 1 << debug_string_section->alignment_power)
1015 == bfd_section_size (abfd, debug_string_section))));
1021 coff_write_linenumbers (abfd)
1025 bfd_size_type linesz;
1028 linesz = bfd_coff_linesz (abfd);
1029 buff = bfd_alloc (abfd, linesz);
1032 bfd_set_error (bfd_error_no_memory);
1035 for (s = abfd->sections; s != (asection *) NULL; s = s->next) {
1036 if (s->lineno_count) {
1037 asymbol **q = abfd->outsymbols;
1038 if (bfd_seek(abfd, s->line_filepos, SEEK_SET) != 0)
1040 /* Find all the linenumbers in this section */
1043 if (p->section->output_section == s) {
1045 BFD_SEND(bfd_asymbol_bfd(p), _get_lineno, (bfd_asymbol_bfd(p), p));
1047 /* Found a linenumber entry, output */
1048 struct internal_lineno out;
1049 memset( (PTR)&out, 0, sizeof(out));
1051 out.l_addr.l_symndx = l->u.offset;
1052 bfd_coff_swap_lineno_out(abfd, &out, buff);
1053 if (bfd_write(buff, 1, linesz, abfd) != linesz)
1056 while (l->line_number) {
1057 out.l_lnno = l->line_number;
1058 out.l_addr.l_symndx = l->u.offset;
1059 bfd_coff_swap_lineno_out(abfd, &out, buff);
1060 if (bfd_write(buff, 1, linesz, abfd) != linesz)
1070 bfd_release (abfd, buff);
1076 coff_get_lineno (ignore_abfd, symbol)
1080 return coffsymbol(symbol)->lineno;
1084 coff_section_symbol (abfd, name)
1088 asection *sec = bfd_make_section_old_way (abfd, name);
1090 combined_entry_type *csym;
1093 csym = coff_symbol_from (abfd, sym)->native;
1094 /* Make sure back-end COFF stuff is there. */
1098 coff_symbol_type sym;
1099 /* @@FIXME This shouldn't use a fixed size!! */
1100 combined_entry_type e[10];
1103 f = (struct foo *) bfd_alloc_by_size_t (abfd, sizeof (*f));
1106 bfd_set_error (bfd_error_no_error);
1109 memset ((char *) f, 0, sizeof (*f));
1110 coff_symbol_from (abfd, sym)->native = csym = f->e;
1112 csym[0].u.syment.n_sclass = C_STAT;
1113 csym[0].u.syment.n_numaux = 1;
1114 /* SF_SET_STATICS (sym); @@ ??? */
1115 csym[1].u.auxent.x_scn.x_scnlen = sec->_raw_size;
1116 csym[1].u.auxent.x_scn.x_nreloc = sec->reloc_count;
1117 csym[1].u.auxent.x_scn.x_nlinno = sec->lineno_count;
1119 if (sec->output_section == NULL)
1121 sec->output_section = sec;
1122 sec->output_offset = 0;
1128 /* This function transforms the offsets into the symbol table into
1129 pointers to syments. */
1132 coff_pointerize_aux (abfd, table_base, type, class, auxent)
1134 combined_entry_type *table_base;
1137 combined_entry_type *auxent;
1139 /* Don't bother if this is a file or a section */
1140 if (class == C_STAT && type == T_NULL) return;
1141 if (class == C_FILE) return;
1143 /* Otherwise patch up */
1144 #define N_TMASK coff_data (abfd)->local_n_tmask
1145 #define N_BTSHFT coff_data (abfd)->local_n_btshft
1146 if ((ISFCN(type) || ISTAG(class) || class == C_BLOCK)
1147 && auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l > 0)
1149 auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p =
1151 + auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l);
1152 auxent->fix_end = 1;
1154 /* A negative tagndx is meaningless, but the SCO 3.2v4 cc can
1155 generate one, so we must be careful to ignore it. */
1156 if (auxent->u.auxent.x_sym.x_tagndx.l > 0) {
1157 auxent->u.auxent.x_sym.x_tagndx.p =
1158 table_base + auxent->u.auxent.x_sym.x_tagndx.l;
1159 auxent->fix_tag = 1;
1164 build_string_table (abfd)
1167 char string_table_size_buffer[STRING_SIZE_SIZE];
1168 unsigned int string_table_size;
1171 /* At this point we should be "seek"'d to the end of the
1172 symbols === the symbol table size. */
1173 if (bfd_read((char *) string_table_size_buffer,
1174 sizeof(string_table_size_buffer),
1175 1, abfd) != sizeof(string_table_size))
1178 #if STRING_SIZE_SIZE == 4
1179 string_table_size = bfd_h_get_32(abfd, (bfd_byte *) string_table_size_buffer);
1181 #error Change bfd_h_get_32
1184 if ((string_table = (PTR) bfd_alloc(abfd,
1185 string_table_size -= STRING_SIZE_SIZE))
1188 bfd_set_error (bfd_error_no_memory);
1190 } /* on mallocation error */
1191 if (bfd_read(string_table, string_table_size, 1, abfd) != string_table_size)
1193 return string_table;
1196 /* Allocate space for the ".debug" section, and read it.
1197 We did not read the debug section until now, because
1198 we didn't want to go to the trouble until someone needed it. */
1201 build_debug_section (abfd)
1204 char *debug_section;
1207 asection *sect = bfd_get_section_by_name (abfd, ".debug");
1210 bfd_set_error (bfd_error_no_debug_section);
1214 debug_section = (PTR) bfd_alloc (abfd,
1215 bfd_get_section_size_before_reloc (sect));
1216 if (debug_section == NULL) {
1217 bfd_set_error (bfd_error_no_memory);
1221 /* Seek to the beginning of the `.debug' section and read it.
1222 Save the current position first; it is needed by our caller.
1223 Then read debug section and reset the file pointer. */
1225 position = bfd_tell (abfd);
1226 if (bfd_seek (abfd, sect->filepos, SEEK_SET) != 0
1227 || (bfd_read (debug_section,
1228 bfd_get_section_size_before_reloc (sect), 1, abfd)
1229 != bfd_get_section_size_before_reloc(sect))
1230 || bfd_seek (abfd, position, SEEK_SET) != 0)
1232 return debug_section;
1236 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
1237 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
1238 be \0-terminated. */
1240 copy_name (abfd, name, maxlen)
1248 for (len = 0; len < maxlen; ++len) {
1249 if (name[len] == '\0') {
1254 if ((newname = (PTR) bfd_alloc(abfd, len+1)) == NULL) {
1255 bfd_set_error (bfd_error_no_memory);
1258 strncpy(newname, name, len);
1259 newname[len] = '\0';
1263 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
1264 knit the symbol names into a normalized form. By normalized here I
1265 mean that all symbols have an n_offset pointer that points to a null-
1266 terminated string. */
1268 combined_entry_type *
1269 coff_get_normalized_symtab (abfd)
1272 combined_entry_type *internal;
1273 combined_entry_type *internal_ptr;
1274 combined_entry_type *symbol_ptr;
1275 combined_entry_type *internal_end;
1276 bfd_size_type symesz;
1280 char *string_table = NULL;
1281 char *debug_section = NULL;
1284 unsigned int raw_size;
1285 if (obj_raw_syments(abfd) != (combined_entry_type *)NULL) {
1286 return obj_raw_syments(abfd);
1288 size = obj_raw_syment_count (abfd) * sizeof (combined_entry_type);
1291 bfd_set_error (bfd_error_no_symbols);
1295 internal = (combined_entry_type *)bfd_alloc(abfd, size);
1298 bfd_set_error (bfd_error_no_memory);
1301 internal_end = internal + obj_raw_syment_count (abfd);
1303 symesz = bfd_coff_symesz (abfd);
1304 raw_size = obj_raw_syment_count (abfd) * symesz;
1305 raw = bfd_alloc(abfd,raw_size);
1308 bfd_set_error (bfd_error_no_memory);
1312 if (bfd_seek(abfd, obj_sym_filepos(abfd), SEEK_SET) == -1
1313 || bfd_read(raw, raw_size, 1, abfd) != raw_size)
1315 /* mark the end of the symbols */
1316 raw_end = (char *) raw + obj_raw_syment_count (abfd) * symesz;
1318 FIXME SOMEDAY. A string table size of zero is very weird, but
1319 probably possible. If one shows up, it will probably kill us.
1322 /* Swap all the raw entries */
1323 for (raw_src = (char *) raw, internal_ptr = internal;
1325 raw_src += symesz, internal_ptr++) {
1328 bfd_coff_swap_sym_in(abfd, (PTR)raw_src, (PTR)&internal_ptr->u.syment);
1329 internal_ptr->fix_value = 0;
1330 internal_ptr->fix_tag = 0;
1331 internal_ptr->fix_end = 0;
1332 internal_ptr->fix_scnlen = 0;
1333 symbol_ptr = internal_ptr;
1336 i < symbol_ptr->u.syment.n_numaux;
1342 internal_ptr->fix_value = 0;
1343 internal_ptr->fix_tag = 0;
1344 internal_ptr->fix_end = 0;
1345 internal_ptr->fix_scnlen = 0;
1346 bfd_coff_swap_aux_in(abfd, (PTR) raw_src,
1347 symbol_ptr->u.syment.n_type,
1348 symbol_ptr->u.syment.n_sclass,
1349 i, symbol_ptr->u.syment.n_numaux,
1350 &(internal_ptr->u.auxent));
1351 /* Remember that bal entries arn't pointerized */
1352 if (i != 1 || symbol_ptr->u.syment.n_sclass != C_LEAFPROC)
1355 coff_pointerize_aux(abfd,
1357 symbol_ptr->u.syment.n_type,
1358 symbol_ptr->u.syment.n_sclass,
1365 /* Free all the raw stuff */
1366 bfd_release(abfd, raw);
1368 for (internal_ptr = internal; internal_ptr < internal_end;
1371 if (internal_ptr->u.syment.n_sclass == C_FILE
1372 && internal_ptr->u.syment.n_numaux > 0) {
1373 /* make a file symbol point to the name in the auxent, since
1374 the text ".file" is redundant */
1375 if ((internal_ptr+1)->u.auxent.x_file.x_n.x_zeroes == 0) {
1376 /* the filename is a long one, point into the string table */
1377 if (string_table == NULL) {
1378 string_table = build_string_table(abfd);
1381 internal_ptr->u.syment._n._n_n._n_offset =
1382 (long) (string_table - STRING_SIZE_SIZE +
1383 (internal_ptr+1)->u.auxent.x_file.x_n.x_offset);
1386 /* ordinary short filename, put into memory anyway */
1387 internal_ptr->u.syment._n._n_n._n_offset = (long)
1388 copy_name(abfd, (internal_ptr+1)->u.auxent.x_file.x_fname,
1393 if (internal_ptr->u.syment._n._n_n._n_zeroes != 0) {
1394 /* This is a "short" name. Make it long. */
1395 unsigned long i = 0;
1396 char *newstring = NULL;
1398 /* find the length of this string without walking into memory
1400 for (i = 0; i < 8; ++i) {
1401 if (internal_ptr->u.syment._n._n_name[i] == '\0') {
1403 } /* if end of string */
1404 } /* possible lengths of this string. */
1406 if ((newstring = (PTR) bfd_alloc(abfd, ++i)) == NULL) {
1407 bfd_set_error (bfd_error_no_memory);
1410 memset(newstring, 0, i);
1411 strncpy(newstring, internal_ptr->u.syment._n._n_name, i-1);
1412 internal_ptr->u.syment._n._n_n._n_offset = (long int) newstring;
1413 internal_ptr->u.syment._n._n_n._n_zeroes = 0;
1415 else if (internal_ptr->u.syment._n._n_n._n_offset == 0)
1416 internal_ptr->u.syment._n._n_n._n_offset = (long int) "";
1417 else if (!bfd_coff_symname_in_debug(abfd, &internal_ptr->u.syment)) {
1418 /* Long name already. Point symbol at the string in the table. */
1419 if (string_table == NULL) {
1420 string_table = build_string_table(abfd);
1422 internal_ptr->u.syment._n._n_n._n_offset = (long int)
1425 + internal_ptr->u.syment._n._n_n._n_offset);
1428 /* Long name in debug section. Very similar. */
1429 if (debug_section == NULL) {
1430 debug_section = build_debug_section(abfd);
1432 internal_ptr->u.syment._n._n_n._n_offset = (long int)
1433 (debug_section + internal_ptr->u.syment._n._n_n._n_offset);
1436 internal_ptr += internal_ptr->u.syment.n_numaux;
1439 obj_raw_syments(abfd) = internal;
1440 BFD_ASSERT (obj_raw_syment_count (abfd) == internal_ptr - internal);
1443 } /* coff_get_normalized_symtab() */
1446 coff_get_reloc_upper_bound (abfd, asect)
1450 if (bfd_get_format(abfd) != bfd_object) {
1451 bfd_set_error (bfd_error_invalid_operation);
1454 return (asect->reloc_count + 1) * sizeof(arelent *);
1458 coff_make_empty_symbol (abfd)
1461 coff_symbol_type *new = (coff_symbol_type *) bfd_alloc(abfd, sizeof(coff_symbol_type));
1463 bfd_set_error (bfd_error_no_memory);
1466 memset (new, 0, sizeof *new);
1467 new->symbol.section = 0;
1469 new->lineno = (alent *) NULL;
1470 new->done_lineno = false;
1471 new->symbol.the_bfd = abfd;
1472 return &new->symbol;
1475 /* Make a debugging symbol. */
1478 coff_bfd_make_debug_symbol (abfd, ptr, sz)
1483 coff_symbol_type *new = (coff_symbol_type *) bfd_alloc(abfd, sizeof(coff_symbol_type));
1485 bfd_set_error (bfd_error_no_memory);
1488 /* @@ This shouldn't be using a constant multiplier. */
1489 new->native = (combined_entry_type *) bfd_zalloc (abfd, sizeof (combined_entry_type) * 10);
1492 bfd_set_error (bfd_error_no_memory);
1495 new->symbol.section = &bfd_debug_section;
1496 new->lineno = (alent *) NULL;
1497 new->done_lineno = false;
1498 new->symbol.the_bfd = abfd;
1499 return &new->symbol;
1504 coff_get_symbol_info (abfd, symbol, ret)
1509 bfd_symbol_info (symbol, ret);
1512 /* Print out information about COFF symbol. */
1515 coff_print_symbol (abfd, filep, symbol, how)
1519 bfd_print_symbol_type how;
1521 FILE *file = (FILE *) filep;
1525 case bfd_print_symbol_name:
1526 fprintf (file, "%s", symbol->name);
1529 case bfd_print_symbol_more:
1530 fprintf (file, "coff %s %s",
1531 coffsymbol(symbol)->native ? "n" : "g",
1532 coffsymbol(symbol)->lineno ? "l" : " ");
1535 case bfd_print_symbol_all:
1536 if (coffsymbol(symbol)->native)
1539 combined_entry_type *combined = coffsymbol (symbol)->native;
1540 combined_entry_type *root = obj_raw_syments (abfd);
1541 struct lineno_cache_entry *l = coffsymbol(symbol)->lineno;
1543 fprintf (file,"[%3ld]", (long) (combined - root));
1546 "(sc %2d)(fl 0x%02x)(ty %3x)(sc %3d) (nx %d) 0x%08lx %s",
1547 combined->u.syment.n_scnum,
1548 combined->u.syment.n_flags,
1549 combined->u.syment.n_type,
1550 combined->u.syment.n_sclass,
1551 combined->u.syment.n_numaux,
1552 (unsigned long) combined->u.syment.n_value,
1555 for (aux = 0; aux < combined->u.syment.n_numaux; aux++)
1557 combined_entry_type *auxp = combined + aux + 1;
1561 tagndx = auxp->u.auxent.x_sym.x_tagndx.p - root;
1563 tagndx = auxp->u.auxent.x_sym.x_tagndx.l;
1565 fprintf (file, "\n");
1566 switch (combined->u.syment.n_sclass)
1569 fprintf (file, "File ");
1573 if (combined->u.syment.n_type == T_NULL)
1574 /* probably a section symbol? */
1576 fprintf (file, "AUX scnlen 0x%lx nreloc %d nlnno %d",
1577 (long) auxp->u.auxent.x_scn.x_scnlen,
1578 auxp->u.auxent.x_scn.x_nreloc,
1579 auxp->u.auxent.x_scn.x_nlinno);
1582 /* else fall through */
1585 fprintf (file, "AUX lnno %d size 0x%x tagndx %ld",
1586 auxp->u.auxent.x_sym.x_misc.x_lnsz.x_lnno,
1587 auxp->u.auxent.x_sym.x_misc.x_lnsz.x_size,
1590 fprintf (file, " endndx %ld",
1592 (auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p
1600 fprintf (file, "\n%s :", l->u.sym->name);
1602 while (l->line_number)
1604 fprintf (file, "\n%4d : 0x%lx",
1607 (l->u.offset + symbol->section->vma)));
1614 bfd_print_symbol_vandf ((PTR) file, symbol);
1615 fprintf (file, " %-5s %s %s %s",
1616 symbol->section->name,
1617 coffsymbol(symbol)->native ? "n" : "g",
1618 coffsymbol(symbol)->lineno ? "l" : " ",
1624 /* Provided a BFD, a section and an offset into the section, calculate
1625 and return the name of the source file and the line nearest to the
1630 coff_find_nearest_line (abfd, section, ignore_symbols, offset, filename_ptr,
1631 functionname_ptr, line_ptr)
1634 asymbol **ignore_symbols;
1636 CONST char **filename_ptr;
1637 CONST char **functionname_ptr;
1638 unsigned int *line_ptr;
1640 static bfd *cache_abfd;
1641 static asection *cache_section;
1642 static bfd_vma cache_offset;
1643 static unsigned int cache_i;
1644 static CONST char *cache_function;
1645 static unsigned int line_base = 0;
1648 coff_data_type *cof = coff_data(abfd);
1649 /* Run through the raw syments if available */
1650 combined_entry_type *p;
1651 combined_entry_type *pend;
1656 *functionname_ptr = 0;
1659 /* Don't try and find line numbers in a non coff file */
1660 if (abfd->xvec->flavour != bfd_target_coff_flavour)
1666 /* Find the first C_FILE symbol. */
1667 p = cof->raw_syments;
1668 pend = p + cof->raw_syment_count;
1671 if (p->u.syment.n_sclass == C_FILE)
1673 p += 1 + p->u.syment.n_numaux;
1680 /* Look through the C_FILE symbols to find the best one. */
1681 *filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
1682 maxdiff = (bfd_vma) 0 - (bfd_vma) 1;
1685 combined_entry_type *p2;
1687 for (p2 = p + 1 + p->u.syment.n_numaux;
1689 p2 += 1 + p2->u.syment.n_numaux)
1691 if (p2->u.syment.n_scnum > 0
1693 == coff_section_from_bfd_index (abfd,
1694 p2->u.syment.n_scnum)))
1696 if (p2->u.syment.n_sclass == C_FILE)
1704 && offset >= p2->u.syment.n_value
1705 && offset - p2->u.syment.n_value < maxdiff)
1707 *filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
1708 maxdiff = offset - p2->u.syment.n_value;
1711 /* Avoid endless loops on erroneous files by ensuring that
1712 we always move forward in the file. */
1713 if (p - cof->raw_syments >= p->u.syment.n_value)
1716 p = cof->raw_syments + p->u.syment.n_value;
1717 if (p > pend || p->u.syment.n_sclass != C_FILE)
1722 /* Now wander though the raw linenumbers of the section */
1724 If this is the same BFD as we were previously called with and this is
1725 the same section, and the offset we want is further down then we can
1726 prime the lookup loop
1728 if (abfd == cache_abfd &&
1729 section == cache_section &&
1730 offset >= cache_offset) {
1732 *functionname_ptr = cache_function;
1737 l = §ion->lineno[i];
1739 for (; i < section->lineno_count; i++) {
1740 if (l->line_number == 0) {
1741 /* Get the symbol this line number points at */
1742 coff_symbol_type *coff = (coff_symbol_type *) (l->u.sym);
1743 if (coff->symbol.value > offset)
1745 *functionname_ptr = coff->symbol.name;
1747 combined_entry_type *s = coff->native;
1748 s = s + 1 + s->u.syment.n_numaux;
1750 /* In XCOFF a debugging symbol can follow the function
1752 if (s->u.syment.n_scnum == N_DEBUG)
1753 s = s + 1 + s->u.syment.n_numaux;
1756 S should now point to the .bf of the function
1758 if (s->u.syment.n_numaux) {
1760 The linenumber is stored in the auxent
1762 union internal_auxent *a = &((s + 1)->u.auxent);
1763 line_base = a->x_sym.x_misc.x_lnsz.x_lnno;
1764 *line_ptr = line_base;
1769 if (l->u.offset + bfd_get_section_vma (abfd, section) > offset)
1771 *line_ptr = l->line_number + line_base - 1;
1777 cache_section = section;
1778 cache_offset = offset;
1780 cache_function = *functionname_ptr;
1786 coff_sizeof_headers (abfd, reloc)
1792 if (reloc == false) {
1793 size = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
1796 size = bfd_coff_filhsz (abfd);
1799 size += abfd->section_count * bfd_coff_scnhsz (abfd);