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 /* Get the name of a symbol. The caller must pass in a buffer of size
336 _bfd_coff_internal_syment_name (abfd
, sym
, buf
)
338 const struct internal_syment
*sym
;
341 /* FIXME: It's not clear this will work correctly if sizeof
343 if (sym
->_n
._n_n
._n_zeroes
!= 0
344 || sym
->_n
._n_n
._n_offset
== 0)
346 memcpy (buf
, sym
->_n
._n_name
, SYMNMLEN
);
347 buf
[SYMNMLEN
] = '\0';
354 BFD_ASSERT (sym
->_n
._n_n
._n_offset
>= STRING_SIZE_SIZE
);
355 strings
= obj_coff_strings (abfd
);
358 strings
= _bfd_coff_read_string_table (abfd
);
362 return strings
+ sym
->_n
._n_n
._n_offset
;
366 /* Read in and swap the relocs. This returns a buffer holding the
367 relocs for section SEC in file ABFD. If CACHE is true and
368 INTERNAL_RELOCS is NULL, the relocs read in will be saved in case
369 the function is called again. If EXTERNAL_RELOCS is not NULL, it
370 is a buffer large enough to hold the unswapped relocs. If
371 INTERNAL_RELOCS is not NULL, it is a buffer large enough to hold
372 the swapped relocs. If REQUIRE_INTERNAL is true, then the return
373 value must be INTERNAL_RELOCS. The function returns NULL on error. */
375 struct internal_reloc
*
376 _bfd_coff_read_internal_relocs (abfd
, sec
, cache
, external_relocs
,
377 require_internal
, internal_relocs
)
381 bfd_byte
*external_relocs
;
382 boolean require_internal
;
383 struct internal_reloc
*internal_relocs
;
386 bfd_byte
*free_external
= NULL
;
387 struct internal_reloc
*free_internal
= NULL
;
390 struct internal_reloc
*irel
;
392 if (coff_section_data (abfd
, sec
) != NULL
393 && coff_section_data (abfd
, sec
)->relocs
!= NULL
)
395 if (! require_internal
)
396 return coff_section_data (abfd
, sec
)->relocs
;
397 memcpy (internal_relocs
, coff_section_data (abfd
, sec
)->relocs
,
398 sec
->reloc_count
* sizeof (struct internal_reloc
));
399 return internal_relocs
;
402 relsz
= bfd_coff_relsz (abfd
);
404 if (external_relocs
== NULL
)
406 free_external
= (bfd_byte
*) malloc (sec
->reloc_count
* relsz
);
407 if (free_external
== NULL
&& sec
->reloc_count
> 0)
409 bfd_set_error (bfd_error_no_memory
);
412 external_relocs
= free_external
;
415 if (bfd_seek (abfd
, sec
->rel_filepos
, SEEK_SET
) != 0
416 || (bfd_read (external_relocs
, relsz
, sec
->reloc_count
, abfd
)
417 != relsz
* sec
->reloc_count
))
420 if (internal_relocs
== NULL
)
422 free_internal
= ((struct internal_reloc
*)
423 malloc (sec
->reloc_count
424 * sizeof (struct internal_reloc
)));
425 if (free_internal
== NULL
&& sec
->reloc_count
> 0)
427 bfd_set_error (bfd_error_no_memory
);
430 internal_relocs
= free_internal
;
433 /* Swap in the relocs. */
434 erel
= external_relocs
;
435 erel_end
= erel
+ relsz
* sec
->reloc_count
;
436 irel
= internal_relocs
;
437 for (; erel
< erel_end
; erel
+= relsz
, irel
++)
438 bfd_coff_swap_reloc_in (abfd
, (PTR
) erel
, (PTR
) irel
);
440 if (free_external
!= NULL
)
442 free (free_external
);
443 free_external
= NULL
;
446 if (cache
&& free_internal
!= NULL
)
448 if (coff_section_data (abfd
, sec
) == NULL
)
451 (PTR
) bfd_zalloc (abfd
,
452 sizeof (struct coff_section_tdata
));
453 if (sec
->used_by_bfd
== NULL
)
455 bfd_set_error (bfd_error_no_memory
);
458 coff_section_data (abfd
, sec
)->contents
= NULL
;
460 coff_section_data (abfd
, sec
)->relocs
= free_internal
;
463 return internal_relocs
;
466 if (free_external
!= NULL
)
467 free (free_external
);
468 if (free_internal
!= NULL
)
469 free (free_internal
);
473 /* Set lineno_count for the output sections of a COFF file. */
476 coff_count_linenumbers (abfd
)
479 unsigned int limit
= bfd_get_symcount (abfd
);
487 /* This may be from the backend linker, in which case the
488 lineno_count in the sections is correct. */
489 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
490 total
+= s
->lineno_count
;
494 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
495 BFD_ASSERT (s
->lineno_count
== 0);
497 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
499 asymbol
*q_maybe
= *p
;
501 if (bfd_asymbol_flavour (q_maybe
) == bfd_target_coff_flavour
)
503 coff_symbol_type
*q
= coffsymbol (q_maybe
);
505 /* The AIX 4.1 compiler can sometimes generate line numbers
506 attached to debugging symbols. We try to simply ignore
508 if (q
->lineno
!= NULL
509 && q
->symbol
.section
->owner
!= NULL
)
511 /* This symbol has line numbers. Increment the owning
512 section's linenumber count. */
513 alent
*l
= q
->lineno
;
515 ++q
->symbol
.section
->output_section
->lineno_count
;
518 while (l
->line_number
!= 0)
521 ++q
->symbol
.section
->output_section
->lineno_count
;
531 /* Takes a bfd and a symbol, returns a pointer to the coff specific
532 area of the symbol if there is one. */
536 coff_symbol_from (ignore_abfd
, symbol
)
540 if (bfd_asymbol_flavour (symbol
) != bfd_target_coff_flavour
)
541 return (coff_symbol_type
*) NULL
;
543 if (bfd_asymbol_bfd (symbol
)->tdata
.coff_obj_data
== (coff_data_type
*) NULL
)
544 return (coff_symbol_type
*) NULL
;
546 return (coff_symbol_type
*) symbol
;
550 fixup_symbol_value (coff_symbol_ptr
, syment
)
551 coff_symbol_type
*coff_symbol_ptr
;
552 struct internal_syment
*syment
;
555 /* Normalize the symbol flags */
556 if (bfd_is_com_section (coff_symbol_ptr
->symbol
.section
))
558 /* a common symbol is undefined with a value */
559 syment
->n_scnum
= N_UNDEF
;
560 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
562 else if (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
)
564 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
566 else if (bfd_is_und_section (coff_symbol_ptr
->symbol
.section
))
568 syment
->n_scnum
= N_UNDEF
;
573 if (coff_symbol_ptr
->symbol
.section
)
576 coff_symbol_ptr
->symbol
.section
->output_section
->target_index
;
579 coff_symbol_ptr
->symbol
.value
+
580 coff_symbol_ptr
->symbol
.section
->output_offset
+
581 coff_symbol_ptr
->symbol
.section
->output_section
->vma
;
586 /* This can happen, but I don't know why yet (steve@cygnus.com) */
587 syment
->n_scnum
= N_ABS
;
588 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
593 /* Run through all the symbols in the symbol table and work out what
594 their indexes into the symbol table will be when output.
596 Coff requires that each C_FILE symbol points to the next one in the
597 chain, and that the last one points to the first external symbol. We
601 coff_renumber_symbols (bfd_ptr
, first_undef
)
605 unsigned int symbol_count
= bfd_get_symcount (bfd_ptr
);
606 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
607 unsigned int native_index
= 0;
608 struct internal_syment
*last_file
= (struct internal_syment
*) NULL
;
609 unsigned int symbol_index
;
611 /* COFF demands that undefined symbols come after all other symbols.
612 Since we don't need to impose this extra knowledge on all our
613 client programs, deal with that here. Sort the symbol table;
614 just move the undefined symbols to the end, leaving the rest
615 alone. The O'Reilly book says that defined global symbols come
616 at the end before the undefined symbols, so we do that here as
618 /* @@ Do we have some condition we could test for, so we don't always
619 have to do this? I don't think relocatability is quite right, but
620 I'm not certain. [raeburn:19920508.1711EST] */
625 newsyms
= (asymbol
**) bfd_alloc_by_size_t (bfd_ptr
,
627 * (symbol_count
+ 1));
630 bfd_set_error (bfd_error_no_memory
);
633 bfd_ptr
->outsymbols
= newsyms
;
634 for (i
= 0; i
< symbol_count
; i
++)
635 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) != 0
636 || (!bfd_is_und_section (symbol_ptr_ptr
[i
]->section
)
637 && ((symbol_ptr_ptr
[i
]->flags
& (BSF_GLOBAL
| BSF_FUNCTION
))
639 *newsyms
++ = symbol_ptr_ptr
[i
];
641 for (i
= 0; i
< symbol_count
; i
++)
642 if (!bfd_is_und_section (symbol_ptr_ptr
[i
]->section
)
643 && ((symbol_ptr_ptr
[i
]->flags
& (BSF_GLOBAL
647 *newsyms
++ = symbol_ptr_ptr
[i
];
649 *first_undef
= newsyms
- bfd_ptr
->outsymbols
;
651 for (i
= 0; i
< symbol_count
; i
++)
652 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) == 0
653 && bfd_is_und_section (symbol_ptr_ptr
[i
]->section
))
654 *newsyms
++ = symbol_ptr_ptr
[i
];
655 *newsyms
= (asymbol
*) NULL
;
656 symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
659 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
661 coff_symbol_type
*coff_symbol_ptr
= coff_symbol_from (bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
662 symbol_ptr_ptr
[symbol_index
]->udata
.i
= symbol_index
;
663 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
)
665 combined_entry_type
*s
= coff_symbol_ptr
->native
;
668 if (s
->u
.syment
.n_sclass
== C_FILE
)
670 if (last_file
!= (struct internal_syment
*) NULL
)
671 last_file
->n_value
= native_index
;
672 last_file
= &(s
->u
.syment
);
677 /* Modify the symbol values according to their section and
680 fixup_symbol_value (coff_symbol_ptr
, &(s
->u
.syment
));
682 for (i
= 0; i
< s
->u
.syment
.n_numaux
+ 1; i
++)
683 s
[i
].offset
= native_index
++;
690 obj_conv_table_size (bfd_ptr
) = native_index
;
695 /* Run thorough the symbol table again, and fix it so that all
696 pointers to entries are changed to the entries' index in the output
700 coff_mangle_symbols (bfd_ptr
)
703 unsigned int symbol_count
= bfd_get_symcount (bfd_ptr
);
704 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
705 unsigned int symbol_index
;
707 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
709 coff_symbol_type
*coff_symbol_ptr
=
710 coff_symbol_from (bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
712 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
)
715 combined_entry_type
*s
= coff_symbol_ptr
->native
;
719 /* FIXME: We should use a union here. */
720 s
->u
.syment
.n_value
=
721 ((combined_entry_type
*) s
->u
.syment
.n_value
)->offset
;
726 /* The value is the offset into the line number entries
727 for the symbol's section. On output, the symbol's
728 section should be N_DEBUG. */
729 s
->u
.syment
.n_value
=
730 (coff_symbol_ptr
->symbol
.section
->output_section
->line_filepos
731 + s
->u
.syment
.n_value
* bfd_coff_linesz (bfd_ptr
));
732 coff_symbol_ptr
->symbol
.section
=
733 coff_section_from_bfd_index (bfd_ptr
, N_DEBUG
);
734 BFD_ASSERT (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
);
736 for (i
= 0; i
< s
->u
.syment
.n_numaux
; i
++)
738 combined_entry_type
*a
= s
+ i
+ 1;
741 a
->u
.auxent
.x_sym
.x_tagndx
.l
=
742 a
->u
.auxent
.x_sym
.x_tagndx
.p
->offset
;
747 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
748 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
->offset
;
753 a
->u
.auxent
.x_csect
.x_scnlen
.l
=
754 a
->u
.auxent
.x_csect
.x_scnlen
.p
->offset
;
763 coff_fix_symbol_name (abfd
, symbol
, native
, string_size_p
,
764 debug_string_section_p
, debug_string_size_p
)
767 combined_entry_type
*native
;
768 bfd_size_type
*string_size_p
;
769 asection
**debug_string_section_p
;
770 bfd_size_type
*debug_string_size_p
;
772 unsigned int name_length
;
773 union internal_auxent
*auxent
;
774 char *name
= (char *) (symbol
->name
);
776 if (name
== (char *) NULL
)
778 /* coff symbols always have names, so we'll make one up */
779 symbol
->name
= "strange";
780 name
= (char *) symbol
->name
;
782 name_length
= strlen (name
);
784 if (native
->u
.syment
.n_sclass
== C_FILE
785 && native
->u
.syment
.n_numaux
> 0)
787 strncpy (native
->u
.syment
._n
._n_name
, ".file", SYMNMLEN
);
788 auxent
= &(native
+ 1)->u
.auxent
;
790 if (bfd_coff_long_filenames (abfd
))
792 if (name_length
<= FILNMLEN
)
794 strncpy (auxent
->x_file
.x_fname
, name
, FILNMLEN
);
798 auxent
->x_file
.x_n
.x_offset
= *string_size_p
+ STRING_SIZE_SIZE
;
799 auxent
->x_file
.x_n
.x_zeroes
= 0;
800 *string_size_p
+= name_length
+ 1;
805 strncpy (auxent
->x_file
.x_fname
, name
, FILNMLEN
);
806 if (name_length
> FILNMLEN
)
808 name
[FILNMLEN
] = '\0';
814 if (name_length
<= SYMNMLEN
)
816 /* This name will fit into the symbol neatly */
817 strncpy (native
->u
.syment
._n
._n_name
, symbol
->name
, SYMNMLEN
);
819 else if (!bfd_coff_symname_in_debug (abfd
, &native
->u
.syment
))
821 native
->u
.syment
._n
._n_n
._n_offset
= (*string_size_p
823 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
824 *string_size_p
+= name_length
+ 1;
831 /* This name should be written into the .debug section. For
832 some reason each name is preceded by a two byte length
833 and also followed by a null byte. FIXME: We assume that
834 the .debug section has already been created, and that it
836 if (*debug_string_section_p
== (asection
*) NULL
)
837 *debug_string_section_p
= bfd_get_section_by_name (abfd
, ".debug");
838 filepos
= bfd_tell (abfd
);
839 bfd_put_16 (abfd
, name_length
+ 1, buf
);
840 if (!bfd_set_section_contents (abfd
,
841 *debug_string_section_p
,
843 (file_ptr
) *debug_string_size_p
,
845 || !bfd_set_section_contents (abfd
,
846 *debug_string_section_p
,
848 ((file_ptr
) *debug_string_size_p
850 (bfd_size_type
) name_length
+ 1))
852 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
854 native
->u
.syment
._n
._n_n
._n_offset
= *debug_string_size_p
+ 2;
855 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
856 *debug_string_size_p
+= name_length
+ 3;
861 /* We need to keep track of the symbol index so that when we write out
862 the relocs we can get the index for a symbol. This method is a
865 #define set_index(symbol, idx) ((symbol)->udata.i = (idx))
867 /* Write a symbol out to a COFF file. */
870 coff_write_symbol (abfd
, symbol
, native
, written
, string_size_p
,
871 debug_string_section_p
, debug_string_size_p
)
874 combined_entry_type
*native
;
875 unsigned int *written
;
876 bfd_size_type
*string_size_p
;
877 asection
**debug_string_section_p
;
878 bfd_size_type
*debug_string_size_p
;
880 unsigned int numaux
= native
->u
.syment
.n_numaux
;
881 int type
= native
->u
.syment
.n_type
;
882 int class = native
->u
.syment
.n_sclass
;
884 bfd_size_type symesz
;
886 if (native
->u
.syment
.n_sclass
== C_FILE
)
887 symbol
->flags
|= BSF_DEBUGGING
;
889 if (symbol
->flags
& BSF_DEBUGGING
890 && bfd_is_abs_section (symbol
->section
))
892 native
->u
.syment
.n_scnum
= N_DEBUG
;
894 else if (bfd_is_abs_section (symbol
->section
))
896 native
->u
.syment
.n_scnum
= N_ABS
;
898 else if (bfd_is_und_section (symbol
->section
))
900 native
->u
.syment
.n_scnum
= N_UNDEF
;
904 native
->u
.syment
.n_scnum
=
905 symbol
->section
->output_section
->target_index
;
908 coff_fix_symbol_name (abfd
, symbol
, native
, string_size_p
,
909 debug_string_section_p
, debug_string_size_p
);
911 symesz
= bfd_coff_symesz (abfd
);
912 buf
= bfd_alloc (abfd
, symesz
);
915 bfd_set_error (bfd_error_no_memory
);
918 bfd_coff_swap_sym_out (abfd
, &native
->u
.syment
, buf
);
919 if (bfd_write (buf
, 1, symesz
, abfd
) != symesz
)
921 bfd_release (abfd
, buf
);
923 if (native
->u
.syment
.n_numaux
> 0)
925 bfd_size_type auxesz
;
928 auxesz
= bfd_coff_auxesz (abfd
);
929 buf
= bfd_alloc (abfd
, auxesz
);
932 bfd_set_error (bfd_error_no_memory
);
935 for (j
= 0; j
< native
->u
.syment
.n_numaux
; j
++)
937 bfd_coff_swap_aux_out (abfd
,
938 &((native
+ j
+ 1)->u
.auxent
),
942 native
->u
.syment
.n_numaux
,
944 if (bfd_write (buf
, 1, auxesz
, abfd
) != auxesz
)
947 bfd_release (abfd
, buf
);
950 /* Store the index for use when we write out the relocs. */
951 set_index (symbol
, *written
);
953 *written
+= numaux
+ 1;
957 /* Write out a symbol to a COFF file that does not come from a COFF
958 file originally. This symbol may have been created by the linker,
959 or we may be linking a non COFF file to a COFF file. */
962 coff_write_alien_symbol (abfd
, symbol
, written
, string_size_p
,
963 debug_string_section_p
, debug_string_size_p
)
966 unsigned int *written
;
967 bfd_size_type
*string_size_p
;
968 asection
**debug_string_section_p
;
969 bfd_size_type
*debug_string_size_p
;
971 combined_entry_type
*native
;
972 combined_entry_type dummy
;
975 native
->u
.syment
.n_type
= T_NULL
;
976 native
->u
.syment
.n_flags
= 0;
977 if (bfd_is_und_section (symbol
->section
))
979 native
->u
.syment
.n_scnum
= N_UNDEF
;
980 native
->u
.syment
.n_value
= symbol
->value
;
982 else if (bfd_is_com_section (symbol
->section
))
984 native
->u
.syment
.n_scnum
= N_UNDEF
;
985 native
->u
.syment
.n_value
= symbol
->value
;
987 else if (symbol
->flags
& BSF_DEBUGGING
)
989 /* There isn't much point to writing out a debugging symbol
990 unless we are prepared to convert it into COFF debugging
991 format. So, we just ignore them. We must clobber the symbol
992 name to keep it from being put in the string table. */
998 native
->u
.syment
.n_scnum
=
999 symbol
->section
->output_section
->target_index
;
1000 native
->u
.syment
.n_value
= (symbol
->value
1001 + symbol
->section
->output_section
->vma
1002 + symbol
->section
->output_offset
);
1004 /* Copy the any flags from the the file header into the symbol.
1007 coff_symbol_type
*c
= coff_symbol_from (abfd
, symbol
);
1008 if (c
!= (coff_symbol_type
*) NULL
)
1009 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (&c
->symbol
)->flags
;
1013 native
->u
.syment
.n_type
= 0;
1014 if (symbol
->flags
& BSF_LOCAL
)
1015 native
->u
.syment
.n_sclass
= C_STAT
;
1017 native
->u
.syment
.n_sclass
= C_EXT
;
1018 native
->u
.syment
.n_numaux
= 0;
1020 return coff_write_symbol (abfd
, symbol
, native
, written
, string_size_p
,
1021 debug_string_section_p
, debug_string_size_p
);
1024 /* Write a native symbol to a COFF file. */
1027 coff_write_native_symbol (abfd
, symbol
, written
, string_size_p
,
1028 debug_string_section_p
, debug_string_size_p
)
1030 coff_symbol_type
*symbol
;
1031 unsigned int *written
;
1032 bfd_size_type
*string_size_p
;
1033 asection
**debug_string_section_p
;
1034 bfd_size_type
*debug_string_size_p
;
1036 combined_entry_type
*native
= symbol
->native
;
1037 alent
*lineno
= symbol
->lineno
;
1039 /* If this symbol has an associated line number, we must store the
1040 symbol index in the line number field. We also tag the auxent to
1041 point to the right place in the lineno table. */
1042 if (lineno
&& !symbol
->done_lineno
&& symbol
->symbol
.section
->owner
!= NULL
)
1044 unsigned int count
= 0;
1045 lineno
[count
].u
.offset
= *written
;
1046 if (native
->u
.syment
.n_numaux
)
1048 union internal_auxent
*a
= &((native
+ 1)->u
.auxent
);
1050 a
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1051 symbol
->symbol
.section
->output_section
->moving_line_filepos
;
1054 /* Count and relocate all other linenumbers. */
1056 while (lineno
[count
].line_number
!= 0)
1060 I've been told this, but still need proof:
1061 > The second bug is also in `bfd/coffcode.h'. This bug
1062 > causes the linker to screw up the pc-relocations for
1063 > all the line numbers in COFF code. This bug isn't only
1064 > specific to A29K implementations, but affects all
1065 > systems using COFF format binaries. Note that in COFF
1066 > object files, the line number core offsets output by
1067 > the assembler are relative to the start of each
1068 > procedure, not to the start of the .text section. This
1069 > patch relocates the line numbers relative to the
1070 > `native->u.syment.n_value' instead of the section
1072 > modular!olson@cs.arizona.edu (Jon Olson)
1074 lineno
[count
].u
.offset
+= native
->u
.syment
.n_value
;
1076 lineno
[count
].u
.offset
+=
1077 (symbol
->symbol
.section
->output_section
->vma
1078 + symbol
->symbol
.section
->output_offset
);
1082 symbol
->done_lineno
= true;
1084 symbol
->symbol
.section
->output_section
->moving_line_filepos
+=
1085 count
* bfd_coff_linesz (abfd
);
1088 return coff_write_symbol (abfd
, &(symbol
->symbol
), native
, written
,
1089 string_size_p
, debug_string_section_p
,
1090 debug_string_size_p
);
1093 /* Write out the COFF symbols. */
1096 coff_write_symbols (abfd
)
1099 bfd_size_type string_size
;
1100 asection
*debug_string_section
;
1101 bfd_size_type debug_string_size
;
1103 unsigned int limit
= bfd_get_symcount (abfd
);
1104 unsigned int written
= 0;
1108 debug_string_section
= NULL
;
1109 debug_string_size
= 0;
1111 /* Seek to the right place */
1112 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
1115 /* Output all the symbols we have */
1118 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1120 asymbol
*symbol
= *p
;
1121 coff_symbol_type
*c_symbol
= coff_symbol_from (abfd
, symbol
);
1123 if (c_symbol
== (coff_symbol_type
*) NULL
1124 || c_symbol
->native
== (combined_entry_type
*) NULL
)
1126 if (!coff_write_alien_symbol (abfd
, symbol
, &written
, &string_size
,
1127 &debug_string_section
,
1128 &debug_string_size
))
1133 if (!coff_write_native_symbol (abfd
, c_symbol
, &written
,
1134 &string_size
, &debug_string_section
,
1135 &debug_string_size
))
1140 obj_raw_syment_count (abfd
) = written
;
1142 /* Now write out strings */
1144 if (string_size
!= 0)
1146 unsigned int size
= string_size
+ STRING_SIZE_SIZE
;
1147 bfd_byte buffer
[STRING_SIZE_SIZE
];
1149 #if STRING_SIZE_SIZE == 4
1150 bfd_h_put_32 (abfd
, size
, buffer
);
1152 #error Change bfd_h_put_32
1154 if (bfd_write ((PTR
) buffer
, 1, sizeof (buffer
), abfd
) != sizeof (buffer
))
1156 for (p
= abfd
->outsymbols
, i
= 0;
1161 size_t name_length
= strlen (q
->name
);
1162 coff_symbol_type
*c_symbol
= coff_symbol_from (abfd
, q
);
1165 /* Figure out whether the symbol name should go in the string
1166 table. Symbol names that are short enough are stored
1167 directly in the syment structure. File names permit a
1168 different, longer, length in the syment structure. On
1169 XCOFF, some symbol names are stored in the .debug section
1170 rather than in the string table. */
1172 if (c_symbol
== NULL
1173 || c_symbol
->native
== NULL
)
1175 /* This is not a COFF symbol, so it certainly is not a
1176 file name, nor does it go in the .debug section. */
1179 else if (bfd_coff_symname_in_debug (abfd
,
1180 &c_symbol
->native
->u
.syment
))
1182 /* This symbol name is in the XCOFF .debug section.
1183 Don't write it into the string table. */
1184 maxlen
= name_length
;
1186 else if (c_symbol
->native
->u
.syment
.n_sclass
== C_FILE
1187 && c_symbol
->native
->u
.syment
.n_numaux
> 0)
1192 if (name_length
> maxlen
)
1194 if (bfd_write ((PTR
) (q
->name
), 1, name_length
+ 1, abfd
)
1202 /* We would normally not write anything here, but we'll write
1203 out 4 so that any stupid coff reader which tries to read the
1204 string table even when there isn't one won't croak. */
1205 unsigned int size
= STRING_SIZE_SIZE
;
1206 bfd_byte buffer
[STRING_SIZE_SIZE
];
1208 #if STRING_SIZE_SIZE == 4
1209 bfd_h_put_32 (abfd
, size
, buffer
);
1211 #error Change bfd_h_put_32
1213 if (bfd_write ((PTR
) buffer
, 1, STRING_SIZE_SIZE
, abfd
)
1214 != STRING_SIZE_SIZE
)
1218 /* Make sure the .debug section was created to be the correct size.
1219 We should create it ourselves on the fly, but we don't because
1220 BFD won't let us write to any section until we know how large all
1221 the sections are. We could still do it by making another pass
1222 over the symbols. FIXME. */
1223 BFD_ASSERT (debug_string_size
== 0
1224 || (debug_string_section
!= (asection
*) NULL
1225 && (BFD_ALIGN (debug_string_size
,
1226 1 << debug_string_section
->alignment_power
)
1227 == bfd_section_size (abfd
, debug_string_section
))));
1233 coff_write_linenumbers (abfd
)
1237 bfd_size_type linesz
;
1240 linesz
= bfd_coff_linesz (abfd
);
1241 buff
= bfd_alloc (abfd
, linesz
);
1244 bfd_set_error (bfd_error_no_memory
);
1247 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
1249 if (s
->lineno_count
)
1251 asymbol
**q
= abfd
->outsymbols
;
1252 if (bfd_seek (abfd
, s
->line_filepos
, SEEK_SET
) != 0)
1254 /* Find all the linenumbers in this section */
1258 if (p
->section
->output_section
== s
)
1261 BFD_SEND (bfd_asymbol_bfd (p
), _get_lineno
,
1262 (bfd_asymbol_bfd (p
), p
));
1265 /* Found a linenumber entry, output */
1266 struct internal_lineno out
;
1267 memset ((PTR
) & out
, 0, sizeof (out
));
1269 out
.l_addr
.l_symndx
= l
->u
.offset
;
1270 bfd_coff_swap_lineno_out (abfd
, &out
, buff
);
1271 if (bfd_write (buff
, 1, linesz
, abfd
) != linesz
)
1274 while (l
->line_number
)
1276 out
.l_lnno
= l
->line_number
;
1277 out
.l_addr
.l_symndx
= l
->u
.offset
;
1278 bfd_coff_swap_lineno_out (abfd
, &out
, buff
);
1279 if (bfd_write (buff
, 1, linesz
, abfd
) != linesz
)
1289 bfd_release (abfd
, buff
);
1295 coff_get_lineno (ignore_abfd
, symbol
)
1299 return coffsymbol (symbol
)->lineno
;
1303 coff_section_symbol (abfd
, name
)
1307 asection
*sec
= bfd_make_section_old_way (abfd
, name
);
1309 combined_entry_type
*csym
;
1312 csym
= coff_symbol_from (abfd
, sym
)->native
;
1313 /* Make sure back-end COFF stuff is there. */
1318 coff_symbol_type sym
;
1319 /* @@FIXME This shouldn't use a fixed size!! */
1320 combined_entry_type e
[10];
1323 f
= (struct foo
*) bfd_alloc_by_size_t (abfd
, sizeof (*f
));
1326 bfd_set_error (bfd_error_no_error
);
1329 memset ((char *) f
, 0, sizeof (*f
));
1330 coff_symbol_from (abfd
, sym
)->native
= csym
= f
->e
;
1332 csym
[0].u
.syment
.n_sclass
= C_STAT
;
1333 csym
[0].u
.syment
.n_numaux
= 1;
1334 /* SF_SET_STATICS (sym); @@ ??? */
1335 csym
[1].u
.auxent
.x_scn
.x_scnlen
= sec
->_raw_size
;
1336 csym
[1].u
.auxent
.x_scn
.x_nreloc
= sec
->reloc_count
;
1337 csym
[1].u
.auxent
.x_scn
.x_nlinno
= sec
->lineno_count
;
1339 if (sec
->output_section
== NULL
)
1341 sec
->output_section
= sec
;
1342 sec
->output_offset
= 0;
1348 /* This function transforms the offsets into the symbol table into
1349 pointers to syments. */
1352 coff_pointerize_aux (abfd
, table_base
, symbol
, indaux
, auxent
)
1354 combined_entry_type
*table_base
;
1355 combined_entry_type
*symbol
;
1356 unsigned int indaux
;
1357 combined_entry_type
*auxent
;
1359 int type
= symbol
->u
.syment
.n_type
;
1360 int class = symbol
->u
.syment
.n_sclass
;
1362 if (coff_backend_info (abfd
)->_bfd_coff_pointerize_aux_hook
)
1364 if ((*coff_backend_info (abfd
)->_bfd_coff_pointerize_aux_hook
)
1365 (abfd
, table_base
, symbol
, indaux
, auxent
))
1369 /* Don't bother if this is a file or a section */
1370 if (class == C_STAT
&& type
== T_NULL
)
1372 if (class == C_FILE
)
1375 /* Otherwise patch up */
1376 #define N_TMASK coff_data (abfd)->local_n_tmask
1377 #define N_BTSHFT coff_data (abfd)->local_n_btshft
1378 if ((ISFCN (type
) || ISTAG (class) || class == C_BLOCK
)
1379 && auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
> 0)
1381 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
=
1382 table_base
+ auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
1383 auxent
->fix_end
= 1;
1385 /* A negative tagndx is meaningless, but the SCO 3.2v4 cc can
1386 generate one, so we must be careful to ignore it. */
1387 if (auxent
->u
.auxent
.x_sym
.x_tagndx
.l
> 0)
1389 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
=
1390 table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
;
1391 auxent
->fix_tag
= 1;
1395 /* Allocate space for the ".debug" section, and read it.
1396 We did not read the debug section until now, because
1397 we didn't want to go to the trouble until someone needed it. */
1400 build_debug_section (abfd
)
1403 char *debug_section
;
1406 asection
*sect
= bfd_get_section_by_name (abfd
, ".debug");
1410 bfd_set_error (bfd_error_no_debug_section
);
1414 debug_section
= (PTR
) bfd_alloc (abfd
,
1415 bfd_get_section_size_before_reloc (sect
));
1416 if (debug_section
== NULL
)
1418 bfd_set_error (bfd_error_no_memory
);
1422 /* Seek to the beginning of the `.debug' section and read it.
1423 Save the current position first; it is needed by our caller.
1424 Then read debug section and reset the file pointer. */
1426 position
= bfd_tell (abfd
);
1427 if (bfd_seek (abfd
, sect
->filepos
, SEEK_SET
) != 0
1428 || (bfd_read (debug_section
,
1429 bfd_get_section_size_before_reloc (sect
), 1, abfd
)
1430 != bfd_get_section_size_before_reloc (sect
))
1431 || bfd_seek (abfd
, position
, SEEK_SET
) != 0)
1433 return debug_section
;
1437 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
1438 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
1439 be \0-terminated. */
1441 copy_name (abfd
, name
, maxlen
)
1449 for (len
= 0; len
< maxlen
; ++len
)
1451 if (name
[len
] == '\0')
1457 if ((newname
= (PTR
) bfd_alloc (abfd
, len
+ 1)) == NULL
)
1459 bfd_set_error (bfd_error_no_memory
);
1462 strncpy (newname
, name
, len
);
1463 newname
[len
] = '\0';
1467 /* Read in the external symbols. */
1470 _bfd_coff_get_external_symbols (abfd
)
1473 bfd_size_type symesz
;
1477 if (obj_coff_external_syms (abfd
) != NULL
)
1480 symesz
= bfd_coff_symesz (abfd
);
1482 size
= obj_raw_syment_count (abfd
) * symesz
;
1484 syms
= malloc (size
);
1485 if (syms
== NULL
&& size
!= 0)
1487 bfd_set_error (bfd_error_no_memory
);
1491 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
1492 || bfd_read (syms
, size
, 1, abfd
) != size
)
1499 obj_coff_external_syms (abfd
) = syms
;
1504 /* Read in the external strings. The strings are not loaded until
1505 they are needed. This is because we have no simple way of
1506 detecting a missing string table in an archive. */
1509 _bfd_coff_read_string_table (abfd
)
1512 char extstrsize
[STRING_SIZE_SIZE
];
1516 if (obj_coff_strings (abfd
) != NULL
)
1517 return obj_coff_strings (abfd
);
1520 (obj_sym_filepos (abfd
)
1521 + obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
)),
1525 if (bfd_read (extstrsize
, sizeof extstrsize
, 1, abfd
) != sizeof extstrsize
)
1527 if (bfd_get_error () != bfd_error_file_truncated
)
1530 /* There is no string table. */
1531 strsize
= STRING_SIZE_SIZE
;
1535 #if STRING_SIZE_SIZE == 4
1536 strsize
= bfd_h_get_32 (abfd
, (bfd_byte
*) extstrsize
);
1538 #error Change bfd_h_get_32
1542 strings
= malloc (strsize
);
1543 if (strings
== NULL
)
1545 bfd_set_error (bfd_error_no_memory
);
1549 if (bfd_read (strings
+ STRING_SIZE_SIZE
,
1550 strsize
- STRING_SIZE_SIZE
, 1, abfd
)
1551 != strsize
- STRING_SIZE_SIZE
)
1557 obj_coff_strings (abfd
) = strings
;
1562 /* Free up the external symbols and strings read from a COFF file. */
1565 _bfd_coff_free_symbols (abfd
)
1568 if (obj_coff_external_syms (abfd
) != NULL
1569 && ! obj_coff_keep_syms (abfd
))
1571 free (obj_coff_external_syms (abfd
));
1572 obj_coff_external_syms (abfd
) = NULL
;
1574 if (obj_coff_strings (abfd
) != NULL
1575 && ! obj_coff_keep_strings (abfd
))
1577 free (obj_coff_strings (abfd
));
1578 obj_coff_strings (abfd
) = NULL
;
1583 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
1584 knit the symbol names into a normalized form. By normalized here I
1585 mean that all symbols have an n_offset pointer that points to a null-
1586 terminated string. */
1588 combined_entry_type
*
1589 coff_get_normalized_symtab (abfd
)
1592 combined_entry_type
*internal
;
1593 combined_entry_type
*internal_ptr
;
1594 combined_entry_type
*symbol_ptr
;
1595 combined_entry_type
*internal_end
;
1596 bfd_size_type symesz
;
1599 const char *string_table
= NULL
;
1600 char *debug_section
= NULL
;
1603 if (obj_raw_syments (abfd
) != NULL
)
1604 return obj_raw_syments (abfd
);
1606 size
= obj_raw_syment_count (abfd
) * sizeof (combined_entry_type
);
1607 internal
= (combined_entry_type
*) bfd_alloc (abfd
, size
);
1608 if (internal
== NULL
&& size
!= 0)
1610 bfd_set_error (bfd_error_no_memory
);
1613 internal_end
= internal
+ obj_raw_syment_count (abfd
);
1615 if (! _bfd_coff_get_external_symbols (abfd
))
1618 raw_src
= (char *) obj_coff_external_syms (abfd
);
1620 /* mark the end of the symbols */
1621 symesz
= bfd_coff_symesz (abfd
);
1622 raw_end
= (char *) raw_src
+ obj_raw_syment_count (abfd
) * symesz
;
1624 /* FIXME SOMEDAY. A string table size of zero is very weird, but
1625 probably possible. If one shows up, it will probably kill us. */
1627 /* Swap all the raw entries */
1628 for (internal_ptr
= internal
;
1630 raw_src
+= symesz
, internal_ptr
++)
1634 bfd_coff_swap_sym_in (abfd
, (PTR
) raw_src
,
1635 (PTR
) & internal_ptr
->u
.syment
);
1636 internal_ptr
->fix_value
= 0;
1637 internal_ptr
->fix_tag
= 0;
1638 internal_ptr
->fix_end
= 0;
1639 internal_ptr
->fix_scnlen
= 0;
1640 symbol_ptr
= internal_ptr
;
1643 i
< symbol_ptr
->u
.syment
.n_numaux
;
1649 internal_ptr
->fix_value
= 0;
1650 internal_ptr
->fix_tag
= 0;
1651 internal_ptr
->fix_end
= 0;
1652 internal_ptr
->fix_scnlen
= 0;
1653 bfd_coff_swap_aux_in (abfd
, (PTR
) raw_src
,
1654 symbol_ptr
->u
.syment
.n_type
,
1655 symbol_ptr
->u
.syment
.n_sclass
,
1656 i
, symbol_ptr
->u
.syment
.n_numaux
,
1657 &(internal_ptr
->u
.auxent
));
1658 coff_pointerize_aux (abfd
, internal
, symbol_ptr
, i
,
1663 /* Free the raw symbols, but not the strings (if we have them). */
1664 obj_coff_keep_strings (abfd
) = true;
1665 if (! _bfd_coff_free_symbols (abfd
))
1668 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
1671 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
1672 && internal_ptr
->u
.syment
.n_numaux
> 0)
1674 /* make a file symbol point to the name in the auxent, since
1675 the text ".file" is redundant */
1676 if ((internal_ptr
+ 1)->u
.auxent
.x_file
.x_n
.x_zeroes
== 0)
1678 /* the filename is a long one, point into the string table */
1679 if (string_table
== NULL
)
1681 string_table
= _bfd_coff_read_string_table (abfd
);
1682 if (string_table
== NULL
)
1686 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1689 + (internal_ptr
+ 1)->u
.auxent
.x_file
.x_n
.x_offset
));
1693 /* ordinary short filename, put into memory anyway */
1694 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (long)
1695 copy_name (abfd
, (internal_ptr
+ 1)->u
.auxent
.x_file
.x_fname
,
1701 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0)
1703 /* This is a "short" name. Make it long. */
1704 unsigned long i
= 0;
1705 char *newstring
= NULL
;
1707 /* find the length of this string without walking into memory
1709 for (i
= 0; i
< 8; ++i
)
1711 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0')
1714 } /* if end of string */
1715 } /* possible lengths of this string. */
1717 if ((newstring
= (PTR
) bfd_alloc (abfd
, ++i
)) == NULL
)
1719 bfd_set_error (bfd_error_no_memory
);
1722 memset (newstring
, 0, i
);
1723 strncpy (newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
- 1);
1724 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (long int) newstring
;
1725 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1727 else if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
== 0)
1728 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (long int) "";
1729 else if (!bfd_coff_symname_in_debug (abfd
, &internal_ptr
->u
.syment
))
1731 /* Long name already. Point symbol at the string in the
1733 if (string_table
== NULL
)
1735 string_table
= _bfd_coff_read_string_table (abfd
);
1736 if (string_table
== NULL
)
1739 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1742 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
));
1746 /* Long name in debug section. Very similar. */
1747 if (debug_section
== NULL
)
1748 debug_section
= build_debug_section (abfd
);
1749 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (long int)
1750 (debug_section
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
1753 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
1756 obj_raw_syments (abfd
) = internal
;
1757 BFD_ASSERT (obj_raw_syment_count (abfd
)
1758 == (unsigned int) (internal_ptr
- internal
));
1761 } /* coff_get_normalized_symtab() */
1764 coff_get_reloc_upper_bound (abfd
, asect
)
1768 if (bfd_get_format (abfd
) != bfd_object
)
1770 bfd_set_error (bfd_error_invalid_operation
);
1773 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
1777 coff_make_empty_symbol (abfd
)
1780 coff_symbol_type
*new = (coff_symbol_type
*) bfd_alloc (abfd
, sizeof (coff_symbol_type
));
1783 bfd_set_error (bfd_error_no_memory
);
1786 memset (new, 0, sizeof *new);
1787 new->symbol
.section
= 0;
1789 new->lineno
= (alent
*) NULL
;
1790 new->done_lineno
= false;
1791 new->symbol
.the_bfd
= abfd
;
1792 return &new->symbol
;
1795 /* Make a debugging symbol. */
1798 coff_bfd_make_debug_symbol (abfd
, ptr
, sz
)
1803 coff_symbol_type
*new = (coff_symbol_type
*) bfd_alloc (abfd
, sizeof (coff_symbol_type
));
1806 bfd_set_error (bfd_error_no_memory
);
1809 /* @@ This shouldn't be using a constant multiplier. */
1810 new->native
= (combined_entry_type
*) bfd_zalloc (abfd
, sizeof (combined_entry_type
) * 10);
1813 bfd_set_error (bfd_error_no_memory
);
1816 new->symbol
.section
= bfd_abs_section_ptr
;
1817 new->symbol
.flags
= BSF_DEBUGGING
;
1818 new->lineno
= (alent
*) NULL
;
1819 new->done_lineno
= false;
1820 new->symbol
.the_bfd
= abfd
;
1821 return &new->symbol
;
1826 coff_get_symbol_info (abfd
, symbol
, ret
)
1831 bfd_symbol_info (symbol
, ret
);
1832 if (coffsymbol (symbol
)->native
!= NULL
1833 && coffsymbol (symbol
)->native
->fix_value
)
1835 combined_entry_type
*psym
;
1837 psym
= ((combined_entry_type
*)
1838 coffsymbol (symbol
)->native
->u
.syment
.n_value
);
1839 ret
->value
= (bfd_vma
) (psym
- obj_raw_syments (abfd
));
1843 /* Print out information about COFF symbol. */
1846 coff_print_symbol (abfd
, filep
, symbol
, how
)
1850 bfd_print_symbol_type how
;
1852 FILE *file
= (FILE *) filep
;
1856 case bfd_print_symbol_name
:
1857 fprintf (file
, "%s", symbol
->name
);
1860 case bfd_print_symbol_more
:
1861 fprintf (file
, "coff %s %s",
1862 coffsymbol (symbol
)->native
? "n" : "g",
1863 coffsymbol (symbol
)->lineno
? "l" : " ");
1866 case bfd_print_symbol_all
:
1867 if (coffsymbol (symbol
)->native
)
1871 combined_entry_type
*combined
= coffsymbol (symbol
)->native
;
1872 combined_entry_type
*root
= obj_raw_syments (abfd
);
1873 struct lineno_cache_entry
*l
= coffsymbol (symbol
)->lineno
;
1875 fprintf (file
, "[%3ld]", (long) (combined
- root
));
1877 if (! combined
->fix_value
)
1878 val
= (unsigned long) combined
->u
.syment
.n_value
;
1880 val
= ((unsigned long)
1881 ((combined_entry_type
*) combined
->u
.syment
.n_value
1885 "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x%08lx %s",
1886 combined
->u
.syment
.n_scnum
,
1887 combined
->u
.syment
.n_flags
,
1888 combined
->u
.syment
.n_type
,
1889 combined
->u
.syment
.n_sclass
,
1890 combined
->u
.syment
.n_numaux
,
1894 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
1896 combined_entry_type
*auxp
= combined
+ aux
+ 1;
1900 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.p
- root
;
1902 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.l
;
1904 fprintf (file
, "\n");
1906 if (bfd_coff_print_aux (abfd
, file
, root
, combined
, auxp
, aux
))
1909 switch (combined
->u
.syment
.n_sclass
)
1912 fprintf (file
, "File ");
1916 if (combined
->u
.syment
.n_type
== T_NULL
)
1917 /* probably a section symbol? */
1919 fprintf (file
, "AUX scnlen 0x%lx nreloc %d nlnno %d",
1920 (long) auxp
->u
.auxent
.x_scn
.x_scnlen
,
1921 auxp
->u
.auxent
.x_scn
.x_nreloc
,
1922 auxp
->u
.auxent
.x_scn
.x_nlinno
);
1925 /* else fall through */
1928 fprintf (file
, "AUX lnno %d size 0x%x tagndx %ld",
1929 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
1930 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
,
1933 fprintf (file
, " endndx %ld",
1935 (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
1943 fprintf (file
, "\n%s :", l
->u
.sym
->name
);
1945 while (l
->line_number
)
1947 fprintf (file
, "\n%4d : 0x%lx",
1950 (l
->u
.offset
+ symbol
->section
->vma
)));
1957 bfd_print_symbol_vandf ((PTR
) file
, symbol
);
1958 fprintf (file
, " %-5s %s %s %s",
1959 symbol
->section
->name
,
1960 coffsymbol (symbol
)->native
? "n" : "g",
1961 coffsymbol (symbol
)->lineno
? "l" : " ",
1967 /* Provided a BFD, a section and an offset into the section, calculate
1968 and return the name of the source file and the line nearest to the
1973 coff_find_nearest_line (abfd
, section
, ignore_symbols
, offset
, filename_ptr
,
1974 functionname_ptr
, line_ptr
)
1977 asymbol
**ignore_symbols
;
1979 CONST
char **filename_ptr
;
1980 CONST
char **functionname_ptr
;
1981 unsigned int *line_ptr
;
1984 unsigned int line_base
;
1985 coff_data_type
*cof
= coff_data (abfd
);
1986 /* Run through the raw syments if available */
1987 combined_entry_type
*p
;
1988 combined_entry_type
*pend
;
1990 struct coff_section_tdata
*sec_data
;
1993 *functionname_ptr
= 0;
1996 /* Don't try and find line numbers in a non coff file */
1997 if (abfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
2003 /* Find the first C_FILE symbol. */
2004 p
= cof
->raw_syments
;
2005 pend
= p
+ cof
->raw_syment_count
;
2008 if (p
->u
.syment
.n_sclass
== C_FILE
)
2010 p
+= 1 + p
->u
.syment
.n_numaux
;
2017 /* Look through the C_FILE symbols to find the best one. */
2018 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2019 maxdiff
= (bfd_vma
) 0 - (bfd_vma
) 1;
2022 combined_entry_type
*p2
;
2024 for (p2
= p
+ 1 + p
->u
.syment
.n_numaux
;
2026 p2
+= 1 + p2
->u
.syment
.n_numaux
)
2028 if (p2
->u
.syment
.n_scnum
> 0
2030 == coff_section_from_bfd_index (abfd
,
2031 p2
->u
.syment
.n_scnum
)))
2033 if (p2
->u
.syment
.n_sclass
== C_FILE
)
2041 && offset
>= (bfd_vma
) p2
->u
.syment
.n_value
2042 && offset
- (bfd_vma
) p2
->u
.syment
.n_value
< maxdiff
)
2044 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2045 maxdiff
= offset
- p2
->u
.syment
.n_value
;
2048 /* Avoid endless loops on erroneous files by ensuring that
2049 we always move forward in the file. */
2050 if (p
- cof
->raw_syments
>= p
->u
.syment
.n_value
)
2053 p
= cof
->raw_syments
+ p
->u
.syment
.n_value
;
2054 if (p
> pend
|| p
->u
.syment
.n_sclass
!= C_FILE
)
2059 /* Now wander though the raw linenumbers of the section */
2060 /* If we have been called on this section before, and the offset we
2061 want is further down then we can prime the lookup loop. */
2062 sec_data
= coff_section_data (abfd
, section
);
2063 if (sec_data
!= NULL
2065 && offset
>= sec_data
->offset
)
2068 *functionname_ptr
= sec_data
->function
;
2069 line_base
= sec_data
->line_base
;
2077 l
= §ion
->lineno
[i
];
2079 for (; i
< section
->lineno_count
; i
++)
2081 if (l
->line_number
== 0)
2083 /* Get the symbol this line number points at */
2084 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
2085 if (coff
->symbol
.value
> offset
)
2087 *functionname_ptr
= coff
->symbol
.name
;
2090 combined_entry_type
*s
= coff
->native
;
2091 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2093 /* In XCOFF a debugging symbol can follow the function
2095 if (s
->u
.syment
.n_scnum
== N_DEBUG
)
2096 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2099 S should now point to the .bf of the function
2101 if (s
->u
.syment
.n_numaux
)
2104 The linenumber is stored in the auxent
2106 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
2107 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
2108 *line_ptr
= line_base
;
2114 if (l
->u
.offset
+ bfd_get_section_vma (abfd
, section
) > offset
)
2116 *line_ptr
= l
->line_number
+ line_base
- 1;
2121 /* Cache the results for the next call. */
2122 if (sec_data
== NULL
)
2124 section
->used_by_bfd
=
2125 ((PTR
) bfd_zalloc (abfd
,
2126 sizeof (struct coff_section_tdata
)));
2127 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2129 if (sec_data
!= NULL
)
2131 sec_data
->offset
= offset
;
2133 sec_data
->function
= *functionname_ptr
;
2134 sec_data
->line_base
= line_base
;
2141 coff_sizeof_headers (abfd
, reloc
)
2149 size
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
2153 size
= bfd_coff_filhsz (abfd
);
2156 size
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);