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