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 *, size_t));
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
;
85 boolean result
= true;
90 /* Handle long section names as in PE. */
91 if (bfd_coff_long_section_names (abfd
)
92 && hdr
->s_name
[0] == '/')
99 memcpy (buf
, hdr
->s_name
+ 1, SCNNMLEN
- 1);
100 buf
[SCNNMLEN
- 1] = '\0';
101 strindex
= strtol (buf
, &p
, 10);
102 if (*p
== '\0' && strindex
>= 0)
104 strings
= _bfd_coff_read_string_table (abfd
);
107 /* FIXME: For extra safety, we should make sure that
108 strindex does not run us past the end, but right now we
109 don't know the length of the string table. */
111 name
= bfd_alloc (abfd
, (bfd_size_type
) strlen (strings
) + 1);
114 strcpy (name
, strings
);
120 /* Assorted wastage to null-terminate the name, thanks AT&T! */
121 name
= bfd_alloc (abfd
, (bfd_size_type
) sizeof (hdr
->s_name
) + 1);
124 strncpy (name
, (char *) &hdr
->s_name
[0], sizeof (hdr
->s_name
));
125 name
[sizeof (hdr
->s_name
)] = 0;
128 return_section
= bfd_make_section_anyway (abfd
, name
);
129 if (return_section
== NULL
)
132 return_section
->vma
= hdr
->s_vaddr
;
133 return_section
->lma
= hdr
->s_paddr
;
134 return_section
->_raw_size
= hdr
->s_size
;
135 return_section
->filepos
= hdr
->s_scnptr
;
136 return_section
->rel_filepos
= hdr
->s_relptr
;
137 return_section
->reloc_count
= hdr
->s_nreloc
;
139 bfd_coff_set_alignment_hook (abfd
, return_section
, hdr
);
141 return_section
->line_filepos
= hdr
->s_lnnoptr
;
143 return_section
->lineno_count
= hdr
->s_nlnno
;
144 return_section
->userdata
= NULL
;
145 return_section
->next
= (asection
*) NULL
;
146 return_section
->target_index
= target_index
;
148 if (! bfd_coff_styp_to_sec_flags_hook (abfd
, hdr
, name
, return_section
,
152 return_section
->flags
= flags
;
154 /* At least on i386-coff, the line number count for a shared library
155 section must be ignored. */
156 if ((return_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
157 return_section
->lineno_count
= 0;
159 if (hdr
->s_nreloc
!= 0)
160 return_section
->flags
|= SEC_RELOC
;
161 /* FIXME: should this check 'hdr->s_size > 0' */
162 if (hdr
->s_scnptr
!= 0)
163 return_section
->flags
|= SEC_HAS_CONTENTS
;
168 /* Read in a COFF object and make it into a BFD. This is used by
171 static const bfd_target
*
172 coff_real_object_p (abfd
, nscns
, internal_f
, internal_a
)
175 struct internal_filehdr
*internal_f
;
176 struct internal_aouthdr
*internal_a
;
178 flagword oflags
= abfd
->flags
;
179 bfd_vma ostart
= bfd_get_start_address (abfd
);
181 bfd_size_type readsize
; /* length of file_info */
183 char *external_sections
;
185 if (!(internal_f
->f_flags
& F_RELFLG
))
186 abfd
->flags
|= HAS_RELOC
;
187 if ((internal_f
->f_flags
& F_EXEC
))
188 abfd
->flags
|= EXEC_P
;
189 if (!(internal_f
->f_flags
& F_LNNO
))
190 abfd
->flags
|= HAS_LINENO
;
191 if (!(internal_f
->f_flags
& F_LSYMS
))
192 abfd
->flags
|= HAS_LOCALS
;
194 /* FIXME: How can we set D_PAGED correctly? */
195 if ((internal_f
->f_flags
& F_EXEC
) != 0)
196 abfd
->flags
|= D_PAGED
;
198 bfd_get_symcount (abfd
) = internal_f
->f_nsyms
;
199 if (internal_f
->f_nsyms
)
200 abfd
->flags
|= HAS_SYMS
;
202 if (internal_a
!= (struct internal_aouthdr
*) NULL
)
203 bfd_get_start_address (abfd
) = internal_a
->entry
;
205 bfd_get_start_address (abfd
) = 0;
207 /* Set up the tdata area. ECOFF uses its own routine, and overrides
209 tdata
= bfd_coff_mkobject_hook (abfd
, (PTR
) internal_f
, (PTR
) internal_a
);
213 scnhsz
= bfd_coff_scnhsz (abfd
);
214 readsize
= (bfd_size_type
) nscns
* scnhsz
;
215 external_sections
= (char *) bfd_alloc (abfd
, readsize
);
216 if (!external_sections
)
219 if (bfd_bread ((PTR
) external_sections
, readsize
, abfd
) != readsize
)
222 /* Set the arch/mach *before* swapping in sections; section header swapping
223 may depend on arch/mach info. */
224 if (bfd_coff_set_arch_mach_hook (abfd
, (PTR
) internal_f
) == false)
227 /* Now copy data as required; construct all asections etc */
231 for (i
= 0; i
< nscns
; i
++)
233 struct internal_scnhdr tmp
;
234 bfd_coff_swap_scnhdr_in (abfd
,
235 (PTR
) (external_sections
+ i
* scnhsz
),
237 if (! make_a_section_from_file (abfd
, &tmp
, i
+ 1))
242 /* make_abs_section (abfd); */
247 bfd_release (abfd
, tdata
);
248 abfd
->flags
= oflags
;
249 bfd_get_start_address (abfd
) = ostart
;
250 return (const bfd_target
*) NULL
;
253 /* Turn a COFF file into a BFD, but fail with bfd_error_wrong_format if it is
254 not a COFF file. This is also used by ECOFF. */
260 bfd_size_type filhsz
;
261 bfd_size_type aoutsz
;
264 struct internal_filehdr internal_f
;
265 struct internal_aouthdr internal_a
;
267 /* figure out how much to read */
268 filhsz
= bfd_coff_filhsz (abfd
);
269 aoutsz
= bfd_coff_aoutsz (abfd
);
271 filehdr
= bfd_alloc (abfd
, filhsz
);
274 if (bfd_bread (filehdr
, filhsz
, abfd
) != filhsz
)
276 if (bfd_get_error () != bfd_error_system_call
)
277 bfd_set_error (bfd_error_wrong_format
);
280 bfd_coff_swap_filehdr_in (abfd
, filehdr
, &internal_f
);
281 bfd_release (abfd
, filehdr
);
283 if (bfd_coff_bad_format_hook (abfd
, &internal_f
) == false)
285 bfd_set_error (bfd_error_wrong_format
);
288 nscns
= internal_f
.f_nscns
;
290 if (internal_f
.f_opthdr
)
294 opthdr
= bfd_alloc (abfd
, aoutsz
);
297 if (bfd_bread (opthdr
, (bfd_size_type
) internal_f
.f_opthdr
, abfd
)
298 != internal_f
.f_opthdr
)
302 bfd_coff_swap_aouthdr_in (abfd
, opthdr
, (PTR
) &internal_a
);
305 return coff_real_object_p (abfd
, nscns
, &internal_f
,
306 (internal_f
.f_opthdr
!= 0
308 : (struct internal_aouthdr
*) NULL
));
311 /* Get the BFD section from a COFF symbol section number. */
314 coff_section_from_bfd_index (abfd
, index
)
318 struct sec
*answer
= abfd
->sections
;
321 return bfd_abs_section_ptr
;
322 if (index
== N_UNDEF
)
323 return bfd_und_section_ptr
;
324 if (index
== N_DEBUG
)
325 return bfd_abs_section_ptr
;
329 if (answer
->target_index
== index
)
331 answer
= answer
->next
;
334 /* We should not reach this point, but the SCO 3.2v4 /lib/libc_s.a
335 has a bad symbol table in biglitpow.o. */
336 return bfd_und_section_ptr
;
339 /* Get the upper bound of a COFF symbol table. */
342 coff_get_symtab_upper_bound (abfd
)
345 if (!bfd_coff_slurp_symbol_table (abfd
))
348 return (bfd_get_symcount (abfd
) + 1) * (sizeof (coff_symbol_type
*));
351 /* Canonicalize a COFF symbol table. */
354 coff_get_symtab (abfd
, alocation
)
358 unsigned int counter
;
359 coff_symbol_type
*symbase
;
360 coff_symbol_type
**location
= (coff_symbol_type
**) alocation
;
362 if (!bfd_coff_slurp_symbol_table (abfd
))
365 symbase
= obj_symbols (abfd
);
366 counter
= bfd_get_symcount (abfd
);
367 while (counter
-- > 0)
368 *location
++ = symbase
++;
372 return bfd_get_symcount (abfd
);
375 /* Get the name of a symbol. The caller must pass in a buffer of size
379 _bfd_coff_internal_syment_name (abfd
, sym
, buf
)
381 const struct internal_syment
*sym
;
384 /* FIXME: It's not clear this will work correctly if sizeof
386 if (sym
->_n
._n_n
._n_zeroes
!= 0
387 || sym
->_n
._n_n
._n_offset
== 0)
389 memcpy (buf
, sym
->_n
._n_name
, SYMNMLEN
);
390 buf
[SYMNMLEN
] = '\0';
397 BFD_ASSERT (sym
->_n
._n_n
._n_offset
>= STRING_SIZE_SIZE
);
398 strings
= obj_coff_strings (abfd
);
401 strings
= _bfd_coff_read_string_table (abfd
);
405 return strings
+ sym
->_n
._n_n
._n_offset
;
409 /* Read in and swap the relocs. This returns a buffer holding the
410 relocs for section SEC in file ABFD. If CACHE is true and
411 INTERNAL_RELOCS is NULL, the relocs read in will be saved in case
412 the function is called again. If EXTERNAL_RELOCS is not NULL, it
413 is a buffer large enough to hold the unswapped relocs. If
414 INTERNAL_RELOCS is not NULL, it is a buffer large enough to hold
415 the swapped relocs. If REQUIRE_INTERNAL is true, then the return
416 value must be INTERNAL_RELOCS. The function returns NULL on error. */
418 struct internal_reloc
*
419 _bfd_coff_read_internal_relocs (abfd
, sec
, cache
, external_relocs
,
420 require_internal
, internal_relocs
)
424 bfd_byte
*external_relocs
;
425 boolean require_internal
;
426 struct internal_reloc
*internal_relocs
;
429 bfd_byte
*free_external
= NULL
;
430 struct internal_reloc
*free_internal
= NULL
;
433 struct internal_reloc
*irel
;
436 if (coff_section_data (abfd
, sec
) != NULL
437 && coff_section_data (abfd
, sec
)->relocs
!= NULL
)
439 if (! require_internal
)
440 return coff_section_data (abfd
, sec
)->relocs
;
441 memcpy (internal_relocs
, coff_section_data (abfd
, sec
)->relocs
,
442 sec
->reloc_count
* sizeof (struct internal_reloc
));
443 return internal_relocs
;
446 relsz
= bfd_coff_relsz (abfd
);
448 amt
= sec
->reloc_count
* relsz
;
449 if (external_relocs
== NULL
)
451 free_external
= (bfd_byte
*) bfd_malloc (amt
);
452 if (free_external
== NULL
&& sec
->reloc_count
> 0)
454 external_relocs
= free_external
;
457 if (bfd_seek (abfd
, sec
->rel_filepos
, SEEK_SET
) != 0
458 || bfd_bread (external_relocs
, amt
, abfd
) != amt
)
461 if (internal_relocs
== NULL
)
463 amt
= sec
->reloc_count
;
464 amt
*= sizeof (struct internal_reloc
);
465 free_internal
= (struct internal_reloc
*) bfd_malloc (amt
);
466 if (free_internal
== NULL
&& sec
->reloc_count
> 0)
468 internal_relocs
= free_internal
;
471 /* Swap in the relocs. */
472 erel
= external_relocs
;
473 erel_end
= erel
+ relsz
* sec
->reloc_count
;
474 irel
= internal_relocs
;
475 for (; erel
< erel_end
; erel
+= relsz
, irel
++)
476 bfd_coff_swap_reloc_in (abfd
, (PTR
) erel
, (PTR
) irel
);
478 if (free_external
!= NULL
)
480 free (free_external
);
481 free_external
= NULL
;
484 if (cache
&& free_internal
!= NULL
)
486 if (coff_section_data (abfd
, sec
) == NULL
)
488 amt
= sizeof (struct coff_section_tdata
);
489 sec
->used_by_bfd
= (PTR
) bfd_zalloc (abfd
, amt
);
490 if (sec
->used_by_bfd
== NULL
)
492 coff_section_data (abfd
, sec
)->contents
= NULL
;
494 coff_section_data (abfd
, sec
)->relocs
= free_internal
;
497 return internal_relocs
;
500 if (free_external
!= NULL
)
501 free (free_external
);
502 if (free_internal
!= NULL
)
503 free (free_internal
);
507 /* Set lineno_count for the output sections of a COFF file. */
510 coff_count_linenumbers (abfd
)
513 unsigned int limit
= bfd_get_symcount (abfd
);
521 /* This may be from the backend linker, in which case the
522 lineno_count in the sections is correct. */
523 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
524 total
+= s
->lineno_count
;
528 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
529 BFD_ASSERT (s
->lineno_count
== 0);
531 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
533 asymbol
*q_maybe
= *p
;
535 if (bfd_family_coff (bfd_asymbol_bfd (q_maybe
)))
537 coff_symbol_type
*q
= coffsymbol (q_maybe
);
539 /* The AIX 4.1 compiler can sometimes generate line numbers
540 attached to debugging symbols. We try to simply ignore
542 if (q
->lineno
!= NULL
543 && q
->symbol
.section
->owner
!= NULL
)
545 /* This symbol has line numbers. Increment the owning
546 section's linenumber count. */
547 alent
*l
= q
->lineno
;
549 ++q
->symbol
.section
->output_section
->lineno_count
;
552 while (l
->line_number
!= 0)
555 ++q
->symbol
.section
->output_section
->lineno_count
;
565 /* Takes a bfd and a symbol, returns a pointer to the coff specific
566 area of the symbol if there is one. */
569 coff_symbol_from (ignore_abfd
, symbol
)
570 bfd
*ignore_abfd ATTRIBUTE_UNUSED
;
573 if (!bfd_family_coff (bfd_asymbol_bfd (symbol
)))
574 return (coff_symbol_type
*) NULL
;
576 if (bfd_asymbol_bfd (symbol
)->tdata
.coff_obj_data
== (coff_data_type
*) NULL
)
577 return (coff_symbol_type
*) NULL
;
579 return (coff_symbol_type
*) symbol
;
583 fixup_symbol_value (abfd
, coff_symbol_ptr
, syment
)
585 coff_symbol_type
*coff_symbol_ptr
;
586 struct internal_syment
*syment
;
589 /* Normalize the symbol flags */
590 if (bfd_is_com_section (coff_symbol_ptr
->symbol
.section
))
592 /* a common symbol is undefined with a value */
593 syment
->n_scnum
= N_UNDEF
;
594 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
596 else if ((coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
) != 0
597 && (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING_RELOC
) == 0)
599 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
601 else if (bfd_is_und_section (coff_symbol_ptr
->symbol
.section
))
603 syment
->n_scnum
= N_UNDEF
;
606 /* FIXME: Do we need to handle the absolute section here? */
609 if (coff_symbol_ptr
->symbol
.section
)
612 coff_symbol_ptr
->symbol
.section
->output_section
->target_index
;
614 syment
->n_value
= (coff_symbol_ptr
->symbol
.value
615 + coff_symbol_ptr
->symbol
.section
->output_offset
);
618 syment
->n_value
+= (syment
->n_sclass
== C_STATLAB
)
619 ? coff_symbol_ptr
->symbol
.section
->output_section
->lma
620 : coff_symbol_ptr
->symbol
.section
->output_section
->vma
;
626 /* This can happen, but I don't know why yet (steve@cygnus.com) */
627 syment
->n_scnum
= N_ABS
;
628 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
633 /* Run through all the symbols in the symbol table and work out what
634 their indexes into the symbol table will be when output.
636 Coff requires that each C_FILE symbol points to the next one in the
637 chain, and that the last one points to the first external symbol. We
641 coff_renumber_symbols (bfd_ptr
, first_undef
)
645 unsigned int symbol_count
= bfd_get_symcount (bfd_ptr
);
646 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
647 unsigned int native_index
= 0;
648 struct internal_syment
*last_file
= (struct internal_syment
*) NULL
;
649 unsigned int symbol_index
;
651 /* COFF demands that undefined symbols come after all other symbols.
652 Since we don't need to impose this extra knowledge on all our
653 client programs, deal with that here. Sort the symbol table;
654 just move the undefined symbols to the end, leaving the rest
655 alone. The O'Reilly book says that defined global symbols come
656 at the end before the undefined symbols, so we do that here as
658 /* @@ Do we have some condition we could test for, so we don't always
659 have to do this? I don't think relocatability is quite right, but
660 I'm not certain. [raeburn:19920508.1711EST] */
666 amt
= sizeof (asymbol
*) * ((bfd_size_type
) symbol_count
+ 1);
667 newsyms
= (asymbol
**) bfd_alloc (bfd_ptr
, amt
);
670 bfd_ptr
->outsymbols
= newsyms
;
671 for (i
= 0; i
< symbol_count
; i
++)
672 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) != 0
673 || (!bfd_is_und_section (symbol_ptr_ptr
[i
]->section
)
674 && !bfd_is_com_section (symbol_ptr_ptr
[i
]->section
)
675 && ((symbol_ptr_ptr
[i
]->flags
& BSF_FUNCTION
) != 0
676 || ((symbol_ptr_ptr
[i
]->flags
& (BSF_GLOBAL
| BSF_WEAK
))
678 *newsyms
++ = symbol_ptr_ptr
[i
];
680 for (i
= 0; i
< symbol_count
; i
++)
681 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) == 0
682 && !bfd_is_und_section (symbol_ptr_ptr
[i
]->section
)
683 && (bfd_is_com_section (symbol_ptr_ptr
[i
]->section
)
684 || ((symbol_ptr_ptr
[i
]->flags
& BSF_FUNCTION
) == 0
685 && ((symbol_ptr_ptr
[i
]->flags
& (BSF_GLOBAL
| BSF_WEAK
))
687 *newsyms
++ = symbol_ptr_ptr
[i
];
689 *first_undef
= newsyms
- bfd_ptr
->outsymbols
;
691 for (i
= 0; i
< symbol_count
; i
++)
692 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) == 0
693 && bfd_is_und_section (symbol_ptr_ptr
[i
]->section
))
694 *newsyms
++ = symbol_ptr_ptr
[i
];
695 *newsyms
= (asymbol
*) NULL
;
696 symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
699 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
701 coff_symbol_type
*coff_symbol_ptr
= coff_symbol_from (bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
702 symbol_ptr_ptr
[symbol_index
]->udata
.i
= symbol_index
;
703 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
)
705 combined_entry_type
*s
= coff_symbol_ptr
->native
;
708 if (s
->u
.syment
.n_sclass
== C_FILE
)
710 if (last_file
!= (struct internal_syment
*) NULL
)
711 last_file
->n_value
= native_index
;
712 last_file
= &(s
->u
.syment
);
717 /* Modify the symbol values according to their section and
720 fixup_symbol_value (bfd_ptr
, coff_symbol_ptr
, &(s
->u
.syment
));
722 for (i
= 0; i
< s
->u
.syment
.n_numaux
+ 1; i
++)
723 s
[i
].offset
= native_index
++;
730 obj_conv_table_size (bfd_ptr
) = native_index
;
735 /* Run thorough the symbol table again, and fix it so that all
736 pointers to entries are changed to the entries' index in the output
740 coff_mangle_symbols (bfd_ptr
)
743 unsigned int symbol_count
= bfd_get_symcount (bfd_ptr
);
744 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
745 unsigned int symbol_index
;
747 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
749 coff_symbol_type
*coff_symbol_ptr
=
750 coff_symbol_from (bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
752 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
)
755 combined_entry_type
*s
= coff_symbol_ptr
->native
;
759 /* FIXME: We should use a union here. */
760 s
->u
.syment
.n_value
=
761 (bfd_vma
)((combined_entry_type
*)
762 ((unsigned long) s
->u
.syment
.n_value
))->offset
;
767 /* The value is the offset into the line number entries
768 for the symbol's section. On output, the symbol's
769 section should be N_DEBUG. */
770 s
->u
.syment
.n_value
=
771 (coff_symbol_ptr
->symbol
.section
->output_section
->line_filepos
772 + s
->u
.syment
.n_value
* bfd_coff_linesz (bfd_ptr
));
773 coff_symbol_ptr
->symbol
.section
=
774 coff_section_from_bfd_index (bfd_ptr
, N_DEBUG
);
775 BFD_ASSERT (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
);
777 for (i
= 0; i
< s
->u
.syment
.n_numaux
; i
++)
779 combined_entry_type
*a
= s
+ i
+ 1;
782 a
->u
.auxent
.x_sym
.x_tagndx
.l
=
783 a
->u
.auxent
.x_sym
.x_tagndx
.p
->offset
;
788 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
789 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
->offset
;
794 a
->u
.auxent
.x_csect
.x_scnlen
.l
=
795 a
->u
.auxent
.x_csect
.x_scnlen
.p
->offset
;
804 coff_fix_symbol_name (abfd
, symbol
, native
, string_size_p
,
805 debug_string_section_p
, debug_string_size_p
)
808 combined_entry_type
*native
;
809 bfd_size_type
*string_size_p
;
810 asection
**debug_string_section_p
;
811 bfd_size_type
*debug_string_size_p
;
813 unsigned int name_length
;
814 union internal_auxent
*auxent
;
815 char *name
= (char *) (symbol
->name
);
817 if (name
== (char *) NULL
)
819 /* coff symbols always have names, so we'll make one up */
820 symbol
->name
= "strange";
821 name
= (char *) symbol
->name
;
823 name_length
= strlen (name
);
825 if (native
->u
.syment
.n_sclass
== C_FILE
826 && native
->u
.syment
.n_numaux
> 0)
828 unsigned int filnmlen
;
830 if (bfd_coff_force_symnames_in_strings (abfd
))
832 native
->u
.syment
._n
._n_n
._n_offset
=
833 (*string_size_p
+ STRING_SIZE_SIZE
);
834 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
835 *string_size_p
+= 6; /* strlen(".file") + 1 */
838 strncpy (native
->u
.syment
._n
._n_name
, ".file", SYMNMLEN
);
840 auxent
= &(native
+ 1)->u
.auxent
;
842 filnmlen
= bfd_coff_filnmlen (abfd
);
844 if (bfd_coff_long_filenames (abfd
))
846 if (name_length
<= filnmlen
)
848 strncpy (auxent
->x_file
.x_fname
, name
, filnmlen
);
852 auxent
->x_file
.x_n
.x_offset
= *string_size_p
+ STRING_SIZE_SIZE
;
853 auxent
->x_file
.x_n
.x_zeroes
= 0;
854 *string_size_p
+= name_length
+ 1;
859 strncpy (auxent
->x_file
.x_fname
, name
, filnmlen
);
860 if (name_length
> filnmlen
)
861 name
[filnmlen
] = '\0';
866 if (name_length
<= SYMNMLEN
&& !bfd_coff_force_symnames_in_strings (abfd
))
868 /* This name will fit into the symbol neatly */
869 strncpy (native
->u
.syment
._n
._n_name
, symbol
->name
, SYMNMLEN
);
871 else if (!bfd_coff_symname_in_debug (abfd
, &native
->u
.syment
))
873 native
->u
.syment
._n
._n_n
._n_offset
= (*string_size_p
875 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
876 *string_size_p
+= name_length
+ 1;
882 int prefix_len
= bfd_coff_debug_string_prefix_length (abfd
);
884 /* This name should be written into the .debug section. For
885 some reason each name is preceded by a two byte length
886 and also followed by a null byte. FIXME: We assume that
887 the .debug section has already been created, and that it
889 if (*debug_string_section_p
== (asection
*) NULL
)
890 *debug_string_section_p
= bfd_get_section_by_name (abfd
, ".debug");
891 filepos
= bfd_tell (abfd
);
893 bfd_put_32 (abfd
, (bfd_vma
) (name_length
+ 1), buf
);
895 bfd_put_16 (abfd
, (bfd_vma
) (name_length
+ 1), buf
);
897 if (!bfd_set_section_contents (abfd
,
898 *debug_string_section_p
,
900 (file_ptr
) *debug_string_size_p
,
901 (bfd_size_type
) prefix_len
)
902 || !bfd_set_section_contents (abfd
,
903 *debug_string_section_p
,
905 (file_ptr
) (*debug_string_size_p
907 (bfd_size_type
) name_length
+ 1))
909 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
911 native
->u
.syment
._n
._n_n
._n_offset
=
912 *debug_string_size_p
+ prefix_len
;
913 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
914 *debug_string_size_p
+= name_length
+ 1 + prefix_len
;
919 /* We need to keep track of the symbol index so that when we write out
920 the relocs we can get the index for a symbol. This method is a
923 #define set_index(symbol, idx) ((symbol)->udata.i = (idx))
925 /* Write a symbol out to a COFF file. */
928 coff_write_symbol (abfd
, symbol
, native
, written
, string_size_p
,
929 debug_string_section_p
, debug_string_size_p
)
932 combined_entry_type
*native
;
934 bfd_size_type
*string_size_p
;
935 asection
**debug_string_section_p
;
936 bfd_size_type
*debug_string_size_p
;
938 unsigned int numaux
= native
->u
.syment
.n_numaux
;
939 int type
= native
->u
.syment
.n_type
;
940 int class = native
->u
.syment
.n_sclass
;
942 bfd_size_type symesz
;
944 if (native
->u
.syment
.n_sclass
== C_FILE
)
945 symbol
->flags
|= BSF_DEBUGGING
;
947 if (symbol
->flags
& BSF_DEBUGGING
948 && bfd_is_abs_section (symbol
->section
))
950 native
->u
.syment
.n_scnum
= N_DEBUG
;
952 else if (bfd_is_abs_section (symbol
->section
))
954 native
->u
.syment
.n_scnum
= N_ABS
;
956 else if (bfd_is_und_section (symbol
->section
))
958 native
->u
.syment
.n_scnum
= N_UNDEF
;
962 native
->u
.syment
.n_scnum
=
963 symbol
->section
->output_section
->target_index
;
966 coff_fix_symbol_name (abfd
, symbol
, native
, string_size_p
,
967 debug_string_section_p
, debug_string_size_p
);
969 symesz
= bfd_coff_symesz (abfd
);
970 buf
= bfd_alloc (abfd
, symesz
);
973 bfd_coff_swap_sym_out (abfd
, &native
->u
.syment
, buf
);
974 if (bfd_bwrite (buf
, symesz
, abfd
) != symesz
)
976 bfd_release (abfd
, buf
);
978 if (native
->u
.syment
.n_numaux
> 0)
980 bfd_size_type auxesz
;
983 auxesz
= bfd_coff_auxesz (abfd
);
984 buf
= bfd_alloc (abfd
, auxesz
);
987 for (j
= 0; j
< native
->u
.syment
.n_numaux
; j
++)
989 bfd_coff_swap_aux_out (abfd
,
990 &((native
+ j
+ 1)->u
.auxent
),
994 native
->u
.syment
.n_numaux
,
996 if (bfd_bwrite (buf
, auxesz
, abfd
) != auxesz
)
999 bfd_release (abfd
, buf
);
1002 /* Store the index for use when we write out the relocs. */
1003 set_index (symbol
, *written
);
1005 *written
+= numaux
+ 1;
1009 /* Write out a symbol to a COFF file that does not come from a COFF
1010 file originally. This symbol may have been created by the linker,
1011 or we may be linking a non COFF file to a COFF file. */
1014 coff_write_alien_symbol (abfd
, symbol
, written
, string_size_p
,
1015 debug_string_section_p
, debug_string_size_p
)
1019 bfd_size_type
*string_size_p
;
1020 asection
**debug_string_section_p
;
1021 bfd_size_type
*debug_string_size_p
;
1023 combined_entry_type
*native
;
1024 combined_entry_type dummy
;
1027 native
->u
.syment
.n_type
= T_NULL
;
1028 native
->u
.syment
.n_flags
= 0;
1029 if (bfd_is_und_section (symbol
->section
))
1031 native
->u
.syment
.n_scnum
= N_UNDEF
;
1032 native
->u
.syment
.n_value
= symbol
->value
;
1034 else if (bfd_is_com_section (symbol
->section
))
1036 native
->u
.syment
.n_scnum
= N_UNDEF
;
1037 native
->u
.syment
.n_value
= symbol
->value
;
1039 else if (symbol
->flags
& BSF_DEBUGGING
)
1041 /* There isn't much point to writing out a debugging symbol
1042 unless we are prepared to convert it into COFF debugging
1043 format. So, we just ignore them. We must clobber the symbol
1044 name to keep it from being put in the string table. */
1050 native
->u
.syment
.n_scnum
=
1051 symbol
->section
->output_section
->target_index
;
1052 native
->u
.syment
.n_value
= (symbol
->value
1053 + symbol
->section
->output_offset
);
1054 if (! obj_pe (abfd
))
1055 native
->u
.syment
.n_value
+= symbol
->section
->output_section
->vma
;
1057 /* Copy the any flags from the the file header into the symbol.
1060 coff_symbol_type
*c
= coff_symbol_from (abfd
, symbol
);
1061 if (c
!= (coff_symbol_type
*) NULL
)
1062 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (&c
->symbol
)->flags
;
1066 native
->u
.syment
.n_type
= 0;
1067 if (symbol
->flags
& BSF_LOCAL
)
1068 native
->u
.syment
.n_sclass
= C_STAT
;
1069 else if (symbol
->flags
& BSF_WEAK
)
1070 native
->u
.syment
.n_sclass
= obj_pe (abfd
) ? C_NT_WEAK
: C_WEAKEXT
;
1072 native
->u
.syment
.n_sclass
= C_EXT
;
1073 native
->u
.syment
.n_numaux
= 0;
1075 return coff_write_symbol (abfd
, symbol
, native
, written
, string_size_p
,
1076 debug_string_section_p
, debug_string_size_p
);
1079 /* Write a native symbol to a COFF file. */
1082 coff_write_native_symbol (abfd
, symbol
, written
, string_size_p
,
1083 debug_string_section_p
, debug_string_size_p
)
1085 coff_symbol_type
*symbol
;
1087 bfd_size_type
*string_size_p
;
1088 asection
**debug_string_section_p
;
1089 bfd_size_type
*debug_string_size_p
;
1091 combined_entry_type
*native
= symbol
->native
;
1092 alent
*lineno
= symbol
->lineno
;
1094 /* If this symbol has an associated line number, we must store the
1095 symbol index in the line number field. We also tag the auxent to
1096 point to the right place in the lineno table. */
1097 if (lineno
&& !symbol
->done_lineno
&& symbol
->symbol
.section
->owner
!= NULL
)
1099 unsigned int count
= 0;
1100 lineno
[count
].u
.offset
= *written
;
1101 if (native
->u
.syment
.n_numaux
)
1103 union internal_auxent
*a
= &((native
+ 1)->u
.auxent
);
1105 a
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1106 symbol
->symbol
.section
->output_section
->moving_line_filepos
;
1109 /* Count and relocate all other linenumbers. */
1111 while (lineno
[count
].line_number
!= 0)
1115 I've been told this, but still need proof:
1116 > The second bug is also in `bfd/coffcode.h'. This bug
1117 > causes the linker to screw up the pc-relocations for
1118 > all the line numbers in COFF code. This bug isn't only
1119 > specific to A29K implementations, but affects all
1120 > systems using COFF format binaries. Note that in COFF
1121 > object files, the line number core offsets output by
1122 > the assembler are relative to the start of each
1123 > procedure, not to the start of the .text section. This
1124 > patch relocates the line numbers relative to the
1125 > `native->u.syment.n_value' instead of the section
1127 > modular!olson@cs.arizona.edu (Jon Olson)
1129 lineno
[count
].u
.offset
+= native
->u
.syment
.n_value
;
1131 lineno
[count
].u
.offset
+=
1132 (symbol
->symbol
.section
->output_section
->vma
1133 + symbol
->symbol
.section
->output_offset
);
1137 symbol
->done_lineno
= true;
1139 symbol
->symbol
.section
->output_section
->moving_line_filepos
+=
1140 count
* bfd_coff_linesz (abfd
);
1143 return coff_write_symbol (abfd
, &(symbol
->symbol
), native
, written
,
1144 string_size_p
, debug_string_section_p
,
1145 debug_string_size_p
);
1148 /* Write out the COFF symbols. */
1151 coff_write_symbols (abfd
)
1154 bfd_size_type string_size
;
1155 asection
*debug_string_section
;
1156 bfd_size_type debug_string_size
;
1158 unsigned int limit
= bfd_get_symcount (abfd
);
1159 bfd_signed_vma written
= 0;
1163 debug_string_section
= NULL
;
1164 debug_string_size
= 0;
1166 /* If this target supports long section names, they must be put into
1167 the string table. This is supported by PE. This code must
1168 handle section names just as they are handled in
1169 coff_write_object_contents. */
1170 if (bfd_coff_long_section_names (abfd
))
1174 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1178 len
= strlen (o
->name
);
1180 string_size
+= len
+ 1;
1184 /* Seek to the right place */
1185 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
1188 /* Output all the symbols we have */
1191 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1193 asymbol
*symbol
= *p
;
1194 coff_symbol_type
*c_symbol
= coff_symbol_from (abfd
, symbol
);
1196 if (c_symbol
== (coff_symbol_type
*) NULL
1197 || c_symbol
->native
== (combined_entry_type
*) NULL
)
1199 if (!coff_write_alien_symbol (abfd
, symbol
, &written
, &string_size
,
1200 &debug_string_section
,
1201 &debug_string_size
))
1206 if (!coff_write_native_symbol (abfd
, c_symbol
, &written
,
1207 &string_size
, &debug_string_section
,
1208 &debug_string_size
))
1213 obj_raw_syment_count (abfd
) = written
;
1215 /* Now write out strings */
1217 if (string_size
!= 0)
1219 unsigned int size
= string_size
+ STRING_SIZE_SIZE
;
1220 bfd_byte buffer
[STRING_SIZE_SIZE
];
1222 #if STRING_SIZE_SIZE == 4
1223 H_PUT_32 (abfd
, size
, buffer
);
1225 #error Change H_PUT_32
1227 if (bfd_bwrite ((PTR
) buffer
, (bfd_size_type
) sizeof (buffer
), abfd
)
1231 /* Handle long section names. This code must handle section
1232 names just as they are handled in coff_write_object_contents. */
1233 if (bfd_coff_long_section_names (abfd
))
1237 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1241 len
= strlen (o
->name
);
1244 if (bfd_bwrite (o
->name
, (bfd_size_type
) (len
+ 1), abfd
)
1251 for (p
= abfd
->outsymbols
, i
= 0;
1256 size_t name_length
= strlen (q
->name
);
1257 coff_symbol_type
*c_symbol
= coff_symbol_from (abfd
, q
);
1260 /* Figure out whether the symbol name should go in the string
1261 table. Symbol names that are short enough are stored
1262 directly in the syment structure. File names permit a
1263 different, longer, length in the syment structure. On
1264 XCOFF, some symbol names are stored in the .debug section
1265 rather than in the string table. */
1267 if (c_symbol
== NULL
1268 || c_symbol
->native
== NULL
)
1270 /* This is not a COFF symbol, so it certainly is not a
1271 file name, nor does it go in the .debug section. */
1272 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1274 else if (bfd_coff_symname_in_debug (abfd
,
1275 &c_symbol
->native
->u
.syment
))
1277 /* This symbol name is in the XCOFF .debug section.
1278 Don't write it into the string table. */
1279 maxlen
= name_length
;
1281 else if (c_symbol
->native
->u
.syment
.n_sclass
== C_FILE
1282 && c_symbol
->native
->u
.syment
.n_numaux
> 0)
1284 if (bfd_coff_force_symnames_in_strings (abfd
))
1286 if (bfd_bwrite (".file", (bfd_size_type
) 6, abfd
) != 6)
1289 maxlen
= bfd_coff_filnmlen (abfd
);
1292 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1294 if (name_length
> maxlen
)
1296 if (bfd_bwrite ((PTR
) (q
->name
), (bfd_size_type
) name_length
+ 1,
1297 abfd
) != name_length
+ 1)
1304 /* We would normally not write anything here, but we'll write
1305 out 4 so that any stupid coff reader which tries to read the
1306 string table even when there isn't one won't croak. */
1307 unsigned int size
= STRING_SIZE_SIZE
;
1308 bfd_byte buffer
[STRING_SIZE_SIZE
];
1310 #if STRING_SIZE_SIZE == 4
1311 H_PUT_32 (abfd
, size
, buffer
);
1313 #error Change H_PUT_32
1315 if (bfd_bwrite ((PTR
) buffer
, (bfd_size_type
) STRING_SIZE_SIZE
, abfd
)
1316 != STRING_SIZE_SIZE
)
1320 /* Make sure the .debug section was created to be the correct size.
1321 We should create it ourselves on the fly, but we don't because
1322 BFD won't let us write to any section until we know how large all
1323 the sections are. We could still do it by making another pass
1324 over the symbols. FIXME. */
1325 BFD_ASSERT (debug_string_size
== 0
1326 || (debug_string_section
!= (asection
*) NULL
1327 && (BFD_ALIGN (debug_string_size
,
1328 1 << debug_string_section
->alignment_power
)
1329 == bfd_section_size (abfd
, debug_string_section
))));
1335 coff_write_linenumbers (abfd
)
1339 bfd_size_type linesz
;
1342 linesz
= bfd_coff_linesz (abfd
);
1343 buff
= bfd_alloc (abfd
, linesz
);
1346 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
1348 if (s
->lineno_count
)
1350 asymbol
**q
= abfd
->outsymbols
;
1351 if (bfd_seek (abfd
, s
->line_filepos
, SEEK_SET
) != 0)
1353 /* Find all the linenumbers in this section */
1357 if (p
->section
->output_section
== s
)
1360 BFD_SEND (bfd_asymbol_bfd (p
), _get_lineno
,
1361 (bfd_asymbol_bfd (p
), p
));
1364 /* Found a linenumber entry, output */
1365 struct internal_lineno out
;
1366 memset ((PTR
) & out
, 0, sizeof (out
));
1368 out
.l_addr
.l_symndx
= l
->u
.offset
;
1369 bfd_coff_swap_lineno_out (abfd
, &out
, buff
);
1370 if (bfd_bwrite (buff
, (bfd_size_type
) linesz
, abfd
)
1374 while (l
->line_number
)
1376 out
.l_lnno
= l
->line_number
;
1377 out
.l_addr
.l_symndx
= l
->u
.offset
;
1378 bfd_coff_swap_lineno_out (abfd
, &out
, buff
);
1379 if (bfd_bwrite (buff
, (bfd_size_type
) linesz
, abfd
)
1390 bfd_release (abfd
, buff
);
1395 coff_get_lineno (ignore_abfd
, symbol
)
1396 bfd
*ignore_abfd ATTRIBUTE_UNUSED
;
1399 return coffsymbol (symbol
)->lineno
;
1404 /* This is only called from coff_add_missing_symbols, which has been
1408 coff_section_symbol (abfd
, name
)
1412 asection
*sec
= bfd_make_section_old_way (abfd
, name
);
1414 combined_entry_type
*csym
;
1417 csym
= coff_symbol_from (abfd
, sym
)->native
;
1418 /* Make sure back-end COFF stuff is there. */
1423 coff_symbol_type sym
;
1424 /* @@FIXME This shouldn't use a fixed size!! */
1425 combined_entry_type e
[10];
1428 f
= (struct foo
*) bfd_alloc (abfd
, (bfd_size_type
) sizeof (*f
));
1431 bfd_set_error (bfd_error_no_error
);
1434 memset ((char *) f
, 0, sizeof (*f
));
1435 coff_symbol_from (abfd
, sym
)->native
= csym
= f
->e
;
1437 csym
[0].u
.syment
.n_sclass
= C_STAT
;
1438 csym
[0].u
.syment
.n_numaux
= 1;
1439 /* SF_SET_STATICS (sym); @@ ??? */
1440 csym
[1].u
.auxent
.x_scn
.x_scnlen
= sec
->_raw_size
;
1441 csym
[1].u
.auxent
.x_scn
.x_nreloc
= sec
->reloc_count
;
1442 csym
[1].u
.auxent
.x_scn
.x_nlinno
= sec
->lineno_count
;
1444 if (sec
->output_section
== NULL
)
1446 sec
->output_section
= sec
;
1447 sec
->output_offset
= 0;
1455 /* This function transforms the offsets into the symbol table into
1456 pointers to syments. */
1459 coff_pointerize_aux (abfd
, table_base
, symbol
, indaux
, auxent
)
1461 combined_entry_type
*table_base
;
1462 combined_entry_type
*symbol
;
1463 unsigned int indaux
;
1464 combined_entry_type
*auxent
;
1466 unsigned int type
= symbol
->u
.syment
.n_type
;
1467 unsigned int class = symbol
->u
.syment
.n_sclass
;
1469 if (coff_backend_info (abfd
)->_bfd_coff_pointerize_aux_hook
)
1471 if ((*coff_backend_info (abfd
)->_bfd_coff_pointerize_aux_hook
)
1472 (abfd
, table_base
, symbol
, indaux
, auxent
))
1476 /* Don't bother if this is a file or a section */
1477 if (class == C_STAT
&& type
== T_NULL
)
1479 if (class == C_FILE
)
1482 /* Otherwise patch up */
1483 #define N_TMASK coff_data (abfd)->local_n_tmask
1484 #define N_BTSHFT coff_data (abfd)->local_n_btshft
1485 if ((ISFCN (type
) || ISTAG (class) || class == C_BLOCK
|| class == C_FCN
)
1486 && auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
> 0)
1488 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
=
1489 table_base
+ auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
1490 auxent
->fix_end
= 1;
1492 /* A negative tagndx is meaningless, but the SCO 3.2v4 cc can
1493 generate one, so we must be careful to ignore it. */
1494 if (auxent
->u
.auxent
.x_sym
.x_tagndx
.l
> 0)
1496 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
=
1497 table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
;
1498 auxent
->fix_tag
= 1;
1502 /* Allocate space for the ".debug" section, and read it.
1503 We did not read the debug section until now, because
1504 we didn't want to go to the trouble until someone needed it. */
1507 build_debug_section (abfd
)
1510 char *debug_section
;
1512 bfd_size_type sec_size
;
1514 asection
*sect
= bfd_get_section_by_name (abfd
, ".debug");
1518 bfd_set_error (bfd_error_no_debug_section
);
1522 sec_size
= bfd_get_section_size_before_reloc (sect
);
1523 debug_section
= (PTR
) bfd_alloc (abfd
, sec_size
);
1524 if (debug_section
== NULL
)
1527 /* Seek to the beginning of the `.debug' section and read it.
1528 Save the current position first; it is needed by our caller.
1529 Then read debug section and reset the file pointer. */
1531 position
= bfd_tell (abfd
);
1532 if (bfd_seek (abfd
, sect
->filepos
, SEEK_SET
) != 0
1533 || bfd_bread (debug_section
, sec_size
, abfd
) != sec_size
1534 || bfd_seek (abfd
, position
, SEEK_SET
) != 0)
1536 return debug_section
;
1539 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
1540 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
1541 be \0-terminated. */
1543 copy_name (abfd
, name
, maxlen
)
1551 for (len
= 0; len
< maxlen
; ++len
)
1553 if (name
[len
] == '\0')
1559 if ((newname
= (PTR
) bfd_alloc (abfd
, (bfd_size_type
) len
+ 1)) == NULL
)
1561 strncpy (newname
, name
, len
);
1562 newname
[len
] = '\0';
1566 /* Read in the external symbols. */
1569 _bfd_coff_get_external_symbols (abfd
)
1572 bfd_size_type symesz
;
1576 if (obj_coff_external_syms (abfd
) != NULL
)
1579 symesz
= bfd_coff_symesz (abfd
);
1581 size
= obj_raw_syment_count (abfd
) * symesz
;
1583 syms
= (PTR
) bfd_malloc (size
);
1584 if (syms
== NULL
&& size
!= 0)
1587 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
1588 || bfd_bread (syms
, size
, abfd
) != size
)
1595 obj_coff_external_syms (abfd
) = syms
;
1600 /* Read in the external strings. The strings are not loaded until
1601 they are needed. This is because we have no simple way of
1602 detecting a missing string table in an archive. */
1605 _bfd_coff_read_string_table (abfd
)
1608 char extstrsize
[STRING_SIZE_SIZE
];
1609 bfd_size_type strsize
;
1613 if (obj_coff_strings (abfd
) != NULL
)
1614 return obj_coff_strings (abfd
);
1616 if (obj_sym_filepos (abfd
) == 0)
1618 bfd_set_error (bfd_error_no_symbols
);
1622 pos
= obj_sym_filepos (abfd
);
1623 pos
+= obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
1624 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
1627 if (bfd_bread (extstrsize
, (bfd_size_type
) sizeof extstrsize
, abfd
)
1628 != sizeof extstrsize
)
1630 if (bfd_get_error () != bfd_error_file_truncated
)
1633 /* There is no string table. */
1634 strsize
= STRING_SIZE_SIZE
;
1638 #if STRING_SIZE_SIZE == 4
1639 strsize
= H_GET_32 (abfd
, extstrsize
);
1641 #error Change H_GET_32
1645 if (strsize
< STRING_SIZE_SIZE
)
1647 (*_bfd_error_handler
)
1648 (_("%s: bad string table size %lu"), bfd_archive_filename (abfd
),
1649 (unsigned long) strsize
);
1650 bfd_set_error (bfd_error_bad_value
);
1654 strings
= (char *) bfd_malloc (strsize
);
1655 if (strings
== NULL
)
1658 if (bfd_bread (strings
+ STRING_SIZE_SIZE
, strsize
- STRING_SIZE_SIZE
, abfd
)
1659 != strsize
- STRING_SIZE_SIZE
)
1665 obj_coff_strings (abfd
) = strings
;
1670 /* Free up the external symbols and strings read from a COFF file. */
1673 _bfd_coff_free_symbols (abfd
)
1676 if (obj_coff_external_syms (abfd
) != NULL
1677 && ! obj_coff_keep_syms (abfd
))
1679 free (obj_coff_external_syms (abfd
));
1680 obj_coff_external_syms (abfd
) = NULL
;
1682 if (obj_coff_strings (abfd
) != NULL
1683 && ! obj_coff_keep_strings (abfd
))
1685 free (obj_coff_strings (abfd
));
1686 obj_coff_strings (abfd
) = NULL
;
1691 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
1692 knit the symbol names into a normalized form. By normalized here I
1693 mean that all symbols have an n_offset pointer that points to a null-
1694 terminated string. */
1696 combined_entry_type
*
1697 coff_get_normalized_symtab (abfd
)
1700 combined_entry_type
*internal
;
1701 combined_entry_type
*internal_ptr
;
1702 combined_entry_type
*symbol_ptr
;
1703 combined_entry_type
*internal_end
;
1707 const char *string_table
= NULL
;
1708 char *debug_section
= NULL
;
1711 if (obj_raw_syments (abfd
) != NULL
)
1712 return obj_raw_syments (abfd
);
1714 size
= obj_raw_syment_count (abfd
) * sizeof (combined_entry_type
);
1715 internal
= (combined_entry_type
*) bfd_zalloc (abfd
, size
);
1716 if (internal
== NULL
&& size
!= 0)
1718 internal_end
= internal
+ obj_raw_syment_count (abfd
);
1720 if (! _bfd_coff_get_external_symbols (abfd
))
1723 raw_src
= (char *) obj_coff_external_syms (abfd
);
1725 /* mark the end of the symbols */
1726 symesz
= bfd_coff_symesz (abfd
);
1727 raw_end
= (char *) raw_src
+ obj_raw_syment_count (abfd
) * symesz
;
1729 /* FIXME SOMEDAY. A string table size of zero is very weird, but
1730 probably possible. If one shows up, it will probably kill us. */
1732 /* Swap all the raw entries */
1733 for (internal_ptr
= internal
;
1735 raw_src
+= symesz
, internal_ptr
++)
1739 bfd_coff_swap_sym_in (abfd
, (PTR
) raw_src
,
1740 (PTR
) & internal_ptr
->u
.syment
);
1741 symbol_ptr
= internal_ptr
;
1744 i
< symbol_ptr
->u
.syment
.n_numaux
;
1749 bfd_coff_swap_aux_in (abfd
, (PTR
) raw_src
,
1750 symbol_ptr
->u
.syment
.n_type
,
1751 symbol_ptr
->u
.syment
.n_sclass
,
1752 (int) i
, symbol_ptr
->u
.syment
.n_numaux
,
1753 &(internal_ptr
->u
.auxent
));
1754 coff_pointerize_aux (abfd
, internal
, symbol_ptr
, i
,
1759 /* Free the raw symbols, but not the strings (if we have them). */
1760 obj_coff_keep_strings (abfd
) = true;
1761 if (! _bfd_coff_free_symbols (abfd
))
1764 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
1767 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
1768 && internal_ptr
->u
.syment
.n_numaux
> 0)
1770 /* make a file symbol point to the name in the auxent, since
1771 the text ".file" is redundant */
1772 if ((internal_ptr
+ 1)->u
.auxent
.x_file
.x_n
.x_zeroes
== 0)
1774 /* the filename is a long one, point into the string table */
1775 if (string_table
== NULL
)
1777 string_table
= _bfd_coff_read_string_table (abfd
);
1778 if (string_table
== NULL
)
1782 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1785 + (internal_ptr
+ 1)->u
.auxent
.x_file
.x_n
.x_offset
));
1789 /* Ordinary short filename, put into memory anyway. The
1790 Microsoft PE tools sometimes store a filename in
1791 multiple AUX entries. */
1792 if (internal_ptr
->u
.syment
.n_numaux
> 1
1793 && coff_data (abfd
)->pe
)
1795 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1798 (internal_ptr
+ 1)->u
.auxent
.x_file
.x_fname
,
1799 internal_ptr
->u
.syment
.n_numaux
* symesz
));
1803 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1806 (internal_ptr
+ 1)->u
.auxent
.x_file
.x_fname
,
1807 (size_t) bfd_coff_filnmlen (abfd
)));
1813 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0)
1815 /* This is a "short" name. Make it long. */
1819 /* find the length of this string without walking into memory
1821 for (i
= 0; i
< 8; ++i
)
1822 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0')
1825 newstring
= (PTR
) bfd_alloc (abfd
, (bfd_size_type
) (i
+ 1));
1826 if (newstring
== NULL
)
1828 memset (newstring
, 0, i
+ 1);
1829 strncpy (newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
);
1830 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (long int) newstring
;
1831 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1833 else if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
== 0)
1834 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (long int) "";
1835 else if (!bfd_coff_symname_in_debug (abfd
, &internal_ptr
->u
.syment
))
1837 /* Long name already. Point symbol at the string in the
1839 if (string_table
== NULL
)
1841 string_table
= _bfd_coff_read_string_table (abfd
);
1842 if (string_table
== NULL
)
1845 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1848 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
));
1852 /* Long name in debug section. Very similar. */
1853 if (debug_section
== NULL
)
1854 debug_section
= build_debug_section (abfd
);
1855 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (long int)
1856 (debug_section
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
1859 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
1862 obj_raw_syments (abfd
) = internal
;
1863 BFD_ASSERT (obj_raw_syment_count (abfd
)
1864 == (unsigned int) (internal_ptr
- internal
));
1867 } /* coff_get_normalized_symtab() */
1870 coff_get_reloc_upper_bound (abfd
, asect
)
1874 if (bfd_get_format (abfd
) != bfd_object
)
1876 bfd_set_error (bfd_error_invalid_operation
);
1879 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
1883 coff_make_empty_symbol (abfd
)
1886 bfd_size_type amt
= sizeof (coff_symbol_type
);
1887 coff_symbol_type
*new = (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
1890 memset (new, 0, sizeof *new);
1891 new->symbol
.section
= 0;
1893 new->lineno
= (alent
*) NULL
;
1894 new->done_lineno
= false;
1895 new->symbol
.the_bfd
= abfd
;
1896 return &new->symbol
;
1899 /* Make a debugging symbol. */
1902 coff_bfd_make_debug_symbol (abfd
, ptr
, sz
)
1904 PTR ptr ATTRIBUTE_UNUSED
;
1905 unsigned long sz ATTRIBUTE_UNUSED
;
1907 bfd_size_type amt
= sizeof (coff_symbol_type
);
1908 coff_symbol_type
*new = (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
1911 /* @@ The 10 is a guess at a plausible maximum number of aux entries
1912 (but shouldn't be a constant). */
1913 amt
= sizeof (combined_entry_type
) * 10;
1914 new->native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
1917 new->symbol
.section
= bfd_abs_section_ptr
;
1918 new->symbol
.flags
= BSF_DEBUGGING
;
1919 new->lineno
= (alent
*) NULL
;
1920 new->done_lineno
= false;
1921 new->symbol
.the_bfd
= abfd
;
1922 return &new->symbol
;
1926 coff_get_symbol_info (abfd
, symbol
, ret
)
1931 bfd_symbol_info (symbol
, ret
);
1932 if (coffsymbol (symbol
)->native
!= NULL
1933 && coffsymbol (symbol
)->native
->fix_value
)
1935 ret
->value
= coffsymbol (symbol
)->native
->u
.syment
.n_value
-
1936 (unsigned long) obj_raw_syments (abfd
);
1940 /* Return the COFF syment for a symbol. */
1943 bfd_coff_get_syment (abfd
, symbol
, psyment
)
1946 struct internal_syment
*psyment
;
1948 coff_symbol_type
*csym
;
1950 csym
= coff_symbol_from (abfd
, symbol
);
1951 if (csym
== NULL
|| csym
->native
== NULL
)
1953 bfd_set_error (bfd_error_invalid_operation
);
1957 *psyment
= csym
->native
->u
.syment
;
1959 if (csym
->native
->fix_value
)
1960 psyment
->n_value
= psyment
->n_value
-
1961 (unsigned long) obj_raw_syments (abfd
);
1963 /* FIXME: We should handle fix_line here. */
1968 /* Return the COFF auxent for a symbol. */
1971 bfd_coff_get_auxent (abfd
, symbol
, indx
, pauxent
)
1975 union internal_auxent
*pauxent
;
1977 coff_symbol_type
*csym
;
1978 combined_entry_type
*ent
;
1980 csym
= coff_symbol_from (abfd
, symbol
);
1983 || csym
->native
== NULL
1984 || indx
>= csym
->native
->u
.syment
.n_numaux
)
1986 bfd_set_error (bfd_error_invalid_operation
);
1990 ent
= csym
->native
+ indx
+ 1;
1992 *pauxent
= ent
->u
.auxent
;
1995 pauxent
->x_sym
.x_tagndx
.l
=
1996 ((combined_entry_type
*) pauxent
->x_sym
.x_tagndx
.p
1997 - obj_raw_syments (abfd
));
2000 pauxent
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
2001 ((combined_entry_type
*) pauxent
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2002 - obj_raw_syments (abfd
));
2004 if (ent
->fix_scnlen
)
2005 pauxent
->x_csect
.x_scnlen
.l
=
2006 ((combined_entry_type
*) pauxent
->x_csect
.x_scnlen
.p
2007 - obj_raw_syments (abfd
));
2012 /* Print out information about COFF symbol. */
2015 coff_print_symbol (abfd
, filep
, symbol
, how
)
2019 bfd_print_symbol_type how
;
2021 FILE *file
= (FILE *) filep
;
2025 case bfd_print_symbol_name
:
2026 fprintf (file
, "%s", symbol
->name
);
2029 case bfd_print_symbol_more
:
2030 fprintf (file
, "coff %s %s",
2031 coffsymbol (symbol
)->native
? "n" : "g",
2032 coffsymbol (symbol
)->lineno
? "l" : " ");
2035 case bfd_print_symbol_all
:
2036 if (coffsymbol (symbol
)->native
)
2040 combined_entry_type
*combined
= coffsymbol (symbol
)->native
;
2041 combined_entry_type
*root
= obj_raw_syments (abfd
);
2042 struct lineno_cache_entry
*l
= coffsymbol (symbol
)->lineno
;
2044 fprintf (file
, "[%3ld]", (long) (combined
- root
));
2046 if (! combined
->fix_value
)
2047 val
= (bfd_vma
) combined
->u
.syment
.n_value
;
2049 val
= combined
->u
.syment
.n_value
- (unsigned long) root
;
2053 "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x%08lx %s",
2054 combined
->u
.syment
.n_scnum
,
2055 combined
->u
.syment
.n_flags
,
2056 combined
->u
.syment
.n_type
,
2057 combined
->u
.syment
.n_sclass
,
2058 combined
->u
.syment
.n_numaux
,
2059 (unsigned long) val
,
2062 /* Print out the wide, 64 bit, symbol value */
2064 "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x%016llx %s",
2065 combined
->u
.syment
.n_scnum
,
2066 combined
->u
.syment
.n_flags
,
2067 combined
->u
.syment
.n_type
,
2068 combined
->u
.syment
.n_sclass
,
2069 combined
->u
.syment
.n_numaux
,
2074 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
2076 combined_entry_type
*auxp
= combined
+ aux
+ 1;
2080 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.p
- root
;
2082 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.l
;
2084 fprintf (file
, "\n");
2086 if (bfd_coff_print_aux (abfd
, file
, root
, combined
, auxp
, aux
))
2089 switch (combined
->u
.syment
.n_sclass
)
2092 fprintf (file
, "File ");
2096 if (combined
->u
.syment
.n_type
== T_NULL
)
2097 /* probably a section symbol? */
2099 fprintf (file
, "AUX scnlen 0x%lx nreloc %d nlnno %d",
2100 (long) auxp
->u
.auxent
.x_scn
.x_scnlen
,
2101 auxp
->u
.auxent
.x_scn
.x_nreloc
,
2102 auxp
->u
.auxent
.x_scn
.x_nlinno
);
2103 if (auxp
->u
.auxent
.x_scn
.x_checksum
!= 0
2104 || auxp
->u
.auxent
.x_scn
.x_associated
!= 0
2105 || auxp
->u
.auxent
.x_scn
.x_comdat
!= 0)
2106 fprintf (file
, " checksum 0x%lx assoc %d comdat %d",
2107 auxp
->u
.auxent
.x_scn
.x_checksum
,
2108 auxp
->u
.auxent
.x_scn
.x_associated
,
2109 auxp
->u
.auxent
.x_scn
.x_comdat
);
2112 /* else fall through */
2114 if (ISFCN (combined
->u
.syment
.n_type
))
2119 next
= (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2122 next
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2123 llnos
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
2125 _("AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld"),
2126 tagndx
, auxp
->u
.auxent
.x_sym
.x_misc
.x_fsize
,
2130 /* else fall through */
2132 fprintf (file
, "AUX lnno %d size 0x%x tagndx %ld",
2133 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
2134 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
,
2137 fprintf (file
, " endndx %ld",
2139 (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2147 fprintf (file
, "\n%s :", l
->u
.sym
->name
);
2149 while (l
->line_number
)
2151 fprintf (file
, "\n%4d : 0x%lx",
2154 (l
->u
.offset
+ symbol
->section
->vma
)));
2161 bfd_print_symbol_vandf (abfd
, (PTR
) file
, symbol
);
2162 fprintf (file
, " %-5s %s %s %s",
2163 symbol
->section
->name
,
2164 coffsymbol (symbol
)->native
? "n" : "g",
2165 coffsymbol (symbol
)->lineno
? "l" : " ",
2171 /* Return whether a symbol name implies a local symbol. In COFF,
2172 local symbols generally start with ``.L''. Most targets use this
2173 function for the is_local_label_name entry point, but some may
2177 _bfd_coff_is_local_label_name (abfd
, name
)
2178 bfd
*abfd ATTRIBUTE_UNUSED
;
2181 return name
[0] == '.' && name
[1] == 'L';
2184 /* Provided a BFD, a section and an offset (in bytes, not octets) into the
2185 section, calculate and return the name of the source file and the line
2186 nearest to the wanted location. */
2189 coff_find_nearest_line (abfd
, section
, symbols
, offset
, filename_ptr
,
2190 functionname_ptr
, line_ptr
)
2195 const char **filename_ptr
;
2196 const char **functionname_ptr
;
2197 unsigned int *line_ptr
;
2201 unsigned int line_base
;
2202 coff_data_type
*cof
= coff_data (abfd
);
2203 /* Run through the raw syments if available */
2204 combined_entry_type
*p
;
2205 combined_entry_type
*pend
;
2207 struct coff_section_tdata
*sec_data
;
2210 /* Before looking through the symbol table, try to use a .stab
2211 section to find the information. */
2212 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2213 &found
, filename_ptr
,
2214 functionname_ptr
, line_ptr
,
2215 &coff_data(abfd
)->line_info
))
2221 /* Also try examining DWARF2 debugging information. */
2222 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
2223 filename_ptr
, functionname_ptr
,
2225 &coff_data(abfd
)->dwarf2_find_line_info
))
2229 *functionname_ptr
= 0;
2232 /* Don't try and find line numbers in a non coff file */
2233 if (!bfd_family_coff (abfd
))
2239 /* Find the first C_FILE symbol. */
2240 p
= cof
->raw_syments
;
2244 pend
= p
+ cof
->raw_syment_count
;
2247 if (p
->u
.syment
.n_sclass
== C_FILE
)
2249 p
+= 1 + p
->u
.syment
.n_numaux
;
2257 /* Look through the C_FILE symbols to find the best one. */
2258 sec_vma
= bfd_get_section_vma (abfd
, section
);
2259 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2260 maxdiff
= (bfd_vma
) 0 - (bfd_vma
) 1;
2263 combined_entry_type
*p2
;
2265 for (p2
= p
+ 1 + p
->u
.syment
.n_numaux
;
2267 p2
+= 1 + p2
->u
.syment
.n_numaux
)
2269 if (p2
->u
.syment
.n_scnum
> 0
2271 == coff_section_from_bfd_index (abfd
,
2272 p2
->u
.syment
.n_scnum
)))
2274 if (p2
->u
.syment
.n_sclass
== C_FILE
)
2281 /* We use <= MAXDIFF here so that if we get a zero length
2282 file, we actually use the next file entry. */
2284 && offset
+ sec_vma
>= (bfd_vma
) p2
->u
.syment
.n_value
2285 && offset
+ sec_vma
- (bfd_vma
) p2
->u
.syment
.n_value
<= maxdiff
)
2287 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2288 maxdiff
= offset
+ sec_vma
- p2
->u
.syment
.n_value
;
2291 /* Avoid endless loops on erroneous files by ensuring that
2292 we always move forward in the file. */
2293 if (p
>= cof
->raw_syments
+ p
->u
.syment
.n_value
)
2296 p
= cof
->raw_syments
+ p
->u
.syment
.n_value
;
2297 if (p
> pend
|| p
->u
.syment
.n_sclass
!= C_FILE
)
2302 /* Now wander though the raw linenumbers of the section */
2303 /* If we have been called on this section before, and the offset we
2304 want is further down then we can prime the lookup loop. */
2305 sec_data
= coff_section_data (abfd
, section
);
2306 if (sec_data
!= NULL
2308 && offset
>= sec_data
->offset
)
2311 *functionname_ptr
= sec_data
->function
;
2312 line_base
= sec_data
->line_base
;
2320 if (section
->lineno
!= NULL
)
2322 bfd_vma last_value
= 0;
2324 l
= §ion
->lineno
[i
];
2326 for (; i
< section
->lineno_count
; i
++)
2328 if (l
->line_number
== 0)
2330 /* Get the symbol this line number points at */
2331 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
2332 if (coff
->symbol
.value
> offset
)
2334 *functionname_ptr
= coff
->symbol
.name
;
2335 last_value
= coff
->symbol
.value
;
2338 combined_entry_type
*s
= coff
->native
;
2339 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2341 /* In XCOFF a debugging symbol can follow the
2343 if (s
->u
.syment
.n_scnum
== N_DEBUG
)
2344 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2346 /* S should now point to the .bf of the function. */
2347 if (s
->u
.syment
.n_numaux
)
2349 /* The linenumber is stored in the auxent. */
2350 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
2351 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
2352 *line_ptr
= line_base
;
2358 if (l
->u
.offset
> offset
)
2360 *line_ptr
= l
->line_number
+ line_base
- 1;
2365 /* If we fell off the end of the loop, then assume that this
2366 symbol has no line number info. Otherwise, symbols with no
2367 line number info get reported with the line number of the
2368 last line of the last symbol which does have line number
2369 info. We use 0x100 as a slop to account for cases where the
2370 last line has executable code. */
2371 if (i
>= section
->lineno_count
2373 && offset
- last_value
> 0x100)
2375 *functionname_ptr
= NULL
;
2380 /* Cache the results for the next call. */
2381 if (sec_data
== NULL
&& section
->owner
== abfd
)
2383 amt
= sizeof (struct coff_section_tdata
);
2384 section
->used_by_bfd
= (PTR
) bfd_zalloc (abfd
, amt
);
2385 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2387 if (sec_data
!= NULL
)
2389 sec_data
->offset
= offset
;
2391 sec_data
->function
= *functionname_ptr
;
2392 sec_data
->line_base
= line_base
;
2399 coff_sizeof_headers (abfd
, reloc
)
2407 size
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
2411 size
= bfd_coff_filhsz (abfd
);
2414 size
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
2418 /* Change the class of a coff symbol held by BFD. */
2420 bfd_coff_set_symbol_class (abfd
, symbol
, class)
2425 coff_symbol_type
* csym
;
2427 csym
= coff_symbol_from (abfd
, symbol
);
2430 bfd_set_error (bfd_error_invalid_operation
);
2433 else if (csym
->native
== NULL
)
2435 /* This is an alien symbol which no native coff backend data.
2436 We cheat here by creating a fake native entry for it and
2437 then filling in the class. This code is based on that in
2438 coff_write_alien_symbol(). */
2440 combined_entry_type
* native
;
2441 bfd_size_type amt
= sizeof (* native
);
2443 native
= (combined_entry_type
*) bfd_alloc (abfd
, amt
);
2447 memset (native
, 0, sizeof (* native
));
2449 native
->u
.syment
.n_type
= T_NULL
;
2450 native
->u
.syment
.n_sclass
= class;
2452 if (bfd_is_und_section (symbol
->section
))
2454 native
->u
.syment
.n_scnum
= N_UNDEF
;
2455 native
->u
.syment
.n_value
= symbol
->value
;
2457 else if (bfd_is_com_section (symbol
->section
))
2459 native
->u
.syment
.n_scnum
= N_UNDEF
;
2460 native
->u
.syment
.n_value
= symbol
->value
;
2464 native
->u
.syment
.n_scnum
=
2465 symbol
->section
->output_section
->target_index
;
2466 native
->u
.syment
.n_value
= (symbol
->value
2467 + symbol
->section
->output_offset
);
2468 if (! obj_pe (abfd
))
2469 native
->u
.syment
.n_value
+= symbol
->section
->output_section
->vma
;
2471 /* Copy the any flags from the the file header into the symbol.
2473 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (& csym
->symbol
)->flags
;
2476 csym
->native
= native
;
2480 csym
->native
->u
.syment
.n_sclass
= class;