source: trunk/src/binutils/binutils/rdcoff.c@ 10

Last change on this file since 10 was 10, checked in by bird, 22 years ago

Initial revision
  • Property cvs2svn:cvs-rev set to 1.1
  • Property svn:eol-style set to native
  • Property svn:executable set to *
File size: 21.2 KB
Line 
1/* stabs.c -- Parse COFF debugging information
2 Copyright 1996, 2000 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor <ian@cygnus.com>.
4
5 This file is part of GNU Binutils.
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 2 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., 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA. */
21
22/* This file contains code which parses COFF debugging information. */
23
24#include "bfd.h"
25#include "coff/internal.h"
26#include "bucomm.h"
27#include "libiberty.h"
28#include "demangle.h"
29#include "debug.h"
30#include "budbg.h"
31
32/* FIXME: We should not need this BFD internal file. We need it for
33 the N_BTMASK, etc., values. */
34#include "libcoff.h"
35
36/* These macros extract the right mask and shifts for this BFD. They
37 assume that there is a local variable named ABFD. This is so that
38 macros like ISFCN and DECREF, from coff/internal.h, will work
39 without modification. */
40#define N_BTMASK (coff_data (abfd)->local_n_btmask)
41#define N_BTSHFT (coff_data (abfd)->local_n_btshft)
42#define N_TMASK (coff_data (abfd)->local_n_tmask)
43#define N_TSHIFT (coff_data (abfd)->local_n_tshift)
44
45/* This structure is used to hold the symbols, as well as the current
46 location within the symbols. */
47
48struct coff_symbols
49{
50 /* The symbols. */
51 asymbol **syms;
52 /* The number of symbols. */
53 long symcount;
54 /* The index of the current symbol. */
55 long symno;
56 /* The index of the current symbol in the COFF symbol table (where
57 each auxent counts as a symbol). */
58 long coff_symno;
59};
60
61/* The largest basic type we are prepared to handle. */
62
63#define T_MAX (T_LNGDBL)
64
65/* This structure is used to hold slots. */
66
67struct coff_slots
68{
69 /* Next set of slots. */
70 struct coff_slots *next;
71 /* Slots. */
72#define COFF_SLOTS (16)
73 debug_type slots[COFF_SLOTS];
74};
75
76/* This structure is used to map symbol indices to types. */
77
78struct coff_types
79{
80 /* Slots. */
81 struct coff_slots *slots;
82 /* Basic types. */
83 debug_type basic[T_MAX + 1];
84};
85
86static debug_type *coff_get_slot PARAMS ((struct coff_types *, int));
87static debug_type parse_coff_type
88 PARAMS ((bfd *, struct coff_symbols *, struct coff_types *, long, int,
89 union internal_auxent *, boolean, PTR));
90static debug_type parse_coff_base_type
91 PARAMS ((bfd *, struct coff_symbols *, struct coff_types *, long, int,
92 union internal_auxent *, PTR));
93static debug_type parse_coff_struct_type
94 PARAMS ((bfd *, struct coff_symbols *, struct coff_types *, int,
95 union internal_auxent *, PTR));
96static debug_type parse_coff_enum_type
97 PARAMS ((bfd *, struct coff_symbols *, struct coff_types *,
98 union internal_auxent *, PTR));
99static boolean parse_coff_symbol
100 PARAMS ((bfd *, struct coff_types *, asymbol *, long,
101 struct internal_syment *, PTR, debug_type, boolean));
102static boolean external_coff_symbol_p PARAMS ((int sym_class));
103
104
105/* Return the slot for a type. */
106
107static debug_type *
108coff_get_slot (types, indx)
109 struct coff_types *types;
110 int indx;
111{
112 struct coff_slots **pps;
113
114 pps = &types->slots;
115
116 while (indx >= COFF_SLOTS)
117 {
118 if (*pps == NULL)
119 {
120 *pps = (struct coff_slots *) xmalloc (sizeof **pps);
121 memset (*pps, 0, sizeof **pps);
122 }
123 pps = &(*pps)->next;
124 indx -= COFF_SLOTS;
125 }
126
127 if (*pps == NULL)
128 {
129 *pps = (struct coff_slots *) xmalloc (sizeof **pps);
130 memset (*pps, 0, sizeof **pps);
131 }
132
133 return (*pps)->slots + indx;
134}
135
136/* Parse a COFF type code in NTYPE. */
137
138static debug_type
139parse_coff_type (abfd, symbols, types, coff_symno, ntype, pauxent, useaux,
140 dhandle)
141 bfd *abfd;
142 struct coff_symbols *symbols;
143 struct coff_types *types;
144 long coff_symno;
145 int ntype;
146 union internal_auxent *pauxent;
147 boolean useaux;
148 PTR dhandle;
149{
150 debug_type type;
151
152 if ((ntype & ~N_BTMASK) != 0)
153 {
154 int newtype;
155
156 newtype = DECREF (ntype);
157
158 if (ISPTR (ntype))
159 {
160 type = parse_coff_type (abfd, symbols, types, coff_symno, newtype,
161 pauxent, useaux, dhandle);
162 type = debug_make_pointer_type (dhandle, type);
163 }
164 else if (ISFCN (ntype))
165 {
166 type = parse_coff_type (abfd, symbols, types, coff_symno, newtype,
167 pauxent, useaux, dhandle);
168 type = debug_make_function_type (dhandle, type, (debug_type *) NULL,
169 false);
170 }
171 else if (ISARY (ntype))
172 {
173 int n;
174
175 if (pauxent == NULL)
176 n = 0;
177 else
178 {
179 unsigned short *dim;
180 int i;
181
182 /* FIXME: If pauxent->x_sym.x_tagndx.l == 0, gdb sets
183 the c_naux field of the syment to 0. */
184
185 /* Move the dimensions down, so that the next array
186 picks up the next one. */
187 dim = pauxent->x_sym.x_fcnary.x_ary.x_dimen;
188 n = dim[0];
189 for (i = 0; *dim != 0 && i < DIMNUM - 1; i++, dim++)
190 *dim = *(dim + 1);
191 *dim = 0;
192 }
193
194 type = parse_coff_type (abfd, symbols, types, coff_symno, newtype,
195 pauxent, false, dhandle);
196 type = debug_make_array_type (dhandle, type,
197 parse_coff_base_type (abfd, symbols,
198 types,
199 coff_symno,
200 T_INT,
201 NULL, dhandle),
202 0, n - 1, false);
203 }
204 else
205 {
206 non_fatal (_("parse_coff_type: Bad type code 0x%x"), ntype);
207 return DEBUG_TYPE_NULL;
208 }
209
210 return type;
211 }
212
213 if (pauxent != NULL && pauxent->x_sym.x_tagndx.l > 0)
214 {
215 debug_type *slot;
216
217 /* This is a reference to an existing type. FIXME: gdb checks
218 that the class is not C_STRTAG, nor C_UNTAG, nor C_ENTAG. */
219 slot = coff_get_slot (types, pauxent->x_sym.x_tagndx.l);
220 if (*slot != DEBUG_TYPE_NULL)
221 return *slot;
222 else
223 return debug_make_indirect_type (dhandle, slot, (const char *) NULL);
224 }
225
226 /* If the aux entry has already been used for something, useaux will
227 have been set to false, indicating that parse_coff_base_type
228 should not use it. We need to do it this way, rather than simply
229 passing pauxent as NULL, because we need to be able handle
230 multiple array dimensions while still discarding pauxent after
231 having handled all of them. */
232 if (! useaux)
233 pauxent = NULL;
234
235 return parse_coff_base_type (abfd, symbols, types, coff_symno, ntype,
236 pauxent, dhandle);
237}
238
239/* Parse a basic COFF type in NTYPE. */
240
241static debug_type
242parse_coff_base_type (abfd, symbols, types, coff_symno, ntype, pauxent,
243 dhandle)
244 bfd *abfd;
245 struct coff_symbols *symbols;
246 struct coff_types *types;
247 long coff_symno;
248 int ntype;
249 union internal_auxent *pauxent;
250 PTR dhandle;
251{
252 debug_type ret;
253 boolean set_basic;
254 const char *name;
255 debug_type *slot;
256
257 if (ntype >= 0
258 && ntype <= T_MAX
259 && types->basic[ntype] != DEBUG_TYPE_NULL)
260 return types->basic[ntype];
261
262 set_basic = true;
263 name = NULL;
264
265 switch (ntype)
266 {
267 default:
268 ret = debug_make_void_type (dhandle);
269 break;
270
271 case T_NULL:
272 case T_VOID:
273 ret = debug_make_void_type (dhandle);
274 name = "void";
275 break;
276
277 case T_CHAR:
278 ret = debug_make_int_type (dhandle, 1, false);
279 name = "char";
280 break;
281
282 case T_SHORT:
283 ret = debug_make_int_type (dhandle, 2, false);
284 name = "short";
285 break;
286
287 case T_INT:
288 /* FIXME: Perhaps the size should depend upon the architecture. */
289 ret = debug_make_int_type (dhandle, 4, false);
290 name = "int";
291 break;
292
293 case T_LONG:
294 ret = debug_make_int_type (dhandle, 4, false);
295 name = "long";
296 break;
297
298 case T_FLOAT:
299 ret = debug_make_float_type (dhandle, 4);
300 name = "float";
301 break;
302
303 case T_DOUBLE:
304 ret = debug_make_float_type (dhandle, 8);
305 name = "double";
306 break;
307
308 case T_LNGDBL:
309 ret = debug_make_float_type (dhandle, 12);
310 name = "long double";
311 break;
312
313 case T_UCHAR:
314 ret = debug_make_int_type (dhandle, 1, true);
315 name = "unsigned char";
316 break;
317
318 case T_USHORT:
319 ret = debug_make_int_type (dhandle, 2, true);
320 name = "unsigned short";
321 break;
322
323 case T_UINT:
324 ret = debug_make_int_type (dhandle, 4, true);
325 name = "unsigned int";
326 break;
327
328 case T_ULONG:
329 ret = debug_make_int_type (dhandle, 4, true);
330 name = "unsigned long";
331 break;
332
333 case T_STRUCT:
334 if (pauxent == NULL)
335 ret = debug_make_struct_type (dhandle, true, 0,
336 (debug_field *) NULL);
337 else
338 ret = parse_coff_struct_type (abfd, symbols, types, ntype, pauxent,
339 dhandle);
340
341 slot = coff_get_slot (types, coff_symno);
342 *slot = ret;
343
344 set_basic = false;
345 break;
346
347 case T_UNION:
348 if (pauxent == NULL)
349 ret = debug_make_struct_type (dhandle, false, 0, (debug_field *) NULL);
350 else
351 ret = parse_coff_struct_type (abfd, symbols, types, ntype, pauxent,
352 dhandle);
353
354 slot = coff_get_slot (types, coff_symno);
355 *slot = ret;
356
357 set_basic = false;
358 break;
359
360 case T_ENUM:
361 if (pauxent == NULL)
362 ret = debug_make_enum_type (dhandle, (const char **) NULL,
363 (bfd_signed_vma *) NULL);
364 else
365 ret = parse_coff_enum_type (abfd, symbols, types, pauxent, dhandle);
366
367 slot = coff_get_slot (types, coff_symno);
368 *slot = ret;
369
370 set_basic = false;
371 break;
372 }
373
374 if (name != NULL)
375 ret = debug_name_type (dhandle, name, ret);
376
377 if (set_basic
378 && ntype >= 0
379 && ntype <= T_MAX)
380 types->basic[ntype] = ret;
381
382 return ret;
383}
384
385/* Parse a struct type. */
386
387static debug_type
388parse_coff_struct_type (abfd, symbols, types, ntype, pauxent, dhandle)
389 bfd *abfd;
390 struct coff_symbols *symbols;
391 struct coff_types *types;
392 int ntype;
393 union internal_auxent *pauxent;
394 PTR dhandle;
395{
396 long symend;
397 int alloc;
398 debug_field *fields;
399 int count;
400 boolean done;
401
402 symend = pauxent->x_sym.x_fcnary.x_fcn.x_endndx.l;
403
404 alloc = 10;
405 fields = (debug_field *) xmalloc (alloc * sizeof *fields);
406 count = 0;
407
408 done = false;
409 while (! done
410 && symbols->coff_symno < symend
411 && symbols->symno < symbols->symcount)
412 {
413 asymbol *sym;
414 long this_coff_symno;
415 struct internal_syment syment;
416 union internal_auxent auxent;
417 union internal_auxent *psubaux;
418 bfd_vma bitpos = 0, bitsize = 0;
419
420 sym = symbols->syms[symbols->symno];
421
422 if (! bfd_coff_get_syment (abfd, sym, &syment))
423 {
424 non_fatal (_("bfd_coff_get_syment failed: %s"),
425 bfd_errmsg (bfd_get_error ()));
426 return DEBUG_TYPE_NULL;
427 }
428
429 this_coff_symno = symbols->coff_symno;
430
431 ++symbols->symno;
432 symbols->coff_symno += 1 + syment.n_numaux;
433
434 if (syment.n_numaux == 0)
435 psubaux = NULL;
436 else
437 {
438 if (! bfd_coff_get_auxent (abfd, sym, 0, &auxent))
439 {
440 non_fatal (_("bfd_coff_get_auxent failed: %s"),
441 bfd_errmsg (bfd_get_error ()));
442 return DEBUG_TYPE_NULL;
443 }
444 psubaux = &auxent;
445 }
446
447 switch (syment.n_sclass)
448 {
449 case C_MOS:
450 case C_MOU:
451 bitpos = 8 * bfd_asymbol_value (sym);
452 bitsize = 0;
453 break;
454
455 case C_FIELD:
456 bitpos = bfd_asymbol_value (sym);
457 bitsize = auxent.x_sym.x_misc.x_lnsz.x_size;
458 break;
459
460 case C_EOS:
461 done = true;
462 break;
463 }
464
465 if (! done)
466 {
467 debug_type ftype;
468 debug_field f;
469
470 ftype = parse_coff_type (abfd, symbols, types, this_coff_symno,
471 syment.n_type, psubaux, true, dhandle);
472 f = debug_make_field (dhandle, bfd_asymbol_name (sym), ftype,
473 bitpos, bitsize, DEBUG_VISIBILITY_PUBLIC);
474 if (f == DEBUG_FIELD_NULL)
475 return DEBUG_TYPE_NULL;
476
477 if (count + 1 >= alloc)
478 {
479 alloc += 10;
480 fields = ((debug_field *)
481 xrealloc (fields, alloc * sizeof *fields));
482 }
483
484 fields[count] = f;
485 ++count;
486 }
487 }
488
489 fields[count] = DEBUG_FIELD_NULL;
490
491 return debug_make_struct_type (dhandle, ntype == T_STRUCT,
492 pauxent->x_sym.x_misc.x_lnsz.x_size,
493 fields);
494}
495
496/* Parse an enum type. */
497
498static debug_type
499parse_coff_enum_type (abfd, symbols, types, pauxent, dhandle)
500 bfd *abfd;
501 struct coff_symbols *symbols;
502 struct coff_types *types ATTRIBUTE_UNUSED;
503 union internal_auxent *pauxent;
504 PTR dhandle;
505{
506 long symend;
507 int alloc;
508 const char **names;
509 bfd_signed_vma *vals;
510 int count;
511 boolean done;
512
513 symend = pauxent->x_sym.x_fcnary.x_fcn.x_endndx.l;
514
515 alloc = 10;
516 names = (const char **) xmalloc (alloc * sizeof *names);
517 vals = (bfd_signed_vma *) xmalloc (alloc * sizeof *vals);
518 count = 0;
519
520 done = false;
521 while (! done
522 && symbols->coff_symno < symend
523 && symbols->symno < symbols->symcount)
524 {
525 asymbol *sym;
526 struct internal_syment syment;
527
528 sym = symbols->syms[symbols->symno];
529
530 if (! bfd_coff_get_syment (abfd, sym, &syment))
531 {
532 non_fatal (_("bfd_coff_get_syment failed: %s"),
533 bfd_errmsg (bfd_get_error ()));
534 return DEBUG_TYPE_NULL;
535 }
536
537 ++symbols->symno;
538 symbols->coff_symno += 1 + syment.n_numaux;
539
540 switch (syment.n_sclass)
541 {
542 case C_MOE:
543 if (count + 1 >= alloc)
544 {
545 alloc += 10;
546 names = ((const char **)
547 xrealloc (names, alloc * sizeof *names));
548 vals = ((bfd_signed_vma *)
549 xrealloc (vals, alloc * sizeof *vals));
550 }
551
552 names[count] = bfd_asymbol_name (sym);
553 vals[count] = bfd_asymbol_value (sym);
554 ++count;
555 break;
556
557 case C_EOS:
558 done = true;
559 break;
560 }
561 }
562
563 names[count] = NULL;
564
565 return debug_make_enum_type (dhandle, names, vals);
566}
567
568/* Handle a single COFF symbol. */
569
570static boolean
571parse_coff_symbol (abfd, types, sym, coff_symno, psyment, dhandle, type,
572 within_function)
573 bfd *abfd ATTRIBUTE_UNUSED;
574 struct coff_types *types;
575 asymbol *sym;
576 long coff_symno;
577 struct internal_syment *psyment;
578 PTR dhandle;
579 debug_type type;
580 boolean within_function;
581{
582 switch (psyment->n_sclass)
583 {
584 case C_NULL:
585 break;
586
587 case C_AUTO:
588 if (! debug_record_variable (dhandle, bfd_asymbol_name (sym), type,
589 DEBUG_LOCAL, bfd_asymbol_value (sym)))
590 return false;
591 break;
592
593 case C_WEAKEXT:
594 case C_EXT:
595 if (! debug_record_variable (dhandle, bfd_asymbol_name (sym), type,
596 DEBUG_GLOBAL, bfd_asymbol_value (sym)))
597 return false;
598 break;
599
600 case C_STAT:
601 if (! debug_record_variable (dhandle, bfd_asymbol_name (sym), type,
602 (within_function
603 ? DEBUG_LOCAL_STATIC
604 : DEBUG_STATIC),
605 bfd_asymbol_value (sym)))
606 return false;
607 break;
608
609 case C_REG:
610 /* FIXME: We may need to convert the register number. */
611 if (! debug_record_variable (dhandle, bfd_asymbol_name (sym), type,
612 DEBUG_REGISTER, bfd_asymbol_value (sym)))
613 return false;
614 break;
615
616 case C_LABEL:
617 break;
618
619 case C_ARG:
620 if (! debug_record_parameter (dhandle, bfd_asymbol_name (sym), type,
621 DEBUG_PARM_STACK, bfd_asymbol_value (sym)))
622 return false;
623 break;
624
625 case C_REGPARM:
626 /* FIXME: We may need to convert the register number. */
627 if (! debug_record_parameter (dhandle, bfd_asymbol_name (sym), type,
628 DEBUG_PARM_REG, bfd_asymbol_value (sym)))
629 return false;
630 break;
631
632 case C_TPDEF:
633 type = debug_name_type (dhandle, bfd_asymbol_name (sym), type);
634 if (type == DEBUG_TYPE_NULL)
635 return false;
636 break;
637
638 case C_STRTAG:
639 case C_UNTAG:
640 case C_ENTAG:
641 {
642 debug_type *slot;
643
644 type = debug_tag_type (dhandle, bfd_asymbol_name (sym), type);
645 if (type == DEBUG_TYPE_NULL)
646 return false;
647
648 /* Store the named type into the slot, so that references get
649 the name. */
650 slot = coff_get_slot (types, coff_symno);
651 *slot = type;
652 }
653 break;
654
655 default:
656 break;
657 }
658
659 return true;
660}
661
662/* Determine if a symbol has external visibility. */
663
664static boolean
665external_coff_symbol_p (sym_class)
666 int sym_class;
667{
668 switch (sym_class)
669 {
670 case C_EXT:
671 case C_WEAKEXT:
672 return true;
673 default:
674 break;
675 }
676 return false;
677}
678
679/* This is the main routine. It looks through all the symbols and
680 handles them. */
681
682boolean
683parse_coff (abfd, syms, symcount, dhandle)
684 bfd *abfd;
685 asymbol **syms;
686 long symcount;
687 PTR dhandle;
688{
689 struct coff_symbols symbols;
690 struct coff_types types;
691 int i;
692 long next_c_file;
693 const char *fnname;
694 int fnclass;
695 int fntype;
696 bfd_vma fnend;
697 alent *linenos;
698 boolean within_function;
699 long this_coff_symno;
700
701 symbols.syms = syms;
702 symbols.symcount = symcount;
703 symbols.symno = 0;
704 symbols.coff_symno = 0;
705
706 types.slots = NULL;
707 for (i = 0; i <= T_MAX; i++)
708 types.basic[i] = DEBUG_TYPE_NULL;
709
710 next_c_file = -1;
711 fnname = NULL;
712 fnclass = 0;
713 fntype = 0;
714 fnend = 0;
715 linenos = NULL;
716 within_function = false;
717
718 while (symbols.symno < symcount)
719 {
720 asymbol *sym;
721 const char *name;
722 struct internal_syment syment;
723 union internal_auxent auxent;
724 union internal_auxent *paux;
725 debug_type type;
726
727 sym = syms[symbols.symno];
728
729 if (! bfd_coff_get_syment (abfd, sym, &syment))
730 {
731 non_fatal (_("bfd_coff_get_syment failed: %s"),
732 bfd_errmsg (bfd_get_error ()));
733 return false;
734 }
735
736 name = bfd_asymbol_name (sym);
737
738 this_coff_symno = symbols.coff_symno;
739
740 ++symbols.symno;
741 symbols.coff_symno += 1 + syment.n_numaux;
742
743 /* We only worry about the first auxent, because that is the
744 only one which is relevant for debugging information. */
745 if (syment.n_numaux == 0)
746 paux = NULL;
747 else
748 {
749 if (! bfd_coff_get_auxent (abfd, sym, 0, &auxent))
750 {
751 non_fatal (_("bfd_coff_get_auxent failed: %s"),
752 bfd_errmsg (bfd_get_error ()));
753 return false;
754 }
755 paux = &auxent;
756 }
757
758 if (this_coff_symno == next_c_file && syment.n_sclass != C_FILE)
759 {
760 /* The last C_FILE symbol points to the first external
761 symbol. */
762 if (! debug_set_filename (dhandle, "*globals*"))
763 return false;
764 }
765
766 switch (syment.n_sclass)
767 {
768 case C_EFCN:
769 case C_EXTDEF:
770 case C_ULABEL:
771 case C_USTATIC:
772 case C_LINE:
773 case C_ALIAS:
774 case C_HIDDEN:
775 /* Just ignore these classes. */
776 break;
777
778 case C_FILE:
779 next_c_file = syment.n_value;
780 if (! debug_set_filename (dhandle, name))
781 return false;
782 break;
783
784 case C_STAT:
785 /* Ignore static symbols with a type of T_NULL. These
786 represent section entries. */
787 if (syment.n_type == T_NULL)
788 break;
789 /* Fall through. */
790 case C_WEAKEXT:
791 case C_EXT:
792 if (ISFCN (syment.n_type))
793 {
794 fnname = name;
795 fnclass = syment.n_sclass;
796 fntype = syment.n_type;
797 if (syment.n_numaux > 0)
798 fnend = bfd_asymbol_value (sym) + auxent.x_sym.x_misc.x_fsize;
799 else
800 fnend = 0;
801 linenos = BFD_SEND (abfd, _get_lineno, (abfd, sym));
802 break;
803 }
804 type = parse_coff_type (abfd, &symbols, &types, this_coff_symno,
805 syment.n_type, paux, true, dhandle);
806 if (type == DEBUG_TYPE_NULL)
807 return false;
808 if (! parse_coff_symbol (abfd, &types, sym, this_coff_symno, &syment,
809 dhandle, type, within_function))
810 return false;
811 break;
812
813 case C_FCN:
814 if (strcmp (name, ".bf") == 0)
815 {
816 if (fnname == NULL)
817 {
818 non_fatal (_("%ld: .bf without preceding function"),
819 this_coff_symno);
820 return false;
821 }
822
823 type = parse_coff_type (abfd, &symbols, &types, this_coff_symno,
824 DECREF (fntype), paux, false, dhandle);
825 if (type == DEBUG_TYPE_NULL)
826 return false;
827
828 if (! debug_record_function (dhandle, fnname, type,
829 external_coff_symbol_p (fnclass),
830 bfd_asymbol_value (sym)))
831 return false;
832
833 if (linenos != NULL)
834 {
835 int base;
836 bfd_vma addr;
837
838 if (syment.n_numaux == 0)
839 base = 0;
840 else
841 base = auxent.x_sym.x_misc.x_lnsz.x_lnno - 1;
842
843 addr = bfd_get_section_vma (abfd, bfd_get_section (sym));
844
845 ++linenos;
846
847 while (linenos->line_number != 0)
848 {
849 if (! debug_record_line (dhandle,
850 linenos->line_number + base,
851 linenos->u.offset + addr))
852 return false;
853 ++linenos;
854 }
855 }
856
857 fnname = NULL;
858 linenos = NULL;
859 fnclass = 0;
860 fntype = 0;
861
862 within_function = true;
863 }
864 else if (strcmp (name, ".ef") == 0)
865 {
866 if (! within_function)
867 {
868 non_fatal (_("%ld: unexpected .ef\n"), this_coff_symno);
869 return false;
870 }
871
872 if (bfd_asymbol_value (sym) > fnend)
873 fnend = bfd_asymbol_value (sym);
874 if (! debug_end_function (dhandle, fnend))
875 return false;
876
877 fnend = 0;
878 within_function = false;
879 }
880 break;
881
882 case C_BLOCK:
883 if (strcmp (name, ".bb") == 0)
884 {
885 if (! debug_start_block (dhandle, bfd_asymbol_value (sym)))
886 return false;
887 }
888 else if (strcmp (name, ".eb") == 0)
889 {
890 if (! debug_end_block (dhandle, bfd_asymbol_value (sym)))
891 return false;
892 }
893 break;
894
895 default:
896 type = parse_coff_type (abfd, &symbols, &types, this_coff_symno,
897 syment.n_type, paux, true, dhandle);
898 if (type == DEBUG_TYPE_NULL)
899 return false;
900 if (! parse_coff_symbol (abfd, &types, sym, this_coff_symno, &syment,
901 dhandle, type, within_function))
902 return false;
903 break;
904 }
905 }
906
907 return true;
908}
Note: See TracBrowser for help on using the repository browser.