binutils/rdcoff.c

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