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