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