binutils/rdcoff.c

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