1 /* Support for the generic parts of COFF, for BFD.
2 Copyright (C) 1990-2024 Free Software Foundation, Inc.
3 Written by Cygnus Support.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
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.
11
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.
16
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. */
21
22 /* Most of this hacked by Steve Chamberlain, sac@cygnus.com.
23 Split out of coffcode.h by Ian Taylor, ian@cygnus.com. */
24
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
28 put it another way,
29
30 ********** DO NOT PUT TARGET SPECIFIC CODE IN THIS FILE **********
31
32 If you need to add some target specific behaviour, add a new hook
33 function to bfd_coff_backend_data.
34
35 Some of these functions are also called by the ECOFF routines.
36 Those functions may not use any COFF specific information, such as
37 coff_data (abfd). */
38
39 #include "sysdep.h"
40 #include <limits.h>
41 #include "bfd.h"
42 #include "libbfd.h"
43 #include "coff/internal.h"
44 #include "libcoff.h"
45 #include "hashtab.h"
46
47 /* Extract a long section name at STRINDEX and copy it to the bfd objstack.
48 Return NULL in case of error. */
49
50 static char *
extract_long_section_name(bfd * abfd,unsigned long strindex)51 extract_long_section_name(bfd *abfd, unsigned long strindex)
52 {
53 const char *strings;
54 char *name;
55
56 strings = _bfd_coff_read_string_table (abfd);
57 if (strings == NULL)
58 return NULL;
59 if ((bfd_size_type)(strindex + 2) >= obj_coff_strings_len (abfd))
60 return NULL;
61 strings += strindex;
62 name = (char *) bfd_alloc (abfd, (bfd_size_type) strlen (strings) + 1);
63 if (name == NULL)
64 return NULL;
65 strcpy (name, strings);
66
67 return name;
68 }
69
70 /* Decode a base 64 coded string at STR of length LEN, and write the result
71 to RES. Return true on success.
72 Return false in case of invalid character or overflow. */
73
74 static bool
decode_base64(const char * str,unsigned len,uint32_t * res)75 decode_base64 (const char *str, unsigned len, uint32_t *res)
76 {
77 unsigned i;
78 uint32_t val;
79
80 val = 0;
81 for (i = 0; i < len; i++)
82 {
83 char c = str[i];
84 unsigned d;
85
86 if (c >= 'A' && c <= 'Z')
87 d = c - 'A';
88 else if (c >= 'a' && c <= 'z')
89 d = c - 'a' + 26;
90 else if (c >= '0' && c <= '9')
91 d = c - '0' + 52;
92 else if (c == '+')
93 d = 62;
94 else if (c == '/')
95 d = 63;
96 else
97 return false;
98
99 /* Check for overflow. */
100 if ((val >> 26) != 0)
101 return false;
102
103 val = (val << 6) + d;
104 }
105
106 *res = val;
107 return true;
108 }
109
110 /* Take a section header read from a coff file (in HOST byte order),
111 and make a BFD "section" out of it. This is used by ECOFF. */
112
113 static bool
make_a_section_from_file(bfd * abfd,struct internal_scnhdr * hdr,unsigned int target_index)114 make_a_section_from_file (bfd *abfd,
115 struct internal_scnhdr *hdr,
116 unsigned int target_index)
117 {
118 asection *newsect;
119 char *name;
120 bool result = true;
121 flagword flags;
122
123 name = NULL;
124
125 /* Handle long section names as in PE. On reading, we want to
126 accept long names if the format permits them at all, regardless
127 of the current state of the flag that dictates if we would generate
128 them in outputs; this construct checks if that is the case by
129 attempting to set the flag, without changing its state; the call
130 will fail for formats that do not support long names at all. */
131 if (bfd_coff_set_long_section_names (abfd, bfd_coff_long_section_names (abfd))
132 && hdr->s_name[0] == '/')
133 {
134 /* Flag that this BFD uses long names, even though the format might
135 expect them to be off by default. This won't directly affect the
136 format of any output BFD created from this one, but the information
137 can be used to decide what to do. */
138 bfd_coff_set_long_section_names (abfd, true);
139
140 if (hdr->s_name[1] == '/')
141 {
142 /* LLVM extension: the '/' is followed by another '/' and then by
143 the index in the strtab encoded in base64 without NUL at the
144 end. */
145 uint32_t strindex;
146
147 /* Decode the index. No overflow is expected as the string table
148 length is at most 2^32 - 1 (the length is written on the first
149 four bytes).
150 Also, contrary to RFC 4648, all the characters must be decoded,
151 there is no padding. */
152 if (!decode_base64 (hdr->s_name + 2, SCNNMLEN - 2, &strindex))
153 return false;
154
155 name = extract_long_section_name (abfd, strindex);
156 if (name == NULL)
157 return false;
158 }
159 else
160 {
161 /* PE classic long section name. The '/' is followed by the index
162 in the strtab. The index is formatted as a decimal string. */
163 char buf[SCNNMLEN];
164 long strindex;
165 char *p;
166
167 memcpy (buf, hdr->s_name + 1, SCNNMLEN - 1);
168 buf[SCNNMLEN - 1] = '\0';
169 strindex = strtol (buf, &p, 10);
170 if (*p == '\0' && strindex >= 0)
171 {
172 name = extract_long_section_name (abfd, strindex);
173 if (name == NULL)
174 return false;
175 }
176 }
177 }
178
179 if (name == NULL)
180 {
181 /* Assorted wastage to null-terminate the name, thanks AT&T! */
182 name = (char *) bfd_alloc (abfd,
183 (bfd_size_type) sizeof (hdr->s_name) + 1 + 1);
184 if (name == NULL)
185 return false;
186 strncpy (name, (char *) &hdr->s_name[0], sizeof (hdr->s_name));
187 name[sizeof (hdr->s_name)] = 0;
188 }
189
190 newsect = bfd_make_section_anyway (abfd, name);
191 if (newsect == NULL)
192 return false;
193
194 newsect->vma = hdr->s_vaddr;
195 newsect->lma = hdr->s_paddr;
196 newsect->size = hdr->s_size;
197 newsect->filepos = hdr->s_scnptr;
198 newsect->rel_filepos = hdr->s_relptr;
199 newsect->reloc_count = hdr->s_nreloc;
200
201 bfd_coff_set_alignment_hook (abfd, newsect, hdr);
202
203 newsect->line_filepos = hdr->s_lnnoptr;
204
205 newsect->lineno_count = hdr->s_nlnno;
206 newsect->userdata = NULL;
207 newsect->next = NULL;
208 newsect->target_index = target_index;
209
210 if (!bfd_coff_styp_to_sec_flags_hook (abfd, hdr, name, newsect, &flags))
211 result = false;
212
213 /* At least on i386-coff, the line number count for a shared library
214 section must be ignored. */
215 if ((flags & SEC_COFF_SHARED_LIBRARY) != 0)
216 newsect->lineno_count = 0;
217
218 if (hdr->s_nreloc != 0)
219 flags |= SEC_RELOC;
220 /* FIXME: should this check 'hdr->s_size > 0'. */
221 if (hdr->s_scnptr != 0)
222 flags |= SEC_HAS_CONTENTS;
223
224 newsect->flags = flags;
225
226 /* Compress/decompress DWARF debug sections. */
227 if ((flags & SEC_DEBUGGING) != 0
228 && (flags & SEC_HAS_CONTENTS) != 0
229 && (startswith (name, ".debug_")
230 || startswith (name, ".zdebug_")
231 || startswith (name, ".gnu.debuglto_.debug_")
232 || startswith (name, ".gnu.linkonce.wi.")))
233 {
234 enum { nothing, compress, decompress } action = nothing;
235
236 if (bfd_is_section_compressed (abfd, newsect))
237 {
238 /* Compressed section. Check if we should decompress. */
239 if ((abfd->flags & BFD_DECOMPRESS))
240 action = decompress;
241 }
242 else
243 {
244 /* Normal section. Check if we should compress. */
245 if ((abfd->flags & BFD_COMPRESS) && newsect->size != 0)
246 action = compress;
247 }
248
249 if (action == compress)
250 {
251 if (!bfd_init_section_compress_status (abfd, newsect))
252 {
253 _bfd_error_handler
254 /* xgettext:c-format */
255 (_("%pB: unable to compress section %s"), abfd, name);
256 return false;
257 }
258 }
259 else if (action == decompress)
260 {
261 if (!bfd_init_section_decompress_status (abfd, newsect))
262 {
263 _bfd_error_handler
264 /* xgettext:c-format */
265 (_("%pB: unable to decompress section %s"), abfd, name);
266 return false;
267 }
268 if (abfd->is_linker_input
269 && name[1] == 'z')
270 {
271 /* Rename section from .zdebug_* to .debug_* so that ld
272 scripts will see this section as a debug section. */
273 char *new_name = bfd_zdebug_name_to_debug (abfd, name);
274 if (new_name == NULL)
275 return false;
276 bfd_rename_section (newsect, new_name);
277 }
278 }
279 }
280
281 return result;
282 }
283
284 void
coff_object_cleanup(bfd * abfd)285 coff_object_cleanup (bfd *abfd)
286 {
287 struct coff_tdata *td = coff_data (abfd);
288 if (td != NULL)
289 {
290 if (td->section_by_index)
291 htab_delete (td->section_by_index);
292 if (td->section_by_target_index)
293 htab_delete (td->section_by_target_index);
294 if (obj_pe (abfd) && pe_data (abfd)->comdat_hash)
295 htab_delete (pe_data (abfd)->comdat_hash);
296 }
297 }
298
299 /* Read in a COFF object and make it into a BFD. This is used by
300 ECOFF as well. */
301 bfd_cleanup
coff_real_object_p(bfd * abfd,unsigned nscns,struct internal_filehdr * internal_f,struct internal_aouthdr * internal_a)302 coff_real_object_p (bfd *abfd,
303 unsigned nscns,
304 struct internal_filehdr *internal_f,
305 struct internal_aouthdr *internal_a)
306 {
307 flagword oflags = abfd->flags;
308 bfd_vma ostart = bfd_get_start_address (abfd);
309 void * tdata;
310 void * tdata_save;
311 bfd_size_type readsize; /* Length of file_info. */
312 unsigned int scnhsz;
313 char *external_sections;
314
315 if (!(internal_f->f_flags & F_RELFLG))
316 abfd->flags |= HAS_RELOC;
317 if ((internal_f->f_flags & F_EXEC))
318 abfd->flags |= EXEC_P;
319 if (!(internal_f->f_flags & F_LNNO))
320 abfd->flags |= HAS_LINENO;
321 if (!(internal_f->f_flags & F_LSYMS))
322 abfd->flags |= HAS_LOCALS;
323
324 /* FIXME: How can we set D_PAGED correctly? */
325 if ((internal_f->f_flags & F_EXEC) != 0)
326 abfd->flags |= D_PAGED;
327
328 abfd->symcount = internal_f->f_nsyms;
329 if (internal_f->f_nsyms)
330 abfd->flags |= HAS_SYMS;
331
332 if (internal_a != (struct internal_aouthdr *) NULL)
333 abfd->start_address = internal_a->entry;
334 else
335 abfd->start_address = 0;
336
337 /* Set up the tdata area. ECOFF uses its own routine, and overrides
338 abfd->flags. */
339 tdata_save = abfd->tdata.any;
340 tdata = bfd_coff_mkobject_hook (abfd, (void *) internal_f, (void *) internal_a);
341 if (tdata == NULL)
342 goto fail2;
343
344 scnhsz = bfd_coff_scnhsz (abfd);
345 readsize = (bfd_size_type) nscns * scnhsz;
346 external_sections = (char *) _bfd_alloc_and_read (abfd, readsize, readsize);
347 if (!external_sections)
348 goto fail;
349
350 /* Set the arch/mach *before* swapping in sections; section header swapping
351 may depend on arch/mach info. */
352 if (! bfd_coff_set_arch_mach_hook (abfd, (void *) internal_f))
353 goto fail;
354
355 /* Now copy data as required; construct all asections etc. */
356 if (nscns != 0)
357 {
358 unsigned int i;
359 for (i = 0; i < nscns; i++)
360 {
361 struct internal_scnhdr tmp;
362 bfd_coff_swap_scnhdr_in (abfd,
363 (void *) (external_sections + i * scnhsz),
364 (void *) & tmp);
365 if (! make_a_section_from_file (abfd, &tmp, i + 1))
366 goto fail;
367 }
368 }
369
370 _bfd_coff_free_symbols (abfd);
371 return coff_object_cleanup;
372
373 fail:
374 coff_object_cleanup (abfd);
375 _bfd_coff_free_symbols (abfd);
376 bfd_release (abfd, tdata);
377 fail2:
378 abfd->tdata.any = tdata_save;
379 abfd->flags = oflags;
380 abfd->start_address = ostart;
381 return NULL;
382 }
383
384 /* Turn a COFF file into a BFD, but fail with bfd_error_wrong_format if it is
385 not a COFF file. This is also used by ECOFF. */
386
387 bfd_cleanup
coff_object_p(bfd * abfd)388 coff_object_p (bfd *abfd)
389 {
390 bfd_size_type filhsz;
391 bfd_size_type aoutsz;
392 unsigned int nscns;
393 void * filehdr;
394 struct internal_filehdr internal_f;
395 struct internal_aouthdr internal_a;
396
397 /* Figure out how much to read. */
398 filhsz = bfd_coff_filhsz (abfd);
399 aoutsz = bfd_coff_aoutsz (abfd);
400
401 filehdr = _bfd_alloc_and_read (abfd, filhsz, filhsz);
402 if (filehdr == NULL)
403 {
404 if (bfd_get_error () != bfd_error_system_call)
405 bfd_set_error (bfd_error_wrong_format);
406 return NULL;
407 }
408 bfd_coff_swap_filehdr_in (abfd, filehdr, &internal_f);
409 bfd_release (abfd, filehdr);
410
411 /* The XCOFF format has two sizes for the f_opthdr. SMALL_AOUTSZ
412 (less than aoutsz) used in object files and AOUTSZ (equal to
413 aoutsz) in executables. The bfd_coff_swap_aouthdr_in function
414 expects this header to be aoutsz bytes in length, so we use that
415 value in the call to bfd_alloc below. But we must be careful to
416 only read in f_opthdr bytes in the call to bfd_read. We should
417 also attempt to catch corrupt or non-COFF binaries with a strange
418 value for f_opthdr. */
419 if (! bfd_coff_bad_format_hook (abfd, &internal_f)
420 || internal_f.f_opthdr > aoutsz)
421 {
422 bfd_set_error (bfd_error_wrong_format);
423 return NULL;
424 }
425 nscns = internal_f.f_nscns;
426
427 if (internal_f.f_opthdr)
428 {
429 void * opthdr;
430
431 opthdr = _bfd_alloc_and_read (abfd, aoutsz, internal_f.f_opthdr);
432 if (opthdr == NULL)
433 return NULL;
434 /* PR 17512: file: 11056-1136-0.004. */
435 if (internal_f.f_opthdr < aoutsz)
436 memset (((char *) opthdr) + internal_f.f_opthdr, 0,
437 aoutsz - internal_f.f_opthdr);
438
439 bfd_coff_swap_aouthdr_in (abfd, opthdr, (void *) &internal_a);
440 bfd_release (abfd, opthdr);
441 }
442
443 return coff_real_object_p (abfd, nscns, &internal_f,
444 (internal_f.f_opthdr != 0
445 ? &internal_a
446 : (struct internal_aouthdr *) NULL));
447 }
448
449 static hashval_t
htab_hash_section_target_index(const void * entry)450 htab_hash_section_target_index (const void * entry)
451 {
452 const struct bfd_section * sec = entry;
453 return sec->target_index;
454 }
455
456 static int
htab_eq_section_target_index(const void * e1,const void * e2)457 htab_eq_section_target_index (const void * e1, const void * e2)
458 {
459 const struct bfd_section * sec1 = e1;
460 const struct bfd_section * sec2 = e2;
461 return sec1->target_index == sec2->target_index;
462 }
463
464 /* Get the BFD section from a COFF symbol section number. */
465
466 asection *
coff_section_from_bfd_index(bfd * abfd,int section_index)467 coff_section_from_bfd_index (bfd *abfd, int section_index)
468 {
469 if (section_index == N_ABS)
470 return bfd_abs_section_ptr;
471 if (section_index == N_UNDEF)
472 return bfd_und_section_ptr;
473 if (section_index == N_DEBUG)
474 return bfd_abs_section_ptr;
475
476 struct bfd_section *answer;
477 htab_t table = coff_data (abfd)->section_by_target_index;
478
479 if (!table)
480 {
481 table = htab_create (10, htab_hash_section_target_index,
482 htab_eq_section_target_index, NULL);
483 if (table == NULL)
484 return bfd_und_section_ptr;
485 coff_data (abfd)->section_by_target_index = table;
486 }
487
488 if (htab_elements (table) == 0)
489 {
490 for (answer = abfd->sections; answer; answer = answer->next)
491 {
492 void **slot = htab_find_slot (table, answer, INSERT);
493 if (slot == NULL)
494 return bfd_und_section_ptr;
495 *slot = answer;
496 }
497 }
498
499 struct bfd_section needle;
500 needle.target_index = section_index;
501
502 answer = htab_find (table, &needle);
503 if (answer != NULL)
504 return answer;
505
506 /* Cover the unlikely case of sections added after the first call to
507 this function. */
508 for (answer = abfd->sections; answer; answer = answer->next)
509 if (answer->target_index == section_index)
510 {
511 void **slot = htab_find_slot (table, answer, INSERT);
512 if (slot != NULL)
513 *slot = answer;
514 return answer;
515 }
516
517 /* We should not reach this point, but the SCO 3.2v4 /lib/libc_s.a
518 has a bad symbol table in biglitpow.o. */
519 return bfd_und_section_ptr;
520 }
521
522 /* Get the upper bound of a COFF symbol table. */
523
524 long
coff_get_symtab_upper_bound(bfd * abfd)525 coff_get_symtab_upper_bound (bfd *abfd)
526 {
527 if (!bfd_coff_slurp_symbol_table (abfd))
528 return -1;
529
530 return (bfd_get_symcount (abfd) + 1) * (sizeof (coff_symbol_type *));
531 }
532
533 /* Canonicalize a COFF symbol table. */
534
535 long
coff_canonicalize_symtab(bfd * abfd,asymbol ** alocation)536 coff_canonicalize_symtab (bfd *abfd, asymbol **alocation)
537 {
538 unsigned int counter;
539 coff_symbol_type *symbase;
540 coff_symbol_type **location = (coff_symbol_type **) alocation;
541
542 if (!bfd_coff_slurp_symbol_table (abfd))
543 return -1;
544
545 symbase = obj_symbols (abfd);
546 counter = bfd_get_symcount (abfd);
547 while (counter-- > 0)
548 *location++ = symbase++;
549
550 *location = NULL;
551
552 return bfd_get_symcount (abfd);
553 }
554
555 /* Get the name of a symbol. The caller must pass in a buffer of size
556 >= SYMNMLEN + 1. */
557
558 const char *
_bfd_coff_internal_syment_name(bfd * abfd,const struct internal_syment * sym,char * buf)559 _bfd_coff_internal_syment_name (bfd *abfd,
560 const struct internal_syment *sym,
561 char *buf)
562 {
563 /* FIXME: It's not clear this will work correctly if sizeof
564 (_n_zeroes) != 4. */
565 if (sym->_n._n_n._n_zeroes != 0
566 || sym->_n._n_n._n_offset == 0)
567 {
568 memcpy (buf, sym->_n._n_name, SYMNMLEN);
569 buf[SYMNMLEN] = '\0';
570 return buf;
571 }
572 else
573 {
574 const char *strings;
575
576 BFD_ASSERT (sym->_n._n_n._n_offset >= STRING_SIZE_SIZE);
577 strings = obj_coff_strings (abfd);
578 if (strings == NULL)
579 {
580 strings = _bfd_coff_read_string_table (abfd);
581 if (strings == NULL)
582 return NULL;
583 }
584 if (sym->_n._n_n._n_offset >= obj_coff_strings_len (abfd))
585 return NULL;
586 return strings + sym->_n._n_n._n_offset;
587 }
588 }
589
590 /* Read in and swap the relocs. This returns a buffer holding the
591 relocs for section SEC in file ABFD. If CACHE is TRUE and
592 INTERNAL_RELOCS is NULL, the relocs read in will be saved in case
593 the function is called again. If EXTERNAL_RELOCS is not NULL, it
594 is a buffer large enough to hold the unswapped relocs. If
595 INTERNAL_RELOCS is not NULL, it is a buffer large enough to hold
596 the swapped relocs. If REQUIRE_INTERNAL is TRUE, then the return
597 value must be INTERNAL_RELOCS. The function returns NULL on error. */
598
599 struct internal_reloc *
_bfd_coff_read_internal_relocs(bfd * abfd,asection * sec,bool cache,bfd_byte * external_relocs,bool require_internal,struct internal_reloc * internal_relocs)600 _bfd_coff_read_internal_relocs (bfd *abfd,
601 asection *sec,
602 bool cache,
603 bfd_byte *external_relocs,
604 bool require_internal,
605 struct internal_reloc *internal_relocs)
606 {
607 bfd_size_type relsz;
608 bfd_byte *free_external = NULL;
609 struct internal_reloc *free_internal = NULL;
610 bfd_byte *erel;
611 bfd_byte *erel_end;
612 struct internal_reloc *irel;
613 bfd_size_type amt;
614
615 if (sec->reloc_count == 0)
616 return internal_relocs; /* Nothing to do. */
617
618 if (coff_section_data (abfd, sec) != NULL
619 && coff_section_data (abfd, sec)->relocs != NULL)
620 {
621 if (! require_internal)
622 return coff_section_data (abfd, sec)->relocs;
623 memcpy (internal_relocs, coff_section_data (abfd, sec)->relocs,
624 sec->reloc_count * sizeof (struct internal_reloc));
625 return internal_relocs;
626 }
627
628 relsz = bfd_coff_relsz (abfd);
629
630 amt = sec->reloc_count * relsz;
631 if (external_relocs == NULL)
632 {
633 free_external = (bfd_byte *) bfd_malloc (amt);
634 if (free_external == NULL)
635 goto error_return;
636 external_relocs = free_external;
637 }
638
639 if (bfd_seek (abfd, sec->rel_filepos, SEEK_SET) != 0
640 || bfd_read (external_relocs, amt, abfd) != amt)
641 goto error_return;
642
643 if (internal_relocs == NULL)
644 {
645 amt = sec->reloc_count;
646 amt *= sizeof (struct internal_reloc);
647 free_internal = (struct internal_reloc *) bfd_malloc (amt);
648 if (free_internal == NULL)
649 goto error_return;
650 internal_relocs = free_internal;
651 }
652
653 /* Swap in the relocs. */
654 erel = external_relocs;
655 erel_end = erel + relsz * sec->reloc_count;
656 irel = internal_relocs;
657 for (; erel < erel_end; erel += relsz, irel++)
658 bfd_coff_swap_reloc_in (abfd, (void *) erel, (void *) irel);
659
660 free (free_external);
661 free_external = NULL;
662
663 if (cache && free_internal != NULL)
664 {
665 if (coff_section_data (abfd, sec) == NULL)
666 {
667 amt = sizeof (struct coff_section_tdata);
668 sec->used_by_bfd = bfd_zalloc (abfd, amt);
669 if (sec->used_by_bfd == NULL)
670 goto error_return;
671 coff_section_data (abfd, sec)->contents = NULL;
672 }
673 coff_section_data (abfd, sec)->relocs = free_internal;
674 }
675
676 return internal_relocs;
677
678 error_return:
679 free (free_external);
680 free (free_internal);
681 return NULL;
682 }
683
684 /* Set lineno_count for the output sections of a COFF file. */
685
686 int
coff_count_linenumbers(bfd * abfd)687 coff_count_linenumbers (bfd *abfd)
688 {
689 unsigned int limit = bfd_get_symcount (abfd);
690 unsigned int i;
691 int total = 0;
692 asymbol **p;
693 asection *s;
694
695 if (limit == 0)
696 {
697 /* This may be from the backend linker, in which case the
698 lineno_count in the sections is correct. */
699 for (s = abfd->sections; s != NULL; s = s->next)
700 total += s->lineno_count;
701 return total;
702 }
703
704 for (s = abfd->sections; s != NULL; s = s->next)
705 BFD_ASSERT (s->lineno_count == 0);
706
707 for (p = abfd->outsymbols, i = 0; i < limit; i++, p++)
708 {
709 asymbol *q_maybe = *p;
710
711 if (bfd_asymbol_bfd (q_maybe) != NULL
712 && bfd_family_coff (bfd_asymbol_bfd (q_maybe)))
713 {
714 coff_symbol_type *q = coffsymbol (q_maybe);
715
716 /* The AIX 4.1 compiler can sometimes generate line numbers
717 attached to debugging symbols. We try to simply ignore
718 those here. */
719 if (q->lineno != NULL
720 && q->symbol.section->owner != NULL)
721 {
722 /* This symbol has line numbers. Increment the owning
723 section's linenumber count. */
724 alent *l = q->lineno;
725
726 do
727 {
728 asection * sec = q->symbol.section->output_section;
729
730 /* Do not try to update fields in read-only sections. */
731 if (! bfd_is_const_section (sec))
732 sec->lineno_count ++;
733
734 ++total;
735 ++l;
736 }
737 while (l->line_number != 0);
738 }
739 }
740 }
741
742 return total;
743 }
744
745 static void
fixup_symbol_value(bfd * abfd,coff_symbol_type * coff_symbol_ptr,struct internal_syment * syment)746 fixup_symbol_value (bfd *abfd,
747 coff_symbol_type *coff_symbol_ptr,
748 struct internal_syment *syment)
749 {
750 /* Normalize the symbol flags. */
751 if (coff_symbol_ptr->symbol.section
752 && bfd_is_com_section (coff_symbol_ptr->symbol.section))
753 {
754 /* A common symbol is undefined with a value. */
755 syment->n_scnum = N_UNDEF;
756 syment->n_value = coff_symbol_ptr->symbol.value;
757 }
758 else if ((coff_symbol_ptr->symbol.flags & BSF_DEBUGGING) != 0
759 && (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING_RELOC) == 0)
760 {
761 syment->n_value = coff_symbol_ptr->symbol.value;
762 }
763 else if (bfd_is_und_section (coff_symbol_ptr->symbol.section))
764 {
765 syment->n_scnum = N_UNDEF;
766 syment->n_value = 0;
767 }
768 /* FIXME: Do we need to handle the absolute section here? */
769 else
770 {
771 if (coff_symbol_ptr->symbol.section)
772 {
773 syment->n_scnum =
774 coff_symbol_ptr->symbol.section->output_section->target_index;
775
776 syment->n_value = (coff_symbol_ptr->symbol.value
777 + coff_symbol_ptr->symbol.section->output_offset);
778 if (! obj_pe (abfd))
779 {
780 syment->n_value += (syment->n_sclass == C_STATLAB)
781 ? coff_symbol_ptr->symbol.section->output_section->lma
782 : coff_symbol_ptr->symbol.section->output_section->vma;
783 }
784 }
785 else
786 {
787 BFD_ASSERT (0);
788 /* This can happen, but I don't know why yet (steve@cygnus.com) */
789 syment->n_scnum = N_ABS;
790 syment->n_value = coff_symbol_ptr->symbol.value;
791 }
792 }
793 }
794
795 /* Run through all the symbols in the symbol table and work out what
796 their indexes into the symbol table will be when output.
797
798 Coff requires that each C_FILE symbol points to the next one in the
799 chain, and that the last one points to the first external symbol. We
800 do that here too. */
801
802 bool
coff_renumber_symbols(bfd * bfd_ptr,int * first_undef)803 coff_renumber_symbols (bfd *bfd_ptr, int *first_undef)
804 {
805 unsigned int symbol_count = bfd_get_symcount (bfd_ptr);
806 asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
807 unsigned int native_index = 0;
808 struct internal_syment *last_file = NULL;
809 unsigned int symbol_index;
810
811 /* COFF demands that undefined symbols come after all other symbols.
812 Since we don't need to impose this extra knowledge on all our
813 client programs, deal with that here. Sort the symbol table;
814 just move the undefined symbols to the end, leaving the rest
815 alone. The O'Reilly book says that defined global symbols come
816 at the end before the undefined symbols, so we do that here as
817 well. */
818 /* @@ Do we have some condition we could test for, so we don't always
819 have to do this? I don't think relocatability is quite right, but
820 I'm not certain. [raeburn:19920508.1711EST] */
821 {
822 asymbol **newsyms;
823 unsigned int i;
824 bfd_size_type amt;
825
826 amt = sizeof (asymbol *) * ((bfd_size_type) symbol_count + 1);
827 newsyms = (asymbol **) bfd_alloc (bfd_ptr, amt);
828 if (!newsyms)
829 return false;
830 bfd_ptr->outsymbols = newsyms;
831 for (i = 0; i < symbol_count; i++)
832 if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) != 0
833 || (!bfd_is_und_section (symbol_ptr_ptr[i]->section)
834 && !bfd_is_com_section (symbol_ptr_ptr[i]->section)
835 && ((symbol_ptr_ptr[i]->flags & BSF_FUNCTION) != 0
836 || ((symbol_ptr_ptr[i]->flags & (BSF_GLOBAL | BSF_WEAK))
837 == 0))))
838 *newsyms++ = symbol_ptr_ptr[i];
839
840 for (i = 0; i < symbol_count; i++)
841 if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) == 0
842 && !bfd_is_und_section (symbol_ptr_ptr[i]->section)
843 && (bfd_is_com_section (symbol_ptr_ptr[i]->section)
844 || ((symbol_ptr_ptr[i]->flags & BSF_FUNCTION) == 0
845 && ((symbol_ptr_ptr[i]->flags & (BSF_GLOBAL | BSF_WEAK))
846 != 0))))
847 *newsyms++ = symbol_ptr_ptr[i];
848
849 *first_undef = newsyms - bfd_ptr->outsymbols;
850
851 for (i = 0; i < symbol_count; i++)
852 if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) == 0
853 && bfd_is_und_section (symbol_ptr_ptr[i]->section))
854 *newsyms++ = symbol_ptr_ptr[i];
855 *newsyms = (asymbol *) NULL;
856 symbol_ptr_ptr = bfd_ptr->outsymbols;
857 }
858
859 for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
860 {
861 coff_symbol_type *coff_symbol_ptr;
862
863 coff_symbol_ptr = coff_symbol_from (symbol_ptr_ptr[symbol_index]);
864 symbol_ptr_ptr[symbol_index]->udata.i = symbol_index;
865 if (coff_symbol_ptr && coff_symbol_ptr->native)
866 {
867 combined_entry_type *s = coff_symbol_ptr->native;
868 int i;
869
870 BFD_ASSERT (s->is_sym);
871 if (s->u.syment.n_sclass == C_FILE)
872 {
873 if (last_file != NULL)
874 last_file->n_value = native_index;
875 last_file = &(s->u.syment);
876 }
877 else
878 /* Modify the symbol values according to their section and
879 type. */
880 fixup_symbol_value (bfd_ptr, coff_symbol_ptr, &(s->u.syment));
881
882 for (i = 0; i < s->u.syment.n_numaux + 1; i++)
883 s[i].offset = native_index++;
884 }
885 else
886 native_index++;
887 }
888
889 obj_conv_table_size (bfd_ptr) = native_index;
890
891 return true;
892 }
893
894 /* Run thorough the symbol table again, and fix it so that all
895 pointers to entries are changed to the entries' index in the output
896 symbol table. */
897
898 void
coff_mangle_symbols(bfd * bfd_ptr)899 coff_mangle_symbols (bfd *bfd_ptr)
900 {
901 unsigned int symbol_count = bfd_get_symcount (bfd_ptr);
902 asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
903 unsigned int symbol_index;
904
905 for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
906 {
907 coff_symbol_type *coff_symbol_ptr;
908
909 coff_symbol_ptr = coff_symbol_from (symbol_ptr_ptr[symbol_index]);
910 if (coff_symbol_ptr && coff_symbol_ptr->native)
911 {
912 int i;
913 combined_entry_type *s = coff_symbol_ptr->native;
914
915 BFD_ASSERT (s->is_sym);
916 if (s->fix_value)
917 {
918 /* FIXME: We should use a union here. */
919 s->u.syment.n_value =
920 (uintptr_t) ((combined_entry_type *)
921 (uintptr_t) s->u.syment.n_value)->offset;
922 s->fix_value = 0;
923 }
924 if (s->fix_line)
925 {
926 /* The value is the offset into the line number entries
927 for the symbol's section. On output, the symbol's
928 section should be N_DEBUG. */
929 s->u.syment.n_value =
930 (coff_symbol_ptr->symbol.section->output_section->line_filepos
931 + s->u.syment.n_value * bfd_coff_linesz (bfd_ptr));
932 coff_symbol_ptr->symbol.section =
933 coff_section_from_bfd_index (bfd_ptr, N_DEBUG);
934 BFD_ASSERT (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING);
935 }
936 for (i = 0; i < s->u.syment.n_numaux; i++)
937 {
938 combined_entry_type *a = s + i + 1;
939
940 BFD_ASSERT (! a->is_sym);
941 if (a->fix_tag)
942 {
943 a->u.auxent.x_sym.x_tagndx.u32 =
944 a->u.auxent.x_sym.x_tagndx.p->offset;
945 a->fix_tag = 0;
946 }
947 if (a->fix_end)
948 {
949 a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.u32 =
950 a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p->offset;
951 a->fix_end = 0;
952 }
953 if (a->fix_scnlen)
954 {
955 a->u.auxent.x_csect.x_scnlen.u64 =
956 a->u.auxent.x_csect.x_scnlen.p->offset;
957 a->fix_scnlen = 0;
958 }
959 }
960 }
961 }
962 }
963
964 static bool
coff_write_auxent_fname(bfd * abfd,char * str,union internal_auxent * auxent,struct bfd_strtab_hash * strtab,bool hash)965 coff_write_auxent_fname (bfd *abfd,
966 char *str,
967 union internal_auxent *auxent,
968 struct bfd_strtab_hash *strtab,
969 bool hash)
970 {
971 unsigned int str_length = strlen (str);
972 unsigned int filnmlen = bfd_coff_filnmlen (abfd);
973
974 if (bfd_coff_long_filenames (abfd))
975 {
976 if (str_length <= filnmlen)
977 strncpy (auxent->x_file.x_n.x_fname, str, filnmlen);
978 else
979 {
980 bfd_size_type indx = _bfd_stringtab_add (strtab, str, hash, false);
981
982 if (indx == (bfd_size_type) -1)
983 return false;
984
985 auxent->x_file.x_n.x_n.x_offset = STRING_SIZE_SIZE + indx;
986 auxent->x_file.x_n.x_n.x_zeroes = 0;
987 }
988 }
989 else
990 {
991 strncpy (auxent->x_file.x_n.x_fname, str, filnmlen);
992 if (str_length > filnmlen)
993 str[filnmlen] = '\0';
994 }
995
996 return true;
997 }
998
999 static bool
coff_fix_symbol_name(bfd * abfd,asymbol * symbol,combined_entry_type * native,struct bfd_strtab_hash * strtab,bool hash,asection ** debug_string_section_p,bfd_size_type * debug_string_size_p)1000 coff_fix_symbol_name (bfd *abfd,
1001 asymbol *symbol,
1002 combined_entry_type *native,
1003 struct bfd_strtab_hash *strtab,
1004 bool hash,
1005 asection **debug_string_section_p,
1006 bfd_size_type *debug_string_size_p)
1007 {
1008 unsigned int name_length;
1009 char *name = (char *) (symbol->name);
1010 bfd_size_type indx;
1011
1012 if (name == NULL)
1013 {
1014 /* COFF symbols always have names, so we'll make one up. */
1015 symbol->name = "strange";
1016 name = (char *) symbol->name;
1017 }
1018 name_length = strlen (name);
1019
1020 BFD_ASSERT (native->is_sym);
1021 if (native->u.syment.n_sclass == C_FILE
1022 && native->u.syment.n_numaux > 0)
1023 {
1024 if (bfd_coff_force_symnames_in_strings (abfd))
1025 {
1026 indx = _bfd_stringtab_add (strtab, ".file", hash, false);
1027 if (indx == (bfd_size_type) -1)
1028 return false;
1029
1030 native->u.syment._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
1031 native->u.syment._n._n_n._n_zeroes = 0;
1032 }
1033 else
1034 strncpy (native->u.syment._n._n_name, ".file", SYMNMLEN);
1035
1036 BFD_ASSERT (! (native + 1)->is_sym);
1037 if (!coff_write_auxent_fname (abfd, name, &(native + 1)->u.auxent,
1038 strtab, hash))
1039 return false;
1040 }
1041 else
1042 {
1043 if (name_length <= SYMNMLEN && !bfd_coff_force_symnames_in_strings (abfd))
1044 /* This name will fit into the symbol neatly. */
1045 strncpy (native->u.syment._n._n_name, symbol->name, SYMNMLEN);
1046
1047 else if (!bfd_coff_symname_in_debug (abfd, &native->u.syment))
1048 {
1049 indx = _bfd_stringtab_add (strtab, name, hash, false);
1050 if (indx == (bfd_size_type) -1)
1051 return false;
1052
1053 native->u.syment._n._n_n._n_offset = STRING_SIZE_SIZE + indx;
1054 native->u.syment._n._n_n._n_zeroes = 0;
1055 }
1056 else
1057 {
1058 file_ptr filepos;
1059 bfd_byte buf[4];
1060 int prefix_len = bfd_coff_debug_string_prefix_length (abfd);
1061
1062 /* This name should be written into the .debug section. For
1063 some reason each name is preceded by a two byte length
1064 and also followed by a null byte. FIXME: We assume that
1065 the .debug section has already been created, and that it
1066 is large enough. */
1067 if (*debug_string_section_p == (asection *) NULL)
1068 *debug_string_section_p = bfd_get_section_by_name (abfd, ".debug");
1069 filepos = bfd_tell (abfd);
1070 if (prefix_len == 4)
1071 bfd_put_32 (abfd, (bfd_vma) (name_length + 1), buf);
1072 else
1073 bfd_put_16 (abfd, (bfd_vma) (name_length + 1), buf);
1074
1075 if (!bfd_set_section_contents (abfd,
1076 *debug_string_section_p,
1077 (void *) buf,
1078 (file_ptr) *debug_string_size_p,
1079 (bfd_size_type) prefix_len)
1080 || !bfd_set_section_contents (abfd,
1081 *debug_string_section_p,
1082 (void *) symbol->name,
1083 (file_ptr) (*debug_string_size_p
1084 + prefix_len),
1085 (bfd_size_type) name_length + 1))
1086 abort ();
1087 if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
1088 abort ();
1089 native->u.syment._n._n_n._n_offset =
1090 *debug_string_size_p + prefix_len;
1091 native->u.syment._n._n_n._n_zeroes = 0;
1092 *debug_string_size_p += name_length + 1 + prefix_len;
1093 }
1094 }
1095
1096 return true;
1097 }
1098
1099 /* We need to keep track of the symbol index so that when we write out
1100 the relocs we can get the index for a symbol. This method is a
1101 hack. FIXME. */
1102
1103 #define set_index(symbol, idx) ((symbol)->udata.i = (idx))
1104
1105 /* Write a symbol out to a COFF file. */
1106
1107 static bool
coff_write_symbol(bfd * abfd,asymbol * symbol,combined_entry_type * native,bfd_vma * written,struct bfd_strtab_hash * strtab,bool hash,asection ** debug_string_section_p,bfd_size_type * debug_string_size_p)1108 coff_write_symbol (bfd *abfd,
1109 asymbol *symbol,
1110 combined_entry_type *native,
1111 bfd_vma *written,
1112 struct bfd_strtab_hash *strtab,
1113 bool hash,
1114 asection **debug_string_section_p,
1115 bfd_size_type *debug_string_size_p)
1116 {
1117 unsigned int numaux = native->u.syment.n_numaux;
1118 int type = native->u.syment.n_type;
1119 int n_sclass = (int) native->u.syment.n_sclass;
1120 asection *output_section = symbol->section->output_section
1121 ? symbol->section->output_section
1122 : symbol->section;
1123 void * buf;
1124 bfd_size_type symesz;
1125
1126 BFD_ASSERT (native->is_sym);
1127
1128 if (native->u.syment.n_sclass == C_FILE)
1129 symbol->flags |= BSF_DEBUGGING;
1130
1131 if (symbol->flags & BSF_DEBUGGING
1132 && bfd_is_abs_section (symbol->section))
1133 native->u.syment.n_scnum = N_DEBUG;
1134
1135 else if (bfd_is_abs_section (symbol->section))
1136 native->u.syment.n_scnum = N_ABS;
1137
1138 else if (bfd_is_und_section (symbol->section))
1139 native->u.syment.n_scnum = N_UNDEF;
1140
1141 else
1142 native->u.syment.n_scnum =
1143 output_section->target_index;
1144
1145 if (!coff_fix_symbol_name (abfd, symbol, native, strtab, hash,
1146 debug_string_section_p, debug_string_size_p))
1147 return false;
1148
1149 symesz = bfd_coff_symesz (abfd);
1150 buf = bfd_alloc (abfd, symesz);
1151 if (!buf)
1152 return false;
1153 bfd_coff_swap_sym_out (abfd, &native->u.syment, buf);
1154 if (bfd_write (buf, symesz, abfd) != symesz)
1155 return false;
1156 bfd_release (abfd, buf);
1157
1158 if (native->u.syment.n_numaux > 0)
1159 {
1160 bfd_size_type auxesz;
1161 unsigned int j;
1162
1163 auxesz = bfd_coff_auxesz (abfd);
1164 buf = bfd_alloc (abfd, auxesz);
1165 if (!buf)
1166 return false;
1167 for (j = 0; j < native->u.syment.n_numaux; j++)
1168 {
1169 BFD_ASSERT (! (native + j + 1)->is_sym);
1170
1171 /* Adjust auxent only if this isn't the filename
1172 auxiliary entry. */
1173 if (native->u.syment.n_sclass == C_FILE
1174 && (native + j + 1)->u.auxent.x_file.x_ftype
1175 && (native + j + 1)->extrap)
1176 coff_write_auxent_fname (abfd, (char *) (native + j + 1)->extrap,
1177 &(native + j + 1)->u.auxent, strtab, hash);
1178
1179 bfd_coff_swap_aux_out (abfd,
1180 &((native + j + 1)->u.auxent),
1181 type, n_sclass, (int) j,
1182 native->u.syment.n_numaux,
1183 buf);
1184 if (bfd_write (buf, auxesz, abfd) != auxesz)
1185 return false;
1186 }
1187 bfd_release (abfd, buf);
1188 }
1189
1190 /* Store the index for use when we write out the relocs. */
1191 set_index (symbol, *written);
1192
1193 *written += numaux + 1;
1194 return true;
1195 }
1196
1197 /* Write out a symbol to a COFF file that does not come from a COFF
1198 file originally. This symbol may have been created by the linker,
1199 or we may be linking a non COFF file to a COFF file. */
1200
1201 bool
coff_write_alien_symbol(bfd * abfd,asymbol * symbol,struct internal_syment * isym,bfd_vma * written,struct bfd_strtab_hash * strtab,bool hash,asection ** debug_string_section_p,bfd_size_type * debug_string_size_p)1202 coff_write_alien_symbol (bfd *abfd,
1203 asymbol *symbol,
1204 struct internal_syment *isym,
1205 bfd_vma *written,
1206 struct bfd_strtab_hash *strtab,
1207 bool hash,
1208 asection **debug_string_section_p,
1209 bfd_size_type *debug_string_size_p)
1210 {
1211 combined_entry_type *native;
1212 combined_entry_type dummy[2];
1213 asection *output_section = symbol->section->output_section
1214 ? symbol->section->output_section
1215 : symbol->section;
1216 struct bfd_link_info *link_info = coff_data (abfd)->link_info;
1217 bool ret;
1218
1219 if ((!link_info || link_info->strip_discarded)
1220 && !bfd_is_abs_section (symbol->section)
1221 && symbol->section->output_section == bfd_abs_section_ptr)
1222 {
1223 symbol->name = "";
1224 if (isym != NULL)
1225 memset (isym, 0, sizeof (*isym));
1226 return true;
1227 }
1228 memset (dummy, 0, sizeof dummy);
1229 native = dummy;
1230 native->is_sym = true;
1231 native[1].is_sym = false;
1232 native->u.syment.n_type = T_NULL;
1233 native->u.syment.n_flags = 0;
1234 native->u.syment.n_numaux = 0;
1235 if (bfd_is_und_section (symbol->section))
1236 {
1237 native->u.syment.n_scnum = N_UNDEF;
1238 native->u.syment.n_value = symbol->value;
1239 }
1240 else if (bfd_is_com_section (symbol->section))
1241 {
1242 native->u.syment.n_scnum = N_UNDEF;
1243 native->u.syment.n_value = symbol->value;
1244 }
1245 else if (symbol->flags & BSF_FILE)
1246 {
1247 native->u.syment.n_scnum = N_DEBUG;
1248 native->u.syment.n_numaux = 1;
1249 }
1250 else if (symbol->flags & BSF_DEBUGGING)
1251 {
1252 /* There isn't much point to writing out a debugging symbol
1253 unless we are prepared to convert it into COFF debugging
1254 format. So, we just ignore them. We must clobber the symbol
1255 name to keep it from being put in the string table. */
1256 symbol->name = "";
1257 if (isym != NULL)
1258 memset (isym, 0, sizeof (*isym));
1259 return true;
1260 }
1261 else
1262 {
1263 native->u.syment.n_scnum = output_section->target_index;
1264 native->u.syment.n_value = (symbol->value
1265 + symbol->section->output_offset);
1266 if (! obj_pe (abfd))
1267 native->u.syment.n_value += output_section->vma;
1268
1269 /* Copy the any flags from the file header into the symbol.
1270 FIXME: Why? */
1271 {
1272 coff_symbol_type *c = coff_symbol_from (symbol);
1273 if (c != (coff_symbol_type *) NULL)
1274 native->u.syment.n_flags = bfd_asymbol_bfd (&c->symbol)->flags;
1275 }
1276 }
1277
1278 native->u.syment.n_type = 0;
1279 if (symbol->flags & BSF_FILE)
1280 native->u.syment.n_sclass = C_FILE;
1281 else if (symbol->flags & BSF_LOCAL)
1282 native->u.syment.n_sclass = C_STAT;
1283 else if (symbol->flags & BSF_WEAK)
1284 native->u.syment.n_sclass = obj_pe (abfd) ? C_NT_WEAK : C_WEAKEXT;
1285 else
1286 native->u.syment.n_sclass = C_EXT;
1287
1288 ret = coff_write_symbol (abfd, symbol, native, written, strtab, hash,
1289 debug_string_section_p, debug_string_size_p);
1290 if (isym != NULL)
1291 *isym = native->u.syment;
1292 return ret;
1293 }
1294
1295 /* Write a native symbol to a COFF file. */
1296
1297 static bool
coff_write_native_symbol(bfd * abfd,coff_symbol_type * symbol,bfd_vma * written,struct bfd_strtab_hash * strtab,asection ** debug_string_section_p,bfd_size_type * debug_string_size_p)1298 coff_write_native_symbol (bfd *abfd,
1299 coff_symbol_type *symbol,
1300 bfd_vma *written,
1301 struct bfd_strtab_hash *strtab,
1302 asection **debug_string_section_p,
1303 bfd_size_type *debug_string_size_p)
1304 {
1305 combined_entry_type *native = symbol->native;
1306 alent *lineno = symbol->lineno;
1307 struct bfd_link_info *link_info = coff_data (abfd)->link_info;
1308
1309 if ((!link_info || link_info->strip_discarded)
1310 && !bfd_is_abs_section (symbol->symbol.section)
1311 && symbol->symbol.section->output_section == bfd_abs_section_ptr)
1312 {
1313 symbol->symbol.name = "";
1314 return true;
1315 }
1316
1317 BFD_ASSERT (native->is_sym);
1318 /* If this symbol has an associated line number, we must store the
1319 symbol index in the line number field. We also tag the auxent to
1320 point to the right place in the lineno table. */
1321 if (lineno && !symbol->done_lineno && symbol->symbol.section->owner != NULL)
1322 {
1323 unsigned int count = 0;
1324
1325 lineno[count].u.offset = *written;
1326 if (native->u.syment.n_numaux)
1327 {
1328 union internal_auxent *a = &((native + 1)->u.auxent);
1329
1330 a->x_sym.x_fcnary.x_fcn.x_lnnoptr =
1331 symbol->symbol.section->output_section->moving_line_filepos;
1332 }
1333
1334 /* Count and relocate all other linenumbers. */
1335 count++;
1336 while (lineno[count].line_number != 0)
1337 {
1338 lineno[count].u.offset +=
1339 (symbol->symbol.section->output_section->vma
1340 + symbol->symbol.section->output_offset);
1341 count++;
1342 }
1343 symbol->done_lineno = true;
1344
1345 if (! bfd_is_const_section (symbol->symbol.section->output_section))
1346 symbol->symbol.section->output_section->moving_line_filepos +=
1347 count * bfd_coff_linesz (abfd);
1348 }
1349
1350 return coff_write_symbol (abfd, &(symbol->symbol), native, written,
1351 strtab, true, debug_string_section_p,
1352 debug_string_size_p);
1353 }
1354
1355 static void
null_error_handler(const char * fmt ATTRIBUTE_UNUSED,va_list ap ATTRIBUTE_UNUSED)1356 null_error_handler (const char *fmt ATTRIBUTE_UNUSED,
1357 va_list ap ATTRIBUTE_UNUSED)
1358 {
1359 }
1360
1361 /* Write out the COFF symbols. */
1362
1363 bool
coff_write_symbols(bfd * abfd)1364 coff_write_symbols (bfd *abfd)
1365 {
1366 struct bfd_strtab_hash *strtab;
1367 asection *debug_string_section;
1368 bfd_size_type debug_string_size;
1369 unsigned int i;
1370 unsigned int limit = bfd_get_symcount (abfd);
1371 bfd_vma written = 0;
1372 asymbol **p;
1373
1374 debug_string_section = NULL;
1375 debug_string_size = 0;
1376
1377 strtab = _bfd_stringtab_init ();
1378 if (strtab == NULL)
1379 return false;
1380
1381 /* If this target supports long section names, they must be put into
1382 the string table. This is supported by PE. This code must
1383 handle section names just as they are handled in
1384 coff_write_object_contents. This is why we pass hash as FALSE below. */
1385 if (bfd_coff_long_section_names (abfd))
1386 {
1387 asection *o;
1388
1389 for (o = abfd->sections; o != NULL; o = o->next)
1390 if (strlen (o->name) > SCNNMLEN
1391 && _bfd_stringtab_add (strtab, o->name, false, false)
1392 == (bfd_size_type) -1)
1393 return false;
1394 }
1395
1396 /* Seek to the right place. */
1397 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0)
1398 return false;
1399
1400 /* Output all the symbols we have. */
1401 written = 0;
1402 for (p = abfd->outsymbols, i = 0; i < limit; i++, p++)
1403 {
1404 asymbol *symbol = *p;
1405 coff_symbol_type *c_symbol = coff_symbol_from (symbol);
1406
1407 if (c_symbol == (coff_symbol_type *) NULL
1408 || c_symbol->native == (combined_entry_type *) NULL)
1409 {
1410 if (!coff_write_alien_symbol (abfd, symbol, NULL, &written,
1411 strtab, true, &debug_string_section,
1412 &debug_string_size))
1413 return false;
1414 }
1415 else
1416 {
1417 if (coff_backend_info (abfd)->_bfd_coff_classify_symbol != NULL)
1418 {
1419 bfd_error_handler_type current_error_handler;
1420 enum coff_symbol_classification sym_class;
1421 unsigned char *n_sclass;
1422
1423 /* Suppress error reporting by bfd_coff_classify_symbol.
1424 Error messages can be generated when we are processing a local
1425 symbol which has no associated section and we do not have to
1426 worry about this, all we need to know is that it is local. */
1427 current_error_handler = bfd_set_error_handler (null_error_handler);
1428 BFD_ASSERT (c_symbol->native->is_sym);
1429 sym_class = bfd_coff_classify_symbol (abfd,
1430 &c_symbol->native->u.syment);
1431 (void) bfd_set_error_handler (current_error_handler);
1432
1433 n_sclass = &c_symbol->native->u.syment.n_sclass;
1434
1435 /* If the symbol class has been changed (eg objcopy/ld script/etc)
1436 we cannot retain the existing sclass from the original symbol.
1437 Weak symbols only have one valid sclass, so just set it always.
1438 If it is not local class and should be, set it C_STAT.
1439 If it is global and not classified as global, or if it is
1440 weak (which is also classified as global), set it C_EXT. */
1441
1442 if (symbol->flags & BSF_WEAK)
1443 *n_sclass = obj_pe (abfd) ? C_NT_WEAK : C_WEAKEXT;
1444 else if (symbol->flags & BSF_LOCAL && sym_class != COFF_SYMBOL_LOCAL)
1445 *n_sclass = C_STAT;
1446 else if (symbol->flags & BSF_GLOBAL
1447 && (sym_class != COFF_SYMBOL_GLOBAL
1448 #ifdef COFF_WITH_PE
1449 || *n_sclass == C_NT_WEAK
1450 #endif
1451 || *n_sclass == C_WEAKEXT))
1452 c_symbol->native->u.syment.n_sclass = C_EXT;
1453 }
1454
1455 if (!coff_write_native_symbol (abfd, c_symbol, &written,
1456 strtab, &debug_string_section,
1457 &debug_string_size))
1458 return false;
1459 }
1460 }
1461
1462 obj_raw_syment_count (abfd) = written;
1463
1464 /* Now write out strings.
1465
1466 We would normally not write anything here if there are no strings, but
1467 we'll write out 4 so that any stupid coff reader which tries to read the
1468 string table even when there isn't one won't croak. */
1469 {
1470 bfd_byte buffer[STRING_SIZE_SIZE];
1471
1472 #if STRING_SIZE_SIZE == 4
1473 H_PUT_32 (abfd, _bfd_stringtab_size (strtab) + STRING_SIZE_SIZE, buffer);
1474 #else
1475 #error Change H_PUT_32
1476 #endif
1477 if (bfd_write (buffer, sizeof (buffer), abfd) != sizeof (buffer))
1478 return false;
1479
1480 if (! _bfd_stringtab_emit (abfd, strtab))
1481 return false;
1482 }
1483
1484 _bfd_stringtab_free (strtab);
1485
1486 /* Make sure the .debug section was created to be the correct size.
1487 We should create it ourselves on the fly, but we don't because
1488 BFD won't let us write to any section until we know how large all
1489 the sections are. We could still do it by making another pass
1490 over the symbols. FIXME. */
1491 BFD_ASSERT (debug_string_size == 0
1492 || (debug_string_section != (asection *) NULL
1493 && (BFD_ALIGN (debug_string_size,
1494 1 << debug_string_section->alignment_power)
1495 == debug_string_section->size)));
1496
1497 return true;
1498 }
1499
1500 bool
coff_write_linenumbers(bfd * abfd)1501 coff_write_linenumbers (bfd *abfd)
1502 {
1503 asection *s;
1504 bfd_size_type linesz;
1505 void * buff;
1506
1507 linesz = bfd_coff_linesz (abfd);
1508 buff = bfd_alloc (abfd, linesz);
1509 if (!buff)
1510 return false;
1511 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
1512 {
1513 if (s->lineno_count)
1514 {
1515 asymbol **q = abfd->outsymbols;
1516 if (bfd_seek (abfd, s->line_filepos, SEEK_SET) != 0)
1517 return false;
1518 /* Find all the linenumbers in this section. */
1519 while (*q)
1520 {
1521 asymbol *p = *q;
1522 if (p->section->output_section == s)
1523 {
1524 alent *l =
1525 BFD_SEND (bfd_asymbol_bfd (p), _get_lineno,
1526 (bfd_asymbol_bfd (p), p));
1527 if (l)
1528 {
1529 /* Found a linenumber entry, output. */
1530 struct internal_lineno out;
1531
1532 memset ((void *) & out, 0, sizeof (out));
1533 out.l_lnno = 0;
1534 out.l_addr.l_symndx = l->u.offset;
1535 bfd_coff_swap_lineno_out (abfd, &out, buff);
1536 if (bfd_write (buff, linesz, abfd) != linesz)
1537 return false;
1538 l++;
1539 while (l->line_number)
1540 {
1541 out.l_lnno = l->line_number;
1542 out.l_addr.l_symndx = l->u.offset;
1543 bfd_coff_swap_lineno_out (abfd, &out, buff);
1544 if (bfd_write (buff, linesz, abfd) != linesz)
1545 return false;
1546 l++;
1547 }
1548 }
1549 }
1550 q++;
1551 }
1552 }
1553 }
1554 bfd_release (abfd, buff);
1555 return true;
1556 }
1557
1558 alent *
coff_get_lineno(bfd * ignore_abfd ATTRIBUTE_UNUSED,asymbol * symbol)1559 coff_get_lineno (bfd *ignore_abfd ATTRIBUTE_UNUSED, asymbol *symbol)
1560 {
1561 return coffsymbol (symbol)->lineno;
1562 }
1563
1564 /* This function transforms the offsets into the symbol table into
1565 pointers to syments. */
1566
1567 static void
coff_pointerize_aux(bfd * abfd,combined_entry_type * table_base,combined_entry_type * symbol,unsigned int indaux,combined_entry_type * auxent)1568 coff_pointerize_aux (bfd *abfd,
1569 combined_entry_type *table_base,
1570 combined_entry_type *symbol,
1571 unsigned int indaux,
1572 combined_entry_type *auxent)
1573 {
1574 unsigned int type = symbol->u.syment.n_type;
1575 unsigned int n_sclass = symbol->u.syment.n_sclass;
1576
1577 BFD_ASSERT (symbol->is_sym);
1578 if (coff_backend_info (abfd)->_bfd_coff_pointerize_aux_hook)
1579 {
1580 if ((*coff_backend_info (abfd)->_bfd_coff_pointerize_aux_hook)
1581 (abfd, table_base, symbol, indaux, auxent))
1582 return;
1583 }
1584
1585 /* Don't bother if this is a file or a section. */
1586 if (n_sclass == C_STAT && type == T_NULL)
1587 return;
1588 if (n_sclass == C_FILE)
1589 return;
1590 if (n_sclass == C_DWARF)
1591 return;
1592
1593 BFD_ASSERT (! auxent->is_sym);
1594 /* Otherwise patch up. */
1595 #define N_TMASK coff_data (abfd)->local_n_tmask
1596 #define N_BTSHFT coff_data (abfd)->local_n_btshft
1597
1598 if ((ISFCN (type) || ISTAG (n_sclass) || n_sclass == C_BLOCK
1599 || n_sclass == C_FCN)
1600 && auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.u32 > 0
1601 && (auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.u32
1602 < obj_raw_syment_count (abfd)))
1603 {
1604 auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p =
1605 table_base + auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.u32;
1606 auxent->fix_end = 1;
1607 }
1608
1609 /* A negative tagndx is meaningless, but the SCO 3.2v4 cc can
1610 generate one, so we must be careful to ignore it. */
1611 if (auxent->u.auxent.x_sym.x_tagndx.u32 < obj_raw_syment_count (abfd))
1612 {
1613 auxent->u.auxent.x_sym.x_tagndx.p =
1614 table_base + auxent->u.auxent.x_sym.x_tagndx.u32;
1615 auxent->fix_tag = 1;
1616 }
1617 }
1618
1619 /* Allocate space for the ".debug" section, and read it.
1620 We did not read the debug section until now, because
1621 we didn't want to go to the trouble until someone needed it. */
1622
1623 static char *
build_debug_section(bfd * abfd,asection ** sect_return)1624 build_debug_section (bfd *abfd, asection ** sect_return)
1625 {
1626 char *debug_section;
1627 file_ptr position;
1628 bfd_size_type sec_size;
1629
1630 asection *sect = bfd_get_section_by_name (abfd, ".debug");
1631
1632 if (!sect)
1633 {
1634 bfd_set_error (bfd_error_no_debug_section);
1635 return NULL;
1636 }
1637
1638 /* Seek to the beginning of the `.debug' section and read it.
1639 Save the current position first; it is needed by our caller.
1640 Then read debug section and reset the file pointer. */
1641
1642 position = bfd_tell (abfd);
1643 if (bfd_seek (abfd, sect->filepos, SEEK_SET) != 0)
1644 return NULL;
1645
1646 sec_size = sect->size;
1647 debug_section = (char *) _bfd_alloc_and_read (abfd, sec_size + 1, sec_size);
1648 if (debug_section == NULL)
1649 return NULL;
1650 debug_section[sec_size] = 0;
1651
1652 if (bfd_seek (abfd, position, SEEK_SET) != 0)
1653 return NULL;
1654
1655 * sect_return = sect;
1656 return debug_section;
1657 }
1658
1659 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
1660 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
1661 be \0-terminated. */
1662
1663 static char *
copy_name(bfd * abfd,char * name,size_t maxlen)1664 copy_name (bfd *abfd, char *name, size_t maxlen)
1665 {
1666 size_t len;
1667 char *newname;
1668
1669 for (len = 0; len < maxlen; ++len)
1670 if (name[len] == '\0')
1671 break;
1672
1673 if ((newname = (char *) bfd_alloc (abfd, (bfd_size_type) len + 1)) == NULL)
1674 return NULL;
1675
1676 strncpy (newname, name, len);
1677 newname[len] = '\0';
1678 return newname;
1679 }
1680
1681 /* Read in the external symbols. */
1682
1683 bool
_bfd_coff_get_external_symbols(bfd * abfd)1684 _bfd_coff_get_external_symbols (bfd *abfd)
1685 {
1686 size_t symesz;
1687 size_t size;
1688 void * syms;
1689 ufile_ptr filesize;
1690
1691 if (obj_coff_external_syms (abfd) != NULL)
1692 return true;
1693
1694 symesz = bfd_coff_symesz (abfd);
1695 if (_bfd_mul_overflow (obj_raw_syment_count (abfd), symesz, &size))
1696 {
1697 bfd_set_error (bfd_error_file_truncated);
1698 return false;
1699 }
1700
1701 if (size == 0)
1702 return true;
1703
1704 filesize = bfd_get_file_size (abfd);
1705 if (filesize != 0
1706 && ((ufile_ptr) obj_sym_filepos (abfd) > filesize
1707 || size > filesize - obj_sym_filepos (abfd)))
1708 {
1709 bfd_set_error (bfd_error_file_truncated);
1710 return false;
1711 }
1712
1713 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0)
1714 return false;
1715 syms = _bfd_malloc_and_read (abfd, size, size);
1716 obj_coff_external_syms (abfd) = syms;
1717 return syms != NULL;
1718 }
1719
1720 /* Read in the external strings. The strings are not loaded until
1721 they are needed. This is because we have no simple way of
1722 detecting a missing string table in an archive. If the strings
1723 are loaded then the STRINGS and STRINGS_LEN fields in the
1724 coff_tdata structure will be set. */
1725
1726 const char *
_bfd_coff_read_string_table(bfd * abfd)1727 _bfd_coff_read_string_table (bfd *abfd)
1728 {
1729 char extstrsize[STRING_SIZE_SIZE];
1730 bfd_size_type strsize;
1731 char *strings;
1732 ufile_ptr pos;
1733 ufile_ptr filesize;
1734 size_t symesz;
1735 size_t size;
1736
1737 if (obj_coff_strings (abfd) != NULL)
1738 return obj_coff_strings (abfd);
1739
1740 if (obj_sym_filepos (abfd) == 0)
1741 {
1742 bfd_set_error (bfd_error_no_symbols);
1743 return NULL;
1744 }
1745
1746 symesz = bfd_coff_symesz (abfd);
1747 pos = obj_sym_filepos (abfd);
1748 if (_bfd_mul_overflow (obj_raw_syment_count (abfd), symesz, &size)
1749 || pos + size < pos)
1750 {
1751 bfd_set_error (bfd_error_file_truncated);
1752 return NULL;
1753 }
1754
1755 if (bfd_seek (abfd, pos + size, SEEK_SET) != 0)
1756 return NULL;
1757
1758 if (bfd_read (extstrsize, sizeof extstrsize, abfd) != sizeof extstrsize)
1759 {
1760 if (bfd_get_error () != bfd_error_file_truncated)
1761 return NULL;
1762
1763 /* There is no string table. */
1764 strsize = STRING_SIZE_SIZE;
1765 }
1766 else
1767 {
1768 #if STRING_SIZE_SIZE == 4
1769 strsize = H_GET_32 (abfd, extstrsize);
1770 #else
1771 #error Change H_GET_32
1772 #endif
1773 }
1774
1775 filesize = bfd_get_file_size (abfd);
1776 if (strsize < STRING_SIZE_SIZE
1777 || (filesize != 0 && strsize > filesize))
1778 {
1779 _bfd_error_handler
1780 /* xgettext: c-format */
1781 (_("%pB: bad string table size %" PRIu64), abfd, (uint64_t) strsize);
1782 bfd_set_error (bfd_error_bad_value);
1783 return NULL;
1784 }
1785
1786 strings = (char *) bfd_malloc (strsize + 1);
1787 if (strings == NULL)
1788 return NULL;
1789
1790 /* PR 17521 file: 079-54929-0.004.
1791 A corrupt file could contain an index that points into the first
1792 STRING_SIZE_SIZE bytes of the string table, so make sure that
1793 they are zero. */
1794 memset (strings, 0, STRING_SIZE_SIZE);
1795
1796 if (bfd_read (strings + STRING_SIZE_SIZE, strsize - STRING_SIZE_SIZE, abfd)
1797 != strsize - STRING_SIZE_SIZE)
1798 {
1799 free (strings);
1800 return NULL;
1801 }
1802
1803 obj_coff_strings (abfd) = strings;
1804 obj_coff_strings_len (abfd) = strsize;
1805 /* Terminate the string table, just in case. */
1806 strings[strsize] = 0;
1807 return strings;
1808 }
1809
1810 /* Free up the external symbols and strings read from a COFF file. */
1811
1812 bool
_bfd_coff_free_symbols(bfd * abfd)1813 _bfd_coff_free_symbols (bfd *abfd)
1814 {
1815 if (! bfd_family_coff (abfd))
1816 return false;
1817
1818 if (obj_coff_external_syms (abfd) != NULL
1819 && ! obj_coff_keep_syms (abfd))
1820 {
1821 free (obj_coff_external_syms (abfd));
1822 obj_coff_external_syms (abfd) = NULL;
1823 }
1824
1825 if (obj_coff_strings (abfd) != NULL
1826 && ! obj_coff_keep_strings (abfd))
1827 {
1828 free (obj_coff_strings (abfd));
1829 obj_coff_strings (abfd) = NULL;
1830 obj_coff_strings_len (abfd) = 0;
1831 }
1832
1833 return true;
1834 }
1835
1836 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
1837 knit the symbol names into a normalized form. By normalized here I
1838 mean that all symbols have an n_offset pointer that points to a null-
1839 terminated string. */
1840
1841 combined_entry_type *
coff_get_normalized_symtab(bfd * abfd)1842 coff_get_normalized_symtab (bfd *abfd)
1843 {
1844 combined_entry_type *internal;
1845 combined_entry_type *internal_ptr;
1846 size_t symesz;
1847 char *raw_src;
1848 char *raw_end;
1849 const char *string_table = NULL;
1850 asection * debug_sec = NULL;
1851 char *debug_sec_data = NULL;
1852 bfd_size_type size;
1853
1854 if (obj_raw_syments (abfd) != NULL)
1855 return obj_raw_syments (abfd);
1856
1857 if (! _bfd_coff_get_external_symbols (abfd))
1858 return NULL;
1859
1860 size = obj_raw_syment_count (abfd);
1861 /* Check for integer overflow. */
1862 if (size > (bfd_size_type) -1 / sizeof (combined_entry_type))
1863 return NULL;
1864 size *= sizeof (combined_entry_type);
1865 internal = (combined_entry_type *) bfd_zalloc (abfd, size);
1866 if (internal == NULL && size != 0)
1867 return NULL;
1868
1869 raw_src = (char *) obj_coff_external_syms (abfd);
1870
1871 /* Mark the end of the symbols. */
1872 symesz = bfd_coff_symesz (abfd);
1873 raw_end = PTR_ADD (raw_src, obj_raw_syment_count (abfd) * symesz);
1874
1875 /* FIXME SOMEDAY. A string table size of zero is very weird, but
1876 probably possible. If one shows up, it will probably kill us. */
1877
1878 /* Swap all the raw entries. */
1879 for (internal_ptr = internal;
1880 raw_src < raw_end;
1881 raw_src += symesz, internal_ptr++)
1882 {
1883 unsigned int i;
1884
1885 bfd_coff_swap_sym_in (abfd, (void *) raw_src,
1886 (void *) & internal_ptr->u.syment);
1887 internal_ptr->is_sym = true;
1888 combined_entry_type *sym = internal_ptr;
1889
1890 /* PR 17512: Prevent buffer overrun. */
1891 if (sym->u.syment.n_numaux > ((raw_end - 1) - raw_src) / symesz)
1892 return NULL;
1893
1894 for (i = 0; i < sym->u.syment.n_numaux; i++)
1895 {
1896 internal_ptr++;
1897 raw_src += symesz;
1898
1899 bfd_coff_swap_aux_in (abfd, (void *) raw_src,
1900 sym->u.syment.n_type,
1901 sym->u.syment.n_sclass,
1902 (int) i, sym->u.syment.n_numaux,
1903 &(internal_ptr->u.auxent));
1904
1905 internal_ptr->is_sym = false;
1906 coff_pointerize_aux (abfd, internal, sym, i, internal_ptr);
1907 }
1908
1909 if (sym->u.syment.n_sclass == C_FILE
1910 && sym->u.syment.n_numaux > 0)
1911 {
1912 combined_entry_type * aux = sym + 1;
1913
1914 /* Make a file symbol point to the name in the auxent, since
1915 the text ".file" is redundant. */
1916 BFD_ASSERT (! aux->is_sym);
1917
1918 if (aux->u.auxent.x_file.x_n.x_n.x_zeroes == 0)
1919 {
1920 /* The filename is a long one, point into the string table. */
1921 if (string_table == NULL)
1922 {
1923 string_table = _bfd_coff_read_string_table (abfd);
1924 if (string_table == NULL)
1925 return NULL;
1926 }
1927
1928 if ((bfd_size_type) aux->u.auxent.x_file.x_n.x_n.x_offset
1929 >= obj_coff_strings_len (abfd))
1930 sym->u.syment._n._n_n._n_offset =
1931 (uintptr_t) _("<corrupt>");
1932 else
1933 sym->u.syment._n._n_n._n_offset =
1934 (uintptr_t) (string_table
1935 + aux->u.auxent.x_file.x_n.x_n.x_offset);
1936 }
1937 else
1938 {
1939 /* Ordinary short filename, put into memory anyway. The
1940 Microsoft PE tools sometimes store a filename in
1941 multiple AUX entries. */
1942 size_t len;
1943 char *src;
1944 if (sym->u.syment.n_numaux > 1 && obj_pe (abfd))
1945 {
1946 len = sym->u.syment.n_numaux * symesz;
1947 src = raw_src - (len - symesz);
1948 }
1949 else
1950 {
1951 len = bfd_coff_filnmlen (abfd);
1952 src = aux->u.auxent.x_file.x_n.x_fname;
1953 }
1954 sym->u.syment._n._n_n._n_offset =
1955 (uintptr_t) copy_name (abfd, src, len);
1956 }
1957
1958 /* Normalize other strings available in C_FILE aux entries. */
1959 if (!obj_pe (abfd))
1960 for (int numaux = 1;
1961 numaux < sym->u.syment.n_numaux;
1962 numaux++)
1963 {
1964 aux = sym + numaux + 1;
1965 BFD_ASSERT (! aux->is_sym);
1966
1967 if (aux->u.auxent.x_file.x_n.x_n.x_zeroes == 0)
1968 {
1969 /* The string information is a long one, point
1970 into the string table. */
1971 if (string_table == NULL)
1972 {
1973 string_table = _bfd_coff_read_string_table (abfd);
1974 if (string_table == NULL)
1975 return NULL;
1976 }
1977
1978 if ((bfd_size_type) aux->u.auxent.x_file.x_n.x_n.x_offset
1979 >= obj_coff_strings_len (abfd))
1980 aux->u.auxent.x_file.x_n.x_n.x_offset =
1981 (uintptr_t) _("<corrupt>");
1982 else
1983 aux->u.auxent.x_file.x_n.x_n.x_offset =
1984 (uintptr_t) (string_table
1985 + aux->u.auxent.x_file.x_n.x_n.x_offset);
1986 }
1987 else
1988 aux->u.auxent.x_file.x_n.x_n.x_offset =
1989 ((uintptr_t)
1990 copy_name (abfd,
1991 aux->u.auxent.x_file.x_n.x_fname,
1992 bfd_coff_filnmlen (abfd)));
1993 }
1994
1995 }
1996 else
1997 {
1998 if (sym->u.syment._n._n_n._n_zeroes != 0)
1999 {
2000 /* This is a "short" name. Make it long. */
2001 char *newstring;
2002
2003 /* Find the length of this string without walking into memory
2004 that isn't ours. */
2005 for (i = 0; i < SYMNMLEN; ++i)
2006 if (sym->u.syment._n._n_name[i] == '\0')
2007 break;
2008
2009 newstring = bfd_alloc (abfd, i + 1);
2010 if (newstring == NULL)
2011 return NULL;
2012 memcpy (newstring, sym->u.syment._n._n_name, i);
2013 newstring[i] = 0;
2014 sym->u.syment._n._n_n._n_offset = (uintptr_t) newstring;
2015 sym->u.syment._n._n_n._n_zeroes = 0;
2016 }
2017 else if (sym->u.syment._n._n_n._n_offset == 0)
2018 sym->u.syment._n._n_n._n_offset = (uintptr_t) "";
2019 else if (!bfd_coff_symname_in_debug (abfd, &sym->u.syment))
2020 {
2021 /* Long name already. Point symbol at the string in the
2022 table. */
2023 if (string_table == NULL)
2024 {
2025 string_table = _bfd_coff_read_string_table (abfd);
2026 if (string_table == NULL)
2027 return NULL;
2028 }
2029 if (sym->u.syment._n._n_n._n_offset >= obj_coff_strings_len (abfd))
2030 sym->u.syment._n._n_n._n_offset =
2031 (uintptr_t) _("<corrupt>");
2032 else
2033 sym->u.syment._n._n_n._n_offset =
2034 (uintptr_t) (string_table
2035 + sym->u.syment._n._n_n._n_offset);
2036 }
2037 else
2038 {
2039 /* Long name in debug section. Very similar. */
2040 if (debug_sec_data == NULL)
2041 {
2042 debug_sec_data = build_debug_section (abfd, &debug_sec);
2043 if (debug_sec_data == NULL)
2044 return NULL;
2045 }
2046 /* PR binutils/17512: Catch out of range offsets into
2047 the debug data. */
2048 if (sym->u.syment._n._n_n._n_offset >= debug_sec->size)
2049 sym->u.syment._n._n_n._n_offset =
2050 (uintptr_t) _("<corrupt>");
2051 else
2052 sym->u.syment._n._n_n._n_offset =
2053 (uintptr_t) (debug_sec_data
2054 + sym->u.syment._n._n_n._n_offset);
2055 }
2056 }
2057 }
2058
2059 /* Free the raw symbols. */
2060 if (obj_coff_external_syms (abfd) != NULL
2061 && ! obj_coff_keep_syms (abfd))
2062 {
2063 free (obj_coff_external_syms (abfd));
2064 obj_coff_external_syms (abfd) = NULL;
2065 }
2066
2067 obj_raw_syments (abfd) = internal;
2068 BFD_ASSERT (obj_raw_syment_count (abfd)
2069 == (size_t) (internal_ptr - internal));
2070
2071 return internal;
2072 }
2073
2074 long
coff_get_reloc_upper_bound(bfd * abfd,sec_ptr asect)2075 coff_get_reloc_upper_bound (bfd *abfd, sec_ptr asect)
2076 {
2077 size_t count, raw;
2078
2079 count = asect->reloc_count;
2080 if (count >= LONG_MAX / sizeof (arelent *)
2081 || _bfd_mul_overflow (count, bfd_coff_relsz (abfd), &raw))
2082 {
2083 bfd_set_error (bfd_error_file_too_big);
2084 return -1;
2085 }
2086 if (!bfd_write_p (abfd))
2087 {
2088 ufile_ptr filesize = bfd_get_file_size (abfd);
2089 if (filesize != 0 && raw > filesize)
2090 {
2091 bfd_set_error (bfd_error_file_truncated);
2092 return -1;
2093 }
2094 }
2095 return (count + 1) * sizeof (arelent *);
2096 }
2097
2098 asymbol *
coff_make_empty_symbol(bfd * abfd)2099 coff_make_empty_symbol (bfd *abfd)
2100 {
2101 size_t amt = sizeof (coff_symbol_type);
2102 coff_symbol_type *new_symbol = (coff_symbol_type *) bfd_zalloc (abfd, amt);
2103
2104 if (new_symbol == NULL)
2105 return NULL;
2106 new_symbol->symbol.section = 0;
2107 new_symbol->native = NULL;
2108 new_symbol->lineno = NULL;
2109 new_symbol->done_lineno = false;
2110 new_symbol->symbol.the_bfd = abfd;
2111
2112 return & new_symbol->symbol;
2113 }
2114
2115 /* Make a debugging symbol. */
2116
2117 asymbol *
coff_bfd_make_debug_symbol(bfd * abfd)2118 coff_bfd_make_debug_symbol (bfd *abfd)
2119 {
2120 size_t amt = sizeof (coff_symbol_type);
2121 coff_symbol_type *new_symbol = (coff_symbol_type *) bfd_alloc (abfd, amt);
2122
2123 if (new_symbol == NULL)
2124 return NULL;
2125 /* @@ The 10 is a guess at a plausible maximum number of aux entries
2126 (but shouldn't be a constant). */
2127 amt = sizeof (combined_entry_type) * 10;
2128 new_symbol->native = (combined_entry_type *) bfd_zalloc (abfd, amt);
2129 if (!new_symbol->native)
2130 return NULL;
2131 new_symbol->native->is_sym = true;
2132 new_symbol->symbol.section = bfd_abs_section_ptr;
2133 new_symbol->symbol.flags = BSF_DEBUGGING;
2134 new_symbol->lineno = NULL;
2135 new_symbol->done_lineno = false;
2136 new_symbol->symbol.the_bfd = abfd;
2137
2138 return & new_symbol->symbol;
2139 }
2140
2141 void
coff_get_symbol_info(bfd * abfd,asymbol * symbol,symbol_info * ret)2142 coff_get_symbol_info (bfd *abfd, asymbol *symbol, symbol_info *ret)
2143 {
2144 bfd_symbol_info (symbol, ret);
2145
2146 if (coffsymbol (symbol)->native != NULL
2147 && coffsymbol (symbol)->native->fix_value
2148 && coffsymbol (symbol)->native->is_sym)
2149 ret->value
2150 = (((uintptr_t) coffsymbol (symbol)->native->u.syment.n_value
2151 - (uintptr_t) obj_raw_syments (abfd))
2152 / sizeof (combined_entry_type));
2153 }
2154
2155 /* Print out information about COFF symbol. */
2156
2157 void
coff_print_symbol(bfd * abfd,void * filep,asymbol * symbol,bfd_print_symbol_type how)2158 coff_print_symbol (bfd *abfd,
2159 void * filep,
2160 asymbol *symbol,
2161 bfd_print_symbol_type how)
2162 {
2163 FILE * file = (FILE *) filep;
2164
2165 switch (how)
2166 {
2167 case bfd_print_symbol_name:
2168 fprintf (file, "%s", symbol->name);
2169 break;
2170
2171 case bfd_print_symbol_more:
2172 fprintf (file, "coff %s %s",
2173 coffsymbol (symbol)->native ? "n" : "g",
2174 coffsymbol (symbol)->lineno ? "l" : " ");
2175 break;
2176
2177 case bfd_print_symbol_all:
2178 if (coffsymbol (symbol)->native)
2179 {
2180 bfd_vma val;
2181 unsigned int aux;
2182 combined_entry_type *combined = coffsymbol (symbol)->native;
2183 combined_entry_type *root = obj_raw_syments (abfd);
2184 struct lineno_cache_entry *l = coffsymbol (symbol)->lineno;
2185
2186 fprintf (file, "[%3ld]", (long) (combined - root));
2187
2188 /* PR 17512: file: 079-33786-0.001:0.1. */
2189 if (combined < obj_raw_syments (abfd)
2190 || combined >= obj_raw_syments (abfd) + obj_raw_syment_count (abfd))
2191 {
2192 fprintf (file, _("<corrupt info> %s"), symbol->name);
2193 break;
2194 }
2195
2196 BFD_ASSERT (combined->is_sym);
2197 if (! combined->fix_value)
2198 val = (bfd_vma) combined->u.syment.n_value;
2199 else
2200 val = (((uintptr_t) combined->u.syment.n_value - (uintptr_t) root)
2201 / sizeof (combined_entry_type));
2202
2203 fprintf (file, "(sec %2d)(fl 0x%02x)(ty %4x)(scl %3d) (nx %d) 0x",
2204 combined->u.syment.n_scnum,
2205 combined->u.syment.n_flags,
2206 combined->u.syment.n_type,
2207 combined->u.syment.n_sclass,
2208 combined->u.syment.n_numaux);
2209 bfd_fprintf_vma (abfd, file, val);
2210 fprintf (file, " %s", symbol->name);
2211
2212 for (aux = 0; aux < combined->u.syment.n_numaux; aux++)
2213 {
2214 combined_entry_type *auxp = combined + aux + 1;
2215 long tagndx;
2216
2217 BFD_ASSERT (! auxp->is_sym);
2218 if (auxp->fix_tag)
2219 tagndx = auxp->u.auxent.x_sym.x_tagndx.p - root;
2220 else
2221 tagndx = auxp->u.auxent.x_sym.x_tagndx.u32;
2222
2223 fprintf (file, "\n");
2224
2225 if (bfd_coff_print_aux (abfd, file, root, combined, auxp, aux))
2226 continue;
2227
2228 switch (combined->u.syment.n_sclass)
2229 {
2230 case C_FILE:
2231 fprintf (file, "File ");
2232 /* Add additional information if this isn't the filename
2233 auxiliary entry. */
2234 if (auxp->u.auxent.x_file.x_ftype)
2235 fprintf (file, "ftype %d fname \"%s\"",
2236 auxp->u.auxent.x_file.x_ftype,
2237 (char *) auxp->u.auxent.x_file.x_n.x_n.x_offset);
2238 break;
2239
2240 case C_DWARF:
2241 fprintf (file, "AUX scnlen %#" PRIx64 " nreloc %" PRId64,
2242 auxp->u.auxent.x_sect.x_scnlen,
2243 auxp->u.auxent.x_sect.x_nreloc);
2244 break;
2245
2246 case C_STAT:
2247 if (combined->u.syment.n_type == T_NULL)
2248 /* Probably a section symbol ? */
2249 {
2250 fprintf (file, "AUX scnlen 0x%lx nreloc %d nlnno %d",
2251 (unsigned long) auxp->u.auxent.x_scn.x_scnlen,
2252 auxp->u.auxent.x_scn.x_nreloc,
2253 auxp->u.auxent.x_scn.x_nlinno);
2254 if (auxp->u.auxent.x_scn.x_checksum != 0
2255 || auxp->u.auxent.x_scn.x_associated != 0
2256 || auxp->u.auxent.x_scn.x_comdat != 0)
2257 fprintf (file, " checksum 0x%x assoc %d comdat %d",
2258 auxp->u.auxent.x_scn.x_checksum,
2259 auxp->u.auxent.x_scn.x_associated,
2260 auxp->u.auxent.x_scn.x_comdat);
2261 break;
2262 }
2263 /* Fall through. */
2264 case C_EXT:
2265 case C_AIX_WEAKEXT:
2266 if (ISFCN (combined->u.syment.n_type))
2267 {
2268 long next, llnos;
2269
2270 if (auxp->fix_end)
2271 next = (auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p
2272 - root);
2273 else
2274 next = auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.u32;
2275 llnos = auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_lnnoptr;
2276 fprintf (file,
2277 "AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld",
2278 tagndx,
2279 (unsigned long) auxp->u.auxent.x_sym.x_misc.x_fsize,
2280 llnos, next);
2281 break;
2282 }
2283 /* Fall through. */
2284 default:
2285 fprintf (file, "AUX lnno %d size 0x%x tagndx %ld",
2286 auxp->u.auxent.x_sym.x_misc.x_lnsz.x_lnno,
2287 auxp->u.auxent.x_sym.x_misc.x_lnsz.x_size,
2288 tagndx);
2289 if (auxp->fix_end)
2290 fprintf (file, " endndx %ld",
2291 ((long)
2292 (auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p
2293 - root)));
2294 break;
2295 }
2296 }
2297
2298 if (l)
2299 {
2300 fprintf (file, "\n%s :", l->u.sym->name);
2301 l++;
2302 while (l->line_number)
2303 {
2304 if (l->line_number > 0)
2305 {
2306 fprintf (file, "\n%4d : ", l->line_number);
2307 bfd_fprintf_vma (abfd, file, l->u.offset + symbol->section->vma);
2308 }
2309 l++;
2310 }
2311 }
2312 }
2313 else
2314 {
2315 bfd_print_symbol_vandf (abfd, (void *) file, symbol);
2316 fprintf (file, " %-5s %s %s %s",
2317 symbol->section->name,
2318 coffsymbol (symbol)->native ? "n" : "g",
2319 coffsymbol (symbol)->lineno ? "l" : " ",
2320 symbol->name);
2321 }
2322 }
2323 }
2324
2325 /* Return whether a symbol name implies a local symbol. In COFF,
2326 local symbols generally start with ``.L''. Most targets use this
2327 function for the is_local_label_name entry point, but some may
2328 override it. */
2329
2330 bool
_bfd_coff_is_local_label_name(bfd * abfd ATTRIBUTE_UNUSED,const char * name)2331 _bfd_coff_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
2332 const char *name)
2333 {
2334 return name[0] == '.' && name[1] == 'L';
2335 }
2336
2337 /* Provided a BFD, a section and an offset (in bytes, not octets) into the
2338 section, calculate and return the name of the source file and the line
2339 nearest to the wanted location. */
2340
2341 bool
coff_find_nearest_line_with_names(bfd * abfd,asymbol ** symbols,asection * section,bfd_vma offset,const char ** filename_ptr,const char ** functionname_ptr,unsigned int * line_ptr,const struct dwarf_debug_section * debug_sections)2342 coff_find_nearest_line_with_names (bfd *abfd,
2343 asymbol **symbols,
2344 asection *section,
2345 bfd_vma offset,
2346 const char **filename_ptr,
2347 const char **functionname_ptr,
2348 unsigned int *line_ptr,
2349 const struct dwarf_debug_section *debug_sections)
2350 {
2351 bool found;
2352 unsigned int i;
2353 unsigned int line_base;
2354 coff_data_type *cof = coff_data (abfd);
2355 /* Run through the raw syments if available. */
2356 combined_entry_type *p;
2357 combined_entry_type *pend;
2358 alent *l;
2359 struct coff_section_tdata *sec_data;
2360 size_t amt;
2361
2362 /* Before looking through the symbol table, try to use a .stab
2363 section to find the information. */
2364 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
2365 &found, filename_ptr,
2366 functionname_ptr, line_ptr,
2367 &coff_data(abfd)->line_info))
2368 return false;
2369
2370 if (found)
2371 return true;
2372
2373 /* Also try examining DWARF2 debugging information. */
2374 if (_bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset,
2375 filename_ptr, functionname_ptr,
2376 line_ptr, NULL, debug_sections,
2377 &coff_data(abfd)->dwarf2_find_line_info))
2378 return true;
2379
2380 sec_data = coff_section_data (abfd, section);
2381
2382 /* If the DWARF lookup failed, but there is DWARF information available
2383 then the problem might be that the file has been rebased. This tool
2384 changes the VMAs of all the sections, but it does not update the DWARF
2385 information. So try again, using a bias against the address sought. */
2386 if (coff_data (abfd)->dwarf2_find_line_info != NULL)
2387 {
2388 bfd_signed_vma bias = 0;
2389
2390 /* Create a cache of the result for the next call. */
2391 if (sec_data == NULL && section->owner == abfd)
2392 {
2393 amt = sizeof (struct coff_section_tdata);
2394 section->used_by_bfd = bfd_zalloc (abfd, amt);
2395 sec_data = (struct coff_section_tdata *) section->used_by_bfd;
2396 }
2397
2398 if (sec_data != NULL && sec_data->saved_bias)
2399 bias = sec_data->bias;
2400 else if (symbols)
2401 {
2402 bias = _bfd_dwarf2_find_symbol_bias (symbols,
2403 & coff_data (abfd)->dwarf2_find_line_info);
2404
2405 if (sec_data)
2406 {
2407 sec_data->saved_bias = true;
2408 sec_data->bias = bias;
2409 }
2410 }
2411
2412 if (bias
2413 && _bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section,
2414 offset + bias,
2415 filename_ptr, functionname_ptr,
2416 line_ptr, NULL, debug_sections,
2417 &coff_data(abfd)->dwarf2_find_line_info))
2418 return true;
2419 }
2420
2421 *filename_ptr = 0;
2422 *functionname_ptr = 0;
2423 *line_ptr = 0;
2424
2425 /* Don't try and find line numbers in a non coff file. */
2426 if (!bfd_family_coff (abfd))
2427 return false;
2428
2429 if (cof == NULL)
2430 return false;
2431
2432 /* Find the first C_FILE symbol. */
2433 p = cof->raw_syments;
2434 if (!p)
2435 return false;
2436
2437 pend = p + cof->raw_syment_count;
2438 while (p < pend)
2439 {
2440 BFD_ASSERT (p->is_sym);
2441 if (p->u.syment.n_sclass == C_FILE)
2442 break;
2443 p += 1 + p->u.syment.n_numaux;
2444 }
2445
2446 if (p < pend)
2447 {
2448 bfd_vma sec_vma;
2449 bfd_vma maxdiff;
2450
2451 /* Look through the C_FILE symbols to find the best one. */
2452 sec_vma = bfd_section_vma (section);
2453 *filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
2454 maxdiff = (bfd_vma) 0 - (bfd_vma) 1;
2455 while (1)
2456 {
2457 bfd_vma file_addr;
2458 combined_entry_type *p2;
2459
2460 for (p2 = p + 1 + p->u.syment.n_numaux;
2461 p2 < pend;
2462 p2 += 1 + p2->u.syment.n_numaux)
2463 {
2464 BFD_ASSERT (p2->is_sym);
2465 if (p2->u.syment.n_scnum > 0
2466 && (section
2467 == coff_section_from_bfd_index (abfd,
2468 p2->u.syment.n_scnum)))
2469 break;
2470 if (p2->u.syment.n_sclass == C_FILE)
2471 {
2472 p2 = pend;
2473 break;
2474 }
2475 }
2476 if (p2 >= pend)
2477 break;
2478
2479 file_addr = (bfd_vma) p2->u.syment.n_value;
2480 /* PR 11512: Include the section address of the function name symbol. */
2481 if (p2->u.syment.n_scnum > 0)
2482 file_addr += coff_section_from_bfd_index (abfd,
2483 p2->u.syment.n_scnum)->vma;
2484 /* We use <= MAXDIFF here so that if we get a zero length
2485 file, we actually use the next file entry. */
2486 if (p2 < pend
2487 && offset + sec_vma >= file_addr
2488 && offset + sec_vma - file_addr <= maxdiff)
2489 {
2490 *filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
2491 maxdiff = offset + sec_vma - p2->u.syment.n_value;
2492 }
2493
2494 if (p->u.syment.n_value >= cof->raw_syment_count)
2495 break;
2496
2497 /* Avoid endless loops on erroneous files by ensuring that
2498 we always move forward in the file. */
2499 if (p >= cof->raw_syments + p->u.syment.n_value)
2500 break;
2501
2502 p = cof->raw_syments + p->u.syment.n_value;
2503 if (!p->is_sym || p->u.syment.n_sclass != C_FILE)
2504 break;
2505 }
2506 }
2507
2508 if (section->lineno_count == 0)
2509 {
2510 *functionname_ptr = NULL;
2511 *line_ptr = 0;
2512 return true;
2513 }
2514
2515 /* Now wander though the raw linenumbers of the section.
2516 If we have been called on this section before, and the offset
2517 we want is further down then we can prime the lookup loop. */
2518 if (sec_data != NULL
2519 && sec_data->i > 0
2520 && offset >= sec_data->offset)
2521 {
2522 i = sec_data->i;
2523 *functionname_ptr = sec_data->function;
2524 line_base = sec_data->line_base;
2525 }
2526 else
2527 {
2528 i = 0;
2529 line_base = 0;
2530 }
2531
2532 if (section->lineno != NULL)
2533 {
2534 bfd_vma last_value = 0;
2535
2536 l = §ion->lineno[i];
2537
2538 for (; i < section->lineno_count; i++)
2539 {
2540 if (l->line_number == 0)
2541 {
2542 /* Get the symbol this line number points at. */
2543 coff_symbol_type *coff = (coff_symbol_type *) (l->u.sym);
2544 if (coff->symbol.value > offset)
2545 break;
2546
2547 *functionname_ptr = coff->symbol.name;
2548 last_value = coff->symbol.value;
2549 if (coff->native)
2550 {
2551 combined_entry_type *s = coff->native;
2552
2553 BFD_ASSERT (s->is_sym);
2554 s = s + 1 + s->u.syment.n_numaux;
2555
2556 /* In XCOFF a debugging symbol can follow the
2557 function symbol. */
2558 if (((size_t) ((char *) s - (char *) obj_raw_syments (abfd))
2559 < obj_raw_syment_count (abfd) * sizeof (*s))
2560 && s->u.syment.n_scnum == N_DEBUG)
2561 s = s + 1 + s->u.syment.n_numaux;
2562
2563 /* S should now point to the .bf of the function. */
2564 if (((size_t) ((char *) s - (char *) obj_raw_syments (abfd))
2565 < obj_raw_syment_count (abfd) * sizeof (*s))
2566 && s->u.syment.n_numaux)
2567 {
2568 /* The linenumber is stored in the auxent. */
2569 union internal_auxent *a = &((s + 1)->u.auxent);
2570
2571 line_base = a->x_sym.x_misc.x_lnsz.x_lnno;
2572 *line_ptr = line_base;
2573 }
2574 }
2575 }
2576 else
2577 {
2578 if (l->u.offset > offset)
2579 break;
2580 *line_ptr = l->line_number + line_base - 1;
2581 }
2582 l++;
2583 }
2584
2585 /* If we fell off the end of the loop, then assume that this
2586 symbol has no line number info. Otherwise, symbols with no
2587 line number info get reported with the line number of the
2588 last line of the last symbol which does have line number
2589 info. We use 0x100 as a slop to account for cases where the
2590 last line has executable code. */
2591 if (i >= section->lineno_count
2592 && last_value != 0
2593 && offset - last_value > 0x100)
2594 {
2595 *functionname_ptr = NULL;
2596 *line_ptr = 0;
2597 }
2598 }
2599
2600 /* Cache the results for the next call. */
2601 if (sec_data == NULL && section->owner == abfd)
2602 {
2603 amt = sizeof (struct coff_section_tdata);
2604 section->used_by_bfd = bfd_zalloc (abfd, amt);
2605 sec_data = (struct coff_section_tdata *) section->used_by_bfd;
2606 }
2607
2608 if (sec_data != NULL)
2609 {
2610 sec_data->offset = offset;
2611 sec_data->i = i - 1;
2612 sec_data->function = *functionname_ptr;
2613 sec_data->line_base = line_base;
2614 }
2615
2616 return true;
2617 }
2618
2619 bool
coff_find_nearest_line(bfd * abfd,asymbol ** symbols,asection * section,bfd_vma offset,const char ** filename_ptr,const char ** functionname_ptr,unsigned int * line_ptr,unsigned int * discriminator_ptr)2620 coff_find_nearest_line (bfd *abfd,
2621 asymbol **symbols,
2622 asection *section,
2623 bfd_vma offset,
2624 const char **filename_ptr,
2625 const char **functionname_ptr,
2626 unsigned int *line_ptr,
2627 unsigned int *discriminator_ptr)
2628 {
2629 if (discriminator_ptr)
2630 *discriminator_ptr = 0;
2631 return coff_find_nearest_line_with_names (abfd, symbols, section, offset,
2632 filename_ptr, functionname_ptr,
2633 line_ptr, dwarf_debug_sections);
2634 }
2635
2636 bool
coff_find_inliner_info(bfd * abfd,const char ** filename_ptr,const char ** functionname_ptr,unsigned int * line_ptr)2637 coff_find_inliner_info (bfd *abfd,
2638 const char **filename_ptr,
2639 const char **functionname_ptr,
2640 unsigned int *line_ptr)
2641 {
2642 bool found;
2643
2644 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
2645 functionname_ptr, line_ptr,
2646 &coff_data(abfd)->dwarf2_find_line_info);
2647 return (found);
2648 }
2649
2650 int
coff_sizeof_headers(bfd * abfd,struct bfd_link_info * info)2651 coff_sizeof_headers (bfd *abfd, struct bfd_link_info *info)
2652 {
2653 size_t size;
2654
2655 if (!bfd_link_relocatable (info))
2656 size = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
2657 else
2658 size = bfd_coff_filhsz (abfd);
2659
2660 size += abfd->section_count * bfd_coff_scnhsz (abfd);
2661 return size;
2662 }
2663
2664 /* Change the class of a coff symbol held by BFD. */
2665
2666 bool
bfd_coff_set_symbol_class(bfd * abfd,asymbol * symbol,unsigned int symbol_class)2667 bfd_coff_set_symbol_class (bfd * abfd,
2668 asymbol * symbol,
2669 unsigned int symbol_class)
2670 {
2671 coff_symbol_type * csym;
2672
2673 csym = coff_symbol_from (symbol);
2674 if (csym == NULL)
2675 {
2676 bfd_set_error (bfd_error_invalid_operation);
2677 return false;
2678 }
2679 else if (csym->native == NULL)
2680 {
2681 /* This is an alien symbol which no native coff backend data.
2682 We cheat here by creating a fake native entry for it and
2683 then filling in the class. This code is based on that in
2684 coff_write_alien_symbol(). */
2685
2686 combined_entry_type * native;
2687 size_t amt = sizeof (* native);
2688
2689 native = (combined_entry_type *) bfd_zalloc (abfd, amt);
2690 if (native == NULL)
2691 return false;
2692
2693 native->is_sym = true;
2694 native->u.syment.n_type = T_NULL;
2695 native->u.syment.n_sclass = symbol_class;
2696
2697 if (bfd_is_und_section (symbol->section))
2698 {
2699 native->u.syment.n_scnum = N_UNDEF;
2700 native->u.syment.n_value = symbol->value;
2701 }
2702 else if (bfd_is_com_section (symbol->section))
2703 {
2704 native->u.syment.n_scnum = N_UNDEF;
2705 native->u.syment.n_value = symbol->value;
2706 }
2707 else
2708 {
2709 native->u.syment.n_scnum =
2710 symbol->section->output_section->target_index;
2711 native->u.syment.n_value = (symbol->value
2712 + symbol->section->output_offset);
2713 if (! obj_pe (abfd))
2714 native->u.syment.n_value += symbol->section->output_section->vma;
2715
2716 /* Copy the any flags from the file header into the symbol.
2717 FIXME: Why? */
2718 native->u.syment.n_flags = bfd_asymbol_bfd (& csym->symbol)->flags;
2719 }
2720
2721 csym->native = native;
2722 }
2723 else
2724 csym->native->u.syment.n_sclass = symbol_class;
2725
2726 return true;
2727 }
2728
2729 bool
_bfd_coff_section_already_linked(bfd * abfd,asection * sec,struct bfd_link_info * info)2730 _bfd_coff_section_already_linked (bfd *abfd,
2731 asection *sec,
2732 struct bfd_link_info *info)
2733 {
2734 flagword flags;
2735 const char *name, *key;
2736 struct bfd_section_already_linked *l;
2737 struct bfd_section_already_linked_hash_entry *already_linked_list;
2738 struct coff_comdat_info *s_comdat;
2739
2740 if (sec->output_section == bfd_abs_section_ptr)
2741 return false;
2742
2743 flags = sec->flags;
2744 if ((flags & SEC_LINK_ONCE) == 0)
2745 return false;
2746
2747 /* The COFF backend linker doesn't support group sections. */
2748 if ((flags & SEC_GROUP) != 0)
2749 return false;
2750
2751 name = bfd_section_name (sec);
2752 s_comdat = bfd_coff_get_comdat_section (abfd, sec);
2753
2754 if (s_comdat != NULL)
2755 key = s_comdat->name;
2756 else
2757 {
2758 if (startswith (name, ".gnu.linkonce.")
2759 && (key = strchr (name + sizeof (".gnu.linkonce.") - 1, '.')) != NULL)
2760 key++;
2761 else
2762 /* FIXME: gcc as of 2011-09 emits sections like .text$<key>,
2763 .xdata$<key> and .pdata$<key> only the first of which has a
2764 comdat key. Should these all match the LTO IR key? */
2765 key = name;
2766 }
2767
2768 already_linked_list = bfd_section_already_linked_table_lookup (key);
2769
2770 for (l = already_linked_list->entry; l != NULL; l = l->next)
2771 {
2772 struct coff_comdat_info *l_comdat;
2773
2774 l_comdat = bfd_coff_get_comdat_section (l->sec->owner, l->sec);
2775
2776 /* The section names must match, and both sections must be
2777 comdat and have the same comdat name, or both sections must
2778 be non-comdat. LTO IR plugin sections are an exception. They
2779 are always named .gnu.linkonce.t.<key> (<key> is some string)
2780 and match any comdat section with comdat name of <key>, and
2781 any linkonce section with the same suffix, ie.
2782 .gnu.linkonce.*.<key>. */
2783 if (((s_comdat != NULL) == (l_comdat != NULL)
2784 && strcmp (name, l->sec->name) == 0)
2785 || (l->sec->owner->flags & BFD_PLUGIN) != 0
2786 || (sec->owner->flags & BFD_PLUGIN) != 0)
2787 {
2788 /* The section has already been linked. See if we should
2789 issue a warning. */
2790 return _bfd_handle_already_linked (sec, l, info);
2791 }
2792 }
2793
2794 /* This is the first section with this name. Record it. */
2795 if (!bfd_section_already_linked_table_insert (already_linked_list, sec))
2796 info->callbacks->einfo (_("%F%P: already_linked_table: %E\n"));
2797 return false;
2798 }
2799
2800 /* Initialize COOKIE for input bfd ABFD. */
2801
2802 static bool
init_reloc_cookie(struct coff_reloc_cookie * cookie,struct bfd_link_info * info ATTRIBUTE_UNUSED,bfd * abfd)2803 init_reloc_cookie (struct coff_reloc_cookie *cookie,
2804 struct bfd_link_info *info ATTRIBUTE_UNUSED,
2805 bfd *abfd)
2806 {
2807 /* Sometimes the symbol table does not yet have been loaded here. */
2808 bfd_coff_slurp_symbol_table (abfd);
2809
2810 cookie->abfd = abfd;
2811 cookie->sym_hashes = obj_coff_sym_hashes (abfd);
2812
2813 cookie->symbols = obj_symbols (abfd);
2814
2815 return true;
2816 }
2817
2818 /* Free the memory allocated by init_reloc_cookie, if appropriate. */
2819
2820 static void
fini_reloc_cookie(struct coff_reloc_cookie * cookie ATTRIBUTE_UNUSED,bfd * abfd ATTRIBUTE_UNUSED)2821 fini_reloc_cookie (struct coff_reloc_cookie *cookie ATTRIBUTE_UNUSED,
2822 bfd *abfd ATTRIBUTE_UNUSED)
2823 {
2824 /* Nothing to do. */
2825 }
2826
2827 /* Initialize the relocation information in COOKIE for input section SEC
2828 of input bfd ABFD. */
2829
2830 static bool
init_reloc_cookie_rels(struct coff_reloc_cookie * cookie,struct bfd_link_info * info ATTRIBUTE_UNUSED,bfd * abfd,asection * sec)2831 init_reloc_cookie_rels (struct coff_reloc_cookie *cookie,
2832 struct bfd_link_info *info ATTRIBUTE_UNUSED,
2833 bfd *abfd,
2834 asection *sec)
2835 {
2836 if (sec->reloc_count == 0)
2837 {
2838 cookie->rels = NULL;
2839 cookie->relend = NULL;
2840 cookie->rel = NULL;
2841 return true;
2842 }
2843
2844 cookie->rels = _bfd_coff_read_internal_relocs (abfd, sec, false, NULL,
2845 0, NULL);
2846
2847 if (cookie->rels == NULL)
2848 return false;
2849
2850 cookie->rel = cookie->rels;
2851 cookie->relend = (cookie->rels + sec->reloc_count);
2852 return true;
2853 }
2854
2855 /* Free the memory allocated by init_reloc_cookie_rels,
2856 if appropriate. */
2857
2858 static void
fini_reloc_cookie_rels(struct coff_reloc_cookie * cookie,asection * sec)2859 fini_reloc_cookie_rels (struct coff_reloc_cookie *cookie,
2860 asection *sec)
2861 {
2862 if (cookie->rels
2863 /* PR 20401. The relocs may not have been cached, so check first.
2864 If the relocs were loaded by init_reloc_cookie_rels() then this
2865 will be the case. FIXME: Would performance be improved if the
2866 relocs *were* cached ? */
2867 && coff_section_data (NULL, sec)
2868 && coff_section_data (NULL, sec)->relocs != cookie->rels)
2869 free (cookie->rels);
2870 }
2871
2872 /* Initialize the whole of COOKIE for input section SEC. */
2873
2874 static bool
init_reloc_cookie_for_section(struct coff_reloc_cookie * cookie,struct bfd_link_info * info,asection * sec)2875 init_reloc_cookie_for_section (struct coff_reloc_cookie *cookie,
2876 struct bfd_link_info *info,
2877 asection *sec)
2878 {
2879 if (!init_reloc_cookie (cookie, info, sec->owner))
2880 return false;
2881
2882 if (!init_reloc_cookie_rels (cookie, info, sec->owner, sec))
2883 {
2884 fini_reloc_cookie (cookie, sec->owner);
2885 return false;
2886 }
2887 return true;
2888 }
2889
2890 /* Free the memory allocated by init_reloc_cookie_for_section,
2891 if appropriate. */
2892
2893 static void
fini_reloc_cookie_for_section(struct coff_reloc_cookie * cookie,asection * sec)2894 fini_reloc_cookie_for_section (struct coff_reloc_cookie *cookie,
2895 asection *sec)
2896 {
2897 fini_reloc_cookie_rels (cookie, sec);
2898 fini_reloc_cookie (cookie, sec->owner);
2899 }
2900
2901 static asection *
_bfd_coff_gc_mark_hook(asection * sec,struct bfd_link_info * info ATTRIBUTE_UNUSED,struct internal_reloc * rel ATTRIBUTE_UNUSED,struct coff_link_hash_entry * h,struct internal_syment * sym)2902 _bfd_coff_gc_mark_hook (asection *sec,
2903 struct bfd_link_info *info ATTRIBUTE_UNUSED,
2904 struct internal_reloc *rel ATTRIBUTE_UNUSED,
2905 struct coff_link_hash_entry *h,
2906 struct internal_syment *sym)
2907 {
2908 if (h != NULL)
2909 {
2910 switch (h->root.type)
2911 {
2912 case bfd_link_hash_defined:
2913 case bfd_link_hash_defweak:
2914 return h->root.u.def.section;
2915
2916 case bfd_link_hash_common:
2917 return h->root.u.c.p->section;
2918
2919 case bfd_link_hash_undefweak:
2920 if (h->symbol_class == C_NT_WEAK && h->numaux == 1)
2921 {
2922 /* PE weak externals. A weak symbol may include an auxiliary
2923 record indicating that if the weak symbol is not resolved,
2924 another external symbol is used instead. */
2925 struct coff_link_hash_entry *h2 =
2926 h->auxbfd->tdata.coff_obj_data->sym_hashes
2927 [h->aux->x_sym.x_tagndx.u32];
2928
2929 if (h2 && h2->root.type != bfd_link_hash_undefined)
2930 return h2->root.u.def.section;
2931 }
2932 break;
2933
2934 case bfd_link_hash_undefined:
2935 default:
2936 break;
2937 }
2938 return NULL;
2939 }
2940
2941 return coff_section_from_bfd_index (sec->owner, sym->n_scnum);
2942 }
2943
2944 /* COOKIE->rel describes a relocation against section SEC, which is
2945 a section we've decided to keep. Return the section that contains
2946 the relocation symbol, or NULL if no section contains it. */
2947
2948 static asection *
_bfd_coff_gc_mark_rsec(struct bfd_link_info * info,asection * sec,coff_gc_mark_hook_fn gc_mark_hook,struct coff_reloc_cookie * cookie)2949 _bfd_coff_gc_mark_rsec (struct bfd_link_info *info, asection *sec,
2950 coff_gc_mark_hook_fn gc_mark_hook,
2951 struct coff_reloc_cookie *cookie)
2952 {
2953 struct coff_link_hash_entry *h;
2954
2955 h = cookie->sym_hashes[cookie->rel->r_symndx];
2956 if (h != NULL)
2957 {
2958 while (h->root.type == bfd_link_hash_indirect
2959 || h->root.type == bfd_link_hash_warning)
2960 h = (struct coff_link_hash_entry *) h->root.u.i.link;
2961
2962 return (*gc_mark_hook) (sec, info, cookie->rel, h, NULL);
2963 }
2964
2965 return (*gc_mark_hook) (sec, info, cookie->rel, NULL,
2966 &(cookie->symbols
2967 + obj_convert (sec->owner)[cookie->rel->r_symndx])->native->u.syment);
2968 }
2969
2970 static bool _bfd_coff_gc_mark
2971 (struct bfd_link_info *, asection *, coff_gc_mark_hook_fn);
2972
2973 /* COOKIE->rel describes a relocation against section SEC, which is
2974 a section we've decided to keep. Mark the section that contains
2975 the relocation symbol. */
2976
2977 static bool
_bfd_coff_gc_mark_reloc(struct bfd_link_info * info,asection * sec,coff_gc_mark_hook_fn gc_mark_hook,struct coff_reloc_cookie * cookie)2978 _bfd_coff_gc_mark_reloc (struct bfd_link_info *info,
2979 asection *sec,
2980 coff_gc_mark_hook_fn gc_mark_hook,
2981 struct coff_reloc_cookie *cookie)
2982 {
2983 asection *rsec;
2984
2985 rsec = _bfd_coff_gc_mark_rsec (info, sec, gc_mark_hook, cookie);
2986 if (rsec && !rsec->gc_mark)
2987 {
2988 if (bfd_get_flavour (rsec->owner) != bfd_target_coff_flavour)
2989 rsec->gc_mark = 1;
2990 else if (!_bfd_coff_gc_mark (info, rsec, gc_mark_hook))
2991 return false;
2992 }
2993 return true;
2994 }
2995
2996 /* The mark phase of garbage collection. For a given section, mark
2997 it and any sections in this section's group, and all the sections
2998 which define symbols to which it refers. */
2999
3000 static bool
_bfd_coff_gc_mark(struct bfd_link_info * info,asection * sec,coff_gc_mark_hook_fn gc_mark_hook)3001 _bfd_coff_gc_mark (struct bfd_link_info *info,
3002 asection *sec,
3003 coff_gc_mark_hook_fn gc_mark_hook)
3004 {
3005 bool ret = true;
3006
3007 sec->gc_mark = 1;
3008
3009 /* Look through the section relocs. */
3010 if ((sec->flags & SEC_RELOC) != 0
3011 && sec->reloc_count > 0)
3012 {
3013 struct coff_reloc_cookie cookie;
3014
3015 if (!init_reloc_cookie_for_section (&cookie, info, sec))
3016 ret = false;
3017 else
3018 {
3019 for (; cookie.rel < cookie.relend; cookie.rel++)
3020 {
3021 if (!_bfd_coff_gc_mark_reloc (info, sec, gc_mark_hook, &cookie))
3022 {
3023 ret = false;
3024 break;
3025 }
3026 }
3027 fini_reloc_cookie_for_section (&cookie, sec);
3028 }
3029 }
3030
3031 return ret;
3032 }
3033
3034 static bool
_bfd_coff_gc_mark_extra_sections(struct bfd_link_info * info,coff_gc_mark_hook_fn mark_hook ATTRIBUTE_UNUSED)3035 _bfd_coff_gc_mark_extra_sections (struct bfd_link_info *info,
3036 coff_gc_mark_hook_fn mark_hook ATTRIBUTE_UNUSED)
3037 {
3038 bfd *ibfd;
3039
3040 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
3041 {
3042 asection *isec;
3043 bool some_kept;
3044
3045 if (bfd_get_flavour (ibfd) != bfd_target_coff_flavour)
3046 continue;
3047
3048 /* Ensure all linker created sections are kept, and see whether
3049 any other section is already marked. */
3050 some_kept = false;
3051 for (isec = ibfd->sections; isec != NULL; isec = isec->next)
3052 {
3053 if ((isec->flags & SEC_LINKER_CREATED) != 0)
3054 isec->gc_mark = 1;
3055 else if (isec->gc_mark)
3056 some_kept = true;
3057 }
3058
3059 /* If no section in this file will be kept, then we can
3060 toss out debug sections. */
3061 if (!some_kept)
3062 continue;
3063
3064 /* Keep debug and special sections like .comment when they are
3065 not part of a group, or when we have single-member groups. */
3066 for (isec = ibfd->sections; isec != NULL; isec = isec->next)
3067 if ((isec->flags & SEC_DEBUGGING) != 0
3068 || (isec->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) == 0)
3069 isec->gc_mark = 1;
3070 }
3071 return true;
3072 }
3073
3074 /* Sweep symbols in swept sections. Called via coff_link_hash_traverse. */
3075
3076 static bool
coff_gc_sweep_symbol(struct coff_link_hash_entry * h,void * data ATTRIBUTE_UNUSED)3077 coff_gc_sweep_symbol (struct coff_link_hash_entry *h,
3078 void *data ATTRIBUTE_UNUSED)
3079 {
3080 if (h->root.type == bfd_link_hash_warning)
3081 h = (struct coff_link_hash_entry *) h->root.u.i.link;
3082
3083 if ((h->root.type == bfd_link_hash_defined
3084 || h->root.type == bfd_link_hash_defweak)
3085 && !h->root.u.def.section->gc_mark
3086 && !(h->root.u.def.section->owner->flags & DYNAMIC))
3087 {
3088 /* Do our best to hide the symbol. */
3089 h->root.u.def.section = bfd_und_section_ptr;
3090 h->symbol_class = C_HIDDEN;
3091 }
3092
3093 return true;
3094 }
3095
3096 /* The sweep phase of garbage collection. Remove all garbage sections. */
3097
3098 typedef bool (*gc_sweep_hook_fn)
3099 (bfd *, struct bfd_link_info *, asection *, const struct internal_reloc *);
3100
3101 static bool
coff_gc_sweep(bfd * abfd ATTRIBUTE_UNUSED,struct bfd_link_info * info)3102 coff_gc_sweep (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
3103 {
3104 bfd *sub;
3105
3106 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
3107 {
3108 asection *o;
3109
3110 if (bfd_get_flavour (sub) != bfd_target_coff_flavour)
3111 continue;
3112
3113 for (o = sub->sections; o != NULL; o = o->next)
3114 {
3115 /* Keep debug and special sections. */
3116 if ((o->flags & (SEC_DEBUGGING | SEC_LINKER_CREATED)) != 0
3117 || (o->flags & (SEC_ALLOC | SEC_LOAD | SEC_RELOC)) == 0)
3118 o->gc_mark = 1;
3119 else if (startswith (o->name, ".idata")
3120 || startswith (o->name, ".pdata")
3121 || startswith (o->name, ".xdata")
3122 || startswith (o->name, ".rsrc"))
3123 o->gc_mark = 1;
3124
3125 if (o->gc_mark)
3126 continue;
3127
3128 /* Skip sweeping sections already excluded. */
3129 if (o->flags & SEC_EXCLUDE)
3130 continue;
3131
3132 /* Since this is early in the link process, it is simple
3133 to remove a section from the output. */
3134 o->flags |= SEC_EXCLUDE;
3135
3136 if (info->print_gc_sections && o->size != 0)
3137 /* xgettext: c-format */
3138 _bfd_error_handler (_("removing unused section '%pA' in file '%pB'"),
3139 o, sub);
3140
3141 #if 0
3142 /* But we also have to update some of the relocation
3143 info we collected before. */
3144 if (gc_sweep_hook
3145 && (o->flags & SEC_RELOC) != 0
3146 && o->reloc_count > 0
3147 && !bfd_is_abs_section (o->output_section))
3148 {
3149 struct internal_reloc *internal_relocs;
3150 bool r;
3151
3152 internal_relocs
3153 = _bfd_coff_link_read_relocs (o->owner, o, NULL, NULL,
3154 info->keep_memory);
3155 if (internal_relocs == NULL)
3156 return false;
3157
3158 r = (*gc_sweep_hook) (o->owner, info, o, internal_relocs);
3159
3160 if (coff_section_data (o)->relocs != internal_relocs)
3161 free (internal_relocs);
3162
3163 if (!r)
3164 return false;
3165 }
3166 #endif
3167 }
3168 }
3169
3170 /* Remove the symbols that were in the swept sections from the dynamic
3171 symbol table. */
3172 coff_link_hash_traverse (coff_hash_table (info), coff_gc_sweep_symbol,
3173 NULL);
3174
3175 return true;
3176 }
3177
3178 /* Keep all sections containing symbols undefined on the command-line,
3179 and the section containing the entry symbol. */
3180
3181 static void
_bfd_coff_gc_keep(struct bfd_link_info * info)3182 _bfd_coff_gc_keep (struct bfd_link_info *info)
3183 {
3184 struct bfd_sym_chain *sym;
3185
3186 for (sym = info->gc_sym_list; sym != NULL; sym = sym->next)
3187 {
3188 struct coff_link_hash_entry *h;
3189
3190 h = coff_link_hash_lookup (coff_hash_table (info), sym->name,
3191 false, false, false);
3192
3193 if (h != NULL
3194 && (h->root.type == bfd_link_hash_defined
3195 || h->root.type == bfd_link_hash_defweak)
3196 && !bfd_is_abs_section (h->root.u.def.section))
3197 h->root.u.def.section->flags |= SEC_KEEP;
3198 }
3199 }
3200
3201 /* Do mark and sweep of unused sections. */
3202
3203 bool
bfd_coff_gc_sections(bfd * abfd ATTRIBUTE_UNUSED,struct bfd_link_info * info)3204 bfd_coff_gc_sections (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_link_info *info)
3205 {
3206 bfd *sub;
3207
3208 /* FIXME: Should we implement this? */
3209 #if 0
3210 const bfd_coff_backend_data *bed = coff_backend_info (abfd);
3211
3212 if (!bed->can_gc_sections
3213 || !is_coff_hash_table (info->hash))
3214 {
3215 _bfd_error_handler(_("warning: gc-sections option ignored"));
3216 return true;
3217 }
3218 #endif
3219
3220 _bfd_coff_gc_keep (info);
3221
3222 /* Grovel through relocs to find out who stays ... */
3223 for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
3224 {
3225 asection *o;
3226
3227 if (bfd_get_flavour (sub) != bfd_target_coff_flavour)
3228 continue;
3229
3230 for (o = sub->sections; o != NULL; o = o->next)
3231 {
3232 if (((o->flags & (SEC_EXCLUDE | SEC_KEEP)) == SEC_KEEP
3233 || startswith (o->name, ".vectors")
3234 || startswith (o->name, ".ctors")
3235 || startswith (o->name, ".dtors"))
3236 && !o->gc_mark)
3237 {
3238 if (!_bfd_coff_gc_mark (info, o, _bfd_coff_gc_mark_hook))
3239 return false;
3240 }
3241 }
3242 }
3243
3244 /* Allow the backend to mark additional target specific sections. */
3245 _bfd_coff_gc_mark_extra_sections (info, _bfd_coff_gc_mark_hook);
3246
3247 /* ... and mark SEC_EXCLUDE for those that go. */
3248 return coff_gc_sweep (abfd, info);
3249 }
3250
3251 /* Return name used to identify a comdat group. */
3252
3253 const char *
bfd_coff_group_name(bfd * abfd,const asection * sec)3254 bfd_coff_group_name (bfd *abfd, const asection *sec)
3255 {
3256 struct coff_comdat_info *ci = bfd_coff_get_comdat_section (abfd, sec);
3257 if (ci != NULL)
3258 return ci->name;
3259 return NULL;
3260 }
3261
3262 bool
_bfd_coff_free_cached_info(bfd * abfd)3263 _bfd_coff_free_cached_info (bfd *abfd)
3264 {
3265 struct coff_tdata *tdata;
3266
3267 if (bfd_family_coff (abfd)
3268 && (bfd_get_format (abfd) == bfd_object
3269 || bfd_get_format (abfd) == bfd_core)
3270 && (tdata = coff_data (abfd)) != NULL)
3271 {
3272 if (tdata->section_by_index)
3273 {
3274 htab_delete (tdata->section_by_index);
3275 tdata->section_by_index = NULL;
3276 }
3277
3278 if (tdata->section_by_target_index)
3279 {
3280 htab_delete (tdata->section_by_target_index);
3281 tdata->section_by_target_index = NULL;
3282 }
3283
3284 if (obj_pe (abfd) && pe_data (abfd)->comdat_hash)
3285 {
3286 htab_delete (pe_data (abfd)->comdat_hash);
3287 pe_data (abfd)->comdat_hash = NULL;
3288 }
3289
3290 _bfd_dwarf2_cleanup_debug_info (abfd, &tdata->dwarf2_find_line_info);
3291 _bfd_stab_cleanup (abfd, &tdata->line_info);
3292
3293 /* PR 25447:
3294 Do not clear the keep_syms and keep_strings flags.
3295 These may have been set by pe_ILF_build_a_bfd() indicating
3296 that the syms and strings pointers are not to be freed. */
3297 if (!_bfd_coff_free_symbols (abfd))
3298 return false;
3299 }
3300
3301 return _bfd_generic_bfd_free_cached_info (abfd);
3302 }
3303