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 }