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 obj_raw_syment_count (abfd) =
184 obj_conv_table_size (abfd) =
185 bfd_get_symcount(abfd) =
187 if (internal_f->f_nsyms)
188 abfd->flags |= HAS_SYMS;
190 if (internal_a != (struct internal_aouthdr *) NULL)
191 bfd_get_start_address (abfd) = internal_a->entry;
193 bfd_get_start_address (abfd) = 0;
197 bfd_release(abfd, tdata);
198 return (const bfd_target *)NULL;
201 /* Turn a COFF file into a BFD, but fail with bfd_error_wrong_format if it is
202 not a COFF file. This is also used by ECOFF. */
212 struct internal_filehdr internal_f;
213 struct internal_aouthdr internal_a;
215 /* figure out how much to read */
216 filhsz = bfd_coff_filhsz (abfd);
217 aoutsz = bfd_coff_aoutsz (abfd);
219 filehdr = bfd_alloc (abfd, filhsz);
222 if (bfd_read(filehdr, 1, filhsz, abfd) != filhsz)
224 if (bfd_get_error () != bfd_error_system_call)
225 bfd_set_error (bfd_error_wrong_format);
228 bfd_coff_swap_filehdr_in(abfd, filehdr, &internal_f);
229 bfd_release (abfd, filehdr);
231 if (bfd_coff_bad_format_hook (abfd, &internal_f) == false) {
232 bfd_set_error (bfd_error_wrong_format);
235 nscns =internal_f.f_nscns;
237 if (internal_f.f_opthdr) {
240 opthdr = bfd_alloc (abfd, aoutsz);
243 if (bfd_read(opthdr, 1,aoutsz, abfd) != aoutsz) {
246 bfd_coff_swap_aouthdr_in(abfd, opthdr, (PTR)&internal_a);
249 /* Seek past the opt hdr stuff */
250 if (bfd_seek(abfd, (file_ptr) (internal_f.f_opthdr + filhsz), SEEK_SET)
254 return coff_real_object_p(abfd, nscns, &internal_f,
255 (internal_f.f_opthdr != 0
257 : (struct internal_aouthdr *) NULL));
260 /* Get the BFD section from a COFF symbol section number. */
263 coff_section_from_bfd_index (abfd, index)
267 struct sec *answer = abfd->sections;
271 return bfd_abs_section_ptr;
273 if (index == N_UNDEF)
275 return bfd_und_section_ptr;
279 return &bfd_debug_section;
284 if (answer->target_index == index)
286 answer = answer->next;
289 /* We should not reach this point, but the SCO 3.2v4 /lib/libc_s.a
290 has a bad symbol table in biglitpow.o. */
291 return bfd_und_section_ptr;
294 /* Get the upper bound of a COFF symbol table. */
297 coff_get_symtab_upper_bound(abfd)
300 if (!bfd_coff_slurp_symbol_table(abfd))
303 return (bfd_get_symcount(abfd) + 1) * (sizeof(coff_symbol_type *));
307 /* Canonicalize a COFF symbol table. */
310 coff_get_symtab (abfd, alocation)
314 unsigned int counter = 0;
315 coff_symbol_type *symbase;
316 coff_symbol_type **location = (coff_symbol_type **) (alocation);
317 if (!bfd_coff_slurp_symbol_table(abfd))
320 symbase = obj_symbols(abfd);
321 while (counter < bfd_get_symcount(abfd))
323 /* This nasty code looks at the symbol to decide whether or
324 not it is descibes a constructor/destructor entry point. It
325 is structured this way to (hopefully) speed non matches */
327 if (0 && symbase->symbol.name[9] == '$')
329 bfd_constructor_entry(abfd,
330 (asymbol **)location,
331 symbase->symbol.name[10] == 'I' ?
335 *(location++) = symbase++;
339 return bfd_get_symcount(abfd);
342 /* Set lineno_count for the output sections of a COFF file. */
345 coff_count_linenumbers (abfd)
348 unsigned int limit = bfd_get_symcount(abfd);
353 asection *s = abfd->sections->output_section;
355 BFD_ASSERT(s->lineno_count == 0);
361 for (p = abfd->outsymbols, i = 0; i < limit; i++, p++) {
362 asymbol *q_maybe = *p;
363 if (bfd_asymbol_flavour(q_maybe) == bfd_target_coff_flavour) {
364 coff_symbol_type *q = coffsymbol(q_maybe);
367 This symbol has a linenumber, increment the owning
368 section's linenumber count
370 alent *l = q->lineno;
371 q->symbol.section->output_section->lineno_count++;
374 while (l->line_number) {
376 q->symbol.section->output_section->lineno_count++;
385 /* Takes a bfd and a symbol, returns a pointer to the coff specific
386 area of the symbol if there is one. */
390 coff_symbol_from (ignore_abfd, symbol)
394 if (bfd_asymbol_flavour(symbol) != bfd_target_coff_flavour)
395 return (coff_symbol_type *)NULL;
397 if (bfd_asymbol_bfd(symbol)->tdata.coff_obj_data == (coff_data_type*)NULL)
398 return (coff_symbol_type *)NULL;
400 return (coff_symbol_type *) symbol;
404 fixup_symbol_value (coff_symbol_ptr, syment)
405 coff_symbol_type *coff_symbol_ptr;
406 struct internal_syment *syment;
409 /* Normalize the symbol flags */
410 if (bfd_is_com_section (coff_symbol_ptr->symbol.section)) {
411 /* a common symbol is undefined with a value */
412 syment->n_scnum = N_UNDEF;
413 syment->n_value = coff_symbol_ptr->symbol.value;
415 else if (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING) {
416 syment->n_value = coff_symbol_ptr->symbol.value;
418 else if (bfd_is_und_section (coff_symbol_ptr->symbol.section)) {
419 syment->n_scnum = N_UNDEF;
423 if (coff_symbol_ptr->symbol.section) {
425 coff_symbol_ptr->symbol.section->output_section->target_index;
428 coff_symbol_ptr->symbol.value +
429 coff_symbol_ptr->symbol.section->output_offset +
430 coff_symbol_ptr->symbol.section->output_section->vma;
434 /* This can happen, but I don't know why yet (steve@cygnus.com) */
435 syment->n_scnum = N_ABS;
436 syment->n_value = coff_symbol_ptr->symbol.value;
441 /* run through all the symbols in the symbol table and work out what
442 their indexes into the symbol table will be when output
444 Coff requires that each C_FILE symbol points to the next one in the
445 chain, and that the last one points to the first external symbol. We
450 coff_renumber_symbols (bfd_ptr)
453 unsigned int symbol_count = bfd_get_symcount(bfd_ptr);
454 asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
455 unsigned int native_index = 0;
456 struct internal_syment *last_file = (struct internal_syment *)NULL;
457 unsigned int symbol_index;
459 /* COFF demands that undefined symbols come after all other symbols.
460 Since we don't need to impose this extra knowledge on all our client
461 programs, deal with that here. Sort the symbol table; just move the
462 undefined symbols to the end, leaving the rest alone. */
463 /* @@ Do we have some condition we could test for, so we don't always
464 have to do this? I don't think relocatability is quite right, but
465 I'm not certain. [raeburn:19920508.1711EST] */
470 newsyms = (asymbol **) bfd_alloc_by_size_t (bfd_ptr,
472 * (symbol_count + 1));
475 bfd_set_error (bfd_error_no_memory);
478 bfd_ptr->outsymbols = newsyms;
479 for (i = 0; i < symbol_count; i++)
480 if (! bfd_is_und_section (symbol_ptr_ptr[i]->section))
481 *newsyms++ = symbol_ptr_ptr[i];
482 for (i = 0; i < symbol_count; i++)
483 if (bfd_is_und_section (symbol_ptr_ptr[i]->section))
484 *newsyms++ = symbol_ptr_ptr[i];
485 *newsyms = (asymbol *) NULL;
486 symbol_ptr_ptr = bfd_ptr->outsymbols;
489 for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
491 coff_symbol_type *coff_symbol_ptr = coff_symbol_from(bfd_ptr, symbol_ptr_ptr[symbol_index]);
492 if (coff_symbol_ptr && coff_symbol_ptr->native) {
493 combined_entry_type *s = coff_symbol_ptr->native;
496 if (s->u.syment.n_sclass == C_FILE)
498 if (last_file != (struct internal_syment *)NULL) {
499 last_file->n_value = native_index;
501 last_file = &(s->u.syment);
505 /* Modify the symbol values according to their section and
508 fixup_symbol_value(coff_symbol_ptr, &(s->u.syment));
510 for (i = 0; i < s->u.syment.n_numaux + 1; i++) {
511 s[i].offset = native_index ++;
518 obj_conv_table_size (bfd_ptr) = native_index;
523 Run thorough the symbol table again, and fix it so that all pointers to
524 entries are changed to the entries' index in the output symbol table.
528 coff_mangle_symbols (bfd_ptr)
531 unsigned int symbol_count = bfd_get_symcount (bfd_ptr);
532 asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
533 unsigned int symbol_index;
535 for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
537 coff_symbol_type *coff_symbol_ptr =
538 coff_symbol_from (bfd_ptr, symbol_ptr_ptr[symbol_index]);
540 if (coff_symbol_ptr && coff_symbol_ptr->native)
543 combined_entry_type *s = coff_symbol_ptr->native;
547 /* FIXME: We should use a union here. */
548 s->u.syment.n_value =
549 ((combined_entry_type *) s->u.syment.n_value)->offset;
552 for (i = 0; i < s->u.syment.n_numaux ; i++)
554 combined_entry_type *a = s + i + 1;
557 a->u.auxent.x_sym.x_tagndx.l =
558 a->u.auxent.x_sym.x_tagndx.p->offset;
563 a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l =
564 a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p->offset;
569 a->u.auxent.x_csect.x_scnlen.l =
570 a->u.auxent.x_csect.x_scnlen.p->offset;
578 static bfd_size_type string_size;
579 static bfd_size_type debug_string_size;
580 static asection *debug_string_section;
583 coff_fix_symbol_name (abfd, symbol, native)
586 combined_entry_type *native;
588 unsigned int name_length;
589 union internal_auxent *auxent;
590 char * name = ( char *)(symbol->name);
592 if (name == (char *) NULL) {
593 /* coff symbols always have names, so we'll make one up */
594 symbol->name = "strange";
595 name = (char *)symbol->name;
597 name_length = strlen(name);
599 if (native->u.syment.n_sclass == C_FILE) {
600 strncpy(native->u.syment._n._n_name, ".file", SYMNMLEN);
601 auxent = &(native+1)->u.auxent;
603 if (bfd_coff_long_filenames (abfd)) {
604 if (name_length <= FILNMLEN) {
605 strncpy(auxent->x_file.x_fname, name, FILNMLEN);
608 auxent->x_file.x_n.x_offset = string_size + STRING_SIZE_SIZE;
609 auxent->x_file.x_n.x_zeroes = 0;
610 string_size += name_length + 1;
614 strncpy(auxent->x_file.x_fname, name, FILNMLEN);
615 if (name_length > FILNMLEN) {
616 name[FILNMLEN] = '\0';
621 { /* NOT A C_FILE SYMBOL */
622 if (name_length <= SYMNMLEN)
624 /* This name will fit into the symbol neatly */
625 strncpy(native->u.syment._n._n_name, symbol->name, SYMNMLEN);
627 else if (! bfd_coff_symname_in_debug (abfd, &native->u.syment))
629 native->u.syment._n._n_n._n_offset = string_size + STRING_SIZE_SIZE;
630 native->u.syment._n._n_n._n_zeroes = 0;
631 string_size += name_length + 1;
638 /* This name should be written into the .debug section. For
639 some reason each name is preceded by a two byte length
640 and also followed by a null byte. FIXME: We assume that
641 the .debug section has already been created, and that it
643 if (debug_string_section == (asection *) NULL)
644 debug_string_section = bfd_get_section_by_name (abfd, ".debug");
645 filepos = bfd_tell (abfd);
646 bfd_put_16 (abfd, name_length + 1, buf);
647 if (! bfd_set_section_contents (abfd,
648 debug_string_section,
650 (file_ptr) debug_string_size,
652 || ! bfd_set_section_contents (abfd,
653 debug_string_section,
655 (file_ptr) debug_string_size + 2,
656 (bfd_size_type) name_length + 1))
658 if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
660 native->u.syment._n._n_n._n_offset = debug_string_size + 2;
661 native->u.syment._n._n_n._n_zeroes = 0;
662 debug_string_size += name_length + 3;
667 /* We need to keep track of the symbol index so that when we write out
668 the relocs we can get the index for a symbol. This method is a
671 #define set_index(symbol, idx) ((symbol)->udata = (PTR) (idx))
673 /* Write a symbol out to a COFF file. */
676 coff_write_symbol (abfd, symbol, native, written)
679 combined_entry_type *native;
680 unsigned int *written;
682 unsigned int numaux = native->u.syment.n_numaux;
683 int type = native->u.syment.n_type;
684 int class = native->u.syment.n_sclass;
686 bfd_size_type symesz;
688 /* @@ bfd_debug_section isn't accessible outside this file, but we
689 know that C_FILE symbols belong there. So move them. */
690 if (native->u.syment.n_sclass == C_FILE)
691 symbol->section = &bfd_debug_section;
693 if (bfd_is_abs_section (symbol->section))
695 native->u.syment.n_scnum = N_ABS;
697 else if (symbol->section == &bfd_debug_section)
699 native->u.syment.n_scnum = N_DEBUG;
701 else if (bfd_is_und_section (symbol->section))
703 native->u.syment.n_scnum = N_UNDEF;
707 native->u.syment.n_scnum =
708 symbol->section->output_section->target_index;
711 coff_fix_symbol_name (abfd, symbol, native);
713 symesz = bfd_coff_symesz (abfd);
714 buf = bfd_alloc (abfd, symesz);
717 bfd_set_error (bfd_error_no_memory);
720 bfd_coff_swap_sym_out (abfd, &native->u.syment, buf);
721 if (bfd_write (buf, 1, symesz, abfd) != symesz)
723 bfd_release (abfd, buf);
725 if (native->u.syment.n_numaux > 0)
727 bfd_size_type auxesz;
730 auxesz = bfd_coff_auxesz (abfd);
731 buf = bfd_alloc (abfd, auxesz);
734 bfd_set_error (bfd_error_no_memory);
737 for (j = 0; j < native->u.syment.n_numaux; j++)
739 bfd_coff_swap_aux_out (abfd,
740 &((native + j + 1)->u.auxent),
744 native->u.syment.n_numaux,
746 if (bfd_write (buf, 1, auxesz, abfd)!= auxesz)
749 bfd_release (abfd, buf);
752 /* Store the index for use when we write out the relocs. */
753 set_index (symbol, *written);
755 *written += numaux + 1;
759 /* Write out a symbol to a COFF file that does not come from a COFF
760 file originally. This symbol may have been created by the linker,
761 or we may be linking a non COFF file to a COFF file. */
764 coff_write_alien_symbol (abfd, symbol, written)
767 unsigned int *written;
769 combined_entry_type *native;
770 combined_entry_type dummy;
773 native->u.syment.n_type = T_NULL;
774 native->u.syment.n_flags = 0;
775 if (bfd_is_und_section (symbol->section))
777 native->u.syment.n_scnum = N_UNDEF;
778 native->u.syment.n_value = symbol->value;
780 else if (bfd_is_com_section (symbol->section))
782 native->u.syment.n_scnum = N_UNDEF;
783 native->u.syment.n_value = symbol->value;
785 else if (symbol->flags & BSF_DEBUGGING)
787 /* There isn't much point to writing out a debugging symbol
788 unless we are prepared to convert it into COFF debugging
789 format. So, we just ignore them. We must clobber the symbol
790 name to keep it from being put in the string table. */
796 native->u.syment.n_scnum =
797 symbol->section->output_section->target_index;
798 native->u.syment.n_value = (symbol->value
799 + symbol->section->output_section->vma
800 + symbol->section->output_offset);
802 /* Copy the any flags from the the file header into the symbol.
805 coff_symbol_type *c = coff_symbol_from (abfd, symbol);
806 if (c != (coff_symbol_type *) NULL)
807 native->u.syment.n_flags = bfd_asymbol_bfd (&c->symbol)->flags;
811 native->u.syment.n_type = 0;
812 if (symbol->flags & BSF_LOCAL)
813 native->u.syment.n_sclass = C_STAT;
815 native->u.syment.n_sclass = C_EXT;
816 native->u.syment.n_numaux = 0;
818 return coff_write_symbol (abfd, symbol, native, written);
821 /* Write a native symbol to a COFF file. */
824 coff_write_native_symbol (abfd, symbol, written)
826 coff_symbol_type *symbol;
827 unsigned int *written;
829 combined_entry_type *native = symbol->native;
830 alent *lineno = symbol->lineno;
832 /* If this symbol has an associated line number, we must store the
833 symbol index in the line number field. We also tag the auxent to
834 point to the right place in the lineno table. */
835 if (lineno && !symbol->done_lineno)
837 unsigned int count = 0;
838 lineno[count].u.offset = *written;
839 if (native->u.syment.n_numaux)
841 union internal_auxent *a = &((native+1)->u.auxent);
843 a->x_sym.x_fcnary.x_fcn.x_lnnoptr =
844 symbol->symbol.section->output_section->moving_line_filepos;
847 /* Count and relocate all other linenumbers. */
849 while (lineno[count].line_number != 0)
853 I've been told this, but still need proof:
854 > The second bug is also in `bfd/coffcode.h'. This bug
855 > causes the linker to screw up the pc-relocations for
856 > all the line numbers in COFF code. This bug isn't only
857 > specific to A29K implementations, but affects all
858 > systems using COFF format binaries. Note that in COFF
859 > object files, the line number core offsets output by
860 > the assembler are relative to the start of each
861 > procedure, not to the start of the .text section. This
862 > patch relocates the line numbers relative to the
863 > `native->u.syment.n_value' instead of the section
865 > modular!olson@cs.arizona.edu (Jon Olson)
867 lineno[count].u.offset += native->u.syment.n_value;
869 lineno[count].u.offset +=
870 (symbol->symbol.section->output_section->vma
871 + symbol->symbol.section->output_offset);
875 symbol->done_lineno = true;
877 symbol->symbol.section->output_section->moving_line_filepos +=
878 count * bfd_coff_linesz (abfd);
881 return coff_write_symbol (abfd, &(symbol->symbol), native, written);
884 /* Write out the COFF symbols. */
887 coff_write_symbols (abfd)
891 unsigned int limit = bfd_get_symcount(abfd);
892 unsigned int written = 0;
896 debug_string_size = 0;
898 /* Seek to the right place */
899 if (bfd_seek (abfd, obj_sym_filepos(abfd), SEEK_SET) != 0)
902 /* Output all the symbols we have */
905 for (p = abfd->outsymbols, i = 0; i < limit; i++, p++)
907 asymbol *symbol = *p;
908 coff_symbol_type *c_symbol = coff_symbol_from (abfd, symbol);
910 if (c_symbol == (coff_symbol_type *) NULL
911 || c_symbol->native == (combined_entry_type *)NULL)
913 if (! coff_write_alien_symbol (abfd, symbol, &written))
918 if (! coff_write_native_symbol (abfd, c_symbol, &written))
923 bfd_get_symcount (abfd) = written;
925 /* Now write out strings */
927 if (string_size != 0)
929 unsigned int size = string_size + STRING_SIZE_SIZE;
930 bfd_byte buffer[STRING_SIZE_SIZE];
932 #if STRING_SIZE_SIZE == 4
933 bfd_h_put_32 (abfd, size, buffer);
935 #error Change bfd_h_put_32
937 if (bfd_write ((PTR) buffer, 1, sizeof (buffer), abfd) != sizeof (buffer))
939 for (p = abfd->outsymbols, i = 0;
944 size_t name_length = strlen (q->name);
945 coff_symbol_type *c_symbol = coff_symbol_from (abfd, q);
948 /* Figure out whether the symbol name should go in the string
949 table. Symbol names that are short enough are stored
950 directly in the syment structure. File names permit a
951 different, longer, length in the syment structure. On
952 XCOFF, some symbol names are stored in the .debug section
953 rather than in the string table. */
956 || c_symbol->native == NULL)
958 /* This is not a COFF symbol, so it certainly is not a
959 file name, nor does it go in the .debug section. */
962 else if (bfd_coff_symname_in_debug (abfd,
963 &c_symbol->native->u.syment))
965 /* This symbol name is in the XCOFF .debug section.
966 Don't write it into the string table. */
967 maxlen = name_length;
969 else if (c_symbol->native->u.syment.n_sclass == C_FILE)
974 if (name_length > maxlen)
976 if (bfd_write ((PTR) (q->name), 1, name_length + 1, abfd)
984 /* We would normally not write anything here, but we'll write
985 out 4 so that any stupid coff reader which tries to read the
986 string table even when there isn't one won't croak. */
987 unsigned int 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, STRING_SIZE_SIZE, abfd)
1000 /* Make sure the .debug section was created to be the correct size.
1001 We should create it ourselves on the fly, but we don't because
1002 BFD won't let us write to any section until we know how large all
1003 the sections are. We could still do it by making another pass
1004 over the symbols. FIXME. */
1005 BFD_ASSERT (debug_string_size == 0
1006 || (debug_string_section != (asection *) NULL
1007 && (BFD_ALIGN (debug_string_size,
1008 1 << debug_string_section->alignment_power)
1009 == bfd_section_size (abfd, debug_string_section))));
1015 coff_write_linenumbers (abfd)
1019 bfd_size_type linesz;
1022 linesz = bfd_coff_linesz (abfd);
1023 buff = bfd_alloc (abfd, linesz);
1026 bfd_set_error (bfd_error_no_memory);
1029 for (s = abfd->sections; s != (asection *) NULL; s = s->next) {
1030 if (s->lineno_count) {
1031 asymbol **q = abfd->outsymbols;
1032 if (bfd_seek(abfd, s->line_filepos, SEEK_SET) != 0)
1034 /* Find all the linenumbers in this section */
1037 if (p->section->output_section == s) {
1039 BFD_SEND(bfd_asymbol_bfd(p), _get_lineno, (bfd_asymbol_bfd(p), p));
1041 /* Found a linenumber entry, output */
1042 struct internal_lineno out;
1043 memset( (PTR)&out, 0, sizeof(out));
1045 out.l_addr.l_symndx = l->u.offset;
1046 bfd_coff_swap_lineno_out(abfd, &out, buff);
1047 if (bfd_write(buff, 1, linesz, abfd) != linesz)
1050 while (l->line_number) {
1051 out.l_lnno = l->line_number;
1052 out.l_addr.l_symndx = l->u.offset;
1053 bfd_coff_swap_lineno_out(abfd, &out, buff);
1054 if (bfd_write(buff, 1, linesz, abfd) != linesz)
1064 bfd_release (abfd, buff);
1070 coff_get_lineno (ignore_abfd, symbol)
1074 return coffsymbol(symbol)->lineno;
1078 coff_section_symbol (abfd, name)
1082 asection *sec = bfd_make_section_old_way (abfd, name);
1084 combined_entry_type *csym;
1087 csym = coff_symbol_from (abfd, sym)->native;
1088 /* Make sure back-end COFF stuff is there. */
1092 coff_symbol_type sym;
1093 /* @@FIXME This shouldn't use a fixed size!! */
1094 combined_entry_type e[10];
1097 f = (struct foo *) bfd_alloc_by_size_t (abfd, sizeof (*f));
1100 bfd_set_error (bfd_error_no_error);
1103 memset ((char *) f, 0, sizeof (*f));
1104 coff_symbol_from (abfd, sym)->native = csym = f->e;
1106 csym[0].u.syment.n_sclass = C_STAT;
1107 csym[0].u.syment.n_numaux = 1;
1108 /* SF_SET_STATICS (sym); @@ ??? */
1109 csym[1].u.auxent.x_scn.x_scnlen = sec->_raw_size;
1110 csym[1].u.auxent.x_scn.x_nreloc = sec->reloc_count;
1111 csym[1].u.auxent.x_scn.x_nlinno = sec->lineno_count;
1113 if (sec->output_section == NULL)
1115 sec->output_section = sec;
1116 sec->output_offset = 0;
1122 /* This function transforms the offsets into the symbol table into
1123 pointers to syments. */
1126 coff_pointerize_aux (abfd, table_base, type, class, auxent)
1128 combined_entry_type *table_base;
1131 combined_entry_type *auxent;
1133 /* Don't bother if this is a file or a section */
1134 if (class == C_STAT && type == T_NULL) return;
1135 if (class == C_FILE) return;
1137 /* Otherwise patch up */
1138 #define N_TMASK coff_data (abfd)->local_n_tmask
1139 #define N_BTSHFT coff_data (abfd)->local_n_btshft
1140 if (ISFCN(type) || ISTAG(class) || class == C_BLOCK) {
1141 auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p = table_base +
1142 auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l;
1143 auxent->fix_end = 1;
1145 /* A negative tagndx is meaningless, but the SCO 3.2v4 cc can
1146 generate one, so we must be careful to ignore it. */
1147 if (auxent->u.auxent.x_sym.x_tagndx.l > 0) {
1148 auxent->u.auxent.x_sym.x_tagndx.p =
1149 table_base + auxent->u.auxent.x_sym.x_tagndx.l;
1150 auxent->fix_tag = 1;
1155 build_string_table (abfd)
1158 char string_table_size_buffer[STRING_SIZE_SIZE];
1159 unsigned int string_table_size;
1162 /* At this point we should be "seek"'d to the end of the
1163 symbols === the symbol table size. */
1164 if (bfd_read((char *) string_table_size_buffer,
1165 sizeof(string_table_size_buffer),
1166 1, abfd) != sizeof(string_table_size))
1169 #if STRING_SIZE_SIZE == 4
1170 string_table_size = bfd_h_get_32(abfd, (bfd_byte *) string_table_size_buffer);
1172 #error Change bfd_h_get_32
1175 if ((string_table = (PTR) bfd_alloc(abfd,
1176 string_table_size -= STRING_SIZE_SIZE))
1179 bfd_set_error (bfd_error_no_memory);
1181 } /* on mallocation error */
1182 if (bfd_read(string_table, string_table_size, 1, abfd) != string_table_size)
1184 return string_table;
1187 /* Allocate space for the ".debug" section, and read it.
1188 We did not read the debug section until now, because
1189 we didn't want to go to the trouble until someone needed it. */
1192 build_debug_section (abfd)
1195 char *debug_section;
1198 asection *sect = bfd_get_section_by_name (abfd, ".debug");
1201 bfd_set_error (bfd_error_no_debug_section);
1205 debug_section = (PTR) bfd_alloc (abfd,
1206 bfd_get_section_size_before_reloc (sect));
1207 if (debug_section == NULL) {
1208 bfd_set_error (bfd_error_no_memory);
1212 /* Seek to the beginning of the `.debug' section and read it.
1213 Save the current position first; it is needed by our caller.
1214 Then read debug section and reset the file pointer. */
1216 position = bfd_tell (abfd);
1217 if (bfd_seek (abfd, sect->filepos, SEEK_SET) != 0
1218 || (bfd_read (debug_section,
1219 bfd_get_section_size_before_reloc (sect), 1, abfd)
1220 != bfd_get_section_size_before_reloc(sect))
1221 || bfd_seek (abfd, position, SEEK_SET) != 0)
1223 return debug_section;
1227 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
1228 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
1229 be \0-terminated. */
1231 copy_name (abfd, name, maxlen)
1239 for (len = 0; len < maxlen; ++len) {
1240 if (name[len] == '\0') {
1245 if ((newname = (PTR) bfd_alloc(abfd, len+1)) == NULL) {
1246 bfd_set_error (bfd_error_no_memory);
1249 strncpy(newname, name, len);
1250 newname[len] = '\0';
1254 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
1255 knit the symbol names into a normalized form. By normalized here I
1256 mean that all symbols have an n_offset pointer that points to a null-
1257 terminated string. */
1259 combined_entry_type *
1260 coff_get_normalized_symtab (abfd)
1263 combined_entry_type *internal;
1264 combined_entry_type *internal_ptr;
1265 combined_entry_type *symbol_ptr;
1266 combined_entry_type *internal_end;
1267 bfd_size_type symesz;
1271 char *string_table = NULL;
1272 char *debug_section = NULL;
1275 unsigned int raw_size;
1276 if (obj_raw_syments(abfd) != (combined_entry_type *)NULL) {
1277 return obj_raw_syments(abfd);
1279 if ((size = bfd_get_symcount(abfd) * sizeof(combined_entry_type)) == 0) {
1280 bfd_set_error (bfd_error_no_symbols);
1284 internal = (combined_entry_type *)bfd_alloc(abfd, size);
1287 bfd_set_error (bfd_error_no_memory);
1290 internal_end = internal + bfd_get_symcount(abfd);
1292 symesz = bfd_coff_symesz (abfd);
1293 raw_size = bfd_get_symcount(abfd) * symesz;
1294 raw = bfd_alloc(abfd,raw_size);
1297 bfd_set_error (bfd_error_no_memory);
1301 if (bfd_seek(abfd, obj_sym_filepos(abfd), SEEK_SET) == -1
1302 || bfd_read(raw, raw_size, 1, abfd) != raw_size)
1304 /* mark the end of the symbols */
1305 raw_end = (char *) raw + bfd_get_symcount(abfd) * symesz;
1307 FIXME SOMEDAY. A string table size of zero is very weird, but
1308 probably possible. If one shows up, it will probably kill us.
1311 /* Swap all the raw entries */
1312 for (raw_src = (char *) raw, internal_ptr = internal;
1314 raw_src += symesz, internal_ptr++) {
1317 bfd_coff_swap_sym_in(abfd, (PTR)raw_src, (PTR)&internal_ptr->u.syment);
1318 internal_ptr->fix_value = 0;
1319 internal_ptr->fix_tag = 0;
1320 internal_ptr->fix_end = 0;
1321 internal_ptr->fix_scnlen = 0;
1322 symbol_ptr = internal_ptr;
1325 i < symbol_ptr->u.syment.n_numaux;
1331 internal_ptr->fix_value = 0;
1332 internal_ptr->fix_tag = 0;
1333 internal_ptr->fix_end = 0;
1334 internal_ptr->fix_scnlen = 0;
1335 bfd_coff_swap_aux_in(abfd, (PTR) raw_src,
1336 symbol_ptr->u.syment.n_type,
1337 symbol_ptr->u.syment.n_sclass,
1338 i, symbol_ptr->u.syment.n_numaux,
1339 &(internal_ptr->u.auxent));
1340 /* Remember that bal entries arn't pointerized */
1341 if (i != 1 || symbol_ptr->u.syment.n_sclass != C_LEAFPROC)
1344 coff_pointerize_aux(abfd,
1346 symbol_ptr->u.syment.n_type,
1347 symbol_ptr->u.syment.n_sclass,
1354 /* Free all the raw stuff */
1355 bfd_release(abfd, raw);
1357 for (internal_ptr = internal; internal_ptr < internal_end;
1360 if (internal_ptr->u.syment.n_sclass == C_FILE
1361 && internal_ptr->u.syment.n_numaux > 0) {
1362 /* make a file symbol point to the name in the auxent, since
1363 the text ".file" is redundant */
1364 if ((internal_ptr+1)->u.auxent.x_file.x_n.x_zeroes == 0) {
1365 /* the filename is a long one, point into the string table */
1366 if (string_table == NULL) {
1367 string_table = build_string_table(abfd);
1370 internal_ptr->u.syment._n._n_n._n_offset =
1371 (long) (string_table - STRING_SIZE_SIZE +
1372 (internal_ptr+1)->u.auxent.x_file.x_n.x_offset);
1375 /* ordinary short filename, put into memory anyway */
1376 internal_ptr->u.syment._n._n_n._n_offset = (long)
1377 copy_name(abfd, (internal_ptr+1)->u.auxent.x_file.x_fname,
1382 if (internal_ptr->u.syment._n._n_n._n_zeroes != 0) {
1383 /* This is a "short" name. Make it long. */
1384 unsigned long i = 0;
1385 char *newstring = NULL;
1387 /* find the length of this string without walking into memory
1389 for (i = 0; i < 8; ++i) {
1390 if (internal_ptr->u.syment._n._n_name[i] == '\0') {
1392 } /* if end of string */
1393 } /* possible lengths of this string. */
1395 if ((newstring = (PTR) bfd_alloc(abfd, ++i)) == NULL) {
1396 bfd_set_error (bfd_error_no_memory);
1399 memset(newstring, 0, i);
1400 strncpy(newstring, internal_ptr->u.syment._n._n_name, i-1);
1401 internal_ptr->u.syment._n._n_n._n_offset = (long int) newstring;
1402 internal_ptr->u.syment._n._n_n._n_zeroes = 0;
1404 else if (internal_ptr->u.syment._n._n_n._n_offset == 0)
1405 internal_ptr->u.syment._n._n_n._n_offset = (long int) "";
1406 else if (!bfd_coff_symname_in_debug(abfd, &internal_ptr->u.syment)) {
1407 /* Long name already. Point symbol at the string in the table. */
1408 if (string_table == NULL) {
1409 string_table = build_string_table(abfd);
1411 internal_ptr->u.syment._n._n_n._n_offset = (long int)
1414 + internal_ptr->u.syment._n._n_n._n_offset);
1417 /* Long name in debug section. Very similar. */
1418 if (debug_section == NULL) {
1419 debug_section = build_debug_section(abfd);
1421 internal_ptr->u.syment._n._n_n._n_offset = (long int)
1422 (debug_section + internal_ptr->u.syment._n._n_n._n_offset);
1425 internal_ptr += internal_ptr->u.syment.n_numaux;
1428 obj_raw_syments(abfd) = internal;
1429 BFD_ASSERT (obj_raw_syment_count (abfd) == internal_ptr - internal);
1432 } /* coff_get_normalized_symtab() */
1435 coff_get_reloc_upper_bound (abfd, asect)
1439 if (bfd_get_format(abfd) != bfd_object) {
1440 bfd_set_error (bfd_error_invalid_operation);
1443 return (asect->reloc_count + 1) * sizeof(arelent *);
1447 coff_make_empty_symbol (abfd)
1450 coff_symbol_type *new = (coff_symbol_type *) bfd_alloc(abfd, sizeof(coff_symbol_type));
1452 bfd_set_error (bfd_error_no_memory);
1455 memset (new, 0, sizeof *new);
1456 new->symbol.section = 0;
1458 new->lineno = (alent *) NULL;
1459 new->done_lineno = false;
1460 new->symbol.the_bfd = abfd;
1461 return &new->symbol;
1464 /* Make a debugging symbol. */
1467 coff_bfd_make_debug_symbol (abfd, ptr, sz)
1472 coff_symbol_type *new = (coff_symbol_type *) bfd_alloc(abfd, sizeof(coff_symbol_type));
1474 bfd_set_error (bfd_error_no_memory);
1477 /* @@ This shouldn't be using a constant multiplier. */
1478 new->native = (combined_entry_type *) bfd_zalloc (abfd, sizeof (combined_entry_type) * 10);
1481 bfd_set_error (bfd_error_no_memory);
1484 new->symbol.section = &bfd_debug_section;
1485 new->lineno = (alent *) NULL;
1486 new->done_lineno = false;
1487 new->symbol.the_bfd = abfd;
1488 return &new->symbol;
1493 coff_get_symbol_info (abfd, symbol, ret)
1498 bfd_symbol_info (symbol, ret);
1501 /* Print out information about COFF symbol. */
1504 coff_print_symbol (abfd, filep, symbol, how)
1508 bfd_print_symbol_type how;
1510 FILE *file = (FILE *) filep;
1514 case bfd_print_symbol_name:
1515 fprintf (file, "%s", symbol->name);
1518 case bfd_print_symbol_more:
1519 fprintf (file, "coff %s %s",
1520 coffsymbol(symbol)->native ? "n" : "g",
1521 coffsymbol(symbol)->lineno ? "l" : " ");
1524 case bfd_print_symbol_all:
1525 if (coffsymbol(symbol)->native)
1528 combined_entry_type *combined = coffsymbol (symbol)->native;
1529 combined_entry_type *root = obj_raw_syments (abfd);
1530 struct lineno_cache_entry *l = coffsymbol(symbol)->lineno;
1532 fprintf (file,"[%3ld]", (long) (combined - root));
1535 "(sc %2d)(fl 0x%02x)(ty %3x)(sc %3d) (nx %d) 0x%08lx %s",
1536 combined->u.syment.n_scnum,
1537 combined->u.syment.n_flags,
1538 combined->u.syment.n_type,
1539 combined->u.syment.n_sclass,
1540 combined->u.syment.n_numaux,
1541 (unsigned long) combined->u.syment.n_value,
1544 for (aux = 0; aux < combined->u.syment.n_numaux; aux++)
1546 combined_entry_type *auxp = combined + aux + 1;
1550 tagndx = auxp->u.auxent.x_sym.x_tagndx.p - root;
1552 tagndx = auxp->u.auxent.x_sym.x_tagndx.l;
1554 fprintf (file, "\n");
1555 switch (combined->u.syment.n_sclass)
1558 fprintf (file, "File ");
1562 if (combined->u.syment.n_type == T_NULL)
1563 /* probably a section symbol? */
1565 fprintf (file, "AUX scnlen 0x%lx nreloc %d nlnno %d",
1566 (long) auxp->u.auxent.x_scn.x_scnlen,
1567 auxp->u.auxent.x_scn.x_nreloc,
1568 auxp->u.auxent.x_scn.x_nlinno);
1571 /* else fall through */
1574 fprintf (file, "AUX lnno %d size 0x%x tagndx %ld",
1575 auxp->u.auxent.x_sym.x_misc.x_lnsz.x_lnno,
1576 auxp->u.auxent.x_sym.x_misc.x_lnsz.x_size,
1584 fprintf (file, "\n%s :", l->u.sym->name);
1586 while (l->line_number)
1588 fprintf (file, "\n%4d : 0x%lx",
1591 (l->u.offset + symbol->section->vma)));
1598 bfd_print_symbol_vandf ((PTR) file, symbol);
1599 fprintf (file, " %-5s %s %s %s",
1600 symbol->section->name,
1601 coffsymbol(symbol)->native ? "n" : "g",
1602 coffsymbol(symbol)->lineno ? "l" : " ",
1608 /* Provided a BFD, a section and an offset into the section, calculate
1609 and return the name of the source file and the line nearest to the
1614 coff_find_nearest_line (abfd, section, ignore_symbols, offset, filename_ptr,
1615 functionname_ptr, line_ptr)
1618 asymbol **ignore_symbols;
1620 CONST char **filename_ptr;
1621 CONST char **functionname_ptr;
1622 unsigned int *line_ptr;
1624 static bfd *cache_abfd;
1625 static asection *cache_section;
1626 static bfd_vma cache_offset;
1627 static unsigned int cache_i;
1628 static CONST char *cache_function;
1629 static unsigned int line_base = 0;
1632 coff_data_type *cof = coff_data(abfd);
1633 /* Run through the raw syments if available */
1634 combined_entry_type *p;
1635 combined_entry_type *pend;
1640 *functionname_ptr = 0;
1643 /* Don't try and find line numbers in a non coff file */
1644 if (abfd->xvec->flavour != bfd_target_coff_flavour)
1650 /* Find the first C_FILE symbol. */
1651 p = cof->raw_syments;
1652 pend = p + cof->raw_syment_count;
1655 if (p->u.syment.n_sclass == C_FILE)
1657 p += 1 + p->u.syment.n_numaux;
1664 /* Look through the C_FILE symbols to find the best one. */
1665 *filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
1666 maxdiff = (bfd_vma) 0 - (bfd_vma) 1;
1669 combined_entry_type *p2;
1671 for (p2 = p + 1 + p->u.syment.n_numaux;
1673 p2 += 1 + p2->u.syment.n_numaux)
1675 if (p2->u.syment.n_scnum > 0
1677 == coff_section_from_bfd_index (abfd,
1678 p2->u.syment.n_scnum)))
1680 if (p2->u.syment.n_sclass == C_FILE)
1688 && offset >= p2->u.syment.n_value
1689 && offset - p2->u.syment.n_value < maxdiff)
1691 *filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
1692 maxdiff = offset - p2->u.syment.n_value;
1695 /* Avoid endless loops on erroneous files by ensuring that
1696 we always move forward in the file. */
1697 if (p - cof->raw_syments >= p->u.syment.n_value)
1700 p = cof->raw_syments + p->u.syment.n_value;
1701 if (p > pend || p->u.syment.n_sclass != C_FILE)
1706 /* Now wander though the raw linenumbers of the section */
1708 If this is the same BFD as we were previously called with and this is
1709 the same section, and the offset we want is further down then we can
1710 prime the lookup loop
1712 if (abfd == cache_abfd &&
1713 section == cache_section &&
1714 offset >= cache_offset) {
1716 *functionname_ptr = cache_function;
1721 l = §ion->lineno[i];
1723 for (; i < section->lineno_count; i++) {
1724 if (l->line_number == 0) {
1725 /* Get the symbol this line number points at */
1726 coff_symbol_type *coff = (coff_symbol_type *) (l->u.sym);
1727 if (coff->symbol.value > offset)
1729 *functionname_ptr = coff->symbol.name;
1731 combined_entry_type *s = coff->native;
1732 s = s + 1 + s->u.syment.n_numaux;
1734 /* In XCOFF a debugging symbol can follow the function
1736 if (s->u.syment.n_scnum == N_DEBUG)
1737 s = s + 1 + s->u.syment.n_numaux;
1740 S should now point to the .bf of the function
1742 if (s->u.syment.n_numaux) {
1744 The linenumber is stored in the auxent
1746 union internal_auxent *a = &((s + 1)->u.auxent);
1747 line_base = a->x_sym.x_misc.x_lnsz.x_lnno;
1748 *line_ptr = line_base;
1753 if (l->u.offset + bfd_get_section_vma (abfd, section) > offset)
1755 *line_ptr = l->line_number + line_base - 1;
1761 cache_section = section;
1762 cache_offset = offset;
1764 cache_function = *functionname_ptr;
1770 coff_sizeof_headers (abfd, reloc)
1776 if (reloc == false) {
1777 size = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
1780 size = bfd_coff_filhsz (abfd);
1783 size += abfd->section_count * bfd_coff_scnhsz (abfd);