1 /* Support for the generic parts of COFF, for BFD.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005, 2007
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 3 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., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
24 /* Most of this hacked by Steve Chamberlain, sac@cygnus.com.
25 Split out of coffcode.h by Ian Taylor, ian@cygnus.com. */
27 /* This file contains COFF code that is not dependent on any
28 particular COFF target. There is only one version of this file in
29 libbfd.a, so no target specific code may be put in here. Or, to
32 ********** DO NOT PUT TARGET SPECIFIC CODE IN THIS FILE **********
34 If you need to add some target specific behaviour, add a new hook
35 function to bfd_coff_backend_data.
37 Some of these functions are also called by the ECOFF routines.
38 Those functions may not use any COFF specific information, such as
44 #include "coff/internal.h"
47 /* Take a section header read from a coff file (in HOST byte order),
48 and make a BFD "section" out of it. This is used by ECOFF. */
51 make_a_section_from_file (bfd
*abfd
,
52 struct internal_scnhdr
*hdr
,
53 unsigned int target_index
)
55 asection
*return_section
;
57 bfd_boolean result
= TRUE
;
62 /* Handle long section names as in PE. */
63 if (bfd_coff_long_section_names (abfd
)
64 && hdr
->s_name
[0] == '/')
71 memcpy (buf
, hdr
->s_name
+ 1, SCNNMLEN
- 1);
72 buf
[SCNNMLEN
- 1] = '\0';
73 strindex
= strtol (buf
, &p
, 10);
74 if (*p
== '\0' && strindex
>= 0)
76 strings
= _bfd_coff_read_string_table (abfd
);
79 /* FIXME: For extra safety, we should make sure that
80 strindex does not run us past the end, but right now we
81 don't know the length of the string table. */
83 name
= bfd_alloc (abfd
, (bfd_size_type
) strlen (strings
) + 1);
86 strcpy (name
, strings
);
92 /* Assorted wastage to null-terminate the name, thanks AT&T! */
93 name
= bfd_alloc (abfd
, (bfd_size_type
) sizeof (hdr
->s_name
) + 1);
96 strncpy (name
, (char *) &hdr
->s_name
[0], sizeof (hdr
->s_name
));
97 name
[sizeof (hdr
->s_name
)] = 0;
100 return_section
= bfd_make_section_anyway (abfd
, name
);
101 if (return_section
== NULL
)
104 return_section
->vma
= hdr
->s_vaddr
;
105 return_section
->lma
= hdr
->s_paddr
;
106 return_section
->size
= hdr
->s_size
;
107 return_section
->filepos
= hdr
->s_scnptr
;
108 return_section
->rel_filepos
= hdr
->s_relptr
;
109 return_section
->reloc_count
= hdr
->s_nreloc
;
111 bfd_coff_set_alignment_hook (abfd
, return_section
, hdr
);
113 return_section
->line_filepos
= hdr
->s_lnnoptr
;
115 return_section
->lineno_count
= hdr
->s_nlnno
;
116 return_section
->userdata
= NULL
;
117 return_section
->next
= NULL
;
118 return_section
->target_index
= target_index
;
120 if (! bfd_coff_styp_to_sec_flags_hook (abfd
, hdr
, name
, return_section
,
124 return_section
->flags
= flags
;
126 /* At least on i386-coff, the line number count for a shared library
127 section must be ignored. */
128 if ((return_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
129 return_section
->lineno_count
= 0;
131 if (hdr
->s_nreloc
!= 0)
132 return_section
->flags
|= SEC_RELOC
;
133 /* FIXME: should this check 'hdr->s_size > 0'. */
134 if (hdr
->s_scnptr
!= 0)
135 return_section
->flags
|= SEC_HAS_CONTENTS
;
140 /* Read in a COFF object and make it into a BFD. This is used by
143 static const bfd_target
*
144 coff_real_object_p (bfd
*abfd
,
146 struct internal_filehdr
*internal_f
,
147 struct internal_aouthdr
*internal_a
)
149 flagword oflags
= abfd
->flags
;
150 bfd_vma ostart
= bfd_get_start_address (abfd
);
153 bfd_size_type readsize
; /* Length of file_info. */
155 char *external_sections
;
157 if (!(internal_f
->f_flags
& F_RELFLG
))
158 abfd
->flags
|= HAS_RELOC
;
159 if ((internal_f
->f_flags
& F_EXEC
))
160 abfd
->flags
|= EXEC_P
;
161 if (!(internal_f
->f_flags
& F_LNNO
))
162 abfd
->flags
|= HAS_LINENO
;
163 if (!(internal_f
->f_flags
& F_LSYMS
))
164 abfd
->flags
|= HAS_LOCALS
;
166 /* FIXME: How can we set D_PAGED correctly? */
167 if ((internal_f
->f_flags
& F_EXEC
) != 0)
168 abfd
->flags
|= D_PAGED
;
170 bfd_get_symcount (abfd
) = internal_f
->f_nsyms
;
171 if (internal_f
->f_nsyms
)
172 abfd
->flags
|= HAS_SYMS
;
174 if (internal_a
!= (struct internal_aouthdr
*) NULL
)
175 bfd_get_start_address (abfd
) = internal_a
->entry
;
177 bfd_get_start_address (abfd
) = 0;
179 /* Set up the tdata area. ECOFF uses its own routine, and overrides
181 tdata_save
= abfd
->tdata
.any
;
182 tdata
= bfd_coff_mkobject_hook (abfd
, (void *) internal_f
, (void *) internal_a
);
186 scnhsz
= bfd_coff_scnhsz (abfd
);
187 readsize
= (bfd_size_type
) nscns
* scnhsz
;
188 external_sections
= bfd_alloc (abfd
, readsize
);
189 if (!external_sections
)
192 if (bfd_bread ((void *) external_sections
, readsize
, abfd
) != readsize
)
195 /* Set the arch/mach *before* swapping in sections; section header swapping
196 may depend on arch/mach info. */
197 if (! bfd_coff_set_arch_mach_hook (abfd
, (void *) internal_f
))
200 /* Now copy data as required; construct all asections etc. */
204 for (i
= 0; i
< nscns
; i
++)
206 struct internal_scnhdr tmp
;
207 bfd_coff_swap_scnhdr_in (abfd
,
208 (void *) (external_sections
+ i
* scnhsz
),
210 if (! make_a_section_from_file (abfd
, &tmp
, i
+ 1))
218 bfd_release (abfd
, tdata
);
220 abfd
->tdata
.any
= tdata_save
;
221 abfd
->flags
= oflags
;
222 bfd_get_start_address (abfd
) = ostart
;
223 return (const bfd_target
*) NULL
;
226 /* Turn a COFF file into a BFD, but fail with bfd_error_wrong_format if it is
227 not a COFF file. This is also used by ECOFF. */
230 coff_object_p (bfd
*abfd
)
232 bfd_size_type filhsz
;
233 bfd_size_type aoutsz
;
236 struct internal_filehdr internal_f
;
237 struct internal_aouthdr internal_a
;
239 /* Figure out how much to read. */
240 filhsz
= bfd_coff_filhsz (abfd
);
241 aoutsz
= bfd_coff_aoutsz (abfd
);
243 filehdr
= bfd_alloc (abfd
, filhsz
);
246 if (bfd_bread (filehdr
, filhsz
, abfd
) != filhsz
)
248 if (bfd_get_error () != bfd_error_system_call
)
249 bfd_set_error (bfd_error_wrong_format
);
250 bfd_release (abfd
, filehdr
);
253 bfd_coff_swap_filehdr_in (abfd
, filehdr
, &internal_f
);
254 bfd_release (abfd
, filehdr
);
256 /* The XCOFF format has two sizes for the f_opthdr. SMALL_AOUTSZ
257 (less than aoutsz) used in object files and AOUTSZ (equal to
258 aoutsz) in executables. The bfd_coff_swap_aouthdr_in function
259 expects this header to be aoutsz bytes in length, so we use that
260 value in the call to bfd_alloc below. But we must be careful to
261 only read in f_opthdr bytes in the call to bfd_bread. We should
262 also attempt to catch corrupt or non-COFF binaries with a strange
263 value for f_opthdr. */
264 if (! bfd_coff_bad_format_hook (abfd
, &internal_f
)
265 || internal_f
.f_opthdr
> aoutsz
)
267 bfd_set_error (bfd_error_wrong_format
);
270 nscns
= internal_f
.f_nscns
;
272 if (internal_f
.f_opthdr
)
276 opthdr
= bfd_alloc (abfd
, aoutsz
);
279 if (bfd_bread (opthdr
, (bfd_size_type
) internal_f
.f_opthdr
, abfd
)
280 != internal_f
.f_opthdr
)
282 bfd_release (abfd
, opthdr
);
285 bfd_coff_swap_aouthdr_in (abfd
, opthdr
, (void *) &internal_a
);
286 bfd_release (abfd
, opthdr
);
289 return coff_real_object_p (abfd
, nscns
, &internal_f
,
290 (internal_f
.f_opthdr
!= 0
292 : (struct internal_aouthdr
*) NULL
));
295 /* Get the BFD section from a COFF symbol section number. */
298 coff_section_from_bfd_index (bfd
*abfd
, int index
)
300 struct bfd_section
*answer
= abfd
->sections
;
303 return bfd_abs_section_ptr
;
304 if (index
== N_UNDEF
)
305 return bfd_und_section_ptr
;
306 if (index
== N_DEBUG
)
307 return bfd_abs_section_ptr
;
311 if (answer
->target_index
== index
)
313 answer
= answer
->next
;
316 /* We should not reach this point, but the SCO 3.2v4 /lib/libc_s.a
317 has a bad symbol table in biglitpow.o. */
318 return bfd_und_section_ptr
;
321 /* Get the upper bound of a COFF symbol table. */
324 coff_get_symtab_upper_bound (bfd
*abfd
)
326 if (!bfd_coff_slurp_symbol_table (abfd
))
329 return (bfd_get_symcount (abfd
) + 1) * (sizeof (coff_symbol_type
*));
332 /* Canonicalize a COFF symbol table. */
335 coff_canonicalize_symtab (bfd
*abfd
, asymbol
**alocation
)
337 unsigned int counter
;
338 coff_symbol_type
*symbase
;
339 coff_symbol_type
**location
= (coff_symbol_type
**) alocation
;
341 if (!bfd_coff_slurp_symbol_table (abfd
))
344 symbase
= obj_symbols (abfd
);
345 counter
= bfd_get_symcount (abfd
);
346 while (counter
-- > 0)
347 *location
++ = symbase
++;
351 return bfd_get_symcount (abfd
);
354 /* Get the name of a symbol. The caller must pass in a buffer of size
358 _bfd_coff_internal_syment_name (bfd
*abfd
,
359 const struct internal_syment
*sym
,
362 /* FIXME: It's not clear this will work correctly if sizeof
364 if (sym
->_n
._n_n
._n_zeroes
!= 0
365 || sym
->_n
._n_n
._n_offset
== 0)
367 memcpy (buf
, sym
->_n
._n_name
, SYMNMLEN
);
368 buf
[SYMNMLEN
] = '\0';
375 BFD_ASSERT (sym
->_n
._n_n
._n_offset
>= STRING_SIZE_SIZE
);
376 strings
= obj_coff_strings (abfd
);
379 strings
= _bfd_coff_read_string_table (abfd
);
383 return strings
+ sym
->_n
._n_n
._n_offset
;
387 /* Read in and swap the relocs. This returns a buffer holding the
388 relocs for section SEC in file ABFD. If CACHE is TRUE and
389 INTERNAL_RELOCS is NULL, the relocs read in will be saved in case
390 the function is called again. If EXTERNAL_RELOCS is not NULL, it
391 is a buffer large enough to hold the unswapped relocs. If
392 INTERNAL_RELOCS is not NULL, it is a buffer large enough to hold
393 the swapped relocs. If REQUIRE_INTERNAL is TRUE, then the return
394 value must be INTERNAL_RELOCS. The function returns NULL on error. */
396 struct internal_reloc
*
397 _bfd_coff_read_internal_relocs (bfd
*abfd
,
400 bfd_byte
*external_relocs
,
401 bfd_boolean require_internal
,
402 struct internal_reloc
*internal_relocs
)
405 bfd_byte
*free_external
= NULL
;
406 struct internal_reloc
*free_internal
= NULL
;
409 struct internal_reloc
*irel
;
412 if (coff_section_data (abfd
, sec
) != NULL
413 && coff_section_data (abfd
, sec
)->relocs
!= NULL
)
415 if (! require_internal
)
416 return coff_section_data (abfd
, sec
)->relocs
;
417 memcpy (internal_relocs
, coff_section_data (abfd
, sec
)->relocs
,
418 sec
->reloc_count
* sizeof (struct internal_reloc
));
419 return internal_relocs
;
422 relsz
= bfd_coff_relsz (abfd
);
424 amt
= sec
->reloc_count
* relsz
;
425 if (external_relocs
== NULL
)
427 free_external
= bfd_malloc (amt
);
428 if (free_external
== NULL
&& sec
->reloc_count
> 0)
430 external_relocs
= free_external
;
433 if (bfd_seek (abfd
, sec
->rel_filepos
, SEEK_SET
) != 0
434 || bfd_bread (external_relocs
, amt
, abfd
) != amt
)
437 if (internal_relocs
== NULL
)
439 amt
= sec
->reloc_count
;
440 amt
*= sizeof (struct internal_reloc
);
441 free_internal
= bfd_malloc (amt
);
442 if (free_internal
== NULL
&& sec
->reloc_count
> 0)
444 internal_relocs
= free_internal
;
447 /* Swap in the relocs. */
448 erel
= external_relocs
;
449 erel_end
= erel
+ relsz
* sec
->reloc_count
;
450 irel
= internal_relocs
;
451 for (; erel
< erel_end
; erel
+= relsz
, irel
++)
452 bfd_coff_swap_reloc_in (abfd
, (void *) erel
, (void *) irel
);
454 if (free_external
!= NULL
)
456 free (free_external
);
457 free_external
= NULL
;
460 if (cache
&& free_internal
!= NULL
)
462 if (coff_section_data (abfd
, sec
) == NULL
)
464 amt
= sizeof (struct coff_section_tdata
);
465 sec
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
466 if (sec
->used_by_bfd
== NULL
)
468 coff_section_data (abfd
, sec
)->contents
= NULL
;
470 coff_section_data (abfd
, sec
)->relocs
= free_internal
;
473 return internal_relocs
;
476 if (free_external
!= NULL
)
477 free (free_external
);
478 if (free_internal
!= NULL
)
479 free (free_internal
);
483 /* Set lineno_count for the output sections of a COFF file. */
486 coff_count_linenumbers (bfd
*abfd
)
488 unsigned int limit
= bfd_get_symcount (abfd
);
496 /* This may be from the backend linker, in which case the
497 lineno_count in the sections is correct. */
498 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
499 total
+= s
->lineno_count
;
503 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
504 BFD_ASSERT (s
->lineno_count
== 0);
506 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
508 asymbol
*q_maybe
= *p
;
510 if (bfd_family_coff (bfd_asymbol_bfd (q_maybe
)))
512 coff_symbol_type
*q
= coffsymbol (q_maybe
);
514 /* The AIX 4.1 compiler can sometimes generate line numbers
515 attached to debugging symbols. We try to simply ignore
517 if (q
->lineno
!= NULL
518 && q
->symbol
.section
->owner
!= NULL
)
520 /* This symbol has line numbers. Increment the owning
521 section's linenumber count. */
522 alent
*l
= q
->lineno
;
526 asection
* sec
= q
->symbol
.section
->output_section
;
528 /* Do not try to update fields in read-only sections. */
529 if (! bfd_is_const_section (sec
))
530 sec
->lineno_count
++;
535 while (l
->line_number
!= 0);
543 /* Takes a bfd and a symbol, returns a pointer to the coff specific
544 area of the symbol if there is one. */
547 coff_symbol_from (bfd
*ignore_abfd ATTRIBUTE_UNUSED
,
550 if (!bfd_family_coff (bfd_asymbol_bfd (symbol
)))
551 return (coff_symbol_type
*) NULL
;
553 if (bfd_asymbol_bfd (symbol
)->tdata
.coff_obj_data
== (coff_data_type
*) NULL
)
554 return (coff_symbol_type
*) NULL
;
556 return (coff_symbol_type
*) symbol
;
560 fixup_symbol_value (bfd
*abfd
,
561 coff_symbol_type
*coff_symbol_ptr
,
562 struct internal_syment
*syment
)
564 /* Normalize the symbol flags. */
565 if (bfd_is_com_section (coff_symbol_ptr
->symbol
.section
))
567 /* A common symbol is undefined with a value. */
568 syment
->n_scnum
= N_UNDEF
;
569 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
571 else if ((coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
) != 0
572 && (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING_RELOC
) == 0)
574 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
576 else if (bfd_is_und_section (coff_symbol_ptr
->symbol
.section
))
578 syment
->n_scnum
= N_UNDEF
;
581 /* FIXME: Do we need to handle the absolute section here? */
584 if (coff_symbol_ptr
->symbol
.section
)
587 coff_symbol_ptr
->symbol
.section
->output_section
->target_index
;
589 syment
->n_value
= (coff_symbol_ptr
->symbol
.value
590 + coff_symbol_ptr
->symbol
.section
->output_offset
);
593 syment
->n_value
+= (syment
->n_sclass
== C_STATLAB
)
594 ? coff_symbol_ptr
->symbol
.section
->output_section
->lma
595 : coff_symbol_ptr
->symbol
.section
->output_section
->vma
;
601 /* This can happen, but I don't know why yet (steve@cygnus.com) */
602 syment
->n_scnum
= N_ABS
;
603 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
608 /* Run through all the symbols in the symbol table and work out what
609 their indexes into the symbol table will be when output.
611 Coff requires that each C_FILE symbol points to the next one in the
612 chain, and that the last one points to the first external symbol. We
616 coff_renumber_symbols (bfd
*bfd_ptr
, int *first_undef
)
618 unsigned int symbol_count
= bfd_get_symcount (bfd_ptr
);
619 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
620 unsigned int native_index
= 0;
621 struct internal_syment
*last_file
= NULL
;
622 unsigned int symbol_index
;
624 /* COFF demands that undefined symbols come after all other symbols.
625 Since we don't need to impose this extra knowledge on all our
626 client programs, deal with that here. Sort the symbol table;
627 just move the undefined symbols to the end, leaving the rest
628 alone. The O'Reilly book says that defined global symbols come
629 at the end before the undefined symbols, so we do that here as
631 /* @@ Do we have some condition we could test for, so we don't always
632 have to do this? I don't think relocatability is quite right, but
633 I'm not certain. [raeburn:19920508.1711EST] */
639 amt
= sizeof (asymbol
*) * ((bfd_size_type
) symbol_count
+ 1);
640 newsyms
= bfd_alloc (bfd_ptr
, amt
);
643 bfd_ptr
->outsymbols
= newsyms
;
644 for (i
= 0; i
< symbol_count
; i
++)
645 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) != 0
646 || (!bfd_is_und_section (symbol_ptr_ptr
[i
]->section
)
647 && !bfd_is_com_section (symbol_ptr_ptr
[i
]->section
)
648 && ((symbol_ptr_ptr
[i
]->flags
& BSF_FUNCTION
) != 0
649 || ((symbol_ptr_ptr
[i
]->flags
& (BSF_GLOBAL
| BSF_WEAK
))
651 *newsyms
++ = symbol_ptr_ptr
[i
];
653 for (i
= 0; i
< symbol_count
; i
++)
654 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) == 0
655 && !bfd_is_und_section (symbol_ptr_ptr
[i
]->section
)
656 && (bfd_is_com_section (symbol_ptr_ptr
[i
]->section
)
657 || ((symbol_ptr_ptr
[i
]->flags
& BSF_FUNCTION
) == 0
658 && ((symbol_ptr_ptr
[i
]->flags
& (BSF_GLOBAL
| BSF_WEAK
))
660 *newsyms
++ = symbol_ptr_ptr
[i
];
662 *first_undef
= newsyms
- bfd_ptr
->outsymbols
;
664 for (i
= 0; i
< symbol_count
; i
++)
665 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) == 0
666 && bfd_is_und_section (symbol_ptr_ptr
[i
]->section
))
667 *newsyms
++ = symbol_ptr_ptr
[i
];
668 *newsyms
= (asymbol
*) NULL
;
669 symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
672 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
674 coff_symbol_type
*coff_symbol_ptr
= coff_symbol_from (bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
675 symbol_ptr_ptr
[symbol_index
]->udata
.i
= symbol_index
;
676 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
)
678 combined_entry_type
*s
= coff_symbol_ptr
->native
;
681 if (s
->u
.syment
.n_sclass
== C_FILE
)
683 if (last_file
!= NULL
)
684 last_file
->n_value
= native_index
;
685 last_file
= &(s
->u
.syment
);
688 /* Modify the symbol values according to their section and
690 fixup_symbol_value (bfd_ptr
, coff_symbol_ptr
, &(s
->u
.syment
));
692 for (i
= 0; i
< s
->u
.syment
.n_numaux
+ 1; i
++)
693 s
[i
].offset
= native_index
++;
699 obj_conv_table_size (bfd_ptr
) = native_index
;
704 /* Run thorough the symbol table again, and fix it so that all
705 pointers to entries are changed to the entries' index in the output
709 coff_mangle_symbols (bfd
*bfd_ptr
)
711 unsigned int symbol_count
= bfd_get_symcount (bfd_ptr
);
712 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
713 unsigned int symbol_index
;
715 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
717 coff_symbol_type
*coff_symbol_ptr
=
718 coff_symbol_from (bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
720 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
)
723 combined_entry_type
*s
= coff_symbol_ptr
->native
;
727 /* FIXME: We should use a union here. */
728 s
->u
.syment
.n_value
=
729 (bfd_vma
)((combined_entry_type
*)
730 ((unsigned long) s
->u
.syment
.n_value
))->offset
;
735 /* The value is the offset into the line number entries
736 for the symbol's section. On output, the symbol's
737 section should be N_DEBUG. */
738 s
->u
.syment
.n_value
=
739 (coff_symbol_ptr
->symbol
.section
->output_section
->line_filepos
740 + s
->u
.syment
.n_value
* bfd_coff_linesz (bfd_ptr
));
741 coff_symbol_ptr
->symbol
.section
=
742 coff_section_from_bfd_index (bfd_ptr
, N_DEBUG
);
743 BFD_ASSERT (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
);
745 for (i
= 0; i
< s
->u
.syment
.n_numaux
; i
++)
747 combined_entry_type
*a
= s
+ i
+ 1;
750 a
->u
.auxent
.x_sym
.x_tagndx
.l
=
751 a
->u
.auxent
.x_sym
.x_tagndx
.p
->offset
;
756 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
757 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
->offset
;
762 a
->u
.auxent
.x_csect
.x_scnlen
.l
=
763 a
->u
.auxent
.x_csect
.x_scnlen
.p
->offset
;
772 coff_fix_symbol_name (bfd
*abfd
,
774 combined_entry_type
*native
,
775 bfd_size_type
*string_size_p
,
776 asection
**debug_string_section_p
,
777 bfd_size_type
*debug_string_size_p
)
779 unsigned int name_length
;
780 union internal_auxent
*auxent
;
781 char *name
= (char *) (symbol
->name
);
785 /* COFF symbols always have names, so we'll make one up. */
786 symbol
->name
= "strange";
787 name
= (char *) symbol
->name
;
789 name_length
= strlen (name
);
791 if (native
->u
.syment
.n_sclass
== C_FILE
792 && native
->u
.syment
.n_numaux
> 0)
794 unsigned int filnmlen
;
796 if (bfd_coff_force_symnames_in_strings (abfd
))
798 native
->u
.syment
._n
._n_n
._n_offset
=
799 (*string_size_p
+ STRING_SIZE_SIZE
);
800 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
801 *string_size_p
+= 6; /* strlen(".file") + 1 */
804 strncpy (native
->u
.syment
._n
._n_name
, ".file", SYMNMLEN
);
806 auxent
= &(native
+ 1)->u
.auxent
;
808 filnmlen
= bfd_coff_filnmlen (abfd
);
810 if (bfd_coff_long_filenames (abfd
))
812 if (name_length
<= filnmlen
)
813 strncpy (auxent
->x_file
.x_fname
, name
, filnmlen
);
816 auxent
->x_file
.x_n
.x_offset
= *string_size_p
+ STRING_SIZE_SIZE
;
817 auxent
->x_file
.x_n
.x_zeroes
= 0;
818 *string_size_p
+= name_length
+ 1;
823 strncpy (auxent
->x_file
.x_fname
, name
, filnmlen
);
824 if (name_length
> filnmlen
)
825 name
[filnmlen
] = '\0';
830 if (name_length
<= SYMNMLEN
&& !bfd_coff_force_symnames_in_strings (abfd
))
831 /* This name will fit into the symbol neatly. */
832 strncpy (native
->u
.syment
._n
._n_name
, symbol
->name
, SYMNMLEN
);
834 else if (!bfd_coff_symname_in_debug (abfd
, &native
->u
.syment
))
836 native
->u
.syment
._n
._n_n
._n_offset
= (*string_size_p
838 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
839 *string_size_p
+= name_length
+ 1;
845 int prefix_len
= bfd_coff_debug_string_prefix_length (abfd
);
847 /* This name should be written into the .debug section. For
848 some reason each name is preceded by a two byte length
849 and also followed by a null byte. FIXME: We assume that
850 the .debug section has already been created, and that it
852 if (*debug_string_section_p
== (asection
*) NULL
)
853 *debug_string_section_p
= bfd_get_section_by_name (abfd
, ".debug");
854 filepos
= bfd_tell (abfd
);
856 bfd_put_32 (abfd
, (bfd_vma
) (name_length
+ 1), buf
);
858 bfd_put_16 (abfd
, (bfd_vma
) (name_length
+ 1), buf
);
860 if (!bfd_set_section_contents (abfd
,
861 *debug_string_section_p
,
863 (file_ptr
) *debug_string_size_p
,
864 (bfd_size_type
) prefix_len
)
865 || !bfd_set_section_contents (abfd
,
866 *debug_string_section_p
,
867 (void *) symbol
->name
,
868 (file_ptr
) (*debug_string_size_p
870 (bfd_size_type
) name_length
+ 1))
872 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
874 native
->u
.syment
._n
._n_n
._n_offset
=
875 *debug_string_size_p
+ prefix_len
;
876 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
877 *debug_string_size_p
+= name_length
+ 1 + prefix_len
;
882 /* We need to keep track of the symbol index so that when we write out
883 the relocs we can get the index for a symbol. This method is a
886 #define set_index(symbol, idx) ((symbol)->udata.i = (idx))
888 /* Write a symbol out to a COFF file. */
891 coff_write_symbol (bfd
*abfd
,
893 combined_entry_type
*native
,
895 bfd_size_type
*string_size_p
,
896 asection
**debug_string_section_p
,
897 bfd_size_type
*debug_string_size_p
)
899 unsigned int numaux
= native
->u
.syment
.n_numaux
;
900 int type
= native
->u
.syment
.n_type
;
901 int class = native
->u
.syment
.n_sclass
;
903 bfd_size_type symesz
;
905 if (native
->u
.syment
.n_sclass
== C_FILE
)
906 symbol
->flags
|= BSF_DEBUGGING
;
908 if (symbol
->flags
& BSF_DEBUGGING
909 && bfd_is_abs_section (symbol
->section
))
910 native
->u
.syment
.n_scnum
= N_DEBUG
;
912 else if (bfd_is_abs_section (symbol
->section
))
913 native
->u
.syment
.n_scnum
= N_ABS
;
915 else if (bfd_is_und_section (symbol
->section
))
916 native
->u
.syment
.n_scnum
= N_UNDEF
;
919 native
->u
.syment
.n_scnum
=
920 symbol
->section
->output_section
->target_index
;
922 coff_fix_symbol_name (abfd
, symbol
, native
, string_size_p
,
923 debug_string_section_p
, debug_string_size_p
);
925 symesz
= bfd_coff_symesz (abfd
);
926 buf
= bfd_alloc (abfd
, symesz
);
929 bfd_coff_swap_sym_out (abfd
, &native
->u
.syment
, buf
);
930 if (bfd_bwrite (buf
, symesz
, abfd
) != symesz
)
932 bfd_release (abfd
, buf
);
934 if (native
->u
.syment
.n_numaux
> 0)
936 bfd_size_type auxesz
;
939 auxesz
= bfd_coff_auxesz (abfd
);
940 buf
= bfd_alloc (abfd
, auxesz
);
943 for (j
= 0; j
< native
->u
.syment
.n_numaux
; j
++)
945 bfd_coff_swap_aux_out (abfd
,
946 &((native
+ j
+ 1)->u
.auxent
),
947 type
, class, (int) j
,
948 native
->u
.syment
.n_numaux
,
950 if (bfd_bwrite (buf
, auxesz
, abfd
) != auxesz
)
953 bfd_release (abfd
, buf
);
956 /* Store the index for use when we write out the relocs. */
957 set_index (symbol
, *written
);
959 *written
+= numaux
+ 1;
963 /* Write out a symbol to a COFF file that does not come from a COFF
964 file originally. This symbol may have been created by the linker,
965 or we may be linking a non COFF file to a COFF file. */
968 coff_write_alien_symbol (bfd
*abfd
,
971 bfd_size_type
*string_size_p
,
972 asection
**debug_string_section_p
,
973 bfd_size_type
*debug_string_size_p
)
975 combined_entry_type
*native
;
976 combined_entry_type dummy
;
979 native
->u
.syment
.n_type
= T_NULL
;
980 native
->u
.syment
.n_flags
= 0;
981 if (bfd_is_und_section (symbol
->section
))
983 native
->u
.syment
.n_scnum
= N_UNDEF
;
984 native
->u
.syment
.n_value
= symbol
->value
;
986 else if (bfd_is_com_section (symbol
->section
))
988 native
->u
.syment
.n_scnum
= N_UNDEF
;
989 native
->u
.syment
.n_value
= symbol
->value
;
991 else if (symbol
->flags
& BSF_DEBUGGING
)
993 /* There isn't much point to writing out a debugging symbol
994 unless we are prepared to convert it into COFF debugging
995 format. So, we just ignore them. We must clobber the symbol
996 name to keep it from being put in the string table. */
1002 native
->u
.syment
.n_scnum
=
1003 symbol
->section
->output_section
->target_index
;
1004 native
->u
.syment
.n_value
= (symbol
->value
1005 + symbol
->section
->output_offset
);
1006 if (! obj_pe (abfd
))
1007 native
->u
.syment
.n_value
+= symbol
->section
->output_section
->vma
;
1009 /* Copy the any flags from the file header into the symbol.
1012 coff_symbol_type
*c
= coff_symbol_from (abfd
, symbol
);
1013 if (c
!= (coff_symbol_type
*) NULL
)
1014 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (&c
->symbol
)->flags
;
1018 native
->u
.syment
.n_type
= 0;
1019 if (symbol
->flags
& BSF_LOCAL
)
1020 native
->u
.syment
.n_sclass
= C_STAT
;
1021 else if (symbol
->flags
& BSF_WEAK
)
1022 native
->u
.syment
.n_sclass
= obj_pe (abfd
) ? C_NT_WEAK
: C_WEAKEXT
;
1024 native
->u
.syment
.n_sclass
= C_EXT
;
1025 native
->u
.syment
.n_numaux
= 0;
1027 return coff_write_symbol (abfd
, symbol
, native
, written
, string_size_p
,
1028 debug_string_section_p
, debug_string_size_p
);
1031 /* Write a native symbol to a COFF file. */
1034 coff_write_native_symbol (bfd
*abfd
,
1035 coff_symbol_type
*symbol
,
1037 bfd_size_type
*string_size_p
,
1038 asection
**debug_string_section_p
,
1039 bfd_size_type
*debug_string_size_p
)
1041 combined_entry_type
*native
= symbol
->native
;
1042 alent
*lineno
= symbol
->lineno
;
1044 /* If this symbol has an associated line number, we must store the
1045 symbol index in the line number field. We also tag the auxent to
1046 point to the right place in the lineno table. */
1047 if (lineno
&& !symbol
->done_lineno
&& symbol
->symbol
.section
->owner
!= NULL
)
1049 unsigned int count
= 0;
1051 lineno
[count
].u
.offset
= *written
;
1052 if (native
->u
.syment
.n_numaux
)
1054 union internal_auxent
*a
= &((native
+ 1)->u
.auxent
);
1056 a
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1057 symbol
->symbol
.section
->output_section
->moving_line_filepos
;
1060 /* Count and relocate all other linenumbers. */
1062 while (lineno
[count
].line_number
!= 0)
1064 lineno
[count
].u
.offset
+=
1065 (symbol
->symbol
.section
->output_section
->vma
1066 + symbol
->symbol
.section
->output_offset
);
1069 symbol
->done_lineno
= TRUE
;
1071 if (! bfd_is_const_section (symbol
->symbol
.section
->output_section
))
1072 symbol
->symbol
.section
->output_section
->moving_line_filepos
+=
1073 count
* bfd_coff_linesz (abfd
);
1076 return coff_write_symbol (abfd
, &(symbol
->symbol
), native
, written
,
1077 string_size_p
, debug_string_section_p
,
1078 debug_string_size_p
);
1081 /* Write out the COFF symbols. */
1084 coff_write_symbols (bfd
*abfd
)
1086 bfd_size_type string_size
;
1087 asection
*debug_string_section
;
1088 bfd_size_type debug_string_size
;
1090 unsigned int limit
= bfd_get_symcount (abfd
);
1091 bfd_vma written
= 0;
1095 debug_string_section
= NULL
;
1096 debug_string_size
= 0;
1098 /* If this target supports long section names, they must be put into
1099 the string table. This is supported by PE. This code must
1100 handle section names just as they are handled in
1101 coff_write_object_contents. */
1102 if (bfd_coff_long_section_names (abfd
))
1106 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1110 len
= strlen (o
->name
);
1112 string_size
+= len
+ 1;
1116 /* Seek to the right place. */
1117 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
1120 /* Output all the symbols we have. */
1122 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1124 asymbol
*symbol
= *p
;
1125 coff_symbol_type
*c_symbol
= coff_symbol_from (abfd
, symbol
);
1127 if (c_symbol
== (coff_symbol_type
*) NULL
1128 || c_symbol
->native
== (combined_entry_type
*) NULL
)
1130 if (!coff_write_alien_symbol (abfd
, symbol
, &written
, &string_size
,
1131 &debug_string_section
,
1132 &debug_string_size
))
1137 if (!coff_write_native_symbol (abfd
, c_symbol
, &written
,
1138 &string_size
, &debug_string_section
,
1139 &debug_string_size
))
1144 obj_raw_syment_count (abfd
) = written
;
1146 /* Now write out strings. */
1147 if (string_size
!= 0)
1149 unsigned int size
= string_size
+ STRING_SIZE_SIZE
;
1150 bfd_byte buffer
[STRING_SIZE_SIZE
];
1152 #if STRING_SIZE_SIZE == 4
1153 H_PUT_32 (abfd
, size
, buffer
);
1155 #error Change H_PUT_32
1157 if (bfd_bwrite ((void *) buffer
, (bfd_size_type
) sizeof (buffer
), abfd
)
1161 /* Handle long section names. This code must handle section
1162 names just as they are handled in coff_write_object_contents. */
1163 if (bfd_coff_long_section_names (abfd
))
1167 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1171 len
= strlen (o
->name
);
1174 if (bfd_bwrite (o
->name
, (bfd_size_type
) (len
+ 1), abfd
)
1181 for (p
= abfd
->outsymbols
, i
= 0;
1186 size_t name_length
= strlen (q
->name
);
1187 coff_symbol_type
*c_symbol
= coff_symbol_from (abfd
, q
);
1190 /* Figure out whether the symbol name should go in the string
1191 table. Symbol names that are short enough are stored
1192 directly in the syment structure. File names permit a
1193 different, longer, length in the syment structure. On
1194 XCOFF, some symbol names are stored in the .debug section
1195 rather than in the string table. */
1197 if (c_symbol
== NULL
1198 || c_symbol
->native
== NULL
)
1199 /* This is not a COFF symbol, so it certainly is not a
1200 file name, nor does it go in the .debug section. */
1201 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1203 else if (bfd_coff_symname_in_debug (abfd
,
1204 &c_symbol
->native
->u
.syment
))
1205 /* This symbol name is in the XCOFF .debug section.
1206 Don't write it into the string table. */
1207 maxlen
= name_length
;
1209 else if (c_symbol
->native
->u
.syment
.n_sclass
== C_FILE
1210 && c_symbol
->native
->u
.syment
.n_numaux
> 0)
1212 if (bfd_coff_force_symnames_in_strings (abfd
))
1214 if (bfd_bwrite (".file", (bfd_size_type
) 6, abfd
) != 6)
1217 maxlen
= bfd_coff_filnmlen (abfd
);
1220 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1222 if (name_length
> maxlen
)
1224 if (bfd_bwrite ((void *) (q
->name
), (bfd_size_type
) name_length
+ 1,
1225 abfd
) != name_length
+ 1)
1232 /* We would normally not write anything here, but we'll write
1233 out 4 so that any stupid coff reader which tries to read the
1234 string table even when there isn't one won't croak. */
1235 unsigned int size
= STRING_SIZE_SIZE
;
1236 bfd_byte buffer
[STRING_SIZE_SIZE
];
1238 #if STRING_SIZE_SIZE == 4
1239 H_PUT_32 (abfd
, size
, buffer
);
1241 #error Change H_PUT_32
1243 if (bfd_bwrite ((void *) buffer
, (bfd_size_type
) STRING_SIZE_SIZE
, abfd
)
1244 != STRING_SIZE_SIZE
)
1248 /* Make sure the .debug section was created to be the correct size.
1249 We should create it ourselves on the fly, but we don't because
1250 BFD won't let us write to any section until we know how large all
1251 the sections are. We could still do it by making another pass
1252 over the symbols. FIXME. */
1253 BFD_ASSERT (debug_string_size
== 0
1254 || (debug_string_section
!= (asection
*) NULL
1255 && (BFD_ALIGN (debug_string_size
,
1256 1 << debug_string_section
->alignment_power
)
1257 == debug_string_section
->size
)));
1263 coff_write_linenumbers (bfd
*abfd
)
1266 bfd_size_type linesz
;
1269 linesz
= bfd_coff_linesz (abfd
);
1270 buff
= bfd_alloc (abfd
, linesz
);
1273 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
1275 if (s
->lineno_count
)
1277 asymbol
**q
= abfd
->outsymbols
;
1278 if (bfd_seek (abfd
, s
->line_filepos
, SEEK_SET
) != 0)
1280 /* Find all the linenumbers in this section. */
1284 if (p
->section
->output_section
== s
)
1287 BFD_SEND (bfd_asymbol_bfd (p
), _get_lineno
,
1288 (bfd_asymbol_bfd (p
), p
));
1291 /* Found a linenumber entry, output. */
1292 struct internal_lineno out
;
1293 memset ((void *) & out
, 0, sizeof (out
));
1295 out
.l_addr
.l_symndx
= l
->u
.offset
;
1296 bfd_coff_swap_lineno_out (abfd
, &out
, buff
);
1297 if (bfd_bwrite (buff
, (bfd_size_type
) linesz
, abfd
)
1301 while (l
->line_number
)
1303 out
.l_lnno
= l
->line_number
;
1304 out
.l_addr
.l_symndx
= l
->u
.offset
;
1305 bfd_coff_swap_lineno_out (abfd
, &out
, buff
);
1306 if (bfd_bwrite (buff
, (bfd_size_type
) linesz
, abfd
)
1317 bfd_release (abfd
, buff
);
1322 coff_get_lineno (bfd
*ignore_abfd ATTRIBUTE_UNUSED
, asymbol
*symbol
)
1324 return coffsymbol (symbol
)->lineno
;
1327 /* This function transforms the offsets into the symbol table into
1328 pointers to syments. */
1331 coff_pointerize_aux (bfd
*abfd
,
1332 combined_entry_type
*table_base
,
1333 combined_entry_type
*symbol
,
1334 unsigned int indaux
,
1335 combined_entry_type
*auxent
)
1337 unsigned int type
= symbol
->u
.syment
.n_type
;
1338 unsigned int class = symbol
->u
.syment
.n_sclass
;
1340 if (coff_backend_info (abfd
)->_bfd_coff_pointerize_aux_hook
)
1342 if ((*coff_backend_info (abfd
)->_bfd_coff_pointerize_aux_hook
)
1343 (abfd
, table_base
, symbol
, indaux
, auxent
))
1347 /* Don't bother if this is a file or a section. */
1348 if (class == C_STAT
&& type
== T_NULL
)
1350 if (class == C_FILE
)
1353 /* Otherwise patch up. */
1354 #define N_TMASK coff_data (abfd)->local_n_tmask
1355 #define N_BTSHFT coff_data (abfd)->local_n_btshft
1357 if ((ISFCN (type
) || ISTAG (class) || class == C_BLOCK
|| class == C_FCN
)
1358 && auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
> 0)
1360 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
=
1361 table_base
+ auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
1362 auxent
->fix_end
= 1;
1364 /* A negative tagndx is meaningless, but the SCO 3.2v4 cc can
1365 generate one, so we must be careful to ignore it. */
1366 if (auxent
->u
.auxent
.x_sym
.x_tagndx
.l
> 0)
1368 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
=
1369 table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
;
1370 auxent
->fix_tag
= 1;
1374 /* Allocate space for the ".debug" section, and read it.
1375 We did not read the debug section until now, because
1376 we didn't want to go to the trouble until someone needed it. */
1379 build_debug_section (bfd
*abfd
)
1381 char *debug_section
;
1383 bfd_size_type sec_size
;
1385 asection
*sect
= bfd_get_section_by_name (abfd
, ".debug");
1389 bfd_set_error (bfd_error_no_debug_section
);
1393 sec_size
= sect
->size
;
1394 debug_section
= bfd_alloc (abfd
, sec_size
);
1395 if (debug_section
== NULL
)
1398 /* Seek to the beginning of the `.debug' section and read it.
1399 Save the current position first; it is needed by our caller.
1400 Then read debug section and reset the file pointer. */
1402 position
= bfd_tell (abfd
);
1403 if (bfd_seek (abfd
, sect
->filepos
, SEEK_SET
) != 0
1404 || bfd_bread (debug_section
, sec_size
, abfd
) != sec_size
1405 || bfd_seek (abfd
, position
, SEEK_SET
) != 0)
1407 return debug_section
;
1410 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
1411 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
1412 be \0-terminated. */
1415 copy_name (bfd
*abfd
, char *name
, size_t maxlen
)
1420 for (len
= 0; len
< maxlen
; ++len
)
1421 if (name
[len
] == '\0')
1424 if ((newname
= bfd_alloc (abfd
, (bfd_size_type
) len
+ 1)) == NULL
)
1427 strncpy (newname
, name
, len
);
1428 newname
[len
] = '\0';
1432 /* Read in the external symbols. */
1435 _bfd_coff_get_external_symbols (bfd
*abfd
)
1437 bfd_size_type symesz
;
1441 if (obj_coff_external_syms (abfd
) != NULL
)
1444 symesz
= bfd_coff_symesz (abfd
);
1446 size
= obj_raw_syment_count (abfd
) * symesz
;
1448 syms
= bfd_malloc (size
);
1449 if (syms
== NULL
&& size
!= 0)
1452 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
1453 || bfd_bread (syms
, size
, abfd
) != size
)
1460 obj_coff_external_syms (abfd
) = syms
;
1465 /* Read in the external strings. The strings are not loaded until
1466 they are needed. This is because we have no simple way of
1467 detecting a missing string table in an archive. */
1470 _bfd_coff_read_string_table (bfd
*abfd
)
1472 char extstrsize
[STRING_SIZE_SIZE
];
1473 bfd_size_type strsize
;
1477 if (obj_coff_strings (abfd
) != NULL
)
1478 return obj_coff_strings (abfd
);
1480 if (obj_sym_filepos (abfd
) == 0)
1482 bfd_set_error (bfd_error_no_symbols
);
1486 pos
= obj_sym_filepos (abfd
);
1487 pos
+= obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
1488 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
1491 if (bfd_bread (extstrsize
, (bfd_size_type
) sizeof extstrsize
, abfd
)
1492 != sizeof extstrsize
)
1494 if (bfd_get_error () != bfd_error_file_truncated
)
1497 /* There is no string table. */
1498 strsize
= STRING_SIZE_SIZE
;
1502 #if STRING_SIZE_SIZE == 4
1503 strsize
= H_GET_32 (abfd
, extstrsize
);
1505 #error Change H_GET_32
1509 if (strsize
< STRING_SIZE_SIZE
)
1511 (*_bfd_error_handler
)
1512 (_("%B: bad string table size %lu"), abfd
, (unsigned long) strsize
);
1513 bfd_set_error (bfd_error_bad_value
);
1517 strings
= bfd_malloc (strsize
);
1518 if (strings
== NULL
)
1521 if (bfd_bread (strings
+ STRING_SIZE_SIZE
, strsize
- STRING_SIZE_SIZE
, abfd
)
1522 != strsize
- STRING_SIZE_SIZE
)
1528 obj_coff_strings (abfd
) = strings
;
1533 /* Free up the external symbols and strings read from a COFF file. */
1536 _bfd_coff_free_symbols (bfd
*abfd
)
1538 if (obj_coff_external_syms (abfd
) != NULL
1539 && ! obj_coff_keep_syms (abfd
))
1541 free (obj_coff_external_syms (abfd
));
1542 obj_coff_external_syms (abfd
) = NULL
;
1544 if (obj_coff_strings (abfd
) != NULL
1545 && ! obj_coff_keep_strings (abfd
))
1547 free (obj_coff_strings (abfd
));
1548 obj_coff_strings (abfd
) = NULL
;
1553 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
1554 knit the symbol names into a normalized form. By normalized here I
1555 mean that all symbols have an n_offset pointer that points to a null-
1556 terminated string. */
1558 combined_entry_type
*
1559 coff_get_normalized_symtab (bfd
*abfd
)
1561 combined_entry_type
*internal
;
1562 combined_entry_type
*internal_ptr
;
1563 combined_entry_type
*symbol_ptr
;
1564 combined_entry_type
*internal_end
;
1568 const char *string_table
= NULL
;
1569 char *debug_section
= NULL
;
1572 if (obj_raw_syments (abfd
) != NULL
)
1573 return obj_raw_syments (abfd
);
1575 size
= obj_raw_syment_count (abfd
) * sizeof (combined_entry_type
);
1576 internal
= bfd_zalloc (abfd
, size
);
1577 if (internal
== NULL
&& size
!= 0)
1579 internal_end
= internal
+ obj_raw_syment_count (abfd
);
1581 if (! _bfd_coff_get_external_symbols (abfd
))
1584 raw_src
= (char *) obj_coff_external_syms (abfd
);
1586 /* Mark the end of the symbols. */
1587 symesz
= bfd_coff_symesz (abfd
);
1588 raw_end
= (char *) raw_src
+ obj_raw_syment_count (abfd
) * symesz
;
1590 /* FIXME SOMEDAY. A string table size of zero is very weird, but
1591 probably possible. If one shows up, it will probably kill us. */
1593 /* Swap all the raw entries. */
1594 for (internal_ptr
= internal
;
1596 raw_src
+= symesz
, internal_ptr
++)
1600 bfd_coff_swap_sym_in (abfd
, (void *) raw_src
,
1601 (void *) & internal_ptr
->u
.syment
);
1602 symbol_ptr
= internal_ptr
;
1605 i
< symbol_ptr
->u
.syment
.n_numaux
;
1610 bfd_coff_swap_aux_in (abfd
, (void *) raw_src
,
1611 symbol_ptr
->u
.syment
.n_type
,
1612 symbol_ptr
->u
.syment
.n_sclass
,
1613 (int) i
, symbol_ptr
->u
.syment
.n_numaux
,
1614 &(internal_ptr
->u
.auxent
));
1615 coff_pointerize_aux (abfd
, internal
, symbol_ptr
, i
,
1620 /* Free the raw symbols, but not the strings (if we have them). */
1621 obj_coff_keep_strings (abfd
) = TRUE
;
1622 if (! _bfd_coff_free_symbols (abfd
))
1625 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
1628 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
1629 && internal_ptr
->u
.syment
.n_numaux
> 0)
1631 /* Make a file symbol point to the name in the auxent, since
1632 the text ".file" is redundant. */
1633 if ((internal_ptr
+ 1)->u
.auxent
.x_file
.x_n
.x_zeroes
== 0)
1635 /* The filename is a long one, point into the string table. */
1636 if (string_table
== NULL
)
1638 string_table
= _bfd_coff_read_string_table (abfd
);
1639 if (string_table
== NULL
)
1643 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1646 + (internal_ptr
+ 1)->u
.auxent
.x_file
.x_n
.x_offset
));
1650 /* Ordinary short filename, put into memory anyway. The
1651 Microsoft PE tools sometimes store a filename in
1652 multiple AUX entries. */
1653 if (internal_ptr
->u
.syment
.n_numaux
> 1
1654 && coff_data (abfd
)->pe
)
1655 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1658 (internal_ptr
+ 1)->u
.auxent
.x_file
.x_fname
,
1659 internal_ptr
->u
.syment
.n_numaux
* symesz
));
1661 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1664 (internal_ptr
+ 1)->u
.auxent
.x_file
.x_fname
,
1665 (size_t) bfd_coff_filnmlen (abfd
)));
1670 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0)
1672 /* This is a "short" name. Make it long. */
1676 /* Find the length of this string without walking into memory
1678 for (i
= 0; i
< 8; ++i
)
1679 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0')
1682 newstring
= bfd_zalloc (abfd
, (bfd_size_type
) (i
+ 1));
1683 if (newstring
== NULL
)
1685 strncpy (newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
);
1686 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (long int) newstring
;
1687 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1689 else if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
== 0)
1690 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (long int) "";
1691 else if (!bfd_coff_symname_in_debug (abfd
, &internal_ptr
->u
.syment
))
1693 /* Long name already. Point symbol at the string in the
1695 if (string_table
== NULL
)
1697 string_table
= _bfd_coff_read_string_table (abfd
);
1698 if (string_table
== NULL
)
1701 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1704 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
));
1708 /* Long name in debug section. Very similar. */
1709 if (debug_section
== NULL
)
1710 debug_section
= build_debug_section (abfd
);
1711 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (long int)
1712 (debug_section
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
1715 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
1718 obj_raw_syments (abfd
) = internal
;
1719 BFD_ASSERT (obj_raw_syment_count (abfd
)
1720 == (unsigned int) (internal_ptr
- internal
));
1726 coff_get_reloc_upper_bound (bfd
*abfd
, sec_ptr asect
)
1728 if (bfd_get_format (abfd
) != bfd_object
)
1730 bfd_set_error (bfd_error_invalid_operation
);
1733 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
1737 coff_make_empty_symbol (bfd
*abfd
)
1739 bfd_size_type amt
= sizeof (coff_symbol_type
);
1740 coff_symbol_type
*new = bfd_zalloc (abfd
, amt
);
1744 new->symbol
.section
= 0;
1747 new->done_lineno
= FALSE
;
1748 new->symbol
.the_bfd
= abfd
;
1750 return & new->symbol
;
1753 /* Make a debugging symbol. */
1756 coff_bfd_make_debug_symbol (bfd
*abfd
,
1757 void * ptr ATTRIBUTE_UNUSED
,
1758 unsigned long sz ATTRIBUTE_UNUSED
)
1760 bfd_size_type amt
= sizeof (coff_symbol_type
);
1761 coff_symbol_type
*new = bfd_alloc (abfd
, amt
);
1765 /* @@ The 10 is a guess at a plausible maximum number of aux entries
1766 (but shouldn't be a constant). */
1767 amt
= sizeof (combined_entry_type
) * 10;
1768 new->native
= bfd_zalloc (abfd
, amt
);
1771 new->symbol
.section
= bfd_abs_section_ptr
;
1772 new->symbol
.flags
= BSF_DEBUGGING
;
1774 new->done_lineno
= FALSE
;
1775 new->symbol
.the_bfd
= abfd
;
1777 return & new->symbol
;
1781 coff_get_symbol_info (bfd
*abfd
, asymbol
*symbol
, symbol_info
*ret
)
1783 bfd_symbol_info (symbol
, ret
);
1785 if (coffsymbol (symbol
)->native
!= NULL
1786 && coffsymbol (symbol
)->native
->fix_value
)
1787 ret
->value
= coffsymbol (symbol
)->native
->u
.syment
.n_value
-
1788 (unsigned long) obj_raw_syments (abfd
);
1791 /* Return the COFF syment for a symbol. */
1794 bfd_coff_get_syment (bfd
*abfd
,
1796 struct internal_syment
*psyment
)
1798 coff_symbol_type
*csym
;
1800 csym
= coff_symbol_from (abfd
, symbol
);
1801 if (csym
== NULL
|| csym
->native
== NULL
)
1803 bfd_set_error (bfd_error_invalid_operation
);
1807 *psyment
= csym
->native
->u
.syment
;
1809 if (csym
->native
->fix_value
)
1810 psyment
->n_value
= psyment
->n_value
-
1811 (unsigned long) obj_raw_syments (abfd
);
1813 /* FIXME: We should handle fix_line here. */
1818 /* Return the COFF auxent for a symbol. */
1821 bfd_coff_get_auxent (bfd
*abfd
,
1824 union internal_auxent
*pauxent
)
1826 coff_symbol_type
*csym
;
1827 combined_entry_type
*ent
;
1829 csym
= coff_symbol_from (abfd
, symbol
);
1832 || csym
->native
== NULL
1833 || indx
>= csym
->native
->u
.syment
.n_numaux
)
1835 bfd_set_error (bfd_error_invalid_operation
);
1839 ent
= csym
->native
+ indx
+ 1;
1841 *pauxent
= ent
->u
.auxent
;
1844 pauxent
->x_sym
.x_tagndx
.l
=
1845 ((combined_entry_type
*) pauxent
->x_sym
.x_tagndx
.p
1846 - obj_raw_syments (abfd
));
1849 pauxent
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
1850 ((combined_entry_type
*) pauxent
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
1851 - obj_raw_syments (abfd
));
1853 if (ent
->fix_scnlen
)
1854 pauxent
->x_csect
.x_scnlen
.l
=
1855 ((combined_entry_type
*) pauxent
->x_csect
.x_scnlen
.p
1856 - obj_raw_syments (abfd
));
1861 /* Print out information about COFF symbol. */
1864 coff_print_symbol (bfd
*abfd
,
1867 bfd_print_symbol_type how
)
1869 FILE * file
= (FILE *) filep
;
1873 case bfd_print_symbol_name
:
1874 fprintf (file
, "%s", symbol
->name
);
1877 case bfd_print_symbol_more
:
1878 fprintf (file
, "coff %s %s",
1879 coffsymbol (symbol
)->native
? "n" : "g",
1880 coffsymbol (symbol
)->lineno
? "l" : " ");
1883 case bfd_print_symbol_all
:
1884 if (coffsymbol (symbol
)->native
)
1888 combined_entry_type
*combined
= coffsymbol (symbol
)->native
;
1889 combined_entry_type
*root
= obj_raw_syments (abfd
);
1890 struct lineno_cache_entry
*l
= coffsymbol (symbol
)->lineno
;
1892 fprintf (file
, "[%3ld]", (long) (combined
- root
));
1894 if (! combined
->fix_value
)
1895 val
= (bfd_vma
) combined
->u
.syment
.n_value
;
1897 val
= combined
->u
.syment
.n_value
- (unsigned long) root
;
1899 fprintf (file
, "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x",
1900 combined
->u
.syment
.n_scnum
,
1901 combined
->u
.syment
.n_flags
,
1902 combined
->u
.syment
.n_type
,
1903 combined
->u
.syment
.n_sclass
,
1904 combined
->u
.syment
.n_numaux
);
1906 /* fprintf_vma() on a 64-bit enabled host will always print a 64-bit
1907 value, but really we want to display the address in the target's
1908 address size. Since we do not have a field in the bfd structure
1909 to tell us this, we take a guess, based on the target's name. */
1910 if (strstr (bfd_get_target (abfd
), "64") == NULL
)
1911 fprintf (file
, "%08lx", (unsigned long) (val
& 0xffffffff));
1914 fprintf_vma (file
, val
);
1915 fprintf (file
, " %s", symbol
->name
);
1917 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
1919 combined_entry_type
*auxp
= combined
+ aux
+ 1;
1923 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.p
- root
;
1925 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.l
;
1927 fprintf (file
, "\n");
1929 if (bfd_coff_print_aux (abfd
, file
, root
, combined
, auxp
, aux
))
1932 switch (combined
->u
.syment
.n_sclass
)
1935 fprintf (file
, "File ");
1939 if (combined
->u
.syment
.n_type
== T_NULL
)
1940 /* Probably a section symbol ? */
1942 fprintf (file
, "AUX scnlen 0x%lx nreloc %d nlnno %d",
1943 (long) auxp
->u
.auxent
.x_scn
.x_scnlen
,
1944 auxp
->u
.auxent
.x_scn
.x_nreloc
,
1945 auxp
->u
.auxent
.x_scn
.x_nlinno
);
1946 if (auxp
->u
.auxent
.x_scn
.x_checksum
!= 0
1947 || auxp
->u
.auxent
.x_scn
.x_associated
!= 0
1948 || auxp
->u
.auxent
.x_scn
.x_comdat
!= 0)
1949 fprintf (file
, " checksum 0x%lx assoc %d comdat %d",
1950 auxp
->u
.auxent
.x_scn
.x_checksum
,
1951 auxp
->u
.auxent
.x_scn
.x_associated
,
1952 auxp
->u
.auxent
.x_scn
.x_comdat
);
1955 /* Otherwise fall through. */
1957 if (ISFCN (combined
->u
.syment
.n_type
))
1962 next
= (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
1965 next
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
1966 llnos
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
1968 "AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld",
1969 tagndx
, auxp
->u
.auxent
.x_sym
.x_misc
.x_fsize
,
1973 /* Otherwise fall through. */
1975 fprintf (file
, "AUX lnno %d size 0x%x tagndx %ld",
1976 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
1977 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
,
1980 fprintf (file
, " endndx %ld",
1982 (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
1990 fprintf (file
, "\n%s :", l
->u
.sym
->name
);
1992 while (l
->line_number
)
1994 fprintf (file
, "\n%4d : ", l
->line_number
);
1995 fprintf_vma (file
, l
->u
.offset
+ symbol
->section
->vma
);
2002 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
2003 fprintf (file
, " %-5s %s %s %s",
2004 symbol
->section
->name
,
2005 coffsymbol (symbol
)->native
? "n" : "g",
2006 coffsymbol (symbol
)->lineno
? "l" : " ",
2012 /* Return whether a symbol name implies a local symbol. In COFF,
2013 local symbols generally start with ``.L''. Most targets use this
2014 function for the is_local_label_name entry point, but some may
2018 _bfd_coff_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
2021 return name
[0] == '.' && name
[1] == 'L';
2024 /* Provided a BFD, a section and an offset (in bytes, not octets) into the
2025 section, calculate and return the name of the source file and the line
2026 nearest to the wanted location. */
2029 coff_find_nearest_line (bfd
*abfd
,
2033 const char **filename_ptr
,
2034 const char **functionname_ptr
,
2035 unsigned int *line_ptr
)
2039 unsigned int line_base
;
2040 coff_data_type
*cof
= coff_data (abfd
);
2041 /* Run through the raw syments if available. */
2042 combined_entry_type
*p
;
2043 combined_entry_type
*pend
;
2045 struct coff_section_tdata
*sec_data
;
2048 /* Before looking through the symbol table, try to use a .stab
2049 section to find the information. */
2050 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2051 &found
, filename_ptr
,
2052 functionname_ptr
, line_ptr
,
2053 &coff_data(abfd
)->line_info
))
2059 /* Also try examining DWARF2 debugging information. */
2060 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
2061 filename_ptr
, functionname_ptr
,
2063 &coff_data(abfd
)->dwarf2_find_line_info
))
2067 *functionname_ptr
= 0;
2070 /* Don't try and find line numbers in a non coff file. */
2071 if (!bfd_family_coff (abfd
))
2077 /* Find the first C_FILE symbol. */
2078 p
= cof
->raw_syments
;
2082 pend
= p
+ cof
->raw_syment_count
;
2085 if (p
->u
.syment
.n_sclass
== C_FILE
)
2087 p
+= 1 + p
->u
.syment
.n_numaux
;
2095 /* Look through the C_FILE symbols to find the best one. */
2096 sec_vma
= bfd_get_section_vma (abfd
, section
);
2097 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2098 maxdiff
= (bfd_vma
) 0 - (bfd_vma
) 1;
2101 combined_entry_type
*p2
;
2103 for (p2
= p
+ 1 + p
->u
.syment
.n_numaux
;
2105 p2
+= 1 + p2
->u
.syment
.n_numaux
)
2107 if (p2
->u
.syment
.n_scnum
> 0
2109 == coff_section_from_bfd_index (abfd
,
2110 p2
->u
.syment
.n_scnum
)))
2112 if (p2
->u
.syment
.n_sclass
== C_FILE
)
2119 /* We use <= MAXDIFF here so that if we get a zero length
2120 file, we actually use the next file entry. */
2122 && offset
+ sec_vma
>= (bfd_vma
) p2
->u
.syment
.n_value
2123 && offset
+ sec_vma
- (bfd_vma
) p2
->u
.syment
.n_value
<= maxdiff
)
2125 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2126 maxdiff
= offset
+ sec_vma
- p2
->u
.syment
.n_value
;
2129 /* Avoid endless loops on erroneous files by ensuring that
2130 we always move forward in the file. */
2131 if (p
>= cof
->raw_syments
+ p
->u
.syment
.n_value
)
2134 p
= cof
->raw_syments
+ p
->u
.syment
.n_value
;
2135 if (p
> pend
|| p
->u
.syment
.n_sclass
!= C_FILE
)
2140 /* Now wander though the raw linenumbers of the section. */
2141 /* If we have been called on this section before, and th. e offset we
2142 want is further down then we can prime the lookup loop. */
2143 sec_data
= coff_section_data (abfd
, section
);
2144 if (sec_data
!= NULL
2146 && offset
>= sec_data
->offset
)
2149 *functionname_ptr
= sec_data
->function
;
2150 line_base
= sec_data
->line_base
;
2158 if (section
->lineno
!= NULL
)
2160 bfd_vma last_value
= 0;
2162 l
= §ion
->lineno
[i
];
2164 for (; i
< section
->lineno_count
; i
++)
2166 if (l
->line_number
== 0)
2168 /* Get the symbol this line number points at. */
2169 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
2170 if (coff
->symbol
.value
> offset
)
2172 *functionname_ptr
= coff
->symbol
.name
;
2173 last_value
= coff
->symbol
.value
;
2176 combined_entry_type
*s
= coff
->native
;
2177 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2179 /* In XCOFF a debugging symbol can follow the
2181 if (s
->u
.syment
.n_scnum
== N_DEBUG
)
2182 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2184 /* S should now point to the .bf of the function. */
2185 if (s
->u
.syment
.n_numaux
)
2187 /* The linenumber is stored in the auxent. */
2188 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
2189 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
2190 *line_ptr
= line_base
;
2196 if (l
->u
.offset
> offset
)
2198 *line_ptr
= l
->line_number
+ line_base
- 1;
2203 /* If we fell off the end of the loop, then assume that this
2204 symbol has no line number info. Otherwise, symbols with no
2205 line number info get reported with the line number of the
2206 last line of the last symbol which does have line number
2207 info. We use 0x100 as a slop to account for cases where the
2208 last line has executable code. */
2209 if (i
>= section
->lineno_count
2211 && offset
- last_value
> 0x100)
2213 *functionname_ptr
= NULL
;
2218 /* Cache the results for the next call. */
2219 if (sec_data
== NULL
&& section
->owner
== abfd
)
2221 amt
= sizeof (struct coff_section_tdata
);
2222 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
2223 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2225 if (sec_data
!= NULL
)
2227 sec_data
->offset
= offset
;
2229 sec_data
->function
= *functionname_ptr
;
2230 sec_data
->line_base
= line_base
;
2237 coff_find_inliner_info (bfd
*abfd
,
2238 const char **filename_ptr
,
2239 const char **functionname_ptr
,
2240 unsigned int *line_ptr
)
2244 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
2245 functionname_ptr
, line_ptr
,
2246 &coff_data(abfd
)->dwarf2_find_line_info
);
2251 coff_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
2255 if (!info
->relocatable
)
2256 size
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
2258 size
= bfd_coff_filhsz (abfd
);
2260 size
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
2264 /* Change the class of a coff symbol held by BFD. */
2267 bfd_coff_set_symbol_class (bfd
* abfd
,
2271 coff_symbol_type
* csym
;
2273 csym
= coff_symbol_from (abfd
, symbol
);
2276 bfd_set_error (bfd_error_invalid_operation
);
2279 else if (csym
->native
== NULL
)
2281 /* This is an alien symbol which no native coff backend data.
2282 We cheat here by creating a fake native entry for it and
2283 then filling in the class. This code is based on that in
2284 coff_write_alien_symbol(). */
2286 combined_entry_type
* native
;
2287 bfd_size_type amt
= sizeof (* native
);
2289 native
= bfd_zalloc (abfd
, amt
);
2293 native
->u
.syment
.n_type
= T_NULL
;
2294 native
->u
.syment
.n_sclass
= class;
2296 if (bfd_is_und_section (symbol
->section
))
2298 native
->u
.syment
.n_scnum
= N_UNDEF
;
2299 native
->u
.syment
.n_value
= symbol
->value
;
2301 else if (bfd_is_com_section (symbol
->section
))
2303 native
->u
.syment
.n_scnum
= N_UNDEF
;
2304 native
->u
.syment
.n_value
= symbol
->value
;
2308 native
->u
.syment
.n_scnum
=
2309 symbol
->section
->output_section
->target_index
;
2310 native
->u
.syment
.n_value
= (symbol
->value
2311 + symbol
->section
->output_offset
);
2312 if (! obj_pe (abfd
))
2313 native
->u
.syment
.n_value
+= symbol
->section
->output_section
->vma
;
2315 /* Copy the any flags from the file header into the symbol.
2317 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (& csym
->symbol
)->flags
;
2320 csym
->native
= native
;
2323 csym
->native
->u
.syment
.n_sclass
= class;
2328 struct coff_comdat_info
*
2329 bfd_coff_get_comdat_section (bfd
*abfd
, struct bfd_section
*sec
)
2331 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
2332 && coff_section_data (abfd
, sec
) != NULL
)
2333 return coff_section_data (abfd
, sec
)->comdat
;