1 /* Support for the generic parts of COFF, for BFD.
2 Copyright (C) 1990-2015 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 /* PR 17910: Only check for string overflow if the length has been set.
472 Some DLLs, eg those produced by Visual Studio, may not set the length field. */
473 if (obj_coff_strings_len (abfd
) > 0
474 && sym
->_n
._n_n
._n_offset
>= obj_coff_strings_len (abfd
))
476 return strings
+ sym
->_n
._n_n
._n_offset
;
480 /* Read in and swap the relocs. This returns a buffer holding the
481 relocs for section SEC in file ABFD. If CACHE is TRUE and
482 INTERNAL_RELOCS is NULL, the relocs read in will be saved in case
483 the function is called again. If EXTERNAL_RELOCS is not NULL, it
484 is a buffer large enough to hold the unswapped relocs. If
485 INTERNAL_RELOCS is not NULL, it is a buffer large enough to hold
486 the swapped relocs. If REQUIRE_INTERNAL is TRUE, then the return
487 value must be INTERNAL_RELOCS. The function returns NULL on error. */
489 struct internal_reloc
*
490 _bfd_coff_read_internal_relocs (bfd
*abfd
,
493 bfd_byte
*external_relocs
,
494 bfd_boolean require_internal
,
495 struct internal_reloc
*internal_relocs
)
498 bfd_byte
*free_external
= NULL
;
499 struct internal_reloc
*free_internal
= NULL
;
502 struct internal_reloc
*irel
;
505 if (sec
->reloc_count
== 0)
506 return internal_relocs
; /* Nothing to do. */
508 if (coff_section_data (abfd
, sec
) != NULL
509 && coff_section_data (abfd
, sec
)->relocs
!= NULL
)
511 if (! require_internal
)
512 return coff_section_data (abfd
, sec
)->relocs
;
513 memcpy (internal_relocs
, coff_section_data (abfd
, sec
)->relocs
,
514 sec
->reloc_count
* sizeof (struct internal_reloc
));
515 return internal_relocs
;
518 relsz
= bfd_coff_relsz (abfd
);
520 amt
= sec
->reloc_count
* relsz
;
521 if (external_relocs
== NULL
)
523 free_external
= (bfd_byte
*) bfd_malloc (amt
);
524 if (free_external
== NULL
)
526 external_relocs
= free_external
;
529 if (bfd_seek (abfd
, sec
->rel_filepos
, SEEK_SET
) != 0
530 || bfd_bread (external_relocs
, amt
, abfd
) != amt
)
533 if (internal_relocs
== NULL
)
535 amt
= sec
->reloc_count
;
536 amt
*= sizeof (struct internal_reloc
);
537 free_internal
= (struct internal_reloc
*) bfd_malloc (amt
);
538 if (free_internal
== NULL
)
540 internal_relocs
= free_internal
;
543 /* Swap in the relocs. */
544 erel
= external_relocs
;
545 erel_end
= erel
+ relsz
* sec
->reloc_count
;
546 irel
= internal_relocs
;
547 for (; erel
< erel_end
; erel
+= relsz
, irel
++)
548 bfd_coff_swap_reloc_in (abfd
, (void *) erel
, (void *) irel
);
550 if (free_external
!= NULL
)
552 free (free_external
);
553 free_external
= NULL
;
556 if (cache
&& free_internal
!= NULL
)
558 if (coff_section_data (abfd
, sec
) == NULL
)
560 amt
= sizeof (struct coff_section_tdata
);
561 sec
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
562 if (sec
->used_by_bfd
== NULL
)
564 coff_section_data (abfd
, sec
)->contents
= NULL
;
566 coff_section_data (abfd
, sec
)->relocs
= free_internal
;
569 return internal_relocs
;
572 if (free_external
!= NULL
)
573 free (free_external
);
574 if (free_internal
!= NULL
)
575 free (free_internal
);
579 /* Set lineno_count for the output sections of a COFF file. */
582 coff_count_linenumbers (bfd
*abfd
)
584 unsigned int limit
= bfd_get_symcount (abfd
);
592 /* This may be from the backend linker, in which case the
593 lineno_count in the sections is correct. */
594 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
595 total
+= s
->lineno_count
;
599 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
600 BFD_ASSERT (s
->lineno_count
== 0);
602 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
604 asymbol
*q_maybe
= *p
;
606 if (bfd_family_coff (bfd_asymbol_bfd (q_maybe
)))
608 coff_symbol_type
*q
= coffsymbol (q_maybe
);
610 /* The AIX 4.1 compiler can sometimes generate line numbers
611 attached to debugging symbols. We try to simply ignore
613 if (q
->lineno
!= NULL
614 && q
->symbol
.section
->owner
!= NULL
)
616 /* This symbol has line numbers. Increment the owning
617 section's linenumber count. */
618 alent
*l
= q
->lineno
;
622 asection
* sec
= q
->symbol
.section
->output_section
;
624 /* Do not try to update fields in read-only sections. */
625 if (! bfd_is_const_section (sec
))
626 sec
->lineno_count
++;
631 while (l
->line_number
!= 0);
640 fixup_symbol_value (bfd
*abfd
,
641 coff_symbol_type
*coff_symbol_ptr
,
642 struct internal_syment
*syment
)
644 /* Normalize the symbol flags. */
645 if (coff_symbol_ptr
->symbol
.section
646 && bfd_is_com_section (coff_symbol_ptr
->symbol
.section
))
648 /* A common symbol is undefined with a value. */
649 syment
->n_scnum
= N_UNDEF
;
650 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
652 else if ((coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
) != 0
653 && (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING_RELOC
) == 0)
655 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
657 else if (bfd_is_und_section (coff_symbol_ptr
->symbol
.section
))
659 syment
->n_scnum
= N_UNDEF
;
662 /* FIXME: Do we need to handle the absolute section here? */
665 if (coff_symbol_ptr
->symbol
.section
)
668 coff_symbol_ptr
->symbol
.section
->output_section
->target_index
;
670 syment
->n_value
= (coff_symbol_ptr
->symbol
.value
671 + coff_symbol_ptr
->symbol
.section
->output_offset
);
674 syment
->n_value
+= (syment
->n_sclass
== C_STATLAB
)
675 ? coff_symbol_ptr
->symbol
.section
->output_section
->lma
676 : coff_symbol_ptr
->symbol
.section
->output_section
->vma
;
682 /* This can happen, but I don't know why yet (steve@cygnus.com) */
683 syment
->n_scnum
= N_ABS
;
684 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
689 /* Run through all the symbols in the symbol table and work out what
690 their indexes into the symbol table will be when output.
692 Coff requires that each C_FILE symbol points to the next one in the
693 chain, and that the last one points to the first external symbol. We
697 coff_renumber_symbols (bfd
*bfd_ptr
, int *first_undef
)
699 unsigned int symbol_count
= bfd_get_symcount (bfd_ptr
);
700 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
701 unsigned int native_index
= 0;
702 struct internal_syment
*last_file
= NULL
;
703 unsigned int symbol_index
;
705 /* COFF demands that undefined symbols come after all other symbols.
706 Since we don't need to impose this extra knowledge on all our
707 client programs, deal with that here. Sort the symbol table;
708 just move the undefined symbols to the end, leaving the rest
709 alone. The O'Reilly book says that defined global symbols come
710 at the end before the undefined symbols, so we do that here as
712 /* @@ Do we have some condition we could test for, so we don't always
713 have to do this? I don't think relocatability is quite right, but
714 I'm not certain. [raeburn:19920508.1711EST] */
720 amt
= sizeof (asymbol
*) * ((bfd_size_type
) symbol_count
+ 1);
721 newsyms
= (asymbol
**) bfd_alloc (bfd_ptr
, amt
);
724 bfd_ptr
->outsymbols
= newsyms
;
725 for (i
= 0; i
< symbol_count
; i
++)
726 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) != 0
727 || (!bfd_is_und_section (symbol_ptr_ptr
[i
]->section
)
728 && !bfd_is_com_section (symbol_ptr_ptr
[i
]->section
)
729 && ((symbol_ptr_ptr
[i
]->flags
& BSF_FUNCTION
) != 0
730 || ((symbol_ptr_ptr
[i
]->flags
& (BSF_GLOBAL
| BSF_WEAK
))
732 *newsyms
++ = symbol_ptr_ptr
[i
];
734 for (i
= 0; i
< symbol_count
; i
++)
735 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) == 0
736 && !bfd_is_und_section (symbol_ptr_ptr
[i
]->section
)
737 && (bfd_is_com_section (symbol_ptr_ptr
[i
]->section
)
738 || ((symbol_ptr_ptr
[i
]->flags
& BSF_FUNCTION
) == 0
739 && ((symbol_ptr_ptr
[i
]->flags
& (BSF_GLOBAL
| BSF_WEAK
))
741 *newsyms
++ = symbol_ptr_ptr
[i
];
743 *first_undef
= newsyms
- bfd_ptr
->outsymbols
;
745 for (i
= 0; i
< symbol_count
; i
++)
746 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) == 0
747 && bfd_is_und_section (symbol_ptr_ptr
[i
]->section
))
748 *newsyms
++ = symbol_ptr_ptr
[i
];
749 *newsyms
= (asymbol
*) NULL
;
750 symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
753 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
755 coff_symbol_type
*coff_symbol_ptr
;
757 coff_symbol_ptr
= coff_symbol_from (symbol_ptr_ptr
[symbol_index
]);
758 symbol_ptr_ptr
[symbol_index
]->udata
.i
= symbol_index
;
759 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
)
761 combined_entry_type
*s
= coff_symbol_ptr
->native
;
764 BFD_ASSERT (s
->is_sym
);
765 if (s
->u
.syment
.n_sclass
== C_FILE
)
767 if (last_file
!= NULL
)
768 last_file
->n_value
= native_index
;
769 last_file
= &(s
->u
.syment
);
772 /* Modify the symbol values according to their section and
774 fixup_symbol_value (bfd_ptr
, coff_symbol_ptr
, &(s
->u
.syment
));
776 for (i
= 0; i
< s
->u
.syment
.n_numaux
+ 1; i
++)
777 s
[i
].offset
= native_index
++;
783 obj_conv_table_size (bfd_ptr
) = native_index
;
788 /* Run thorough the symbol table again, and fix it so that all
789 pointers to entries are changed to the entries' index in the output
793 coff_mangle_symbols (bfd
*bfd_ptr
)
795 unsigned int symbol_count
= bfd_get_symcount (bfd_ptr
);
796 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
797 unsigned int symbol_index
;
799 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
801 coff_symbol_type
*coff_symbol_ptr
;
803 coff_symbol_ptr
= coff_symbol_from (symbol_ptr_ptr
[symbol_index
]);
804 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
)
807 combined_entry_type
*s
= coff_symbol_ptr
->native
;
809 BFD_ASSERT (s
->is_sym
);
812 /* FIXME: We should use a union here. */
813 s
->u
.syment
.n_value
=
814 (bfd_hostptr_t
) ((combined_entry_type
*)
815 ((bfd_hostptr_t
) s
->u
.syment
.n_value
))->offset
;
820 /* The value is the offset into the line number entries
821 for the symbol's section. On output, the symbol's
822 section should be N_DEBUG. */
823 s
->u
.syment
.n_value
=
824 (coff_symbol_ptr
->symbol
.section
->output_section
->line_filepos
825 + s
->u
.syment
.n_value
* bfd_coff_linesz (bfd_ptr
));
826 coff_symbol_ptr
->symbol
.section
=
827 coff_section_from_bfd_index (bfd_ptr
, N_DEBUG
);
828 BFD_ASSERT (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
);
830 for (i
= 0; i
< s
->u
.syment
.n_numaux
; i
++)
832 combined_entry_type
*a
= s
+ i
+ 1;
834 BFD_ASSERT (! a
->is_sym
);
837 a
->u
.auxent
.x_sym
.x_tagndx
.l
=
838 a
->u
.auxent
.x_sym
.x_tagndx
.p
->offset
;
843 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
844 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
->offset
;
849 a
->u
.auxent
.x_csect
.x_scnlen
.l
=
850 a
->u
.auxent
.x_csect
.x_scnlen
.p
->offset
;
859 coff_fix_symbol_name (bfd
*abfd
,
861 combined_entry_type
*native
,
862 bfd_size_type
*string_size_p
,
863 asection
**debug_string_section_p
,
864 bfd_size_type
*debug_string_size_p
)
866 unsigned int name_length
;
867 union internal_auxent
*auxent
;
868 char *name
= (char *) (symbol
->name
);
872 /* COFF symbols always have names, so we'll make one up. */
873 symbol
->name
= "strange";
874 name
= (char *) symbol
->name
;
876 name_length
= strlen (name
);
878 BFD_ASSERT (native
->is_sym
);
879 if (native
->u
.syment
.n_sclass
== C_FILE
880 && native
->u
.syment
.n_numaux
> 0)
882 unsigned int filnmlen
;
884 if (bfd_coff_force_symnames_in_strings (abfd
))
886 native
->u
.syment
._n
._n_n
._n_offset
=
887 (*string_size_p
+ STRING_SIZE_SIZE
);
888 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
889 *string_size_p
+= 6; /* strlen(".file") + 1 */
892 strncpy (native
->u
.syment
._n
._n_name
, ".file", SYMNMLEN
);
894 BFD_ASSERT (! (native
+ 1)->is_sym
);
895 auxent
= &(native
+ 1)->u
.auxent
;
897 filnmlen
= bfd_coff_filnmlen (abfd
);
899 if (bfd_coff_long_filenames (abfd
))
901 if (name_length
<= filnmlen
)
902 strncpy (auxent
->x_file
.x_fname
, name
, filnmlen
);
905 auxent
->x_file
.x_n
.x_offset
= *string_size_p
+ STRING_SIZE_SIZE
;
906 auxent
->x_file
.x_n
.x_zeroes
= 0;
907 *string_size_p
+= name_length
+ 1;
912 strncpy (auxent
->x_file
.x_fname
, name
, filnmlen
);
913 if (name_length
> filnmlen
)
914 name
[filnmlen
] = '\0';
919 if (name_length
<= SYMNMLEN
&& !bfd_coff_force_symnames_in_strings (abfd
))
920 /* This name will fit into the symbol neatly. */
921 strncpy (native
->u
.syment
._n
._n_name
, symbol
->name
, SYMNMLEN
);
923 else if (!bfd_coff_symname_in_debug (abfd
, &native
->u
.syment
))
925 native
->u
.syment
._n
._n_n
._n_offset
= (*string_size_p
927 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
928 *string_size_p
+= name_length
+ 1;
934 int prefix_len
= bfd_coff_debug_string_prefix_length (abfd
);
936 /* This name should be written into the .debug section. For
937 some reason each name is preceded by a two byte length
938 and also followed by a null byte. FIXME: We assume that
939 the .debug section has already been created, and that it
941 if (*debug_string_section_p
== (asection
*) NULL
)
942 *debug_string_section_p
= bfd_get_section_by_name (abfd
, ".debug");
943 filepos
= bfd_tell (abfd
);
945 bfd_put_32 (abfd
, (bfd_vma
) (name_length
+ 1), buf
);
947 bfd_put_16 (abfd
, (bfd_vma
) (name_length
+ 1), buf
);
949 if (!bfd_set_section_contents (abfd
,
950 *debug_string_section_p
,
952 (file_ptr
) *debug_string_size_p
,
953 (bfd_size_type
) prefix_len
)
954 || !bfd_set_section_contents (abfd
,
955 *debug_string_section_p
,
956 (void *) symbol
->name
,
957 (file_ptr
) (*debug_string_size_p
959 (bfd_size_type
) name_length
+ 1))
961 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
963 native
->u
.syment
._n
._n_n
._n_offset
=
964 *debug_string_size_p
+ prefix_len
;
965 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
966 *debug_string_size_p
+= name_length
+ 1 + prefix_len
;
971 /* We need to keep track of the symbol index so that when we write out
972 the relocs we can get the index for a symbol. This method is a
975 #define set_index(symbol, idx) ((symbol)->udata.i = (idx))
977 /* Write a symbol out to a COFF file. */
980 coff_write_symbol (bfd
*abfd
,
982 combined_entry_type
*native
,
984 bfd_size_type
*string_size_p
,
985 asection
**debug_string_section_p
,
986 bfd_size_type
*debug_string_size_p
)
988 unsigned int numaux
= native
->u
.syment
.n_numaux
;
989 int type
= native
->u
.syment
.n_type
;
990 int n_sclass
= (int) native
->u
.syment
.n_sclass
;
991 asection
*output_section
= symbol
->section
->output_section
992 ? symbol
->section
->output_section
995 bfd_size_type symesz
;
997 BFD_ASSERT (native
->is_sym
);
999 if (native
->u
.syment
.n_sclass
== C_FILE
)
1000 symbol
->flags
|= BSF_DEBUGGING
;
1002 if (symbol
->flags
& BSF_DEBUGGING
1003 && bfd_is_abs_section (symbol
->section
))
1004 native
->u
.syment
.n_scnum
= N_DEBUG
;
1006 else if (bfd_is_abs_section (symbol
->section
))
1007 native
->u
.syment
.n_scnum
= N_ABS
;
1009 else if (bfd_is_und_section (symbol
->section
))
1010 native
->u
.syment
.n_scnum
= N_UNDEF
;
1013 native
->u
.syment
.n_scnum
=
1014 output_section
->target_index
;
1016 coff_fix_symbol_name (abfd
, symbol
, native
, string_size_p
,
1017 debug_string_section_p
, debug_string_size_p
);
1019 symesz
= bfd_coff_symesz (abfd
);
1020 buf
= bfd_alloc (abfd
, symesz
);
1023 bfd_coff_swap_sym_out (abfd
, &native
->u
.syment
, buf
);
1024 if (bfd_bwrite (buf
, symesz
, abfd
) != symesz
)
1026 bfd_release (abfd
, buf
);
1028 if (native
->u
.syment
.n_numaux
> 0)
1030 bfd_size_type auxesz
;
1033 auxesz
= bfd_coff_auxesz (abfd
);
1034 buf
= bfd_alloc (abfd
, auxesz
);
1037 for (j
= 0; j
< native
->u
.syment
.n_numaux
; j
++)
1039 BFD_ASSERT (! (native
+ j
+ 1)->is_sym
);
1040 bfd_coff_swap_aux_out (abfd
,
1041 &((native
+ j
+ 1)->u
.auxent
),
1042 type
, n_sclass
, (int) j
,
1043 native
->u
.syment
.n_numaux
,
1045 if (bfd_bwrite (buf
, auxesz
, abfd
) != auxesz
)
1048 bfd_release (abfd
, buf
);
1051 /* Store the index for use when we write out the relocs. */
1052 set_index (symbol
, *written
);
1054 *written
+= numaux
+ 1;
1058 /* Write out a symbol to a COFF file that does not come from a COFF
1059 file originally. This symbol may have been created by the linker,
1060 or we may be linking a non COFF file to a COFF file. */
1063 coff_write_alien_symbol (bfd
*abfd
,
1065 struct internal_syment
*isym
,
1067 bfd_size_type
*string_size_p
,
1068 asection
**debug_string_section_p
,
1069 bfd_size_type
*debug_string_size_p
)
1071 combined_entry_type
*native
;
1072 combined_entry_type dummy
[2];
1073 asection
*output_section
= symbol
->section
->output_section
1074 ? symbol
->section
->output_section
1076 struct bfd_link_info
*link_info
= coff_data (abfd
)->link_info
;
1079 if ((!link_info
|| link_info
->strip_discarded
)
1080 && !bfd_is_abs_section (symbol
->section
)
1081 && symbol
->section
->output_section
== bfd_abs_section_ptr
)
1085 memset (isym
, 0, sizeof (*isym
));
1089 native
->is_sym
= TRUE
;
1090 native
[1].is_sym
= FALSE
;
1091 native
->u
.syment
.n_type
= T_NULL
;
1092 native
->u
.syment
.n_flags
= 0;
1093 native
->u
.syment
.n_numaux
= 0;
1094 if (bfd_is_und_section (symbol
->section
))
1096 native
->u
.syment
.n_scnum
= N_UNDEF
;
1097 native
->u
.syment
.n_value
= symbol
->value
;
1099 else if (bfd_is_com_section (symbol
->section
))
1101 native
->u
.syment
.n_scnum
= N_UNDEF
;
1102 native
->u
.syment
.n_value
= symbol
->value
;
1104 else if (symbol
->flags
& BSF_FILE
)
1106 native
->u
.syment
.n_scnum
= N_DEBUG
;
1107 native
->u
.syment
.n_numaux
= 1;
1109 else if (symbol
->flags
& BSF_DEBUGGING
)
1111 /* There isn't much point to writing out a debugging symbol
1112 unless we are prepared to convert it into COFF debugging
1113 format. So, we just ignore them. We must clobber the symbol
1114 name to keep it from being put in the string table. */
1117 memset (isym
, 0, sizeof (*isym
));
1122 native
->u
.syment
.n_scnum
= output_section
->target_index
;
1123 native
->u
.syment
.n_value
= (symbol
->value
1124 + symbol
->section
->output_offset
);
1125 if (! obj_pe (abfd
))
1126 native
->u
.syment
.n_value
+= output_section
->vma
;
1128 /* Copy the any flags from the file header into the symbol.
1131 coff_symbol_type
*c
= coff_symbol_from (symbol
);
1132 if (c
!= (coff_symbol_type
*) NULL
)
1133 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (&c
->symbol
)->flags
;
1137 native
->u
.syment
.n_type
= 0;
1138 if (symbol
->flags
& BSF_FILE
)
1139 native
->u
.syment
.n_sclass
= C_FILE
;
1140 else if (symbol
->flags
& BSF_LOCAL
)
1141 native
->u
.syment
.n_sclass
= C_STAT
;
1142 else if (symbol
->flags
& BSF_WEAK
)
1143 native
->u
.syment
.n_sclass
= obj_pe (abfd
) ? C_NT_WEAK
: C_WEAKEXT
;
1145 native
->u
.syment
.n_sclass
= C_EXT
;
1147 ret
= coff_write_symbol (abfd
, symbol
, native
, written
, string_size_p
,
1148 debug_string_section_p
, debug_string_size_p
);
1150 *isym
= native
->u
.syment
;
1154 /* Write a native symbol to a COFF file. */
1157 coff_write_native_symbol (bfd
*abfd
,
1158 coff_symbol_type
*symbol
,
1160 bfd_size_type
*string_size_p
,
1161 asection
**debug_string_section_p
,
1162 bfd_size_type
*debug_string_size_p
)
1164 combined_entry_type
*native
= symbol
->native
;
1165 alent
*lineno
= symbol
->lineno
;
1166 struct bfd_link_info
*link_info
= coff_data (abfd
)->link_info
;
1168 if ((!link_info
|| link_info
->strip_discarded
)
1169 && !bfd_is_abs_section (symbol
->symbol
.section
)
1170 && symbol
->symbol
.section
->output_section
== bfd_abs_section_ptr
)
1172 symbol
->symbol
.name
= "";
1176 BFD_ASSERT (native
->is_sym
);
1177 /* If this symbol has an associated line number, we must store the
1178 symbol index in the line number field. We also tag the auxent to
1179 point to the right place in the lineno table. */
1180 if (lineno
&& !symbol
->done_lineno
&& symbol
->symbol
.section
->owner
!= NULL
)
1182 unsigned int count
= 0;
1184 lineno
[count
].u
.offset
= *written
;
1185 if (native
->u
.syment
.n_numaux
)
1187 union internal_auxent
*a
= &((native
+ 1)->u
.auxent
);
1189 a
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1190 symbol
->symbol
.section
->output_section
->moving_line_filepos
;
1193 /* Count and relocate all other linenumbers. */
1195 while (lineno
[count
].line_number
!= 0)
1197 lineno
[count
].u
.offset
+=
1198 (symbol
->symbol
.section
->output_section
->vma
1199 + symbol
->symbol
.section
->output_offset
);
1202 symbol
->done_lineno
= TRUE
;
1204 if (! bfd_is_const_section (symbol
->symbol
.section
->output_section
))
1205 symbol
->symbol
.section
->output_section
->moving_line_filepos
+=
1206 count
* bfd_coff_linesz (abfd
);
1209 return coff_write_symbol (abfd
, &(symbol
->symbol
), native
, written
,
1210 string_size_p
, debug_string_section_p
,
1211 debug_string_size_p
);
1215 null_error_handler (const char * fmt ATTRIBUTE_UNUSED
, ...)
1219 /* Write out the COFF symbols. */
1222 coff_write_symbols (bfd
*abfd
)
1224 bfd_size_type string_size
;
1225 asection
*debug_string_section
;
1226 bfd_size_type debug_string_size
;
1228 unsigned int limit
= bfd_get_symcount (abfd
);
1229 bfd_vma written
= 0;
1233 debug_string_section
= NULL
;
1234 debug_string_size
= 0;
1236 /* If this target supports long section names, they must be put into
1237 the string table. This is supported by PE. This code must
1238 handle section names just as they are handled in
1239 coff_write_object_contents. */
1240 if (bfd_coff_long_section_names (abfd
))
1244 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1248 len
= strlen (o
->name
);
1250 string_size
+= len
+ 1;
1254 /* Seek to the right place. */
1255 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
1258 /* Output all the symbols we have. */
1260 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1262 asymbol
*symbol
= *p
;
1263 coff_symbol_type
*c_symbol
= coff_symbol_from (symbol
);
1265 if (c_symbol
== (coff_symbol_type
*) NULL
1266 || c_symbol
->native
== (combined_entry_type
*) NULL
)
1268 if (!coff_write_alien_symbol (abfd
, symbol
, NULL
, &written
,
1269 &string_size
, &debug_string_section
,
1270 &debug_string_size
))
1275 if (coff_backend_info (abfd
)->_bfd_coff_classify_symbol
!= NULL
)
1277 bfd_error_handler_type current_error_handler
;
1278 enum coff_symbol_classification sym_class
;
1279 unsigned char *n_sclass
;
1281 /* Suppress error reporting by bfd_coff_classify_symbol.
1282 Error messages can be generated when we are processing a local
1283 symbol which has no associated section and we do not have to
1284 worry about this, all we need to know is that it is local. */
1285 current_error_handler
= bfd_set_error_handler (null_error_handler
);
1286 BFD_ASSERT (c_symbol
->native
->is_sym
);
1287 sym_class
= bfd_coff_classify_symbol (abfd
,
1288 &c_symbol
->native
->u
.syment
);
1289 (void) bfd_set_error_handler (current_error_handler
);
1291 n_sclass
= &c_symbol
->native
->u
.syment
.n_sclass
;
1293 /* If the symbol class has been changed (eg objcopy/ld script/etc)
1294 we cannot retain the existing sclass from the original symbol.
1295 Weak symbols only have one valid sclass, so just set it always.
1296 If it is not local class and should be, set it C_STAT.
1297 If it is global and not classified as global, or if it is
1298 weak (which is also classified as global), set it C_EXT. */
1300 if (symbol
->flags
& BSF_WEAK
)
1301 *n_sclass
= obj_pe (abfd
) ? C_NT_WEAK
: C_WEAKEXT
;
1302 else if (symbol
->flags
& BSF_LOCAL
&& sym_class
!= COFF_SYMBOL_LOCAL
)
1304 else if (symbol
->flags
& BSF_GLOBAL
1305 && (sym_class
!= COFF_SYMBOL_GLOBAL
1307 || *n_sclass
== C_NT_WEAK
1309 || *n_sclass
== C_WEAKEXT
))
1310 c_symbol
->native
->u
.syment
.n_sclass
= C_EXT
;
1313 if (!coff_write_native_symbol (abfd
, c_symbol
, &written
,
1314 &string_size
, &debug_string_section
,
1315 &debug_string_size
))
1320 obj_raw_syment_count (abfd
) = written
;
1322 /* Now write out strings. */
1323 if (string_size
!= 0)
1325 unsigned int size
= string_size
+ STRING_SIZE_SIZE
;
1326 bfd_byte buffer
[STRING_SIZE_SIZE
];
1328 #if STRING_SIZE_SIZE == 4
1329 H_PUT_32 (abfd
, size
, buffer
);
1331 #error Change H_PUT_32
1333 if (bfd_bwrite ((void *) buffer
, (bfd_size_type
) sizeof (buffer
), abfd
)
1337 /* Handle long section names. This code must handle section
1338 names just as they are handled in coff_write_object_contents. */
1339 if (bfd_coff_long_section_names (abfd
))
1343 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1347 len
= strlen (o
->name
);
1350 if (bfd_bwrite (o
->name
, (bfd_size_type
) (len
+ 1), abfd
)
1357 for (p
= abfd
->outsymbols
, i
= 0;
1362 size_t name_length
= strlen (q
->name
);
1363 coff_symbol_type
*c_symbol
= coff_symbol_from (q
);
1366 /* Figure out whether the symbol name should go in the string
1367 table. Symbol names that are short enough are stored
1368 directly in the syment structure. File names permit a
1369 different, longer, length in the syment structure. On
1370 XCOFF, some symbol names are stored in the .debug section
1371 rather than in the string table. */
1373 if (c_symbol
== NULL
1374 || c_symbol
->native
== NULL
)
1375 /* This is not a COFF symbol, so it certainly is not a
1376 file name, nor does it go in the .debug section. */
1377 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1379 else if (! c_symbol
->native
->is_sym
)
1380 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1382 else if (bfd_coff_symname_in_debug (abfd
,
1383 &c_symbol
->native
->u
.syment
))
1384 /* This symbol name is in the XCOFF .debug section.
1385 Don't write it into the string table. */
1386 maxlen
= name_length
;
1388 else if (c_symbol
->native
->u
.syment
.n_sclass
== C_FILE
1389 && c_symbol
->native
->u
.syment
.n_numaux
> 0)
1391 if (bfd_coff_force_symnames_in_strings (abfd
))
1393 if (bfd_bwrite (".file", (bfd_size_type
) 6, abfd
) != 6)
1396 maxlen
= bfd_coff_filnmlen (abfd
);
1399 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1401 if (name_length
> maxlen
)
1403 if (bfd_bwrite ((void *) (q
->name
), (bfd_size_type
) name_length
+ 1,
1404 abfd
) != name_length
+ 1)
1411 /* We would normally not write anything here, but we'll write
1412 out 4 so that any stupid coff reader which tries to read the
1413 string table even when there isn't one won't croak. */
1414 unsigned int size
= STRING_SIZE_SIZE
;
1415 bfd_byte buffer
[STRING_SIZE_SIZE
];
1417 #if STRING_SIZE_SIZE == 4
1418 H_PUT_32 (abfd
, size
, buffer
);
1420 #error Change H_PUT_32
1422 if (bfd_bwrite ((void *) buffer
, (bfd_size_type
) STRING_SIZE_SIZE
, abfd
)
1423 != STRING_SIZE_SIZE
)
1427 /* Make sure the .debug section was created to be the correct size.
1428 We should create it ourselves on the fly, but we don't because
1429 BFD won't let us write to any section until we know how large all
1430 the sections are. We could still do it by making another pass
1431 over the symbols. FIXME. */
1432 BFD_ASSERT (debug_string_size
== 0
1433 || (debug_string_section
!= (asection
*) NULL
1434 && (BFD_ALIGN (debug_string_size
,
1435 1 << debug_string_section
->alignment_power
)
1436 == debug_string_section
->size
)));
1442 coff_write_linenumbers (bfd
*abfd
)
1445 bfd_size_type linesz
;
1448 linesz
= bfd_coff_linesz (abfd
);
1449 buff
= bfd_alloc (abfd
, linesz
);
1452 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
1454 if (s
->lineno_count
)
1456 asymbol
**q
= abfd
->outsymbols
;
1457 if (bfd_seek (abfd
, s
->line_filepos
, SEEK_SET
) != 0)
1459 /* Find all the linenumbers in this section. */
1463 if (p
->section
->output_section
== s
)
1466 BFD_SEND (bfd_asymbol_bfd (p
), _get_lineno
,
1467 (bfd_asymbol_bfd (p
), p
));
1470 /* Found a linenumber entry, output. */
1471 struct internal_lineno out
;
1473 memset ((void *) & out
, 0, sizeof (out
));
1475 out
.l_addr
.l_symndx
= l
->u
.offset
;
1476 bfd_coff_swap_lineno_out (abfd
, &out
, buff
);
1477 if (bfd_bwrite (buff
, (bfd_size_type
) linesz
, abfd
)
1481 while (l
->line_number
)
1483 out
.l_lnno
= l
->line_number
;
1484 out
.l_addr
.l_symndx
= l
->u
.offset
;
1485 bfd_coff_swap_lineno_out (abfd
, &out
, buff
);
1486 if (bfd_bwrite (buff
, (bfd_size_type
) linesz
, abfd
)
1497 bfd_release (abfd
, buff
);
1502 coff_get_lineno (bfd
*ignore_abfd ATTRIBUTE_UNUSED
, asymbol
*symbol
)
1504 return coffsymbol (symbol
)->lineno
;
1507 /* This function transforms the offsets into the symbol table into
1508 pointers to syments. */
1511 coff_pointerize_aux (bfd
*abfd
,
1512 combined_entry_type
*table_base
,
1513 combined_entry_type
*symbol
,
1514 unsigned int indaux
,
1515 combined_entry_type
*auxent
)
1517 unsigned int type
= symbol
->u
.syment
.n_type
;
1518 unsigned int n_sclass
= symbol
->u
.syment
.n_sclass
;
1520 BFD_ASSERT (symbol
->is_sym
);
1521 if (coff_backend_info (abfd
)->_bfd_coff_pointerize_aux_hook
)
1523 if ((*coff_backend_info (abfd
)->_bfd_coff_pointerize_aux_hook
)
1524 (abfd
, table_base
, symbol
, indaux
, auxent
))
1528 /* Don't bother if this is a file or a section. */
1529 if (n_sclass
== C_STAT
&& type
== T_NULL
)
1531 if (n_sclass
== C_FILE
)
1534 BFD_ASSERT (! auxent
->is_sym
);
1535 /* Otherwise patch up. */
1536 #define N_TMASK coff_data (abfd)->local_n_tmask
1537 #define N_BTSHFT coff_data (abfd)->local_n_btshft
1539 if ((ISFCN (type
) || ISTAG (n_sclass
) || n_sclass
== C_BLOCK
1540 || n_sclass
== C_FCN
)
1541 && auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
> 0)
1543 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
=
1544 table_base
+ auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
1545 auxent
->fix_end
= 1;
1547 /* A negative tagndx is meaningless, but the SCO 3.2v4 cc can
1548 generate one, so we must be careful to ignore it. */
1549 if (auxent
->u
.auxent
.x_sym
.x_tagndx
.l
> 0)
1551 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
=
1552 table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
;
1553 auxent
->fix_tag
= 1;
1557 /* Allocate space for the ".debug" section, and read it.
1558 We did not read the debug section until now, because
1559 we didn't want to go to the trouble until someone needed it. */
1562 build_debug_section (bfd
*abfd
, asection
** sect_return
)
1564 char *debug_section
;
1566 bfd_size_type sec_size
;
1568 asection
*sect
= bfd_get_section_by_name (abfd
, ".debug");
1572 bfd_set_error (bfd_error_no_debug_section
);
1576 sec_size
= sect
->size
;
1577 debug_section
= (char *) bfd_alloc (abfd
, sec_size
);
1578 if (debug_section
== NULL
)
1581 /* Seek to the beginning of the `.debug' section and read it.
1582 Save the current position first; it is needed by our caller.
1583 Then read debug section and reset the file pointer. */
1585 position
= bfd_tell (abfd
);
1586 if (bfd_seek (abfd
, sect
->filepos
, SEEK_SET
) != 0
1587 || bfd_bread (debug_section
, sec_size
, abfd
) != sec_size
1588 || bfd_seek (abfd
, position
, SEEK_SET
) != 0)
1591 * sect_return
= sect
;
1592 return debug_section
;
1595 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
1596 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
1597 be \0-terminated. */
1600 copy_name (bfd
*abfd
, char *name
, size_t maxlen
)
1605 for (len
= 0; len
< maxlen
; ++len
)
1606 if (name
[len
] == '\0')
1609 if ((newname
= (char *) bfd_alloc (abfd
, (bfd_size_type
) len
+ 1)) == NULL
)
1612 strncpy (newname
, name
, len
);
1613 newname
[len
] = '\0';
1617 /* Read in the external symbols. */
1620 _bfd_coff_get_external_symbols (bfd
*abfd
)
1622 bfd_size_type symesz
;
1626 if (obj_coff_external_syms (abfd
) != NULL
)
1629 symesz
= bfd_coff_symesz (abfd
);
1631 size
= obj_raw_syment_count (abfd
) * symesz
;
1635 syms
= bfd_malloc (size
);
1639 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
1640 || bfd_bread (syms
, size
, abfd
) != size
)
1647 obj_coff_external_syms (abfd
) = syms
;
1652 /* Read in the external strings. The strings are not loaded until
1653 they are needed. This is because we have no simple way of
1654 detecting a missing string table in an archive. If the strings
1655 are loaded then the STRINGS and STRINGS_LEN fields in the
1656 coff_tdata structure will be set. */
1659 _bfd_coff_read_string_table (bfd
*abfd
)
1661 char extstrsize
[STRING_SIZE_SIZE
];
1662 bfd_size_type strsize
;
1666 if (obj_coff_strings (abfd
) != NULL
)
1667 return obj_coff_strings (abfd
);
1669 if (obj_sym_filepos (abfd
) == 0)
1671 bfd_set_error (bfd_error_no_symbols
);
1675 pos
= obj_sym_filepos (abfd
);
1676 pos
+= obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
1677 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
1680 if (bfd_bread (extstrsize
, (bfd_size_type
) sizeof extstrsize
, abfd
)
1681 != sizeof extstrsize
)
1683 if (bfd_get_error () != bfd_error_file_truncated
)
1686 /* There is no string table. */
1687 strsize
= STRING_SIZE_SIZE
;
1691 #if STRING_SIZE_SIZE == 4
1692 strsize
= H_GET_32 (abfd
, extstrsize
);
1694 #error Change H_GET_32
1698 if (strsize
< STRING_SIZE_SIZE
)
1700 (*_bfd_error_handler
)
1701 (_("%B: bad string table size %lu"), abfd
, (unsigned long) strsize
);
1702 bfd_set_error (bfd_error_bad_value
);
1706 strings
= (char *) bfd_malloc (strsize
+ 1);
1707 if (strings
== NULL
)
1710 /* PR 17521 file: 079-54929-0.004.
1711 A corrupt file could contain an index that points into the first
1712 STRING_SIZE_SIZE bytes of the string table, so make sure that
1714 memset (strings
, 0, STRING_SIZE_SIZE
);
1716 if (bfd_bread (strings
+ STRING_SIZE_SIZE
, strsize
- STRING_SIZE_SIZE
, abfd
)
1717 != strsize
- STRING_SIZE_SIZE
)
1723 obj_coff_strings (abfd
) = strings
;
1724 obj_coff_strings_len (abfd
) = strsize
;
1725 /* Terminate the string table, just in case. */
1726 strings
[strsize
] = 0;
1730 /* Free up the external symbols and strings read from a COFF file. */
1733 _bfd_coff_free_symbols (bfd
*abfd
)
1735 if (obj_coff_external_syms (abfd
) != NULL
1736 && ! obj_coff_keep_syms (abfd
))
1738 free (obj_coff_external_syms (abfd
));
1739 obj_coff_external_syms (abfd
) = NULL
;
1741 if (obj_coff_strings (abfd
) != NULL
1742 && ! obj_coff_keep_strings (abfd
))
1744 free (obj_coff_strings (abfd
));
1745 obj_coff_strings (abfd
) = NULL
;
1746 obj_coff_strings_len (abfd
) = 0;
1751 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
1752 knit the symbol names into a normalized form. By normalized here I
1753 mean that all symbols have an n_offset pointer that points to a null-
1754 terminated string. */
1756 combined_entry_type
*
1757 coff_get_normalized_symtab (bfd
*abfd
)
1759 combined_entry_type
*internal
;
1760 combined_entry_type
*internal_ptr
;
1761 combined_entry_type
*symbol_ptr
;
1762 combined_entry_type
*internal_end
;
1766 const char *string_table
= NULL
;
1767 asection
* debug_sec
= NULL
;
1768 char *debug_sec_data
= NULL
;
1771 if (obj_raw_syments (abfd
) != NULL
)
1772 return obj_raw_syments (abfd
);
1774 if (! _bfd_coff_get_external_symbols (abfd
))
1777 size
= obj_raw_syment_count (abfd
) * sizeof (combined_entry_type
);
1778 internal
= (combined_entry_type
*) bfd_zalloc (abfd
, size
);
1779 if (internal
== NULL
&& size
!= 0)
1781 internal_end
= internal
+ obj_raw_syment_count (abfd
);
1783 raw_src
= (char *) obj_coff_external_syms (abfd
);
1785 /* Mark the end of the symbols. */
1786 symesz
= bfd_coff_symesz (abfd
);
1787 raw_end
= (char *) raw_src
+ obj_raw_syment_count (abfd
) * symesz
;
1789 /* FIXME SOMEDAY. A string table size of zero is very weird, but
1790 probably possible. If one shows up, it will probably kill us. */
1792 /* Swap all the raw entries. */
1793 for (internal_ptr
= internal
;
1795 raw_src
+= symesz
, internal_ptr
++)
1799 bfd_coff_swap_sym_in (abfd
, (void *) raw_src
,
1800 (void *) & internal_ptr
->u
.syment
);
1801 symbol_ptr
= internal_ptr
;
1802 internal_ptr
->is_sym
= TRUE
;
1804 /* PR 17512: file: 1353-1166-0.004. */
1805 if (symbol_ptr
->u
.syment
.n_sclass
== C_FILE
1806 && symbol_ptr
->u
.syment
.n_numaux
> 0
1807 && raw_src
+ symesz
+ symbol_ptr
->u
.syment
.n_numaux
1808 * sizeof (union internal_auxent
) >= raw_end
)
1810 bfd_release (abfd
, internal
);
1815 i
< symbol_ptr
->u
.syment
.n_numaux
;
1819 /* PR 17512: Prevent buffer overrun. */
1820 if (internal_ptr
>= internal_end
)
1822 bfd_release (abfd
, internal
);
1828 bfd_coff_swap_aux_in (abfd
, (void *) raw_src
,
1829 symbol_ptr
->u
.syment
.n_type
,
1830 symbol_ptr
->u
.syment
.n_sclass
,
1831 (int) i
, symbol_ptr
->u
.syment
.n_numaux
,
1832 &(internal_ptr
->u
.auxent
));
1834 internal_ptr
->is_sym
= FALSE
;
1835 coff_pointerize_aux (abfd
, internal
, symbol_ptr
, i
,
1840 /* Free the raw symbols, but not the strings (if we have them). */
1841 obj_coff_keep_strings (abfd
) = TRUE
;
1842 if (! _bfd_coff_free_symbols (abfd
))
1845 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
1848 BFD_ASSERT (internal_ptr
->is_sym
);
1850 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
1851 && internal_ptr
->u
.syment
.n_numaux
> 0)
1853 combined_entry_type
* aux
= internal_ptr
+ 1;
1855 /* Make a file symbol point to the name in the auxent, since
1856 the text ".file" is redundant. */
1857 BFD_ASSERT (! aux
->is_sym
);
1859 if (aux
->u
.auxent
.x_file
.x_n
.x_zeroes
== 0)
1861 /* The filename is a long one, point into the string table. */
1862 if (string_table
== NULL
)
1864 string_table
= _bfd_coff_read_string_table (abfd
);
1865 if (string_table
== NULL
)
1869 if ((bfd_size_type
)(aux
->u
.auxent
.x_file
.x_n
.x_offset
)
1870 >= obj_coff_strings_len (abfd
))
1871 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1873 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1874 (bfd_hostptr_t
) (string_table
+ (aux
->u
.auxent
.x_file
.x_n
.x_offset
));
1878 /* Ordinary short filename, put into memory anyway. The
1879 Microsoft PE tools sometimes store a filename in
1880 multiple AUX entries. */
1881 if (internal_ptr
->u
.syment
.n_numaux
> 1
1882 && coff_data (abfd
)->pe
)
1883 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1886 aux
->u
.auxent
.x_file
.x_fname
,
1887 internal_ptr
->u
.syment
.n_numaux
* symesz
);
1889 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1892 aux
->u
.auxent
.x_file
.x_fname
,
1893 (size_t) bfd_coff_filnmlen (abfd
)));
1898 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0)
1900 /* This is a "short" name. Make it long. */
1904 /* Find the length of this string without walking into memory
1906 for (i
= 0; i
< 8; ++i
)
1907 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0')
1910 newstring
= (char *) bfd_zalloc (abfd
, (bfd_size_type
) (i
+ 1));
1911 if (newstring
== NULL
)
1913 strncpy (newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
);
1914 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) newstring
;
1915 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1917 else if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
== 0)
1918 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) "";
1919 else if (!bfd_coff_symname_in_debug (abfd
, &internal_ptr
->u
.syment
))
1921 /* Long name already. Point symbol at the string in the
1923 if (string_table
== NULL
)
1925 string_table
= _bfd_coff_read_string_table (abfd
);
1926 if (string_table
== NULL
)
1929 if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
>= obj_coff_strings_len (abfd
)
1930 || string_table
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
< string_table
)
1931 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1933 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1936 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
));
1940 /* Long name in debug section. Very similar. */
1941 if (debug_sec_data
== NULL
)
1942 debug_sec_data
= build_debug_section (abfd
, & debug_sec
);
1943 if (debug_sec_data
!= NULL
)
1945 BFD_ASSERT (debug_sec
!= NULL
);
1946 /* PR binutils/17512: Catch out of range offsets into the debug data. */
1947 if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
> debug_sec
->size
1948 || debug_sec_data
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
< debug_sec_data
)
1949 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1951 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
)
1952 (debug_sec_data
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
1955 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) "";
1958 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
1961 obj_raw_syments (abfd
) = internal
;
1962 BFD_ASSERT (obj_raw_syment_count (abfd
)
1963 == (unsigned int) (internal_ptr
- internal
));
1969 coff_get_reloc_upper_bound (bfd
*abfd
, sec_ptr asect
)
1971 if (bfd_get_format (abfd
) != bfd_object
)
1973 bfd_set_error (bfd_error_invalid_operation
);
1976 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
1980 coff_make_empty_symbol (bfd
*abfd
)
1982 bfd_size_type amt
= sizeof (coff_symbol_type
);
1983 coff_symbol_type
*new_symbol
= (coff_symbol_type
*) bfd_zalloc (abfd
, amt
);
1985 if (new_symbol
== NULL
)
1987 new_symbol
->symbol
.section
= 0;
1988 new_symbol
->native
= NULL
;
1989 new_symbol
->lineno
= NULL
;
1990 new_symbol
->done_lineno
= FALSE
;
1991 new_symbol
->symbol
.the_bfd
= abfd
;
1993 return & new_symbol
->symbol
;
1996 /* Make a debugging symbol. */
1999 coff_bfd_make_debug_symbol (bfd
*abfd
,
2000 void * ptr ATTRIBUTE_UNUSED
,
2001 unsigned long sz ATTRIBUTE_UNUSED
)
2003 bfd_size_type amt
= sizeof (coff_symbol_type
);
2004 coff_symbol_type
*new_symbol
= (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
2006 if (new_symbol
== NULL
)
2008 /* @@ The 10 is a guess at a plausible maximum number of aux entries
2009 (but shouldn't be a constant). */
2010 amt
= sizeof (combined_entry_type
) * 10;
2011 new_symbol
->native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
2012 if (!new_symbol
->native
)
2014 new_symbol
->native
->is_sym
= TRUE
;
2015 new_symbol
->symbol
.section
= bfd_abs_section_ptr
;
2016 new_symbol
->symbol
.flags
= BSF_DEBUGGING
;
2017 new_symbol
->lineno
= NULL
;
2018 new_symbol
->done_lineno
= FALSE
;
2019 new_symbol
->symbol
.the_bfd
= abfd
;
2021 return & new_symbol
->symbol
;
2025 coff_get_symbol_info (bfd
*abfd
, asymbol
*symbol
, symbol_info
*ret
)
2027 bfd_symbol_info (symbol
, ret
);
2029 if (coffsymbol (symbol
)->native
!= NULL
2030 && coffsymbol (symbol
)->native
->fix_value
2031 && coffsymbol (symbol
)->native
->is_sym
)
2032 ret
->value
= coffsymbol (symbol
)->native
->u
.syment
.n_value
-
2033 (bfd_hostptr_t
) obj_raw_syments (abfd
);
2036 /* Print out information about COFF symbol. */
2039 coff_print_symbol (bfd
*abfd
,
2042 bfd_print_symbol_type how
)
2044 FILE * file
= (FILE *) filep
;
2048 case bfd_print_symbol_name
:
2049 fprintf (file
, "%s", symbol
->name
);
2052 case bfd_print_symbol_more
:
2053 fprintf (file
, "coff %s %s",
2054 coffsymbol (symbol
)->native
? "n" : "g",
2055 coffsymbol (symbol
)->lineno
? "l" : " ");
2058 case bfd_print_symbol_all
:
2059 if (coffsymbol (symbol
)->native
)
2063 combined_entry_type
*combined
= coffsymbol (symbol
)->native
;
2064 combined_entry_type
*root
= obj_raw_syments (abfd
);
2065 struct lineno_cache_entry
*l
= coffsymbol (symbol
)->lineno
;
2067 fprintf (file
, "[%3ld]", (long) (combined
- root
));
2069 /* PR 17512: file: 079-33786-0.001:0.1. */
2070 if (combined
< obj_raw_syments (abfd
)
2071 || combined
>= obj_raw_syments (abfd
) + obj_raw_syment_count (abfd
))
2073 fprintf (file
, _("<corrupt info> %s"), symbol
->name
);
2077 BFD_ASSERT (combined
->is_sym
);
2078 if (! combined
->fix_value
)
2079 val
= (bfd_vma
) combined
->u
.syment
.n_value
;
2081 val
= combined
->u
.syment
.n_value
- (bfd_hostptr_t
) root
;
2083 fprintf (file
, "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x",
2084 combined
->u
.syment
.n_scnum
,
2085 combined
->u
.syment
.n_flags
,
2086 combined
->u
.syment
.n_type
,
2087 combined
->u
.syment
.n_sclass
,
2088 combined
->u
.syment
.n_numaux
);
2089 bfd_fprintf_vma (abfd
, file
, val
);
2090 fprintf (file
, " %s", symbol
->name
);
2092 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
2094 combined_entry_type
*auxp
= combined
+ aux
+ 1;
2097 BFD_ASSERT (! auxp
->is_sym
);
2099 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.p
- root
;
2101 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.l
;
2103 fprintf (file
, "\n");
2105 if (bfd_coff_print_aux (abfd
, file
, root
, combined
, auxp
, aux
))
2108 switch (combined
->u
.syment
.n_sclass
)
2111 fprintf (file
, "File ");
2115 if (combined
->u
.syment
.n_type
== T_NULL
)
2116 /* Probably a section symbol ? */
2118 fprintf (file
, "AUX scnlen 0x%lx nreloc %d nlnno %d",
2119 (unsigned long) auxp
->u
.auxent
.x_scn
.x_scnlen
,
2120 auxp
->u
.auxent
.x_scn
.x_nreloc
,
2121 auxp
->u
.auxent
.x_scn
.x_nlinno
);
2122 if (auxp
->u
.auxent
.x_scn
.x_checksum
!= 0
2123 || auxp
->u
.auxent
.x_scn
.x_associated
!= 0
2124 || auxp
->u
.auxent
.x_scn
.x_comdat
!= 0)
2125 fprintf (file
, " checksum 0x%lx assoc %d comdat %d",
2126 auxp
->u
.auxent
.x_scn
.x_checksum
,
2127 auxp
->u
.auxent
.x_scn
.x_associated
,
2128 auxp
->u
.auxent
.x_scn
.x_comdat
);
2131 /* Otherwise fall through. */
2134 if (ISFCN (combined
->u
.syment
.n_type
))
2139 next
= (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2142 next
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2143 llnos
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
2145 "AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld",
2147 (unsigned long) auxp
->u
.auxent
.x_sym
.x_misc
.x_fsize
,
2151 /* Otherwise fall through. */
2153 fprintf (file
, "AUX lnno %d size 0x%x tagndx %ld",
2154 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
2155 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
,
2158 fprintf (file
, " endndx %ld",
2160 (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2168 fprintf (file
, "\n%s :", l
->u
.sym
->name
);
2170 while (l
->line_number
)
2172 if (l
->line_number
> 0)
2174 fprintf (file
, "\n%4d : ", l
->line_number
);
2175 bfd_fprintf_vma (abfd
, file
, l
->u
.offset
+ symbol
->section
->vma
);
2183 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
2184 fprintf (file
, " %-5s %s %s %s",
2185 symbol
->section
->name
,
2186 coffsymbol (symbol
)->native
? "n" : "g",
2187 coffsymbol (symbol
)->lineno
? "l" : " ",
2193 /* Return whether a symbol name implies a local symbol. In COFF,
2194 local symbols generally start with ``.L''. Most targets use this
2195 function for the is_local_label_name entry point, but some may
2199 _bfd_coff_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
2202 return name
[0] == '.' && name
[1] == 'L';
2205 /* Provided a BFD, a section and an offset (in bytes, not octets) into the
2206 section, calculate and return the name of the source file and the line
2207 nearest to the wanted location. */
2210 coff_find_nearest_line_with_names (bfd
*abfd
,
2214 const char **filename_ptr
,
2215 const char **functionname_ptr
,
2216 unsigned int *line_ptr
,
2217 const struct dwarf_debug_section
*debug_sections
)
2221 unsigned int line_base
;
2222 coff_data_type
*cof
= coff_data (abfd
);
2223 /* Run through the raw syments if available. */
2224 combined_entry_type
*p
;
2225 combined_entry_type
*pend
;
2227 struct coff_section_tdata
*sec_data
;
2230 /* Before looking through the symbol table, try to use a .stab
2231 section to find the information. */
2232 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2233 &found
, filename_ptr
,
2234 functionname_ptr
, line_ptr
,
2235 &coff_data(abfd
)->line_info
))
2241 /* Also try examining DWARF2 debugging information. */
2242 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
2243 filename_ptr
, functionname_ptr
,
2244 line_ptr
, NULL
, debug_sections
, 0,
2245 &coff_data(abfd
)->dwarf2_find_line_info
))
2249 *functionname_ptr
= 0;
2252 /* Don't try and find line numbers in a non coff file. */
2253 if (!bfd_family_coff (abfd
))
2259 /* Find the first C_FILE symbol. */
2260 p
= cof
->raw_syments
;
2264 pend
= p
+ cof
->raw_syment_count
;
2267 BFD_ASSERT (p
->is_sym
);
2268 if (p
->u
.syment
.n_sclass
== C_FILE
)
2270 p
+= 1 + p
->u
.syment
.n_numaux
;
2278 /* Look through the C_FILE symbols to find the best one. */
2279 sec_vma
= bfd_get_section_vma (abfd
, section
);
2280 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2281 maxdiff
= (bfd_vma
) 0 - (bfd_vma
) 1;
2285 combined_entry_type
*p2
;
2287 for (p2
= p
+ 1 + p
->u
.syment
.n_numaux
;
2289 p2
+= 1 + p2
->u
.syment
.n_numaux
)
2291 BFD_ASSERT (p2
->is_sym
);
2292 if (p2
->u
.syment
.n_scnum
> 0
2294 == coff_section_from_bfd_index (abfd
,
2295 p2
->u
.syment
.n_scnum
)))
2297 if (p2
->u
.syment
.n_sclass
== C_FILE
)
2306 file_addr
= (bfd_vma
) p2
->u
.syment
.n_value
;
2307 /* PR 11512: Include the section address of the function name symbol. */
2308 if (p2
->u
.syment
.n_scnum
> 0)
2309 file_addr
+= coff_section_from_bfd_index (abfd
,
2310 p2
->u
.syment
.n_scnum
)->vma
;
2311 /* We use <= MAXDIFF here so that if we get a zero length
2312 file, we actually use the next file entry. */
2314 && offset
+ sec_vma
>= file_addr
2315 && offset
+ sec_vma
- file_addr
<= maxdiff
)
2317 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2318 maxdiff
= offset
+ sec_vma
- p2
->u
.syment
.n_value
;
2321 /* Avoid endless loops on erroneous files by ensuring that
2322 we always move forward in the file. */
2323 if (p
>= cof
->raw_syments
+ p
->u
.syment
.n_value
)
2326 p
= cof
->raw_syments
+ p
->u
.syment
.n_value
;
2327 if (p
> pend
|| p
->u
.syment
.n_sclass
!= C_FILE
)
2332 /* Now wander though the raw linenumbers of the section. */
2333 /* If we have been called on this section before, and the offset we
2334 want is further down then we can prime the lookup loop. */
2335 sec_data
= coff_section_data (abfd
, section
);
2336 if (sec_data
!= NULL
2338 && offset
>= sec_data
->offset
)
2341 *functionname_ptr
= sec_data
->function
;
2342 line_base
= sec_data
->line_base
;
2350 if (section
->lineno
!= NULL
)
2352 bfd_vma last_value
= 0;
2354 l
= §ion
->lineno
[i
];
2356 for (; i
< section
->lineno_count
; i
++)
2358 if (l
->line_number
== 0)
2360 /* Get the symbol this line number points at. */
2361 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
2362 if (coff
->symbol
.value
> offset
)
2364 *functionname_ptr
= coff
->symbol
.name
;
2365 last_value
= coff
->symbol
.value
;
2368 combined_entry_type
*s
= coff
->native
;
2370 BFD_ASSERT (s
->is_sym
);
2371 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2373 /* In XCOFF a debugging symbol can follow the
2375 if (s
->u
.syment
.n_scnum
== N_DEBUG
)
2376 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2378 /* S should now point to the .bf of the function. */
2379 if (s
->u
.syment
.n_numaux
)
2381 /* The linenumber is stored in the auxent. */
2382 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
2384 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
2385 *line_ptr
= line_base
;
2391 if (l
->u
.offset
> offset
)
2393 *line_ptr
= l
->line_number
+ line_base
- 1;
2398 /* If we fell off the end of the loop, then assume that this
2399 symbol has no line number info. Otherwise, symbols with no
2400 line number info get reported with the line number of the
2401 last line of the last symbol which does have line number
2402 info. We use 0x100 as a slop to account for cases where the
2403 last line has executable code. */
2404 if (i
>= section
->lineno_count
2406 && offset
- last_value
> 0x100)
2408 *functionname_ptr
= NULL
;
2413 /* Cache the results for the next call. */
2414 if (sec_data
== NULL
&& section
->owner
== abfd
)
2416 amt
= sizeof (struct coff_section_tdata
);
2417 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
2418 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2420 if (sec_data
!= NULL
)
2422 sec_data
->offset
= offset
;
2423 sec_data
->i
= i
- 1;
2424 sec_data
->function
= *functionname_ptr
;
2425 sec_data
->line_base
= line_base
;
2432 coff_find_nearest_line (bfd
*abfd
,
2436 const char **filename_ptr
,
2437 const char **functionname_ptr
,
2438 unsigned int *line_ptr
,
2439 unsigned int *discriminator_ptr
)
2441 if (discriminator_ptr
)
2442 *discriminator_ptr
= 0;
2443 return coff_find_nearest_line_with_names (abfd
, symbols
, section
, offset
,
2444 filename_ptr
, functionname_ptr
,
2445 line_ptr
, dwarf_debug_sections
);
2449 coff_find_inliner_info (bfd
*abfd
,
2450 const char **filename_ptr
,
2451 const char **functionname_ptr
,
2452 unsigned int *line_ptr
)
2456 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
2457 functionname_ptr
, line_ptr
,
2458 &coff_data(abfd
)->dwarf2_find_line_info
);
2463 coff_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
2467 if (!info
->relocatable
)
2468 size
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
2470 size
= bfd_coff_filhsz (abfd
);
2472 size
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
2476 /* Change the class of a coff symbol held by BFD. */
2479 bfd_coff_set_symbol_class (bfd
* abfd
,
2481 unsigned int symbol_class
)
2483 coff_symbol_type
* csym
;
2485 csym
= coff_symbol_from (symbol
);
2488 bfd_set_error (bfd_error_invalid_operation
);
2491 else if (csym
->native
== NULL
)
2493 /* This is an alien symbol which no native coff backend data.
2494 We cheat here by creating a fake native entry for it and
2495 then filling in the class. This code is based on that in
2496 coff_write_alien_symbol(). */
2498 combined_entry_type
* native
;
2499 bfd_size_type amt
= sizeof (* native
);
2501 native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
2505 native
->is_sym
= TRUE
;
2506 native
->u
.syment
.n_type
= T_NULL
;
2507 native
->u
.syment
.n_sclass
= symbol_class
;
2509 if (bfd_is_und_section (symbol
->section
))
2511 native
->u
.syment
.n_scnum
= N_UNDEF
;
2512 native
->u
.syment
.n_value
= symbol
->value
;
2514 else if (bfd_is_com_section (symbol
->section
))
2516 native
->u
.syment
.n_scnum
= N_UNDEF
;
2517 native
->u
.syment
.n_value
= symbol
->value
;
2521 native
->u
.syment
.n_scnum
=
2522 symbol
->section
->output_section
->target_index
;
2523 native
->u
.syment
.n_value
= (symbol
->value
2524 + symbol
->section
->output_offset
);
2525 if (! obj_pe (abfd
))
2526 native
->u
.syment
.n_value
+= symbol
->section
->output_section
->vma
;
2528 /* Copy the any flags from the file header into the symbol.
2530 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (& csym
->symbol
)->flags
;
2533 csym
->native
= native
;
2536 csym
->native
->u
.syment
.n_sclass
= symbol_class
;
2542 _bfd_coff_section_already_linked (bfd
*abfd
,
2544 struct bfd_link_info
*info
)
2547 const char *name
, *key
;
2548 struct bfd_section_already_linked
*l
;
2549 struct bfd_section_already_linked_hash_entry
*already_linked_list
;
2550 struct coff_comdat_info
*s_comdat
;
2553 if ((flags
& SEC_LINK_ONCE
) == 0)
2556 /* The COFF backend linker doesn't support group sections. */
2557 if ((flags
& SEC_GROUP
) != 0)
2560 name
= bfd_get_section_name (abfd
, sec
);
2561 s_comdat
= bfd_coff_get_comdat_section (abfd
, sec
);
2563 if (s_comdat
!= NULL
)
2564 key
= s_comdat
->name
;
2567 if (CONST_STRNEQ (name
, ".gnu.linkonce.")
2568 && (key
= strchr (name
+ sizeof (".gnu.linkonce.") - 1, '.')) != NULL
)
2571 /* FIXME: gcc as of 2011-09 emits sections like .text$<key>,
2572 .xdata$<key> and .pdata$<key> only the first of which has a
2573 comdat key. Should these all match the LTO IR key? */
2577 already_linked_list
= bfd_section_already_linked_table_lookup (key
);
2579 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
2581 struct coff_comdat_info
*l_comdat
;
2583 l_comdat
= bfd_coff_get_comdat_section (l
->sec
->owner
, l
->sec
);
2585 /* The section names must match, and both sections must be
2586 comdat and have the same comdat name, or both sections must
2587 be non-comdat. LTO IR plugin sections are an exception. They
2588 are always named .gnu.linkonce.t.<key> (<key> is some string)
2589 and match any comdat section with comdat name of <key>, and
2590 any linkonce section with the same suffix, ie.
2591 .gnu.linkonce.*.<key>. */
2592 if (((s_comdat
!= NULL
) == (l_comdat
!= NULL
)
2593 && strcmp (name
, l
->sec
->name
) == 0)
2594 || (l
->sec
->owner
->flags
& BFD_PLUGIN
) != 0)
2596 /* The section has already been linked. See if we should
2598 return _bfd_handle_already_linked (sec
, l
, info
);
2602 /* This is the first section with this name. Record it. */
2603 if (!bfd_section_already_linked_table_insert (already_linked_list
, sec
))
2604 info
->callbacks
->einfo (_("%F%P: already_linked_table: %E\n"));