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 }