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_hostptr_t
) ((combined_entry_type
*)
730 ((bfd_hostptr_t
) 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
;
1450 syms
= bfd_malloc (size
);
1454 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
1455 || bfd_bread (syms
, size
, abfd
) != size
)
1462 obj_coff_external_syms (abfd
) = syms
;
1467 /* Read in the external strings. The strings are not loaded until
1468 they are needed. This is because we have no simple way of
1469 detecting a missing string table in an archive. */
1472 _bfd_coff_read_string_table (bfd
*abfd
)
1474 char extstrsize
[STRING_SIZE_SIZE
];
1475 bfd_size_type strsize
;
1479 if (obj_coff_strings (abfd
) != NULL
)
1480 return obj_coff_strings (abfd
);
1482 if (obj_sym_filepos (abfd
) == 0)
1484 bfd_set_error (bfd_error_no_symbols
);
1488 pos
= obj_sym_filepos (abfd
);
1489 pos
+= obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
1490 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
1493 if (bfd_bread (extstrsize
, (bfd_size_type
) sizeof extstrsize
, abfd
)
1494 != sizeof extstrsize
)
1496 if (bfd_get_error () != bfd_error_file_truncated
)
1499 /* There is no string table. */
1500 strsize
= STRING_SIZE_SIZE
;
1504 #if STRING_SIZE_SIZE == 4
1505 strsize
= H_GET_32 (abfd
, extstrsize
);
1507 #error Change H_GET_32
1511 if (strsize
< STRING_SIZE_SIZE
)
1513 (*_bfd_error_handler
)
1514 (_("%B: bad string table size %lu"), abfd
, (unsigned long) strsize
);
1515 bfd_set_error (bfd_error_bad_value
);
1519 strings
= bfd_malloc (strsize
);
1520 if (strings
== NULL
)
1523 if (bfd_bread (strings
+ STRING_SIZE_SIZE
, strsize
- STRING_SIZE_SIZE
, abfd
)
1524 != strsize
- STRING_SIZE_SIZE
)
1530 obj_coff_strings (abfd
) = strings
;
1535 /* Free up the external symbols and strings read from a COFF file. */
1538 _bfd_coff_free_symbols (bfd
*abfd
)
1540 if (obj_coff_external_syms (abfd
) != NULL
1541 && ! obj_coff_keep_syms (abfd
))
1543 free (obj_coff_external_syms (abfd
));
1544 obj_coff_external_syms (abfd
) = NULL
;
1546 if (obj_coff_strings (abfd
) != NULL
1547 && ! obj_coff_keep_strings (abfd
))
1549 free (obj_coff_strings (abfd
));
1550 obj_coff_strings (abfd
) = NULL
;
1555 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
1556 knit the symbol names into a normalized form. By normalized here I
1557 mean that all symbols have an n_offset pointer that points to a null-
1558 terminated string. */
1560 combined_entry_type
*
1561 coff_get_normalized_symtab (bfd
*abfd
)
1563 combined_entry_type
*internal
;
1564 combined_entry_type
*internal_ptr
;
1565 combined_entry_type
*symbol_ptr
;
1566 combined_entry_type
*internal_end
;
1570 const char *string_table
= NULL
;
1571 char *debug_section
= NULL
;
1574 if (obj_raw_syments (abfd
) != NULL
)
1575 return obj_raw_syments (abfd
);
1577 size
= obj_raw_syment_count (abfd
) * sizeof (combined_entry_type
);
1578 internal
= bfd_zalloc (abfd
, size
);
1579 if (internal
== NULL
&& size
!= 0)
1581 internal_end
= internal
+ obj_raw_syment_count (abfd
);
1583 if (! _bfd_coff_get_external_symbols (abfd
))
1586 raw_src
= (char *) obj_coff_external_syms (abfd
);
1588 /* Mark the end of the symbols. */
1589 symesz
= bfd_coff_symesz (abfd
);
1590 raw_end
= (char *) raw_src
+ obj_raw_syment_count (abfd
) * symesz
;
1592 /* FIXME SOMEDAY. A string table size of zero is very weird, but
1593 probably possible. If one shows up, it will probably kill us. */
1595 /* Swap all the raw entries. */
1596 for (internal_ptr
= internal
;
1598 raw_src
+= symesz
, internal_ptr
++)
1602 bfd_coff_swap_sym_in (abfd
, (void *) raw_src
,
1603 (void *) & internal_ptr
->u
.syment
);
1604 symbol_ptr
= internal_ptr
;
1607 i
< symbol_ptr
->u
.syment
.n_numaux
;
1612 bfd_coff_swap_aux_in (abfd
, (void *) raw_src
,
1613 symbol_ptr
->u
.syment
.n_type
,
1614 symbol_ptr
->u
.syment
.n_sclass
,
1615 (int) i
, symbol_ptr
->u
.syment
.n_numaux
,
1616 &(internal_ptr
->u
.auxent
));
1617 coff_pointerize_aux (abfd
, internal
, symbol_ptr
, i
,
1622 /* Free the raw symbols, but not the strings (if we have them). */
1623 obj_coff_keep_strings (abfd
) = TRUE
;
1624 if (! _bfd_coff_free_symbols (abfd
))
1627 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
1630 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
1631 && internal_ptr
->u
.syment
.n_numaux
> 0)
1633 /* Make a file symbol point to the name in the auxent, since
1634 the text ".file" is redundant. */
1635 if ((internal_ptr
+ 1)->u
.auxent
.x_file
.x_n
.x_zeroes
== 0)
1637 /* The filename is a long one, point into the string table. */
1638 if (string_table
== NULL
)
1640 string_table
= _bfd_coff_read_string_table (abfd
);
1641 if (string_table
== NULL
)
1645 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1648 + (internal_ptr
+ 1)->u
.auxent
.x_file
.x_n
.x_offset
));
1652 /* Ordinary short filename, put into memory anyway. The
1653 Microsoft PE tools sometimes store a filename in
1654 multiple AUX entries. */
1655 if (internal_ptr
->u
.syment
.n_numaux
> 1
1656 && coff_data (abfd
)->pe
)
1657 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1660 (internal_ptr
+ 1)->u
.auxent
.x_file
.x_fname
,
1661 internal_ptr
->u
.syment
.n_numaux
* symesz
));
1663 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1666 (internal_ptr
+ 1)->u
.auxent
.x_file
.x_fname
,
1667 (size_t) bfd_coff_filnmlen (abfd
)));
1672 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0)
1674 /* This is a "short" name. Make it long. */
1678 /* Find the length of this string without walking into memory
1680 for (i
= 0; i
< 8; ++i
)
1681 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0')
1684 newstring
= bfd_zalloc (abfd
, (bfd_size_type
) (i
+ 1));
1685 if (newstring
== NULL
)
1687 strncpy (newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
);
1688 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) newstring
;
1689 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1691 else if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
== 0)
1692 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_vma
) "";
1693 else if (!bfd_coff_symname_in_debug (abfd
, &internal_ptr
->u
.syment
))
1695 /* Long name already. Point symbol at the string in the
1697 if (string_table
== NULL
)
1699 string_table
= _bfd_coff_read_string_table (abfd
);
1700 if (string_table
== NULL
)
1703 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1706 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
));
1710 /* Long name in debug section. Very similar. */
1711 if (debug_section
== NULL
)
1712 debug_section
= build_debug_section (abfd
);
1713 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
)
1714 (debug_section
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
1717 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
1720 obj_raw_syments (abfd
) = internal
;
1721 BFD_ASSERT (obj_raw_syment_count (abfd
)
1722 == (unsigned int) (internal_ptr
- internal
));
1728 coff_get_reloc_upper_bound (bfd
*abfd
, sec_ptr asect
)
1730 if (bfd_get_format (abfd
) != bfd_object
)
1732 bfd_set_error (bfd_error_invalid_operation
);
1735 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
1739 coff_make_empty_symbol (bfd
*abfd
)
1741 bfd_size_type amt
= sizeof (coff_symbol_type
);
1742 coff_symbol_type
*new = bfd_zalloc (abfd
, amt
);
1746 new->symbol
.section
= 0;
1749 new->done_lineno
= FALSE
;
1750 new->symbol
.the_bfd
= abfd
;
1752 return & new->symbol
;
1755 /* Make a debugging symbol. */
1758 coff_bfd_make_debug_symbol (bfd
*abfd
,
1759 void * ptr ATTRIBUTE_UNUSED
,
1760 unsigned long sz ATTRIBUTE_UNUSED
)
1762 bfd_size_type amt
= sizeof (coff_symbol_type
);
1763 coff_symbol_type
*new = bfd_alloc (abfd
, amt
);
1767 /* @@ The 10 is a guess at a plausible maximum number of aux entries
1768 (but shouldn't be a constant). */
1769 amt
= sizeof (combined_entry_type
) * 10;
1770 new->native
= bfd_zalloc (abfd
, amt
);
1773 new->symbol
.section
= bfd_abs_section_ptr
;
1774 new->symbol
.flags
= BSF_DEBUGGING
;
1776 new->done_lineno
= FALSE
;
1777 new->symbol
.the_bfd
= abfd
;
1779 return & new->symbol
;
1783 coff_get_symbol_info (bfd
*abfd
, asymbol
*symbol
, symbol_info
*ret
)
1785 bfd_symbol_info (symbol
, ret
);
1787 if (coffsymbol (symbol
)->native
!= NULL
1788 && coffsymbol (symbol
)->native
->fix_value
)
1789 ret
->value
= coffsymbol (symbol
)->native
->u
.syment
.n_value
-
1790 (bfd_hostptr_t
) obj_raw_syments (abfd
);
1793 /* Return the COFF syment for a symbol. */
1796 bfd_coff_get_syment (bfd
*abfd
,
1798 struct internal_syment
*psyment
)
1800 coff_symbol_type
*csym
;
1802 csym
= coff_symbol_from (abfd
, symbol
);
1803 if (csym
== NULL
|| csym
->native
== NULL
)
1805 bfd_set_error (bfd_error_invalid_operation
);
1809 *psyment
= csym
->native
->u
.syment
;
1811 if (csym
->native
->fix_value
)
1812 psyment
->n_value
= psyment
->n_value
-
1813 (bfd_hostptr_t
) obj_raw_syments (abfd
);
1815 /* FIXME: We should handle fix_line here. */
1820 /* Return the COFF auxent for a symbol. */
1823 bfd_coff_get_auxent (bfd
*abfd
,
1826 union internal_auxent
*pauxent
)
1828 coff_symbol_type
*csym
;
1829 combined_entry_type
*ent
;
1831 csym
= coff_symbol_from (abfd
, symbol
);
1834 || csym
->native
== NULL
1835 || indx
>= csym
->native
->u
.syment
.n_numaux
)
1837 bfd_set_error (bfd_error_invalid_operation
);
1841 ent
= csym
->native
+ indx
+ 1;
1843 *pauxent
= ent
->u
.auxent
;
1846 pauxent
->x_sym
.x_tagndx
.l
=
1847 ((combined_entry_type
*) pauxent
->x_sym
.x_tagndx
.p
1848 - obj_raw_syments (abfd
));
1851 pauxent
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
1852 ((combined_entry_type
*) pauxent
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
1853 - obj_raw_syments (abfd
));
1855 if (ent
->fix_scnlen
)
1856 pauxent
->x_csect
.x_scnlen
.l
=
1857 ((combined_entry_type
*) pauxent
->x_csect
.x_scnlen
.p
1858 - obj_raw_syments (abfd
));
1863 /* Print out information about COFF symbol. */
1866 coff_print_symbol (bfd
*abfd
,
1869 bfd_print_symbol_type how
)
1871 FILE * file
= (FILE *) filep
;
1875 case bfd_print_symbol_name
:
1876 fprintf (file
, "%s", symbol
->name
);
1879 case bfd_print_symbol_more
:
1880 fprintf (file
, "coff %s %s",
1881 coffsymbol (symbol
)->native
? "n" : "g",
1882 coffsymbol (symbol
)->lineno
? "l" : " ");
1885 case bfd_print_symbol_all
:
1886 if (coffsymbol (symbol
)->native
)
1890 combined_entry_type
*combined
= coffsymbol (symbol
)->native
;
1891 combined_entry_type
*root
= obj_raw_syments (abfd
);
1892 struct lineno_cache_entry
*l
= coffsymbol (symbol
)->lineno
;
1894 fprintf (file
, "[%3ld]", (long) (combined
- root
));
1896 if (! combined
->fix_value
)
1897 val
= (bfd_vma
) combined
->u
.syment
.n_value
;
1899 val
= combined
->u
.syment
.n_value
- (bfd_hostptr_t
) root
;
1901 fprintf (file
, "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x",
1902 combined
->u
.syment
.n_scnum
,
1903 combined
->u
.syment
.n_flags
,
1904 combined
->u
.syment
.n_type
,
1905 combined
->u
.syment
.n_sclass
,
1906 combined
->u
.syment
.n_numaux
);
1908 /* fprintf_vma() on a 64-bit enabled host will always print a 64-bit
1909 value, but really we want to display the address in the target's
1910 address size. Since we do not have a field in the bfd structure
1911 to tell us this, we take a guess, based on the target's name. */
1912 if (strstr (bfd_get_target (abfd
), "64") == NULL
)
1913 fprintf (file
, "%08lx", (unsigned long) (val
& 0xffffffff));
1916 fprintf_vma (file
, val
);
1917 fprintf (file
, " %s", symbol
->name
);
1919 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
1921 combined_entry_type
*auxp
= combined
+ aux
+ 1;
1925 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.p
- root
;
1927 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.l
;
1929 fprintf (file
, "\n");
1931 if (bfd_coff_print_aux (abfd
, file
, root
, combined
, auxp
, aux
))
1934 switch (combined
->u
.syment
.n_sclass
)
1937 fprintf (file
, "File ");
1941 if (combined
->u
.syment
.n_type
== T_NULL
)
1942 /* Probably a section symbol ? */
1944 fprintf (file
, "AUX scnlen 0x%lx nreloc %d nlnno %d",
1945 (long) auxp
->u
.auxent
.x_scn
.x_scnlen
,
1946 auxp
->u
.auxent
.x_scn
.x_nreloc
,
1947 auxp
->u
.auxent
.x_scn
.x_nlinno
);
1948 if (auxp
->u
.auxent
.x_scn
.x_checksum
!= 0
1949 || auxp
->u
.auxent
.x_scn
.x_associated
!= 0
1950 || auxp
->u
.auxent
.x_scn
.x_comdat
!= 0)
1951 fprintf (file
, " checksum 0x%lx assoc %d comdat %d",
1952 auxp
->u
.auxent
.x_scn
.x_checksum
,
1953 auxp
->u
.auxent
.x_scn
.x_associated
,
1954 auxp
->u
.auxent
.x_scn
.x_comdat
);
1957 /* Otherwise fall through. */
1959 if (ISFCN (combined
->u
.syment
.n_type
))
1964 next
= (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
1967 next
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
1968 llnos
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
1970 "AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld",
1971 tagndx
, auxp
->u
.auxent
.x_sym
.x_misc
.x_fsize
,
1975 /* Otherwise fall through. */
1977 fprintf (file
, "AUX lnno %d size 0x%x tagndx %ld",
1978 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
1979 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
,
1982 fprintf (file
, " endndx %ld",
1984 (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
1992 fprintf (file
, "\n%s :", l
->u
.sym
->name
);
1994 while (l
->line_number
)
1996 fprintf (file
, "\n%4d : ", l
->line_number
);
1997 fprintf_vma (file
, l
->u
.offset
+ symbol
->section
->vma
);
2004 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
2005 fprintf (file
, " %-5s %s %s %s",
2006 symbol
->section
->name
,
2007 coffsymbol (symbol
)->native
? "n" : "g",
2008 coffsymbol (symbol
)->lineno
? "l" : " ",
2014 /* Return whether a symbol name implies a local symbol. In COFF,
2015 local symbols generally start with ``.L''. Most targets use this
2016 function for the is_local_label_name entry point, but some may
2020 _bfd_coff_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
2023 return name
[0] == '.' && name
[1] == 'L';
2026 /* Provided a BFD, a section and an offset (in bytes, not octets) into the
2027 section, calculate and return the name of the source file and the line
2028 nearest to the wanted location. */
2031 coff_find_nearest_line (bfd
*abfd
,
2035 const char **filename_ptr
,
2036 const char **functionname_ptr
,
2037 unsigned int *line_ptr
)
2041 unsigned int line_base
;
2042 coff_data_type
*cof
= coff_data (abfd
);
2043 /* Run through the raw syments if available. */
2044 combined_entry_type
*p
;
2045 combined_entry_type
*pend
;
2047 struct coff_section_tdata
*sec_data
;
2050 /* Before looking through the symbol table, try to use a .stab
2051 section to find the information. */
2052 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2053 &found
, filename_ptr
,
2054 functionname_ptr
, line_ptr
,
2055 &coff_data(abfd
)->line_info
))
2061 /* Also try examining DWARF2 debugging information. */
2062 if (_bfd_dwarf2_find_nearest_line (abfd
, section
, symbols
, offset
,
2063 filename_ptr
, functionname_ptr
,
2065 &coff_data(abfd
)->dwarf2_find_line_info
))
2069 *functionname_ptr
= 0;
2072 /* Don't try and find line numbers in a non coff file. */
2073 if (!bfd_family_coff (abfd
))
2079 /* Find the first C_FILE symbol. */
2080 p
= cof
->raw_syments
;
2084 pend
= p
+ cof
->raw_syment_count
;
2087 if (p
->u
.syment
.n_sclass
== C_FILE
)
2089 p
+= 1 + p
->u
.syment
.n_numaux
;
2097 /* Look through the C_FILE symbols to find the best one. */
2098 sec_vma
= bfd_get_section_vma (abfd
, section
);
2099 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2100 maxdiff
= (bfd_vma
) 0 - (bfd_vma
) 1;
2103 combined_entry_type
*p2
;
2105 for (p2
= p
+ 1 + p
->u
.syment
.n_numaux
;
2107 p2
+= 1 + p2
->u
.syment
.n_numaux
)
2109 if (p2
->u
.syment
.n_scnum
> 0
2111 == coff_section_from_bfd_index (abfd
,
2112 p2
->u
.syment
.n_scnum
)))
2114 if (p2
->u
.syment
.n_sclass
== C_FILE
)
2121 /* We use <= MAXDIFF here so that if we get a zero length
2122 file, we actually use the next file entry. */
2124 && offset
+ sec_vma
>= (bfd_vma
) p2
->u
.syment
.n_value
2125 && offset
+ sec_vma
- (bfd_vma
) p2
->u
.syment
.n_value
<= maxdiff
)
2127 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2128 maxdiff
= offset
+ sec_vma
- p2
->u
.syment
.n_value
;
2131 /* Avoid endless loops on erroneous files by ensuring that
2132 we always move forward in the file. */
2133 if (p
>= cof
->raw_syments
+ p
->u
.syment
.n_value
)
2136 p
= cof
->raw_syments
+ p
->u
.syment
.n_value
;
2137 if (p
> pend
|| p
->u
.syment
.n_sclass
!= C_FILE
)
2142 /* Now wander though the raw linenumbers of the section. */
2143 /* If we have been called on this section before, and th. e offset we
2144 want is further down then we can prime the lookup loop. */
2145 sec_data
= coff_section_data (abfd
, section
);
2146 if (sec_data
!= NULL
2148 && offset
>= sec_data
->offset
)
2151 *functionname_ptr
= sec_data
->function
;
2152 line_base
= sec_data
->line_base
;
2160 if (section
->lineno
!= NULL
)
2162 bfd_vma last_value
= 0;
2164 l
= §ion
->lineno
[i
];
2166 for (; i
< section
->lineno_count
; i
++)
2168 if (l
->line_number
== 0)
2170 /* Get the symbol this line number points at. */
2171 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
2172 if (coff
->symbol
.value
> offset
)
2174 *functionname_ptr
= coff
->symbol
.name
;
2175 last_value
= coff
->symbol
.value
;
2178 combined_entry_type
*s
= coff
->native
;
2179 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2181 /* In XCOFF a debugging symbol can follow the
2183 if (s
->u
.syment
.n_scnum
== N_DEBUG
)
2184 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2186 /* S should now point to the .bf of the function. */
2187 if (s
->u
.syment
.n_numaux
)
2189 /* The linenumber is stored in the auxent. */
2190 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
2191 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
2192 *line_ptr
= line_base
;
2198 if (l
->u
.offset
> offset
)
2200 *line_ptr
= l
->line_number
+ line_base
- 1;
2205 /* If we fell off the end of the loop, then assume that this
2206 symbol has no line number info. Otherwise, symbols with no
2207 line number info get reported with the line number of the
2208 last line of the last symbol which does have line number
2209 info. We use 0x100 as a slop to account for cases where the
2210 last line has executable code. */
2211 if (i
>= section
->lineno_count
2213 && offset
- last_value
> 0x100)
2215 *functionname_ptr
= NULL
;
2220 /* Cache the results for the next call. */
2221 if (sec_data
== NULL
&& section
->owner
== abfd
)
2223 amt
= sizeof (struct coff_section_tdata
);
2224 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
2225 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2227 if (sec_data
!= NULL
)
2229 sec_data
->offset
= offset
;
2231 sec_data
->function
= *functionname_ptr
;
2232 sec_data
->line_base
= line_base
;
2239 coff_find_inliner_info (bfd
*abfd
,
2240 const char **filename_ptr
,
2241 const char **functionname_ptr
,
2242 unsigned int *line_ptr
)
2246 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
2247 functionname_ptr
, line_ptr
,
2248 &coff_data(abfd
)->dwarf2_find_line_info
);
2253 coff_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
2257 if (!info
->relocatable
)
2258 size
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
2260 size
= bfd_coff_filhsz (abfd
);
2262 size
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
2266 /* Change the class of a coff symbol held by BFD. */
2269 bfd_coff_set_symbol_class (bfd
* abfd
,
2273 coff_symbol_type
* csym
;
2275 csym
= coff_symbol_from (abfd
, symbol
);
2278 bfd_set_error (bfd_error_invalid_operation
);
2281 else if (csym
->native
== NULL
)
2283 /* This is an alien symbol which no native coff backend data.
2284 We cheat here by creating a fake native entry for it and
2285 then filling in the class. This code is based on that in
2286 coff_write_alien_symbol(). */
2288 combined_entry_type
* native
;
2289 bfd_size_type amt
= sizeof (* native
);
2291 native
= bfd_zalloc (abfd
, amt
);
2295 native
->u
.syment
.n_type
= T_NULL
;
2296 native
->u
.syment
.n_sclass
= class;
2298 if (bfd_is_und_section (symbol
->section
))
2300 native
->u
.syment
.n_scnum
= N_UNDEF
;
2301 native
->u
.syment
.n_value
= symbol
->value
;
2303 else if (bfd_is_com_section (symbol
->section
))
2305 native
->u
.syment
.n_scnum
= N_UNDEF
;
2306 native
->u
.syment
.n_value
= symbol
->value
;
2310 native
->u
.syment
.n_scnum
=
2311 symbol
->section
->output_section
->target_index
;
2312 native
->u
.syment
.n_value
= (symbol
->value
2313 + symbol
->section
->output_offset
);
2314 if (! obj_pe (abfd
))
2315 native
->u
.syment
.n_value
+= symbol
->section
->output_section
->vma
;
2317 /* Copy the any flags from the file header into the symbol.
2319 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (& csym
->symbol
)->flags
;
2322 csym
->native
= native
;
2325 csym
->native
->u
.syment
.n_sclass
= class;
2330 struct coff_comdat_info
*
2331 bfd_coff_get_comdat_section (bfd
*abfd
, struct bfd_section
*sec
)
2333 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
2334 && coff_section_data (abfd
, sec
) != NULL
)
2335 return coff_section_data (abfd
, sec
)->comdat
;