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