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
)
149 && ((name
[1] == 'd' && name
[6] == '_')
150 || (name
[1] == 'z' && name
[7] == '_')))
152 enum { nothing
, compress
, decompress
} action
= nothing
;
153 char *new_name
= NULL
;
155 if (bfd_is_section_compressed (abfd
, return_section
))
157 /* Compressed section. Check if we should decompress. */
158 if ((abfd
->flags
& BFD_DECOMPRESS
))
161 else if (!bfd_is_section_compressed (abfd
, return_section
))
163 /* Normal section. Check if we should compress. */
164 if ((abfd
->flags
& BFD_COMPRESS
) && return_section
->size
!= 0)
173 if (!bfd_init_section_compress_status (abfd
, return_section
))
175 (*_bfd_error_handler
)
176 (_("%B: unable to initialize compress status for section %s"),
182 unsigned int len
= strlen (name
);
184 new_name
= bfd_alloc (abfd
, len
+ 2);
185 if (new_name
== NULL
)
189 memcpy (new_name
+ 2, name
+ 1, len
);
193 if (!bfd_init_section_decompress_status (abfd
, return_section
))
195 (*_bfd_error_handler
)
196 (_("%B: unable to initialize decompress status for section %s"),
202 unsigned int len
= strlen (name
);
204 new_name
= bfd_alloc (abfd
, len
);
205 if (new_name
== NULL
)
208 memcpy (new_name
+ 1, name
+ 2, len
- 1);
212 if (new_name
!= NULL
)
213 bfd_rename_section (abfd
, return_section
, new_name
);
219 /* Read in a COFF object and make it into a BFD. This is used by
222 coff_real_object_p (bfd
*,
224 struct internal_filehdr
*,
225 struct internal_aouthdr
*);
227 coff_real_object_p (bfd
*abfd
,
229 struct internal_filehdr
*internal_f
,
230 struct internal_aouthdr
*internal_a
)
232 flagword oflags
= abfd
->flags
;
233 bfd_vma ostart
= bfd_get_start_address (abfd
);
236 bfd_size_type readsize
; /* Length of file_info. */
238 char *external_sections
;
240 if (!(internal_f
->f_flags
& F_RELFLG
))
241 abfd
->flags
|= HAS_RELOC
;
242 if ((internal_f
->f_flags
& F_EXEC
))
243 abfd
->flags
|= EXEC_P
;
244 if (!(internal_f
->f_flags
& F_LNNO
))
245 abfd
->flags
|= HAS_LINENO
;
246 if (!(internal_f
->f_flags
& F_LSYMS
))
247 abfd
->flags
|= HAS_LOCALS
;
249 /* FIXME: How can we set D_PAGED correctly? */
250 if ((internal_f
->f_flags
& F_EXEC
) != 0)
251 abfd
->flags
|= D_PAGED
;
253 bfd_get_symcount (abfd
) = internal_f
->f_nsyms
;
254 if (internal_f
->f_nsyms
)
255 abfd
->flags
|= HAS_SYMS
;
257 if (internal_a
!= (struct internal_aouthdr
*) NULL
)
258 bfd_get_start_address (abfd
) = internal_a
->entry
;
260 bfd_get_start_address (abfd
) = 0;
262 /* Set up the tdata area. ECOFF uses its own routine, and overrides
264 tdata_save
= abfd
->tdata
.any
;
265 tdata
= bfd_coff_mkobject_hook (abfd
, (void *) internal_f
, (void *) internal_a
);
269 scnhsz
= bfd_coff_scnhsz (abfd
);
270 readsize
= (bfd_size_type
) nscns
* scnhsz
;
271 external_sections
= (char *) bfd_alloc (abfd
, readsize
);
272 if (!external_sections
)
275 if (bfd_bread ((void *) external_sections
, readsize
, abfd
) != readsize
)
278 /* Set the arch/mach *before* swapping in sections; section header swapping
279 may depend on arch/mach info. */
280 if (! bfd_coff_set_arch_mach_hook (abfd
, (void *) internal_f
))
283 /* Now copy data as required; construct all asections etc. */
287 for (i
= 0; i
< nscns
; i
++)
289 struct internal_scnhdr tmp
;
290 bfd_coff_swap_scnhdr_in (abfd
,
291 (void *) (external_sections
+ i
* scnhsz
),
293 if (! make_a_section_from_file (abfd
, &tmp
, i
+ 1))
301 bfd_release (abfd
, tdata
);
303 abfd
->tdata
.any
= tdata_save
;
304 abfd
->flags
= oflags
;
305 bfd_get_start_address (abfd
) = ostart
;
306 return (const bfd_target
*) NULL
;
309 /* Turn a COFF file into a BFD, but fail with bfd_error_wrong_format if it is
310 not a COFF file. This is also used by ECOFF. */
313 coff_object_p (bfd
*abfd
)
315 bfd_size_type filhsz
;
316 bfd_size_type aoutsz
;
319 struct internal_filehdr internal_f
;
320 struct internal_aouthdr internal_a
;
322 /* Figure out how much to read. */
323 filhsz
= bfd_coff_filhsz (abfd
);
324 aoutsz
= bfd_coff_aoutsz (abfd
);
326 filehdr
= bfd_alloc (abfd
, filhsz
);
329 if (bfd_bread (filehdr
, filhsz
, abfd
) != filhsz
)
331 if (bfd_get_error () != bfd_error_system_call
)
332 bfd_set_error (bfd_error_wrong_format
);
333 bfd_release (abfd
, filehdr
);
336 bfd_coff_swap_filehdr_in (abfd
, filehdr
, &internal_f
);
337 bfd_release (abfd
, filehdr
);
339 /* The XCOFF format has two sizes for the f_opthdr. SMALL_AOUTSZ
340 (less than aoutsz) used in object files and AOUTSZ (equal to
341 aoutsz) in executables. The bfd_coff_swap_aouthdr_in function
342 expects this header to be aoutsz bytes in length, so we use that
343 value in the call to bfd_alloc below. But we must be careful to
344 only read in f_opthdr bytes in the call to bfd_bread. We should
345 also attempt to catch corrupt or non-COFF binaries with a strange
346 value for f_opthdr. */
347 if (! bfd_coff_bad_format_hook (abfd
, &internal_f
)
348 || internal_f
.f_opthdr
> aoutsz
)
350 bfd_set_error (bfd_error_wrong_format
);
353 nscns
= internal_f
.f_nscns
;
355 if (internal_f
.f_opthdr
)
359 opthdr
= bfd_alloc (abfd
, aoutsz
);
362 if (bfd_bread (opthdr
, (bfd_size_type
) internal_f
.f_opthdr
, abfd
)
363 != internal_f
.f_opthdr
)
365 bfd_release (abfd
, opthdr
);
368 bfd_coff_swap_aouthdr_in (abfd
, opthdr
, (void *) &internal_a
);
369 bfd_release (abfd
, opthdr
);
372 return coff_real_object_p (abfd
, nscns
, &internal_f
,
373 (internal_f
.f_opthdr
!= 0
375 : (struct internal_aouthdr
*) NULL
));
378 /* Get the BFD section from a COFF symbol section number. */
381 coff_section_from_bfd_index (bfd
*abfd
, int section_index
)
383 struct bfd_section
*answer
= abfd
->sections
;
385 if (section_index
== N_ABS
)
386 return bfd_abs_section_ptr
;
387 if (section_index
== N_UNDEF
)
388 return bfd_und_section_ptr
;
389 if (section_index
== N_DEBUG
)
390 return bfd_abs_section_ptr
;
394 if (answer
->target_index
== section_index
)
396 answer
= answer
->next
;
399 /* We should not reach this point, but the SCO 3.2v4 /lib/libc_s.a
400 has a bad symbol table in biglitpow.o. */
401 return bfd_und_section_ptr
;
404 /* Get the upper bound of a COFF symbol table. */
407 coff_get_symtab_upper_bound (bfd
*abfd
)
409 if (!bfd_coff_slurp_symbol_table (abfd
))
412 return (bfd_get_symcount (abfd
) + 1) * (sizeof (coff_symbol_type
*));
415 /* Canonicalize a COFF symbol table. */
418 coff_canonicalize_symtab (bfd
*abfd
, asymbol
**alocation
)
420 unsigned int counter
;
421 coff_symbol_type
*symbase
;
422 coff_symbol_type
**location
= (coff_symbol_type
**) alocation
;
424 if (!bfd_coff_slurp_symbol_table (abfd
))
427 symbase
= obj_symbols (abfd
);
428 counter
= bfd_get_symcount (abfd
);
429 while (counter
-- > 0)
430 *location
++ = symbase
++;
434 return bfd_get_symcount (abfd
);
437 /* Get the name of a symbol. The caller must pass in a buffer of size
441 _bfd_coff_internal_syment_name (bfd
*abfd
,
442 const struct internal_syment
*sym
,
445 /* FIXME: It's not clear this will work correctly if sizeof
447 if (sym
->_n
._n_n
._n_zeroes
!= 0
448 || sym
->_n
._n_n
._n_offset
== 0)
450 memcpy (buf
, sym
->_n
._n_name
, SYMNMLEN
);
451 buf
[SYMNMLEN
] = '\0';
458 BFD_ASSERT (sym
->_n
._n_n
._n_offset
>= STRING_SIZE_SIZE
);
459 strings
= obj_coff_strings (abfd
);
462 strings
= _bfd_coff_read_string_table (abfd
);
466 if (sym
->_n
._n_n
._n_offset
>= obj_coff_strings_len (abfd
))
468 return strings
+ sym
->_n
._n_n
._n_offset
;
472 /* Read in and swap the relocs. This returns a buffer holding the
473 relocs for section SEC in file ABFD. If CACHE is TRUE and
474 INTERNAL_RELOCS is NULL, the relocs read in will be saved in case
475 the function is called again. If EXTERNAL_RELOCS is not NULL, it
476 is a buffer large enough to hold the unswapped relocs. If
477 INTERNAL_RELOCS is not NULL, it is a buffer large enough to hold
478 the swapped relocs. If REQUIRE_INTERNAL is TRUE, then the return
479 value must be INTERNAL_RELOCS. The function returns NULL on error. */
481 struct internal_reloc
*
482 _bfd_coff_read_internal_relocs (bfd
*abfd
,
485 bfd_byte
*external_relocs
,
486 bfd_boolean require_internal
,
487 struct internal_reloc
*internal_relocs
)
490 bfd_byte
*free_external
= NULL
;
491 struct internal_reloc
*free_internal
= NULL
;
494 struct internal_reloc
*irel
;
497 if (sec
->reloc_count
== 0)
498 return internal_relocs
; /* Nothing to do. */
500 if (coff_section_data (abfd
, sec
) != NULL
501 && coff_section_data (abfd
, sec
)->relocs
!= NULL
)
503 if (! require_internal
)
504 return coff_section_data (abfd
, sec
)->relocs
;
505 memcpy (internal_relocs
, coff_section_data (abfd
, sec
)->relocs
,
506 sec
->reloc_count
* sizeof (struct internal_reloc
));
507 return internal_relocs
;
510 relsz
= bfd_coff_relsz (abfd
);
512 amt
= sec
->reloc_count
* relsz
;
513 if (external_relocs
== NULL
)
515 free_external
= (bfd_byte
*) bfd_malloc (amt
);
516 if (free_external
== NULL
)
518 external_relocs
= free_external
;
521 if (bfd_seek (abfd
, sec
->rel_filepos
, SEEK_SET
) != 0
522 || bfd_bread (external_relocs
, amt
, abfd
) != amt
)
525 if (internal_relocs
== NULL
)
527 amt
= sec
->reloc_count
;
528 amt
*= sizeof (struct internal_reloc
);
529 free_internal
= (struct internal_reloc
*) bfd_malloc (amt
);
530 if (free_internal
== NULL
)
532 internal_relocs
= free_internal
;
535 /* Swap in the relocs. */
536 erel
= external_relocs
;
537 erel_end
= erel
+ relsz
* sec
->reloc_count
;
538 irel
= internal_relocs
;
539 for (; erel
< erel_end
; erel
+= relsz
, irel
++)
540 bfd_coff_swap_reloc_in (abfd
, (void *) erel
, (void *) irel
);
542 if (free_external
!= NULL
)
544 free (free_external
);
545 free_external
= NULL
;
548 if (cache
&& free_internal
!= NULL
)
550 if (coff_section_data (abfd
, sec
) == NULL
)
552 amt
= sizeof (struct coff_section_tdata
);
553 sec
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
554 if (sec
->used_by_bfd
== NULL
)
556 coff_section_data (abfd
, sec
)->contents
= NULL
;
558 coff_section_data (abfd
, sec
)->relocs
= free_internal
;
561 return internal_relocs
;
564 if (free_external
!= NULL
)
565 free (free_external
);
566 if (free_internal
!= NULL
)
567 free (free_internal
);
571 /* Set lineno_count for the output sections of a COFF file. */
574 coff_count_linenumbers (bfd
*abfd
)
576 unsigned int limit
= bfd_get_symcount (abfd
);
584 /* This may be from the backend linker, in which case the
585 lineno_count in the sections is correct. */
586 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
587 total
+= s
->lineno_count
;
591 for (s
= abfd
->sections
; s
!= NULL
; s
= s
->next
)
592 BFD_ASSERT (s
->lineno_count
== 0);
594 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
596 asymbol
*q_maybe
= *p
;
598 if (bfd_family_coff (bfd_asymbol_bfd (q_maybe
)))
600 coff_symbol_type
*q
= coffsymbol (q_maybe
);
602 /* The AIX 4.1 compiler can sometimes generate line numbers
603 attached to debugging symbols. We try to simply ignore
605 if (q
->lineno
!= NULL
606 && q
->symbol
.section
->owner
!= NULL
)
608 /* This symbol has line numbers. Increment the owning
609 section's linenumber count. */
610 alent
*l
= q
->lineno
;
614 asection
* sec
= q
->symbol
.section
->output_section
;
616 /* Do not try to update fields in read-only sections. */
617 if (! bfd_is_const_section (sec
))
618 sec
->lineno_count
++;
623 while (l
->line_number
!= 0);
631 /* Takes a bfd and a symbol, returns a pointer to the coff specific
632 area of the symbol if there is one. */
635 coff_symbol_from (bfd
*ignore_abfd ATTRIBUTE_UNUSED
,
638 if (!bfd_family_coff (bfd_asymbol_bfd (symbol
)))
639 return (coff_symbol_type
*) NULL
;
641 if (bfd_asymbol_bfd (symbol
)->tdata
.coff_obj_data
== (coff_data_type
*) NULL
)
642 return (coff_symbol_type
*) NULL
;
644 return (coff_symbol_type
*) symbol
;
648 fixup_symbol_value (bfd
*abfd
,
649 coff_symbol_type
*coff_symbol_ptr
,
650 struct internal_syment
*syment
)
652 /* Normalize the symbol flags. */
653 if (coff_symbol_ptr
->symbol
.section
654 && bfd_is_com_section (coff_symbol_ptr
->symbol
.section
))
656 /* A common symbol is undefined with a value. */
657 syment
->n_scnum
= N_UNDEF
;
658 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
660 else if ((coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
) != 0
661 && (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING_RELOC
) == 0)
663 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
665 else if (bfd_is_und_section (coff_symbol_ptr
->symbol
.section
))
667 syment
->n_scnum
= N_UNDEF
;
670 /* FIXME: Do we need to handle the absolute section here? */
673 if (coff_symbol_ptr
->symbol
.section
)
676 coff_symbol_ptr
->symbol
.section
->output_section
->target_index
;
678 syment
->n_value
= (coff_symbol_ptr
->symbol
.value
679 + coff_symbol_ptr
->symbol
.section
->output_offset
);
682 syment
->n_value
+= (syment
->n_sclass
== C_STATLAB
)
683 ? coff_symbol_ptr
->symbol
.section
->output_section
->lma
684 : coff_symbol_ptr
->symbol
.section
->output_section
->vma
;
690 /* This can happen, but I don't know why yet (steve@cygnus.com) */
691 syment
->n_scnum
= N_ABS
;
692 syment
->n_value
= coff_symbol_ptr
->symbol
.value
;
697 /* Run through all the symbols in the symbol table and work out what
698 their indexes into the symbol table will be when output.
700 Coff requires that each C_FILE symbol points to the next one in the
701 chain, and that the last one points to the first external symbol. We
705 coff_renumber_symbols (bfd
*bfd_ptr
, int *first_undef
)
707 unsigned int symbol_count
= bfd_get_symcount (bfd_ptr
);
708 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
709 unsigned int native_index
= 0;
710 struct internal_syment
*last_file
= NULL
;
711 unsigned int symbol_index
;
713 /* COFF demands that undefined symbols come after all other symbols.
714 Since we don't need to impose this extra knowledge on all our
715 client programs, deal with that here. Sort the symbol table;
716 just move the undefined symbols to the end, leaving the rest
717 alone. The O'Reilly book says that defined global symbols come
718 at the end before the undefined symbols, so we do that here as
720 /* @@ Do we have some condition we could test for, so we don't always
721 have to do this? I don't think relocatability is quite right, but
722 I'm not certain. [raeburn:19920508.1711EST] */
728 amt
= sizeof (asymbol
*) * ((bfd_size_type
) symbol_count
+ 1);
729 newsyms
= (asymbol
**) bfd_alloc (bfd_ptr
, amt
);
732 bfd_ptr
->outsymbols
= newsyms
;
733 for (i
= 0; i
< symbol_count
; i
++)
734 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) != 0
735 || (!bfd_is_und_section (symbol_ptr_ptr
[i
]->section
)
736 && !bfd_is_com_section (symbol_ptr_ptr
[i
]->section
)
737 && ((symbol_ptr_ptr
[i
]->flags
& BSF_FUNCTION
) != 0
738 || ((symbol_ptr_ptr
[i
]->flags
& (BSF_GLOBAL
| BSF_WEAK
))
740 *newsyms
++ = symbol_ptr_ptr
[i
];
742 for (i
= 0; i
< symbol_count
; i
++)
743 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) == 0
744 && !bfd_is_und_section (symbol_ptr_ptr
[i
]->section
)
745 && (bfd_is_com_section (symbol_ptr_ptr
[i
]->section
)
746 || ((symbol_ptr_ptr
[i
]->flags
& BSF_FUNCTION
) == 0
747 && ((symbol_ptr_ptr
[i
]->flags
& (BSF_GLOBAL
| BSF_WEAK
))
749 *newsyms
++ = symbol_ptr_ptr
[i
];
751 *first_undef
= newsyms
- bfd_ptr
->outsymbols
;
753 for (i
= 0; i
< symbol_count
; i
++)
754 if ((symbol_ptr_ptr
[i
]->flags
& BSF_NOT_AT_END
) == 0
755 && bfd_is_und_section (symbol_ptr_ptr
[i
]->section
))
756 *newsyms
++ = symbol_ptr_ptr
[i
];
757 *newsyms
= (asymbol
*) NULL
;
758 symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
761 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
763 coff_symbol_type
*coff_symbol_ptr
= coff_symbol_from (bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
765 symbol_ptr_ptr
[symbol_index
]->udata
.i
= symbol_index
;
766 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
)
768 combined_entry_type
*s
= coff_symbol_ptr
->native
;
771 BFD_ASSERT (s
->is_sym
);
772 if (s
->u
.syment
.n_sclass
== C_FILE
)
774 if (last_file
!= NULL
)
775 last_file
->n_value
= native_index
;
776 last_file
= &(s
->u
.syment
);
779 /* Modify the symbol values according to their section and
781 fixup_symbol_value (bfd_ptr
, coff_symbol_ptr
, &(s
->u
.syment
));
783 for (i
= 0; i
< s
->u
.syment
.n_numaux
+ 1; i
++)
784 s
[i
].offset
= native_index
++;
790 obj_conv_table_size (bfd_ptr
) = native_index
;
795 /* Run thorough the symbol table again, and fix it so that all
796 pointers to entries are changed to the entries' index in the output
800 coff_mangle_symbols (bfd
*bfd_ptr
)
802 unsigned int symbol_count
= bfd_get_symcount (bfd_ptr
);
803 asymbol
**symbol_ptr_ptr
= bfd_ptr
->outsymbols
;
804 unsigned int symbol_index
;
806 for (symbol_index
= 0; symbol_index
< symbol_count
; symbol_index
++)
808 coff_symbol_type
*coff_symbol_ptr
=
809 coff_symbol_from (bfd_ptr
, symbol_ptr_ptr
[symbol_index
]);
811 if (coff_symbol_ptr
&& coff_symbol_ptr
->native
)
814 combined_entry_type
*s
= coff_symbol_ptr
->native
;
816 BFD_ASSERT (s
->is_sym
);
819 /* FIXME: We should use a union here. */
820 s
->u
.syment
.n_value
=
821 (bfd_hostptr_t
) ((combined_entry_type
*)
822 ((bfd_hostptr_t
) s
->u
.syment
.n_value
))->offset
;
827 /* The value is the offset into the line number entries
828 for the symbol's section. On output, the symbol's
829 section should be N_DEBUG. */
830 s
->u
.syment
.n_value
=
831 (coff_symbol_ptr
->symbol
.section
->output_section
->line_filepos
832 + s
->u
.syment
.n_value
* bfd_coff_linesz (bfd_ptr
));
833 coff_symbol_ptr
->symbol
.section
=
834 coff_section_from_bfd_index (bfd_ptr
, N_DEBUG
);
835 BFD_ASSERT (coff_symbol_ptr
->symbol
.flags
& BSF_DEBUGGING
);
837 for (i
= 0; i
< s
->u
.syment
.n_numaux
; i
++)
839 combined_entry_type
*a
= s
+ i
+ 1;
841 BFD_ASSERT (! a
->is_sym
);
844 a
->u
.auxent
.x_sym
.x_tagndx
.l
=
845 a
->u
.auxent
.x_sym
.x_tagndx
.p
->offset
;
850 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
851 a
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
->offset
;
856 a
->u
.auxent
.x_csect
.x_scnlen
.l
=
857 a
->u
.auxent
.x_csect
.x_scnlen
.p
->offset
;
866 coff_fix_symbol_name (bfd
*abfd
,
868 combined_entry_type
*native
,
869 bfd_size_type
*string_size_p
,
870 asection
**debug_string_section_p
,
871 bfd_size_type
*debug_string_size_p
)
873 unsigned int name_length
;
874 union internal_auxent
*auxent
;
875 char *name
= (char *) (symbol
->name
);
879 /* COFF symbols always have names, so we'll make one up. */
880 symbol
->name
= "strange";
881 name
= (char *) symbol
->name
;
883 name_length
= strlen (name
);
885 BFD_ASSERT (native
->is_sym
);
886 if (native
->u
.syment
.n_sclass
== C_FILE
887 && native
->u
.syment
.n_numaux
> 0)
889 unsigned int filnmlen
;
891 if (bfd_coff_force_symnames_in_strings (abfd
))
893 native
->u
.syment
._n
._n_n
._n_offset
=
894 (*string_size_p
+ STRING_SIZE_SIZE
);
895 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
896 *string_size_p
+= 6; /* strlen(".file") + 1 */
899 strncpy (native
->u
.syment
._n
._n_name
, ".file", SYMNMLEN
);
901 BFD_ASSERT (! (native
+ 1)->is_sym
);
902 auxent
= &(native
+ 1)->u
.auxent
;
904 filnmlen
= bfd_coff_filnmlen (abfd
);
906 if (bfd_coff_long_filenames (abfd
))
908 if (name_length
<= filnmlen
)
909 strncpy (auxent
->x_file
.x_fname
, name
, filnmlen
);
912 auxent
->x_file
.x_n
.x_offset
= *string_size_p
+ STRING_SIZE_SIZE
;
913 auxent
->x_file
.x_n
.x_zeroes
= 0;
914 *string_size_p
+= name_length
+ 1;
919 strncpy (auxent
->x_file
.x_fname
, name
, filnmlen
);
920 if (name_length
> filnmlen
)
921 name
[filnmlen
] = '\0';
926 if (name_length
<= SYMNMLEN
&& !bfd_coff_force_symnames_in_strings (abfd
))
927 /* This name will fit into the symbol neatly. */
928 strncpy (native
->u
.syment
._n
._n_name
, symbol
->name
, SYMNMLEN
);
930 else if (!bfd_coff_symname_in_debug (abfd
, &native
->u
.syment
))
932 native
->u
.syment
._n
._n_n
._n_offset
= (*string_size_p
934 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
935 *string_size_p
+= name_length
+ 1;
941 int prefix_len
= bfd_coff_debug_string_prefix_length (abfd
);
943 /* This name should be written into the .debug section. For
944 some reason each name is preceded by a two byte length
945 and also followed by a null byte. FIXME: We assume that
946 the .debug section has already been created, and that it
948 if (*debug_string_section_p
== (asection
*) NULL
)
949 *debug_string_section_p
= bfd_get_section_by_name (abfd
, ".debug");
950 filepos
= bfd_tell (abfd
);
952 bfd_put_32 (abfd
, (bfd_vma
) (name_length
+ 1), buf
);
954 bfd_put_16 (abfd
, (bfd_vma
) (name_length
+ 1), buf
);
956 if (!bfd_set_section_contents (abfd
,
957 *debug_string_section_p
,
959 (file_ptr
) *debug_string_size_p
,
960 (bfd_size_type
) prefix_len
)
961 || !bfd_set_section_contents (abfd
,
962 *debug_string_section_p
,
963 (void *) symbol
->name
,
964 (file_ptr
) (*debug_string_size_p
966 (bfd_size_type
) name_length
+ 1))
968 if (bfd_seek (abfd
, filepos
, SEEK_SET
) != 0)
970 native
->u
.syment
._n
._n_n
._n_offset
=
971 *debug_string_size_p
+ prefix_len
;
972 native
->u
.syment
._n
._n_n
._n_zeroes
= 0;
973 *debug_string_size_p
+= name_length
+ 1 + prefix_len
;
978 /* We need to keep track of the symbol index so that when we write out
979 the relocs we can get the index for a symbol. This method is a
982 #define set_index(symbol, idx) ((symbol)->udata.i = (idx))
984 /* Write a symbol out to a COFF file. */
987 coff_write_symbol (bfd
*abfd
,
989 combined_entry_type
*native
,
991 bfd_size_type
*string_size_p
,
992 asection
**debug_string_section_p
,
993 bfd_size_type
*debug_string_size_p
)
995 unsigned int numaux
= native
->u
.syment
.n_numaux
;
996 int type
= native
->u
.syment
.n_type
;
997 int n_sclass
= (int) native
->u
.syment
.n_sclass
;
998 asection
*output_section
= symbol
->section
->output_section
999 ? symbol
->section
->output_section
1002 bfd_size_type symesz
;
1004 BFD_ASSERT (native
->is_sym
);
1006 if (native
->u
.syment
.n_sclass
== C_FILE
)
1007 symbol
->flags
|= BSF_DEBUGGING
;
1009 if (symbol
->flags
& BSF_DEBUGGING
1010 && bfd_is_abs_section (symbol
->section
))
1011 native
->u
.syment
.n_scnum
= N_DEBUG
;
1013 else if (bfd_is_abs_section (symbol
->section
))
1014 native
->u
.syment
.n_scnum
= N_ABS
;
1016 else if (bfd_is_und_section (symbol
->section
))
1017 native
->u
.syment
.n_scnum
= N_UNDEF
;
1020 native
->u
.syment
.n_scnum
=
1021 output_section
->target_index
;
1023 coff_fix_symbol_name (abfd
, symbol
, native
, string_size_p
,
1024 debug_string_section_p
, debug_string_size_p
);
1026 symesz
= bfd_coff_symesz (abfd
);
1027 buf
= bfd_alloc (abfd
, symesz
);
1030 bfd_coff_swap_sym_out (abfd
, &native
->u
.syment
, buf
);
1031 if (bfd_bwrite (buf
, symesz
, abfd
) != symesz
)
1033 bfd_release (abfd
, buf
);
1035 if (native
->u
.syment
.n_numaux
> 0)
1037 bfd_size_type auxesz
;
1040 auxesz
= bfd_coff_auxesz (abfd
);
1041 buf
= bfd_alloc (abfd
, auxesz
);
1044 for (j
= 0; j
< native
->u
.syment
.n_numaux
; j
++)
1046 BFD_ASSERT (! (native
+ j
+ 1)->is_sym
);
1047 bfd_coff_swap_aux_out (abfd
,
1048 &((native
+ j
+ 1)->u
.auxent
),
1049 type
, n_sclass
, (int) j
,
1050 native
->u
.syment
.n_numaux
,
1052 if (bfd_bwrite (buf
, auxesz
, abfd
) != auxesz
)
1055 bfd_release (abfd
, buf
);
1058 /* Store the index for use when we write out the relocs. */
1059 set_index (symbol
, *written
);
1061 *written
+= numaux
+ 1;
1065 /* Write out a symbol to a COFF file that does not come from a COFF
1066 file originally. This symbol may have been created by the linker,
1067 or we may be linking a non COFF file to a COFF file. */
1070 coff_write_alien_symbol (bfd
*abfd
,
1072 struct internal_syment
*isym
,
1074 bfd_size_type
*string_size_p
,
1075 asection
**debug_string_section_p
,
1076 bfd_size_type
*debug_string_size_p
)
1078 combined_entry_type
*native
;
1079 combined_entry_type dummy
[2];
1080 asection
*output_section
= symbol
->section
->output_section
1081 ? symbol
->section
->output_section
1083 struct bfd_link_info
*link_info
= coff_data (abfd
)->link_info
;
1086 if ((!link_info
|| link_info
->strip_discarded
)
1087 && !bfd_is_abs_section (symbol
->section
)
1088 && symbol
->section
->output_section
== bfd_abs_section_ptr
)
1092 memset (isym
, 0, sizeof (*isym
));
1096 native
->is_sym
= TRUE
;
1097 native
[1].is_sym
= FALSE
;
1098 native
->u
.syment
.n_type
= T_NULL
;
1099 native
->u
.syment
.n_flags
= 0;
1100 native
->u
.syment
.n_numaux
= 0;
1101 if (bfd_is_und_section (symbol
->section
))
1103 native
->u
.syment
.n_scnum
= N_UNDEF
;
1104 native
->u
.syment
.n_value
= symbol
->value
;
1106 else if (bfd_is_com_section (symbol
->section
))
1108 native
->u
.syment
.n_scnum
= N_UNDEF
;
1109 native
->u
.syment
.n_value
= symbol
->value
;
1111 else if (symbol
->flags
& BSF_FILE
)
1113 native
->u
.syment
.n_scnum
= N_DEBUG
;
1114 native
->u
.syment
.n_numaux
= 1;
1116 else if (symbol
->flags
& BSF_DEBUGGING
)
1118 /* There isn't much point to writing out a debugging symbol
1119 unless we are prepared to convert it into COFF debugging
1120 format. So, we just ignore them. We must clobber the symbol
1121 name to keep it from being put in the string table. */
1124 memset (isym
, 0, sizeof (*isym
));
1129 native
->u
.syment
.n_scnum
= output_section
->target_index
;
1130 native
->u
.syment
.n_value
= (symbol
->value
1131 + symbol
->section
->output_offset
);
1132 if (! obj_pe (abfd
))
1133 native
->u
.syment
.n_value
+= output_section
->vma
;
1135 /* Copy the any flags from the file header into the symbol.
1138 coff_symbol_type
*c
= coff_symbol_from (abfd
, symbol
);
1139 if (c
!= (coff_symbol_type
*) NULL
)
1140 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (&c
->symbol
)->flags
;
1144 native
->u
.syment
.n_type
= 0;
1145 if (symbol
->flags
& BSF_FILE
)
1146 native
->u
.syment
.n_sclass
= C_FILE
;
1147 else if (symbol
->flags
& BSF_LOCAL
)
1148 native
->u
.syment
.n_sclass
= C_STAT
;
1149 else if (symbol
->flags
& BSF_WEAK
)
1150 native
->u
.syment
.n_sclass
= obj_pe (abfd
) ? C_NT_WEAK
: C_WEAKEXT
;
1152 native
->u
.syment
.n_sclass
= C_EXT
;
1154 ret
= coff_write_symbol (abfd
, symbol
, native
, written
, string_size_p
,
1155 debug_string_section_p
, debug_string_size_p
);
1157 *isym
= native
->u
.syment
;
1161 /* Write a native symbol to a COFF file. */
1164 coff_write_native_symbol (bfd
*abfd
,
1165 coff_symbol_type
*symbol
,
1167 bfd_size_type
*string_size_p
,
1168 asection
**debug_string_section_p
,
1169 bfd_size_type
*debug_string_size_p
)
1171 combined_entry_type
*native
= symbol
->native
;
1172 alent
*lineno
= symbol
->lineno
;
1173 struct bfd_link_info
*link_info
= coff_data (abfd
)->link_info
;
1175 if ((!link_info
|| link_info
->strip_discarded
)
1176 && !bfd_is_abs_section (symbol
->symbol
.section
)
1177 && symbol
->symbol
.section
->output_section
== bfd_abs_section_ptr
)
1179 symbol
->symbol
.name
= "";
1183 BFD_ASSERT (native
->is_sym
);
1184 /* If this symbol has an associated line number, we must store the
1185 symbol index in the line number field. We also tag the auxent to
1186 point to the right place in the lineno table. */
1187 if (lineno
&& !symbol
->done_lineno
&& symbol
->symbol
.section
->owner
!= NULL
)
1189 unsigned int count
= 0;
1191 lineno
[count
].u
.offset
= *written
;
1192 if (native
->u
.syment
.n_numaux
)
1194 union internal_auxent
*a
= &((native
+ 1)->u
.auxent
);
1196 a
->x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
=
1197 symbol
->symbol
.section
->output_section
->moving_line_filepos
;
1200 /* Count and relocate all other linenumbers. */
1202 while (lineno
[count
].line_number
!= 0)
1204 lineno
[count
].u
.offset
+=
1205 (symbol
->symbol
.section
->output_section
->vma
1206 + symbol
->symbol
.section
->output_offset
);
1209 symbol
->done_lineno
= TRUE
;
1211 if (! bfd_is_const_section (symbol
->symbol
.section
->output_section
))
1212 symbol
->symbol
.section
->output_section
->moving_line_filepos
+=
1213 count
* bfd_coff_linesz (abfd
);
1216 return coff_write_symbol (abfd
, &(symbol
->symbol
), native
, written
,
1217 string_size_p
, debug_string_section_p
,
1218 debug_string_size_p
);
1222 null_error_handler (const char * fmt ATTRIBUTE_UNUSED
, ...)
1226 /* Write out the COFF symbols. */
1229 coff_write_symbols (bfd
*abfd
)
1231 bfd_size_type string_size
;
1232 asection
*debug_string_section
;
1233 bfd_size_type debug_string_size
;
1235 unsigned int limit
= bfd_get_symcount (abfd
);
1236 bfd_vma written
= 0;
1240 debug_string_section
= NULL
;
1241 debug_string_size
= 0;
1243 /* If this target supports long section names, they must be put into
1244 the string table. This is supported by PE. This code must
1245 handle section names just as they are handled in
1246 coff_write_object_contents. */
1247 if (bfd_coff_long_section_names (abfd
))
1251 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1255 len
= strlen (o
->name
);
1257 string_size
+= len
+ 1;
1261 /* Seek to the right place. */
1262 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0)
1265 /* Output all the symbols we have. */
1267 for (p
= abfd
->outsymbols
, i
= 0; i
< limit
; i
++, p
++)
1269 asymbol
*symbol
= *p
;
1270 coff_symbol_type
*c_symbol
= coff_symbol_from (abfd
, symbol
);
1272 if (c_symbol
== (coff_symbol_type
*) NULL
1273 || c_symbol
->native
== (combined_entry_type
*) NULL
)
1275 if (!coff_write_alien_symbol (abfd
, symbol
, NULL
, &written
,
1276 &string_size
, &debug_string_section
,
1277 &debug_string_size
))
1282 if (coff_backend_info (abfd
)->_bfd_coff_classify_symbol
!= NULL
)
1284 bfd_error_handler_type current_error_handler
;
1285 enum coff_symbol_classification sym_class
;
1286 unsigned char *n_sclass
;
1288 /* Suppress error reporting by bfd_coff_classify_symbol.
1289 Error messages can be generated when we are processing a local
1290 symbol which has no associated section and we do not have to
1291 worry about this, all we need to know is that it is local. */
1292 current_error_handler
= bfd_set_error_handler (null_error_handler
);
1293 BFD_ASSERT (c_symbol
->native
->is_sym
);
1294 sym_class
= bfd_coff_classify_symbol (abfd
,
1295 &c_symbol
->native
->u
.syment
);
1296 (void) bfd_set_error_handler (current_error_handler
);
1298 n_sclass
= &c_symbol
->native
->u
.syment
.n_sclass
;
1300 /* If the symbol class has been changed (eg objcopy/ld script/etc)
1301 we cannot retain the existing sclass from the original symbol.
1302 Weak symbols only have one valid sclass, so just set it always.
1303 If it is not local class and should be, set it C_STAT.
1304 If it is global and not classified as global, or if it is
1305 weak (which is also classified as global), set it C_EXT. */
1307 if (symbol
->flags
& BSF_WEAK
)
1308 *n_sclass
= obj_pe (abfd
) ? C_NT_WEAK
: C_WEAKEXT
;
1309 else if (symbol
->flags
& BSF_LOCAL
&& sym_class
!= COFF_SYMBOL_LOCAL
)
1311 else if (symbol
->flags
& BSF_GLOBAL
1312 && (sym_class
!= COFF_SYMBOL_GLOBAL
1314 || *n_sclass
== C_NT_WEAK
1316 || *n_sclass
== C_WEAKEXT
))
1317 c_symbol
->native
->u
.syment
.n_sclass
= C_EXT
;
1320 if (!coff_write_native_symbol (abfd
, c_symbol
, &written
,
1321 &string_size
, &debug_string_section
,
1322 &debug_string_size
))
1327 obj_raw_syment_count (abfd
) = written
;
1329 /* Now write out strings. */
1330 if (string_size
!= 0)
1332 unsigned int size
= string_size
+ STRING_SIZE_SIZE
;
1333 bfd_byte buffer
[STRING_SIZE_SIZE
];
1335 #if STRING_SIZE_SIZE == 4
1336 H_PUT_32 (abfd
, size
, buffer
);
1338 #error Change H_PUT_32
1340 if (bfd_bwrite ((void *) buffer
, (bfd_size_type
) sizeof (buffer
), abfd
)
1344 /* Handle long section names. This code must handle section
1345 names just as they are handled in coff_write_object_contents. */
1346 if (bfd_coff_long_section_names (abfd
))
1350 for (o
= abfd
->sections
; o
!= NULL
; o
= o
->next
)
1354 len
= strlen (o
->name
);
1357 if (bfd_bwrite (o
->name
, (bfd_size_type
) (len
+ 1), abfd
)
1364 for (p
= abfd
->outsymbols
, i
= 0;
1369 size_t name_length
= strlen (q
->name
);
1370 coff_symbol_type
*c_symbol
= coff_symbol_from (abfd
, q
);
1373 /* Figure out whether the symbol name should go in the string
1374 table. Symbol names that are short enough are stored
1375 directly in the syment structure. File names permit a
1376 different, longer, length in the syment structure. On
1377 XCOFF, some symbol names are stored in the .debug section
1378 rather than in the string table. */
1380 if (c_symbol
== NULL
1381 || c_symbol
->native
== NULL
)
1382 /* This is not a COFF symbol, so it certainly is not a
1383 file name, nor does it go in the .debug section. */
1384 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1386 else if (! c_symbol
->native
->is_sym
)
1387 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1389 else if (bfd_coff_symname_in_debug (abfd
,
1390 &c_symbol
->native
->u
.syment
))
1391 /* This symbol name is in the XCOFF .debug section.
1392 Don't write it into the string table. */
1393 maxlen
= name_length
;
1395 else if (c_symbol
->native
->u
.syment
.n_sclass
== C_FILE
1396 && c_symbol
->native
->u
.syment
.n_numaux
> 0)
1398 if (bfd_coff_force_symnames_in_strings (abfd
))
1400 if (bfd_bwrite (".file", (bfd_size_type
) 6, abfd
) != 6)
1403 maxlen
= bfd_coff_filnmlen (abfd
);
1406 maxlen
= bfd_coff_force_symnames_in_strings (abfd
) ? 0 : SYMNMLEN
;
1408 if (name_length
> maxlen
)
1410 if (bfd_bwrite ((void *) (q
->name
), (bfd_size_type
) name_length
+ 1,
1411 abfd
) != name_length
+ 1)
1418 /* We would normally not write anything here, but we'll write
1419 out 4 so that any stupid coff reader which tries to read the
1420 string table even when there isn't one won't croak. */
1421 unsigned int size
= STRING_SIZE_SIZE
;
1422 bfd_byte buffer
[STRING_SIZE_SIZE
];
1424 #if STRING_SIZE_SIZE == 4
1425 H_PUT_32 (abfd
, size
, buffer
);
1427 #error Change H_PUT_32
1429 if (bfd_bwrite ((void *) buffer
, (bfd_size_type
) STRING_SIZE_SIZE
, abfd
)
1430 != STRING_SIZE_SIZE
)
1434 /* Make sure the .debug section was created to be the correct size.
1435 We should create it ourselves on the fly, but we don't because
1436 BFD won't let us write to any section until we know how large all
1437 the sections are. We could still do it by making another pass
1438 over the symbols. FIXME. */
1439 BFD_ASSERT (debug_string_size
== 0
1440 || (debug_string_section
!= (asection
*) NULL
1441 && (BFD_ALIGN (debug_string_size
,
1442 1 << debug_string_section
->alignment_power
)
1443 == debug_string_section
->size
)));
1449 coff_write_linenumbers (bfd
*abfd
)
1452 bfd_size_type linesz
;
1455 linesz
= bfd_coff_linesz (abfd
);
1456 buff
= bfd_alloc (abfd
, linesz
);
1459 for (s
= abfd
->sections
; s
!= (asection
*) NULL
; s
= s
->next
)
1461 if (s
->lineno_count
)
1463 asymbol
**q
= abfd
->outsymbols
;
1464 if (bfd_seek (abfd
, s
->line_filepos
, SEEK_SET
) != 0)
1466 /* Find all the linenumbers in this section. */
1470 if (p
->section
->output_section
== s
)
1473 BFD_SEND (bfd_asymbol_bfd (p
), _get_lineno
,
1474 (bfd_asymbol_bfd (p
), p
));
1477 /* Found a linenumber entry, output. */
1478 struct internal_lineno out
;
1480 memset ((void *) & out
, 0, sizeof (out
));
1482 out
.l_addr
.l_symndx
= l
->u
.offset
;
1483 bfd_coff_swap_lineno_out (abfd
, &out
, buff
);
1484 if (bfd_bwrite (buff
, (bfd_size_type
) linesz
, abfd
)
1488 while (l
->line_number
)
1490 out
.l_lnno
= l
->line_number
;
1491 out
.l_addr
.l_symndx
= l
->u
.offset
;
1492 bfd_coff_swap_lineno_out (abfd
, &out
, buff
);
1493 if (bfd_bwrite (buff
, (bfd_size_type
) linesz
, abfd
)
1504 bfd_release (abfd
, buff
);
1509 coff_get_lineno (bfd
*ignore_abfd ATTRIBUTE_UNUSED
, asymbol
*symbol
)
1511 return coffsymbol (symbol
)->lineno
;
1514 /* This function transforms the offsets into the symbol table into
1515 pointers to syments. */
1518 coff_pointerize_aux (bfd
*abfd
,
1519 combined_entry_type
*table_base
,
1520 combined_entry_type
*symbol
,
1521 unsigned int indaux
,
1522 combined_entry_type
*auxent
)
1524 unsigned int type
= symbol
->u
.syment
.n_type
;
1525 unsigned int n_sclass
= symbol
->u
.syment
.n_sclass
;
1527 BFD_ASSERT (symbol
->is_sym
);
1528 if (coff_backend_info (abfd
)->_bfd_coff_pointerize_aux_hook
)
1530 if ((*coff_backend_info (abfd
)->_bfd_coff_pointerize_aux_hook
)
1531 (abfd
, table_base
, symbol
, indaux
, auxent
))
1535 /* Don't bother if this is a file or a section. */
1536 if (n_sclass
== C_STAT
&& type
== T_NULL
)
1538 if (n_sclass
== C_FILE
)
1541 BFD_ASSERT (! auxent
->is_sym
);
1542 /* Otherwise patch up. */
1543 #define N_TMASK coff_data (abfd)->local_n_tmask
1544 #define N_BTSHFT coff_data (abfd)->local_n_btshft
1546 if ((ISFCN (type
) || ISTAG (n_sclass
) || n_sclass
== C_BLOCK
1547 || n_sclass
== C_FCN
)
1548 && auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
> 0)
1550 auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
=
1551 table_base
+ auxent
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
1552 auxent
->fix_end
= 1;
1554 /* A negative tagndx is meaningless, but the SCO 3.2v4 cc can
1555 generate one, so we must be careful to ignore it. */
1556 if (auxent
->u
.auxent
.x_sym
.x_tagndx
.l
> 0)
1558 auxent
->u
.auxent
.x_sym
.x_tagndx
.p
=
1559 table_base
+ auxent
->u
.auxent
.x_sym
.x_tagndx
.l
;
1560 auxent
->fix_tag
= 1;
1564 /* Allocate space for the ".debug" section, and read it.
1565 We did not read the debug section until now, because
1566 we didn't want to go to the trouble until someone needed it. */
1569 build_debug_section (bfd
*abfd
, asection
** sect_return
)
1571 char *debug_section
;
1573 bfd_size_type sec_size
;
1575 asection
*sect
= bfd_get_section_by_name (abfd
, ".debug");
1579 bfd_set_error (bfd_error_no_debug_section
);
1583 sec_size
= sect
->size
;
1584 debug_section
= (char *) bfd_alloc (abfd
, sec_size
);
1585 if (debug_section
== NULL
)
1588 /* Seek to the beginning of the `.debug' section and read it.
1589 Save the current position first; it is needed by our caller.
1590 Then read debug section and reset the file pointer. */
1592 position
= bfd_tell (abfd
);
1593 if (bfd_seek (abfd
, sect
->filepos
, SEEK_SET
) != 0
1594 || bfd_bread (debug_section
, sec_size
, abfd
) != sec_size
1595 || bfd_seek (abfd
, position
, SEEK_SET
) != 0)
1598 * sect_return
= sect
;
1599 return debug_section
;
1602 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
1603 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
1604 be \0-terminated. */
1607 copy_name (bfd
*abfd
, char *name
, size_t maxlen
)
1612 for (len
= 0; len
< maxlen
; ++len
)
1613 if (name
[len
] == '\0')
1616 if ((newname
= (char *) bfd_alloc (abfd
, (bfd_size_type
) len
+ 1)) == NULL
)
1619 strncpy (newname
, name
, len
);
1620 newname
[len
] = '\0';
1624 /* Read in the external symbols. */
1627 _bfd_coff_get_external_symbols (bfd
*abfd
)
1629 bfd_size_type symesz
;
1633 if (obj_coff_external_syms (abfd
) != NULL
)
1636 symesz
= bfd_coff_symesz (abfd
);
1638 size
= obj_raw_syment_count (abfd
) * symesz
;
1642 syms
= bfd_malloc (size
);
1646 if (bfd_seek (abfd
, obj_sym_filepos (abfd
), SEEK_SET
) != 0
1647 || bfd_bread (syms
, size
, abfd
) != size
)
1654 obj_coff_external_syms (abfd
) = syms
;
1659 /* Read in the external strings. The strings are not loaded until
1660 they are needed. This is because we have no simple way of
1661 detecting a missing string table in an archive. If the strings
1662 are loaded then the STRINGS and STRINGS_LEN fields in the
1663 coff_tdata structure will be set. */
1666 _bfd_coff_read_string_table (bfd
*abfd
)
1668 char extstrsize
[STRING_SIZE_SIZE
];
1669 bfd_size_type strsize
;
1673 if (obj_coff_strings (abfd
) != NULL
)
1674 return obj_coff_strings (abfd
);
1676 if (obj_sym_filepos (abfd
) == 0)
1678 bfd_set_error (bfd_error_no_symbols
);
1682 pos
= obj_sym_filepos (abfd
);
1683 pos
+= obj_raw_syment_count (abfd
) * bfd_coff_symesz (abfd
);
1684 if (bfd_seek (abfd
, pos
, SEEK_SET
) != 0)
1687 if (bfd_bread (extstrsize
, (bfd_size_type
) sizeof extstrsize
, abfd
)
1688 != sizeof extstrsize
)
1690 if (bfd_get_error () != bfd_error_file_truncated
)
1693 /* There is no string table. */
1694 strsize
= STRING_SIZE_SIZE
;
1698 #if STRING_SIZE_SIZE == 4
1699 strsize
= H_GET_32 (abfd
, extstrsize
);
1701 #error Change H_GET_32
1705 if (strsize
< STRING_SIZE_SIZE
)
1707 (*_bfd_error_handler
)
1708 (_("%B: bad string table size %lu"), abfd
, (unsigned long) strsize
);
1709 bfd_set_error (bfd_error_bad_value
);
1713 strings
= (char *) bfd_malloc (strsize
+ 1);
1714 if (strings
== NULL
)
1717 /* PR 17521 file: 079-54929-0.004.
1718 A corrupt file could contain an index that points into the first
1719 STRING_SIZE_SIZE bytes of the string table, so make sure that
1721 memset (strings
, 0, STRING_SIZE_SIZE
);
1723 if (bfd_bread (strings
+ STRING_SIZE_SIZE
, strsize
- STRING_SIZE_SIZE
, abfd
)
1724 != strsize
- STRING_SIZE_SIZE
)
1730 obj_coff_strings (abfd
) = strings
;
1731 obj_coff_strings_len (abfd
) = strsize
;
1732 /* Terminate the string table, just in case. */
1733 strings
[strsize
] = 0;
1737 /* Free up the external symbols and strings read from a COFF file. */
1740 _bfd_coff_free_symbols (bfd
*abfd
)
1742 if (obj_coff_external_syms (abfd
) != NULL
1743 && ! obj_coff_keep_syms (abfd
))
1745 free (obj_coff_external_syms (abfd
));
1746 obj_coff_external_syms (abfd
) = NULL
;
1748 if (obj_coff_strings (abfd
) != NULL
1749 && ! obj_coff_keep_strings (abfd
))
1751 free (obj_coff_strings (abfd
));
1752 obj_coff_strings (abfd
) = NULL
;
1753 obj_coff_strings_len (abfd
) = 0;
1758 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
1759 knit the symbol names into a normalized form. By normalized here I
1760 mean that all symbols have an n_offset pointer that points to a null-
1761 terminated string. */
1763 combined_entry_type
*
1764 coff_get_normalized_symtab (bfd
*abfd
)
1766 combined_entry_type
*internal
;
1767 combined_entry_type
*internal_ptr
;
1768 combined_entry_type
*symbol_ptr
;
1769 combined_entry_type
*internal_end
;
1773 const char *string_table
= NULL
;
1774 asection
* debug_sec
= NULL
;
1775 char *debug_sec_data
= NULL
;
1778 if (obj_raw_syments (abfd
) != NULL
)
1779 return obj_raw_syments (abfd
);
1781 if (! _bfd_coff_get_external_symbols (abfd
))
1784 size
= obj_raw_syment_count (abfd
) * sizeof (combined_entry_type
);
1785 internal
= (combined_entry_type
*) bfd_zalloc (abfd
, size
);
1786 if (internal
== NULL
&& size
!= 0)
1788 internal_end
= internal
+ obj_raw_syment_count (abfd
);
1790 raw_src
= (char *) obj_coff_external_syms (abfd
);
1792 /* Mark the end of the symbols. */
1793 symesz
= bfd_coff_symesz (abfd
);
1794 raw_end
= (char *) raw_src
+ obj_raw_syment_count (abfd
) * symesz
;
1796 /* FIXME SOMEDAY. A string table size of zero is very weird, but
1797 probably possible. If one shows up, it will probably kill us. */
1799 /* Swap all the raw entries. */
1800 for (internal_ptr
= internal
;
1802 raw_src
+= symesz
, internal_ptr
++)
1806 bfd_coff_swap_sym_in (abfd
, (void *) raw_src
,
1807 (void *) & internal_ptr
->u
.syment
);
1808 symbol_ptr
= internal_ptr
;
1809 internal_ptr
->is_sym
= TRUE
;
1811 /* PR 17512: file: 1353-1166-0.004. */
1812 if (symbol_ptr
->u
.syment
.n_sclass
== C_FILE
1813 && symbol_ptr
->u
.syment
.n_numaux
> 0
1814 && raw_src
+ symesz
+ symbol_ptr
->u
.syment
.n_numaux
1815 * sizeof (union internal_auxent
) >= raw_end
)
1817 bfd_release (abfd
, internal
);
1822 i
< symbol_ptr
->u
.syment
.n_numaux
;
1826 /* PR 17512: Prevent buffer overrun. */
1827 if (internal_ptr
>= internal_end
)
1829 bfd_release (abfd
, internal
);
1835 bfd_coff_swap_aux_in (abfd
, (void *) raw_src
,
1836 symbol_ptr
->u
.syment
.n_type
,
1837 symbol_ptr
->u
.syment
.n_sclass
,
1838 (int) i
, symbol_ptr
->u
.syment
.n_numaux
,
1839 &(internal_ptr
->u
.auxent
));
1841 internal_ptr
->is_sym
= FALSE
;
1842 coff_pointerize_aux (abfd
, internal
, symbol_ptr
, i
,
1847 /* Free the raw symbols, but not the strings (if we have them). */
1848 obj_coff_keep_strings (abfd
) = TRUE
;
1849 if (! _bfd_coff_free_symbols (abfd
))
1852 for (internal_ptr
= internal
; internal_ptr
< internal_end
;
1855 BFD_ASSERT (internal_ptr
->is_sym
);
1857 if (internal_ptr
->u
.syment
.n_sclass
== C_FILE
1858 && internal_ptr
->u
.syment
.n_numaux
> 0)
1860 combined_entry_type
* aux
= internal_ptr
+ 1;
1862 /* Make a file symbol point to the name in the auxent, since
1863 the text ".file" is redundant. */
1864 BFD_ASSERT (! aux
->is_sym
);
1866 if (aux
->u
.auxent
.x_file
.x_n
.x_zeroes
== 0)
1868 /* The filename is a long one, point into the string table. */
1869 if (string_table
== NULL
)
1871 string_table
= _bfd_coff_read_string_table (abfd
);
1872 if (string_table
== NULL
)
1876 if ((bfd_size_type
)(aux
->u
.auxent
.x_file
.x_n
.x_offset
)
1877 >= obj_coff_strings_len (abfd
))
1878 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1880 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1881 (bfd_hostptr_t
) (string_table
+ (aux
->u
.auxent
.x_file
.x_n
.x_offset
));
1885 /* Ordinary short filename, put into memory anyway. The
1886 Microsoft PE tools sometimes store a filename in
1887 multiple AUX entries. */
1888 if (internal_ptr
->u
.syment
.n_numaux
> 1
1889 && coff_data (abfd
)->pe
)
1890 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1893 aux
->u
.auxent
.x_file
.x_fname
,
1894 internal_ptr
->u
.syment
.n_numaux
* symesz
);
1896 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1899 aux
->u
.auxent
.x_file
.x_fname
,
1900 (size_t) bfd_coff_filnmlen (abfd
)));
1905 if (internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
!= 0)
1907 /* This is a "short" name. Make it long. */
1911 /* Find the length of this string without walking into memory
1913 for (i
= 0; i
< 8; ++i
)
1914 if (internal_ptr
->u
.syment
._n
._n_name
[i
] == '\0')
1917 newstring
= (char *) bfd_zalloc (abfd
, (bfd_size_type
) (i
+ 1));
1918 if (newstring
== NULL
)
1920 strncpy (newstring
, internal_ptr
->u
.syment
._n
._n_name
, i
);
1921 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) newstring
;
1922 internal_ptr
->u
.syment
._n
._n_n
._n_zeroes
= 0;
1924 else if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
== 0)
1925 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) "";
1926 else if (!bfd_coff_symname_in_debug (abfd
, &internal_ptr
->u
.syment
))
1928 /* Long name already. Point symbol at the string in the
1930 if (string_table
== NULL
)
1932 string_table
= _bfd_coff_read_string_table (abfd
);
1933 if (string_table
== NULL
)
1936 if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
>= obj_coff_strings_len (abfd
)
1937 || string_table
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
< string_table
)
1938 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1940 internal_ptr
->u
.syment
._n
._n_n
._n_offset
=
1943 + internal_ptr
->u
.syment
._n
._n_n
._n_offset
));
1947 /* Long name in debug section. Very similar. */
1948 if (debug_sec_data
== NULL
)
1949 debug_sec_data
= build_debug_section (abfd
, & debug_sec
);
1950 if (debug_sec_data
!= NULL
)
1952 BFD_ASSERT (debug_sec
!= NULL
);
1953 /* PR binutils/17512: Catch out of range offsets into the debug data. */
1954 if (internal_ptr
->u
.syment
._n
._n_n
._n_offset
> debug_sec
->size
1955 || debug_sec_data
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
< debug_sec_data
)
1956 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) _("<corrupt>");
1958 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
)
1959 (debug_sec_data
+ internal_ptr
->u
.syment
._n
._n_n
._n_offset
);
1962 internal_ptr
->u
.syment
._n
._n_n
._n_offset
= (bfd_hostptr_t
) "";
1965 internal_ptr
+= internal_ptr
->u
.syment
.n_numaux
;
1968 obj_raw_syments (abfd
) = internal
;
1969 BFD_ASSERT (obj_raw_syment_count (abfd
)
1970 == (unsigned int) (internal_ptr
- internal
));
1976 coff_get_reloc_upper_bound (bfd
*abfd
, sec_ptr asect
)
1978 if (bfd_get_format (abfd
) != bfd_object
)
1980 bfd_set_error (bfd_error_invalid_operation
);
1983 return (asect
->reloc_count
+ 1) * sizeof (arelent
*);
1987 coff_make_empty_symbol (bfd
*abfd
)
1989 bfd_size_type amt
= sizeof (coff_symbol_type
);
1990 coff_symbol_type
*new_symbol
= (coff_symbol_type
*) bfd_zalloc (abfd
, amt
);
1992 if (new_symbol
== NULL
)
1994 new_symbol
->symbol
.section
= 0;
1995 new_symbol
->native
= NULL
;
1996 new_symbol
->lineno
= NULL
;
1997 new_symbol
->done_lineno
= FALSE
;
1998 new_symbol
->symbol
.the_bfd
= abfd
;
2000 return & new_symbol
->symbol
;
2003 /* Make a debugging symbol. */
2006 coff_bfd_make_debug_symbol (bfd
*abfd
,
2007 void * ptr ATTRIBUTE_UNUSED
,
2008 unsigned long sz ATTRIBUTE_UNUSED
)
2010 bfd_size_type amt
= sizeof (coff_symbol_type
);
2011 coff_symbol_type
*new_symbol
= (coff_symbol_type
*) bfd_alloc (abfd
, amt
);
2013 if (new_symbol
== NULL
)
2015 /* @@ The 10 is a guess at a plausible maximum number of aux entries
2016 (but shouldn't be a constant). */
2017 amt
= sizeof (combined_entry_type
) * 10;
2018 new_symbol
->native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
2019 if (!new_symbol
->native
)
2021 new_symbol
->native
->is_sym
= TRUE
;
2022 new_symbol
->symbol
.section
= bfd_abs_section_ptr
;
2023 new_symbol
->symbol
.flags
= BSF_DEBUGGING
;
2024 new_symbol
->lineno
= NULL
;
2025 new_symbol
->done_lineno
= FALSE
;
2026 new_symbol
->symbol
.the_bfd
= abfd
;
2028 return & new_symbol
->symbol
;
2032 coff_get_symbol_info (bfd
*abfd
, asymbol
*symbol
, symbol_info
*ret
)
2034 bfd_symbol_info (symbol
, ret
);
2036 if (coffsymbol (symbol
)->native
!= NULL
2037 && coffsymbol (symbol
)->native
->fix_value
2038 && coffsymbol (symbol
)->native
->is_sym
)
2039 ret
->value
= coffsymbol (symbol
)->native
->u
.syment
.n_value
-
2040 (bfd_hostptr_t
) obj_raw_syments (abfd
);
2043 /* Return the COFF syment for a symbol. */
2046 bfd_coff_get_syment (bfd
*abfd
,
2048 struct internal_syment
*psyment
)
2050 coff_symbol_type
*csym
;
2052 csym
= coff_symbol_from (abfd
, symbol
);
2053 if (csym
== NULL
|| csym
->native
== NULL
2054 || ! csym
->native
->is_sym
)
2056 bfd_set_error (bfd_error_invalid_operation
);
2060 *psyment
= csym
->native
->u
.syment
;
2062 if (csym
->native
->fix_value
)
2063 psyment
->n_value
= psyment
->n_value
-
2064 (bfd_hostptr_t
) obj_raw_syments (abfd
);
2066 /* FIXME: We should handle fix_line here. */
2071 /* Return the COFF auxent for a symbol. */
2074 bfd_coff_get_auxent (bfd
*abfd
,
2077 union internal_auxent
*pauxent
)
2079 coff_symbol_type
*csym
;
2080 combined_entry_type
*ent
;
2082 csym
= coff_symbol_from (abfd
, symbol
);
2085 || csym
->native
== NULL
2086 || ! csym
->native
->is_sym
2087 || indx
>= csym
->native
->u
.syment
.n_numaux
)
2089 bfd_set_error (bfd_error_invalid_operation
);
2093 ent
= csym
->native
+ indx
+ 1;
2095 BFD_ASSERT (! ent
->is_sym
);
2096 *pauxent
= ent
->u
.auxent
;
2099 pauxent
->x_sym
.x_tagndx
.l
=
2100 ((combined_entry_type
*) pauxent
->x_sym
.x_tagndx
.p
2101 - obj_raw_syments (abfd
));
2104 pauxent
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
=
2105 ((combined_entry_type
*) pauxent
->x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2106 - obj_raw_syments (abfd
));
2108 if (ent
->fix_scnlen
)
2109 pauxent
->x_csect
.x_scnlen
.l
=
2110 ((combined_entry_type
*) pauxent
->x_csect
.x_scnlen
.p
2111 - obj_raw_syments (abfd
));
2116 /* Print out information about COFF symbol. */
2119 coff_print_symbol (bfd
*abfd
,
2122 bfd_print_symbol_type how
)
2124 FILE * file
= (FILE *) filep
;
2128 case bfd_print_symbol_name
:
2129 fprintf (file
, "%s", symbol
->name
);
2132 case bfd_print_symbol_more
:
2133 fprintf (file
, "coff %s %s",
2134 coffsymbol (symbol
)->native
? "n" : "g",
2135 coffsymbol (symbol
)->lineno
? "l" : " ");
2138 case bfd_print_symbol_all
:
2139 if (coffsymbol (symbol
)->native
)
2143 combined_entry_type
*combined
= coffsymbol (symbol
)->native
;
2144 combined_entry_type
*root
= obj_raw_syments (abfd
);
2145 struct lineno_cache_entry
*l
= coffsymbol (symbol
)->lineno
;
2147 fprintf (file
, "[%3ld]", (long) (combined
- root
));
2149 /* PR 17512: file: 079-33786-0.001:0.1. */
2150 if (combined
< obj_raw_syments (abfd
)
2151 || combined
>= obj_raw_syments (abfd
) + obj_raw_syment_count (abfd
))
2153 fprintf (file
, _("<corrupt info> %s"), symbol
->name
);
2157 BFD_ASSERT (combined
->is_sym
);
2158 if (! combined
->fix_value
)
2159 val
= (bfd_vma
) combined
->u
.syment
.n_value
;
2161 val
= combined
->u
.syment
.n_value
- (bfd_hostptr_t
) root
;
2163 fprintf (file
, "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x",
2164 combined
->u
.syment
.n_scnum
,
2165 combined
->u
.syment
.n_flags
,
2166 combined
->u
.syment
.n_type
,
2167 combined
->u
.syment
.n_sclass
,
2168 combined
->u
.syment
.n_numaux
);
2169 bfd_fprintf_vma (abfd
, file
, val
);
2170 fprintf (file
, " %s", symbol
->name
);
2172 for (aux
= 0; aux
< combined
->u
.syment
.n_numaux
; aux
++)
2174 combined_entry_type
*auxp
= combined
+ aux
+ 1;
2177 BFD_ASSERT (! auxp
->is_sym
);
2179 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.p
- root
;
2181 tagndx
= auxp
->u
.auxent
.x_sym
.x_tagndx
.l
;
2183 fprintf (file
, "\n");
2185 if (bfd_coff_print_aux (abfd
, file
, root
, combined
, auxp
, aux
))
2188 switch (combined
->u
.syment
.n_sclass
)
2191 fprintf (file
, "File ");
2195 if (combined
->u
.syment
.n_type
== T_NULL
)
2196 /* Probably a section symbol ? */
2198 fprintf (file
, "AUX scnlen 0x%lx nreloc %d nlnno %d",
2199 (unsigned long) auxp
->u
.auxent
.x_scn
.x_scnlen
,
2200 auxp
->u
.auxent
.x_scn
.x_nreloc
,
2201 auxp
->u
.auxent
.x_scn
.x_nlinno
);
2202 if (auxp
->u
.auxent
.x_scn
.x_checksum
!= 0
2203 || auxp
->u
.auxent
.x_scn
.x_associated
!= 0
2204 || auxp
->u
.auxent
.x_scn
.x_comdat
!= 0)
2205 fprintf (file
, " checksum 0x%lx assoc %d comdat %d",
2206 auxp
->u
.auxent
.x_scn
.x_checksum
,
2207 auxp
->u
.auxent
.x_scn
.x_associated
,
2208 auxp
->u
.auxent
.x_scn
.x_comdat
);
2211 /* Otherwise fall through. */
2214 if (ISFCN (combined
->u
.syment
.n_type
))
2219 next
= (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2222 next
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.l
;
2223 llnos
= auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_lnnoptr
;
2225 "AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld",
2227 (unsigned long) auxp
->u
.auxent
.x_sym
.x_misc
.x_fsize
,
2231 /* Otherwise fall through. */
2233 fprintf (file
, "AUX lnno %d size 0x%x tagndx %ld",
2234 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_lnno
,
2235 auxp
->u
.auxent
.x_sym
.x_misc
.x_lnsz
.x_size
,
2238 fprintf (file
, " endndx %ld",
2240 (auxp
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
2248 fprintf (file
, "\n%s :", l
->u
.sym
->name
);
2250 while (l
->line_number
)
2252 if (l
->line_number
> 0)
2254 fprintf (file
, "\n%4d : ", l
->line_number
);
2255 bfd_fprintf_vma (abfd
, file
, l
->u
.offset
+ symbol
->section
->vma
);
2263 bfd_print_symbol_vandf (abfd
, (void *) file
, symbol
);
2264 fprintf (file
, " %-5s %s %s %s",
2265 symbol
->section
->name
,
2266 coffsymbol (symbol
)->native
? "n" : "g",
2267 coffsymbol (symbol
)->lineno
? "l" : " ",
2273 /* Return whether a symbol name implies a local symbol. In COFF,
2274 local symbols generally start with ``.L''. Most targets use this
2275 function for the is_local_label_name entry point, but some may
2279 _bfd_coff_is_local_label_name (bfd
*abfd ATTRIBUTE_UNUSED
,
2282 return name
[0] == '.' && name
[1] == 'L';
2285 /* Provided a BFD, a section and an offset (in bytes, not octets) into the
2286 section, calculate and return the name of the source file and the line
2287 nearest to the wanted location. */
2290 coff_find_nearest_line_with_names (bfd
*abfd
,
2294 const char **filename_ptr
,
2295 const char **functionname_ptr
,
2296 unsigned int *line_ptr
,
2297 const struct dwarf_debug_section
*debug_sections
)
2301 unsigned int line_base
;
2302 coff_data_type
*cof
= coff_data (abfd
);
2303 /* Run through the raw syments if available. */
2304 combined_entry_type
*p
;
2305 combined_entry_type
*pend
;
2307 struct coff_section_tdata
*sec_data
;
2310 /* Before looking through the symbol table, try to use a .stab
2311 section to find the information. */
2312 if (! _bfd_stab_section_find_nearest_line (abfd
, symbols
, section
, offset
,
2313 &found
, filename_ptr
,
2314 functionname_ptr
, line_ptr
,
2315 &coff_data(abfd
)->line_info
))
2321 /* Also try examining DWARF2 debugging information. */
2322 if (_bfd_dwarf2_find_nearest_line (abfd
, symbols
, NULL
, section
, offset
,
2323 filename_ptr
, functionname_ptr
,
2324 line_ptr
, NULL
, debug_sections
, 0,
2325 &coff_data(abfd
)->dwarf2_find_line_info
))
2329 *functionname_ptr
= 0;
2332 /* Don't try and find line numbers in a non coff file. */
2333 if (!bfd_family_coff (abfd
))
2339 /* Find the first C_FILE symbol. */
2340 p
= cof
->raw_syments
;
2344 pend
= p
+ cof
->raw_syment_count
;
2347 BFD_ASSERT (p
->is_sym
);
2348 if (p
->u
.syment
.n_sclass
== C_FILE
)
2350 p
+= 1 + p
->u
.syment
.n_numaux
;
2358 /* Look through the C_FILE symbols to find the best one. */
2359 sec_vma
= bfd_get_section_vma (abfd
, section
);
2360 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2361 maxdiff
= (bfd_vma
) 0 - (bfd_vma
) 1;
2365 combined_entry_type
*p2
;
2367 for (p2
= p
+ 1 + p
->u
.syment
.n_numaux
;
2369 p2
+= 1 + p2
->u
.syment
.n_numaux
)
2371 BFD_ASSERT (p2
->is_sym
);
2372 if (p2
->u
.syment
.n_scnum
> 0
2374 == coff_section_from_bfd_index (abfd
,
2375 p2
->u
.syment
.n_scnum
)))
2377 if (p2
->u
.syment
.n_sclass
== C_FILE
)
2386 file_addr
= (bfd_vma
) p2
->u
.syment
.n_value
;
2387 /* PR 11512: Include the section address of the function name symbol. */
2388 if (p2
->u
.syment
.n_scnum
> 0)
2389 file_addr
+= coff_section_from_bfd_index (abfd
,
2390 p2
->u
.syment
.n_scnum
)->vma
;
2391 /* We use <= MAXDIFF here so that if we get a zero length
2392 file, we actually use the next file entry. */
2394 && offset
+ sec_vma
>= file_addr
2395 && offset
+ sec_vma
- file_addr
<= maxdiff
)
2397 *filename_ptr
= (char *) p
->u
.syment
._n
._n_n
._n_offset
;
2398 maxdiff
= offset
+ sec_vma
- p2
->u
.syment
.n_value
;
2401 /* Avoid endless loops on erroneous files by ensuring that
2402 we always move forward in the file. */
2403 if (p
>= cof
->raw_syments
+ p
->u
.syment
.n_value
)
2406 p
= cof
->raw_syments
+ p
->u
.syment
.n_value
;
2407 if (p
> pend
|| p
->u
.syment
.n_sclass
!= C_FILE
)
2412 /* Now wander though the raw linenumbers of the section. */
2413 /* If we have been called on this section before, and the offset we
2414 want is further down then we can prime the lookup loop. */
2415 sec_data
= coff_section_data (abfd
, section
);
2416 if (sec_data
!= NULL
2418 && offset
>= sec_data
->offset
)
2421 *functionname_ptr
= sec_data
->function
;
2422 line_base
= sec_data
->line_base
;
2430 if (section
->lineno
!= NULL
)
2432 bfd_vma last_value
= 0;
2434 l
= §ion
->lineno
[i
];
2436 for (; i
< section
->lineno_count
; i
++)
2438 if (l
->line_number
== 0)
2440 /* Get the symbol this line number points at. */
2441 coff_symbol_type
*coff
= (coff_symbol_type
*) (l
->u
.sym
);
2442 if (coff
->symbol
.value
> offset
)
2444 *functionname_ptr
= coff
->symbol
.name
;
2445 last_value
= coff
->symbol
.value
;
2448 combined_entry_type
*s
= coff
->native
;
2450 BFD_ASSERT (s
->is_sym
);
2451 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2453 /* In XCOFF a debugging symbol can follow the
2455 if (s
->u
.syment
.n_scnum
== N_DEBUG
)
2456 s
= s
+ 1 + s
->u
.syment
.n_numaux
;
2458 /* S should now point to the .bf of the function. */
2459 if (s
->u
.syment
.n_numaux
)
2461 /* The linenumber is stored in the auxent. */
2462 union internal_auxent
*a
= &((s
+ 1)->u
.auxent
);
2464 line_base
= a
->x_sym
.x_misc
.x_lnsz
.x_lnno
;
2465 *line_ptr
= line_base
;
2471 if (l
->u
.offset
> offset
)
2473 *line_ptr
= l
->line_number
+ line_base
- 1;
2478 /* If we fell off the end of the loop, then assume that this
2479 symbol has no line number info. Otherwise, symbols with no
2480 line number info get reported with the line number of the
2481 last line of the last symbol which does have line number
2482 info. We use 0x100 as a slop to account for cases where the
2483 last line has executable code. */
2484 if (i
>= section
->lineno_count
2486 && offset
- last_value
> 0x100)
2488 *functionname_ptr
= NULL
;
2493 /* Cache the results for the next call. */
2494 if (sec_data
== NULL
&& section
->owner
== abfd
)
2496 amt
= sizeof (struct coff_section_tdata
);
2497 section
->used_by_bfd
= bfd_zalloc (abfd
, amt
);
2498 sec_data
= (struct coff_section_tdata
*) section
->used_by_bfd
;
2500 if (sec_data
!= NULL
)
2502 sec_data
->offset
= offset
;
2503 sec_data
->i
= i
- 1;
2504 sec_data
->function
= *functionname_ptr
;
2505 sec_data
->line_base
= line_base
;
2512 coff_find_nearest_line (bfd
*abfd
,
2516 const char **filename_ptr
,
2517 const char **functionname_ptr
,
2518 unsigned int *line_ptr
,
2519 unsigned int *discriminator_ptr
)
2521 if (discriminator_ptr
)
2522 *discriminator_ptr
= 0;
2523 return coff_find_nearest_line_with_names (abfd
, symbols
, section
, offset
,
2524 filename_ptr
, functionname_ptr
,
2525 line_ptr
, dwarf_debug_sections
);
2529 coff_find_inliner_info (bfd
*abfd
,
2530 const char **filename_ptr
,
2531 const char **functionname_ptr
,
2532 unsigned int *line_ptr
)
2536 found
= _bfd_dwarf2_find_inliner_info (abfd
, filename_ptr
,
2537 functionname_ptr
, line_ptr
,
2538 &coff_data(abfd
)->dwarf2_find_line_info
);
2543 coff_sizeof_headers (bfd
*abfd
, struct bfd_link_info
*info
)
2547 if (!info
->relocatable
)
2548 size
= bfd_coff_filhsz (abfd
) + bfd_coff_aoutsz (abfd
);
2550 size
= bfd_coff_filhsz (abfd
);
2552 size
+= abfd
->section_count
* bfd_coff_scnhsz (abfd
);
2556 /* Change the class of a coff symbol held by BFD. */
2559 bfd_coff_set_symbol_class (bfd
* abfd
,
2561 unsigned int symbol_class
)
2563 coff_symbol_type
* csym
;
2565 csym
= coff_symbol_from (abfd
, symbol
);
2568 bfd_set_error (bfd_error_invalid_operation
);
2571 else if (csym
->native
== NULL
)
2573 /* This is an alien symbol which no native coff backend data.
2574 We cheat here by creating a fake native entry for it and
2575 then filling in the class. This code is based on that in
2576 coff_write_alien_symbol(). */
2578 combined_entry_type
* native
;
2579 bfd_size_type amt
= sizeof (* native
);
2581 native
= (combined_entry_type
*) bfd_zalloc (abfd
, amt
);
2585 native
->is_sym
= TRUE
;
2586 native
->u
.syment
.n_type
= T_NULL
;
2587 native
->u
.syment
.n_sclass
= symbol_class
;
2589 if (bfd_is_und_section (symbol
->section
))
2591 native
->u
.syment
.n_scnum
= N_UNDEF
;
2592 native
->u
.syment
.n_value
= symbol
->value
;
2594 else if (bfd_is_com_section (symbol
->section
))
2596 native
->u
.syment
.n_scnum
= N_UNDEF
;
2597 native
->u
.syment
.n_value
= symbol
->value
;
2601 native
->u
.syment
.n_scnum
=
2602 symbol
->section
->output_section
->target_index
;
2603 native
->u
.syment
.n_value
= (symbol
->value
2604 + symbol
->section
->output_offset
);
2605 if (! obj_pe (abfd
))
2606 native
->u
.syment
.n_value
+= symbol
->section
->output_section
->vma
;
2608 /* Copy the any flags from the file header into the symbol.
2610 native
->u
.syment
.n_flags
= bfd_asymbol_bfd (& csym
->symbol
)->flags
;
2613 csym
->native
= native
;
2616 csym
->native
->u
.syment
.n_sclass
= symbol_class
;
2621 struct coff_comdat_info
*
2622 bfd_coff_get_comdat_section (bfd
*abfd
, struct bfd_section
*sec
)
2624 if (bfd_get_flavour (abfd
) == bfd_target_coff_flavour
2625 && coff_section_data (abfd
, sec
) != NULL
)
2626 return coff_section_data (abfd
, sec
)->comdat
;
2632 _bfd_coff_section_already_linked (bfd
*abfd
,
2634 struct bfd_link_info
*info
)
2637 const char *name
, *key
;
2638 struct bfd_section_already_linked
*l
;
2639 struct bfd_section_already_linked_hash_entry
*already_linked_list
;
2640 struct coff_comdat_info
*s_comdat
;
2643 if ((flags
& SEC_LINK_ONCE
) == 0)
2646 /* The COFF backend linker doesn't support group sections. */
2647 if ((flags
& SEC_GROUP
) != 0)
2650 name
= bfd_get_section_name (abfd
, sec
);
2651 s_comdat
= bfd_coff_get_comdat_section (abfd
, sec
);
2653 if (s_comdat
!= NULL
)
2654 key
= s_comdat
->name
;
2657 if (CONST_STRNEQ (name
, ".gnu.linkonce.")
2658 && (key
= strchr (name
+ sizeof (".gnu.linkonce.") - 1, '.')) != NULL
)
2661 /* FIXME: gcc as of 2011-09 emits sections like .text$<key>,
2662 .xdata$<key> and .pdata$<key> only the first of which has a
2663 comdat key. Should these all match the LTO IR key? */
2667 already_linked_list
= bfd_section_already_linked_table_lookup (key
);
2669 for (l
= already_linked_list
->entry
; l
!= NULL
; l
= l
->next
)
2671 struct coff_comdat_info
*l_comdat
;
2673 l_comdat
= bfd_coff_get_comdat_section (l
->sec
->owner
, l
->sec
);
2675 /* The section names must match, and both sections must be
2676 comdat and have the same comdat name, or both sections must
2677 be non-comdat. LTO IR plugin sections are an exception. They
2678 are always named .gnu.linkonce.t.<key> (<key> is some string)
2679 and match any comdat section with comdat name of <key>, and
2680 any linkonce section with the same suffix, ie.
2681 .gnu.linkonce.*.<key>. */
2682 if (((s_comdat
!= NULL
) == (l_comdat
!= NULL
)
2683 && strcmp (name
, l
->sec
->name
) == 0)
2684 || (l
->sec
->owner
->flags
& BFD_PLUGIN
) != 0)
2686 /* The section has already been linked. See if we should
2688 return _bfd_handle_already_linked (sec
, l
, info
);
2692 /* This is the first section with this name. Record it. */
2693 if (!bfd_section_already_linked_table_insert (already_linked_list
, sec
))
2694 info
->callbacks
->einfo (_("%F%P: already_linked_table: %E\n"));