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 && !bfd_is_com_section (symbol_ptr_ptr
[i
]->section
)
638 && ((symbol_ptr_ptr
[i
]->flags
& (BSF_GLOBAL
| BSF_FUNCTION
))
640 *newsyms
++ = symbol_ptr_ptr
[i
];
642 for (i
= 0; i
< symbol_count
; i
++)
643 if (!bfd_is_und_section (symbol_ptr_ptr
[i
]->section
)
644 && (bfd_is_com_section (symbol_ptr_ptr
[i
]->section
)
645 || ((symbol_ptr_ptr
[i
]->flags
& (BSF_GLOBAL
649 *newsyms
++ = symbol_ptr_ptr
[i
];
651 *first_undef
= newsyms
- bfd_ptr
->outsymbols
;
653 for (i
= 0; i
< symbol_count
; i
++)
654 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) == 0
655 && bfd_is_und_section (symbol_ptr_ptr
[i
]->section
))
656 *newsyms
++ = symbol_ptr_ptr
[i
];
657 *newsyms
= (asymbol
*) NULL
;
658 symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
661 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
663 coff_symbol_type
*coff_symbol_ptr
= coff_symbol_from (bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
664 symbol_ptr_ptr
[symbol_index
]->udata
.i
= symbol_index
;
665 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
)
667 combined_entry_type
*s
= coff_symbol_ptr
->native
;
670 if (s
->u
.syment
.n_sclass
== C_FILE
)
672 if (last_file
!= (struct internal_syment
*) NULL
)
673 last_file
->n_value
= native_index
;
674 last_file
= &(s
->u
.syment
);
679 /* Modify the symbol values according to their section and
682 fixup_symbol_value (coff_symbol_ptr
, &(s
->u
.syment
));
684 for (i
= 0; i
< s
->u
.syment
.n_numaux
+ 1; i
++)
685 s
[i
].offset
= native_index
++;
692 obj_conv_table_size (bfd_ptr
) = native_index
;
697 /* Run thorough the symbol table again, and fix it so that all
698 pointers to entries are changed to the entries' index in the output
702 coff_mangle_symbols (bfd_ptr
)
705 unsigned int symbol_count
= bfd_get_symcount (bfd_ptr
);
706 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
707 unsigned int symbol_index
;
709 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
711 coff_symbol_type
*coff_symbol_ptr
=
712 coff_symbol_from (bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
714 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
)
717 combined_entry_type
*s
= coff_symbol_ptr
->native
;
721 /* FIXME: We should use a union here. */
722 s
->u
.syment
.n_value
=
723 ((combined_entry_type
*) s
->u
.syment
.n_value
)->offset
;
728 /* The value is the offset into the line number entries
729 for the symbol's section. On output, the symbol's
730 section should be N_DEBUG. */
731 s
->u
.syment
.n_value
=
732 (coff_symbol_ptr
->symbol
.section
->output_section
->line_filepos
733 + s
->u
.syment
.n_value
* bfd_coff_linesz (bfd_ptr
));
734 coff_symbol_ptr
->symbol
.section
=
735 coff_section_from_bfd_index (bfd_ptr
, N_DEBUG
);
736 BFD_ASSERT (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
);
738 for (i
= 0; i
< s
->u
.syment
.n_numaux
; i
++)
740 combined_entry_type
*a
= s
+ i
+ 1;
743 a
->u
.auxent
.x_sym
.x_tagndx
.l
=
744 a
->u
.auxent
.x_sym
.x_tagndx
.p
->offset
;
749 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
750 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
->offset
;
755 a
->u
.auxent
.x_csect
.x_scnlen
.l
=
756 a
->u
.auxent
.x_csect
.x_scnlen
.p
->offset
;
765 coff_fix_symbol_name (abfd
, symbol
, native
, string_size_p
,
766 debug_string_section_p
, debug_string_size_p
)
769 combined_entry_type
*native
;
770 bfd_size_type
*string_size_p
;
771 asection
**debug_string_section_p
;
772 bfd_size_type
*debug_string_size_p
;
774 unsigned int name_length
;
775 union internal_auxent
*auxent
;
776 char *name
= (char *) (symbol
->name
);
778 if (name
== (char *) NULL
)
780 /* coff symbols always have names, so we'll make one up */
781 symbol
->name
= "strange";
782 name
= (char *) symbol
->name
;
784 name_length
= strlen (name
);
786 if (native
->u
.syment
.n_sclass
== C_FILE
787 && native
->u
.syment
.n_numaux
> 0)
789 strncpy (native
->u
.syment
._n
._n_name
, ".file", SYMNMLEN
);
790 auxent
= &(native
+ 1)->u
.auxent
;
792 if (bfd_coff_long_filenames (abfd
))
794 if (name_length
<= FILNMLEN
)
796 strncpy (auxent
->x_file
.x_fname
, name
, FILNMLEN
);
800 auxent
->x_file
.x_n
.x_offset
= *string_size_p
+ STRING_SIZE_SIZE
;
801 auxent
->x_file
.x_n
.x_zeroes
= 0;
802 *string_size_p
+= name_length
+ 1;
807 strncpy (auxent
->x_file
.x_fname
, name
, FILNMLEN
);
808 if (name_length
> FILNMLEN
)
810 name
[FILNMLEN
] = '\0';
816 if (name_length
<= SYMNMLEN
)
818 /* This name will fit into the symbol neatly */
819 strncpy (native
->u
.syment
._n
._n_name
, symbol
->name
, SYMNMLEN
);
821 else if (!bfd_coff_symname_in_debug (abfd
, &native
->u
.syment
))
823 native
->u
.syment
._n
._n_n
._n_offset
= (*string_size_p
825 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
826 *string_size_p
+= name_length
+ 1;
833 /* This name should be written into the .debug section. For
834 some reason each name is preceded by a two byte length
835 and also followed by a null byte. FIXME: We assume that
836 the .debug section has already been created, and that it
838 if (*debug_string_section_p
== (asection
*) NULL
)
839 *debug_string_section_p
= bfd_get_section_by_name (abfd
, ".debug");
840 filepos
= bfd_tell (abfd
);
841 bfd_put_16 (abfd
, name_length
+ 1, buf
);
842 if (!bfd_set_section_contents (abfd
,
843 *debug_string_section_p
,
845 (file_ptr
) *debug_string_size_p
,
847 || !bfd_set_section_contents (abfd
,
848 *debug_string_section_p
,
850 ((file_ptr
) *debug_string_size_p
852 (bfd_size_type
) name_length
+ 1))
854 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
856 native
->u
.syment
._n
._n_n
._n_offset
= *debug_string_size_p
+ 2;
857 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
858 *debug_string_size_p
+= name_length
+ 3;
863 /* We need to keep track of the symbol index so that when we write out
864 the relocs we can get the index for a symbol. This method is a
867 #define set_index(symbol, idx) ((symbol)->udata.i = (idx))
869 /* Write a symbol out to a COFF file. */
872 coff_write_symbol (abfd
, symbol
, native
, written
, string_size_p
,
873 debug_string_section_p
, debug_string_size_p
)
876 combined_entry_type
*native
;
877 unsigned int *written
;
878 bfd_size_type
*string_size_p
;
879 asection
**debug_string_section_p
;
880 bfd_size_type
*debug_string_size_p
;
882 unsigned int numaux
= native
->u
.syment
.n_numaux
;
883 int type
= native
->u
.syment
.n_type
;
884 int class = native
->u
.syment
.n_sclass
;
886 bfd_size_type symesz
;
888 if (native
->u
.syment
.n_sclass
== C_FILE
)
889 symbol
->flags
|= BSF_DEBUGGING
;
891 if (symbol
->flags
& BSF_DEBUGGING
892 && bfd_is_abs_section (symbol
->section
))
894 native
->u
.syment
.n_scnum
= N_DEBUG
;
896 else if (bfd_is_abs_section (symbol
->section
))
898 native
->u
.syment
.n_scnum
= N_ABS
;
900 else if (bfd_is_und_section (symbol
->section
))
902 native
->u
.syment
.n_scnum
= N_UNDEF
;
906 native
->u
.syment
.n_scnum
=
907 symbol
->section
->output_section
->target_index
;
910 coff_fix_symbol_name (abfd
, symbol
, native
, string_size_p
,
911 debug_string_section_p
, debug_string_size_p
);
913 symesz
= bfd_coff_symesz (abfd
);
914 buf
= bfd_alloc (abfd
, symesz
);
917 bfd_set_error (bfd_error_no_memory
);
920 bfd_coff_swap_sym_out (abfd
, &native
->u
.syment
, buf
);
921 if (bfd_write (buf
, 1, symesz
, abfd
) != symesz
)
923 bfd_release (abfd
, buf
);
925 if (native
->u
.syment
.n_numaux
> 0)
927 bfd_size_type auxesz
;
930 auxesz
= bfd_coff_auxesz (abfd
);
931 buf
= bfd_alloc (abfd
, auxesz
);
934 bfd_set_error (bfd_error_no_memory
);
937 for (j
= 0; j
< native
->u
.syment
.n_numaux
; j
++)
939 bfd_coff_swap_aux_out (abfd
,
940 &((native
+ j
+ 1)->u
.auxent
),
944 native
->u
.syment
.n_numaux
,
946 if (bfd_write (buf
, 1, auxesz
, abfd
) != auxesz
)
949 bfd_release (abfd
, buf
);
952 /* Store the index for use when we write out the relocs. */
953 set_index (symbol
, *written
);
955 *written
+= numaux
+ 1;
959 /* Write out a symbol to a COFF file that does not come from a COFF
960 file originally. This symbol may have been created by the linker,
961 or we may be linking a non COFF file to a COFF file. */
964 coff_write_alien_symbol (abfd
, symbol
, written
, string_size_p
,
965 debug_string_section_p
, debug_string_size_p
)
968 unsigned int *written
;
969 bfd_size_type
*string_size_p
;
970 asection
**debug_string_section_p
;
971 bfd_size_type
*debug_string_size_p
;
973 combined_entry_type
*native
;
974 combined_entry_type dummy
;
977 native
->u
.syment
.n_type
= T_NULL
;
978 native
->u
.syment
.n_flags
= 0;
979 if (bfd_is_und_section (symbol
->section
))
981 native
->u
.syment
.n_scnum
= N_UNDEF
;
982 native
->u
.syment
.n_value
= symbol
->value
;
984 else if (bfd_is_com_section (symbol
->section
))
986 native
->u
.syment
.n_scnum
= N_UNDEF
;
987 native
->u
.syment
.n_value
= symbol
->value
;
989 else if (symbol
->flags
& BSF_DEBUGGING
)
991 /* There isn't much point to writing out a debugging symbol
992 unless we are prepared to convert it into COFF debugging
993 format. So, we just ignore them. We must clobber the symbol
994 name to keep it from being put in the string table. */
1000 native
->u
.syment
.n_scnum
=
1001 symbol
->section
->output_section
->target_index
;
1002 native
->u
.syment
.n_value
= (symbol
->value
1003 + symbol
->section
->output_section
->vma
1004 + symbol
->section
->output_offset
);
1006 /* Copy the any flags from the the file header into the symbol.
1009 coff_symbol_type
*c
= coff_symbol_from (abfd
, symbol
);
1010 if (c
!= (coff_symbol_type
*) NULL
)
1011 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (&c
->symbol
)->flags
;
1015 native
->u
.syment
.n_type
= 0;
1016 if (symbol
->flags
& BSF_LOCAL
)
1017 native
->u
.syment
.n_sclass
= C_STAT
;
1019 native
->u
.syment
.n_sclass
= C_EXT
;
1020 native
->u
.syment
.n_numaux
= 0;
1022 return coff_write_symbol (abfd
, symbol
, native
, written
, string_size_p
,
1023 debug_string_section_p
, debug_string_size_p
);
1026 /* Write a native symbol to a COFF file. */
1029 coff_write_native_symbol (abfd
, symbol
, written
, string_size_p
,
1030 debug_string_section_p
, debug_string_size_p
)
1032 coff_symbol_type
*symbol
;
1033 unsigned int *written
;
1034 bfd_size_type
*string_size_p
;
1035 asection
**debug_string_section_p
;
1036 bfd_size_type
*debug_string_size_p
;
1038 combined_entry_type
*native
= symbol
->native
;
1039 alent
*lineno
= symbol
->lineno
;
1041 /* If this symbol has an associated line number, we must store the
1042 symbol index in the line number field. We also tag the auxent to
1043 point to the right place in the lineno table. */
1044 if (lineno
&& !symbol
->done_lineno
&& symbol
->symbol
.section
->owner
!= NULL
)
1046 unsigned int count
= 0;
1047 lineno
[count
].u
.offset
= *written
;
1048 if (native
->u
.syment
.n_numaux
)
1050 union internal_auxent
*a
= &((native
+ 1)->u
.auxent
);
1052 a
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1053 symbol
->symbol
.section
->output_section
->moving_line_filepos
;
1056 /* Count and relocate all other linenumbers. */
1058 while (lineno
[count
].line_number
!= 0)
1062 I've been told this, but still need proof:
1063 > The second bug is also in `bfd/coffcode.h'. This bug
1064 > causes the linker to screw up the pc-relocations for
1065 > all the line numbers in COFF code. This bug isn't only
1066 > specific to A29K implementations, but affects all
1067 > systems using COFF format binaries. Note that in COFF
1068 > object files, the line number core offsets output by
1069 > the assembler are relative to the start of each
1070 > procedure, not to the start of the .text section. This
1071 > patch relocates the line numbers relative to the
1072 > `native->u.syment.n_value' instead of the section
1074 > modular!olson@cs.arizona.edu (Jon Olson)
1076 lineno
[count
].u
.offset
+= native
->u
.syment
.n_value
;
1078 lineno
[count
].u
.offset
+=
1079 (symbol
->symbol
.section
->output_section
->vma
1080 + symbol
->symbol
.section
->output_offset
);
1084 symbol
->done_lineno
= true;
1086 symbol
->symbol
.section
->output_section
->moving_line_filepos
+=
1087 count
* bfd_coff_linesz (abfd
);
1090 return coff_write_symbol (abfd
, &(symbol
->symbol
), native
, written
,
1091 string_size_p
, debug_string_section_p
,
1092 debug_string_size_p
);
1095 /* Write out the COFF symbols. */
1098 coff_write_symbols (abfd
)
1101 bfd_size_type string_size
;
1102 asection
*debug_string_section
;
1103 bfd_size_type debug_string_size
;
1105 unsigned int limit
= bfd_get_symcount (abfd
);
1106 unsigned int written
= 0;
1110 debug_string_section
= NULL
;
1111 debug_string_size
= 0;
1113 /* Seek to the right place */
1114 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
1117 /* Output all the symbols we have */
1120 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1122 asymbol
*symbol
= *p
;
1123 coff_symbol_type
*c_symbol
= coff_symbol_from (abfd
, symbol
);
1125 if (c_symbol
== (coff_symbol_type
*) NULL
1126 || c_symbol
->native
== (combined_entry_type
*) NULL
)
1128 if (!coff_write_alien_symbol (abfd
, symbol
, &written
, &string_size
,
1129 &debug_string_section
,
1130 &debug_string_size
))
1135 if (!coff_write_native_symbol (abfd
, c_symbol
, &written
,
1136 &string_size
, &debug_string_section
,
1137 &debug_string_size
))
1142 obj_raw_syment_count (abfd
) = written
;
1144 /* Now write out strings */
1146 if (string_size
!= 0)
1148 unsigned int size
= string_size
+ STRING_SIZE_SIZE
;
1149 bfd_byte buffer
[STRING_SIZE_SIZE
];
1151 #if STRING_SIZE_SIZE == 4
1152 bfd_h_put_32 (abfd
, size
, buffer
);
1154 #error Change bfd_h_put_32
1156 if (bfd_write ((PTR
) buffer
, 1, sizeof (buffer
), abfd
) != sizeof (buffer
))
1158 for (p
= abfd
->outsymbols
, i
= 0;
1163 size_t name_length
= strlen (q
->name
);
1164 coff_symbol_type
*c_symbol
= coff_symbol_from (abfd
, q
);
1167 /* Figure out whether the symbol name should go in the string
1168 table. Symbol names that are short enough are stored
1169 directly in the syment structure. File names permit a
1170 different, longer, length in the syment structure. On
1171 XCOFF, some symbol names are stored in the .debug section
1172 rather than in the string table. */
1174 if (c_symbol
== NULL
1175 || c_symbol
->native
== NULL
)
1177 /* This is not a COFF symbol, so it certainly is not a
1178 file name, nor does it go in the .debug section. */
1181 else if (bfd_coff_symname_in_debug (abfd
,
1182 &c_symbol
->native
->u
.syment
))
1184 /* This symbol name is in the XCOFF .debug section.
1185 Don't write it into the string table. */
1186 maxlen
= name_length
;
1188 else if (c_symbol
->native
->u
.syment
.n_sclass
== C_FILE
1189 && c_symbol
->native
->u
.syment
.n_numaux
> 0)
1194 if (name_length
> maxlen
)
1196 if (bfd_write ((PTR
) (q
->name
), 1, name_length
+ 1, abfd
)
1204 /* We would normally not write anything here, but we'll write
1205 out 4 so that any stupid coff reader which tries to read the
1206 string table even when there isn't one won't croak. */
1207 unsigned int size
= STRING_SIZE_SIZE
;
1208 bfd_byte buffer
[STRING_SIZE_SIZE
];
1210 #if STRING_SIZE_SIZE == 4
1211 bfd_h_put_32 (abfd
, size
, buffer
);
1213 #error Change bfd_h_put_32
1215 if (bfd_write ((PTR
) buffer
, 1, STRING_SIZE_SIZE
, abfd
)
1216 != STRING_SIZE_SIZE
)
1220 /* Make sure the .debug section was created to be the correct size.
1221 We should create it ourselves on the fly, but we don't because
1222 BFD won't let us write to any section until we know how large all
1223 the sections are. We could still do it by making another pass
1224 over the symbols. FIXME. */
1225 BFD_ASSERT (debug_string_size
== 0
1226 || (debug_string_section
!= (asection
*) NULL
1227 && (BFD_ALIGN (debug_string_size
,
1228 1 << debug_string_section
->alignment_power
)
1229 == bfd_section_size (abfd
, debug_string_section
))));
1235 coff_write_linenumbers (abfd
)
1239 bfd_size_type linesz
;
1242 linesz
= bfd_coff_linesz (abfd
);
1243 buff
= bfd_alloc (abfd
, linesz
);
1246 bfd_set_error (bfd_error_no_memory
);
1249 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
1251 if (s
->lineno_count
)
1253 asymbol
**q
= abfd
->outsymbols
;
1254 if (bfd_seek (abfd
, s
->line_filepos
, SEEK_SET
) != 0)
1256 /* Find all the linenumbers in this section */
1260 if (p
->section
->output_section
== s
)
1263 BFD_SEND (bfd_asymbol_bfd (p
), _get_lineno
,
1264 (bfd_asymbol_bfd (p
), p
));
1267 /* Found a linenumber entry, output */
1268 struct internal_lineno out
;
1269 memset ((PTR
) & out
, 0, sizeof (out
));
1271 out
.l_addr
.l_symndx
= l
->u
.offset
;
1272 bfd_coff_swap_lineno_out (abfd
, &out
, buff
);
1273 if (bfd_write (buff
, 1, linesz
, abfd
) != linesz
)
1276 while (l
->line_number
)
1278 out
.l_lnno
= l
->line_number
;
1279 out
.l_addr
.l_symndx
= l
->u
.offset
;
1280 bfd_coff_swap_lineno_out (abfd
, &out
, buff
);
1281 if (bfd_write (buff
, 1, linesz
, abfd
) != linesz
)
1291 bfd_release (abfd
, buff
);
1297 coff_get_lineno (ignore_abfd
, symbol
)
1301 return coffsymbol (symbol
)->lineno
;
1305 coff_section_symbol (abfd
, name
)
1309 asection
*sec
= bfd_make_section_old_way (abfd
, name
);
1311 combined_entry_type
*csym
;
1314 csym
= coff_symbol_from (abfd
, sym
)->native
;
1315 /* Make sure back-end COFF stuff is there. */
1320 coff_symbol_type sym
;
1321 /* @@FIXME This shouldn't use a fixed size!! */
1322 combined_entry_type e
[10];
1325 f
= (struct foo
*) bfd_alloc_by_size_t (abfd
, sizeof (*f
));
1328 bfd_set_error (bfd_error_no_error
);
1331 memset ((char *) f
, 0, sizeof (*f
));
1332 coff_symbol_from (abfd
, sym
)->native
= csym
= f
->e
;
1334 csym
[0].u
.syment
.n_sclass
= C_STAT
;
1335 csym
[0].u
.syment
.n_numaux
= 1;
1336 /* SF_SET_STATICS (sym); @@ ??? */
1337 csym
[1].u
.auxent
.x_scn
.x_scnlen
= sec
->_raw_size
;
1338 csym
[1].u
.auxent
.x_scn
.x_nreloc
= sec
->reloc_count
;
1339 csym
[1].u
.auxent
.x_scn
.x_nlinno
= sec
->lineno_count
;
1341 if (sec
->output_section
== NULL
)
1343 sec
->output_section
= sec
;
1344 sec
->output_offset
= 0;
1350 /* This function transforms the offsets into the symbol table into
1351 pointers to syments. */
1354 coff_pointerize_aux (abfd
, table_base
, symbol
, indaux
, auxent
)
1356 combined_entry_type
*table_base
;
1357 combined_entry_type
*symbol
;
1358 unsigned int indaux
;
1359 combined_entry_type
*auxent
;
1361 int type
= symbol
->u
.syment
.n_type
;
1362 int class = symbol
->u
.syment
.n_sclass
;
1364 if (coff_backend_info (abfd
)->_bfd_coff_pointerize_aux_hook
)
1366 if ((*coff_backend_info (abfd
)->_bfd_coff_pointerize_aux_hook
)
1367 (abfd
, table_base
, symbol
, indaux
, auxent
))
1371 /* Don't bother if this is a file or a section */
1372 if (class == C_STAT
&& type
== T_NULL
)
1374 if (class == C_FILE
)
1377 /* Otherwise patch up */
1378 #define N_TMASK coff_data (abfd)->local_n_tmask
1379 #define N_BTSHFT coff_data (abfd)->local_n_btshft
1380 if ((ISFCN (type
) || ISTAG (class) || class == C_BLOCK
)
1381 && auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
> 0)
1383 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
=
1384 table_base
+ auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
1385 auxent
->fix_end
= 1;
1387 /* A negative tagndx is meaningless, but the SCO 3.2v4 cc can
1388 generate one, so we must be careful to ignore it. */
1389 if (auxent
->u
.auxent
.x_sym
.x_tagndx
.l
> 0)
1391 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
=
1392 table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
;
1393 auxent
->fix_tag
= 1;
1397 /* Allocate space for the ".debug" section, and read it.
1398 We did not read the debug section until now, because
1399 we didn't want to go to the trouble until someone needed it. */
1402 build_debug_section (abfd
)
1405 char *debug_section
;
1408 asection
*sect
= bfd_get_section_by_name (abfd
, ".debug");
1412 bfd_set_error (bfd_error_no_debug_section
);
1416 debug_section
= (PTR
) bfd_alloc (abfd
,
1417 bfd_get_section_size_before_reloc (sect
));
1418 if (debug_section
== NULL
)
1420 bfd_set_error (bfd_error_no_memory
);
1424 /* Seek to the beginning of the `.debug' section and read it.
1425 Save the current position first; it is needed by our caller.
1426 Then read debug section and reset the file pointer. */
1428 position
= bfd_tell (abfd
);
1429 if (bfd_seek (abfd
, sect
->filepos
, SEEK_SET
) != 0
1430 || (bfd_read (debug_section
,
1431 bfd_get_section_size_before_reloc (sect
), 1, abfd
)
1432 != bfd_get_section_size_before_reloc (sect
))
1433 || bfd_seek (abfd
, position
, SEEK_SET
) != 0)
1435 return debug_section
;
1439 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
1440 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
1441 be \0-terminated. */
1443 copy_name (abfd
, name
, maxlen
)
1451 for (len
= 0; len
< maxlen
; ++len
)
1453 if (name
[len
] == '\0')
1459 if ((newname
= (PTR
) bfd_alloc (abfd
, len
+ 1)) == NULL
)
1461 bfd_set_error (bfd_error_no_memory
);
1464 strncpy (newname
, name
, len
);
1465 newname
[len
] = '\0';
1469 /* Read in the external symbols. */
1472 _bfd_coff_get_external_symbols (abfd
)
1475 bfd_size_type symesz
;
1479 if (obj_coff_external_syms (abfd
) != NULL
)
1482 symesz
= bfd_coff_symesz (abfd
);
1484 size
= obj_raw_syment_count (abfd
) * symesz
;
1486 syms
= (PTR
) malloc (size
);
1487 if (syms
== NULL
&& size
!= 0)
1489 bfd_set_error (bfd_error_no_memory
);
1493 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
1494 || bfd_read (syms
, size
, 1, abfd
) != size
)
1501 obj_coff_external_syms (abfd
) = syms
;
1506 /* Read in the external strings. The strings are not loaded until
1507 they are needed. This is because we have no simple way of
1508 detecting a missing string table in an archive. */
1511 _bfd_coff_read_string_table (abfd
)
1514 char extstrsize
[STRING_SIZE_SIZE
];
1518 if (obj_coff_strings (abfd
) != NULL
)
1519 return obj_coff_strings (abfd
);
1522 (obj_sym_filepos (abfd
)
1523 + obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
)),
1527 if (bfd_read (extstrsize
, sizeof extstrsize
, 1, abfd
) != sizeof extstrsize
)
1529 if (bfd_get_error () != bfd_error_file_truncated
)
1532 /* There is no string table. */
1533 strsize
= STRING_SIZE_SIZE
;
1537 #if STRING_SIZE_SIZE == 4
1538 strsize
= bfd_h_get_32 (abfd
, (bfd_byte
*) extstrsize
);
1540 #error Change bfd_h_get_32
1544 if (strsize
< STRING_SIZE_SIZE
)
1546 (*_bfd_error_handler
)
1547 ("%s: bad string table size %lu", bfd_get_filename (abfd
),
1548 (unsigned long) strsize
);
1549 bfd_set_error (bfd_error_bad_value
);
1553 strings
= (char *) malloc (strsize
);
1554 if (strings
== NULL
)
1556 bfd_set_error (bfd_error_no_memory
);
1560 if (bfd_read (strings
+ STRING_SIZE_SIZE
,
1561 strsize
- STRING_SIZE_SIZE
, 1, abfd
)
1562 != strsize
- STRING_SIZE_SIZE
)
1568 obj_coff_strings (abfd
) = strings
;
1573 /* Free up the external symbols and strings read from a COFF file. */
1576 _bfd_coff_free_symbols (abfd
)
1579 if (obj_coff_external_syms (abfd
) != NULL
1580 && ! obj_coff_keep_syms (abfd
))
1582 free (obj_coff_external_syms (abfd
));
1583 obj_coff_external_syms (abfd
) = NULL
;
1585 if (obj_coff_strings (abfd
) != NULL
1586 && ! obj_coff_keep_strings (abfd
))
1588 free (obj_coff_strings (abfd
));
1589 obj_coff_strings (abfd
) = NULL
;
1594 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
1595 knit the symbol names into a normalized form. By normalized here I
1596 mean that all symbols have an n_offset pointer that points to a null-
1597 terminated string. */
1599 combined_entry_type
*
1600 coff_get_normalized_symtab (abfd
)
1603 combined_entry_type
*internal
;
1604 combined_entry_type
*internal_ptr
;
1605 combined_entry_type
*symbol_ptr
;
1606 combined_entry_type
*internal_end
;
1607 bfd_size_type symesz
;
1610 const char *string_table
= NULL
;
1611 char *debug_section
= NULL
;
1614 if (obj_raw_syments (abfd
) != NULL
)
1615 return obj_raw_syments (abfd
);
1617 size
= obj_raw_syment_count (abfd
) * sizeof (combined_entry_type
);
1618 internal
= (combined_entry_type
*) bfd_alloc (abfd
, size
);
1619 if (internal
== NULL
&& size
!= 0)
1621 bfd_set_error (bfd_error_no_memory
);
1624 internal_end
= internal
+ obj_raw_syment_count (abfd
);
1626 if (! _bfd_coff_get_external_symbols (abfd
))
1629 raw_src
= (char *) obj_coff_external_syms (abfd
);
1631 /* mark the end of the symbols */
1632 symesz
= bfd_coff_symesz (abfd
);
1633 raw_end
= (char *) raw_src
+ obj_raw_syment_count (abfd
) * symesz
;
1635 /* FIXME SOMEDAY. A string table size of zero is very weird, but
1636 probably possible. If one shows up, it will probably kill us. */
1638 /* Swap all the raw entries */
1639 for (internal_ptr
= internal
;
1641 raw_src
+= symesz
, internal_ptr
++)
1645 bfd_coff_swap_sym_in (abfd
, (PTR
) raw_src
,
1646 (PTR
) & internal_ptr
->u
.syment
);
1647 internal_ptr
->fix_value
= 0;
1648 internal_ptr
->fix_tag
= 0;
1649 internal_ptr
->fix_end
= 0;
1650 internal_ptr
->fix_scnlen
= 0;
1651 symbol_ptr
= internal_ptr
;
1654 i
< symbol_ptr
->u
.syment
.n_numaux
;
1660 internal_ptr
->fix_value
= 0;
1661 internal_ptr
->fix_tag
= 0;
1662 internal_ptr
->fix_end
= 0;
1663 internal_ptr
->fix_scnlen
= 0;
1664 bfd_coff_swap_aux_in (abfd
, (PTR
) raw_src
,
1665 symbol_ptr
->u
.syment
.n_type
,
1666 symbol_ptr
->u
.syment
.n_sclass
,
1667 i
, symbol_ptr
->u
.syment
.n_numaux
,
1668 &(internal_ptr
->u
.auxent
));
1669 coff_pointerize_aux (abfd
, internal
, symbol_ptr
, i
,
1674 /* Free the raw symbols, but not the strings (if we have them). */
1675 obj_coff_keep_strings (abfd
) = true;
1676 if (! _bfd_coff_free_symbols (abfd
))
1679 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
1682 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
1683 && internal_ptr
->u
.syment
.n_numaux
> 0)
1685 /* make a file symbol point to the name in the auxent, since
1686 the text ".file" is redundant */
1687 if ((internal_ptr
+ 1)->u
.auxent
.x_file
.x_n
.x_zeroes
== 0)
1689 /* the filename is a long one, point into the string table */
1690 if (string_table
== NULL
)
1692 string_table
= _bfd_coff_read_string_table (abfd
);
1693 if (string_table
== NULL
)
1697 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1700 + (internal_ptr
+ 1)->u
.auxent
.x_file
.x_n
.x_offset
));
1704 /* ordinary short filename, put into memory anyway */
1705 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (long)
1706 copy_name (abfd
, (internal_ptr
+ 1)->u
.auxent
.x_file
.x_fname
,
1712 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0)
1714 /* This is a "short" name. Make it long. */
1715 unsigned long i
= 0;
1716 char *newstring
= NULL
;
1718 /* find the length of this string without walking into memory
1720 for (i
= 0; i
< 8; ++i
)
1722 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0')
1725 } /* if end of string */
1726 } /* possible lengths of this string. */
1728 if ((newstring
= (PTR
) bfd_alloc (abfd
, ++i
)) == NULL
)
1730 bfd_set_error (bfd_error_no_memory
);
1733 memset (newstring
, 0, i
);
1734 strncpy (newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
- 1);
1735 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (long int) newstring
;
1736 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1738 else if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
== 0)
1739 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (long int) "";
1740 else if (!bfd_coff_symname_in_debug (abfd
, &internal_ptr
->u
.syment
))
1742 /* Long name already. Point symbol at the string in the
1744 if (string_table
== NULL
)
1746 string_table
= _bfd_coff_read_string_table (abfd
);
1747 if (string_table
== NULL
)
1750 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1753 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
));
1757 /* Long name in debug section. Very similar. */
1758 if (debug_section
== NULL
)
1759 debug_section
= build_debug_section (abfd
);
1760 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (long int)
1761 (debug_section
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
1764 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
1767 obj_raw_syments (abfd
) = internal
;
1768 BFD_ASSERT (obj_raw_syment_count (abfd
)
1769 == (unsigned int) (internal_ptr
- internal
));
1772 } /* coff_get_normalized_symtab() */
1775 coff_get_reloc_upper_bound (abfd
, asect
)
1779 if (bfd_get_format (abfd
) != bfd_object
)
1781 bfd_set_error (bfd_error_invalid_operation
);
1784 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
1788 coff_make_empty_symbol (abfd
)
1791 coff_symbol_type
*new = (coff_symbol_type
*) bfd_alloc (abfd
, sizeof (coff_symbol_type
));
1794 bfd_set_error (bfd_error_no_memory
);
1797 memset (new, 0, sizeof *new);
1798 new->symbol
.section
= 0;
1800 new->lineno
= (alent
*) NULL
;
1801 new->done_lineno
= false;
1802 new->symbol
.the_bfd
= abfd
;
1803 return &new->symbol
;
1806 /* Make a debugging symbol. */
1809 coff_bfd_make_debug_symbol (abfd
, ptr
, sz
)
1814 coff_symbol_type
*new = (coff_symbol_type
*) bfd_alloc (abfd
, sizeof (coff_symbol_type
));
1817 bfd_set_error (bfd_error_no_memory
);
1820 /* @@ This shouldn't be using a constant multiplier. */
1821 new->native
= (combined_entry_type
*) bfd_zalloc (abfd
, sizeof (combined_entry_type
) * 10);
1824 bfd_set_error (bfd_error_no_memory
);
1827 new->symbol
.section
= bfd_abs_section_ptr
;
1828 new->symbol
.flags
= BSF_DEBUGGING
;
1829 new->lineno
= (alent
*) NULL
;
1830 new->done_lineno
= false;
1831 new->symbol
.the_bfd
= abfd
;
1832 return &new->symbol
;
1837 coff_get_symbol_info (abfd
, symbol
, ret
)
1842 bfd_symbol_info (symbol
, ret
);
1843 if (coffsymbol (symbol
)->native
!= NULL
1844 && coffsymbol (symbol
)->native
->fix_value
)
1846 combined_entry_type
*psym
;
1848 psym
= ((combined_entry_type
*)
1849 coffsymbol (symbol
)->native
->u
.syment
.n_value
);
1850 ret
->value
= (bfd_vma
) (psym
- obj_raw_syments (abfd
));
1854 /* Print out information about COFF symbol. */
1857 coff_print_symbol (abfd
, filep
, symbol
, how
)
1861 bfd_print_symbol_type how
;
1863 FILE *file
= (FILE *) filep
;
1867 case bfd_print_symbol_name
:
1868 fprintf (file
, "%s", symbol
->name
);
1871 case bfd_print_symbol_more
:
1872 fprintf (file
, "coff %s %s",
1873 coffsymbol (symbol
)->native
? "n" : "g",
1874 coffsymbol (symbol
)->lineno
? "l" : " ");
1877 case bfd_print_symbol_all
:
1878 if (coffsymbol (symbol
)->native
)
1882 combined_entry_type
*combined
= coffsymbol (symbol
)->native
;
1883 combined_entry_type
*root
= obj_raw_syments (abfd
);
1884 struct lineno_cache_entry
*l
= coffsymbol (symbol
)->lineno
;
1886 fprintf (file
, "[%3ld]", (long) (combined
- root
));
1888 if (! combined
->fix_value
)
1889 val
= (unsigned long) combined
->u
.syment
.n_value
;
1891 val
= ((unsigned long)
1892 ((combined_entry_type
*) combined
->u
.syment
.n_value
1896 "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x%08lx %s",
1897 combined
->u
.syment
.n_scnum
,
1898 combined
->u
.syment
.n_flags
,
1899 combined
->u
.syment
.n_type
,
1900 combined
->u
.syment
.n_sclass
,
1901 combined
->u
.syment
.n_numaux
,
1905 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
1907 combined_entry_type
*auxp
= combined
+ aux
+ 1;
1911 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.p
- root
;
1913 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.l
;
1915 fprintf (file
, "\n");
1917 if (bfd_coff_print_aux (abfd
, file
, root
, combined
, auxp
, aux
))
1920 switch (combined
->u
.syment
.n_sclass
)
1923 fprintf (file
, "File ");
1927 if (combined
->u
.syment
.n_type
== T_NULL
)
1928 /* probably a section symbol? */
1930 fprintf (file
, "AUX scnlen 0x%lx nreloc %d nlnno %d",
1931 (long) auxp
->u
.auxent
.x_scn
.x_scnlen
,
1932 auxp
->u
.auxent
.x_scn
.x_nreloc
,
1933 auxp
->u
.auxent
.x_scn
.x_nlinno
);
1936 /* else fall through */
1939 fprintf (file
, "AUX lnno %d size 0x%x tagndx %ld",
1940 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
1941 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
,
1944 fprintf (file
, " endndx %ld",
1946 (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
1954 fprintf (file
, "\n%s :", l
->u
.sym
->name
);
1956 while (l
->line_number
)
1958 fprintf (file
, "\n%4d : 0x%lx",
1961 (l
->u
.offset
+ symbol
->section
->vma
)));
1968 bfd_print_symbol_vandf ((PTR
) file
, symbol
);
1969 fprintf (file
, " %-5s %s %s %s",
1970 symbol
->section
->name
,
1971 coffsymbol (symbol
)->native
? "n" : "g",
1972 coffsymbol (symbol
)->lineno
? "l" : " ",
1978 /* Provided a BFD, a section and an offset into the section, calculate
1979 and return the name of the source file and the line nearest to the
1984 coff_find_nearest_line (abfd
, section
, ignore_symbols
, offset
, filename_ptr
,
1985 functionname_ptr
, line_ptr
)
1988 asymbol
**ignore_symbols
;
1990 CONST
char **filename_ptr
;
1991 CONST
char **functionname_ptr
;
1992 unsigned int *line_ptr
;
1995 unsigned int line_base
;
1996 coff_data_type
*cof
= coff_data (abfd
);
1997 /* Run through the raw syments if available */
1998 combined_entry_type
*p
;
1999 combined_entry_type
*pend
;
2001 struct coff_section_tdata
*sec_data
;
2004 *functionname_ptr
= 0;
2007 /* Don't try and find line numbers in a non coff file */
2008 if (abfd
->xvec
->flavour
!= bfd_target_coff_flavour
)
2014 /* Find the first C_FILE symbol. */
2015 p
= cof
->raw_syments
;
2016 pend
= p
+ cof
->raw_syment_count
;
2019 if (p
->u
.syment
.n_sclass
== C_FILE
)
2021 p
+= 1 + p
->u
.syment
.n_numaux
;
2028 /* Look through the C_FILE symbols to find the best one. */
2029 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2030 maxdiff
= (bfd_vma
) 0 - (bfd_vma
) 1;
2033 combined_entry_type
*p2
;
2035 for (p2
= p
+ 1 + p
->u
.syment
.n_numaux
;
2037 p2
+= 1 + p2
->u
.syment
.n_numaux
)
2039 if (p2
->u
.syment
.n_scnum
> 0
2041 == coff_section_from_bfd_index (abfd
,
2042 p2
->u
.syment
.n_scnum
)))
2044 if (p2
->u
.syment
.n_sclass
== C_FILE
)
2052 && offset
>= (bfd_vma
) p2
->u
.syment
.n_value
2053 && offset
- (bfd_vma
) p2
->u
.syment
.n_value
< maxdiff
)
2055 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2056 maxdiff
= offset
- p2
->u
.syment
.n_value
;
2059 /* Avoid endless loops on erroneous files by ensuring that
2060 we always move forward in the file. */
2061 if (p
- cof
->raw_syments
>= p
->u
.syment
.n_value
)
2064 p
= cof
->raw_syments
+ p
->u
.syment
.n_value
;
2065 if (p
> pend
|| p
->u
.syment
.n_sclass
!= C_FILE
)
2070 /* Now wander though the raw linenumbers of the section */
2071 /* If we have been called on this section before, and the offset we
2072 want is further down then we can prime the lookup loop. */
2073 sec_data
= coff_section_data (abfd
, section
);
2074 if (sec_data
!= NULL
2076 && offset
>= sec_data
->offset
)
2079 *functionname_ptr
= sec_data
->function
;
2080 line_base
= sec_data
->line_base
;
2088 l
= §ion
->lineno
[i
];
2090 for (; i
< section
->lineno_count
; i
++)
2092 if (l
->line_number
== 0)
2094 /* Get the symbol this line number points at */
2095 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
2096 if (coff
->symbol
.value
> offset
)
2098 *functionname_ptr
= coff
->symbol
.name
;
2101 combined_entry_type
*s
= coff
->native
;
2102 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2104 /* In XCOFF a debugging symbol can follow the function
2106 if (s
->u
.syment
.n_scnum
== N_DEBUG
)
2107 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2110 S should now point to the .bf of the function
2112 if (s
->u
.syment
.n_numaux
)
2115 The linenumber is stored in the auxent
2117 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
2118 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
2119 *line_ptr
= line_base
;
2125 if (l
->u
.offset
+ bfd_get_section_vma (abfd
, section
) > offset
)
2127 *line_ptr
= l
->line_number
+ line_base
- 1;
2132 /* Cache the results for the next call. */
2133 if (sec_data
== NULL
)
2135 section
->used_by_bfd
=
2136 ((PTR
) bfd_zalloc (abfd
,
2137 sizeof (struct coff_section_tdata
)));
2138 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2140 if (sec_data
!= NULL
)
2142 sec_data
->offset
= offset
;
2144 sec_data
->function
= *functionname_ptr
;
2145 sec_data
->line_base
= line_base
;
2152 coff_sizeof_headers (abfd
, reloc
)
2160 size
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
2164 size
= bfd_coff_filhsz (abfd
);
2167 size
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);