binutils/rdcoff.c

   1 /* stabs.c -- Parse COFF debugging information
   2    Copyright 1996, 2000 Free Software Foundation, Inc.
   3    Written by Ian Lance Taylor <ian@cygnus.com>.
   4
   5    This file is part of GNU Binutils.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  20    02111-1307, USA.  */
  21
  22 /* This file contains code which parses COFF debugging information.  */
  23
  24 #include "bfd.h"
  25 #include "coff/internal.h"
  26 #include "bucomm.h"
  27 #include "libiberty.h"
  28 #include "debug.h"
  29 #include "budbg.h"
  30
  31 /* FIXME: We should not need this BFD internal file.  We need it for
  32    the N_BTMASK, etc., values.  */
  33 #include "libcoff.h"
  34
  35 /* These macros extract the right mask and shifts for this BFD.  They
  36    assume that there is a local variable named ABFD.  This is so that
  37    macros like ISFCN and DECREF, from coff/internal.h, will work
  38    without modification.  */
  39 #define N_BTMASK (coff_data (abfd)->local_n_btmask)
  40 #define N_BTSHFT (coff_data (abfd)->local_n_btshft)
  41 #define N_TMASK  (coff_data (abfd)->local_n_tmask)
  42 #define N_TSHIFT (coff_data (abfd)->local_n_tshift)
  43
  44 /* This structure is used to hold the symbols, as well as the current
  45    location within the symbols.  */
  46
  47 struct coff_symbols
  48 {
  49   /* The symbols.  */
  50   asymbol **syms;
  51   /* The number of symbols.  */
  52   long symcount;
  53   /* The index of the current symbol.  */
  54   long symno;
  55   /* The index of the current symbol in the COFF symbol table (where
  56      each auxent counts as a symbol).  */
  57   long coff_symno;
  58 };
  59
  60 /* The largest basic type we are prepared to handle.  */
  61
  62 #define T_MAX (T_LNGDBL)
  63
  64 /* This structure is used to hold slots.  */
  65
  66 struct coff_slots
  67 {
  68   /* Next set of slots.  */
  69   struct coff_slots *next;
  70   /* Slots.  */
  71 #define COFF_SLOTS (16)
  72   debug_type slots[COFF_SLOTS];
  73 };
  74
  75 /* This structure is used to map symbol indices to types.  */
  76
  77 struct coff_types
  78 {
  79   /* Slots.  */
  80   struct coff_slots *slots;
  81   /* Basic types.  */
  82   debug_type basic[T_MAX + 1];
  83 };
  84
  85 static debug_type *coff_get_slot PARAMS ((struct coff_types *, int));
  86 static debug_type parse_coff_type
  87   PARAMS ((bfd *, struct coff_symbols *, struct coff_types *, long, int,
  88            union internal_auxent *, boolean, PTR));
  89 static debug_type parse_coff_base_type
  90   PARAMS ((bfd *, struct coff_symbols *, struct coff_types *, long, int,
  91            union internal_auxent *, PTR));
  92 static debug_type parse_coff_struct_type
  93   PARAMS ((bfd *, struct coff_symbols *, struct coff_types *, int,
  94            union internal_auxent *, PTR));
  95 static debug_type parse_coff_enum_type
  96   PARAMS ((bfd *, struct coff_symbols *, struct coff_types *,
  97            union internal_auxent *, PTR));
  98 static boolean parse_coff_symbol
  99   PARAMS ((bfd *, struct coff_types *, asymbol *, long,
 100            struct internal_syment *, PTR, debug_type, boolean));
 101 static boolean external_coff_symbol_p PARAMS ((int sym_class));
 102 \f
 103 /* Return the slot for a type.  */
 104
 105 static debug_type *
 106 coff_get_slot (types, indx)
 107      struct coff_types *types;
 108      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 (abfd, symbols, types, coff_symno, ntype, pauxent, useaux,
 138                  dhandle)
 139      bfd *abfd;
 140      struct coff_symbols *symbols;
 141      struct coff_types *types;
 142      long coff_symno;
 143      int ntype;
 144      union internal_auxent *pauxent;
 145      boolean useaux;
 146      PTR dhandle;
 147 {
 148   debug_type type;
 149
 150   if ((ntype & ~N_BTMASK) != 0)
 151     {
 152       int newtype;
 153
 154       newtype = DECREF (ntype);
 155
 156       if (ISPTR (ntype))
 157         {
 158           type = parse_coff_type (abfd, symbols, types, coff_symno, newtype,
 159                                   pauxent, useaux, dhandle);
 160           type = debug_make_pointer_type (dhandle, type);
 161         }
 162       else if (ISFCN (ntype))
 163         {
 164           type = parse_coff_type (abfd, symbols, types, coff_symno, newtype,
 165                                   pauxent, useaux, dhandle);
 166           type = debug_make_function_type (dhandle, type, (debug_type *) NULL,
 167                                            false);
 168         }
 169       else if (ISARY (ntype))
 170         {
 171           int n;
 172
 173           if (pauxent == NULL)
 174             n = 0;
 175           else
 176             {
 177               unsigned short *dim;
 178               int i;
 179
 180               /* FIXME: If pauxent->x_sym.x_tagndx.l == 0, gdb sets
 181                  the c_naux field of the syment to 0.  */
 182
 183               /* Move the dimensions down, so that the next array
 184                  picks up the next one.  */
 185               dim = pauxent->x_sym.x_fcnary.x_ary.x_dimen;
 186               n = dim[0];
 187               for (i = 0; *dim != 0 && i < DIMNUM - 1; i++, dim++)
 188                 *dim = *(dim + 1);
 189               *dim = 0;
 190             }
 191
 192           type = parse_coff_type (abfd, symbols, types, coff_symno, newtype,
 193                                   pauxent, false, dhandle);
 194           type = debug_make_array_type (dhandle, type,
 195                                         parse_coff_base_type (abfd, symbols,
 196                                                               types,
 197                                                               coff_symno,
 198                                                               T_INT,
 199                                                               NULL, dhandle),
 200                                         0, n - 1, false);
 201         }
 202       else
 203         {
 204           non_fatal (_("parse_coff_type: Bad type code 0x%x"), ntype);
 205           return DEBUG_TYPE_NULL;
 206         }
 207
 208       return type;
 209     }
 210
 211   if (pauxent != NULL && pauxent->x_sym.x_tagndx.l > 0)
 212     {
 213       debug_type *slot;
 214
 215       /* This is a reference to an existing type.  FIXME: gdb checks
 216          that the class is not C_STRTAG, nor C_UNTAG, nor C_ENTAG.  */
 217       slot = coff_get_slot (types, pauxent->x_sym.x_tagndx.l);
 218       if (*slot != DEBUG_TYPE_NULL)
 219         return *slot;
 220       else
 221         return debug_make_indirect_type (dhandle, slot, (const char *) NULL);
 222     }
 223
 224   /* If the aux entry has already been used for something, useaux will
 225      have been set to false, indicating that parse_coff_base_type
 226      should not use it.  We need to do it this way, rather than simply
 227      passing pauxent as NULL, because we need to be able handle
 228      multiple array dimensions while still discarding pauxent after
 229      having handled all of them.  */
 230   if (! useaux)
 231     pauxent = NULL;
 232
 233   return parse_coff_base_type (abfd, symbols, types, coff_symno, ntype,
 234                                pauxent, dhandle);
 235 }
 236
 237 /* Parse a basic COFF type in NTYPE.  */
 238
 239 static debug_type
 240 parse_coff_base_type (abfd, symbols, types, coff_symno, ntype, pauxent,
 241                       dhandle)
 242      bfd *abfd;
 243      struct coff_symbols *symbols;
 244      struct coff_types *types;
 245      long coff_symno;
 246      int ntype;
 247      union internal_auxent *pauxent;
 248      PTR dhandle;
 249 {
 250   debug_type ret;
 251   boolean set_basic;
 252   const char *name;
 253   debug_type *slot;
 254
 255   if (ntype >= 0
 256       && ntype <= T_MAX
 257       && types->basic[ntype] != DEBUG_TYPE_NULL)
 258     return types->basic[ntype];
 259
 260   set_basic = true;
 261   name = NULL;
 262
 263   switch (ntype)
 264     {
 265     default:
 266       ret = debug_make_void_type (dhandle);
 267       break;
 268
 269     case T_NULL:
 270     case T_VOID:
 271       ret = debug_make_void_type (dhandle);
 272       name = "void";
 273       break;
 274
 275     case T_CHAR:
 276       ret = debug_make_int_type (dhandle, 1, false);
 277       name = "char";
 278       break;
 279
 280     case T_SHORT:
 281       ret = debug_make_int_type (dhandle, 2, false);
 282       name = "short";
 283       break;
 284
 285     case T_INT:
 286       /* FIXME: Perhaps the size should depend upon the architecture.  */
 287       ret = debug_make_int_type (dhandle, 4, false);
 288       name = "int";
 289       break;
 290
 291     case T_LONG:
 292       ret = debug_make_int_type (dhandle, 4, false);
 293       name = "long";
 294       break;
 295
 296     case T_FLOAT:
 297       ret = debug_make_float_type (dhandle, 4);
 298       name = "float";
 299       break;
 300
 301     case T_DOUBLE:
 302       ret = debug_make_float_type (dhandle, 8);
 303       name = "double";
 304       break;
 305
 306     case T_LNGDBL:
 307       ret = debug_make_float_type (dhandle, 12);
 308       name = "long double";
 309       break;
 310
 311     case T_UCHAR:
 312       ret = debug_make_int_type (dhandle, 1, true);
 313       name = "unsigned char";
 314       break;
 315
 316     case T_USHORT:
 317       ret = debug_make_int_type (dhandle, 2, true);
 318       name = "unsigned short";
 319       break;
 320
 321     case T_UINT:
 322       ret = debug_make_int_type (dhandle, 4, true);
 323       name = "unsigned int";
 324       break;
 325
 326     case T_ULONG:
 327       ret = debug_make_int_type (dhandle, 4, true);
 328       name = "unsigned long";
 329       break;
 330
 331     case T_STRUCT:
 332       if (pauxent == NULL)
 333         ret = debug_make_struct_type (dhandle, true, 0,
 334                                       (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_UNION:
 346       if (pauxent == NULL)
 347         ret = debug_make_struct_type (dhandle, false, 0, (debug_field *) NULL);
 348       else
 349         ret = parse_coff_struct_type (abfd, symbols, types, ntype, pauxent,
 350                                       dhandle);
 351
 352       slot = coff_get_slot (types, coff_symno);
 353       *slot = ret;
 354
 355       set_basic = false;
 356       break;
 357
 358     case T_ENUM:
 359       if (pauxent == NULL)
 360         ret = debug_make_enum_type (dhandle, (const char **) NULL,
 361                                     (bfd_signed_vma *) NULL);
 362       else
 363         ret = parse_coff_enum_type (abfd, symbols, types, pauxent, dhandle);
 364
 365       slot = coff_get_slot (types, coff_symno);
 366       *slot = ret;
 367
 368       set_basic = false;
 369       break;
 370     }
 371
 372   if (name != NULL)
 373     ret = debug_name_type (dhandle, name, ret);
 374
 375   if (set_basic
 376       && ntype >= 0
 377       && ntype <= T_MAX)
 378     types->basic[ntype] = ret;
 379
 380   return ret;
 381 }
 382
 383 /* Parse a struct type.  */
 384
 385 static debug_type
 386 parse_coff_struct_type (abfd, symbols, types, ntype, pauxent, dhandle)
 387      bfd *abfd;
 388      struct coff_symbols *symbols;
 389      struct coff_types *types;
 390      int ntype;
 391      union internal_auxent *pauxent;
 392      PTR dhandle;
 393 {
 394   long symend;
 395   int alloc;
 396   debug_field *fields;
 397   int count;
 398   boolean done;
 399
 400   symend = pauxent->x_sym.x_fcnary.x_fcn.x_endndx.l;
 401
 402   alloc = 10;
 403   fields = (debug_field *) xmalloc (alloc * sizeof *fields);
 404   count = 0;
 405
 406   done = false;
 407   while (! done
 408          && symbols->coff_symno < symend
 409          && symbols->symno < symbols->symcount)
 410     {
 411       asymbol *sym;
 412       long this_coff_symno;
 413       struct internal_syment syment;
 414       union internal_auxent auxent;
 415       union internal_auxent *psubaux;
 416       bfd_vma bitpos = 0, bitsize = 0;
 417
 418       sym = symbols->syms[symbols->symno];
 419
 420       if (! bfd_coff_get_syment (abfd, sym, &syment))
 421         {
 422           non_fatal (_("bfd_coff_get_syment failed: %s"),
 423                      bfd_errmsg (bfd_get_error ()));
 424           return DEBUG_TYPE_NULL;
 425         }
 426
 427       this_coff_symno = symbols->coff_symno;
 428
 429       ++symbols->symno;
 430       symbols->coff_symno += 1 + syment.n_numaux;
 431
 432       if (syment.n_numaux == 0)
 433         psubaux = NULL;
 434       else
 435         {
 436           if (! bfd_coff_get_auxent (abfd, sym, 0, &auxent))
 437             {
 438               non_fatal (_("bfd_coff_get_auxent failed: %s"),
 439                          bfd_errmsg (bfd_get_error ()));
 440               return DEBUG_TYPE_NULL;
 441             }
 442           psubaux = &auxent;
 443         }
 444
 445       switch (syment.n_sclass)
 446         {
 447         case C_MOS:
 448         case C_MOU:
 449           bitpos = 8 * bfd_asymbol_value (sym);
 450           bitsize = 0;
 451           break;
 452
 453         case C_FIELD:
 454           bitpos = bfd_asymbol_value (sym);
 455           bitsize = auxent.x_sym.x_misc.x_lnsz.x_size;
 456           break;
 457
 458         case C_EOS:
 459           done = true;
 460           break;
 461         }
 462
 463       if (! done)
 464         {
 465           debug_type ftype;
 466           debug_field f;
 467
 468           ftype = parse_coff_type (abfd, symbols, types, this_coff_symno,
 469                                    syment.n_type, psubaux, true, dhandle);
 470           f = debug_make_field (dhandle, bfd_asymbol_name (sym), ftype,
 471                                 bitpos, bitsize, DEBUG_VISIBILITY_PUBLIC);
 472           if (f == DEBUG_FIELD_NULL)
 473             return DEBUG_TYPE_NULL;
 474
 475           if (count + 1 >= alloc)
 476             {
 477               alloc += 10;
 478               fields = ((debug_field *)
 479                         xrealloc (fields, alloc * sizeof *fields));
 480             }
 481
 482           fields[count] = f;
 483           ++count;
 484         }
 485     }
 486
 487   fields[count] = DEBUG_FIELD_NULL;
 488
 489   return debug_make_struct_type (dhandle, ntype == T_STRUCT,
 490                                  pauxent->x_sym.x_misc.x_lnsz.x_size,
 491                                  fields);
 492 }
 493
 494 /* Parse an enum type.  */
 495
 496 static debug_type
 497 parse_coff_enum_type (abfd, symbols, types, pauxent, dhandle)
 498      bfd *abfd;
 499      struct coff_symbols *symbols;
 500      struct coff_types *types ATTRIBUTE_UNUSED;
 501      union internal_auxent *pauxent;
 502      PTR dhandle;
 503 {
 504   long symend;
 505   int alloc;
 506   const char **names;
 507   bfd_signed_vma *vals;
 508   int count;
 509   boolean done;
 510
 511   symend = pauxent->x_sym.x_fcnary.x_fcn.x_endndx.l;
 512
 513   alloc = 10;
 514   names = (const char **) xmalloc (alloc * sizeof *names);
 515   vals = (bfd_signed_vma *) xmalloc (alloc * sizeof *vals);
 516   count = 0;
 517
 518   done = false;
 519   while (! done
 520          && symbols->coff_symno < symend
 521          && symbols->symno < symbols->symcount)
 522     {
 523       asymbol *sym;
 524       struct internal_syment syment;
 525
 526       sym = symbols->syms[symbols->symno];
 527
 528       if (! bfd_coff_get_syment (abfd, sym, &syment))
 529         {
 530           non_fatal (_("bfd_coff_get_syment failed: %s"),
 531                      bfd_errmsg (bfd_get_error ()));
 532           return DEBUG_TYPE_NULL;
 533         }
 534
 535       ++symbols->symno;
 536       symbols->coff_symno += 1 + syment.n_numaux;
 537
 538       switch (syment.n_sclass)
 539         {
 540         case C_MOE:
 541           if (count + 1 >= alloc)
 542             {
 543               alloc += 10;
 544               names = ((const char **)
 545                        xrealloc (names, alloc * sizeof *names));
 546               vals = ((bfd_signed_vma *)
 547                       xrealloc (vals, alloc * sizeof *vals));
 548             }
 549
 550           names[count] = bfd_asymbol_name (sym);
 551           vals[count] = bfd_asymbol_value (sym);
 552           ++count;
 553           break;
 554
 555         case C_EOS:
 556           done = true;
 557           break;
 558         }
 559     }
 560
 561   names[count] = NULL;
 562
 563   return debug_make_enum_type (dhandle, names, vals);
 564 }
 565
 566 /* Handle a single COFF symbol.  */
 567
 568 static boolean
 569 parse_coff_symbol (abfd, types, sym, coff_symno, psyment, dhandle, type,
 570                    within_function)
 571      bfd *abfd ATTRIBUTE_UNUSED;
 572      struct coff_types *types;
 573      asymbol *sym;
 574      long coff_symno;
 575      struct internal_syment *psyment;
 576      PTR dhandle;
 577      debug_type type;
 578      boolean within_function;
 579 {
 580   switch (psyment->n_sclass)
 581     {
 582     case C_NULL:
 583       break;
 584
 585     case C_AUTO:
 586       if (! debug_record_variable (dhandle, bfd_asymbol_name (sym), type,
 587                                    DEBUG_LOCAL, bfd_asymbol_value (sym)))
 588         return false;
 589       break;
 590
 591     case C_WEAKEXT:
 592     case C_EXT:
 593       if (! debug_record_variable (dhandle, bfd_asymbol_name (sym), type,
 594                                    DEBUG_GLOBAL, bfd_asymbol_value (sym)))
 595         return false;
 596       break;
 597
 598     case C_STAT:
 599       if (! debug_record_variable (dhandle, bfd_asymbol_name (sym), type,
 600                                    (within_function
 601                                     ? DEBUG_LOCAL_STATIC
 602                                     : DEBUG_STATIC),
 603                                    bfd_asymbol_value (sym)))
 604         return false;
 605       break;
 606
 607     case C_REG:
 608       /* FIXME: We may need to convert the register number.  */
 609       if (! debug_record_variable (dhandle, bfd_asymbol_name (sym), type,
 610                                    DEBUG_REGISTER, bfd_asymbol_value (sym)))
 611         return false;
 612       break;
 613
 614     case C_LABEL:
 615       break;
 616
 617     case C_ARG:
 618       if (! debug_record_parameter (dhandle, bfd_asymbol_name (sym), type,
 619                                     DEBUG_PARM_STACK, bfd_asymbol_value (sym)))
 620         return false;
 621       break;
 622
 623     case C_REGPARM:
 624       /* FIXME: We may need to convert the register number.  */
 625       if (! debug_record_parameter (dhandle, bfd_asymbol_name (sym), type,
 626                                     DEBUG_PARM_REG, bfd_asymbol_value (sym)))
 627         return false;
 628       break;
 629
 630     case C_TPDEF:
 631       type = debug_name_type (dhandle, bfd_asymbol_name (sym), type);
 632       if (type == DEBUG_TYPE_NULL)
 633         return false;
 634       break;
 635
 636     case C_STRTAG:
 637     case C_UNTAG:
 638     case C_ENTAG:
 639       {
 640         debug_type *slot;
 641
 642         type = debug_tag_type (dhandle, bfd_asymbol_name (sym), type);
 643         if (type == DEBUG_TYPE_NULL)
 644           return false;
 645
 646         /* Store the named type into the slot, so that references get
 647            the name.  */
 648         slot = coff_get_slot (types, coff_symno);
 649         *slot = type;
 650       }
 651       break;
 652
 653     default:
 654       break;
 655     }
 656
 657   return true;
 658 }
 659
 660 /* Determine if a symbol has external visibility.  */
 661
 662 static boolean
 663 external_coff_symbol_p (sym_class)
 664      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 }