binutils/rdcoff.c

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