2007-07-25 Michael Snyder <msnyder@access-company.com>
[deliverable/binutils-gdb.git] / bfd / coffgen.c
1 /* Support for the generic parts of COFF, for BFD.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2000, 2001, 2002, 2003, 2004, 2005, 2007
4 Free Software Foundation, Inc.
5 Written by Cygnus Support.
6
7 This file is part of BFD, the Binary File Descriptor library.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22 MA 02110-1301, USA. */
23
24 /* Most of this hacked by Steve Chamberlain, sac@cygnus.com.
25 Split out of coffcode.h by Ian Taylor, ian@cygnus.com. */
26
27 /* This file contains COFF code that is not dependent on any
28 particular COFF target. There is only one version of this file in
29 libbfd.a, so no target specific code may be put in here. Or, to
30 put it another way,
31
32 ********** DO NOT PUT TARGET SPECIFIC CODE IN THIS FILE **********
33
34 If you need to add some target specific behaviour, add a new hook
35 function to bfd_coff_backend_data.
36
37 Some of these functions are also called by the ECOFF routines.
38 Those functions may not use any COFF specific information, such as
39 coff_data (abfd). */
40
41 #include "sysdep.h"
42 #include "bfd.h"
43 #include "libbfd.h"
44 #include "coff/internal.h"
45 #include "libcoff.h"
46
47 /* Take a section header read from a coff file (in HOST byte order),
48 and make a BFD "section" out of it. This is used by ECOFF. */
49
50 static bfd_boolean
51 make_a_section_from_file (bfd *abfd,
52 struct internal_scnhdr *hdr,
53 unsigned int target_index)
54 {
55 asection *return_section;
56 char *name;
57 bfd_boolean result = TRUE;
58 flagword flags;
59
60 name = NULL;
61
62 /* Handle long section names as in PE. */
63 if (bfd_coff_long_section_names (abfd)
64 && hdr->s_name[0] == '/')
65 {
66 char buf[SCNNMLEN];
67 long strindex;
68 char *p;
69 const char *strings;
70
71 memcpy (buf, hdr->s_name + 1, SCNNMLEN - 1);
72 buf[SCNNMLEN - 1] = '\0';
73 strindex = strtol (buf, &p, 10);
74 if (*p == '\0' && strindex >= 0)
75 {
76 strings = _bfd_coff_read_string_table (abfd);
77 if (strings == NULL)
78 return FALSE;
79 /* FIXME: For extra safety, we should make sure that
80 strindex does not run us past the end, but right now we
81 don't know the length of the string table. */
82 strings += strindex;
83 name = bfd_alloc (abfd, (bfd_size_type) strlen (strings) + 1);
84 if (name == NULL)
85 return FALSE;
86 strcpy (name, strings);
87 }
88 }
89
90 if (name == NULL)
91 {
92 /* Assorted wastage to null-terminate the name, thanks AT&T! */
93 name = bfd_alloc (abfd, (bfd_size_type) sizeof (hdr->s_name) + 1);
94 if (name == NULL)
95 return FALSE;
96 strncpy (name, (char *) &hdr->s_name[0], sizeof (hdr->s_name));
97 name[sizeof (hdr->s_name)] = 0;
98 }
99
100 return_section = bfd_make_section_anyway (abfd, name);
101 if (return_section == NULL)
102 return FALSE;
103
104 return_section->vma = hdr->s_vaddr;
105 return_section->lma = hdr->s_paddr;
106 return_section->size = hdr->s_size;
107 return_section->filepos = hdr->s_scnptr;
108 return_section->rel_filepos = hdr->s_relptr;
109 return_section->reloc_count = hdr->s_nreloc;
110
111 bfd_coff_set_alignment_hook (abfd, return_section, hdr);
112
113 return_section->line_filepos = hdr->s_lnnoptr;
114
115 return_section->lineno_count = hdr->s_nlnno;
116 return_section->userdata = NULL;
117 return_section->next = NULL;
118 return_section->target_index = target_index;
119
120 if (! bfd_coff_styp_to_sec_flags_hook (abfd, hdr, name, return_section,
121 & flags))
122 result = FALSE;
123
124 return_section->flags = flags;
125
126 /* At least on i386-coff, the line number count for a shared library
127 section must be ignored. */
128 if ((return_section->flags & SEC_COFF_SHARED_LIBRARY) != 0)
129 return_section->lineno_count = 0;
130
131 if (hdr->s_nreloc != 0)
132 return_section->flags |= SEC_RELOC;
133 /* FIXME: should this check 'hdr->s_size > 0'. */
134 if (hdr->s_scnptr != 0)
135 return_section->flags |= SEC_HAS_CONTENTS;
136
137 return result;
138 }
139
140 /* Read in a COFF object and make it into a BFD. This is used by
141 ECOFF as well. */
142
143 static const bfd_target *
144 coff_real_object_p (bfd *abfd,
145 unsigned nscns,
146 struct internal_filehdr *internal_f,
147 struct internal_aouthdr *internal_a)
148 {
149 flagword oflags = abfd->flags;
150 bfd_vma ostart = bfd_get_start_address (abfd);
151 void * tdata;
152 void * tdata_save;
153 bfd_size_type readsize; /* Length of file_info. */
154 unsigned int scnhsz;
155 char *external_sections;
156
157 if (!(internal_f->f_flags & F_RELFLG))
158 abfd->flags |= HAS_RELOC;
159 if ((internal_f->f_flags & F_EXEC))
160 abfd->flags |= EXEC_P;
161 if (!(internal_f->f_flags & F_LNNO))
162 abfd->flags |= HAS_LINENO;
163 if (!(internal_f->f_flags & F_LSYMS))
164 abfd->flags |= HAS_LOCALS;
165
166 /* FIXME: How can we set D_PAGED correctly? */
167 if ((internal_f->f_flags & F_EXEC) != 0)
168 abfd->flags |= D_PAGED;
169
170 bfd_get_symcount (abfd) = internal_f->f_nsyms;
171 if (internal_f->f_nsyms)
172 abfd->flags |= HAS_SYMS;
173
174 if (internal_a != (struct internal_aouthdr *) NULL)
175 bfd_get_start_address (abfd) = internal_a->entry;
176 else
177 bfd_get_start_address (abfd) = 0;
178
179 /* Set up the tdata area. ECOFF uses its own routine, and overrides
180 abfd->flags. */
181 tdata_save = abfd->tdata.any;
182 tdata = bfd_coff_mkobject_hook (abfd, (void *) internal_f, (void *) internal_a);
183 if (tdata == NULL)
184 goto fail2;
185
186 scnhsz = bfd_coff_scnhsz (abfd);
187 readsize = (bfd_size_type) nscns * scnhsz;
188 external_sections = bfd_alloc (abfd, readsize);
189 if (!external_sections)
190 goto fail;
191
192 if (bfd_bread ((void *) external_sections, readsize, abfd) != readsize)
193 goto fail;
194
195 /* Set the arch/mach *before* swapping in sections; section header swapping
196 may depend on arch/mach info. */
197 if (! bfd_coff_set_arch_mach_hook (abfd, (void *) internal_f))
198 goto fail;
199
200 /* Now copy data as required; construct all asections etc. */
201 if (nscns != 0)
202 {
203 unsigned int i;
204 for (i = 0; i < nscns; i++)
205 {
206 struct internal_scnhdr tmp;
207 bfd_coff_swap_scnhdr_in (abfd,
208 (void *) (external_sections + i * scnhsz),
209 (void *) & tmp);
210 if (! make_a_section_from_file (abfd, &tmp, i + 1))
211 goto fail;
212 }
213 }
214
215 return abfd->xvec;
216
217 fail:
218 bfd_release (abfd, tdata);
219 fail2:
220 abfd->tdata.any = tdata_save;
221 abfd->flags = oflags;
222 bfd_get_start_address (abfd) = ostart;
223 return (const bfd_target *) NULL;
224 }
225
226 /* Turn a COFF file into a BFD, but fail with bfd_error_wrong_format if it is
227 not a COFF file. This is also used by ECOFF. */
228
229 const bfd_target *
230 coff_object_p (bfd *abfd)
231 {
232 bfd_size_type filhsz;
233 bfd_size_type aoutsz;
234 unsigned int nscns;
235 void * filehdr;
236 struct internal_filehdr internal_f;
237 struct internal_aouthdr internal_a;
238
239 /* Figure out how much to read. */
240 filhsz = bfd_coff_filhsz (abfd);
241 aoutsz = bfd_coff_aoutsz (abfd);
242
243 filehdr = bfd_alloc (abfd, filhsz);
244 if (filehdr == NULL)
245 return NULL;
246 if (bfd_bread (filehdr, filhsz, abfd) != filhsz)
247 {
248 if (bfd_get_error () != bfd_error_system_call)
249 bfd_set_error (bfd_error_wrong_format);
250 bfd_release (abfd, filehdr);
251 return NULL;
252 }
253 bfd_coff_swap_filehdr_in (abfd, filehdr, &internal_f);
254 bfd_release (abfd, filehdr);
255
256 /* The XCOFF format has two sizes for the f_opthdr. SMALL_AOUTSZ
257 (less than aoutsz) used in object files and AOUTSZ (equal to
258 aoutsz) in executables. The bfd_coff_swap_aouthdr_in function
259 expects this header to be aoutsz bytes in length, so we use that
260 value in the call to bfd_alloc below. But we must be careful to
261 only read in f_opthdr bytes in the call to bfd_bread. We should
262 also attempt to catch corrupt or non-COFF binaries with a strange
263 value for f_opthdr. */
264 if (! bfd_coff_bad_format_hook (abfd, &internal_f)
265 || internal_f.f_opthdr > aoutsz)
266 {
267 bfd_set_error (bfd_error_wrong_format);
268 return NULL;
269 }
270 nscns = internal_f.f_nscns;
271
272 if (internal_f.f_opthdr)
273 {
274 void * opthdr;
275
276 opthdr = bfd_alloc (abfd, aoutsz);
277 if (opthdr == NULL)
278 return NULL;
279 if (bfd_bread (opthdr, (bfd_size_type) internal_f.f_opthdr, abfd)
280 != internal_f.f_opthdr)
281 {
282 bfd_release (abfd, opthdr);
283 return NULL;
284 }
285 bfd_coff_swap_aouthdr_in (abfd, opthdr, (void *) &internal_a);
286 bfd_release (abfd, opthdr);
287 }
288
289 return coff_real_object_p (abfd, nscns, &internal_f,
290 (internal_f.f_opthdr != 0
291 ? &internal_a
292 : (struct internal_aouthdr *) NULL));
293 }
294
295 /* Get the BFD section from a COFF symbol section number. */
296
297 asection *
298 coff_section_from_bfd_index (bfd *abfd, int index)
299 {
300 struct bfd_section *answer = abfd->sections;
301
302 if (index == N_ABS)
303 return bfd_abs_section_ptr;
304 if (index == N_UNDEF)
305 return bfd_und_section_ptr;
306 if (index == N_DEBUG)
307 return bfd_abs_section_ptr;
308
309 while (answer)
310 {
311 if (answer->target_index == index)
312 return answer;
313 answer = answer->next;
314 }
315
316 /* We should not reach this point, but the SCO 3.2v4 /lib/libc_s.a
317 has a bad symbol table in biglitpow.o. */
318 return bfd_und_section_ptr;
319 }
320
321 /* Get the upper bound of a COFF symbol table. */
322
323 long
324 coff_get_symtab_upper_bound (bfd *abfd)
325 {
326 if (!bfd_coff_slurp_symbol_table (abfd))
327 return -1;
328
329 return (bfd_get_symcount (abfd) + 1) * (sizeof (coff_symbol_type *));
330 }
331
332 /* Canonicalize a COFF symbol table. */
333
334 long
335 coff_canonicalize_symtab (bfd *abfd, asymbol **alocation)
336 {
337 unsigned int counter;
338 coff_symbol_type *symbase;
339 coff_symbol_type **location = (coff_symbol_type **) alocation;
340
341 if (!bfd_coff_slurp_symbol_table (abfd))
342 return -1;
343
344 symbase = obj_symbols (abfd);
345 counter = bfd_get_symcount (abfd);
346 while (counter-- > 0)
347 *location++ = symbase++;
348
349 *location = NULL;
350
351 return bfd_get_symcount (abfd);
352 }
353
354 /* Get the name of a symbol. The caller must pass in a buffer of size
355 >= SYMNMLEN + 1. */
356
357 const char *
358 _bfd_coff_internal_syment_name (bfd *abfd,
359 const struct internal_syment *sym,
360 char *buf)
361 {
362 /* FIXME: It's not clear this will work correctly if sizeof
363 (_n_zeroes) != 4. */
364 if (sym->_n._n_n._n_zeroes != 0
365 || sym->_n._n_n._n_offset == 0)
366 {
367 memcpy (buf, sym->_n._n_name, SYMNMLEN);
368 buf[SYMNMLEN] = '\0';
369 return buf;
370 }
371 else
372 {
373 const char *strings;
374
375 BFD_ASSERT (sym->_n._n_n._n_offset >= STRING_SIZE_SIZE);
376 strings = obj_coff_strings (abfd);
377 if (strings == NULL)
378 {
379 strings = _bfd_coff_read_string_table (abfd);
380 if (strings == NULL)
381 return NULL;
382 }
383 return strings + sym->_n._n_n._n_offset;
384 }
385 }
386
387 /* Read in and swap the relocs. This returns a buffer holding the
388 relocs for section SEC in file ABFD. If CACHE is TRUE and
389 INTERNAL_RELOCS is NULL, the relocs read in will be saved in case
390 the function is called again. If EXTERNAL_RELOCS is not NULL, it
391 is a buffer large enough to hold the unswapped relocs. If
392 INTERNAL_RELOCS is not NULL, it is a buffer large enough to hold
393 the swapped relocs. If REQUIRE_INTERNAL is TRUE, then the return
394 value must be INTERNAL_RELOCS. The function returns NULL on error. */
395
396 struct internal_reloc *
397 _bfd_coff_read_internal_relocs (bfd *abfd,
398 asection *sec,
399 bfd_boolean cache,
400 bfd_byte *external_relocs,
401 bfd_boolean require_internal,
402 struct internal_reloc *internal_relocs)
403 {
404 bfd_size_type relsz;
405 bfd_byte *free_external = NULL;
406 struct internal_reloc *free_internal = NULL;
407 bfd_byte *erel;
408 bfd_byte *erel_end;
409 struct internal_reloc *irel;
410 bfd_size_type amt;
411
412 if (coff_section_data (abfd, sec) != NULL
413 && coff_section_data (abfd, sec)->relocs != NULL)
414 {
415 if (! require_internal)
416 return coff_section_data (abfd, sec)->relocs;
417 memcpy (internal_relocs, coff_section_data (abfd, sec)->relocs,
418 sec->reloc_count * sizeof (struct internal_reloc));
419 return internal_relocs;
420 }
421
422 relsz = bfd_coff_relsz (abfd);
423
424 amt = sec->reloc_count * relsz;
425 if (external_relocs == NULL)
426 {
427 free_external = bfd_malloc (amt);
428 if (free_external == NULL && sec->reloc_count > 0)
429 goto error_return;
430 external_relocs = free_external;
431 }
432
433 if (bfd_seek (abfd, sec->rel_filepos, SEEK_SET) != 0
434 || bfd_bread (external_relocs, amt, abfd) != amt)
435 goto error_return;
436
437 if (internal_relocs == NULL)
438 {
439 amt = sec->reloc_count;
440 amt *= sizeof (struct internal_reloc);
441 free_internal = bfd_malloc (amt);
442 if (free_internal == NULL && sec->reloc_count > 0)
443 goto error_return;
444 internal_relocs = free_internal;
445 }
446
447 /* Swap in the relocs. */
448 erel = external_relocs;
449 erel_end = erel + relsz * sec->reloc_count;
450 irel = internal_relocs;
451 for (; erel < erel_end; erel += relsz, irel++)
452 bfd_coff_swap_reloc_in (abfd, (void *) erel, (void *) irel);
453
454 if (free_external != NULL)
455 {
456 free (free_external);
457 free_external = NULL;
458 }
459
460 if (cache && free_internal != NULL)
461 {
462 if (coff_section_data (abfd, sec) == NULL)
463 {
464 amt = sizeof (struct coff_section_tdata);
465 sec->used_by_bfd = bfd_zalloc (abfd, amt);
466 if (sec->used_by_bfd == NULL)
467 goto error_return;
468 coff_section_data (abfd, sec)->contents = NULL;
469 }
470 coff_section_data (abfd, sec)->relocs = free_internal;
471 }
472
473 return internal_relocs;
474
475 error_return:
476 if (free_external != NULL)
477 free (free_external);
478 if (free_internal != NULL)
479 free (free_internal);
480 return NULL;
481 }
482
483 /* Set lineno_count for the output sections of a COFF file. */
484
485 int
486 coff_count_linenumbers (bfd *abfd)
487 {
488 unsigned int limit = bfd_get_symcount (abfd);
489 unsigned int i;
490 int total = 0;
491 asymbol **p;
492 asection *s;
493
494 if (limit == 0)
495 {
496 /* This may be from the backend linker, in which case the
497 lineno_count in the sections is correct. */
498 for (s = abfd->sections; s != NULL; s = s->next)
499 total += s->lineno_count;
500 return total;
501 }
502
503 for (s = abfd->sections; s != NULL; s = s->next)
504 BFD_ASSERT (s->lineno_count == 0);
505
506 for (p = abfd->outsymbols, i = 0; i < limit; i++, p++)
507 {
508 asymbol *q_maybe = *p;
509
510 if (bfd_family_coff (bfd_asymbol_bfd (q_maybe)))
511 {
512 coff_symbol_type *q = coffsymbol (q_maybe);
513
514 /* The AIX 4.1 compiler can sometimes generate line numbers
515 attached to debugging symbols. We try to simply ignore
516 those here. */
517 if (q->lineno != NULL
518 && q->symbol.section->owner != NULL)
519 {
520 /* This symbol has line numbers. Increment the owning
521 section's linenumber count. */
522 alent *l = q->lineno;
523
524 do
525 {
526 asection * sec = q->symbol.section->output_section;
527
528 /* Do not try to update fields in read-only sections. */
529 if (! bfd_is_const_section (sec))
530 sec->lineno_count ++;
531
532 ++total;
533 ++l;
534 }
535 while (l->line_number != 0);
536 }
537 }
538 }
539
540 return total;
541 }
542
543 /* Takes a bfd and a symbol, returns a pointer to the coff specific
544 area of the symbol if there is one. */
545
546 coff_symbol_type *
547 coff_symbol_from (bfd *ignore_abfd ATTRIBUTE_UNUSED,
548 asymbol *symbol)
549 {
550 if (!bfd_family_coff (bfd_asymbol_bfd (symbol)))
551 return (coff_symbol_type *) NULL;
552
553 if (bfd_asymbol_bfd (symbol)->tdata.coff_obj_data == (coff_data_type *) NULL)
554 return (coff_symbol_type *) NULL;
555
556 return (coff_symbol_type *) symbol;
557 }
558
559 static void
560 fixup_symbol_value (bfd *abfd,
561 coff_symbol_type *coff_symbol_ptr,
562 struct internal_syment *syment)
563 {
564 /* Normalize the symbol flags. */
565 if (bfd_is_com_section (coff_symbol_ptr->symbol.section))
566 {
567 /* A common symbol is undefined with a value. */
568 syment->n_scnum = N_UNDEF;
569 syment->n_value = coff_symbol_ptr->symbol.value;
570 }
571 else if ((coff_symbol_ptr->symbol.flags & BSF_DEBUGGING) != 0
572 && (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING_RELOC) == 0)
573 {
574 syment->n_value = coff_symbol_ptr->symbol.value;
575 }
576 else if (bfd_is_und_section (coff_symbol_ptr->symbol.section))
577 {
578 syment->n_scnum = N_UNDEF;
579 syment->n_value = 0;
580 }
581 /* FIXME: Do we need to handle the absolute section here? */
582 else
583 {
584 if (coff_symbol_ptr->symbol.section)
585 {
586 syment->n_scnum =
587 coff_symbol_ptr->symbol.section->output_section->target_index;
588
589 syment->n_value = (coff_symbol_ptr->symbol.value
590 + coff_symbol_ptr->symbol.section->output_offset);
591 if (! obj_pe (abfd))
592 {
593 syment->n_value += (syment->n_sclass == C_STATLAB)
594 ? coff_symbol_ptr->symbol.section->output_section->lma
595 : coff_symbol_ptr->symbol.section->output_section->vma;
596 }
597 }
598 else
599 {
600 BFD_ASSERT (0);
601 /* This can happen, but I don't know why yet (steve@cygnus.com) */
602 syment->n_scnum = N_ABS;
603 syment->n_value = coff_symbol_ptr->symbol.value;
604 }
605 }
606 }
607
608 /* Run through all the symbols in the symbol table and work out what
609 their indexes into the symbol table will be when output.
610
611 Coff requires that each C_FILE symbol points to the next one in the
612 chain, and that the last one points to the first external symbol. We
613 do that here too. */
614
615 bfd_boolean
616 coff_renumber_symbols (bfd *bfd_ptr, int *first_undef)
617 {
618 unsigned int symbol_count = bfd_get_symcount (bfd_ptr);
619 asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
620 unsigned int native_index = 0;
621 struct internal_syment *last_file = NULL;
622 unsigned int symbol_index;
623
624 /* COFF demands that undefined symbols come after all other symbols.
625 Since we don't need to impose this extra knowledge on all our
626 client programs, deal with that here. Sort the symbol table;
627 just move the undefined symbols to the end, leaving the rest
628 alone. The O'Reilly book says that defined global symbols come
629 at the end before the undefined symbols, so we do that here as
630 well. */
631 /* @@ Do we have some condition we could test for, so we don't always
632 have to do this? I don't think relocatability is quite right, but
633 I'm not certain. [raeburn:19920508.1711EST] */
634 {
635 asymbol **newsyms;
636 unsigned int i;
637 bfd_size_type amt;
638
639 amt = sizeof (asymbol *) * ((bfd_size_type) symbol_count + 1);
640 newsyms = bfd_alloc (bfd_ptr, amt);
641 if (!newsyms)
642 return FALSE;
643 bfd_ptr->outsymbols = newsyms;
644 for (i = 0; i < symbol_count; i++)
645 if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) != 0
646 || (!bfd_is_und_section (symbol_ptr_ptr[i]->section)
647 && !bfd_is_com_section (symbol_ptr_ptr[i]->section)
648 && ((symbol_ptr_ptr[i]->flags & BSF_FUNCTION) != 0
649 || ((symbol_ptr_ptr[i]->flags & (BSF_GLOBAL | BSF_WEAK))
650 == 0))))
651 *newsyms++ = symbol_ptr_ptr[i];
652
653 for (i = 0; i < symbol_count; i++)
654 if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) == 0
655 && !bfd_is_und_section (symbol_ptr_ptr[i]->section)
656 && (bfd_is_com_section (symbol_ptr_ptr[i]->section)
657 || ((symbol_ptr_ptr[i]->flags & BSF_FUNCTION) == 0
658 && ((symbol_ptr_ptr[i]->flags & (BSF_GLOBAL | BSF_WEAK))
659 != 0))))
660 *newsyms++ = symbol_ptr_ptr[i];
661
662 *first_undef = newsyms - bfd_ptr->outsymbols;
663
664 for (i = 0; i < symbol_count; i++)
665 if ((symbol_ptr_ptr[i]->flags & BSF_NOT_AT_END) == 0
666 && bfd_is_und_section (symbol_ptr_ptr[i]->section))
667 *newsyms++ = symbol_ptr_ptr[i];
668 *newsyms = (asymbol *) NULL;
669 symbol_ptr_ptr = bfd_ptr->outsymbols;
670 }
671
672 for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
673 {
674 coff_symbol_type *coff_symbol_ptr = coff_symbol_from (bfd_ptr, symbol_ptr_ptr[symbol_index]);
675 symbol_ptr_ptr[symbol_index]->udata.i = symbol_index;
676 if (coff_symbol_ptr && coff_symbol_ptr->native)
677 {
678 combined_entry_type *s = coff_symbol_ptr->native;
679 int i;
680
681 if (s->u.syment.n_sclass == C_FILE)
682 {
683 if (last_file != NULL)
684 last_file->n_value = native_index;
685 last_file = &(s->u.syment);
686 }
687 else
688 /* Modify the symbol values according to their section and
689 type. */
690 fixup_symbol_value (bfd_ptr, coff_symbol_ptr, &(s->u.syment));
691
692 for (i = 0; i < s->u.syment.n_numaux + 1; i++)
693 s[i].offset = native_index++;
694 }
695 else
696 native_index++;
697 }
698
699 obj_conv_table_size (bfd_ptr) = native_index;
700
701 return TRUE;
702 }
703
704 /* Run thorough the symbol table again, and fix it so that all
705 pointers to entries are changed to the entries' index in the output
706 symbol table. */
707
708 void
709 coff_mangle_symbols (bfd *bfd_ptr)
710 {
711 unsigned int symbol_count = bfd_get_symcount (bfd_ptr);
712 asymbol **symbol_ptr_ptr = bfd_ptr->outsymbols;
713 unsigned int symbol_index;
714
715 for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
716 {
717 coff_symbol_type *coff_symbol_ptr =
718 coff_symbol_from (bfd_ptr, symbol_ptr_ptr[symbol_index]);
719
720 if (coff_symbol_ptr && coff_symbol_ptr->native)
721 {
722 int i;
723 combined_entry_type *s = coff_symbol_ptr->native;
724
725 if (s->fix_value)
726 {
727 /* FIXME: We should use a union here. */
728 s->u.syment.n_value =
729 (bfd_hostptr_t) ((combined_entry_type *)
730 ((bfd_hostptr_t) s->u.syment.n_value))->offset;
731 s->fix_value = 0;
732 }
733 if (s->fix_line)
734 {
735 /* The value is the offset into the line number entries
736 for the symbol's section. On output, the symbol's
737 section should be N_DEBUG. */
738 s->u.syment.n_value =
739 (coff_symbol_ptr->symbol.section->output_section->line_filepos
740 + s->u.syment.n_value * bfd_coff_linesz (bfd_ptr));
741 coff_symbol_ptr->symbol.section =
742 coff_section_from_bfd_index (bfd_ptr, N_DEBUG);
743 BFD_ASSERT (coff_symbol_ptr->symbol.flags & BSF_DEBUGGING);
744 }
745 for (i = 0; i < s->u.syment.n_numaux; i++)
746 {
747 combined_entry_type *a = s + i + 1;
748 if (a->fix_tag)
749 {
750 a->u.auxent.x_sym.x_tagndx.l =
751 a->u.auxent.x_sym.x_tagndx.p->offset;
752 a->fix_tag = 0;
753 }
754 if (a->fix_end)
755 {
756 a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l =
757 a->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p->offset;
758 a->fix_end = 0;
759 }
760 if (a->fix_scnlen)
761 {
762 a->u.auxent.x_csect.x_scnlen.l =
763 a->u.auxent.x_csect.x_scnlen.p->offset;
764 a->fix_scnlen = 0;
765 }
766 }
767 }
768 }
769 }
770
771 static void
772 coff_fix_symbol_name (bfd *abfd,
773 asymbol *symbol,
774 combined_entry_type *native,
775 bfd_size_type *string_size_p,
776 asection **debug_string_section_p,
777 bfd_size_type *debug_string_size_p)
778 {
779 unsigned int name_length;
780 union internal_auxent *auxent;
781 char *name = (char *) (symbol->name);
782
783 if (name == NULL)
784 {
785 /* COFF symbols always have names, so we'll make one up. */
786 symbol->name = "strange";
787 name = (char *) symbol->name;
788 }
789 name_length = strlen (name);
790
791 if (native->u.syment.n_sclass == C_FILE
792 && native->u.syment.n_numaux > 0)
793 {
794 unsigned int filnmlen;
795
796 if (bfd_coff_force_symnames_in_strings (abfd))
797 {
798 native->u.syment._n._n_n._n_offset =
799 (*string_size_p + STRING_SIZE_SIZE);
800 native->u.syment._n._n_n._n_zeroes = 0;
801 *string_size_p += 6; /* strlen(".file") + 1 */
802 }
803 else
804 strncpy (native->u.syment._n._n_name, ".file", SYMNMLEN);
805
806 auxent = &(native + 1)->u.auxent;
807
808 filnmlen = bfd_coff_filnmlen (abfd);
809
810 if (bfd_coff_long_filenames (abfd))
811 {
812 if (name_length <= filnmlen)
813 strncpy (auxent->x_file.x_fname, name, filnmlen);
814 else
815 {
816 auxent->x_file.x_n.x_offset = *string_size_p + STRING_SIZE_SIZE;
817 auxent->x_file.x_n.x_zeroes = 0;
818 *string_size_p += name_length + 1;
819 }
820 }
821 else
822 {
823 strncpy (auxent->x_file.x_fname, name, filnmlen);
824 if (name_length > filnmlen)
825 name[filnmlen] = '\0';
826 }
827 }
828 else
829 {
830 if (name_length <= SYMNMLEN && !bfd_coff_force_symnames_in_strings (abfd))
831 /* This name will fit into the symbol neatly. */
832 strncpy (native->u.syment._n._n_name, symbol->name, SYMNMLEN);
833
834 else if (!bfd_coff_symname_in_debug (abfd, &native->u.syment))
835 {
836 native->u.syment._n._n_n._n_offset = (*string_size_p
837 + STRING_SIZE_SIZE);
838 native->u.syment._n._n_n._n_zeroes = 0;
839 *string_size_p += name_length + 1;
840 }
841 else
842 {
843 file_ptr filepos;
844 bfd_byte buf[4];
845 int prefix_len = bfd_coff_debug_string_prefix_length (abfd);
846
847 /* This name should be written into the .debug section. For
848 some reason each name is preceded by a two byte length
849 and also followed by a null byte. FIXME: We assume that
850 the .debug section has already been created, and that it
851 is large enough. */
852 if (*debug_string_section_p == (asection *) NULL)
853 *debug_string_section_p = bfd_get_section_by_name (abfd, ".debug");
854 filepos = bfd_tell (abfd);
855 if (prefix_len == 4)
856 bfd_put_32 (abfd, (bfd_vma) (name_length + 1), buf);
857 else
858 bfd_put_16 (abfd, (bfd_vma) (name_length + 1), buf);
859
860 if (!bfd_set_section_contents (abfd,
861 *debug_string_section_p,
862 (void *) buf,
863 (file_ptr) *debug_string_size_p,
864 (bfd_size_type) prefix_len)
865 || !bfd_set_section_contents (abfd,
866 *debug_string_section_p,
867 (void *) symbol->name,
868 (file_ptr) (*debug_string_size_p
869 + prefix_len),
870 (bfd_size_type) name_length + 1))
871 abort ();
872 if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
873 abort ();
874 native->u.syment._n._n_n._n_offset =
875 *debug_string_size_p + prefix_len;
876 native->u.syment._n._n_n._n_zeroes = 0;
877 *debug_string_size_p += name_length + 1 + prefix_len;
878 }
879 }
880 }
881
882 /* We need to keep track of the symbol index so that when we write out
883 the relocs we can get the index for a symbol. This method is a
884 hack. FIXME. */
885
886 #define set_index(symbol, idx) ((symbol)->udata.i = (idx))
887
888 /* Write a symbol out to a COFF file. */
889
890 static bfd_boolean
891 coff_write_symbol (bfd *abfd,
892 asymbol *symbol,
893 combined_entry_type *native,
894 bfd_vma *written,
895 bfd_size_type *string_size_p,
896 asection **debug_string_section_p,
897 bfd_size_type *debug_string_size_p)
898 {
899 unsigned int numaux = native->u.syment.n_numaux;
900 int type = native->u.syment.n_type;
901 int class = native->u.syment.n_sclass;
902 void * buf;
903 bfd_size_type symesz;
904
905 if (native->u.syment.n_sclass == C_FILE)
906 symbol->flags |= BSF_DEBUGGING;
907
908 if (symbol->flags & BSF_DEBUGGING
909 && bfd_is_abs_section (symbol->section))
910 native->u.syment.n_scnum = N_DEBUG;
911
912 else if (bfd_is_abs_section (symbol->section))
913 native->u.syment.n_scnum = N_ABS;
914
915 else if (bfd_is_und_section (symbol->section))
916 native->u.syment.n_scnum = N_UNDEF;
917
918 else
919 native->u.syment.n_scnum =
920 symbol->section->output_section->target_index;
921
922 coff_fix_symbol_name (abfd, symbol, native, string_size_p,
923 debug_string_section_p, debug_string_size_p);
924
925 symesz = bfd_coff_symesz (abfd);
926 buf = bfd_alloc (abfd, symesz);
927 if (!buf)
928 return FALSE;
929 bfd_coff_swap_sym_out (abfd, &native->u.syment, buf);
930 if (bfd_bwrite (buf, symesz, abfd) != symesz)
931 return FALSE;
932 bfd_release (abfd, buf);
933
934 if (native->u.syment.n_numaux > 0)
935 {
936 bfd_size_type auxesz;
937 unsigned int j;
938
939 auxesz = bfd_coff_auxesz (abfd);
940 buf = bfd_alloc (abfd, auxesz);
941 if (!buf)
942 return FALSE;
943 for (j = 0; j < native->u.syment.n_numaux; j++)
944 {
945 bfd_coff_swap_aux_out (abfd,
946 &((native + j + 1)->u.auxent),
947 type, class, (int) j,
948 native->u.syment.n_numaux,
949 buf);
950 if (bfd_bwrite (buf, auxesz, abfd) != auxesz)
951 return FALSE;
952 }
953 bfd_release (abfd, buf);
954 }
955
956 /* Store the index for use when we write out the relocs. */
957 set_index (symbol, *written);
958
959 *written += numaux + 1;
960 return TRUE;
961 }
962
963 /* Write out a symbol to a COFF file that does not come from a COFF
964 file originally. This symbol may have been created by the linker,
965 or we may be linking a non COFF file to a COFF file. */
966
967 static bfd_boolean
968 coff_write_alien_symbol (bfd *abfd,
969 asymbol *symbol,
970 bfd_vma *written,
971 bfd_size_type *string_size_p,
972 asection **debug_string_section_p,
973 bfd_size_type *debug_string_size_p)
974 {
975 combined_entry_type *native;
976 combined_entry_type dummy;
977
978 native = &dummy;
979 native->u.syment.n_type = T_NULL;
980 native->u.syment.n_flags = 0;
981 if (bfd_is_und_section (symbol->section))
982 {
983 native->u.syment.n_scnum = N_UNDEF;
984 native->u.syment.n_value = symbol->value;
985 }
986 else if (bfd_is_com_section (symbol->section))
987 {
988 native->u.syment.n_scnum = N_UNDEF;
989 native->u.syment.n_value = symbol->value;
990 }
991 else if (symbol->flags & BSF_DEBUGGING)
992 {
993 /* There isn't much point to writing out a debugging symbol
994 unless we are prepared to convert it into COFF debugging
995 format. So, we just ignore them. We must clobber the symbol
996 name to keep it from being put in the string table. */
997 symbol->name = "";
998 return TRUE;
999 }
1000 else
1001 {
1002 native->u.syment.n_scnum =
1003 symbol->section->output_section->target_index;
1004 native->u.syment.n_value = (symbol->value
1005 + symbol->section->output_offset);
1006 if (! obj_pe (abfd))
1007 native->u.syment.n_value += symbol->section->output_section->vma;
1008
1009 /* Copy the any flags from the file header into the symbol.
1010 FIXME: Why? */
1011 {
1012 coff_symbol_type *c = coff_symbol_from (abfd, symbol);
1013 if (c != (coff_symbol_type *) NULL)
1014 native->u.syment.n_flags = bfd_asymbol_bfd (&c->symbol)->flags;
1015 }
1016 }
1017
1018 native->u.syment.n_type = 0;
1019 if (symbol->flags & BSF_LOCAL)
1020 native->u.syment.n_sclass = C_STAT;
1021 else if (symbol->flags & BSF_WEAK)
1022 native->u.syment.n_sclass = obj_pe (abfd) ? C_NT_WEAK : C_WEAKEXT;
1023 else
1024 native->u.syment.n_sclass = C_EXT;
1025 native->u.syment.n_numaux = 0;
1026
1027 return coff_write_symbol (abfd, symbol, native, written, string_size_p,
1028 debug_string_section_p, debug_string_size_p);
1029 }
1030
1031 /* Write a native symbol to a COFF file. */
1032
1033 static bfd_boolean
1034 coff_write_native_symbol (bfd *abfd,
1035 coff_symbol_type *symbol,
1036 bfd_vma *written,
1037 bfd_size_type *string_size_p,
1038 asection **debug_string_section_p,
1039 bfd_size_type *debug_string_size_p)
1040 {
1041 combined_entry_type *native = symbol->native;
1042 alent *lineno = symbol->lineno;
1043
1044 /* If this symbol has an associated line number, we must store the
1045 symbol index in the line number field. We also tag the auxent to
1046 point to the right place in the lineno table. */
1047 if (lineno && !symbol->done_lineno && symbol->symbol.section->owner != NULL)
1048 {
1049 unsigned int count = 0;
1050
1051 lineno[count].u.offset = *written;
1052 if (native->u.syment.n_numaux)
1053 {
1054 union internal_auxent *a = &((native + 1)->u.auxent);
1055
1056 a->x_sym.x_fcnary.x_fcn.x_lnnoptr =
1057 symbol->symbol.section->output_section->moving_line_filepos;
1058 }
1059
1060 /* Count and relocate all other linenumbers. */
1061 count++;
1062 while (lineno[count].line_number != 0)
1063 {
1064 lineno[count].u.offset +=
1065 (symbol->symbol.section->output_section->vma
1066 + symbol->symbol.section->output_offset);
1067 count++;
1068 }
1069 symbol->done_lineno = TRUE;
1070
1071 if (! bfd_is_const_section (symbol->symbol.section->output_section))
1072 symbol->symbol.section->output_section->moving_line_filepos +=
1073 count * bfd_coff_linesz (abfd);
1074 }
1075
1076 return coff_write_symbol (abfd, &(symbol->symbol), native, written,
1077 string_size_p, debug_string_section_p,
1078 debug_string_size_p);
1079 }
1080
1081 /* Write out the COFF symbols. */
1082
1083 bfd_boolean
1084 coff_write_symbols (bfd *abfd)
1085 {
1086 bfd_size_type string_size;
1087 asection *debug_string_section;
1088 bfd_size_type debug_string_size;
1089 unsigned int i;
1090 unsigned int limit = bfd_get_symcount (abfd);
1091 bfd_vma written = 0;
1092 asymbol **p;
1093
1094 string_size = 0;
1095 debug_string_section = NULL;
1096 debug_string_size = 0;
1097
1098 /* If this target supports long section names, they must be put into
1099 the string table. This is supported by PE. This code must
1100 handle section names just as they are handled in
1101 coff_write_object_contents. */
1102 if (bfd_coff_long_section_names (abfd))
1103 {
1104 asection *o;
1105
1106 for (o = abfd->sections; o != NULL; o = o->next)
1107 {
1108 size_t len;
1109
1110 len = strlen (o->name);
1111 if (len > SCNNMLEN)
1112 string_size += len + 1;
1113 }
1114 }
1115
1116 /* Seek to the right place. */
1117 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0)
1118 return FALSE;
1119
1120 /* Output all the symbols we have. */
1121 written = 0;
1122 for (p = abfd->outsymbols, i = 0; i < limit; i++, p++)
1123 {
1124 asymbol *symbol = *p;
1125 coff_symbol_type *c_symbol = coff_symbol_from (abfd, symbol);
1126
1127 if (c_symbol == (coff_symbol_type *) NULL
1128 || c_symbol->native == (combined_entry_type *) NULL)
1129 {
1130 if (!coff_write_alien_symbol (abfd, symbol, &written, &string_size,
1131 &debug_string_section,
1132 &debug_string_size))
1133 return FALSE;
1134 }
1135 else
1136 {
1137 if (!coff_write_native_symbol (abfd, c_symbol, &written,
1138 &string_size, &debug_string_section,
1139 &debug_string_size))
1140 return FALSE;
1141 }
1142 }
1143
1144 obj_raw_syment_count (abfd) = written;
1145
1146 /* Now write out strings. */
1147 if (string_size != 0)
1148 {
1149 unsigned int size = string_size + STRING_SIZE_SIZE;
1150 bfd_byte buffer[STRING_SIZE_SIZE];
1151
1152 #if STRING_SIZE_SIZE == 4
1153 H_PUT_32 (abfd, size, buffer);
1154 #else
1155 #error Change H_PUT_32
1156 #endif
1157 if (bfd_bwrite ((void *) buffer, (bfd_size_type) sizeof (buffer), abfd)
1158 != sizeof (buffer))
1159 return FALSE;
1160
1161 /* Handle long section names. This code must handle section
1162 names just as they are handled in coff_write_object_contents. */
1163 if (bfd_coff_long_section_names (abfd))
1164 {
1165 asection *o;
1166
1167 for (o = abfd->sections; o != NULL; o = o->next)
1168 {
1169 size_t len;
1170
1171 len = strlen (o->name);
1172 if (len > SCNNMLEN)
1173 {
1174 if (bfd_bwrite (o->name, (bfd_size_type) (len + 1), abfd)
1175 != len + 1)
1176 return FALSE;
1177 }
1178 }
1179 }
1180
1181 for (p = abfd->outsymbols, i = 0;
1182 i < limit;
1183 i++, p++)
1184 {
1185 asymbol *q = *p;
1186 size_t name_length = strlen (q->name);
1187 coff_symbol_type *c_symbol = coff_symbol_from (abfd, q);
1188 size_t maxlen;
1189
1190 /* Figure out whether the symbol name should go in the string
1191 table. Symbol names that are short enough are stored
1192 directly in the syment structure. File names permit a
1193 different, longer, length in the syment structure. On
1194 XCOFF, some symbol names are stored in the .debug section
1195 rather than in the string table. */
1196
1197 if (c_symbol == NULL
1198 || c_symbol->native == NULL)
1199 /* This is not a COFF symbol, so it certainly is not a
1200 file name, nor does it go in the .debug section. */
1201 maxlen = bfd_coff_force_symnames_in_strings (abfd) ? 0 : SYMNMLEN;
1202
1203 else if (bfd_coff_symname_in_debug (abfd,
1204 &c_symbol->native->u.syment))
1205 /* This symbol name is in the XCOFF .debug section.
1206 Don't write it into the string table. */
1207 maxlen = name_length;
1208
1209 else if (c_symbol->native->u.syment.n_sclass == C_FILE
1210 && c_symbol->native->u.syment.n_numaux > 0)
1211 {
1212 if (bfd_coff_force_symnames_in_strings (abfd))
1213 {
1214 if (bfd_bwrite (".file", (bfd_size_type) 6, abfd) != 6)
1215 return FALSE;
1216 }
1217 maxlen = bfd_coff_filnmlen (abfd);
1218 }
1219 else
1220 maxlen = bfd_coff_force_symnames_in_strings (abfd) ? 0 : SYMNMLEN;
1221
1222 if (name_length > maxlen)
1223 {
1224 if (bfd_bwrite ((void *) (q->name), (bfd_size_type) name_length + 1,
1225 abfd) != name_length + 1)
1226 return FALSE;
1227 }
1228 }
1229 }
1230 else
1231 {
1232 /* We would normally not write anything here, but we'll write
1233 out 4 so that any stupid coff reader which tries to read the
1234 string table even when there isn't one won't croak. */
1235 unsigned int size = STRING_SIZE_SIZE;
1236 bfd_byte buffer[STRING_SIZE_SIZE];
1237
1238 #if STRING_SIZE_SIZE == 4
1239 H_PUT_32 (abfd, size, buffer);
1240 #else
1241 #error Change H_PUT_32
1242 #endif
1243 if (bfd_bwrite ((void *) buffer, (bfd_size_type) STRING_SIZE_SIZE, abfd)
1244 != STRING_SIZE_SIZE)
1245 return FALSE;
1246 }
1247
1248 /* Make sure the .debug section was created to be the correct size.
1249 We should create it ourselves on the fly, but we don't because
1250 BFD won't let us write to any section until we know how large all
1251 the sections are. We could still do it by making another pass
1252 over the symbols. FIXME. */
1253 BFD_ASSERT (debug_string_size == 0
1254 || (debug_string_section != (asection *) NULL
1255 && (BFD_ALIGN (debug_string_size,
1256 1 << debug_string_section->alignment_power)
1257 == debug_string_section->size)));
1258
1259 return TRUE;
1260 }
1261
1262 bfd_boolean
1263 coff_write_linenumbers (bfd *abfd)
1264 {
1265 asection *s;
1266 bfd_size_type linesz;
1267 void * buff;
1268
1269 linesz = bfd_coff_linesz (abfd);
1270 buff = bfd_alloc (abfd, linesz);
1271 if (!buff)
1272 return FALSE;
1273 for (s = abfd->sections; s != (asection *) NULL; s = s->next)
1274 {
1275 if (s->lineno_count)
1276 {
1277 asymbol **q = abfd->outsymbols;
1278 if (bfd_seek (abfd, s->line_filepos, SEEK_SET) != 0)
1279 return FALSE;
1280 /* Find all the linenumbers in this section. */
1281 while (*q)
1282 {
1283 asymbol *p = *q;
1284 if (p->section->output_section == s)
1285 {
1286 alent *l =
1287 BFD_SEND (bfd_asymbol_bfd (p), _get_lineno,
1288 (bfd_asymbol_bfd (p), p));
1289 if (l)
1290 {
1291 /* Found a linenumber entry, output. */
1292 struct internal_lineno out;
1293 memset ((void *) & out, 0, sizeof (out));
1294 out.l_lnno = 0;
1295 out.l_addr.l_symndx = l->u.offset;
1296 bfd_coff_swap_lineno_out (abfd, &out, buff);
1297 if (bfd_bwrite (buff, (bfd_size_type) linesz, abfd)
1298 != linesz)
1299 return FALSE;
1300 l++;
1301 while (l->line_number)
1302 {
1303 out.l_lnno = l->line_number;
1304 out.l_addr.l_symndx = l->u.offset;
1305 bfd_coff_swap_lineno_out (abfd, &out, buff);
1306 if (bfd_bwrite (buff, (bfd_size_type) linesz, abfd)
1307 != linesz)
1308 return FALSE;
1309 l++;
1310 }
1311 }
1312 }
1313 q++;
1314 }
1315 }
1316 }
1317 bfd_release (abfd, buff);
1318 return TRUE;
1319 }
1320
1321 alent *
1322 coff_get_lineno (bfd *ignore_abfd ATTRIBUTE_UNUSED, asymbol *symbol)
1323 {
1324 return coffsymbol (symbol)->lineno;
1325 }
1326
1327 /* This function transforms the offsets into the symbol table into
1328 pointers to syments. */
1329
1330 static void
1331 coff_pointerize_aux (bfd *abfd,
1332 combined_entry_type *table_base,
1333 combined_entry_type *symbol,
1334 unsigned int indaux,
1335 combined_entry_type *auxent)
1336 {
1337 unsigned int type = symbol->u.syment.n_type;
1338 unsigned int class = symbol->u.syment.n_sclass;
1339
1340 if (coff_backend_info (abfd)->_bfd_coff_pointerize_aux_hook)
1341 {
1342 if ((*coff_backend_info (abfd)->_bfd_coff_pointerize_aux_hook)
1343 (abfd, table_base, symbol, indaux, auxent))
1344 return;
1345 }
1346
1347 /* Don't bother if this is a file or a section. */
1348 if (class == C_STAT && type == T_NULL)
1349 return;
1350 if (class == C_FILE)
1351 return;
1352
1353 /* Otherwise patch up. */
1354 #define N_TMASK coff_data (abfd)->local_n_tmask
1355 #define N_BTSHFT coff_data (abfd)->local_n_btshft
1356
1357 if ((ISFCN (type) || ISTAG (class) || class == C_BLOCK || class == C_FCN)
1358 && auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l > 0)
1359 {
1360 auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p =
1361 table_base + auxent->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l;
1362 auxent->fix_end = 1;
1363 }
1364 /* A negative tagndx is meaningless, but the SCO 3.2v4 cc can
1365 generate one, so we must be careful to ignore it. */
1366 if (auxent->u.auxent.x_sym.x_tagndx.l > 0)
1367 {
1368 auxent->u.auxent.x_sym.x_tagndx.p =
1369 table_base + auxent->u.auxent.x_sym.x_tagndx.l;
1370 auxent->fix_tag = 1;
1371 }
1372 }
1373
1374 /* Allocate space for the ".debug" section, and read it.
1375 We did not read the debug section until now, because
1376 we didn't want to go to the trouble until someone needed it. */
1377
1378 static char *
1379 build_debug_section (bfd *abfd)
1380 {
1381 char *debug_section;
1382 file_ptr position;
1383 bfd_size_type sec_size;
1384
1385 asection *sect = bfd_get_section_by_name (abfd, ".debug");
1386
1387 if (!sect)
1388 {
1389 bfd_set_error (bfd_error_no_debug_section);
1390 return NULL;
1391 }
1392
1393 sec_size = sect->size;
1394 debug_section = bfd_alloc (abfd, sec_size);
1395 if (debug_section == NULL)
1396 return NULL;
1397
1398 /* Seek to the beginning of the `.debug' section and read it.
1399 Save the current position first; it is needed by our caller.
1400 Then read debug section and reset the file pointer. */
1401
1402 position = bfd_tell (abfd);
1403 if (bfd_seek (abfd, sect->filepos, SEEK_SET) != 0
1404 || bfd_bread (debug_section, sec_size, abfd) != sec_size
1405 || bfd_seek (abfd, position, SEEK_SET) != 0)
1406 return NULL;
1407 return debug_section;
1408 }
1409
1410 /* Return a pointer to a malloc'd copy of 'name'. 'name' may not be
1411 \0-terminated, but will not exceed 'maxlen' characters. The copy *will*
1412 be \0-terminated. */
1413
1414 static char *
1415 copy_name (bfd *abfd, char *name, size_t maxlen)
1416 {
1417 size_t len;
1418 char *newname;
1419
1420 for (len = 0; len < maxlen; ++len)
1421 if (name[len] == '\0')
1422 break;
1423
1424 if ((newname = bfd_alloc (abfd, (bfd_size_type) len + 1)) == NULL)
1425 return NULL;
1426
1427 strncpy (newname, name, len);
1428 newname[len] = '\0';
1429 return newname;
1430 }
1431
1432 /* Read in the external symbols. */
1433
1434 bfd_boolean
1435 _bfd_coff_get_external_symbols (bfd *abfd)
1436 {
1437 bfd_size_type symesz;
1438 bfd_size_type size;
1439 void * syms;
1440
1441 if (obj_coff_external_syms (abfd) != NULL)
1442 return TRUE;
1443
1444 symesz = bfd_coff_symesz (abfd);
1445
1446 size = obj_raw_syment_count (abfd) * symesz;
1447 if (size == 0)
1448 return TRUE;
1449
1450 syms = bfd_malloc (size);
1451 if (syms == NULL)
1452 return FALSE;
1453
1454 if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
1455 || bfd_bread (syms, size, abfd) != size)
1456 {
1457 if (syms != NULL)
1458 free (syms);
1459 return FALSE;
1460 }
1461
1462 obj_coff_external_syms (abfd) = syms;
1463
1464 return TRUE;
1465 }
1466
1467 /* Read in the external strings. The strings are not loaded until
1468 they are needed. This is because we have no simple way of
1469 detecting a missing string table in an archive. */
1470
1471 const char *
1472 _bfd_coff_read_string_table (bfd *abfd)
1473 {
1474 char extstrsize[STRING_SIZE_SIZE];
1475 bfd_size_type strsize;
1476 char *strings;
1477 file_ptr pos;
1478
1479 if (obj_coff_strings (abfd) != NULL)
1480 return obj_coff_strings (abfd);
1481
1482 if (obj_sym_filepos (abfd) == 0)
1483 {
1484 bfd_set_error (bfd_error_no_symbols);
1485 return NULL;
1486 }
1487
1488 pos = obj_sym_filepos (abfd);
1489 pos += obj_raw_syment_count (abfd) * bfd_coff_symesz (abfd);
1490 if (bfd_seek (abfd, pos, SEEK_SET) != 0)
1491 return NULL;
1492
1493 if (bfd_bread (extstrsize, (bfd_size_type) sizeof extstrsize, abfd)
1494 != sizeof extstrsize)
1495 {
1496 if (bfd_get_error () != bfd_error_file_truncated)
1497 return NULL;
1498
1499 /* There is no string table. */
1500 strsize = STRING_SIZE_SIZE;
1501 }
1502 else
1503 {
1504 #if STRING_SIZE_SIZE == 4
1505 strsize = H_GET_32 (abfd, extstrsize);
1506 #else
1507 #error Change H_GET_32
1508 #endif
1509 }
1510
1511 if (strsize < STRING_SIZE_SIZE)
1512 {
1513 (*_bfd_error_handler)
1514 (_("%B: bad string table size %lu"), abfd, (unsigned long) strsize);
1515 bfd_set_error (bfd_error_bad_value);
1516 return NULL;
1517 }
1518
1519 strings = bfd_malloc (strsize);
1520 if (strings == NULL)
1521 return NULL;
1522
1523 if (bfd_bread (strings + STRING_SIZE_SIZE, strsize - STRING_SIZE_SIZE, abfd)
1524 != strsize - STRING_SIZE_SIZE)
1525 {
1526 free (strings);
1527 return NULL;
1528 }
1529
1530 obj_coff_strings (abfd) = strings;
1531
1532 return strings;
1533 }
1534
1535 /* Free up the external symbols and strings read from a COFF file. */
1536
1537 bfd_boolean
1538 _bfd_coff_free_symbols (bfd *abfd)
1539 {
1540 if (obj_coff_external_syms (abfd) != NULL
1541 && ! obj_coff_keep_syms (abfd))
1542 {
1543 free (obj_coff_external_syms (abfd));
1544 obj_coff_external_syms (abfd) = NULL;
1545 }
1546 if (obj_coff_strings (abfd) != NULL
1547 && ! obj_coff_keep_strings (abfd))
1548 {
1549 free (obj_coff_strings (abfd));
1550 obj_coff_strings (abfd) = NULL;
1551 }
1552 return TRUE;
1553 }
1554
1555 /* Read a symbol table into freshly bfd_allocated memory, swap it, and
1556 knit the symbol names into a normalized form. By normalized here I
1557 mean that all symbols have an n_offset pointer that points to a null-
1558 terminated string. */
1559
1560 combined_entry_type *
1561 coff_get_normalized_symtab (bfd *abfd)
1562 {
1563 combined_entry_type *internal;
1564 combined_entry_type *internal_ptr;
1565 combined_entry_type *symbol_ptr;
1566 combined_entry_type *internal_end;
1567 size_t symesz;
1568 char *raw_src;
1569 char *raw_end;
1570 const char *string_table = NULL;
1571 char *debug_section = NULL;
1572 bfd_size_type size;
1573
1574 if (obj_raw_syments (abfd) != NULL)
1575 return obj_raw_syments (abfd);
1576
1577 size = obj_raw_syment_count (abfd) * sizeof (combined_entry_type);
1578 internal = bfd_zalloc (abfd, size);
1579 if (internal == NULL && size != 0)
1580 return NULL;
1581 internal_end = internal + obj_raw_syment_count (abfd);
1582
1583 if (! _bfd_coff_get_external_symbols (abfd))
1584 return NULL;
1585
1586 raw_src = (char *) obj_coff_external_syms (abfd);
1587
1588 /* Mark the end of the symbols. */
1589 symesz = bfd_coff_symesz (abfd);
1590 raw_end = (char *) raw_src + obj_raw_syment_count (abfd) * symesz;
1591
1592 /* FIXME SOMEDAY. A string table size of zero is very weird, but
1593 probably possible. If one shows up, it will probably kill us. */
1594
1595 /* Swap all the raw entries. */
1596 for (internal_ptr = internal;
1597 raw_src < raw_end;
1598 raw_src += symesz, internal_ptr++)
1599 {
1600
1601 unsigned int i;
1602 bfd_coff_swap_sym_in (abfd, (void *) raw_src,
1603 (void *) & internal_ptr->u.syment);
1604 symbol_ptr = internal_ptr;
1605
1606 for (i = 0;
1607 i < symbol_ptr->u.syment.n_numaux;
1608 i++)
1609 {
1610 internal_ptr++;
1611 raw_src += symesz;
1612 bfd_coff_swap_aux_in (abfd, (void *) raw_src,
1613 symbol_ptr->u.syment.n_type,
1614 symbol_ptr->u.syment.n_sclass,
1615 (int) i, symbol_ptr->u.syment.n_numaux,
1616 &(internal_ptr->u.auxent));
1617 coff_pointerize_aux (abfd, internal, symbol_ptr, i,
1618 internal_ptr);
1619 }
1620 }
1621
1622 /* Free the raw symbols, but not the strings (if we have them). */
1623 obj_coff_keep_strings (abfd) = TRUE;
1624 if (! _bfd_coff_free_symbols (abfd))
1625 return NULL;
1626
1627 for (internal_ptr = internal; internal_ptr < internal_end;
1628 internal_ptr++)
1629 {
1630 if (internal_ptr->u.syment.n_sclass == C_FILE
1631 && internal_ptr->u.syment.n_numaux > 0)
1632 {
1633 /* Make a file symbol point to the name in the auxent, since
1634 the text ".file" is redundant. */
1635 if ((internal_ptr + 1)->u.auxent.x_file.x_n.x_zeroes == 0)
1636 {
1637 /* The filename is a long one, point into the string table. */
1638 if (string_table == NULL)
1639 {
1640 string_table = _bfd_coff_read_string_table (abfd);
1641 if (string_table == NULL)
1642 return NULL;
1643 }
1644
1645 internal_ptr->u.syment._n._n_n._n_offset =
1646 ((bfd_hostptr_t)
1647 (string_table
1648 + (internal_ptr + 1)->u.auxent.x_file.x_n.x_offset));
1649 }
1650 else
1651 {
1652 /* Ordinary short filename, put into memory anyway. The
1653 Microsoft PE tools sometimes store a filename in
1654 multiple AUX entries. */
1655 if (internal_ptr->u.syment.n_numaux > 1
1656 && coff_data (abfd)->pe)
1657 internal_ptr->u.syment._n._n_n._n_offset =
1658 ((bfd_hostptr_t)
1659 copy_name (abfd,
1660 (internal_ptr + 1)->u.auxent.x_file.x_fname,
1661 internal_ptr->u.syment.n_numaux * symesz));
1662 else
1663 internal_ptr->u.syment._n._n_n._n_offset =
1664 ((bfd_hostptr_t)
1665 copy_name (abfd,
1666 (internal_ptr + 1)->u.auxent.x_file.x_fname,
1667 (size_t) bfd_coff_filnmlen (abfd)));
1668 }
1669 }
1670 else
1671 {
1672 if (internal_ptr->u.syment._n._n_n._n_zeroes != 0)
1673 {
1674 /* This is a "short" name. Make it long. */
1675 size_t i;
1676 char *newstring;
1677
1678 /* Find the length of this string without walking into memory
1679 that isn't ours. */
1680 for (i = 0; i < 8; ++i)
1681 if (internal_ptr->u.syment._n._n_name[i] == '\0')
1682 break;
1683
1684 newstring = bfd_zalloc (abfd, (bfd_size_type) (i + 1));
1685 if (newstring == NULL)
1686 return NULL;
1687 strncpy (newstring, internal_ptr->u.syment._n._n_name, i);
1688 internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t) newstring;
1689 internal_ptr->u.syment._n._n_n._n_zeroes = 0;
1690 }
1691 else if (internal_ptr->u.syment._n._n_n._n_offset == 0)
1692 internal_ptr->u.syment._n._n_n._n_offset = (bfd_vma) "";
1693 else if (!bfd_coff_symname_in_debug (abfd, &internal_ptr->u.syment))
1694 {
1695 /* Long name already. Point symbol at the string in the
1696 table. */
1697 if (string_table == NULL)
1698 {
1699 string_table = _bfd_coff_read_string_table (abfd);
1700 if (string_table == NULL)
1701 return NULL;
1702 }
1703 internal_ptr->u.syment._n._n_n._n_offset =
1704 ((bfd_hostptr_t)
1705 (string_table
1706 + internal_ptr->u.syment._n._n_n._n_offset));
1707 }
1708 else
1709 {
1710 /* Long name in debug section. Very similar. */
1711 if (debug_section == NULL)
1712 debug_section = build_debug_section (abfd);
1713 internal_ptr->u.syment._n._n_n._n_offset = (bfd_hostptr_t)
1714 (debug_section + internal_ptr->u.syment._n._n_n._n_offset);
1715 }
1716 }
1717 internal_ptr += internal_ptr->u.syment.n_numaux;
1718 }
1719
1720 obj_raw_syments (abfd) = internal;
1721 BFD_ASSERT (obj_raw_syment_count (abfd)
1722 == (unsigned int) (internal_ptr - internal));
1723
1724 return internal;
1725 }
1726
1727 long
1728 coff_get_reloc_upper_bound (bfd *abfd, sec_ptr asect)
1729 {
1730 if (bfd_get_format (abfd) != bfd_object)
1731 {
1732 bfd_set_error (bfd_error_invalid_operation);
1733 return -1;
1734 }
1735 return (asect->reloc_count + 1) * sizeof (arelent *);
1736 }
1737
1738 asymbol *
1739 coff_make_empty_symbol (bfd *abfd)
1740 {
1741 bfd_size_type amt = sizeof (coff_symbol_type);
1742 coff_symbol_type *new = bfd_zalloc (abfd, amt);
1743
1744 if (new == NULL)
1745 return NULL;
1746 new->symbol.section = 0;
1747 new->native = 0;
1748 new->lineno = NULL;
1749 new->done_lineno = FALSE;
1750 new->symbol.the_bfd = abfd;
1751
1752 return & new->symbol;
1753 }
1754
1755 /* Make a debugging symbol. */
1756
1757 asymbol *
1758 coff_bfd_make_debug_symbol (bfd *abfd,
1759 void * ptr ATTRIBUTE_UNUSED,
1760 unsigned long sz ATTRIBUTE_UNUSED)
1761 {
1762 bfd_size_type amt = sizeof (coff_symbol_type);
1763 coff_symbol_type *new = bfd_alloc (abfd, amt);
1764
1765 if (new == NULL)
1766 return NULL;
1767 /* @@ The 10 is a guess at a plausible maximum number of aux entries
1768 (but shouldn't be a constant). */
1769 amt = sizeof (combined_entry_type) * 10;
1770 new->native = bfd_zalloc (abfd, amt);
1771 if (!new->native)
1772 return NULL;
1773 new->symbol.section = bfd_abs_section_ptr;
1774 new->symbol.flags = BSF_DEBUGGING;
1775 new->lineno = NULL;
1776 new->done_lineno = FALSE;
1777 new->symbol.the_bfd = abfd;
1778
1779 return & new->symbol;
1780 }
1781
1782 void
1783 coff_get_symbol_info (bfd *abfd, asymbol *symbol, symbol_info *ret)
1784 {
1785 bfd_symbol_info (symbol, ret);
1786
1787 if (coffsymbol (symbol)->native != NULL
1788 && coffsymbol (symbol)->native->fix_value)
1789 ret->value = coffsymbol (symbol)->native->u.syment.n_value -
1790 (bfd_hostptr_t) obj_raw_syments (abfd);
1791 }
1792
1793 /* Return the COFF syment for a symbol. */
1794
1795 bfd_boolean
1796 bfd_coff_get_syment (bfd *abfd,
1797 asymbol *symbol,
1798 struct internal_syment *psyment)
1799 {
1800 coff_symbol_type *csym;
1801
1802 csym = coff_symbol_from (abfd, symbol);
1803 if (csym == NULL || csym->native == NULL)
1804 {
1805 bfd_set_error (bfd_error_invalid_operation);
1806 return FALSE;
1807 }
1808
1809 *psyment = csym->native->u.syment;
1810
1811 if (csym->native->fix_value)
1812 psyment->n_value = psyment->n_value -
1813 (bfd_hostptr_t) obj_raw_syments (abfd);
1814
1815 /* FIXME: We should handle fix_line here. */
1816
1817 return TRUE;
1818 }
1819
1820 /* Return the COFF auxent for a symbol. */
1821
1822 bfd_boolean
1823 bfd_coff_get_auxent (bfd *abfd,
1824 asymbol *symbol,
1825 int indx,
1826 union internal_auxent *pauxent)
1827 {
1828 coff_symbol_type *csym;
1829 combined_entry_type *ent;
1830
1831 csym = coff_symbol_from (abfd, symbol);
1832
1833 if (csym == NULL
1834 || csym->native == NULL
1835 || indx >= csym->native->u.syment.n_numaux)
1836 {
1837 bfd_set_error (bfd_error_invalid_operation);
1838 return FALSE;
1839 }
1840
1841 ent = csym->native + indx + 1;
1842
1843 *pauxent = ent->u.auxent;
1844
1845 if (ent->fix_tag)
1846 pauxent->x_sym.x_tagndx.l =
1847 ((combined_entry_type *) pauxent->x_sym.x_tagndx.p
1848 - obj_raw_syments (abfd));
1849
1850 if (ent->fix_end)
1851 pauxent->x_sym.x_fcnary.x_fcn.x_endndx.l =
1852 ((combined_entry_type *) pauxent->x_sym.x_fcnary.x_fcn.x_endndx.p
1853 - obj_raw_syments (abfd));
1854
1855 if (ent->fix_scnlen)
1856 pauxent->x_csect.x_scnlen.l =
1857 ((combined_entry_type *) pauxent->x_csect.x_scnlen.p
1858 - obj_raw_syments (abfd));
1859
1860 return TRUE;
1861 }
1862
1863 /* Print out information about COFF symbol. */
1864
1865 void
1866 coff_print_symbol (bfd *abfd,
1867 void * filep,
1868 asymbol *symbol,
1869 bfd_print_symbol_type how)
1870 {
1871 FILE * file = (FILE *) filep;
1872
1873 switch (how)
1874 {
1875 case bfd_print_symbol_name:
1876 fprintf (file, "%s", symbol->name);
1877 break;
1878
1879 case bfd_print_symbol_more:
1880 fprintf (file, "coff %s %s",
1881 coffsymbol (symbol)->native ? "n" : "g",
1882 coffsymbol (symbol)->lineno ? "l" : " ");
1883 break;
1884
1885 case bfd_print_symbol_all:
1886 if (coffsymbol (symbol)->native)
1887 {
1888 bfd_vma val;
1889 unsigned int aux;
1890 combined_entry_type *combined = coffsymbol (symbol)->native;
1891 combined_entry_type *root = obj_raw_syments (abfd);
1892 struct lineno_cache_entry *l = coffsymbol (symbol)->lineno;
1893
1894 fprintf (file, "[%3ld]", (long) (combined - root));
1895
1896 if (! combined->fix_value)
1897 val = (bfd_vma) combined->u.syment.n_value;
1898 else
1899 val = combined->u.syment.n_value - (bfd_hostptr_t) root;
1900
1901 fprintf (file, "(sec %2d)(fl 0x%02x)(ty %3x)(scl %3d) (nx %d) 0x",
1902 combined->u.syment.n_scnum,
1903 combined->u.syment.n_flags,
1904 combined->u.syment.n_type,
1905 combined->u.syment.n_sclass,
1906 combined->u.syment.n_numaux);
1907 #ifdef BFD64
1908 /* fprintf_vma() on a 64-bit enabled host will always print a 64-bit
1909 value, but really we want to display the address in the target's
1910 address size. Since we do not have a field in the bfd structure
1911 to tell us this, we take a guess, based on the target's name. */
1912 if (strstr (bfd_get_target (abfd), "64") == NULL)
1913 fprintf (file, "%08lx", (unsigned long) (val & 0xffffffff));
1914 else
1915 #endif
1916 fprintf_vma (file, val);
1917 fprintf (file, " %s", symbol->name);
1918
1919 for (aux = 0; aux < combined->u.syment.n_numaux; aux++)
1920 {
1921 combined_entry_type *auxp = combined + aux + 1;
1922 long tagndx;
1923
1924 if (auxp->fix_tag)
1925 tagndx = auxp->u.auxent.x_sym.x_tagndx.p - root;
1926 else
1927 tagndx = auxp->u.auxent.x_sym.x_tagndx.l;
1928
1929 fprintf (file, "\n");
1930
1931 if (bfd_coff_print_aux (abfd, file, root, combined, auxp, aux))
1932 continue;
1933
1934 switch (combined->u.syment.n_sclass)
1935 {
1936 case C_FILE:
1937 fprintf (file, "File ");
1938 break;
1939
1940 case C_STAT:
1941 if (combined->u.syment.n_type == T_NULL)
1942 /* Probably a section symbol ? */
1943 {
1944 fprintf (file, "AUX scnlen 0x%lx nreloc %d nlnno %d",
1945 (long) auxp->u.auxent.x_scn.x_scnlen,
1946 auxp->u.auxent.x_scn.x_nreloc,
1947 auxp->u.auxent.x_scn.x_nlinno);
1948 if (auxp->u.auxent.x_scn.x_checksum != 0
1949 || auxp->u.auxent.x_scn.x_associated != 0
1950 || auxp->u.auxent.x_scn.x_comdat != 0)
1951 fprintf (file, " checksum 0x%lx assoc %d comdat %d",
1952 auxp->u.auxent.x_scn.x_checksum,
1953 auxp->u.auxent.x_scn.x_associated,
1954 auxp->u.auxent.x_scn.x_comdat);
1955 break;
1956 }
1957 /* Otherwise fall through. */
1958 case C_EXT:
1959 if (ISFCN (combined->u.syment.n_type))
1960 {
1961 long next, llnos;
1962
1963 if (auxp->fix_end)
1964 next = (auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p
1965 - root);
1966 else
1967 next = auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.l;
1968 llnos = auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_lnnoptr;
1969 fprintf (file,
1970 "AUX tagndx %ld ttlsiz 0x%lx lnnos %ld next %ld",
1971 tagndx, auxp->u.auxent.x_sym.x_misc.x_fsize,
1972 llnos, next);
1973 break;
1974 }
1975 /* Otherwise fall through. */
1976 default:
1977 fprintf (file, "AUX lnno %d size 0x%x tagndx %ld",
1978 auxp->u.auxent.x_sym.x_misc.x_lnsz.x_lnno,
1979 auxp->u.auxent.x_sym.x_misc.x_lnsz.x_size,
1980 tagndx);
1981 if (auxp->fix_end)
1982 fprintf (file, " endndx %ld",
1983 ((long)
1984 (auxp->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p
1985 - root)));
1986 break;
1987 }
1988 }
1989
1990 if (l)
1991 {
1992 fprintf (file, "\n%s :", l->u.sym->name);
1993 l++;
1994 while (l->line_number)
1995 {
1996 fprintf (file, "\n%4d : ", l->line_number);
1997 fprintf_vma (file, l->u.offset + symbol->section->vma);
1998 l++;
1999 }
2000 }
2001 }
2002 else
2003 {
2004 bfd_print_symbol_vandf (abfd, (void *) file, symbol);
2005 fprintf (file, " %-5s %s %s %s",
2006 symbol->section->name,
2007 coffsymbol (symbol)->native ? "n" : "g",
2008 coffsymbol (symbol)->lineno ? "l" : " ",
2009 symbol->name);
2010 }
2011 }
2012 }
2013
2014 /* Return whether a symbol name implies a local symbol. In COFF,
2015 local symbols generally start with ``.L''. Most targets use this
2016 function for the is_local_label_name entry point, but some may
2017 override it. */
2018
2019 bfd_boolean
2020 _bfd_coff_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
2021 const char *name)
2022 {
2023 return name[0] == '.' && name[1] == 'L';
2024 }
2025
2026 /* Provided a BFD, a section and an offset (in bytes, not octets) into the
2027 section, calculate and return the name of the source file and the line
2028 nearest to the wanted location. */
2029
2030 bfd_boolean
2031 coff_find_nearest_line (bfd *abfd,
2032 asection *section,
2033 asymbol **symbols,
2034 bfd_vma offset,
2035 const char **filename_ptr,
2036 const char **functionname_ptr,
2037 unsigned int *line_ptr)
2038 {
2039 bfd_boolean found;
2040 unsigned int i;
2041 unsigned int line_base;
2042 coff_data_type *cof = coff_data (abfd);
2043 /* Run through the raw syments if available. */
2044 combined_entry_type *p;
2045 combined_entry_type *pend;
2046 alent *l;
2047 struct coff_section_tdata *sec_data;
2048 bfd_size_type amt;
2049
2050 /* Before looking through the symbol table, try to use a .stab
2051 section to find the information. */
2052 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
2053 &found, filename_ptr,
2054 functionname_ptr, line_ptr,
2055 &coff_data(abfd)->line_info))
2056 return FALSE;
2057
2058 if (found)
2059 return TRUE;
2060
2061 /* Also try examining DWARF2 debugging information. */
2062 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
2063 filename_ptr, functionname_ptr,
2064 line_ptr, 0,
2065 &coff_data(abfd)->dwarf2_find_line_info))
2066 return TRUE;
2067
2068 *filename_ptr = 0;
2069 *functionname_ptr = 0;
2070 *line_ptr = 0;
2071
2072 /* Don't try and find line numbers in a non coff file. */
2073 if (!bfd_family_coff (abfd))
2074 return FALSE;
2075
2076 if (cof == NULL)
2077 return FALSE;
2078
2079 /* Find the first C_FILE symbol. */
2080 p = cof->raw_syments;
2081 if (!p)
2082 return FALSE;
2083
2084 pend = p + cof->raw_syment_count;
2085 while (p < pend)
2086 {
2087 if (p->u.syment.n_sclass == C_FILE)
2088 break;
2089 p += 1 + p->u.syment.n_numaux;
2090 }
2091
2092 if (p < pend)
2093 {
2094 bfd_vma sec_vma;
2095 bfd_vma maxdiff;
2096
2097 /* Look through the C_FILE symbols to find the best one. */
2098 sec_vma = bfd_get_section_vma (abfd, section);
2099 *filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
2100 maxdiff = (bfd_vma) 0 - (bfd_vma) 1;
2101 while (1)
2102 {
2103 combined_entry_type *p2;
2104
2105 for (p2 = p + 1 + p->u.syment.n_numaux;
2106 p2 < pend;
2107 p2 += 1 + p2->u.syment.n_numaux)
2108 {
2109 if (p2->u.syment.n_scnum > 0
2110 && (section
2111 == coff_section_from_bfd_index (abfd,
2112 p2->u.syment.n_scnum)))
2113 break;
2114 if (p2->u.syment.n_sclass == C_FILE)
2115 {
2116 p2 = pend;
2117 break;
2118 }
2119 }
2120
2121 /* We use <= MAXDIFF here so that if we get a zero length
2122 file, we actually use the next file entry. */
2123 if (p2 < pend
2124 && offset + sec_vma >= (bfd_vma) p2->u.syment.n_value
2125 && offset + sec_vma - (bfd_vma) p2->u.syment.n_value <= maxdiff)
2126 {
2127 *filename_ptr = (char *) p->u.syment._n._n_n._n_offset;
2128 maxdiff = offset + sec_vma - p2->u.syment.n_value;
2129 }
2130
2131 /* Avoid endless loops on erroneous files by ensuring that
2132 we always move forward in the file. */
2133 if (p >= cof->raw_syments + p->u.syment.n_value)
2134 break;
2135
2136 p = cof->raw_syments + p->u.syment.n_value;
2137 if (p > pend || p->u.syment.n_sclass != C_FILE)
2138 break;
2139 }
2140 }
2141
2142 /* Now wander though the raw linenumbers of the section. */
2143 /* If we have been called on this section before, and th. e offset we
2144 want is further down then we can prime the lookup loop. */
2145 sec_data = coff_section_data (abfd, section);
2146 if (sec_data != NULL
2147 && sec_data->i > 0
2148 && offset >= sec_data->offset)
2149 {
2150 i = sec_data->i;
2151 *functionname_ptr = sec_data->function;
2152 line_base = sec_data->line_base;
2153 }
2154 else
2155 {
2156 i = 0;
2157 line_base = 0;
2158 }
2159
2160 if (section->lineno != NULL)
2161 {
2162 bfd_vma last_value = 0;
2163
2164 l = &section->lineno[i];
2165
2166 for (; i < section->lineno_count; i++)
2167 {
2168 if (l->line_number == 0)
2169 {
2170 /* Get the symbol this line number points at. */
2171 coff_symbol_type *coff = (coff_symbol_type *) (l->u.sym);
2172 if (coff->symbol.value > offset)
2173 break;
2174 *functionname_ptr = coff->symbol.name;
2175 last_value = coff->symbol.value;
2176 if (coff->native)
2177 {
2178 combined_entry_type *s = coff->native;
2179 s = s + 1 + s->u.syment.n_numaux;
2180
2181 /* In XCOFF a debugging symbol can follow the
2182 function symbol. */
2183 if (s->u.syment.n_scnum == N_DEBUG)
2184 s = s + 1 + s->u.syment.n_numaux;
2185
2186 /* S should now point to the .bf of the function. */
2187 if (s->u.syment.n_numaux)
2188 {
2189 /* The linenumber is stored in the auxent. */
2190 union internal_auxent *a = &((s + 1)->u.auxent);
2191 line_base = a->x_sym.x_misc.x_lnsz.x_lnno;
2192 *line_ptr = line_base;
2193 }
2194 }
2195 }
2196 else
2197 {
2198 if (l->u.offset > offset)
2199 break;
2200 *line_ptr = l->line_number + line_base - 1;
2201 }
2202 l++;
2203 }
2204
2205 /* If we fell off the end of the loop, then assume that this
2206 symbol has no line number info. Otherwise, symbols with no
2207 line number info get reported with the line number of the
2208 last line of the last symbol which does have line number
2209 info. We use 0x100 as a slop to account for cases where the
2210 last line has executable code. */
2211 if (i >= section->lineno_count
2212 && last_value != 0
2213 && offset - last_value > 0x100)
2214 {
2215 *functionname_ptr = NULL;
2216 *line_ptr = 0;
2217 }
2218 }
2219
2220 /* Cache the results for the next call. */
2221 if (sec_data == NULL && section->owner == abfd)
2222 {
2223 amt = sizeof (struct coff_section_tdata);
2224 section->used_by_bfd = bfd_zalloc (abfd, amt);
2225 sec_data = (struct coff_section_tdata *) section->used_by_bfd;
2226 }
2227 if (sec_data != NULL)
2228 {
2229 sec_data->offset = offset;
2230 sec_data->i = i;
2231 sec_data->function = *functionname_ptr;
2232 sec_data->line_base = line_base;
2233 }
2234
2235 return TRUE;
2236 }
2237
2238 bfd_boolean
2239 coff_find_inliner_info (bfd *abfd,
2240 const char **filename_ptr,
2241 const char **functionname_ptr,
2242 unsigned int *line_ptr)
2243 {
2244 bfd_boolean found;
2245
2246 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
2247 functionname_ptr, line_ptr,
2248 &coff_data(abfd)->dwarf2_find_line_info);
2249 return (found);
2250 }
2251
2252 int
2253 coff_sizeof_headers (bfd *abfd, struct bfd_link_info *info)
2254 {
2255 size_t size;
2256
2257 if (!info->relocatable)
2258 size = bfd_coff_filhsz (abfd) + bfd_coff_aoutsz (abfd);
2259 else
2260 size = bfd_coff_filhsz (abfd);
2261
2262 size += abfd->section_count * bfd_coff_scnhsz (abfd);
2263 return size;
2264 }
2265
2266 /* Change the class of a coff symbol held by BFD. */
2267
2268 bfd_boolean
2269 bfd_coff_set_symbol_class (bfd * abfd,
2270 asymbol * symbol,
2271 unsigned int class)
2272 {
2273 coff_symbol_type * csym;
2274
2275 csym = coff_symbol_from (abfd, symbol);
2276 if (csym == NULL)
2277 {
2278 bfd_set_error (bfd_error_invalid_operation);
2279 return FALSE;
2280 }
2281 else if (csym->native == NULL)
2282 {
2283 /* This is an alien symbol which no native coff backend data.
2284 We cheat here by creating a fake native entry for it and
2285 then filling in the class. This code is based on that in
2286 coff_write_alien_symbol(). */
2287
2288 combined_entry_type * native;
2289 bfd_size_type amt = sizeof (* native);
2290
2291 native = bfd_zalloc (abfd, amt);
2292 if (native == NULL)
2293 return FALSE;
2294
2295 native->u.syment.n_type = T_NULL;
2296 native->u.syment.n_sclass = class;
2297
2298 if (bfd_is_und_section (symbol->section))
2299 {
2300 native->u.syment.n_scnum = N_UNDEF;
2301 native->u.syment.n_value = symbol->value;
2302 }
2303 else if (bfd_is_com_section (symbol->section))
2304 {
2305 native->u.syment.n_scnum = N_UNDEF;
2306 native->u.syment.n_value = symbol->value;
2307 }
2308 else
2309 {
2310 native->u.syment.n_scnum =
2311 symbol->section->output_section->target_index;
2312 native->u.syment.n_value = (symbol->value
2313 + symbol->section->output_offset);
2314 if (! obj_pe (abfd))
2315 native->u.syment.n_value += symbol->section->output_section->vma;
2316
2317 /* Copy the any flags from the file header into the symbol.
2318 FIXME: Why? */
2319 native->u.syment.n_flags = bfd_asymbol_bfd (& csym->symbol)->flags;
2320 }
2321
2322 csym->native = native;
2323 }
2324 else
2325 csym->native->u.syment.n_sclass = class;
2326
2327 return TRUE;
2328 }
2329
2330 struct coff_comdat_info *
2331 bfd_coff_get_comdat_section (bfd *abfd, struct bfd_section *sec)
2332 {
2333 if (bfd_get_flavour (abfd) == bfd_target_coff_flavour
2334 && coff_section_data (abfd, sec) != NULL)
2335 return coff_section_data (abfd, sec)->comdat;
2336 else
2337 return NULL;
2338 }
This page took 0.081202 seconds and 4 git commands to generate.