1 /* stabs.c -- Parse COFF debugging information 2 Copyright (C) 1996-2016 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 return DEBUG_TYPE_NULL; 413 } 414 415 this_coff_symno = symbols->coff_symno; 416 417 ++symbols->symno; 418 symbols->coff_symno += 1 + syment.n_numaux; 419 420 if (syment.n_numaux == 0) 421 psubaux = NULL; 422 else 423 { 424 if (! bfd_coff_get_auxent (abfd, sym, 0, &auxent)) 425 { 426 non_fatal (_("bfd_coff_get_auxent failed: %s"), 427 bfd_errmsg (bfd_get_error ())); 428 return DEBUG_TYPE_NULL; 429 } 430 psubaux = &auxent; 431 } 432 433 switch (syment.n_sclass) 434 { 435 case C_MOS: 436 case C_MOU: 437 bitpos = 8 * bfd_asymbol_value (sym); 438 bitsize = 0; 439 break; 440 441 case C_FIELD: 442 bitpos = bfd_asymbol_value (sym); 443 bitsize = auxent.x_sym.x_misc.x_lnsz.x_size; 444 break; 445 446 case C_EOS: 447 done = TRUE; 448 break; 449 } 450 451 if (! done) 452 { 453 debug_type ftype; 454 debug_field f; 455 456 ftype = parse_coff_type (abfd, symbols, types, this_coff_symno, 457 syment.n_type, psubaux, TRUE, dhandle); 458 f = debug_make_field (dhandle, bfd_asymbol_name (sym), ftype, 459 bitpos, bitsize, DEBUG_VISIBILITY_PUBLIC); 460 if (f == DEBUG_FIELD_NULL) 461 return DEBUG_TYPE_NULL; 462 463 if (count + 1 >= alloc) 464 { 465 alloc += 10; 466 fields = ((debug_field *) 467 xrealloc (fields, alloc * sizeof *fields)); 468 } 469 470 fields[count] = f; 471 ++count; 472 } 473 } 474 475 fields[count] = DEBUG_FIELD_NULL; 476 477 return debug_make_struct_type (dhandle, ntype == T_STRUCT, 478 pauxent->x_sym.x_misc.x_lnsz.x_size, 479 fields); 480 } 481 482 /* Parse an enum type. */ 483 484 static debug_type 485 parse_coff_enum_type (bfd *abfd, struct coff_symbols *symbols, 486 struct coff_types *types ATTRIBUTE_UNUSED, 487 union internal_auxent *pauxent, void *dhandle) 488 { 489 long symend; 490 int alloc; 491 const char **names; 492 bfd_signed_vma *vals; 493 int count; 494 bfd_boolean done; 495 496 symend = pauxent->x_sym.x_fcnary.x_fcn.x_endndx.l; 497 498 alloc = 10; 499 names = (const char **) xmalloc (alloc * sizeof *names); 500 vals = (bfd_signed_vma *) xmalloc (alloc * sizeof *vals); 501 count = 0; 502 503 done = FALSE; 504 while (! done 505 && symbols->coff_symno < symend 506 && symbols->symno < symbols->symcount) 507 { 508 asymbol *sym; 509 struct internal_syment syment; 510 511 sym = symbols->syms[symbols->symno]; 512 513 if (! bfd_coff_get_syment (abfd, sym, &syment)) 514 { 515 non_fatal (_("bfd_coff_get_syment failed: %s"), 516 bfd_errmsg (bfd_get_error ())); 517 return DEBUG_TYPE_NULL; 518 } 519 520 ++symbols->symno; 521 symbols->coff_symno += 1 + syment.n_numaux; 522 523 switch (syment.n_sclass) 524 { 525 case C_MOE: 526 if (count + 1 >= alloc) 527 { 528 alloc += 10; 529 names = ((const char **) 530 xrealloc (names, alloc * sizeof *names)); 531 vals = ((bfd_signed_vma *) 532 xrealloc (vals, alloc * sizeof *vals)); 533 } 534 535 names[count] = bfd_asymbol_name (sym); 536 vals[count] = bfd_asymbol_value (sym); 537 ++count; 538 break; 539 540 case C_EOS: 541 done = TRUE; 542 break; 543 } 544 } 545 546 names[count] = NULL; 547 548 return debug_make_enum_type (dhandle, names, vals); 549 } 550 551 /* Handle a single COFF symbol. */ 552 553 static bfd_boolean 554 parse_coff_symbol (bfd *abfd ATTRIBUTE_UNUSED, struct coff_types *types, 555 asymbol *sym, long coff_symno, 556 struct internal_syment *psyment, void *dhandle, 557 debug_type type, bfd_boolean within_function) 558 { 559 switch (psyment->n_sclass) 560 { 561 case C_NULL: 562 break; 563 564 case C_AUTO: 565 if (! debug_record_variable (dhandle, bfd_asymbol_name (sym), type, 566 DEBUG_LOCAL, bfd_asymbol_value (sym))) 567 return FALSE; 568 break; 569 570 case C_WEAKEXT: 571 case C_EXT: 572 if (! debug_record_variable (dhandle, bfd_asymbol_name (sym), type, 573 DEBUG_GLOBAL, bfd_asymbol_value (sym))) 574 return FALSE; 575 break; 576 577 case C_STAT: 578 if (! debug_record_variable (dhandle, bfd_asymbol_name (sym), type, 579 (within_function 580 ? DEBUG_LOCAL_STATIC 581 : DEBUG_STATIC), 582 bfd_asymbol_value (sym))) 583 return FALSE; 584 break; 585 586 case C_REG: 587 /* FIXME: We may need to convert the register number. */ 588 if (! debug_record_variable (dhandle, bfd_asymbol_name (sym), type, 589 DEBUG_REGISTER, bfd_asymbol_value (sym))) 590 return FALSE; 591 break; 592 593 case C_LABEL: 594 break; 595 596 case C_ARG: 597 if (! debug_record_parameter (dhandle, bfd_asymbol_name (sym), type, 598 DEBUG_PARM_STACK, bfd_asymbol_value (sym))) 599 return FALSE; 600 break; 601 602 case C_REGPARM: 603 /* FIXME: We may need to convert the register number. */ 604 if (! debug_record_parameter (dhandle, bfd_asymbol_name (sym), type, 605 DEBUG_PARM_REG, bfd_asymbol_value (sym))) 606 return FALSE; 607 break; 608 609 case C_TPDEF: 610 type = debug_name_type (dhandle, bfd_asymbol_name (sym), type); 611 if (type == DEBUG_TYPE_NULL) 612 return FALSE; 613 break; 614 615 case C_STRTAG: 616 case C_UNTAG: 617 case C_ENTAG: 618 { 619 debug_type *slot; 620 621 type = debug_tag_type (dhandle, bfd_asymbol_name (sym), type); 622 if (type == DEBUG_TYPE_NULL) 623 return FALSE; 624 625 /* Store the named type into the slot, so that references get 626 the name. */ 627 slot = coff_get_slot (types, coff_symno); 628 *slot = type; 629 } 630 break; 631 632 default: 633 break; 634 } 635 636 return TRUE; 637 } 638 639 /* Determine if a symbol has external visibility. */ 640 641 static bfd_boolean 642 external_coff_symbol_p (int sym_class) 643 { 644 switch (sym_class) 645 { 646 case C_EXT: 647 case C_WEAKEXT: 648 return TRUE; 649 default: 650 break; 651 } 652 return FALSE; 653 } 654 655 /* This is the main routine. It looks through all the symbols and 656 handles them. */ 657 658 bfd_boolean 659 parse_coff (bfd *abfd, asymbol **syms, long symcount, void *dhandle) 660 { 661 struct coff_symbols symbols; 662 struct coff_types types; 663 int i; 664 long next_c_file; 665 const char *fnname; 666 int fnclass; 667 int fntype; 668 bfd_vma fnend; 669 alent *linenos; 670 bfd_boolean within_function; 671 long this_coff_symno; 672 673 symbols.syms = syms; 674 symbols.symcount = symcount; 675 symbols.symno = 0; 676 symbols.coff_symno = 0; 677 678 types.slots = NULL; 679 for (i = 0; i <= T_MAX; i++) 680 types.basic[i] = DEBUG_TYPE_NULL; 681 682 next_c_file = -1; 683 fnname = NULL; 684 fnclass = 0; 685 fntype = 0; 686 fnend = 0; 687 linenos = NULL; 688 within_function = FALSE; 689 690 while (symbols.symno < symcount) 691 { 692 asymbol *sym; 693 const char *name; 694 struct internal_syment syment; 695 union internal_auxent auxent; 696 union internal_auxent *paux; 697 debug_type type; 698 699 sym = syms[symbols.symno]; 700 701 if (! bfd_coff_get_syment (abfd, sym, &syment)) 702 { 703 non_fatal (_("bfd_coff_get_syment failed: %s"), 704 bfd_errmsg (bfd_get_error ())); 705 return FALSE; 706 } 707 708 name = bfd_asymbol_name (sym); 709 710 this_coff_symno = symbols.coff_symno; 711 712 ++symbols.symno; 713 symbols.coff_symno += 1 + syment.n_numaux; 714 715 /* We only worry about the first auxent, because that is the 716 only one which is relevant for debugging information. */ 717 if (syment.n_numaux == 0) 718 paux = NULL; 719 else 720 { 721 if (! bfd_coff_get_auxent (abfd, sym, 0, &auxent)) 722 { 723 non_fatal (_("bfd_coff_get_auxent failed: %s"), 724 bfd_errmsg (bfd_get_error ())); 725 return FALSE; 726 } 727 paux = &auxent; 728 } 729 730 if (this_coff_symno == next_c_file && syment.n_sclass != C_FILE) 731 { 732 /* The last C_FILE symbol points to the first external 733 symbol. */ 734 if (! debug_set_filename (dhandle, "*globals*")) 735 return FALSE; 736 } 737 738 switch (syment.n_sclass) 739 { 740 case C_EFCN: 741 case C_EXTDEF: 742 case C_ULABEL: 743 case C_USTATIC: 744 case C_LINE: 745 case C_ALIAS: 746 case C_HIDDEN: 747 /* Just ignore these classes. */ 748 break; 749 750 case C_FILE: 751 next_c_file = syment.n_value; 752 if (! debug_set_filename (dhandle, name)) 753 return FALSE; 754 break; 755 756 case C_STAT: 757 /* Ignore static symbols with a type of T_NULL. These 758 represent section entries. */ 759 if (syment.n_type == T_NULL) 760 break; 761 /* Fall through. */ 762 case C_WEAKEXT: 763 case C_EXT: 764 if (ISFCN (syment.n_type)) 765 { 766 fnname = name; 767 fnclass = syment.n_sclass; 768 fntype = syment.n_type; 769 if (syment.n_numaux > 0) 770 fnend = bfd_asymbol_value (sym) + auxent.x_sym.x_misc.x_fsize; 771 else 772 fnend = 0; 773 linenos = BFD_SEND (abfd, _get_lineno, (abfd, sym)); 774 break; 775 } 776 type = parse_coff_type (abfd, &symbols, &types, this_coff_symno, 777 syment.n_type, paux, TRUE, dhandle); 778 if (type == DEBUG_TYPE_NULL) 779 return FALSE; 780 if (! parse_coff_symbol (abfd, &types, sym, this_coff_symno, &syment, 781 dhandle, type, within_function)) 782 return FALSE; 783 break; 784 785 case C_FCN: 786 if (strcmp (name, ".bf") == 0) 787 { 788 if (fnname == NULL) 789 { 790 non_fatal (_("%ld: .bf without preceding function"), 791 this_coff_symno); 792 return FALSE; 793 } 794 795 type = parse_coff_type (abfd, &symbols, &types, this_coff_symno, 796 DECREF (fntype), paux, FALSE, dhandle); 797 if (type == DEBUG_TYPE_NULL) 798 return FALSE; 799 800 if (! debug_record_function (dhandle, fnname, type, 801 external_coff_symbol_p (fnclass), 802 bfd_asymbol_value (sym))) 803 return FALSE; 804 805 if (linenos != NULL) 806 { 807 int base; 808 bfd_vma addr; 809 810 if (syment.n_numaux == 0) 811 base = 0; 812 else 813 base = auxent.x_sym.x_misc.x_lnsz.x_lnno - 1; 814 815 addr = bfd_get_section_vma (abfd, bfd_get_section (sym)); 816 817 ++linenos; 818 819 while (linenos->line_number != 0) 820 { 821 if (! debug_record_line (dhandle, 822 linenos->line_number + base, 823 linenos->u.offset + addr)) 824 return FALSE; 825 ++linenos; 826 } 827 } 828 829 fnname = NULL; 830 linenos = NULL; 831 fnclass = 0; 832 fntype = 0; 833 834 within_function = TRUE; 835 } 836 else if (strcmp (name, ".ef") == 0) 837 { 838 if (! within_function) 839 { 840 non_fatal (_("%ld: unexpected .ef\n"), this_coff_symno); 841 return FALSE; 842 } 843 844 if (bfd_asymbol_value (sym) > fnend) 845 fnend = bfd_asymbol_value (sym); 846 if (! debug_end_function (dhandle, fnend)) 847 return FALSE; 848 849 fnend = 0; 850 within_function = FALSE; 851 } 852 break; 853 854 case C_BLOCK: 855 if (strcmp (name, ".bb") == 0) 856 { 857 if (! debug_start_block (dhandle, bfd_asymbol_value (sym))) 858 return FALSE; 859 } 860 else if (strcmp (name, ".eb") == 0) 861 { 862 if (! debug_end_block (dhandle, bfd_asymbol_value (sym))) 863 return FALSE; 864 } 865 break; 866 867 default: 868 type = parse_coff_type (abfd, &symbols, &types, this_coff_symno, 869 syment.n_type, paux, TRUE, dhandle); 870 if (type == DEBUG_TYPE_NULL) 871 return FALSE; 872 if (! parse_coff_symbol (abfd, &types, sym, this_coff_symno, &syment, 873 dhandle, type, within_function)) 874 return FALSE; 875 break; 876 } 877 } 878 879 return TRUE; 880 } 881