1 /* Support for the generic parts of COFF, for BFD.
2 Copyright (C) 1990-2014 Free Software Foundation, Inc.
3 Written by Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
22 /* Most of this hacked by Steve Chamberlain, sac@cygnus.com.
23 Split out of coffcode.h by Ian Taylor, ian@cygnus.com. */
25 /* This file contains COFF code that is not dependent on any
26 particular COFF target. There is only one version of this file in
27 libbfd.a, so no target specific code may be put in here. Or, to
30 ********** DO NOT PUT TARGET SPECIFIC CODE IN THIS FILE **********
32 If you need to add some target specific behaviour, add a new hook
33 function to bfd_coff_backend_data.
35 Some of these functions are also called by the ECOFF routines.
36 Those functions may not use any COFF specific information, such as
42 #include "coff/internal.h"
45 /* Take a section header read from a coff file (in HOST byte order),
46 and make a BFD "section" out of it. This is used by ECOFF. */
49 make_a_section_from_file (bfd
*abfd
,
50 struct internal_scnhdr
*hdr
,
51 unsigned int target_index
)
53 asection
*return_section
;
55 bfd_boolean result
= TRUE
;
60 /* Handle long section names as in PE. On reading, we want to
61 accept long names if the format permits them at all, regardless
62 of the current state of the flag that dictates if we would generate
63 them in outputs; this construct checks if that is the case by
64 attempting to set the flag, without changing its state; the call
65 will fail for formats that do not support long names at all. */
66 if (bfd_coff_set_long_section_names (abfd
, bfd_coff_long_section_names (abfd
))
67 && hdr
->s_name
[0] == '/')
74 /* Flag that this BFD uses long names, even though the format might
75 expect them to be off by default. This won't directly affect the
76 format of any output BFD created from this one, but the information
77 can be used to decide what to do. */
78 bfd_coff_set_long_section_names (abfd
, TRUE
);
79 memcpy (buf
, hdr
->s_name
+ 1, SCNNMLEN
- 1);
80 buf
[SCNNMLEN
- 1] = '\0';
81 strindex
= strtol (buf
, &p
, 10);
82 if (*p
== '\0' && strindex
>= 0)
84 strings
= _bfd_coff_read_string_table (abfd
);
87 if ((bfd_size_type
)(strindex
+ 2) >= obj_coff_strings_len (abfd
))
90 name
= (char *) bfd_alloc (abfd
,
91 (bfd_size_type
) strlen (strings
) + 1 + 1);
94 strcpy (name
, strings
);
100 /* Assorted wastage to null-terminate the name, thanks AT&T! */
101 name
= (char *) bfd_alloc (abfd
,
102 (bfd_size_type
) sizeof (hdr
->s_name
) + 1 + 1);
105 strncpy (name
, (char *) &hdr
->s_name
[0], sizeof (hdr
->s_name
));
106 name
[sizeof (hdr
->s_name
)] = 0;
109 return_section
= bfd_make_section_anyway (abfd
, name
);
110 if (return_section
== NULL
)
113 return_section
->vma
= hdr
->s_vaddr
;
114 return_section
->lma
= hdr
->s_paddr
;
115 return_section
->size
= hdr
->s_size
;
116 return_section
->filepos
= hdr
->s_scnptr
;
117 return_section
->rel_filepos
= hdr
->s_relptr
;
118 return_section
->reloc_count
= hdr
->s_nreloc
;
120 bfd_coff_set_alignment_hook (abfd
, return_section
, hdr
);
122 return_section
->line_filepos
= hdr
->s_lnnoptr
;
124 return_section
->lineno_count
= hdr
->s_nlnno
;
125 return_section
->userdata
= NULL
;
126 return_section
->next
= NULL
;
127 return_section
->target_index
= target_index
;
129 if (! bfd_coff_styp_to_sec_flags_hook (abfd
, hdr
, name
, return_section
,
133 return_section
->flags
= flags
;
135 /* At least on i386-coff, the line number count for a shared library
136 section must be ignored. */
137 if ((return_section
->flags
& SEC_COFF_SHARED_LIBRARY
) != 0)
138 return_section
->lineno_count
= 0;
140 if (hdr
->s_nreloc
!= 0)
141 return_section
->flags
|= SEC_RELOC
;
142 /* FIXME: should this check 'hdr->s_size > 0'. */
143 if (hdr
->s_scnptr
!= 0)
144 return_section
->flags
|= SEC_HAS_CONTENTS
;
146 /* Compress/decompress DWARF debug sections with names: .debug_* and
147 .zdebug_*, after the section flags is set. */
148 if ((flags
& SEC_DEBUGGING
)
150 && ((name
[1] == 'd' && name
[6] == '_')
151 || (strlen (name
) > 8 && name
[1] == 'z' && name
[7] == '_')))
153 enum { nothing
, compress
, decompress
} action
= nothing
;
154 char *new_name
= NULL
;
156 if (bfd_is_section_compressed (abfd
, return_section
))
158 /* Compressed section. Check if we should decompress. */
159 if ((abfd
->flags
& BFD_DECOMPRESS
))
162 else if (!bfd_is_section_compressed (abfd
, return_section
))
164 /* Normal section. Check if we should compress. */
165 if ((abfd
->flags
& BFD_COMPRESS
) && return_section
->size
!= 0)
174 if (!bfd_init_section_compress_status (abfd
, return_section
))
176 (*_bfd_error_handler
)
177 (_("%B: unable to initialize compress status for section %s"),
183 unsigned int len
= strlen (name
);
185 new_name
= bfd_alloc (abfd
, len
+ 2);
186 if (new_name
== NULL
)
190 memcpy (new_name
+ 2, name
+ 1, len
);
194 if (!bfd_init_section_decompress_status (abfd
, return_section
))
196 (*_bfd_error_handler
)
197 (_("%B: unable to initialize decompress status for section %s"),
203 unsigned int len
= strlen (name
);
205 new_name
= bfd_alloc (abfd
, len
);
206 if (new_name
== NULL
)
209 memcpy (new_name
+ 1, name
+ 2, len
- 1);
213 if (new_name
!= NULL
)
214 bfd_rename_section (abfd
, return_section
, new_name
);
220 /* Read in a COFF object and make it into a BFD. This is used by
223 coff_real_object_p (bfd
*,
225 struct internal_filehdr
*,
226 struct internal_aouthdr
*);
228 coff_real_object_p (bfd
*abfd
,
230 struct internal_filehdr
*internal_f
,
231 struct internal_aouthdr
*internal_a
)
233 flagword oflags
= abfd
->flags
;
234 bfd_vma ostart
= bfd_get_start_address (abfd
);
237 bfd_size_type readsize
; /* Length of file_info. */
239 char *external_sections
;
241 if (!(internal_f
->f_flags
& F_RELFLG
))
242 abfd
->flags
|= HAS_RELOC
;
243 if ((internal_f
->f_flags
& F_EXEC
))
244 abfd
->flags
|= EXEC_P
;
245 if (!(internal_f
->f_flags
& F_LNNO
))
246 abfd
->flags
|= HAS_LINENO
;
247 if (!(internal_f
->f_flags
& F_LSYMS
))
248 abfd
->flags
|= HAS_LOCALS
;
250 /* FIXME: How can we set D_PAGED correctly? */
251 if ((internal_f
->f_flags
& F_EXEC
) != 0)
252 abfd
->flags
|= D_PAGED
;
254 bfd_get_symcount (abfd
) = internal_f
->f_nsyms
;
255 if (internal_f
->f_nsyms
)
256 abfd
->flags
|= HAS_SYMS
;
258 if (internal_a
!= (struct internal_aouthdr
*) NULL
)
259 bfd_get_start_address (abfd
) = internal_a
->entry
;
261 bfd_get_start_address (abfd
) = 0;
263 /* Set up the tdata area. ECOFF uses its own routine, and overrides
265 tdata_save
= abfd
->tdata
.any
;
266 tdata
= bfd_coff_mkobject_hook (abfd
, (void *) internal_f
, (void *) internal_a
);
270 scnhsz
= bfd_coff_scnhsz (abfd
);
271 readsize
= (bfd_size_type
) nscns
* scnhsz
;
272 external_sections
= (char *) bfd_alloc (abfd
, readsize
);
273 if (!external_sections
)
276 if (bfd_bread ((void *) external_sections
, readsize
, abfd
) != readsize
)
279 /* Set the arch/mach *before* swapping in sections; section header swapping
280 may depend on arch/mach info. */
281 if (! bfd_coff_set_arch_mach_hook (abfd
, (void *) internal_f
))
284 /* Now copy data as required; construct all asections etc. */
288 for (i
= 0; i
< nscns
; i
++)
290 struct internal_scnhdr tmp
;
291 bfd_coff_swap_scnhdr_in (abfd
,
292 (void *) (external_sections
+ i
* scnhsz
),
294 if (! make_a_section_from_file (abfd
, &tmp
, i
+ 1))
302 bfd_release (abfd
, tdata
);
304 abfd
->tdata
.any
= tdata_save
;
305 abfd
->flags
= oflags
;
306 bfd_get_start_address (abfd
) = ostart
;
307 return (const bfd_target
*) NULL
;
310 /* Turn a COFF file into a BFD, but fail with bfd_error_wrong_format if it is
311 not a COFF file. This is also used by ECOFF. */
314 coff_object_p (bfd
*abfd
)
316 bfd_size_type filhsz
;
317 bfd_size_type aoutsz
;
320 struct internal_filehdr internal_f
;
321 struct internal_aouthdr internal_a
;
323 /* Figure out how much to read. */
324 filhsz
= bfd_coff_filhsz (abfd
);
325 aoutsz
= bfd_coff_aoutsz (abfd
);
327 filehdr
= bfd_alloc (abfd
, filhsz
);
330 if (bfd_bread (filehdr
, filhsz
, abfd
) != filhsz
)
332 if (bfd_get_error () != bfd_error_system_call
)
333 bfd_set_error (bfd_error_wrong_format
);
334 bfd_release (abfd
, filehdr
);
337 bfd_coff_swap_filehdr_in (abfd
, filehdr
, &internal_f
);
338 bfd_release (abfd
, filehdr
);
340 /* The XCOFF format has two sizes for the f_opthdr. SMALL_AOUTSZ
341 (less than aoutsz) used in object files and AOUTSZ (equal to
342 aoutsz) in executables. The bfd_coff_swap_aouthdr_in function
343 expects this header to be aoutsz bytes in length, so we use that
344 value in the call to bfd_alloc below. But we must be careful to
345 only read in f_opthdr bytes in the call to bfd_bread. We should
346 also attempt to catch corrupt or non-COFF binaries with a strange
347 value for f_opthdr. */
348 if (! bfd_coff_bad_format_hook (abfd
, &internal_f
)
349 || internal_f
.f_opthdr
> aoutsz
)
351 bfd_set_error (bfd_error_wrong_format
);
354 nscns
= internal_f
.f_nscns
;
356 if (internal_f
.f_opthdr
)
360 opthdr
= bfd_alloc (abfd
, aoutsz
);
363 if (bfd_bread (opthdr
, (bfd_size_type
) internal_f
.f_opthdr
, abfd
)
364 != internal_f
.f_opthdr
)
366 bfd_release (abfd
, opthdr
);
369 /* PR 17512: file: 11056-1136-0.004. */
370 if (internal_f
.f_opthdr
< aoutsz
)
371 memset (((char *) opthdr
) + internal_f
.f_opthdr
, 0, aoutsz
- internal_f
.f_opthdr
);
373 bfd_coff_swap_aouthdr_in (abfd
, opthdr
, (void *) &internal_a
);
374 bfd_release (abfd
, opthdr
);
377 return coff_real_object_p (abfd
, nscns
, &internal_f
,
378 (internal_f
.f_opthdr
!= 0
380 : (struct internal_aouthdr
*) NULL
));
383 /* Get the BFD section from a COFF symbol section number. */
386 coff_section_from_bfd_index (bfd
*abfd
, int section_index
)
388 struct bfd_section
*answer
= abfd
->sections
;
390 if (section_index
== N_ABS
)
391 return bfd_abs_section_ptr
;
392 if (section_index
== N_UNDEF
)
393 return bfd_und_section_ptr
;
394 if (section_index
== N_DEBUG
)
395 return bfd_abs_section_ptr
;
399 if (answer
->target_index
== section_index
)
401 answer
= answer
->next
;
404 /* We should not reach this point, but the SCO 3.2v4 /lib/libc_s.a
405 has a bad symbol table in biglitpow.o. */
406 return bfd_und_section_ptr
;
409 /* Get the upper bound of a COFF symbol table. */
412 coff_get_symtab_upper_bound (bfd
*abfd
)
414 if (!bfd_coff_slurp_symbol_table (abfd
))
417 return (bfd_get_symcount (abfd
) + 1) * (sizeof (coff_symbol_type
*));
420 /* Canonicalize a COFF symbol table. */
423 coff_canonicalize_symtab (bfd
*abfd
, asymbol
**alocation
)
425 unsigned int counter
;
426 coff_symbol_type
*symbase
;
427 coff_symbol_type
**location
= (coff_symbol_type
**) alocation
;
429 if (!bfd_coff_slurp_symbol_table (abfd
))
432 symbase
= obj_symbols (abfd
);
433 counter
= bfd_get_symcount (abfd
);
434 while (counter
-- > 0)
435 *location
++ = symbase
++;
439 return bfd_get_symcount (abfd
);
442 /* Get the name of a symbol. The caller must pass in a buffer of size
446 _bfd_coff_internal_syment_name (bfd
*abfd
,
447 const struct internal_syment
*sym
,
450 /* FIXME: It's not clear this will work correctly if sizeof
452 if (sym
->_n
._n_n
._n_zeroes
!= 0
453 || sym
->_n
._n_n
._n_offset
== 0)
455 memcpy (buf
, sym
->_n
._n_name
, SYMNMLEN
);
456 buf
[SYMNMLEN
] = '\0';
463 BFD_ASSERT (sym
->_n
._n_n
._n_offset
>= STRING_SIZE_SIZE
);
464 strings
= obj_coff_strings (abfd
);
467 strings
= _bfd_coff_read_string_table (abfd
);
471 if (sym
->_n
._n_n
._n_offset
>= obj_coff_strings_len (abfd
))
473 return strings
+ sym
->_n
._n_n
._n_offset
;
477 /* Read in and swap the relocs. This returns a buffer holding the
478 relocs for section SEC in file ABFD. If CACHE is TRUE and
479 INTERNAL_RELOCS is NULL, the relocs read in will be saved in case
480 the function is called again. If EXTERNAL_RELOCS is not NULL, it
481 is a buffer large enough to hold the unswapped relocs. If
482 INTERNAL_RELOCS is not NULL, it is a buffer large enough to hold
483 the swapped relocs. If REQUIRE_INTERNAL is TRUE, then the return
484 value must be INTERNAL_RELOCS. The function returns NULL on error. */
486 struct internal_reloc
*
487 _bfd_coff_read_internal_relocs (bfd
*abfd
,
490 bfd_byte
*external_relocs
,
491 bfd_boolean require_internal
,
492 struct internal_reloc
*internal_relocs
)
495 bfd_byte
*free_external
= NULL
;
496 struct internal_reloc
*free_internal
= NULL
;
499 struct internal_reloc
*irel
;
502 if (sec
->reloc_count
== 0)
503 return internal_relocs
; /* Nothing to do. */
505 if (coff_section_data (abfd
, sec
) != NULL
506 && coff_section_data (abfd
, sec
)->relocs
!= NULL
)
508 if (! require_internal
)
509 return coff_section_data (abfd
, sec
)->relocs
;
510 memcpy (internal_relocs
, coff_section_data (abfd
, sec
)->relocs
,
511 sec
->reloc_count
* sizeof (struct internal_reloc
));
512 return internal_relocs
;
515 relsz
= bfd_coff_relsz (abfd
);
517 amt
= sec
->reloc_count
* relsz
;
518 if (external_relocs
== NULL
)
520 free_external
= (bfd_byte
*) bfd_malloc (amt
);
521 if (free_external
== NULL
)
523 external_relocs
= free_external
;
526 if (bfd_seek (abfd
, sec
->rel_filepos
, SEEK_SET
) != 0
527 || bfd_bread (external_relocs
, amt
, abfd
) != amt
)
530 if (internal_relocs
== NULL
)
532 amt
= sec
->reloc_count
;
533 amt
*= sizeof (struct internal_reloc
);
534 free_internal
= (struct internal_reloc
*) bfd_malloc (amt
);
535 if (free_internal
== NULL
)
537 internal_relocs
= free_internal
;
540 /* Swap in the relocs. */
541 erel
= external_relocs
;
542 erel_end
= erel
+ relsz
* sec
->reloc_count
;
543 irel
= internal_relocs
;
544 for (; erel
< erel_end
; erel
+= relsz
, irel
++)
545 bfd_coff_swap_reloc_in (abfd
, (void *) erel
, (void *) irel
);
547 if (free_external
!= NULL
)
549 free (free_external
);
550 free_external
= NULL
;
553 if (cache
&& free_internal
!= NULL
)
555 if (coff_section_data (abfd
, sec
) == NULL
)
557 amt
= sizeof (struct coff_section_tdata
);
558 sec
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
559 if (sec
->used_by_bfd
== NULL
)
561 coff_section_data (abfd
, sec
)->contents
= NULL
;
563 coff_section_data (abfd
, sec
)->relocs
= free_internal
;
566 return internal_relocs
;
569 if (free_external
!= NULL
)
570 free (free_external
);
571 if (free_internal
!= NULL
)
572 free (free_internal
);
576 /* Set lineno_count for the output sections of a COFF file. */
579 coff_count_linenumbers (bfd
*abfd
)
581 unsigned int limit
= bfd_get_symcount (abfd
);
589 /* This may be from the backend linker, in which case the
590 lineno_count in the sections is correct. */
591 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
592 total
+= s
->lineno_count
;
596 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
597 BFD_ASSERT (s
->lineno_count
== 0);
599 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
601 asymbol
*q_maybe
= *p
;
603 if (bfd_family_coff (bfd_asymbol_bfd (q_maybe
)))
605 coff_symbol_type
*q
= coffsymbol (q_maybe
);
607 /* The AIX 4.1 compiler can sometimes generate line numbers
608 attached to debugging symbols. We try to simply ignore
610 if (q
->lineno
!= NULL
611 && q
->symbol
.section
->owner
!= NULL
)
613 /* This symbol has line numbers. Increment the owning
614 section's linenumber count. */
615 alent
*l
= q
->lineno
;
619 asection
* sec
= q
->symbol
.section
->output_section
;
621 /* Do not try to update fields in read-only sections. */
622 if (! bfd_is_const_section (sec
))
623 sec
->lineno_count
++;
628 while (l
->line_number
!= 0);
636 /* Takes a bfd and a symbol, returns a pointer to the coff specific
637 area of the symbol if there is one. */
640 coff_symbol_from (bfd
*ignore_abfd ATTRIBUTE_UNUSED
,
643 if (!bfd_family_coff (bfd_asymbol_bfd (symbol
)))
644 return (coff_symbol_type
*) NULL
;
646 if (bfd_asymbol_bfd (symbol
)->tdata
.coff_obj_data
== (coff_data_type
*) NULL
)
647 return (coff_symbol_type
*) NULL
;
649 return (coff_symbol_type
*) symbol
;
653 fixup_symbol_value (bfd
*abfd
,
654 coff_symbol_type
*coff_symbol_ptr
,
655 struct internal_syment
*syment
)
657 /* Normalize the symbol flags. */
658 if (coff_symbol_ptr
->symbol
.section
659 && bfd_is_com_section (coff_symbol_ptr
->symbol
.section
))
661 /* A common symbol is undefined with a value. */
662 syment
->n_scnum
= N_UNDEF
;
663 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
665 else if ((coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
) != 0
666 && (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING_RELOC
) == 0)
668 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
670 else if (bfd_is_und_section (coff_symbol_ptr
->symbol
.section
))
672 syment
->n_scnum
= N_UNDEF
;
675 /* FIXME: Do we need to handle the absolute section here? */
678 if (coff_symbol_ptr
->symbol
.section
)
681 coff_symbol_ptr
->symbol
.section
->output_section
->target_index
;
683 syment
->n_value
= (coff_symbol_ptr
->symbol
.value
684 + coff_symbol_ptr
->symbol
.section
->output_offset
);
687 syment
->n_value
+= (syment
->n_sclass
== C_STATLAB
)
688 ? coff_symbol_ptr
->symbol
.section
->output_section
->lma
689 : coff_symbol_ptr
->symbol
.section
->output_section
->vma
;
695 /* This can happen, but I don't know why yet (steve@cygnus.com) */
696 syment
->n_scnum
= N_ABS
;
697 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
702 /* Run through all the symbols in the symbol table and work out what
703 their indexes into the symbol table will be when output.
705 Coff requires that each C_FILE symbol points to the next one in the
706 chain, and that the last one points to the first external symbol. We
710 coff_renumber_symbols (bfd
*bfd_ptr
, int *first_undef
)
712 unsigned int symbol_count
= bfd_get_symcount (bfd_ptr
);
713 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
714 unsigned int native_index
= 0;
715 struct internal_syment
*last_file
= NULL
;
716 unsigned int symbol_index
;
718 /* COFF demands that undefined symbols come after all other symbols.
719 Since we don't need to impose this extra knowledge on all our
720 client programs, deal with that here. Sort the symbol table;
721 just move the undefined symbols to the end, leaving the rest
722 alone. The O'Reilly book says that defined global symbols come
723 at the end before the undefined symbols, so we do that here as
725 /* @@ Do we have some condition we could test for, so we don't always
726 have to do this? I don't think relocatability is quite right, but
727 I'm not certain. [raeburn:19920508.1711EST] */
733 amt
= sizeof (asymbol
*) * ((bfd_size_type
) symbol_count
+ 1);
734 newsyms
= (asymbol
**) bfd_alloc (bfd_ptr
, amt
);
737 bfd_ptr
->outsymbols
= newsyms
;
738 for (i
= 0; i
< symbol_count
; i
++)
739 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) != 0
740 || (!bfd_is_und_section (symbol_ptr_ptr
[i
]->section
)
741 && !bfd_is_com_section (symbol_ptr_ptr
[i
]->section
)
742 && ((symbol_ptr_ptr
[i
]->flags
& BSF_FUNCTION
) != 0
743 || ((symbol_ptr_ptr
[i
]->flags
& (BSF_GLOBAL
| BSF_WEAK
))
745 *newsyms
++ = symbol_ptr_ptr
[i
];
747 for (i
= 0; i
< symbol_count
; i
++)
748 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) == 0
749 && !bfd_is_und_section (symbol_ptr_ptr
[i
]->section
)
750 && (bfd_is_com_section (symbol_ptr_ptr
[i
]->section
)
751 || ((symbol_ptr_ptr
[i
]->flags
& BSF_FUNCTION
) == 0
752 && ((symbol_ptr_ptr
[i
]->flags
& (BSF_GLOBAL
| BSF_WEAK
))
754 *newsyms
++ = symbol_ptr_ptr
[i
];
756 *first_undef
= newsyms
- bfd_ptr
->outsymbols
;
758 for (i
= 0; i
< symbol_count
; i
++)
759 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) == 0
760 && bfd_is_und_section (symbol_ptr_ptr
[i
]->section
))
761 *newsyms
++ = symbol_ptr_ptr
[i
];
762 *newsyms
= (asymbol
*) NULL
;
763 symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
766 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
768 coff_symbol_type
*coff_symbol_ptr
= coff_symbol_from (bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
770 symbol_ptr_ptr
[symbol_index
]->udata
.i
= symbol_index
;
771 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
)
773 combined_entry_type
*s
= coff_symbol_ptr
->native
;
776 BFD_ASSERT (s
->is_sym
);
777 if (s
->u
.syment
.n_sclass
== C_FILE
)
779 if (last_file
!= NULL
)
780 last_file
->n_value
= native_index
;
781 last_file
= &(s
->u
.syment
);
784 /* Modify the symbol values according to their section and
786 fixup_symbol_value (bfd_ptr
, coff_symbol_ptr
, &(s
->u
.syment
));
788 for (i
= 0; i
< s
->u
.syment
.n_numaux
+ 1; i
++)
789 s
[i
].offset
= native_index
++;
795 obj_conv_table_size (bfd_ptr
) = native_index
;
800 /* Run thorough the symbol table again, and fix it so that all
801 pointers to entries are changed to the entries' index in the output
805 coff_mangle_symbols (bfd
*bfd_ptr
)
807 unsigned int symbol_count
= bfd_get_symcount (bfd_ptr
);
808 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
809 unsigned int symbol_index
;
811 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
813 coff_symbol_type
*coff_symbol_ptr
=
814 coff_symbol_from (bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
816 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
)
819 combined_entry_type
*s
= coff_symbol_ptr
->native
;
821 BFD_ASSERT (s
->is_sym
);
824 /* FIXME: We should use a union here. */
825 s
->u
.syment
.n_value
=
826 (bfd_hostptr_t
) ((combined_entry_type
*)
827 ((bfd_hostptr_t
) s
->u
.syment
.n_value
))->offset
;
832 /* The value is the offset into the line number entries
833 for the symbol's section. On output, the symbol's
834 section should be N_DEBUG. */
835 s
->u
.syment
.n_value
=
836 (coff_symbol_ptr
->symbol
.section
->output_section
->line_filepos
837 + s
->u
.syment
.n_value
* bfd_coff_linesz (bfd_ptr
));
838 coff_symbol_ptr
->symbol
.section
=
839 coff_section_from_bfd_index (bfd_ptr
, N_DEBUG
);
840 BFD_ASSERT (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
);
842 for (i
= 0; i
< s
->u
.syment
.n_numaux
; i
++)
844 combined_entry_type
*a
= s
+ i
+ 1;
846 BFD_ASSERT (! a
->is_sym
);
849 a
->u
.auxent
.x_sym
.x_tagndx
.l
=
850 a
->u
.auxent
.x_sym
.x_tagndx
.p
->offset
;
855 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
856 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
->offset
;
861 a
->u
.auxent
.x_csect
.x_scnlen
.l
=
862 a
->u
.auxent
.x_csect
.x_scnlen
.p
->offset
;
871 coff_fix_symbol_name (bfd
*abfd
,
873 combined_entry_type
*native
,
874 bfd_size_type
*string_size_p
,
875 asection
**debug_string_section_p
,
876 bfd_size_type
*debug_string_size_p
)
878 unsigned int name_length
;
879 union internal_auxent
*auxent
;
880 char *name
= (char *) (symbol
->name
);
884 /* COFF symbols always have names, so we'll make one up. */
885 symbol
->name
= "strange";
886 name
= (char *) symbol
->name
;
888 name_length
= strlen (name
);
890 BFD_ASSERT (native
->is_sym
);
891 if (native
->u
.syment
.n_sclass
== C_FILE
892 && native
->u
.syment
.n_numaux
> 0)
894 unsigned int filnmlen
;
896 if (bfd_coff_force_symnames_in_strings (abfd
))
898 native
->u
.syment
._n
._n_n
._n_offset
=
899 (*string_size_p
+ STRING_SIZE_SIZE
);
900 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
901 *string_size_p
+= 6; /* strlen(".file") + 1 */
904 strncpy (native
->u
.syment
._n
._n_name
, ".file", SYMNMLEN
);
906 BFD_ASSERT (! (native
+ 1)->is_sym
);
907 auxent
= &(native
+ 1)->u
.auxent
;
909 filnmlen
= bfd_coff_filnmlen (abfd
);
911 if (bfd_coff_long_filenames (abfd
))
913 if (name_length
<= filnmlen
)
914 strncpy (auxent
->x_file
.x_fname
, name
, filnmlen
);
917 auxent
->x_file
.x_n
.x_offset
= *string_size_p
+ STRING_SIZE_SIZE
;
918 auxent
->x_file
.x_n
.x_zeroes
= 0;
919 *string_size_p
+= name_length
+ 1;
924 strncpy (auxent
->x_file
.x_fname
, name
, filnmlen
);
925 if (name_length
> filnmlen
)
926 name
[filnmlen
] = '\0';
931 if (name_length
<= SYMNMLEN
&& !bfd_coff_force_symnames_in_strings (abfd
))
932 /* This name will fit into the symbol neatly. */
933 strncpy (native
->u
.syment
._n
._n_name
, symbol
->name
, SYMNMLEN
);
935 else if (!bfd_coff_symname_in_debug (abfd
, &native
->u
.syment
))
937 native
->u
.syment
._n
._n_n
._n_offset
= (*string_size_p
939 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
940 *string_size_p
+= name_length
+ 1;
946 int prefix_len
= bfd_coff_debug_string_prefix_length (abfd
);
948 /* This name should be written into the .debug section. For
949 some reason each name is preceded by a two byte length
950 and also followed by a null byte. FIXME: We assume that
951 the .debug section has already been created, and that it
953 if (*debug_string_section_p
== (asection
*) NULL
)
954 *debug_string_section_p
= bfd_get_section_by_name (abfd
, ".debug");
955 filepos
= bfd_tell (abfd
);
957 bfd_put_32 (abfd
, (bfd_vma
) (name_length
+ 1), buf
);
959 bfd_put_16 (abfd
, (bfd_vma
) (name_length
+ 1), buf
);
961 if (!bfd_set_section_contents (abfd
,
962 *debug_string_section_p
,
964 (file_ptr
) *debug_string_size_p
,
965 (bfd_size_type
) prefix_len
)
966 || !bfd_set_section_contents (abfd
,
967 *debug_string_section_p
,
968 (void *) symbol
->name
,
969 (file_ptr
) (*debug_string_size_p
971 (bfd_size_type
) name_length
+ 1))
973 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
975 native
->u
.syment
._n
._n_n
._n_offset
=
976 *debug_string_size_p
+ prefix_len
;
977 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
978 *debug_string_size_p
+= name_length
+ 1 + prefix_len
;
983 /* We need to keep track of the symbol index so that when we write out
984 the relocs we can get the index for a symbol. This method is a
987 #define set_index(symbol, idx) ((symbol)->udata.i = (idx))
989 /* Write a symbol out to a COFF file. */
992 coff_write_symbol (bfd
*abfd
,
994 combined_entry_type
*native
,
996 bfd_size_type
*string_size_p
,
997 asection
**debug_string_section_p
,
998 bfd_size_type
*debug_string_size_p
)
1000 unsigned int numaux
= native
->u
.syment
.n_numaux
;
1001 int type
= native
->u
.syment
.n_type
;
1002 int n_sclass
= (int) native
->u
.syment
.n_sclass
;
1003 asection
*output_section
= symbol
->section
->output_section
1004 ? symbol
->section
->output_section
1007 bfd_size_type symesz
;
1009 BFD_ASSERT (native
->is_sym
);
1011 if (native
->u
.syment
.n_sclass
== C_FILE
)
1012 symbol
->flags
|= BSF_DEBUGGING
;
1014 if (symbol
->flags
& BSF_DEBUGGING
1015 && bfd_is_abs_section (symbol
->section
))
1016 native
->u
.syment
.n_scnum
= N_DEBUG
;
1018 else if (bfd_is_abs_section (symbol
->section
))
1019 native
->u
.syment
.n_scnum
= N_ABS
;
1021 else if (bfd_is_und_section (symbol
->section
))
1022 native
->u
.syment
.n_scnum
= N_UNDEF
;
1025 native
->u
.syment
.n_scnum
=
1026 output_section
->target_index
;
1028 coff_fix_symbol_name (abfd
, symbol
, native
, string_size_p
,
1029 debug_string_section_p
, debug_string_size_p
);
1031 symesz
= bfd_coff_symesz (abfd
);
1032 buf
= bfd_alloc (abfd
, symesz
);
1035 bfd_coff_swap_sym_out (abfd
, &native
->u
.syment
, buf
);
1036 if (bfd_bwrite (buf
, symesz
, abfd
) != symesz
)
1038 bfd_release (abfd
, buf
);
1040 if (native
->u
.syment
.n_numaux
> 0)
1042 bfd_size_type auxesz
;
1045 auxesz
= bfd_coff_auxesz (abfd
);
1046 buf
= bfd_alloc (abfd
, auxesz
);
1049 for (j
= 0; j
< native
->u
.syment
.n_numaux
; j
++)
1051 BFD_ASSERT (! (native
+ j
+ 1)->is_sym
);
1052 bfd_coff_swap_aux_out (abfd
,
1053 &((native
+ j
+ 1)->u
.auxent
),
1054 type
, n_sclass
, (int) j
,
1055 native
->u
.syment
.n_numaux
,
1057 if (bfd_bwrite (buf
, auxesz
, abfd
) != auxesz
)
1060 bfd_release (abfd
, buf
);
1063 /* Store the index for use when we write out the relocs. */
1064 set_index (symbol
, *written
);
1066 *written
+= numaux
+ 1;
1070 /* Write out a symbol to a COFF file that does not come from a COFF
1071 file originally. This symbol may have been created by the linker,
1072 or we may be linking a non COFF file to a COFF file. */
1075 coff_write_alien_symbol (bfd
*abfd
,
1077 struct internal_syment
*isym
,
1079 bfd_size_type
*string_size_p
,
1080 asection
**debug_string_section_p
,
1081 bfd_size_type
*debug_string_size_p
)
1083 combined_entry_type
*native
;
1084 combined_entry_type dummy
[2];
1085 asection
*output_section
= symbol
->section
->output_section
1086 ? symbol
->section
->output_section
1088 struct bfd_link_info
*link_info
= coff_data (abfd
)->link_info
;
1091 if ((!link_info
|| link_info
->strip_discarded
)
1092 && !bfd_is_abs_section (symbol
->section
)
1093 && symbol
->section
->output_section
== bfd_abs_section_ptr
)
1097 memset (isym
, 0, sizeof (*isym
));
1101 native
->is_sym
= TRUE
;
1102 native
[1].is_sym
= FALSE
;
1103 native
->u
.syment
.n_type
= T_NULL
;
1104 native
->u
.syment
.n_flags
= 0;
1105 native
->u
.syment
.n_numaux
= 0;
1106 if (bfd_is_und_section (symbol
->section
))
1108 native
->u
.syment
.n_scnum
= N_UNDEF
;
1109 native
->u
.syment
.n_value
= symbol
->value
;
1111 else if (bfd_is_com_section (symbol
->section
))
1113 native
->u
.syment
.n_scnum
= N_UNDEF
;
1114 native
->u
.syment
.n_value
= symbol
->value
;
1116 else if (symbol
->flags
& BSF_FILE
)
1118 native
->u
.syment
.n_scnum
= N_DEBUG
;
1119 native
->u
.syment
.n_numaux
= 1;
1121 else if (symbol
->flags
& BSF_DEBUGGING
)
1123 /* There isn't much point to writing out a debugging symbol
1124 unless we are prepared to convert it into COFF debugging
1125 format. So, we just ignore them. We must clobber the symbol
1126 name to keep it from being put in the string table. */
1129 memset (isym
, 0, sizeof (*isym
));
1134 native
->u
.syment
.n_scnum
= output_section
->target_index
;
1135 native
->u
.syment
.n_value
= (symbol
->value
1136 + symbol
->section
->output_offset
);
1137 if (! obj_pe (abfd
))
1138 native
->u
.syment
.n_value
+= output_section
->vma
;
1140 /* Copy the any flags from the file header into the symbol.
1143 coff_symbol_type
*c
= coff_symbol_from (abfd
, symbol
);
1144 if (c
!= (coff_symbol_type
*) NULL
)
1145 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (&c
->symbol
)->flags
;
1149 native
->u
.syment
.n_type
= 0;
1150 if (symbol
->flags
& BSF_FILE
)
1151 native
->u
.syment
.n_sclass
= C_FILE
;
1152 else if (symbol
->flags
& BSF_LOCAL
)
1153 native
->u
.syment
.n_sclass
= C_STAT
;
1154 else if (symbol
->flags
& BSF_WEAK
)
1155 native
->u
.syment
.n_sclass
= obj_pe (abfd
) ? C_NT_WEAK
: C_WEAKEXT
;
1157 native
->u
.syment
.n_sclass
= C_EXT
;
1159 ret
= coff_write_symbol (abfd
, symbol
, native
, written
, string_size_p
,
1160 debug_string_section_p
, debug_string_size_p
);
1162 *isym
= native
->u
.syment
;
1166 /* Write a native symbol to a COFF file. */
1169 coff_write_native_symbol (bfd
*abfd
,
1170 coff_symbol_type
*symbol
,
1172 bfd_size_type
*string_size_p
,
1173 asection
**debug_string_section_p
,
1174 bfd_size_type
*debug_string_size_p
)
1176 combined_entry_type
*native
= symbol
->native
;
1177 alent
*lineno
= symbol
->lineno
;
1178 struct bfd_link_info
*link_info
= coff_data (abfd
)->link_info
;
1180 if ((!link_info
|| link_info
->strip_discarded
)
1181 && !bfd_is_abs_section (symbol
->symbol
.section
)
1182 && symbol
->symbol
.section
->output_section
== bfd_abs_section_ptr
)
1184 symbol
->symbol
.name
= "";
1188 BFD_ASSERT (native
->is_sym
);
1189 /* If this symbol has an associated line number, we must store the
1190 symbol index in the line number field. We also tag the auxent to
1191 point to the right place in the lineno table. */
1192 if (lineno
&& !symbol
->done_lineno
&& symbol
->symbol
.section
->owner
!= NULL
)
1194 unsigned int count
= 0;
1196 lineno
[count
].u
.offset
= *written
;
1197 if (native
->u
.syment
.n_numaux
)
1199 union internal_auxent
*a
= &((native
+ 1)->u
.auxent
);
1201 a
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1202 symbol
->symbol
.section
->output_section
->moving_line_filepos
;
1205 /* Count and relocate all other linenumbers. */
1207 while (lineno
[count
].line_number
!= 0)
1209 lineno
[count
].u
.offset
+=
1210 (symbol
->symbol
.section
->output_section
->vma
1211 + symbol
->symbol
.section
->output_offset
);
1214 symbol
->done_lineno
= TRUE
;
1216 if (! bfd_is_const_section (symbol
->symbol
.section
->output_section
))
1217 symbol
->symbol
.section
->output_section
->moving_line_filepos
+=
1218 count
* bfd_coff_linesz (abfd
);
1221 return coff_write_symbol (abfd
, &(symbol
->symbol
), native
, written
,
1222 string_size_p
, debug_string_section_p
,
1223 debug_string_size_p
);
1227 null_error_handler (const char * fmt ATTRIBUTE_UNUSED
, ...)
1231 /* Write out the COFF symbols. */
1234 coff_write_symbols (bfd
*abfd
)
1236 bfd_size_type string_size
;
1237 asection
*debug_string_section
;
1238 bfd_size_type debug_string_size
;
1240 unsigned int limit
= bfd_get_symcount (abfd
);
1241 bfd_vma written
= 0;
1245 debug_string_section
= NULL
;
1246 debug_string_size
= 0;
1248 /* If this target supports long section names, they must be put into
1249 the string table. This is supported by PE. This code must
1250 handle section names just as they are handled in
1251 coff_write_object_contents. */
1252 if (bfd_coff_long_section_names (abfd
))
1256 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1260 len
= strlen (o
->name
);
1262 string_size
+= len
+ 1;
1266 /* Seek to the right place. */
1267 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
1270 /* Output all the symbols we have. */
1272 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1274 asymbol
*symbol
= *p
;
1275 coff_symbol_type
*c_symbol
= coff_symbol_from (abfd
, symbol
);
1277 if (c_symbol
== (coff_symbol_type
*) NULL
1278 || c_symbol
->native
== (combined_entry_type
*) NULL
)
1280 if (!coff_write_alien_symbol (abfd
, symbol
, NULL
, &written
,
1281 &string_size
, &debug_string_section
,
1282 &debug_string_size
))
1287 if (coff_backend_info (abfd
)->_bfd_coff_classify_symbol
!= NULL
)
1289 bfd_error_handler_type current_error_handler
;
1290 enum coff_symbol_classification sym_class
;
1291 unsigned char *n_sclass
;
1293 /* Suppress error reporting by bfd_coff_classify_symbol.
1294 Error messages can be generated when we are processing a local
1295 symbol which has no associated section and we do not have to
1296 worry about this, all we need to know is that it is local. */
1297 current_error_handler
= bfd_set_error_handler (null_error_handler
);
1298 BFD_ASSERT (c_symbol
->native
->is_sym
);
1299 sym_class
= bfd_coff_classify_symbol (abfd
,
1300 &c_symbol
->native
->u
.syment
);
1301 (void) bfd_set_error_handler (current_error_handler
);
1303 n_sclass
= &c_symbol
->native
->u
.syment
.n_sclass
;
1305 /* If the symbol class has been changed (eg objcopy/ld script/etc)
1306 we cannot retain the existing sclass from the original symbol.
1307 Weak symbols only have one valid sclass, so just set it always.
1308 If it is not local class and should be, set it C_STAT.
1309 If it is global and not classified as global, or if it is
1310 weak (which is also classified as global), set it C_EXT. */
1312 if (symbol
->flags
& BSF_WEAK
)
1313 *n_sclass
= obj_pe (abfd
) ? C_NT_WEAK
: C_WEAKEXT
;
1314 else if (symbol
->flags
& BSF_LOCAL
&& sym_class
!= COFF_SYMBOL_LOCAL
)
1316 else if (symbol
->flags
& BSF_GLOBAL
1317 && (sym_class
!= COFF_SYMBOL_GLOBAL
1319 || *n_sclass
== C_NT_WEAK
1321 || *n_sclass
== C_WEAKEXT
))
1322 c_symbol
->native
->u
.syment
.n_sclass
= C_EXT
;
1325 if (!coff_write_native_symbol (abfd
, c_symbol
, &written
,
1326 &string_size
, &debug_string_section
,
1327 &debug_string_size
))
1332 obj_raw_syment_count (abfd
) = written
;
1334 /* Now write out strings. */
1335 if (string_size
!= 0)
1337 unsigned int size
= string_size
+ STRING_SIZE_SIZE
;
1338 bfd_byte buffer
[STRING_SIZE_SIZE
];
1340 #if STRING_SIZE_SIZE == 4
1341 H_PUT_32 (abfd
, size
, buffer
);
1343 #error Change H_PUT_32
1345 if (bfd_bwrite ((void *) buffer
, (bfd_size_type
) sizeof (buffer
), abfd
)
1349 /* Handle long section names. This code must handle section
1350 names just as they are handled in coff_write_object_contents. */
1351 if (bfd_coff_long_section_names (abfd
))
1355 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1359 len
= strlen (o
->name
);
1362 if (bfd_bwrite (o
->name
, (bfd_size_type
) (len
+ 1), abfd
)
1369 for (p
= abfd
->outsymbols
, i
= 0;
1374 size_t name_length
= strlen (q
->name
);
1375 coff_symbol_type
*c_symbol
= coff_symbol_from (abfd
, q
);
1378 /* Figure out whether the symbol name should go in the string
1379 table. Symbol names that are short enough are stored
1380 directly in the syment structure. File names permit a
1381 different, longer, length in the syment structure. On
1382 XCOFF, some symbol names are stored in the .debug section
1383 rather than in the string table. */
1385 if (c_symbol
== NULL
1386 || c_symbol
->native
== NULL
)
1387 /* This is not a COFF symbol, so it certainly is not a
1388 file name, nor does it go in the .debug section. */
1389 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1391 else if (! c_symbol
->native
->is_sym
)
1392 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1394 else if (bfd_coff_symname_in_debug (abfd
,
1395 &c_symbol
->native
->u
.syment
))
1396 /* This symbol name is in the XCOFF .debug section.
1397 Don't write it into the string table. */
1398 maxlen
= name_length
;
1400 else if (c_symbol
->native
->u
.syment
.n_sclass
== C_FILE
1401 && c_symbol
->native
->u
.syment
.n_numaux
> 0)
1403 if (bfd_coff_force_symnames_in_strings (abfd
))
1405 if (bfd_bwrite (".file", (bfd_size_type
) 6, abfd
) != 6)
1408 maxlen
= bfd_coff_filnmlen (abfd
);
1411 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1413 if (name_length
> maxlen
)
1415 if (bfd_bwrite ((void *) (q
->name
), (bfd_size_type
) name_length
+ 1,
1416 abfd
) != name_length
+ 1)
1423 /* We would normally not write anything here, but we'll write
1424 out 4 so that any stupid coff reader which tries to read the
1425 string table even when there isn't one won't croak. */
1426 unsigned int size
= STRING_SIZE_SIZE
;
1427 bfd_byte buffer
[STRING_SIZE_SIZE
];
1429 #if STRING_SIZE_SIZE == 4
1430 H_PUT_32 (abfd
, size
, buffer
);
1432 #error Change H_PUT_32
1434 if (bfd_bwrite ((void *) buffer
, (bfd_size_type
) STRING_SIZE_SIZE
, abfd
)
1435 != STRING_SIZE_SIZE
)
1439 /* Make sure the .debug section was created to be the correct size.
1440 We should create it ourselves on the fly, but we don't because
1441 BFD won't let us write to any section until we know how large all
1442 the sections are. We could still do it by making another pass
1443 over the symbols. FIXME. */
1444 BFD_ASSERT (debug_string_size
== 0
1445 || (debug_string_section
!= (asection
*) NULL
1446 && (BFD_ALIGN (debug_string_size
,
1447 1 << debug_string_section
->alignment_power
)
1448 == debug_string_section
->size
)));
1454 coff_write_linenumbers (bfd
*abfd
)
1457 bfd_size_type linesz
;
1460 linesz
= bfd_coff_linesz (abfd
);
1461 buff
= bfd_alloc (abfd
, linesz
);
1464 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
1466 if (s
->lineno_count
)
1468 asymbol
**q
= abfd
->outsymbols
;
1469 if (bfd_seek (abfd
, s
->line_filepos
, SEEK_SET
) != 0)
1471 /* Find all the linenumbers in this section. */
1475 if (p
->section
->output_section
== s
)
1478 BFD_SEND (bfd_asymbol_bfd (p
), _get_lineno
,
1479 (bfd_asymbol_bfd (p
), p
));
1482 /* Found a linenumber entry, output. */
1483 struct internal_lineno out
;
1485 memset ((void *) & out
, 0, sizeof (out
));
1487 out
.l_addr
.l_symndx
= l
->u
.offset
;
1488 bfd_coff_swap_lineno_out (abfd
, &out
, buff
);
1489 if (bfd_bwrite (buff
, (bfd_size_type
) linesz
, abfd
)
1493 while (l
->line_number
)
1495 out
.l_lnno
= l
->line_number
;
1496 out
.l_addr
.l_symndx
= l
->u
.offset
;
1497 bfd_coff_swap_lineno_out (abfd
, &out
, buff
);
1498 if (bfd_bwrite (buff
, (bfd_size_type
) linesz
, abfd
)
1509 bfd_release (abfd
, buff
);
1514 coff_get_lineno (bfd
*ignore_abfd ATTRIBUTE_UNUSED
, asymbol
*symbol
)
1516 return coffsymbol (symbol
)->lineno
;
1519 /* This function transforms the offsets into the symbol table into
1520 pointers to syments. */
1523 coff_pointerize_aux (bfd
*abfd
,
1524 combined_entry_type
*table_base
,
1525 combined_entry_type
*symbol
,
1526 unsigned int indaux
,
1527 combined_entry_type
*auxent
)
1529 unsigned int type
= symbol
->u
.syment
.n_type
;
1530 unsigned int n_sclass
= symbol
->u
.syment
.n_sclass
;
1532 BFD_ASSERT (symbol
->is_sym
);
1533 if (coff_backend_info (abfd
)->_bfd_coff_pointerize_aux_hook
)
1535 if ((*coff_backend_info (abfd
)->_bfd_coff_pointerize_aux_hook
)
1536 (abfd
, table_base
, symbol
, indaux
, auxent
))
1540 /* Don't bother if this is a file or a section. */
1541 if (n_sclass
== C_STAT
&& type
== T_NULL
)
1543 if (n_sclass
== C_FILE
)
1546 BFD_ASSERT (! auxent
->is_sym
);
1547 /* Otherwise patch up. */
1548 #define N_TMASK coff_data (abfd)->local_n_tmask
1549 #define N_BTSHFT coff_data (abfd)->local_n_btshft
1551 if ((ISFCN (type
) || ISTAG (n_sclass
) || n_sclass
== C_BLOCK
1552 || n_sclass
== C_FCN
)
1553 && auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
> 0)
1555 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
=
1556 table_base
+ auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
1557 auxent
->fix_end
= 1;
1559 /* A negative tagndx is meaningless, but the SCO 3.2v4 cc can
1560 generate one, so we must be careful to ignore it. */
1561 if (auxent
->u
.auxent
.x_sym
.x_tagndx
.l
> 0)
1563 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
=
1564 table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
;
1565 auxent
->fix_tag
= 1;
1569 /* Allocate space for the ".debug" section, and read it.
1570 We did not read the debug section until now, because
1571 we didn't want to go to the trouble until someone needed it. */
1574 build_debug_section (bfd
*abfd
, asection
** sect_return
)
1576 char *debug_section
;
1578 bfd_size_type sec_size
;
1580 asection
*sect
= bfd_get_section_by_name (abfd
, ".debug");
1584 bfd_set_error (bfd_error_no_debug_section
);
1588 sec_size
= sect
->size
;
1589 debug_section
= (char *) bfd_alloc (abfd
, sec_size
);
1590 if (debug_section
== NULL
)
1593 /* Seek to the beginning of the `.debug' section and read it.
1594 Save the current position first; it is needed by our caller.
1595 Then read debug section and reset the file pointer. */
1597 position
= bfd_tell (abfd
);
1598 if (bfd_seek (abfd
, sect
->filepos
, SEEK_SET
) != 0
1599 || bfd_bread (debug_section
, sec_size
, abfd
) != sec_size
1600 || bfd_seek (abfd
, position
, SEEK_SET
) != 0)
1603 * sect_return
= sect
;
1604 return debug_section
;
1607 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
1608 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
1609 be \0-terminated. */
1612 copy_name (bfd
*abfd
, char *name
, size_t maxlen
)
1617 for (len
= 0; len
< maxlen
; ++len
)
1618 if (name
[len
] == '\0')
1621 if ((newname
= (char *) bfd_alloc (abfd
, (bfd_size_type
) len
+ 1)) == NULL
)
1624 strncpy (newname
, name
, len
);
1625 newname
[len
] = '\0';
1629 /* Read in the external symbols. */
1632 _bfd_coff_get_external_symbols (bfd
*abfd
)
1634 bfd_size_type symesz
;
1638 if (obj_coff_external_syms (abfd
) != NULL
)
1641 symesz
= bfd_coff_symesz (abfd
);
1643 size
= obj_raw_syment_count (abfd
) * symesz
;
1647 syms
= bfd_malloc (size
);
1651 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
1652 || bfd_bread (syms
, size
, abfd
) != size
)
1659 obj_coff_external_syms (abfd
) = syms
;
1664 /* Read in the external strings. The strings are not loaded until
1665 they are needed. This is because we have no simple way of
1666 detecting a missing string table in an archive. If the strings
1667 are loaded then the STRINGS and STRINGS_LEN fields in the
1668 coff_tdata structure will be set. */
1671 _bfd_coff_read_string_table (bfd
*abfd
)
1673 char extstrsize
[STRING_SIZE_SIZE
];
1674 bfd_size_type strsize
;
1678 if (obj_coff_strings (abfd
) != NULL
)
1679 return obj_coff_strings (abfd
);
1681 if (obj_sym_filepos (abfd
) == 0)
1683 bfd_set_error (bfd_error_no_symbols
);
1687 pos
= obj_sym_filepos (abfd
);
1688 pos
+= obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
1689 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
1692 if (bfd_bread (extstrsize
, (bfd_size_type
) sizeof extstrsize
, abfd
)
1693 != sizeof extstrsize
)
1695 if (bfd_get_error () != bfd_error_file_truncated
)
1698 /* There is no string table. */
1699 strsize
= STRING_SIZE_SIZE
;
1703 #if STRING_SIZE_SIZE == 4
1704 strsize
= H_GET_32 (abfd
, extstrsize
);
1706 #error Change H_GET_32
1710 if (strsize
< STRING_SIZE_SIZE
)
1712 (*_bfd_error_handler
)
1713 (_("%B: bad string table size %lu"), abfd
, (unsigned long) strsize
);
1714 bfd_set_error (bfd_error_bad_value
);
1718 strings
= (char *) bfd_malloc (strsize
+ 1);
1719 if (strings
== NULL
)
1722 /* PR 17521 file: 079-54929-0.004.
1723 A corrupt file could contain an index that points into the first
1724 STRING_SIZE_SIZE bytes of the string table, so make sure that
1726 memset (strings
, 0, STRING_SIZE_SIZE
);
1728 if (bfd_bread (strings
+ STRING_SIZE_SIZE
, strsize
- STRING_SIZE_SIZE
, abfd
)
1729 != strsize
- STRING_SIZE_SIZE
)
1735 obj_coff_strings (abfd
) = strings
;
1736 obj_coff_strings_len (abfd
) = strsize
;
1737 /* Terminate the string table, just in case. */
1738 strings
[strsize
] = 0;
1742 /* Free up the external symbols and strings read from a COFF file. */
1745 _bfd_coff_free_symbols (bfd
*abfd
)
1747 if (obj_coff_external_syms (abfd
) != NULL
1748 && ! obj_coff_keep_syms (abfd
))
1750 free (obj_coff_external_syms (abfd
));
1751 obj_coff_external_syms (abfd
) = NULL
;
1753 if (obj_coff_strings (abfd
) != NULL
1754 && ! obj_coff_keep_strings (abfd
))
1756 free (obj_coff_strings (abfd
));
1757 obj_coff_strings (abfd
) = NULL
;
1758 obj_coff_strings_len (abfd
) = 0;
1763 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
1764 knit the symbol names into a normalized form. By normalized here I
1765 mean that all symbols have an n_offset pointer that points to a null-
1766 terminated string. */
1768 combined_entry_type
*
1769 coff_get_normalized_symtab (bfd
*abfd
)
1771 combined_entry_type
*internal
;
1772 combined_entry_type
*internal_ptr
;
1773 combined_entry_type
*symbol_ptr
;
1774 combined_entry_type
*internal_end
;
1778 const char *string_table
= NULL
;
1779 asection
* debug_sec
= NULL
;
1780 char *debug_sec_data
= NULL
;
1783 if (obj_raw_syments (abfd
) != NULL
)
1784 return obj_raw_syments (abfd
);
1786 if (! _bfd_coff_get_external_symbols (abfd
))
1789 size
= obj_raw_syment_count (abfd
) * sizeof (combined_entry_type
);
1790 internal
= (combined_entry_type
*) bfd_zalloc (abfd
, size
);
1791 if (internal
== NULL
&& size
!= 0)
1793 internal_end
= internal
+ obj_raw_syment_count (abfd
);
1795 raw_src
= (char *) obj_coff_external_syms (abfd
);
1797 /* Mark the end of the symbols. */
1798 symesz
= bfd_coff_symesz (abfd
);
1799 raw_end
= (char *) raw_src
+ obj_raw_syment_count (abfd
) * symesz
;
1801 /* FIXME SOMEDAY. A string table size of zero is very weird, but
1802 probably possible. If one shows up, it will probably kill us. */
1804 /* Swap all the raw entries. */
1805 for (internal_ptr
= internal
;
1807 raw_src
+= symesz
, internal_ptr
++)
1811 bfd_coff_swap_sym_in (abfd
, (void *) raw_src
,
1812 (void *) & internal_ptr
->u
.syment
);
1813 symbol_ptr
= internal_ptr
;
1814 internal_ptr
->is_sym
= TRUE
;
1816 /* PR 17512: file: 1353-1166-0.004. */
1817 if (symbol_ptr
->u
.syment
.n_sclass
== C_FILE
1818 && symbol_ptr
->u
.syment
.n_numaux
> 0
1819 && raw_src
+ symesz
+ symbol_ptr
->u
.syment
.n_numaux
1820 * sizeof (union internal_auxent
) >= raw_end
)
1822 bfd_release (abfd
, internal
);
1827 i
< symbol_ptr
->u
.syment
.n_numaux
;
1831 /* PR 17512: Prevent buffer overrun. */
1832 if (internal_ptr
>= internal_end
)
1834 bfd_release (abfd
, internal
);
1840 bfd_coff_swap_aux_in (abfd
, (void *) raw_src
,
1841 symbol_ptr
->u
.syment
.n_type
,
1842 symbol_ptr
->u
.syment
.n_sclass
,
1843 (int) i
, symbol_ptr
->u
.syment
.n_numaux
,
1844 &(internal_ptr
->u
.auxent
));
1846 internal_ptr
->is_sym
= FALSE
;
1847 coff_pointerize_aux (abfd
, internal
, symbol_ptr
, i
,
1852 /* Free the raw symbols, but not the strings (if we have them). */
1853 obj_coff_keep_strings (abfd
) = TRUE
;
1854 if (! _bfd_coff_free_symbols (abfd
))
1857 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
1860 BFD_ASSERT (internal_ptr
->is_sym
);
1862 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
1863 && internal_ptr
->u
.syment
.n_numaux
> 0)
1865 combined_entry_type
* aux
= internal_ptr
+ 1;
1867 /* Make a file symbol point to the name in the auxent, since
1868 the text ".file" is redundant. */
1869 BFD_ASSERT (! aux
->is_sym
);
1871 if (aux
->u
.auxent
.x_file
.x_n
.x_zeroes
== 0)
1873 /* The filename is a long one, point into the string table. */
1874 if (string_table
== NULL
)
1876 string_table
= _bfd_coff_read_string_table (abfd
);
1877 if (string_table
== NULL
)
1881 if ((bfd_size_type
)(aux
->u
.auxent
.x_file
.x_n
.x_offset
)
1882 >= obj_coff_strings_len (abfd
))
1883 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1885 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1886 (bfd_hostptr_t
) (string_table
+ (aux
->u
.auxent
.x_file
.x_n
.x_offset
));
1890 /* Ordinary short filename, put into memory anyway. The
1891 Microsoft PE tools sometimes store a filename in
1892 multiple AUX entries. */
1893 if (internal_ptr
->u
.syment
.n_numaux
> 1
1894 && coff_data (abfd
)->pe
)
1895 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1898 aux
->u
.auxent
.x_file
.x_fname
,
1899 internal_ptr
->u
.syment
.n_numaux
* symesz
);
1901 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1904 aux
->u
.auxent
.x_file
.x_fname
,
1905 (size_t) bfd_coff_filnmlen (abfd
)));
1910 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0)
1912 /* This is a "short" name. Make it long. */
1916 /* Find the length of this string without walking into memory
1918 for (i
= 0; i
< 8; ++i
)
1919 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0')
1922 newstring
= (char *) bfd_zalloc (abfd
, (bfd_size_type
) (i
+ 1));
1923 if (newstring
== NULL
)
1925 strncpy (newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
);
1926 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) newstring
;
1927 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1929 else if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
== 0)
1930 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) "";
1931 else if (!bfd_coff_symname_in_debug (abfd
, &internal_ptr
->u
.syment
))
1933 /* Long name already. Point symbol at the string in the
1935 if (string_table
== NULL
)
1937 string_table
= _bfd_coff_read_string_table (abfd
);
1938 if (string_table
== NULL
)
1941 if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
>= obj_coff_strings_len (abfd
)
1942 || string_table
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
< string_table
)
1943 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1945 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1948 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
));
1952 /* Long name in debug section. Very similar. */
1953 if (debug_sec_data
== NULL
)
1954 debug_sec_data
= build_debug_section (abfd
, & debug_sec
);
1955 if (debug_sec_data
!= NULL
)
1957 BFD_ASSERT (debug_sec
!= NULL
);
1958 /* PR binutils/17512: Catch out of range offsets into the debug data. */
1959 if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
> debug_sec
->size
1960 || debug_sec_data
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
< debug_sec_data
)
1961 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1963 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
)
1964 (debug_sec_data
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
1967 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) "";
1970 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
1973 obj_raw_syments (abfd
) = internal
;
1974 BFD_ASSERT (obj_raw_syment_count (abfd
)
1975 == (unsigned int) (internal_ptr
- internal
));
1981 coff_get_reloc_upper_bound (bfd
*abfd
, sec_ptr asect
)
1983 if (bfd_get_format (abfd
) != bfd_object
)
1985 bfd_set_error (bfd_error_invalid_operation
);
1988 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
1992 coff_make_empty_symbol (bfd
*abfd
)
1994 bfd_size_type amt
= sizeof (coff_symbol_type
);
1995 coff_symbol_type
*new_symbol
= (coff_symbol_type
*) bfd_zalloc (abfd
, amt
);
1997 if (new_symbol
== NULL
)
1999 new_symbol
->symbol
.section
= 0;
2000 new_symbol
->native
= NULL
;
2001 new_symbol
->lineno
= NULL
;
2002 new_symbol
->done_lineno
= FALSE
;
2003 new_symbol
->symbol
.the_bfd
= abfd
;
2005 return & new_symbol
->symbol
;
2008 /* Make a debugging symbol. */
2011 coff_bfd_make_debug_symbol (bfd
*abfd
,
2012 void * ptr ATTRIBUTE_UNUSED
,
2013 unsigned long sz ATTRIBUTE_UNUSED
)
2015 bfd_size_type amt
= sizeof (coff_symbol_type
);
2016 coff_symbol_type
*new_symbol
= (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
2018 if (new_symbol
== NULL
)
2020 /* @@ The 10 is a guess at a plausible maximum number of aux entries
2021 (but shouldn't be a constant). */
2022 amt
= sizeof (combined_entry_type
) * 10;
2023 new_symbol
->native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
2024 if (!new_symbol
->native
)
2026 new_symbol
->native
->is_sym
= TRUE
;
2027 new_symbol
->symbol
.section
= bfd_abs_section_ptr
;
2028 new_symbol
->symbol
.flags
= BSF_DEBUGGING
;
2029 new_symbol
->lineno
= NULL
;
2030 new_symbol
->done_lineno
= FALSE
;
2031 new_symbol
->symbol
.the_bfd
= abfd
;
2033 return & new_symbol
->symbol
;
2037 coff_get_symbol_info (bfd
*abfd
, asymbol
*symbol
, symbol_info
*ret
)
2039 bfd_symbol_info (symbol
, ret
);
2041 if (coffsymbol (symbol
)->native
!= NULL
2042 && coffsymbol (symbol
)->native
->fix_value
2043 && coffsymbol (symbol
)->native
->is_sym
)
2044 ret
->value
= coffsymbol (symbol
)->native
->u
.syment
.n_value
-
2045 (bfd_hostptr_t
) obj_raw_syments (abfd
);
2048 /* Return the COFF syment for a symbol. */
2051 bfd_coff_get_syment (bfd
*abfd
,
2053 struct internal_syment
*psyment
)
2055 coff_symbol_type
*csym
;
2057 csym
= coff_symbol_from (abfd
, symbol
);
2058 if (csym
== NULL
|| csym
->native
== NULL
2059 || ! csym
->native
->is_sym
)
2061 bfd_set_error (bfd_error_invalid_operation
);
2065 *psyment
= csym
->native
->u
.syment
;
2067 if (csym
->native
->fix_value
)
2068 psyment
->n_value
= psyment
->n_value
-
2069 (bfd_hostptr_t
) obj_raw_syments (abfd
);
2071 /* FIXME: We should handle fix_line here. */
2076 /* Return the COFF auxent for a symbol. */
2079 bfd_coff_get_auxent (bfd
*abfd
,
2082 union internal_auxent
*pauxent
)
2084 coff_symbol_type
*csym
;
2085 combined_entry_type
*ent
;
2087 csym
= coff_symbol_from (abfd
, symbol
);
2090 || csym
->native
== NULL
2091 || ! csym
->native
->is_sym
2092 || indx
>= csym
->native
->u
.syment
.n_numaux
)
2094 bfd_set_error (bfd_error_invalid_operation
);
2098 ent
= csym
->native
+ indx
+ 1;
2100 BFD_ASSERT (! ent
->is_sym
);
2101 *pauxent
= ent
->u
.auxent
;
2104 pauxent
->x_sym
.x_tagndx
.l
=
2105 ((combined_entry_type
*) pauxent
->x_sym
.x_tagndx
.p
2106 - obj_raw_syments (abfd
));
2109 pauxent
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
2110 ((combined_entry_type
*) pauxent
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2111 - obj_raw_syments (abfd
));
2113 if (ent
->fix_scnlen
)
2114 pauxent
->x_csect
.x_scnlen
.l
=
2115 ((combined_entry_type
*) pauxent
->x_csect
.x_scnlen
.p
2116 - obj_raw_syments (abfd
));
2121 /* Print out information about COFF symbol. */
2124 coff_print_symbol (bfd
*abfd
,
2127 bfd_print_symbol_type how
)
2129 FILE * file
= (FILE *) filep
;
2133 case bfd_print_symbol_name
:
2134 fprintf (file
, "%s", symbol
->name
);
2137 case bfd_print_symbol_more
:
2138 fprintf (file
, "coff %s %s",
2139 coffsymbol (symbol
)->native
? "n" : "g",
2140 coffsymbol (symbol
)->lineno
? "l" : " ");
2143 case bfd_print_symbol_all
:
2144 if (coffsymbol (symbol
)->native
)
2148 combined_entry_type
*combined
= coffsymbol (symbol
)->native
;
2149 combined_entry_type
*root
= obj_raw_syments (abfd
);
2150 struct lineno_cache_entry
*l
= coffsymbol (symbol
)->lineno
;
2152 fprintf (file
, "[%3ld]", (long) (combined
- root
));
2154 /* PR 17512: file: 079-33786-0.001:0.1. */
2155 if (combined
< obj_raw_syments (abfd
)
2156 || combined
>= obj_raw_syments (abfd
) + obj_raw_syment_count (abfd
))
2158 fprintf (file
, _("<corrupt info> %s"), symbol
->name
);
2162 BFD_ASSERT (combined
->is_sym
);
2163 if (! combined
->fix_value
)
2164 val
= (bfd_vma
) combined
->u
.syment
.n_value
;
2166 val
= combined
->u
.syment
.n_value
- (bfd_hostptr_t
) root
;
2168 fprintf (file
, "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x",
2169 combined
->u
.syment
.n_scnum
,
2170 combined
->u
.syment
.n_flags
,
2171 combined
->u
.syment
.n_type
,
2172 combined
->u
.syment
.n_sclass
,
2173 combined
->u
.syment
.n_numaux
);
2174 bfd_fprintf_vma (abfd
, file
, val
);
2175 fprintf (file
, " %s", symbol
->name
);
2177 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
2179 combined_entry_type
*auxp
= combined
+ aux
+ 1;
2182 BFD_ASSERT (! auxp
->is_sym
);
2184 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.p
- root
;
2186 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.l
;
2188 fprintf (file
, "\n");
2190 if (bfd_coff_print_aux (abfd
, file
, root
, combined
, auxp
, aux
))
2193 switch (combined
->u
.syment
.n_sclass
)
2196 fprintf (file
, "File ");
2200 if (combined
->u
.syment
.n_type
== T_NULL
)
2201 /* Probably a section symbol ? */
2203 fprintf (file
, "AUX scnlen 0x%lx nreloc %d nlnno %d",
2204 (unsigned long) auxp
->u
.auxent
.x_scn
.x_scnlen
,
2205 auxp
->u
.auxent
.x_scn
.x_nreloc
,
2206 auxp
->u
.auxent
.x_scn
.x_nlinno
);
2207 if (auxp
->u
.auxent
.x_scn
.x_checksum
!= 0
2208 || auxp
->u
.auxent
.x_scn
.x_associated
!= 0
2209 || auxp
->u
.auxent
.x_scn
.x_comdat
!= 0)
2210 fprintf (file
, " checksum 0x%lx assoc %d comdat %d",
2211 auxp
->u
.auxent
.x_scn
.x_checksum
,
2212 auxp
->u
.auxent
.x_scn
.x_associated
,
2213 auxp
->u
.auxent
.x_scn
.x_comdat
);
2216 /* Otherwise fall through. */
2219 if (ISFCN (combined
->u
.syment
.n_type
))
2224 next
= (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2227 next
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2228 llnos
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
2230 "AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld",
2232 (unsigned long) auxp
->u
.auxent
.x_sym
.x_misc
.x_fsize
,
2236 /* Otherwise fall through. */
2238 fprintf (file
, "AUX lnno %d size 0x%x tagndx %ld",
2239 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
2240 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
,
2243 fprintf (file
, " endndx %ld",
2245 (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2253 fprintf (file
, "\n%s :", l
->u
.sym
->name
);
2255 while (l
->line_number
)
2257 if (l
->line_number
> 0)
2259 fprintf (file
, "\n%4d : ", l
->line_number
);
2260 bfd_fprintf_vma (abfd
, file
, l
->u
.offset
+ symbol
->section
->vma
);
2268 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
2269 fprintf (file
, " %-5s %s %s %s",
2270 symbol
->section
->name
,
2271 coffsymbol (symbol
)->native
? "n" : "g",
2272 coffsymbol (symbol
)->lineno
? "l" : " ",
2278 /* Return whether a symbol name implies a local symbol. In COFF,
2279 local symbols generally start with ``.L''. Most targets use this
2280 function for the is_local_label_name entry point, but some may
2284 _bfd_coff_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
2287 return name
[0] == '.' && name
[1] == 'L';
2290 /* Provided a BFD, a section and an offset (in bytes, not octets) into the
2291 section, calculate and return the name of the source file and the line
2292 nearest to the wanted location. */
2295 coff_find_nearest_line_with_names (bfd
*abfd
,
2299 const char **filename_ptr
,
2300 const char **functionname_ptr
,
2301 unsigned int *line_ptr
,
2302 const struct dwarf_debug_section
*debug_sections
)
2306 unsigned int line_base
;
2307 coff_data_type
*cof
= coff_data (abfd
);
2308 /* Run through the raw syments if available. */
2309 combined_entry_type
*p
;
2310 combined_entry_type
*pend
;
2312 struct coff_section_tdata
*sec_data
;
2315 /* Before looking through the symbol table, try to use a .stab
2316 section to find the information. */
2317 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2318 &found
, filename_ptr
,
2319 functionname_ptr
, line_ptr
,
2320 &coff_data(abfd
)->line_info
))
2326 /* Also try examining DWARF2 debugging information. */
2327 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
2328 filename_ptr
, functionname_ptr
,
2329 line_ptr
, NULL
, debug_sections
, 0,
2330 &coff_data(abfd
)->dwarf2_find_line_info
))
2334 *functionname_ptr
= 0;
2337 /* Don't try and find line numbers in a non coff file. */
2338 if (!bfd_family_coff (abfd
))
2344 /* Find the first C_FILE symbol. */
2345 p
= cof
->raw_syments
;
2349 pend
= p
+ cof
->raw_syment_count
;
2352 BFD_ASSERT (p
->is_sym
);
2353 if (p
->u
.syment
.n_sclass
== C_FILE
)
2355 p
+= 1 + p
->u
.syment
.n_numaux
;
2363 /* Look through the C_FILE symbols to find the best one. */
2364 sec_vma
= bfd_get_section_vma (abfd
, section
);
2365 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2366 maxdiff
= (bfd_vma
) 0 - (bfd_vma
) 1;
2370 combined_entry_type
*p2
;
2372 for (p2
= p
+ 1 + p
->u
.syment
.n_numaux
;
2374 p2
+= 1 + p2
->u
.syment
.n_numaux
)
2376 BFD_ASSERT (p2
->is_sym
);
2377 if (p2
->u
.syment
.n_scnum
> 0
2379 == coff_section_from_bfd_index (abfd
,
2380 p2
->u
.syment
.n_scnum
)))
2382 if (p2
->u
.syment
.n_sclass
== C_FILE
)
2391 file_addr
= (bfd_vma
) p2
->u
.syment
.n_value
;
2392 /* PR 11512: Include the section address of the function name symbol. */
2393 if (p2
->u
.syment
.n_scnum
> 0)
2394 file_addr
+= coff_section_from_bfd_index (abfd
,
2395 p2
->u
.syment
.n_scnum
)->vma
;
2396 /* We use <= MAXDIFF here so that if we get a zero length
2397 file, we actually use the next file entry. */
2399 && offset
+ sec_vma
>= file_addr
2400 && offset
+ sec_vma
- file_addr
<= maxdiff
)
2402 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2403 maxdiff
= offset
+ sec_vma
- p2
->u
.syment
.n_value
;
2406 /* Avoid endless loops on erroneous files by ensuring that
2407 we always move forward in the file. */
2408 if (p
>= cof
->raw_syments
+ p
->u
.syment
.n_value
)
2411 p
= cof
->raw_syments
+ p
->u
.syment
.n_value
;
2412 if (p
> pend
|| p
->u
.syment
.n_sclass
!= C_FILE
)
2417 /* Now wander though the raw linenumbers of the section. */
2418 /* If we have been called on this section before, and the offset we
2419 want is further down then we can prime the lookup loop. */
2420 sec_data
= coff_section_data (abfd
, section
);
2421 if (sec_data
!= NULL
2423 && offset
>= sec_data
->offset
)
2426 *functionname_ptr
= sec_data
->function
;
2427 line_base
= sec_data
->line_base
;
2435 if (section
->lineno
!= NULL
)
2437 bfd_vma last_value
= 0;
2439 l
= §ion
->lineno
[i
];
2441 for (; i
< section
->lineno_count
; i
++)
2443 if (l
->line_number
== 0)
2445 /* Get the symbol this line number points at. */
2446 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
2447 if (coff
->symbol
.value
> offset
)
2449 *functionname_ptr
= coff
->symbol
.name
;
2450 last_value
= coff
->symbol
.value
;
2453 combined_entry_type
*s
= coff
->native
;
2455 BFD_ASSERT (s
->is_sym
);
2456 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2458 /* In XCOFF a debugging symbol can follow the
2460 if (s
->u
.syment
.n_scnum
== N_DEBUG
)
2461 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2463 /* S should now point to the .bf of the function. */
2464 if (s
->u
.syment
.n_numaux
)
2466 /* The linenumber is stored in the auxent. */
2467 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
2469 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
2470 *line_ptr
= line_base
;
2476 if (l
->u
.offset
> offset
)
2478 *line_ptr
= l
->line_number
+ line_base
- 1;
2483 /* If we fell off the end of the loop, then assume that this
2484 symbol has no line number info. Otherwise, symbols with no
2485 line number info get reported with the line number of the
2486 last line of the last symbol which does have line number
2487 info. We use 0x100 as a slop to account for cases where the
2488 last line has executable code. */
2489 if (i
>= section
->lineno_count
2491 && offset
- last_value
> 0x100)
2493 *functionname_ptr
= NULL
;
2498 /* Cache the results for the next call. */
2499 if (sec_data
== NULL
&& section
->owner
== abfd
)
2501 amt
= sizeof (struct coff_section_tdata
);
2502 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
2503 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2505 if (sec_data
!= NULL
)
2507 sec_data
->offset
= offset
;
2508 sec_data
->i
= i
- 1;
2509 sec_data
->function
= *functionname_ptr
;
2510 sec_data
->line_base
= line_base
;
2517 coff_find_nearest_line (bfd
*abfd
,
2521 const char **filename_ptr
,
2522 const char **functionname_ptr
,
2523 unsigned int *line_ptr
,
2524 unsigned int *discriminator_ptr
)
2526 if (discriminator_ptr
)
2527 *discriminator_ptr
= 0;
2528 return coff_find_nearest_line_with_names (abfd
, symbols
, section
, offset
,
2529 filename_ptr
, functionname_ptr
,
2530 line_ptr
, dwarf_debug_sections
);
2534 coff_find_inliner_info (bfd
*abfd
,
2535 const char **filename_ptr
,
2536 const char **functionname_ptr
,
2537 unsigned int *line_ptr
)
2541 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
2542 functionname_ptr
, line_ptr
,
2543 &coff_data(abfd
)->dwarf2_find_line_info
);
2548 coff_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
2552 if (!info
->relocatable
)
2553 size
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
2555 size
= bfd_coff_filhsz (abfd
);
2557 size
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
2561 /* Change the class of a coff symbol held by BFD. */
2564 bfd_coff_set_symbol_class (bfd
* abfd
,
2566 unsigned int symbol_class
)
2568 coff_symbol_type
* csym
;
2570 csym
= coff_symbol_from (abfd
, symbol
);
2573 bfd_set_error (bfd_error_invalid_operation
);
2576 else if (csym
->native
== NULL
)
2578 /* This is an alien symbol which no native coff backend data.
2579 We cheat here by creating a fake native entry for it and
2580 then filling in the class. This code is based on that in
2581 coff_write_alien_symbol(). */
2583 combined_entry_type
* native
;
2584 bfd_size_type amt
= sizeof (* native
);
2586 native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
2590 native
->is_sym
= TRUE
;
2591 native
->u
.syment
.n_type
= T_NULL
;
2592 native
->u
.syment
.n_sclass
= symbol_class
;
2594 if (bfd_is_und_section (symbol
->section
))
2596 native
->u
.syment
.n_scnum
= N_UNDEF
;
2597 native
->u
.syment
.n_value
= symbol
->value
;
2599 else if (bfd_is_com_section (symbol
->section
))
2601 native
->u
.syment
.n_scnum
= N_UNDEF
;
2602 native
->u
.syment
.n_value
= symbol
->value
;
2606 native
->u
.syment
.n_scnum
=
2607 symbol
->section
->output_section
->target_index
;
2608 native
->u
.syment
.n_value
= (symbol
->value
2609 + symbol
->section
->output_offset
);
2610 if (! obj_pe (abfd
))
2611 native
->u
.syment
.n_value
+= symbol
->section
->output_section
->vma
;
2613 /* Copy the any flags from the file header into the symbol.
2615 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (& csym
->symbol
)->flags
;
2618 csym
->native
= native
;
2621 csym
->native
->u
.syment
.n_sclass
= symbol_class
;
2626 struct coff_comdat_info
*
2627 bfd_coff_get_comdat_section (bfd
*abfd
, struct bfd_section
*sec
)
2629 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
2630 && coff_section_data (abfd
, sec
) != NULL
)
2631 return coff_section_data (abfd
, sec
)->comdat
;
2637 _bfd_coff_section_already_linked (bfd
*abfd
,
2639 struct bfd_link_info
*info
)
2642 const char *name
, *key
;
2643 struct bfd_section_already_linked
*l
;
2644 struct bfd_section_already_linked_hash_entry
*already_linked_list
;
2645 struct coff_comdat_info
*s_comdat
;
2648 if ((flags
& SEC_LINK_ONCE
) == 0)
2651 /* The COFF backend linker doesn't support group sections. */
2652 if ((flags
& SEC_GROUP
) != 0)
2655 name
= bfd_get_section_name (abfd
, sec
);
2656 s_comdat
= bfd_coff_get_comdat_section (abfd
, sec
);
2658 if (s_comdat
!= NULL
)
2659 key
= s_comdat
->name
;
2662 if (CONST_STRNEQ (name
, ".gnu.linkonce.")
2663 && (key
= strchr (name
+ sizeof (".gnu.linkonce.") - 1, '.')) != NULL
)
2666 /* FIXME: gcc as of 2011-09 emits sections like .text$<key>,
2667 .xdata$<key> and .pdata$<key> only the first of which has a
2668 comdat key. Should these all match the LTO IR key? */
2672 already_linked_list
= bfd_section_already_linked_table_lookup (key
);
2674 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
2676 struct coff_comdat_info
*l_comdat
;
2678 l_comdat
= bfd_coff_get_comdat_section (l
->sec
->owner
, l
->sec
);
2680 /* The section names must match, and both sections must be
2681 comdat and have the same comdat name, or both sections must
2682 be non-comdat. LTO IR plugin sections are an exception. They
2683 are always named .gnu.linkonce.t.<key> (<key> is some string)
2684 and match any comdat section with comdat name of <key>, and
2685 any linkonce section with the same suffix, ie.
2686 .gnu.linkonce.*.<key>. */
2687 if (((s_comdat
!= NULL
) == (l_comdat
!= NULL
)
2688 && strcmp (name
, l
->sec
->name
) == 0)
2689 || (l
->sec
->owner
->flags
& BFD_PLUGIN
) != 0)
2691 /* The section has already been linked. See if we should
2693 return _bfd_handle_already_linked (sec
, l
, info
);
2697 /* This is the first section with this name. Record it. */
2698 if (!bfd_section_already_linked_table_insert (already_linked_list
, sec
))
2699 info
->callbacks
->einfo (_("%F%P: already_linked_table: %E\n"));