1 /* Support for the generic parts of COFF, for BFD.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4 Free Software Foundation, Inc.
5 Written by Cygnus Support.
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
23 /* Most of this hacked by Steve Chamberlain, sac@cygnus.com.
24 Split out of coffcode.h by Ian Taylor, ian@cygnus.com. */
26 /* This file contains COFF code that is not dependent on any
27 particular COFF target. There is only one version of this file in
28 libbfd.a, so no target specific code may be put in here. Or, to
31 ********** DO NOT PUT TARGET SPECIFIC CODE IN THIS FILE **********
33 If you need to add some target specific behaviour, add a new hook
34 function to bfd_coff_backend_data.
36 Some of these functions are also called by the ECOFF routines.
37 Those functions may not use any COFF specific information, such as
43 #include "coff/internal.h"
46 static void coff_fix_symbol_name
47 PARAMS ((bfd
*, asymbol
*, combined_entry_type
*, bfd_size_type
*,
48 asection
**, bfd_size_type
*));
49 static boolean coff_write_symbol
50 PARAMS ((bfd
*, asymbol
*, combined_entry_type
*, bfd_vma
*,
51 bfd_size_type
*, asection
**, bfd_size_type
*));
52 static boolean coff_write_alien_symbol
53 PARAMS ((bfd
*, asymbol
*, bfd_vma
*, bfd_size_type
*,
54 asection
**, bfd_size_type
*));
55 static boolean coff_write_native_symbol
56 PARAMS ((bfd
*, coff_symbol_type
*, bfd_vma
*, bfd_size_type
*,
57 asection
**, bfd_size_type
*));
58 static void coff_pointerize_aux
59 PARAMS ((bfd
*, combined_entry_type
*, combined_entry_type
*,
60 unsigned int, combined_entry_type
*));
61 static boolean make_a_section_from_file
62 PARAMS ((bfd
*, struct internal_scnhdr
*, unsigned int));
63 static const bfd_target
*coff_real_object_p
64 PARAMS ((bfd
*, unsigned, struct internal_filehdr
*,
65 struct internal_aouthdr
*));
66 static void fixup_symbol_value
67 PARAMS ((bfd
*, coff_symbol_type
*, struct internal_syment
*));
68 static char *build_debug_section
70 static char *copy_name
71 PARAMS ((bfd
*, char *, int));
73 #define STRING_SIZE_SIZE (4)
75 /* Take a section header read from a coff file (in HOST byte order),
76 and make a BFD "section" out of it. This is used by ECOFF. */
78 make_a_section_from_file (abfd
, hdr
, target_index
)
80 struct internal_scnhdr
*hdr
;
81 unsigned int target_index
;
83 asection
*return_section
;
88 /* Handle long section names as in PE. */
89 if (bfd_coff_long_section_names (abfd
)
90 && hdr
->s_name
[0] == '/')
97 memcpy (buf
, hdr
->s_name
+ 1, SCNNMLEN
- 1);
98 buf
[SCNNMLEN
- 1] = '\0';
99 strindex
= strtol (buf
, &p
, 10);
100 if (*p
== '\0' && strindex
>= 0)
102 strings
= _bfd_coff_read_string_table (abfd
);
105 /* FIXME: For extra safety, we should make sure that
106 strindex does not run us past the end, but right now we
107 don't know the length of the string table. */
109 name
= bfd_alloc (abfd
, strlen (strings
) + 1);
112 strcpy (name
, strings
);
118 /* Assorted wastage to null-terminate the name, thanks AT&T! */
119 name
= bfd_alloc (abfd
, sizeof (hdr
->s_name
) + 1);
122 strncpy (name
, (char *) &hdr
->s_name
[0], sizeof (hdr
->s_name
));
123 name
[sizeof (hdr
->s_name
)] = 0;
126 return_section
= bfd_make_section_anyway (abfd
, name
);
127 if (return_section
== NULL
)
130 return_section
->vma
= hdr
->s_vaddr
;
131 return_section
->lma
= hdr
->s_paddr
;
132 return_section
->_raw_size
= hdr
->s_size
;
133 return_section
->filepos
= hdr
->s_scnptr
;
134 return_section
->rel_filepos
= hdr
->s_relptr
;
135 return_section
->reloc_count
= hdr
->s_nreloc
;
137 bfd_coff_set_alignment_hook (abfd
, return_section
, hdr
);
139 return_section
->line_filepos
= hdr
->s_lnnoptr
;
141 return_section
->lineno_count
= hdr
->s_nlnno
;
142 return_section
->userdata
= NULL
;
143 return_section
->next
= (asection
*) NULL
;
144 return_section
->target_index
= target_index
;
145 return_section
->flags
= bfd_coff_styp_to_sec_flags_hook (abfd
, hdr
, name
,
148 /* At least on i386-coff, the line number count for a shared library
149 section must be ignored. */
150 if ((return_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
151 return_section
->lineno_count
= 0;
153 if (hdr
->s_nreloc
!= 0)
154 return_section
->flags
|= SEC_RELOC
;
155 /* FIXME: should this check 'hdr->s_size > 0' */
156 if (hdr
->s_scnptr
!= 0)
157 return_section
->flags
|= SEC_HAS_CONTENTS
;
161 /* Read in a COFF object and make it into a BFD. This is used by
164 static const bfd_target
*
165 coff_real_object_p (abfd
, nscns
, internal_f
, internal_a
)
168 struct internal_filehdr
*internal_f
;
169 struct internal_aouthdr
*internal_a
;
171 flagword oflags
= abfd
->flags
;
172 bfd_vma ostart
= bfd_get_start_address (abfd
);
174 size_t readsize
; /* length of file_info */
176 char *external_sections
;
178 if (!(internal_f
->f_flags
& F_RELFLG
))
179 abfd
->flags
|= HAS_RELOC
;
180 if ((internal_f
->f_flags
& F_EXEC
))
181 abfd
->flags
|= EXEC_P
;
182 if (!(internal_f
->f_flags
& F_LNNO
))
183 abfd
->flags
|= HAS_LINENO
;
184 if (!(internal_f
->f_flags
& F_LSYMS
))
185 abfd
->flags
|= HAS_LOCALS
;
187 /* FIXME: How can we set D_PAGED correctly? */
188 if ((internal_f
->f_flags
& F_EXEC
) != 0)
189 abfd
->flags
|= D_PAGED
;
191 bfd_get_symcount (abfd
) = internal_f
->f_nsyms
;
192 if (internal_f
->f_nsyms
)
193 abfd
->flags
|= HAS_SYMS
;
195 if (internal_a
!= (struct internal_aouthdr
*) NULL
)
196 bfd_get_start_address (abfd
) = internal_a
->entry
;
198 bfd_get_start_address (abfd
) = 0;
200 /* Set up the tdata area. ECOFF uses its own routine, and overrides
202 tdata
= bfd_coff_mkobject_hook (abfd
, (PTR
) internal_f
, (PTR
) internal_a
);
206 scnhsz
= bfd_coff_scnhsz (abfd
);
207 readsize
= nscns
* scnhsz
;
208 external_sections
= (char *) bfd_alloc (abfd
, readsize
);
209 if (!external_sections
)
212 if (bfd_read ((PTR
) external_sections
, 1, readsize
, abfd
) != readsize
)
215 /* Set the arch/mach *before* swapping in sections; section header swapping
216 may depend on arch/mach info. */
217 if (bfd_coff_set_arch_mach_hook (abfd
, (PTR
) internal_f
) == false)
220 /* Now copy data as required; construct all asections etc */
224 for (i
= 0; i
< nscns
; i
++)
226 struct internal_scnhdr tmp
;
227 bfd_coff_swap_scnhdr_in (abfd
,
228 (PTR
) (external_sections
+ i
* scnhsz
),
230 if (! make_a_section_from_file (abfd
, &tmp
, i
+ 1))
235 /* make_abs_section (abfd); */
240 bfd_release (abfd
, tdata
);
241 abfd
->flags
= oflags
;
242 bfd_get_start_address (abfd
) = ostart
;
243 return (const bfd_target
*) NULL
;
246 /* Turn a COFF file into a BFD, but fail with bfd_error_wrong_format if it is
247 not a COFF file. This is also used by ECOFF. */
257 struct internal_filehdr internal_f
;
258 struct internal_aouthdr internal_a
;
260 /* figure out how much to read */
261 filhsz
= bfd_coff_filhsz (abfd
);
262 aoutsz
= bfd_coff_aoutsz (abfd
);
264 filehdr
= bfd_alloc (abfd
, filhsz
);
267 if (bfd_read (filehdr
, 1, filhsz
, abfd
) != filhsz
)
269 if (bfd_get_error () != bfd_error_system_call
)
270 bfd_set_error (bfd_error_wrong_format
);
273 bfd_coff_swap_filehdr_in (abfd
, filehdr
, &internal_f
);
274 bfd_release (abfd
, filehdr
);
276 if (bfd_coff_bad_format_hook (abfd
, &internal_f
) == false)
278 bfd_set_error (bfd_error_wrong_format
);
281 nscns
= internal_f
.f_nscns
;
283 if (internal_f
.f_opthdr
)
287 opthdr
= bfd_alloc (abfd
, aoutsz
);
290 if (bfd_read (opthdr
, 1, internal_f
.f_opthdr
, abfd
)
291 != internal_f
.f_opthdr
)
295 bfd_coff_swap_aouthdr_in (abfd
, opthdr
, (PTR
) &internal_a
);
298 return coff_real_object_p (abfd
, nscns
, &internal_f
,
299 (internal_f
.f_opthdr
!= 0
301 : (struct internal_aouthdr
*) NULL
));
304 /* Get the BFD section from a COFF symbol section number. */
307 coff_section_from_bfd_index (abfd
, index
)
311 struct sec
*answer
= abfd
->sections
;
314 return bfd_abs_section_ptr
;
315 if (index
== N_UNDEF
)
316 return bfd_und_section_ptr
;
317 if (index
== N_DEBUG
)
318 return bfd_abs_section_ptr
;
322 if (answer
->target_index
== index
)
324 answer
= answer
->next
;
327 /* We should not reach this point, but the SCO 3.2v4 /lib/libc_s.a
328 has a bad symbol table in biglitpow.o. */
329 return bfd_und_section_ptr
;
332 /* Get the upper bound of a COFF symbol table. */
335 coff_get_symtab_upper_bound (abfd
)
338 if (!bfd_coff_slurp_symbol_table (abfd
))
341 return (bfd_get_symcount (abfd
) + 1) * (sizeof (coff_symbol_type
*));
344 /* Canonicalize a COFF symbol table. */
347 coff_get_symtab (abfd
, alocation
)
351 unsigned int counter
;
352 coff_symbol_type
*symbase
;
353 coff_symbol_type
**location
= (coff_symbol_type
**) alocation
;
355 if (!bfd_coff_slurp_symbol_table (abfd
))
358 symbase
= obj_symbols (abfd
);
359 counter
= bfd_get_symcount (abfd
);
360 while (counter
-- > 0)
361 *location
++ = symbase
++;
365 return bfd_get_symcount (abfd
);
368 /* Get the name of a symbol. The caller must pass in a buffer of size
372 _bfd_coff_internal_syment_name (abfd
, sym
, buf
)
374 const struct internal_syment
*sym
;
377 /* FIXME: It's not clear this will work correctly if sizeof
379 if (sym
->_n
._n_n
._n_zeroes
!= 0
380 || sym
->_n
._n_n
._n_offset
== 0)
382 memcpy (buf
, sym
->_n
._n_name
, SYMNMLEN
);
383 buf
[SYMNMLEN
] = '\0';
390 BFD_ASSERT (sym
->_n
._n_n
._n_offset
>= STRING_SIZE_SIZE
);
391 strings
= obj_coff_strings (abfd
);
394 strings
= _bfd_coff_read_string_table (abfd
);
398 return strings
+ sym
->_n
._n_n
._n_offset
;
402 /* Read in and swap the relocs. This returns a buffer holding the
403 relocs for section SEC in file ABFD. If CACHE is true and
404 INTERNAL_RELOCS is NULL, the relocs read in will be saved in case
405 the function is called again. If EXTERNAL_RELOCS is not NULL, it
406 is a buffer large enough to hold the unswapped relocs. If
407 INTERNAL_RELOCS is not NULL, it is a buffer large enough to hold
408 the swapped relocs. If REQUIRE_INTERNAL is true, then the return
409 value must be INTERNAL_RELOCS. The function returns NULL on error. */
411 struct internal_reloc
*
412 _bfd_coff_read_internal_relocs (abfd
, sec
, cache
, external_relocs
,
413 require_internal
, internal_relocs
)
417 bfd_byte
*external_relocs
;
418 boolean require_internal
;
419 struct internal_reloc
*internal_relocs
;
422 bfd_byte
*free_external
= NULL
;
423 struct internal_reloc
*free_internal
= NULL
;
426 struct internal_reloc
*irel
;
428 if (coff_section_data (abfd
, sec
) != NULL
429 && coff_section_data (abfd
, sec
)->relocs
!= NULL
)
431 if (! require_internal
)
432 return coff_section_data (abfd
, sec
)->relocs
;
433 memcpy (internal_relocs
, coff_section_data (abfd
, sec
)->relocs
,
434 sec
->reloc_count
* sizeof (struct internal_reloc
));
435 return internal_relocs
;
438 relsz
= bfd_coff_relsz (abfd
);
440 if (external_relocs
== NULL
)
442 free_external
= (bfd_byte
*) bfd_malloc (sec
->reloc_count
* relsz
);
443 if (free_external
== NULL
&& sec
->reloc_count
> 0)
445 external_relocs
= free_external
;
448 if (bfd_seek (abfd
, sec
->rel_filepos
, SEEK_SET
) != 0
449 || (bfd_read (external_relocs
, relsz
, sec
->reloc_count
, abfd
)
450 != relsz
* sec
->reloc_count
))
453 if (internal_relocs
== NULL
)
455 free_internal
= ((struct internal_reloc
*)
456 bfd_malloc (sec
->reloc_count
457 * sizeof (struct internal_reloc
)));
458 if (free_internal
== NULL
&& sec
->reloc_count
> 0)
460 internal_relocs
= free_internal
;
463 /* Swap in the relocs. */
464 erel
= external_relocs
;
465 erel_end
= erel
+ relsz
* sec
->reloc_count
;
466 irel
= internal_relocs
;
467 for (; erel
< erel_end
; erel
+= relsz
, irel
++)
468 bfd_coff_swap_reloc_in (abfd
, (PTR
) erel
, (PTR
) irel
);
470 if (free_external
!= NULL
)
472 free (free_external
);
473 free_external
= NULL
;
476 if (cache
&& free_internal
!= NULL
)
478 if (coff_section_data (abfd
, sec
) == NULL
)
481 (PTR
) bfd_zalloc (abfd
,
482 sizeof (struct coff_section_tdata
));
483 if (sec
->used_by_bfd
== NULL
)
485 coff_section_data (abfd
, sec
)->contents
= NULL
;
487 coff_section_data (abfd
, sec
)->relocs
= free_internal
;
490 return internal_relocs
;
493 if (free_external
!= NULL
)
494 free (free_external
);
495 if (free_internal
!= NULL
)
496 free (free_internal
);
500 /* Set lineno_count for the output sections of a COFF file. */
503 coff_count_linenumbers (abfd
)
506 unsigned int limit
= bfd_get_symcount (abfd
);
514 /* This may be from the backend linker, in which case the
515 lineno_count in the sections is correct. */
516 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
517 total
+= s
->lineno_count
;
521 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
522 BFD_ASSERT (s
->lineno_count
== 0);
524 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
526 asymbol
*q_maybe
= *p
;
528 if (bfd_family_coff (bfd_asymbol_bfd (q_maybe
)))
530 coff_symbol_type
*q
= coffsymbol (q_maybe
);
532 /* The AIX 4.1 compiler can sometimes generate line numbers
533 attached to debugging symbols. We try to simply ignore
535 if (q
->lineno
!= NULL
536 && q
->symbol
.section
->owner
!= NULL
)
538 /* This symbol has line numbers. Increment the owning
539 section's linenumber count. */
540 alent
*l
= q
->lineno
;
542 ++q
->symbol
.section
->output_section
->lineno_count
;
545 while (l
->line_number
!= 0)
548 ++q
->symbol
.section
->output_section
->lineno_count
;
558 /* Takes a bfd and a symbol, returns a pointer to the coff specific
559 area of the symbol if there is one. */
562 coff_symbol_from (ignore_abfd
, symbol
)
563 bfd
*ignore_abfd ATTRIBUTE_UNUSED
;
566 if (!bfd_family_coff (bfd_asymbol_bfd (symbol
)))
567 return (coff_symbol_type
*) NULL
;
569 if (bfd_asymbol_bfd (symbol
)->tdata
.coff_obj_data
== (coff_data_type
*) NULL
)
570 return (coff_symbol_type
*) NULL
;
572 return (coff_symbol_type
*) symbol
;
576 fixup_symbol_value (abfd
, coff_symbol_ptr
, syment
)
578 coff_symbol_type
*coff_symbol_ptr
;
579 struct internal_syment
*syment
;
582 /* Normalize the symbol flags */
583 if (bfd_is_com_section (coff_symbol_ptr
->symbol
.section
))
585 /* a common symbol is undefined with a value */
586 syment
->n_scnum
= N_UNDEF
;
587 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
589 else if ((coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
) != 0
590 && (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING_RELOC
) == 0)
592 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
594 else if (bfd_is_und_section (coff_symbol_ptr
->symbol
.section
))
596 syment
->n_scnum
= N_UNDEF
;
599 /* FIXME: Do we need to handle the absolute section here? */
602 if (coff_symbol_ptr
->symbol
.section
)
605 coff_symbol_ptr
->symbol
.section
->output_section
->target_index
;
607 syment
->n_value
= (coff_symbol_ptr
->symbol
.value
608 + coff_symbol_ptr
->symbol
.section
->output_offset
);
611 syment
->n_value
+= (syment
->n_sclass
== C_STATLAB
)
612 ? coff_symbol_ptr
->symbol
.section
->output_section
->lma
613 : coff_symbol_ptr
->symbol
.section
->output_section
->vma
;
619 /* This can happen, but I don't know why yet (steve@cygnus.com) */
620 syment
->n_scnum
= N_ABS
;
621 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
626 /* Run through all the symbols in the symbol table and work out what
627 their indexes into the symbol table will be when output.
629 Coff requires that each C_FILE symbol points to the next one in the
630 chain, and that the last one points to the first external symbol. We
634 coff_renumber_symbols (bfd_ptr
, first_undef
)
638 unsigned int symbol_count
= bfd_get_symcount (bfd_ptr
);
639 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
640 unsigned int native_index
= 0;
641 struct internal_syment
*last_file
= (struct internal_syment
*) NULL
;
642 unsigned int symbol_index
;
644 /* COFF demands that undefined symbols come after all other symbols.
645 Since we don't need to impose this extra knowledge on all our
646 client programs, deal with that here. Sort the symbol table;
647 just move the undefined symbols to the end, leaving the rest
648 alone. The O'Reilly book says that defined global symbols come
649 at the end before the undefined symbols, so we do that here as
651 /* @@ Do we have some condition we could test for, so we don't always
652 have to do this? I don't think relocatability is quite right, but
653 I'm not certain. [raeburn:19920508.1711EST] */
658 newsyms
= (asymbol
**) bfd_alloc (bfd_ptr
,
659 sizeof (asymbol
*) * (symbol_count
+ 1));
662 bfd_ptr
->outsymbols
= newsyms
;
663 for (i
= 0; i
< symbol_count
; i
++)
664 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) != 0
665 || (!bfd_is_und_section (symbol_ptr_ptr
[i
]->section
)
666 && !bfd_is_com_section (symbol_ptr_ptr
[i
]->section
)
667 && ((symbol_ptr_ptr
[i
]->flags
& BSF_FUNCTION
) != 0
668 || ((symbol_ptr_ptr
[i
]->flags
& (BSF_GLOBAL
| BSF_WEAK
))
670 *newsyms
++ = symbol_ptr_ptr
[i
];
672 for (i
= 0; i
< symbol_count
; i
++)
673 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) == 0
674 && !bfd_is_und_section (symbol_ptr_ptr
[i
]->section
)
675 && (bfd_is_com_section (symbol_ptr_ptr
[i
]->section
)
676 || ((symbol_ptr_ptr
[i
]->flags
& BSF_FUNCTION
) == 0
677 && ((symbol_ptr_ptr
[i
]->flags
& (BSF_GLOBAL
| BSF_WEAK
))
679 *newsyms
++ = symbol_ptr_ptr
[i
];
681 *first_undef
= newsyms
- bfd_ptr
->outsymbols
;
683 for (i
= 0; i
< symbol_count
; i
++)
684 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) == 0
685 && bfd_is_und_section (symbol_ptr_ptr
[i
]->section
))
686 *newsyms
++ = symbol_ptr_ptr
[i
];
687 *newsyms
= (asymbol
*) NULL
;
688 symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
691 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
693 coff_symbol_type
*coff_symbol_ptr
= coff_symbol_from (bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
694 symbol_ptr_ptr
[symbol_index
]->udata
.i
= symbol_index
;
695 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
)
697 combined_entry_type
*s
= coff_symbol_ptr
->native
;
700 if (s
->u
.syment
.n_sclass
== C_FILE
)
702 if (last_file
!= (struct internal_syment
*) NULL
)
703 last_file
->n_value
= native_index
;
704 last_file
= &(s
->u
.syment
);
709 /* Modify the symbol values according to their section and
712 fixup_symbol_value (bfd_ptr
, coff_symbol_ptr
, &(s
->u
.syment
));
714 for (i
= 0; i
< s
->u
.syment
.n_numaux
+ 1; i
++)
715 s
[i
].offset
= native_index
++;
722 obj_conv_table_size (bfd_ptr
) = native_index
;
727 /* Run thorough the symbol table again, and fix it so that all
728 pointers to entries are changed to the entries' index in the output
732 coff_mangle_symbols (bfd_ptr
)
735 unsigned int symbol_count
= bfd_get_symcount (bfd_ptr
);
736 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
737 unsigned int symbol_index
;
739 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
741 coff_symbol_type
*coff_symbol_ptr
=
742 coff_symbol_from (bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
744 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
)
747 combined_entry_type
*s
= coff_symbol_ptr
->native
;
751 /* FIXME: We should use a union here. */
752 s
->u
.syment
.n_value
=
753 (bfd_vma
)((combined_entry_type
*)
754 ((unsigned long) s
->u
.syment
.n_value
))->offset
;
759 /* The value is the offset into the line number entries
760 for the symbol's section. On output, the symbol's
761 section should be N_DEBUG. */
762 s
->u
.syment
.n_value
=
763 (coff_symbol_ptr
->symbol
.section
->output_section
->line_filepos
764 + s
->u
.syment
.n_value
* bfd_coff_linesz (bfd_ptr
));
765 coff_symbol_ptr
->symbol
.section
=
766 coff_section_from_bfd_index (bfd_ptr
, N_DEBUG
);
767 BFD_ASSERT (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
);
769 for (i
= 0; i
< s
->u
.syment
.n_numaux
; i
++)
771 combined_entry_type
*a
= s
+ i
+ 1;
774 a
->u
.auxent
.x_sym
.x_tagndx
.l
=
775 a
->u
.auxent
.x_sym
.x_tagndx
.p
->offset
;
780 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
781 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
->offset
;
786 a
->u
.auxent
.x_csect
.x_scnlen
.l
=
787 a
->u
.auxent
.x_csect
.x_scnlen
.p
->offset
;
796 coff_fix_symbol_name (abfd
, symbol
, native
, string_size_p
,
797 debug_string_section_p
, debug_string_size_p
)
800 combined_entry_type
*native
;
801 bfd_size_type
*string_size_p
;
802 asection
**debug_string_section_p
;
803 bfd_size_type
*debug_string_size_p
;
805 unsigned int name_length
;
806 union internal_auxent
*auxent
;
807 char *name
= (char *) (symbol
->name
);
809 if (name
== (char *) NULL
)
811 /* coff symbols always have names, so we'll make one up */
812 symbol
->name
= "strange";
813 name
= (char *) symbol
->name
;
815 name_length
= strlen (name
);
817 if (native
->u
.syment
.n_sclass
== C_FILE
818 && native
->u
.syment
.n_numaux
> 0)
820 unsigned int filnmlen
;
822 if (bfd_coff_force_symnames_in_strings (abfd
))
824 native
->u
.syment
._n
._n_n
._n_offset
=
825 (*string_size_p
+ STRING_SIZE_SIZE
);
826 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
827 *string_size_p
+= 6; /* strlen(".file") + 1 */
830 strncpy (native
->u
.syment
._n
._n_name
, ".file", SYMNMLEN
);
832 auxent
= &(native
+ 1)->u
.auxent
;
834 filnmlen
= bfd_coff_filnmlen (abfd
);
836 if (bfd_coff_long_filenames (abfd
))
838 if (name_length
<= filnmlen
)
840 strncpy (auxent
->x_file
.x_fname
, name
, filnmlen
);
844 auxent
->x_file
.x_n
.x_offset
= *string_size_p
+ STRING_SIZE_SIZE
;
845 auxent
->x_file
.x_n
.x_zeroes
= 0;
846 *string_size_p
+= name_length
+ 1;
851 strncpy (auxent
->x_file
.x_fname
, name
, filnmlen
);
852 if (name_length
> filnmlen
)
853 name
[filnmlen
] = '\0';
858 if (name_length
<= SYMNMLEN
&& !bfd_coff_force_symnames_in_strings (abfd
))
860 /* This name will fit into the symbol neatly */
861 strncpy (native
->u
.syment
._n
._n_name
, symbol
->name
, SYMNMLEN
);
863 else if (!bfd_coff_symname_in_debug (abfd
, &native
->u
.syment
))
865 native
->u
.syment
._n
._n_n
._n_offset
= (*string_size_p
867 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
868 *string_size_p
+= name_length
+ 1;
874 int prefix_len
= bfd_coff_debug_string_prefix_length (abfd
);
876 /* This name should be written into the .debug section. For
877 some reason each name is preceded by a two byte length
878 and also followed by a null byte. FIXME: We assume that
879 the .debug section has already been created, and that it
881 if (*debug_string_section_p
== (asection
*) NULL
)
882 *debug_string_section_p
= bfd_get_section_by_name (abfd
, ".debug");
883 filepos
= bfd_tell (abfd
);
885 bfd_put_32 (abfd
, name_length
+ 1, buf
);
887 bfd_put_16 (abfd
, name_length
+ 1, buf
);
889 if (!bfd_set_section_contents (abfd
,
890 *debug_string_section_p
,
892 (file_ptr
) *debug_string_size_p
,
893 (bfd_size_type
) prefix_len
)
894 || !bfd_set_section_contents (abfd
,
895 *debug_string_section_p
,
897 ((file_ptr
) *debug_string_size_p
899 (bfd_size_type
) name_length
+ 1))
901 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
903 native
->u
.syment
._n
._n_n
._n_offset
=
904 *debug_string_size_p
+ prefix_len
;
905 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
906 *debug_string_size_p
+= name_length
+ 1 + prefix_len
;
911 /* We need to keep track of the symbol index so that when we write out
912 the relocs we can get the index for a symbol. This method is a
915 #define set_index(symbol, idx) ((symbol)->udata.i = (idx))
917 /* Write a symbol out to a COFF file. */
920 coff_write_symbol (abfd
, symbol
, native
, written
, string_size_p
,
921 debug_string_section_p
, debug_string_size_p
)
924 combined_entry_type
*native
;
926 bfd_size_type
*string_size_p
;
927 asection
**debug_string_section_p
;
928 bfd_size_type
*debug_string_size_p
;
930 unsigned int numaux
= native
->u
.syment
.n_numaux
;
931 int type
= native
->u
.syment
.n_type
;
932 int class = native
->u
.syment
.n_sclass
;
934 bfd_size_type symesz
;
936 if (native
->u
.syment
.n_sclass
== C_FILE
)
937 symbol
->flags
|= BSF_DEBUGGING
;
939 if (symbol
->flags
& BSF_DEBUGGING
940 && bfd_is_abs_section (symbol
->section
))
942 native
->u
.syment
.n_scnum
= N_DEBUG
;
944 else if (bfd_is_abs_section (symbol
->section
))
946 native
->u
.syment
.n_scnum
= N_ABS
;
948 else if (bfd_is_und_section (symbol
->section
))
950 native
->u
.syment
.n_scnum
= N_UNDEF
;
954 native
->u
.syment
.n_scnum
=
955 symbol
->section
->output_section
->target_index
;
958 coff_fix_symbol_name (abfd
, symbol
, native
, string_size_p
,
959 debug_string_section_p
, debug_string_size_p
);
961 symesz
= bfd_coff_symesz (abfd
);
962 buf
= bfd_alloc (abfd
, symesz
);
965 bfd_coff_swap_sym_out (abfd
, &native
->u
.syment
, buf
);
966 if (bfd_write (buf
, 1, symesz
, abfd
) != symesz
)
968 bfd_release (abfd
, buf
);
970 if (native
->u
.syment
.n_numaux
> 0)
972 bfd_size_type auxesz
;
975 auxesz
= bfd_coff_auxesz (abfd
);
976 buf
= bfd_alloc (abfd
, auxesz
);
979 for (j
= 0; j
< native
->u
.syment
.n_numaux
; j
++)
981 bfd_coff_swap_aux_out (abfd
,
982 &((native
+ j
+ 1)->u
.auxent
),
986 native
->u
.syment
.n_numaux
,
988 if (bfd_write (buf
, 1, auxesz
, abfd
) != auxesz
)
991 bfd_release (abfd
, buf
);
994 /* Store the index for use when we write out the relocs. */
995 set_index (symbol
, *written
);
997 *written
+= numaux
+ 1;
1001 /* Write out a symbol to a COFF file that does not come from a COFF
1002 file originally. This symbol may have been created by the linker,
1003 or we may be linking a non COFF file to a COFF file. */
1006 coff_write_alien_symbol (abfd
, symbol
, written
, string_size_p
,
1007 debug_string_section_p
, debug_string_size_p
)
1011 bfd_size_type
*string_size_p
;
1012 asection
**debug_string_section_p
;
1013 bfd_size_type
*debug_string_size_p
;
1015 combined_entry_type
*native
;
1016 combined_entry_type dummy
;
1019 native
->u
.syment
.n_type
= T_NULL
;
1020 native
->u
.syment
.n_flags
= 0;
1021 if (bfd_is_und_section (symbol
->section
))
1023 native
->u
.syment
.n_scnum
= N_UNDEF
;
1024 native
->u
.syment
.n_value
= symbol
->value
;
1026 else if (bfd_is_com_section (symbol
->section
))
1028 native
->u
.syment
.n_scnum
= N_UNDEF
;
1029 native
->u
.syment
.n_value
= symbol
->value
;
1031 else if (symbol
->flags
& BSF_DEBUGGING
)
1033 /* There isn't much point to writing out a debugging symbol
1034 unless we are prepared to convert it into COFF debugging
1035 format. So, we just ignore them. We must clobber the symbol
1036 name to keep it from being put in the string table. */
1042 native
->u
.syment
.n_scnum
=
1043 symbol
->section
->output_section
->target_index
;
1044 native
->u
.syment
.n_value
= (symbol
->value
1045 + symbol
->section
->output_offset
);
1046 if (! obj_pe (abfd
))
1047 native
->u
.syment
.n_value
+= symbol
->section
->output_section
->vma
;
1049 /* Copy the any flags from the the file header into the symbol.
1052 coff_symbol_type
*c
= coff_symbol_from (abfd
, symbol
);
1053 if (c
!= (coff_symbol_type
*) NULL
)
1054 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (&c
->symbol
)->flags
;
1058 native
->u
.syment
.n_type
= 0;
1059 if (symbol
->flags
& BSF_LOCAL
)
1060 native
->u
.syment
.n_sclass
= C_STAT
;
1061 else if (symbol
->flags
& BSF_WEAK
)
1062 native
->u
.syment
.n_sclass
= obj_pe (abfd
) ? C_NT_WEAK
: C_WEAKEXT
;
1064 native
->u
.syment
.n_sclass
= C_EXT
;
1065 native
->u
.syment
.n_numaux
= 0;
1067 return coff_write_symbol (abfd
, symbol
, native
, written
, string_size_p
,
1068 debug_string_section_p
, debug_string_size_p
);
1071 /* Write a native symbol to a COFF file. */
1074 coff_write_native_symbol (abfd
, symbol
, written
, string_size_p
,
1075 debug_string_section_p
, debug_string_size_p
)
1077 coff_symbol_type
*symbol
;
1079 bfd_size_type
*string_size_p
;
1080 asection
**debug_string_section_p
;
1081 bfd_size_type
*debug_string_size_p
;
1083 combined_entry_type
*native
= symbol
->native
;
1084 alent
*lineno
= symbol
->lineno
;
1086 /* If this symbol has an associated line number, we must store the
1087 symbol index in the line number field. We also tag the auxent to
1088 point to the right place in the lineno table. */
1089 if (lineno
&& !symbol
->done_lineno
&& symbol
->symbol
.section
->owner
!= NULL
)
1091 unsigned int count
= 0;
1092 lineno
[count
].u
.offset
= *written
;
1093 if (native
->u
.syment
.n_numaux
)
1095 union internal_auxent
*a
= &((native
+ 1)->u
.auxent
);
1097 a
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1098 symbol
->symbol
.section
->output_section
->moving_line_filepos
;
1101 /* Count and relocate all other linenumbers. */
1103 while (lineno
[count
].line_number
!= 0)
1107 I've been told this, but still need proof:
1108 > The second bug is also in `bfd/coffcode.h'. This bug
1109 > causes the linker to screw up the pc-relocations for
1110 > all the line numbers in COFF code. This bug isn't only
1111 > specific to A29K implementations, but affects all
1112 > systems using COFF format binaries. Note that in COFF
1113 > object files, the line number core offsets output by
1114 > the assembler are relative to the start of each
1115 > procedure, not to the start of the .text section. This
1116 > patch relocates the line numbers relative to the
1117 > `native->u.syment.n_value' instead of the section
1119 > modular!olson@cs.arizona.edu (Jon Olson)
1121 lineno
[count
].u
.offset
+= native
->u
.syment
.n_value
;
1123 lineno
[count
].u
.offset
+=
1124 (symbol
->symbol
.section
->output_section
->vma
1125 + symbol
->symbol
.section
->output_offset
);
1129 symbol
->done_lineno
= true;
1131 symbol
->symbol
.section
->output_section
->moving_line_filepos
+=
1132 count
* bfd_coff_linesz (abfd
);
1135 return coff_write_symbol (abfd
, &(symbol
->symbol
), native
, written
,
1136 string_size_p
, debug_string_section_p
,
1137 debug_string_size_p
);
1140 /* Write out the COFF symbols. */
1143 coff_write_symbols (abfd
)
1146 bfd_size_type string_size
;
1147 asection
*debug_string_section
;
1148 bfd_size_type debug_string_size
;
1150 unsigned int limit
= bfd_get_symcount (abfd
);
1151 bfd_signed_vma written
= 0;
1155 debug_string_section
= NULL
;
1156 debug_string_size
= 0;
1158 /* If this target supports long section names, they must be put into
1159 the string table. This is supported by PE. This code must
1160 handle section names just as they are handled in
1161 coff_write_object_contents. */
1162 if (bfd_coff_long_section_names (abfd
))
1166 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1170 len
= strlen (o
->name
);
1172 string_size
+= len
+ 1;
1176 /* Seek to the right place */
1177 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
1180 /* Output all the symbols we have */
1183 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1185 asymbol
*symbol
= *p
;
1186 coff_symbol_type
*c_symbol
= coff_symbol_from (abfd
, symbol
);
1188 if (c_symbol
== (coff_symbol_type
*) NULL
1189 || c_symbol
->native
== (combined_entry_type
*) NULL
)
1191 if (!coff_write_alien_symbol (abfd
, symbol
, &written
, &string_size
,
1192 &debug_string_section
,
1193 &debug_string_size
))
1198 if (!coff_write_native_symbol (abfd
, c_symbol
, &written
,
1199 &string_size
, &debug_string_section
,
1200 &debug_string_size
))
1205 obj_raw_syment_count (abfd
) = written
;
1207 /* Now write out strings */
1209 if (string_size
!= 0)
1211 unsigned int size
= string_size
+ STRING_SIZE_SIZE
;
1212 bfd_byte buffer
[STRING_SIZE_SIZE
];
1214 #if STRING_SIZE_SIZE == 4
1215 bfd_h_put_32 (abfd
, size
, buffer
);
1217 #error Change bfd_h_put_32
1219 if (bfd_write ((PTR
) buffer
, 1, sizeof (buffer
), abfd
) != sizeof (buffer
))
1222 /* Handle long section names. This code must handle section
1223 names just as they are handled in coff_write_object_contents. */
1224 if (bfd_coff_long_section_names (abfd
))
1228 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1232 len
= strlen (o
->name
);
1235 if (bfd_write (o
->name
, 1, len
+ 1, abfd
) != len
+ 1)
1241 for (p
= abfd
->outsymbols
, i
= 0;
1246 size_t name_length
= strlen (q
->name
);
1247 coff_symbol_type
*c_symbol
= coff_symbol_from (abfd
, q
);
1250 /* Figure out whether the symbol name should go in the string
1251 table. Symbol names that are short enough are stored
1252 directly in the syment structure. File names permit a
1253 different, longer, length in the syment structure. On
1254 XCOFF, some symbol names are stored in the .debug section
1255 rather than in the string table. */
1257 if (c_symbol
== NULL
1258 || c_symbol
->native
== NULL
)
1260 /* This is not a COFF symbol, so it certainly is not a
1261 file name, nor does it go in the .debug section. */
1262 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1264 else if (bfd_coff_symname_in_debug (abfd
,
1265 &c_symbol
->native
->u
.syment
))
1267 /* This symbol name is in the XCOFF .debug section.
1268 Don't write it into the string table. */
1269 maxlen
= name_length
;
1271 else if (c_symbol
->native
->u
.syment
.n_sclass
== C_FILE
1272 && c_symbol
->native
->u
.syment
.n_numaux
> 0)
1274 if (bfd_coff_force_symnames_in_strings (abfd
))
1275 bfd_write (".file", 1, 6, abfd
);
1276 maxlen
= bfd_coff_filnmlen (abfd
);
1279 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1281 if (name_length
> maxlen
)
1283 if (bfd_write ((PTR
) (q
->name
), 1, name_length
+ 1, abfd
)
1291 /* We would normally not write anything here, but we'll write
1292 out 4 so that any stupid coff reader which tries to read the
1293 string table even when there isn't one won't croak. */
1294 unsigned int size
= STRING_SIZE_SIZE
;
1295 bfd_byte buffer
[STRING_SIZE_SIZE
];
1297 #if STRING_SIZE_SIZE == 4
1298 bfd_h_put_32 (abfd
, size
, buffer
);
1300 #error Change bfd_h_put_32
1302 if (bfd_write ((PTR
) buffer
, 1, STRING_SIZE_SIZE
, abfd
)
1303 != STRING_SIZE_SIZE
)
1307 /* Make sure the .debug section was created to be the correct size.
1308 We should create it ourselves on the fly, but we don't because
1309 BFD won't let us write to any section until we know how large all
1310 the sections are. We could still do it by making another pass
1311 over the symbols. FIXME. */
1312 BFD_ASSERT (debug_string_size
== 0
1313 || (debug_string_section
!= (asection
*) NULL
1314 && (BFD_ALIGN (debug_string_size
,
1315 1 << debug_string_section
->alignment_power
)
1316 == bfd_section_size (abfd
, debug_string_section
))));
1322 coff_write_linenumbers (abfd
)
1326 bfd_size_type linesz
;
1329 linesz
= bfd_coff_linesz (abfd
);
1330 buff
= bfd_alloc (abfd
, linesz
);
1333 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
1335 if (s
->lineno_count
)
1337 asymbol
**q
= abfd
->outsymbols
;
1338 if (bfd_seek (abfd
, s
->line_filepos
, SEEK_SET
) != 0)
1340 /* Find all the linenumbers in this section */
1344 if (p
->section
->output_section
== s
)
1347 BFD_SEND (bfd_asymbol_bfd (p
), _get_lineno
,
1348 (bfd_asymbol_bfd (p
), p
));
1351 /* Found a linenumber entry, output */
1352 struct internal_lineno out
;
1353 memset ((PTR
) & out
, 0, sizeof (out
));
1355 out
.l_addr
.l_symndx
= l
->u
.offset
;
1356 bfd_coff_swap_lineno_out (abfd
, &out
, buff
);
1357 if (bfd_write (buff
, 1, linesz
, abfd
) != linesz
)
1360 while (l
->line_number
)
1362 out
.l_lnno
= l
->line_number
;
1363 out
.l_addr
.l_symndx
= l
->u
.offset
;
1364 bfd_coff_swap_lineno_out (abfd
, &out
, buff
);
1365 if (bfd_write (buff
, 1, linesz
, abfd
) != linesz
)
1375 bfd_release (abfd
, buff
);
1380 coff_get_lineno (ignore_abfd
, symbol
)
1381 bfd
*ignore_abfd ATTRIBUTE_UNUSED
;
1384 return coffsymbol (symbol
)->lineno
;
1389 /* This is only called from coff_add_missing_symbols, which has been
1393 coff_section_symbol (abfd
, name
)
1397 asection
*sec
= bfd_make_section_old_way (abfd
, name
);
1399 combined_entry_type
*csym
;
1402 csym
= coff_symbol_from (abfd
, sym
)->native
;
1403 /* Make sure back-end COFF stuff is there. */
1408 coff_symbol_type sym
;
1409 /* @@FIXME This shouldn't use a fixed size!! */
1410 combined_entry_type e
[10];
1413 f
= (struct foo
*) bfd_alloc (abfd
, sizeof (*f
));
1416 bfd_set_error (bfd_error_no_error
);
1419 memset ((char *) f
, 0, sizeof (*f
));
1420 coff_symbol_from (abfd
, sym
)->native
= csym
= f
->e
;
1422 csym
[0].u
.syment
.n_sclass
= C_STAT
;
1423 csym
[0].u
.syment
.n_numaux
= 1;
1424 /* SF_SET_STATICS (sym); @@ ??? */
1425 csym
[1].u
.auxent
.x_scn
.x_scnlen
= sec
->_raw_size
;
1426 csym
[1].u
.auxent
.x_scn
.x_nreloc
= sec
->reloc_count
;
1427 csym
[1].u
.auxent
.x_scn
.x_nlinno
= sec
->lineno_count
;
1429 if (sec
->output_section
== NULL
)
1431 sec
->output_section
= sec
;
1432 sec
->output_offset
= 0;
1440 /* This function transforms the offsets into the symbol table into
1441 pointers to syments. */
1444 coff_pointerize_aux (abfd
, table_base
, symbol
, indaux
, auxent
)
1446 combined_entry_type
*table_base
;
1447 combined_entry_type
*symbol
;
1448 unsigned int indaux
;
1449 combined_entry_type
*auxent
;
1451 unsigned int type
= symbol
->u
.syment
.n_type
;
1452 unsigned int class = symbol
->u
.syment
.n_sclass
;
1454 if (coff_backend_info (abfd
)->_bfd_coff_pointerize_aux_hook
)
1456 if ((*coff_backend_info (abfd
)->_bfd_coff_pointerize_aux_hook
)
1457 (abfd
, table_base
, symbol
, indaux
, auxent
))
1461 /* Don't bother if this is a file or a section */
1462 if (class == C_STAT
&& type
== T_NULL
)
1464 if (class == C_FILE
)
1467 /* Otherwise patch up */
1468 #define N_TMASK coff_data (abfd)->local_n_tmask
1469 #define N_BTSHFT coff_data (abfd)->local_n_btshft
1470 if ((ISFCN (type
) || ISTAG (class) || class == C_BLOCK
|| class == C_FCN
)
1471 && auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
> 0)
1473 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
=
1474 table_base
+ auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
1475 auxent
->fix_end
= 1;
1477 /* A negative tagndx is meaningless, but the SCO 3.2v4 cc can
1478 generate one, so we must be careful to ignore it. */
1479 if (auxent
->u
.auxent
.x_sym
.x_tagndx
.l
> 0)
1481 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
=
1482 table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
;
1483 auxent
->fix_tag
= 1;
1487 /* Allocate space for the ".debug" section, and read it.
1488 We did not read the debug section until now, because
1489 we didn't want to go to the trouble until someone needed it. */
1492 build_debug_section (abfd
)
1495 char *debug_section
;
1498 asection
*sect
= bfd_get_section_by_name (abfd
, ".debug");
1502 bfd_set_error (bfd_error_no_debug_section
);
1506 debug_section
= (PTR
) bfd_alloc (abfd
,
1507 bfd_get_section_size_before_reloc (sect
));
1508 if (debug_section
== NULL
)
1511 /* Seek to the beginning of the `.debug' section and read it.
1512 Save the current position first; it is needed by our caller.
1513 Then read debug section and reset the file pointer. */
1515 position
= bfd_tell (abfd
);
1516 if (bfd_seek (abfd
, sect
->filepos
, SEEK_SET
) != 0
1517 || (bfd_read (debug_section
,
1518 bfd_get_section_size_before_reloc (sect
), 1, abfd
)
1519 != bfd_get_section_size_before_reloc (sect
))
1520 || bfd_seek (abfd
, position
, SEEK_SET
) != 0)
1522 return debug_section
;
1525 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
1526 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
1527 be \0-terminated. */
1529 copy_name (abfd
, name
, maxlen
)
1537 for (len
= 0; len
< maxlen
; ++len
)
1539 if (name
[len
] == '\0')
1545 if ((newname
= (PTR
) bfd_alloc (abfd
, len
+ 1)) == NULL
)
1547 strncpy (newname
, name
, len
);
1548 newname
[len
] = '\0';
1552 /* Read in the external symbols. */
1555 _bfd_coff_get_external_symbols (abfd
)
1558 bfd_size_type symesz
;
1562 if (obj_coff_external_syms (abfd
) != NULL
)
1565 symesz
= bfd_coff_symesz (abfd
);
1567 size
= obj_raw_syment_count (abfd
) * symesz
;
1569 syms
= (PTR
) bfd_malloc (size
);
1570 if (syms
== NULL
&& size
!= 0)
1573 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
1574 || bfd_read (syms
, size
, 1, abfd
) != size
)
1581 obj_coff_external_syms (abfd
) = syms
;
1586 /* Read in the external strings. The strings are not loaded until
1587 they are needed. This is because we have no simple way of
1588 detecting a missing string table in an archive. */
1591 _bfd_coff_read_string_table (abfd
)
1594 char extstrsize
[STRING_SIZE_SIZE
];
1598 if (obj_coff_strings (abfd
) != NULL
)
1599 return obj_coff_strings (abfd
);
1601 if (obj_sym_filepos (abfd
) == 0)
1603 bfd_set_error (bfd_error_no_symbols
);
1608 (obj_sym_filepos (abfd
)
1609 + obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
)),
1613 if (bfd_read (extstrsize
, sizeof extstrsize
, 1, abfd
) != sizeof extstrsize
)
1615 if (bfd_get_error () != bfd_error_file_truncated
)
1618 /* There is no string table. */
1619 strsize
= STRING_SIZE_SIZE
;
1623 #if STRING_SIZE_SIZE == 4
1624 strsize
= bfd_h_get_32 (abfd
, (bfd_byte
*) extstrsize
);
1626 #error Change bfd_h_get_32
1630 if (strsize
< STRING_SIZE_SIZE
)
1632 (*_bfd_error_handler
)
1633 (_("%s: bad string table size %lu"), bfd_get_filename (abfd
),
1634 (unsigned long) strsize
);
1635 bfd_set_error (bfd_error_bad_value
);
1639 strings
= (char *) bfd_malloc (strsize
);
1640 if (strings
== NULL
)
1643 if (bfd_read (strings
+ STRING_SIZE_SIZE
,
1644 strsize
- STRING_SIZE_SIZE
, 1, abfd
)
1645 != strsize
- STRING_SIZE_SIZE
)
1651 obj_coff_strings (abfd
) = strings
;
1656 /* Free up the external symbols and strings read from a COFF file. */
1659 _bfd_coff_free_symbols (abfd
)
1662 if (obj_coff_external_syms (abfd
) != NULL
1663 && ! obj_coff_keep_syms (abfd
))
1665 free (obj_coff_external_syms (abfd
));
1666 obj_coff_external_syms (abfd
) = NULL
;
1668 if (obj_coff_strings (abfd
) != NULL
1669 && ! obj_coff_keep_strings (abfd
))
1671 free (obj_coff_strings (abfd
));
1672 obj_coff_strings (abfd
) = NULL
;
1677 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
1678 knit the symbol names into a normalized form. By normalized here I
1679 mean that all symbols have an n_offset pointer that points to a null-
1680 terminated string. */
1682 combined_entry_type
*
1683 coff_get_normalized_symtab (abfd
)
1686 combined_entry_type
*internal
;
1687 combined_entry_type
*internal_ptr
;
1688 combined_entry_type
*symbol_ptr
;
1689 combined_entry_type
*internal_end
;
1690 bfd_size_type symesz
;
1693 const char *string_table
= NULL
;
1694 char *debug_section
= NULL
;
1697 if (obj_raw_syments (abfd
) != NULL
)
1698 return obj_raw_syments (abfd
);
1700 size
= obj_raw_syment_count (abfd
) * sizeof (combined_entry_type
);
1701 internal
= (combined_entry_type
*) bfd_zalloc (abfd
, size
);
1702 if (internal
== NULL
&& size
!= 0)
1704 internal_end
= internal
+ obj_raw_syment_count (abfd
);
1706 if (! _bfd_coff_get_external_symbols (abfd
))
1709 raw_src
= (char *) obj_coff_external_syms (abfd
);
1711 /* mark the end of the symbols */
1712 symesz
= bfd_coff_symesz (abfd
);
1713 raw_end
= (char *) raw_src
+ obj_raw_syment_count (abfd
) * symesz
;
1715 /* FIXME SOMEDAY. A string table size of zero is very weird, but
1716 probably possible. If one shows up, it will probably kill us. */
1718 /* Swap all the raw entries */
1719 for (internal_ptr
= internal
;
1721 raw_src
+= symesz
, internal_ptr
++)
1725 bfd_coff_swap_sym_in (abfd
, (PTR
) raw_src
,
1726 (PTR
) & internal_ptr
->u
.syment
);
1727 symbol_ptr
= internal_ptr
;
1730 i
< symbol_ptr
->u
.syment
.n_numaux
;
1735 bfd_coff_swap_aux_in (abfd
, (PTR
) raw_src
,
1736 symbol_ptr
->u
.syment
.n_type
,
1737 symbol_ptr
->u
.syment
.n_sclass
,
1738 i
, symbol_ptr
->u
.syment
.n_numaux
,
1739 &(internal_ptr
->u
.auxent
));
1740 coff_pointerize_aux (abfd
, internal
, symbol_ptr
, i
,
1745 /* Free the raw symbols, but not the strings (if we have them). */
1746 obj_coff_keep_strings (abfd
) = true;
1747 if (! _bfd_coff_free_symbols (abfd
))
1750 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
1753 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
1754 && internal_ptr
->u
.syment
.n_numaux
> 0)
1756 /* make a file symbol point to the name in the auxent, since
1757 the text ".file" is redundant */
1758 if ((internal_ptr
+ 1)->u
.auxent
.x_file
.x_n
.x_zeroes
== 0)
1760 /* the filename is a long one, point into the string table */
1761 if (string_table
== NULL
)
1763 string_table
= _bfd_coff_read_string_table (abfd
);
1764 if (string_table
== NULL
)
1768 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1771 + (internal_ptr
+ 1)->u
.auxent
.x_file
.x_n
.x_offset
));
1775 /* Ordinary short filename, put into memory anyway. The
1776 Microsoft PE tools sometimes store a filename in
1777 multiple AUX entries. */
1778 if (internal_ptr
->u
.syment
.n_numaux
> 1
1779 && coff_data (abfd
)->pe
)
1781 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1784 (internal_ptr
+ 1)->u
.auxent
.x_file
.x_fname
,
1785 internal_ptr
->u
.syment
.n_numaux
* symesz
));
1789 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1792 (internal_ptr
+ 1)->u
.auxent
.x_file
.x_fname
,
1793 bfd_coff_filnmlen (abfd
)));
1799 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0)
1801 /* This is a "short" name. Make it long. */
1802 unsigned long i
= 0;
1803 char *newstring
= NULL
;
1805 /* find the length of this string without walking into memory
1807 for (i
= 0; i
< 8; ++i
)
1809 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0')
1812 } /* if end of string */
1813 } /* possible lengths of this string. */
1815 if ((newstring
= (PTR
) bfd_alloc (abfd
, ++i
)) == NULL
)
1817 memset (newstring
, 0, i
);
1818 strncpy (newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
- 1);
1819 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (long int) newstring
;
1820 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1822 else if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
== 0)
1823 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (long int) "";
1824 else if (!bfd_coff_symname_in_debug (abfd
, &internal_ptr
->u
.syment
))
1826 /* Long name already. Point symbol at the string in the
1828 if (string_table
== NULL
)
1830 string_table
= _bfd_coff_read_string_table (abfd
);
1831 if (string_table
== NULL
)
1834 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1837 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
));
1841 /* Long name in debug section. Very similar. */
1842 if (debug_section
== NULL
)
1843 debug_section
= build_debug_section (abfd
);
1844 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (long int)
1845 (debug_section
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
1848 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
1851 obj_raw_syments (abfd
) = internal
;
1852 BFD_ASSERT (obj_raw_syment_count (abfd
)
1853 == (unsigned int) (internal_ptr
- internal
));
1856 } /* coff_get_normalized_symtab() */
1859 coff_get_reloc_upper_bound (abfd
, asect
)
1863 if (bfd_get_format (abfd
) != bfd_object
)
1865 bfd_set_error (bfd_error_invalid_operation
);
1868 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
1872 coff_make_empty_symbol (abfd
)
1875 coff_symbol_type
*new = (coff_symbol_type
*) bfd_alloc (abfd
, sizeof (coff_symbol_type
));
1878 memset (new, 0, sizeof *new);
1879 new->symbol
.section
= 0;
1881 new->lineno
= (alent
*) NULL
;
1882 new->done_lineno
= false;
1883 new->symbol
.the_bfd
= abfd
;
1884 return &new->symbol
;
1887 /* Make a debugging symbol. */
1890 coff_bfd_make_debug_symbol (abfd
, ptr
, sz
)
1892 PTR ptr ATTRIBUTE_UNUSED
;
1893 unsigned long sz ATTRIBUTE_UNUSED
;
1895 coff_symbol_type
*new = (coff_symbol_type
*) bfd_alloc (abfd
, sizeof (coff_symbol_type
));
1898 /* @@ The 10 is a guess at a plausible maximum number of aux entries
1899 (but shouldn't be a constant). */
1900 new->native
= (combined_entry_type
*) bfd_zalloc (abfd
, sizeof (combined_entry_type
) * 10);
1903 new->symbol
.section
= bfd_abs_section_ptr
;
1904 new->symbol
.flags
= BSF_DEBUGGING
;
1905 new->lineno
= (alent
*) NULL
;
1906 new->done_lineno
= false;
1907 new->symbol
.the_bfd
= abfd
;
1908 return &new->symbol
;
1912 coff_get_symbol_info (abfd
, symbol
, ret
)
1917 bfd_symbol_info (symbol
, ret
);
1918 if (coffsymbol (symbol
)->native
!= NULL
1919 && coffsymbol (symbol
)->native
->fix_value
)
1921 ret
->value
= coffsymbol (symbol
)->native
->u
.syment
.n_value
-
1922 (unsigned long) obj_raw_syments (abfd
);
1926 /* Return the COFF syment for a symbol. */
1929 bfd_coff_get_syment (abfd
, symbol
, psyment
)
1932 struct internal_syment
*psyment
;
1934 coff_symbol_type
*csym
;
1936 csym
= coff_symbol_from (abfd
, symbol
);
1937 if (csym
== NULL
|| csym
->native
== NULL
)
1939 bfd_set_error (bfd_error_invalid_operation
);
1943 *psyment
= csym
->native
->u
.syment
;
1945 if (csym
->native
->fix_value
)
1946 psyment
->n_value
= psyment
->n_value
-
1947 (unsigned long) obj_raw_syments (abfd
);
1949 /* FIXME: We should handle fix_line here. */
1954 /* Return the COFF auxent for a symbol. */
1957 bfd_coff_get_auxent (abfd
, symbol
, indx
, pauxent
)
1961 union internal_auxent
*pauxent
;
1963 coff_symbol_type
*csym
;
1964 combined_entry_type
*ent
;
1966 csym
= coff_symbol_from (abfd
, symbol
);
1969 || csym
->native
== NULL
1970 || indx
>= csym
->native
->u
.syment
.n_numaux
)
1972 bfd_set_error (bfd_error_invalid_operation
);
1976 ent
= csym
->native
+ indx
+ 1;
1978 *pauxent
= ent
->u
.auxent
;
1981 pauxent
->x_sym
.x_tagndx
.l
=
1982 ((combined_entry_type
*) pauxent
->x_sym
.x_tagndx
.p
1983 - obj_raw_syments (abfd
));
1986 pauxent
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
1987 ((combined_entry_type
*) pauxent
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
1988 - obj_raw_syments (abfd
));
1990 if (ent
->fix_scnlen
)
1991 pauxent
->x_csect
.x_scnlen
.l
=
1992 ((combined_entry_type
*) pauxent
->x_csect
.x_scnlen
.p
1993 - obj_raw_syments (abfd
));
1998 /* Print out information about COFF symbol. */
2001 coff_print_symbol (abfd
, filep
, symbol
, how
)
2005 bfd_print_symbol_type how
;
2007 FILE *file
= (FILE *) filep
;
2011 case bfd_print_symbol_name
:
2012 fprintf (file
, "%s", symbol
->name
);
2015 case bfd_print_symbol_more
:
2016 fprintf (file
, "coff %s %s",
2017 coffsymbol (symbol
)->native
? "n" : "g",
2018 coffsymbol (symbol
)->lineno
? "l" : " ");
2021 case bfd_print_symbol_all
:
2022 if (coffsymbol (symbol
)->native
)
2026 combined_entry_type
*combined
= coffsymbol (symbol
)->native
;
2027 combined_entry_type
*root
= obj_raw_syments (abfd
);
2028 struct lineno_cache_entry
*l
= coffsymbol (symbol
)->lineno
;
2030 fprintf (file
, "[%3ld]", (long) (combined
- root
));
2032 if (! combined
->fix_value
)
2033 val
= (bfd_vma
) combined
->u
.syment
.n_value
;
2035 val
= combined
->u
.syment
.n_value
- (unsigned long) root
;
2039 "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x%08lx %s",
2040 combined
->u
.syment
.n_scnum
,
2041 combined
->u
.syment
.n_flags
,
2042 combined
->u
.syment
.n_type
,
2043 combined
->u
.syment
.n_sclass
,
2044 combined
->u
.syment
.n_numaux
,
2045 (unsigned long) val
,
2048 /* Print out the wide, 64 bit, symbol value */
2050 "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x%016llx %s",
2051 combined
->u
.syment
.n_scnum
,
2052 combined
->u
.syment
.n_flags
,
2053 combined
->u
.syment
.n_type
,
2054 combined
->u
.syment
.n_sclass
,
2055 combined
->u
.syment
.n_numaux
,
2060 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
2062 combined_entry_type
*auxp
= combined
+ aux
+ 1;
2066 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.p
- root
;
2068 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.l
;
2070 fprintf (file
, "\n");
2072 if (bfd_coff_print_aux (abfd
, file
, root
, combined
, auxp
, aux
))
2075 switch (combined
->u
.syment
.n_sclass
)
2078 fprintf (file
, "File ");
2082 if (combined
->u
.syment
.n_type
== T_NULL
)
2083 /* probably a section symbol? */
2085 fprintf (file
, "AUX scnlen 0x%lx nreloc %d nlnno %d",
2086 (long) auxp
->u
.auxent
.x_scn
.x_scnlen
,
2087 auxp
->u
.auxent
.x_scn
.x_nreloc
,
2088 auxp
->u
.auxent
.x_scn
.x_nlinno
);
2089 if (auxp
->u
.auxent
.x_scn
.x_checksum
!= 0
2090 || auxp
->u
.auxent
.x_scn
.x_associated
!= 0
2091 || auxp
->u
.auxent
.x_scn
.x_comdat
!= 0)
2092 fprintf (file
, " checksum 0x%lx assoc %d comdat %d",
2093 auxp
->u
.auxent
.x_scn
.x_checksum
,
2094 auxp
->u
.auxent
.x_scn
.x_associated
,
2095 auxp
->u
.auxent
.x_scn
.x_comdat
);
2098 /* else fall through */
2100 if (ISFCN (combined
->u
.syment
.n_type
))
2103 _("AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld"),
2105 auxp
->u
.auxent
.x_sym
.x_misc
.x_fsize
,
2106 auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
,
2109 (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2111 : auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
));
2114 /* else fall through */
2116 fprintf (file
, "AUX lnno %d size 0x%x tagndx %ld",
2117 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
2118 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
,
2121 fprintf (file
, " endndx %ld",
2123 (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2131 fprintf (file
, "\n%s :", l
->u
.sym
->name
);
2133 while (l
->line_number
)
2135 fprintf (file
, "\n%4d : 0x%lx",
2138 (l
->u
.offset
+ symbol
->section
->vma
)));
2145 bfd_print_symbol_vandf ((PTR
) file
, symbol
);
2146 fprintf (file
, " %-5s %s %s %s",
2147 symbol
->section
->name
,
2148 coffsymbol (symbol
)->native
? "n" : "g",
2149 coffsymbol (symbol
)->lineno
? "l" : " ",
2155 /* Return whether a symbol name implies a local symbol. In COFF,
2156 local symbols generally start with ``.L''. Most targets use this
2157 function for the is_local_label_name entry point, but some may
2161 _bfd_coff_is_local_label_name (abfd
, name
)
2162 bfd
*abfd ATTRIBUTE_UNUSED
;
2165 return name
[0] == '.' && name
[1] == 'L';
2168 /* Provided a BFD, a section and an offset (in bytes, not octets) into the
2169 section, calculate and return the name of the source file and the line
2170 nearest to the wanted location. */
2173 coff_find_nearest_line (abfd
, section
, symbols
, offset
, filename_ptr
,
2174 functionname_ptr
, line_ptr
)
2179 CONST
char **filename_ptr
;
2180 CONST
char **functionname_ptr
;
2181 unsigned int *line_ptr
;
2185 unsigned int line_base
;
2186 coff_data_type
*cof
= coff_data (abfd
);
2187 /* Run through the raw syments if available */
2188 combined_entry_type
*p
;
2189 combined_entry_type
*pend
;
2191 struct coff_section_tdata
*sec_data
;
2193 /* Before looking through the symbol table, try to use a .stab
2194 section to find the information. */
2195 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2196 &found
, filename_ptr
,
2197 functionname_ptr
, line_ptr
,
2198 &coff_data(abfd
)->line_info
))
2204 /* Also try examining DWARF2 debugging information. */
2205 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
2206 filename_ptr
, functionname_ptr
,
2208 &coff_data(abfd
)->dwarf2_find_line_info
))
2212 *functionname_ptr
= 0;
2215 /* Don't try and find line numbers in a non coff file */
2216 if (!bfd_family_coff (abfd
))
2222 /* Find the first C_FILE symbol. */
2223 p
= cof
->raw_syments
;
2227 pend
= p
+ cof
->raw_syment_count
;
2230 if (p
->u
.syment
.n_sclass
== C_FILE
)
2232 p
+= 1 + p
->u
.syment
.n_numaux
;
2240 /* Look through the C_FILE symbols to find the best one. */
2241 sec_vma
= bfd_get_section_vma (abfd
, section
);
2242 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2243 maxdiff
= (bfd_vma
) 0 - (bfd_vma
) 1;
2246 combined_entry_type
*p2
;
2248 for (p2
= p
+ 1 + p
->u
.syment
.n_numaux
;
2250 p2
+= 1 + p2
->u
.syment
.n_numaux
)
2252 if (p2
->u
.syment
.n_scnum
> 0
2254 == coff_section_from_bfd_index (abfd
,
2255 p2
->u
.syment
.n_scnum
)))
2257 if (p2
->u
.syment
.n_sclass
== C_FILE
)
2264 /* We use <= MAXDIFF here so that if we get a zero length
2265 file, we actually use the next file entry. */
2267 && offset
+ sec_vma
>= (bfd_vma
) p2
->u
.syment
.n_value
2268 && offset
+ sec_vma
- (bfd_vma
) p2
->u
.syment
.n_value
<= maxdiff
)
2270 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2271 maxdiff
= offset
+ sec_vma
- p2
->u
.syment
.n_value
;
2274 /* Avoid endless loops on erroneous files by ensuring that
2275 we always move forward in the file. */
2276 if (p
- cof
->raw_syments
>= p
->u
.syment
.n_value
)
2279 p
= cof
->raw_syments
+ p
->u
.syment
.n_value
;
2280 if (p
> pend
|| p
->u
.syment
.n_sclass
!= C_FILE
)
2285 /* Now wander though the raw linenumbers of the section */
2286 /* If we have been called on this section before, and the offset we
2287 want is further down then we can prime the lookup loop. */
2288 sec_data
= coff_section_data (abfd
, section
);
2289 if (sec_data
!= NULL
2291 && offset
>= sec_data
->offset
)
2294 *functionname_ptr
= sec_data
->function
;
2295 line_base
= sec_data
->line_base
;
2303 if (section
->lineno
!= NULL
)
2305 bfd_vma last_value
= 0;
2307 l
= §ion
->lineno
[i
];
2309 for (; i
< section
->lineno_count
; i
++)
2311 if (l
->line_number
== 0)
2313 /* Get the symbol this line number points at */
2314 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
2315 if (coff
->symbol
.value
> offset
)
2317 *functionname_ptr
= coff
->symbol
.name
;
2318 last_value
= coff
->symbol
.value
;
2321 combined_entry_type
*s
= coff
->native
;
2322 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2324 /* In XCOFF a debugging symbol can follow the
2326 if (s
->u
.syment
.n_scnum
== N_DEBUG
)
2327 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2329 /* S should now point to the .bf of the function. */
2330 if (s
->u
.syment
.n_numaux
)
2332 /* The linenumber is stored in the auxent. */
2333 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
2334 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
2335 *line_ptr
= line_base
;
2341 if (l
->u
.offset
> offset
)
2343 *line_ptr
= l
->line_number
+ line_base
- 1;
2348 /* If we fell off the end of the loop, then assume that this
2349 symbol has no line number info. Otherwise, symbols with no
2350 line number info get reported with the line number of the
2351 last line of the last symbol which does have line number
2352 info. We use 0x100 as a slop to account for cases where the
2353 last line has executable code. */
2354 if (i
>= section
->lineno_count
2356 && offset
- last_value
> 0x100)
2358 *functionname_ptr
= NULL
;
2363 /* Cache the results for the next call. */
2364 if (sec_data
== NULL
&& section
->owner
== abfd
)
2366 section
->used_by_bfd
=
2367 ((PTR
) bfd_zalloc (abfd
,
2368 sizeof (struct coff_section_tdata
)));
2369 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2371 if (sec_data
!= NULL
)
2373 sec_data
->offset
= offset
;
2375 sec_data
->function
= *functionname_ptr
;
2376 sec_data
->line_base
= line_base
;
2383 coff_sizeof_headers (abfd
, reloc
)
2391 size
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
2395 size
= bfd_coff_filhsz (abfd
);
2398 size
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
2402 /* Change the class of a coff symbol held by BFD. */
2404 bfd_coff_set_symbol_class (abfd
, symbol
, class)
2409 coff_symbol_type
* csym
;
2411 csym
= coff_symbol_from (abfd
, symbol
);
2414 bfd_set_error (bfd_error_invalid_operation
);
2417 else if (csym
->native
== NULL
)
2419 /* This is an alien symbol which no native coff backend data.
2420 We cheat here by creating a fake native entry for it and
2421 then filling in the class. This code is based on that in
2422 coff_write_alien_symbol(). */
2424 combined_entry_type
* native
;
2426 native
= (combined_entry_type
*) bfd_alloc (abfd
, sizeof (* native
));
2430 memset (native
, 0, sizeof (* native
));
2432 native
->u
.syment
.n_type
= T_NULL
;
2433 native
->u
.syment
.n_sclass
= class;
2435 if (bfd_is_und_section (symbol
->section
))
2437 native
->u
.syment
.n_scnum
= N_UNDEF
;
2438 native
->u
.syment
.n_value
= symbol
->value
;
2440 else if (bfd_is_com_section (symbol
->section
))
2442 native
->u
.syment
.n_scnum
= N_UNDEF
;
2443 native
->u
.syment
.n_value
= symbol
->value
;
2447 native
->u
.syment
.n_scnum
=
2448 symbol
->section
->output_section
->target_index
;
2449 native
->u
.syment
.n_value
= (symbol
->value
2450 + symbol
->section
->output_offset
);
2451 if (! obj_pe (abfd
))
2452 native
->u
.syment
.n_value
+= symbol
->section
->output_section
->vma
;
2454 /* Copy the any flags from the the file header into the symbol.
2456 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (& csym
->symbol
)->flags
;
2459 csym
->native
= native
;
2463 csym
->native
->u
.syment
.n_sclass
= class;