1 /* stabs.c -- Parse stabs debugging information 2 Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 3 2006, 2007 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 stabs debugging information. 24 The organization of this code is based on the gdb stabs reading 25 code. The job it does is somewhat different, because it is not 26 trying to identify the correct address for anything. */ 27 28 #include "sysdep.h" 29 #include "bfd.h" 30 #include "libiberty.h" 31 #include "safe-ctype.h" 32 #include "demangle.h" 33 #include "debug.h" 34 #include "budbg.h" 35 #include "filenames.h" 36 #include "aout/aout64.h" 37 #include "aout/stab_gnu.h" 38 39 /* The number of predefined XCOFF types. */ 40 41 #define XCOFF_TYPE_COUNT 34 42 43 /* This structure is used as a handle so that the stab parsing doesn't 44 need to use any static variables. */ 45 46 struct stab_handle 47 { 48 /* The BFD. */ 49 bfd *abfd; 50 /* TRUE if this is stabs in sections. */ 51 bfd_boolean sections; 52 /* The symbol table. */ 53 asymbol **syms; 54 /* The number of symbols. */ 55 long symcount; 56 /* The accumulated file name string. */ 57 char *so_string; 58 /* The value of the last N_SO symbol. */ 59 bfd_vma so_value; 60 /* The value of the start of the file, so that we can handle file 61 relative N_LBRAC and N_RBRAC symbols. */ 62 bfd_vma file_start_offset; 63 /* The offset of the start of the function, so that we can handle 64 function relative N_LBRAC and N_RBRAC symbols. */ 65 bfd_vma function_start_offset; 66 /* The version number of gcc which compiled the current compilation 67 unit, 0 if not compiled by gcc. */ 68 int gcc_compiled; 69 /* Whether an N_OPT symbol was seen that was not generated by gcc, 70 so that we can detect the SunPRO compiler. */ 71 bfd_boolean n_opt_found; 72 /* The main file name. */ 73 char *main_filename; 74 /* A stack of unfinished N_BINCL files. */ 75 struct bincl_file *bincl_stack; 76 /* A list of finished N_BINCL files. */ 77 struct bincl_file *bincl_list; 78 /* Whether we are inside a function or not. */ 79 bfd_boolean within_function; 80 /* The address of the end of the function, used if we have seen an 81 N_FUN symbol while in a function. This is -1 if we have not seen 82 an N_FUN (the normal case). */ 83 bfd_vma function_end; 84 /* The depth of block nesting. */ 85 int block_depth; 86 /* List of pending variable definitions. */ 87 struct stab_pending_var *pending; 88 /* Number of files for which we have types. */ 89 unsigned int files; 90 /* Lists of types per file. */ 91 struct stab_types **file_types; 92 /* Predefined XCOFF types. */ 93 debug_type xcoff_types[XCOFF_TYPE_COUNT]; 94 /* Undefined tags. */ 95 struct stab_tag *tags; 96 /* Set by parse_stab_type if it sees a structure defined as a cross 97 reference to itself. Reset by parse_stab_type otherwise. */ 98 bfd_boolean self_crossref; 99 }; 100 101 /* A list of these structures is used to hold pending variable 102 definitions seen before the N_LBRAC of a block. */ 103 104 struct stab_pending_var 105 { 106 /* Next pending variable definition. */ 107 struct stab_pending_var *next; 108 /* Name. */ 109 const char *name; 110 /* Type. */ 111 debug_type type; 112 /* Kind. */ 113 enum debug_var_kind kind; 114 /* Value. */ 115 bfd_vma val; 116 }; 117 118 /* A list of these structures is used to hold the types for a single 119 file. */ 120 121 struct stab_types 122 { 123 /* Next set of slots for this file. */ 124 struct stab_types *next; 125 /* Types indexed by type number. */ 126 #define STAB_TYPES_SLOTS (16) 127 debug_type types[STAB_TYPES_SLOTS]; 128 }; 129 130 /* We keep a list of undefined tags that we encounter, so that we can 131 fill them in if the tag is later defined. */ 132 133 struct stab_tag 134 { 135 /* Next undefined tag. */ 136 struct stab_tag *next; 137 /* Tag name. */ 138 const char *name; 139 /* Type kind. */ 140 enum debug_type_kind kind; 141 /* Slot to hold real type when we discover it. If we don't, we fill 142 in an undefined tag type. */ 143 debug_type slot; 144 /* Indirect type we have created to point at slot. */ 145 debug_type type; 146 }; 147 148 static char *savestring (const char *, int); 149 static bfd_vma parse_number (const char **, bfd_boolean *); 150 static void bad_stab (const char *); 151 static void warn_stab (const char *, const char *); 152 static bfd_boolean parse_stab_string 153 (void *, struct stab_handle *, int, int, bfd_vma, const char *); 154 static debug_type parse_stab_type 155 (void *, struct stab_handle *, const char *, const char **, debug_type **); 156 static bfd_boolean parse_stab_type_number (const char **, int *); 157 static debug_type parse_stab_range_type 158 (void *, struct stab_handle *, const char *, const char **, const int *); 159 static debug_type parse_stab_sun_builtin_type (void *, const char **); 160 static debug_type parse_stab_sun_floating_type (void *, const char **); 161 static debug_type parse_stab_enum_type (void *, const char **); 162 static debug_type parse_stab_struct_type 163 (void *, struct stab_handle *, const char *, const char **, 164 bfd_boolean, const int *); 165 static bfd_boolean parse_stab_baseclasses 166 (void *, struct stab_handle *, const char **, debug_baseclass **); 167 static bfd_boolean parse_stab_struct_fields 168 (void *, struct stab_handle *, const char **, debug_field **, bfd_boolean *); 169 static bfd_boolean parse_stab_cpp_abbrev 170 (void *, struct stab_handle *, const char **, debug_field *); 171 static bfd_boolean parse_stab_one_struct_field 172 (void *, struct stab_handle *, const char **, const char *, 173 debug_field *, bfd_boolean *); 174 static bfd_boolean parse_stab_members 175 (void *, struct stab_handle *, const char *, const char **, const int *, 176 debug_method **); 177 static debug_type parse_stab_argtypes 178 (void *, struct stab_handle *, debug_type, const char *, const char *, 179 debug_type, const char *, bfd_boolean, bfd_boolean, const char **); 180 static bfd_boolean parse_stab_tilde_field 181 (void *, struct stab_handle *, const char **, const int *, debug_type *, 182 bfd_boolean *); 183 static debug_type parse_stab_array_type 184 (void *, struct stab_handle *, const char **, bfd_boolean); 185 static void push_bincl (struct stab_handle *, const char *, bfd_vma); 186 static const char *pop_bincl (struct stab_handle *); 187 static bfd_boolean find_excl (struct stab_handle *, const char *, bfd_vma); 188 static bfd_boolean stab_record_variable 189 (void *, struct stab_handle *, const char *, debug_type, 190 enum debug_var_kind, bfd_vma); 191 static bfd_boolean stab_emit_pending_vars (void *, struct stab_handle *); 192 static debug_type *stab_find_slot (struct stab_handle *, const int *); 193 static debug_type stab_find_type (void *, struct stab_handle *, const int *); 194 static bfd_boolean stab_record_type 195 (void *, struct stab_handle *, const int *, debug_type); 196 static debug_type stab_xcoff_builtin_type 197 (void *, struct stab_handle *, int); 198 static debug_type stab_find_tagged_type 199 (void *, struct stab_handle *, const char *, int, enum debug_type_kind); 200 static debug_type *stab_demangle_argtypes 201 (void *, struct stab_handle *, const char *, bfd_boolean *, unsigned int); 202 static debug_type *stab_demangle_v3_argtypes 203 (void *, struct stab_handle *, const char *, bfd_boolean *); 204 static debug_type *stab_demangle_v3_arglist 205 (void *, struct stab_handle *, struct demangle_component *, bfd_boolean *); 206 static debug_type stab_demangle_v3_arg 207 (void *, struct stab_handle *, struct demangle_component *, debug_type, 208 bfd_boolean *); 209 210 /* Save a string in memory. */ 211 212 static char * 213 savestring (const char *start, int len) 214 { 215 char *ret; 216 217 ret = (char *) xmalloc (len + 1); 218 memcpy (ret, start, len); 219 ret[len] = '\0'; 220 return ret; 221 } 222 223 /* Read a number from a string. */ 224 225 static bfd_vma 226 parse_number (const char **pp, bfd_boolean *poverflow) 227 { 228 unsigned long ul; 229 const char *orig; 230 231 if (poverflow != NULL) 232 *poverflow = FALSE; 233 234 orig = *pp; 235 236 errno = 0; 237 ul = strtoul (*pp, (char **) pp, 0); 238 if (ul + 1 != 0 || errno == 0) 239 { 240 /* If bfd_vma is larger than unsigned long, and the number is 241 meant to be negative, we have to make sure that we sign 242 extend properly. */ 243 if (*orig == '-') 244 return (bfd_vma) (bfd_signed_vma) (long) ul; 245 return (bfd_vma) ul; 246 } 247 248 /* Note that even though strtoul overflowed, it should have set *pp 249 to the end of the number, which is where we want it. */ 250 if (sizeof (bfd_vma) > sizeof (unsigned long)) 251 { 252 const char *p; 253 bfd_boolean neg; 254 int base; 255 bfd_vma over, lastdig; 256 bfd_boolean overflow; 257 bfd_vma v; 258 259 /* Our own version of strtoul, for a bfd_vma. */ 260 p = orig; 261 262 neg = FALSE; 263 if (*p == '+') 264 ++p; 265 else if (*p == '-') 266 { 267 neg = TRUE; 268 ++p; 269 } 270 271 base = 10; 272 if (*p == '0') 273 { 274 if (p[1] == 'x' || p[1] == 'X') 275 { 276 base = 16; 277 p += 2; 278 } 279 else 280 { 281 base = 8; 282 ++p; 283 } 284 } 285 286 over = ((bfd_vma) (bfd_signed_vma) -1) / (bfd_vma) base; 287 lastdig = ((bfd_vma) (bfd_signed_vma) -1) % (bfd_vma) base; 288 289 overflow = FALSE; 290 v = 0; 291 while (1) 292 { 293 int d; 294 295 d = *p++; 296 if (ISDIGIT (d)) 297 d -= '0'; 298 else if (ISUPPER (d)) 299 d -= 'A'; 300 else if (ISLOWER (d)) 301 d -= 'a'; 302 else 303 break; 304 305 if (d >= base) 306 break; 307 308 if (v > over || (v == over && (bfd_vma) d > lastdig)) 309 { 310 overflow = TRUE; 311 break; 312 } 313 } 314 315 if (! overflow) 316 { 317 if (neg) 318 v = - v; 319 return v; 320 } 321 } 322 323 /* If we get here, the number is too large to represent in a 324 bfd_vma. */ 325 if (poverflow != NULL) 326 *poverflow = TRUE; 327 else 328 warn_stab (orig, _("numeric overflow")); 329 330 return 0; 331 } 332 333 /* Give an error for a bad stab string. */ 334 335 static void 336 bad_stab (const char *p) 337 { 338 fprintf (stderr, _("Bad stab: %s\n"), p); 339 } 340 341 /* Warn about something in a stab string. */ 342 343 static void 344 warn_stab (const char *p, const char *err) 345 { 346 fprintf (stderr, _("Warning: %s: %s\n"), err, p); 347 } 348 349 /* Create a handle to parse stabs symbols with. */ 350 351 void * 352 start_stab (void *dhandle ATTRIBUTE_UNUSED, bfd *abfd, bfd_boolean sections, 353 asymbol **syms, long symcount) 354 { 355 struct stab_handle *ret; 356 357 ret = (struct stab_handle *) xmalloc (sizeof *ret); 358 memset (ret, 0, sizeof *ret); 359 ret->abfd = abfd; 360 ret->sections = sections; 361 ret->syms = syms; 362 ret->symcount = symcount; 363 ret->files = 1; 364 ret->file_types = (struct stab_types **) xmalloc (sizeof *ret->file_types); 365 ret->file_types[0] = NULL; 366 ret->function_end = (bfd_vma) -1; 367 return (void *) ret; 368 } 369 370 /* When we have processed all the stabs information, we need to go 371 through and fill in all the undefined tags. */ 372 373 bfd_boolean 374 finish_stab (void *dhandle, void *handle) 375 { 376 struct stab_handle *info = (struct stab_handle *) handle; 377 struct stab_tag *st; 378 379 if (info->within_function) 380 { 381 if (! stab_emit_pending_vars (dhandle, info) 382 || ! debug_end_function (dhandle, info->function_end)) 383 return FALSE; 384 info->within_function = FALSE; 385 info->function_end = (bfd_vma) -1; 386 } 387 388 for (st = info->tags; st != NULL; st = st->next) 389 { 390 enum debug_type_kind kind; 391 392 kind = st->kind; 393 if (kind == DEBUG_KIND_ILLEGAL) 394 kind = DEBUG_KIND_STRUCT; 395 st->slot = debug_make_undefined_tagged_type (dhandle, st->name, kind); 396 if (st->slot == DEBUG_TYPE_NULL) 397 return FALSE; 398 } 399 400 return TRUE; 401 } 402 403 /* Handle a single stabs symbol. */ 404 405 bfd_boolean 406 parse_stab (void *dhandle, void *handle, int type, int desc, bfd_vma value, 407 const char *string) 408 { 409 struct stab_handle *info = (struct stab_handle *) handle; 410 411 /* gcc will emit two N_SO strings per compilation unit, one for the 412 directory name and one for the file name. We just collect N_SO 413 strings as we see them, and start the new compilation unit when 414 we see a non N_SO symbol. */ 415 if (info->so_string != NULL 416 && (type != N_SO || *string == '\0' || value != info->so_value)) 417 { 418 if (! debug_set_filename (dhandle, info->so_string)) 419 return FALSE; 420 info->main_filename = info->so_string; 421 422 info->gcc_compiled = 0; 423 info->n_opt_found = FALSE; 424 425 /* Generally, for stabs in the symbol table, the N_LBRAC and 426 N_RBRAC symbols are relative to the N_SO symbol value. */ 427 if (! info->sections) 428 info->file_start_offset = info->so_value; 429 430 /* We need to reset the mapping from type numbers to types. We 431 can't free the old mapping, because of the use of 432 debug_make_indirect_type. */ 433 info->files = 1; 434 info->file_types = ((struct stab_types **) 435 xmalloc (sizeof *info->file_types)); 436 info->file_types[0] = NULL; 437 438 info->so_string = NULL; 439 440 /* Now process whatever type we just got. */ 441 } 442 443 switch (type) 444 { 445 case N_FN: 446 case N_FN_SEQ: 447 break; 448 449 case N_LBRAC: 450 /* Ignore extra outermost context from SunPRO cc and acc. */ 451 if (info->n_opt_found && desc == 1) 452 break; 453 454 if (! info->within_function) 455 { 456 fprintf (stderr, _("N_LBRAC not within function\n")); 457 return FALSE; 458 } 459 460 /* Start an inner lexical block. */ 461 if (! debug_start_block (dhandle, 462 (value 463 + info->file_start_offset 464 + info->function_start_offset))) 465 return FALSE; 466 467 /* Emit any pending variable definitions. */ 468 if (! stab_emit_pending_vars (dhandle, info)) 469 return FALSE; 470 471 ++info->block_depth; 472 break; 473 474 case N_RBRAC: 475 /* Ignore extra outermost context from SunPRO cc and acc. */ 476 if (info->n_opt_found && desc == 1) 477 break; 478 479 /* We shouldn't have any pending variable definitions here, but, 480 if we do, we probably need to emit them before closing the 481 block. */ 482 if (! stab_emit_pending_vars (dhandle, info)) 483 return FALSE; 484 485 /* End an inner lexical block. */ 486 if (! debug_end_block (dhandle, 487 (value 488 + info->file_start_offset 489 + info->function_start_offset))) 490 return FALSE; 491 492 --info->block_depth; 493 if (info->block_depth < 0) 494 { 495 fprintf (stderr, _("Too many N_RBRACs\n")); 496 return FALSE; 497 } 498 break; 499 500 case N_SO: 501 /* This always ends a function. */ 502 if (info->within_function) 503 { 504 bfd_vma endval; 505 506 endval = value; 507 if (*string != '\0' 508 && info->function_end != (bfd_vma) -1 509 && info->function_end < endval) 510 endval = info->function_end; 511 if (! stab_emit_pending_vars (dhandle, info) 512 || ! debug_end_function (dhandle, endval)) 513 return FALSE; 514 info->within_function = FALSE; 515 info->function_end = (bfd_vma) -1; 516 } 517 518 /* An empty string is emitted by gcc at the end of a compilation 519 unit. */ 520 if (*string == '\0') 521 return TRUE; 522 523 /* Just accumulate strings until we see a non N_SO symbol. If 524 the string starts with a directory separator or some other 525 form of absolute path specification, we discard the previously 526 accumulated strings. */ 527 if (info->so_string == NULL) 528 info->so_string = xstrdup (string); 529 else 530 { 531 char *f; 532 533 f = info->so_string; 534 535 if (IS_ABSOLUTE_PATH (string)) 536 info->so_string = xstrdup (string); 537 else 538 info->so_string = concat (info->so_string, string, 539 (const char *) NULL); 540 free (f); 541 } 542 543 info->so_value = value; 544 545 break; 546 547 case N_SOL: 548 /* Start an include file. */ 549 if (! debug_start_source (dhandle, string)) 550 return FALSE; 551 break; 552 553 case N_BINCL: 554 /* Start an include file which may be replaced. */ 555 push_bincl (info, string, value); 556 if (! debug_start_source (dhandle, string)) 557 return FALSE; 558 break; 559 560 case N_EINCL: 561 /* End an N_BINCL include. */ 562 if (! debug_start_source (dhandle, pop_bincl (info))) 563 return FALSE; 564 break; 565 566 case N_EXCL: 567 /* This is a duplicate of a header file named by N_BINCL which 568 was eliminated by the linker. */ 569 if (! find_excl (info, string, value)) 570 return FALSE; 571 break; 572 573 case N_SLINE: 574 if (! debug_record_line (dhandle, desc, 575 value + (info->within_function 576 ? info->function_start_offset : 0))) 577 return FALSE; 578 break; 579 580 case N_BCOMM: 581 if (! debug_start_common_block (dhandle, string)) 582 return FALSE; 583 break; 584 585 case N_ECOMM: 586 if (! debug_end_common_block (dhandle, string)) 587 return FALSE; 588 break; 589 590 case N_FUN: 591 if (*string == '\0') 592 { 593 if (info->within_function) 594 { 595 /* This always marks the end of a function; we don't 596 need to worry about info->function_end. */ 597 if (info->sections) 598 value += info->function_start_offset; 599 if (! stab_emit_pending_vars (dhandle, info) 600 || ! debug_end_function (dhandle, value)) 601 return FALSE; 602 info->within_function = FALSE; 603 info->function_end = (bfd_vma) -1; 604 } 605 break; 606 } 607 608 /* A const static symbol in the .text section will have an N_FUN 609 entry. We need to use these to mark the end of the function, 610 in case we are looking at gcc output before it was changed to 611 always emit an empty N_FUN. We can't call debug_end_function 612 here, because it might be a local static symbol. */ 613 if (info->within_function 614 && (info->function_end == (bfd_vma) -1 615 || value < info->function_end)) 616 info->function_end = value; 617 618 /* Fall through. */ 619 /* FIXME: gdb checks the string for N_STSYM, N_LCSYM or N_ROSYM 620 symbols, and if it does not start with :S, gdb relocates the 621 value to the start of the section. gcc always seems to use 622 :S, so we don't worry about this. */ 623 /* Fall through. */ 624 default: 625 { 626 const char *colon; 627 628 colon = strchr (string, ':'); 629 if (colon != NULL 630 && (colon[1] == 'f' || colon[1] == 'F')) 631 { 632 if (info->within_function) 633 { 634 bfd_vma endval; 635 636 endval = value; 637 if (info->function_end != (bfd_vma) -1 638 && info->function_end < endval) 639 endval = info->function_end; 640 if (! stab_emit_pending_vars (dhandle, info) 641 || ! debug_end_function (dhandle, endval)) 642 return FALSE; 643 info->function_end = (bfd_vma) -1; 644 } 645 /* For stabs in sections, line numbers and block addresses 646 are offsets from the start of the function. */ 647 if (info->sections) 648 info->function_start_offset = value; 649 info->within_function = TRUE; 650 } 651 652 if (! parse_stab_string (dhandle, info, type, desc, value, string)) 653 return FALSE; 654 } 655 break; 656 657 case N_OPT: 658 if (string != NULL && strcmp (string, "gcc2_compiled.") == 0) 659 info->gcc_compiled = 2; 660 else if (string != NULL && strcmp (string, "gcc_compiled.") == 0) 661 info->gcc_compiled = 1; 662 else 663 info->n_opt_found = TRUE; 664 break; 665 666 case N_OBJ: 667 case N_ENDM: 668 case N_MAIN: 669 case N_WARNING: 670 break; 671 } 672 673 return TRUE; 674 } 675 676 /* Parse the stabs string. */ 677 678 static bfd_boolean 679 parse_stab_string (void *dhandle, struct stab_handle *info, int stabtype, 680 int desc, bfd_vma value, const char *string) 681 { 682 const char *p; 683 char *name; 684 int type; 685 debug_type dtype; 686 bfd_boolean synonym; 687 bfd_boolean self_crossref; 688 unsigned int lineno; 689 debug_type *slot; 690 691 p = strchr (string, ':'); 692 if (p == NULL) 693 return TRUE; 694 695 while (p[1] == ':') 696 { 697 p += 2; 698 p = strchr (p, ':'); 699 if (p == NULL) 700 { 701 bad_stab (string); 702 return FALSE; 703 } 704 } 705 706 /* GCC 2.x puts the line number in desc. SunOS apparently puts in 707 the number of bytes occupied by a type or object, which we 708 ignore. */ 709 if (info->gcc_compiled >= 2) 710 lineno = desc; 711 else 712 lineno = 0; 713 714 /* FIXME: Sometimes the special C++ names start with '.'. */ 715 name = NULL; 716 if (string[0] == '$') 717 { 718 switch (string[1]) 719 { 720 case 't': 721 name = "this"; 722 break; 723 case 'v': 724 /* Was: name = "vptr"; */ 725 break; 726 case 'e': 727 name = "eh_throw"; 728 break; 729 case '_': 730 /* This was an anonymous type that was never fixed up. */ 731 break; 732 case 'X': 733 /* SunPRO (3.0 at least) static variable encoding. */ 734 break; 735 default: 736 warn_stab (string, _("unknown C++ encoded name")); 737 break; 738 } 739 } 740 741 if (name == NULL) 742 { 743 if (p == string || (string[0] == ' ' && p == string + 1)) 744 name = NULL; 745 else 746 name = savestring (string, p - string); 747 } 748 749 ++p; 750 if (ISDIGIT (*p) || *p == '(' || *p == '-') 751 type = 'l'; 752 else 753 type = *p++; 754 755 switch (type) 756 { 757 case 'c': 758 /* c is a special case, not followed by a type-number. 759 SYMBOL:c=iVALUE for an integer constant symbol. 760 SYMBOL:c=rVALUE for a floating constant symbol. 761 SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol. 762 e.g. "b:c=e6,0" for "const b = blob1" 763 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */ 764 if (*p != '=') 765 { 766 bad_stab (string); 767 return FALSE; 768 } 769 ++p; 770 switch (*p++) 771 { 772 case 'r': 773 /* Floating point constant. */ 774 if (! debug_record_float_const (dhandle, name, atof (p))) 775 return FALSE; 776 break; 777 case 'i': 778 /* Integer constant. */ 779 /* Defining integer constants this way is kind of silly, 780 since 'e' constants allows the compiler to give not only 781 the value, but the type as well. C has at least int, 782 long, unsigned int, and long long as constant types; 783 other languages probably should have at least unsigned as 784 well as signed constants. */ 785 if (! debug_record_int_const (dhandle, name, atoi (p))) 786 return FALSE; 787 break; 788 case 'e': 789 /* SYMBOL:c=eTYPE,INTVALUE for a constant symbol whose value 790 can be represented as integral. 791 e.g. "b:c=e6,0" for "const b = blob1" 792 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */ 793 dtype = parse_stab_type (dhandle, info, (const char *) NULL, 794 &p, (debug_type **) NULL); 795 if (dtype == DEBUG_TYPE_NULL) 796 return FALSE; 797 if (*p != ',') 798 { 799 bad_stab (string); 800 return FALSE; 801 } 802 if (! debug_record_typed_const (dhandle, name, dtype, atoi (p))) 803 return FALSE; 804 break; 805 default: 806 bad_stab (string); 807 return FALSE; 808 } 809 810 break; 811 812 case 'C': 813 /* The name of a caught exception. */ 814 dtype = parse_stab_type (dhandle, info, (const char *) NULL, 815 &p, (debug_type **) NULL); 816 if (dtype == DEBUG_TYPE_NULL) 817 return FALSE; 818 if (! debug_record_label (dhandle, name, dtype, value)) 819 return FALSE; 820 break; 821 822 case 'f': 823 case 'F': 824 /* A function definition. */ 825 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p, 826 (debug_type **) NULL); 827 if (dtype == DEBUG_TYPE_NULL) 828 return FALSE; 829 if (! debug_record_function (dhandle, name, dtype, type == 'F', value)) 830 return FALSE; 831 832 /* Sun acc puts declared types of arguments here. We don't care 833 about their actual types (FIXME -- we should remember the whole 834 function prototype), but the list may define some new types 835 that we have to remember, so we must scan it now. */ 836 while (*p == ';') 837 { 838 ++p; 839 if (parse_stab_type (dhandle, info, (const char *) NULL, &p, 840 (debug_type **) NULL) 841 == DEBUG_TYPE_NULL) 842 return FALSE; 843 } 844 845 break; 846 847 case 'G': 848 { 849 char leading; 850 long c; 851 asymbol **ps; 852 853 /* A global symbol. The value must be extracted from the 854 symbol table. */ 855 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p, 856 (debug_type **) NULL); 857 if (dtype == DEBUG_TYPE_NULL) 858 return FALSE; 859 leading = bfd_get_symbol_leading_char (info->abfd); 860 for (c = info->symcount, ps = info->syms; c > 0; --c, ++ps) 861 { 862 const char *n; 863 864 n = bfd_asymbol_name (*ps); 865 if (leading != '\0' && *n == leading) 866 ++n; 867 if (*n == *name && strcmp (n, name) == 0) 868 break; 869 } 870 if (c > 0) 871 value = bfd_asymbol_value (*ps); 872 if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_GLOBAL, 873 value)) 874 return FALSE; 875 } 876 break; 877 878 /* This case is faked by a conditional above, when there is no 879 code letter in the dbx data. Dbx data never actually 880 contains 'l'. */ 881 case 'l': 882 case 's': 883 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p, 884 (debug_type **) NULL); 885 if (dtype == DEBUG_TYPE_NULL) 886 return FALSE; 887 if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_LOCAL, 888 value)) 889 return FALSE; 890 break; 891 892 case 'p': 893 /* A function parameter. */ 894 if (*p != 'F') 895 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p, 896 (debug_type **) NULL); 897 else 898 { 899 /* pF is a two-letter code that means a function parameter in 900 Fortran. The type-number specifies the type of the return 901 value. Translate it into a pointer-to-function type. */ 902 ++p; 903 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p, 904 (debug_type **) NULL); 905 if (dtype != DEBUG_TYPE_NULL) 906 { 907 debug_type ftype; 908 909 ftype = debug_make_function_type (dhandle, dtype, 910 (debug_type *) NULL, FALSE); 911 dtype = debug_make_pointer_type (dhandle, ftype); 912 } 913 } 914 if (dtype == DEBUG_TYPE_NULL) 915 return FALSE; 916 if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_STACK, 917 value)) 918 return FALSE; 919 920 /* FIXME: At this point gdb considers rearranging the parameter 921 address on a big endian machine if it is smaller than an int. 922 We have no way to do that, since we don't really know much 923 about the target. */ 924 break; 925 926 case 'P': 927 if (stabtype == N_FUN) 928 { 929 /* Prototype of a function referenced by this file. */ 930 while (*p == ';') 931 { 932 ++p; 933 if (parse_stab_type (dhandle, info, (const char *) NULL, &p, 934 (debug_type **) NULL) 935 == DEBUG_TYPE_NULL) 936 return FALSE; 937 } 938 break; 939 } 940 /* Fall through. */ 941 case 'R': 942 /* Parameter which is in a register. */ 943 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p, 944 (debug_type **) NULL); 945 if (dtype == DEBUG_TYPE_NULL) 946 return FALSE; 947 if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_REG, 948 value)) 949 return FALSE; 950 break; 951 952 case 'r': 953 /* Register variable (either global or local). */ 954 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p, 955 (debug_type **) NULL); 956 if (dtype == DEBUG_TYPE_NULL) 957 return FALSE; 958 if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_REGISTER, 959 value)) 960 return FALSE; 961 962 /* FIXME: At this point gdb checks to combine pairs of 'p' and 963 'r' stabs into a single 'P' stab. */ 964 break; 965 966 case 'S': 967 /* Static symbol at top level of file. */ 968 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p, 969 (debug_type **) NULL); 970 if (dtype == DEBUG_TYPE_NULL) 971 return FALSE; 972 if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_STATIC, 973 value)) 974 return FALSE; 975 break; 976 977 case 't': 978 /* A typedef. */ 979 dtype = parse_stab_type (dhandle, info, name, &p, &slot); 980 if (dtype == DEBUG_TYPE_NULL) 981 return FALSE; 982 if (name == NULL) 983 { 984 /* A nameless type. Nothing to do. */ 985 return TRUE; 986 } 987 988 dtype = debug_name_type (dhandle, name, dtype); 989 if (dtype == DEBUG_TYPE_NULL) 990 return FALSE; 991 992 if (slot != NULL) 993 *slot = dtype; 994 995 break; 996 997 case 'T': 998 /* Struct, union, or enum tag. For GNU C++, this can be be followed 999 by 't' which means we are typedef'ing it as well. */ 1000 if (*p != 't') 1001 { 1002 synonym = FALSE; 1003 /* FIXME: gdb sets synonym to TRUE if the current language 1004 is C++. */ 1005 } 1006 else 1007 { 1008 synonym = TRUE; 1009 ++p; 1010 } 1011 1012 dtype = parse_stab_type (dhandle, info, name, &p, &slot); 1013 if (dtype == DEBUG_TYPE_NULL) 1014 return FALSE; 1015 if (name == NULL) 1016 return TRUE; 1017 1018 /* INFO->SELF_CROSSREF is set by parse_stab_type if this type is 1019 a cross reference to itself. These are generated by some 1020 versions of g++. */ 1021 self_crossref = info->self_crossref; 1022 1023 dtype = debug_tag_type (dhandle, name, dtype); 1024 if (dtype == DEBUG_TYPE_NULL) 1025 return FALSE; 1026 if (slot != NULL) 1027 *slot = dtype; 1028 1029 /* See if we have a cross reference to this tag which we can now 1030 fill in. Avoid filling in a cross reference to ourselves, 1031 because that would lead to circular debugging information. */ 1032 if (! self_crossref) 1033 { 1034 register struct stab_tag **pst; 1035 1036 for (pst = &info->tags; *pst != NULL; pst = &(*pst)->next) 1037 { 1038 if ((*pst)->name[0] == name[0] 1039 && strcmp ((*pst)->name, name) == 0) 1040 { 1041 (*pst)->slot = dtype; 1042 *pst = (*pst)->next; 1043 break; 1044 } 1045 } 1046 } 1047 1048 if (synonym) 1049 { 1050 dtype = debug_name_type (dhandle, name, dtype); 1051 if (dtype == DEBUG_TYPE_NULL) 1052 return FALSE; 1053 1054 if (slot != NULL) 1055 *slot = dtype; 1056 } 1057 1058 break; 1059 1060 case 'V': 1061 /* Static symbol of local scope */ 1062 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p, 1063 (debug_type **) NULL); 1064 if (dtype == DEBUG_TYPE_NULL) 1065 return FALSE; 1066 /* FIXME: gdb checks os9k_stabs here. */ 1067 if (! stab_record_variable (dhandle, info, name, dtype, 1068 DEBUG_LOCAL_STATIC, value)) 1069 return FALSE; 1070 break; 1071 1072 case 'v': 1073 /* Reference parameter. */ 1074 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p, 1075 (debug_type **) NULL); 1076 if (dtype == DEBUG_TYPE_NULL) 1077 return FALSE; 1078 if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_REFERENCE, 1079 value)) 1080 return FALSE; 1081 break; 1082 1083 case 'a': 1084 /* Reference parameter which is in a register. */ 1085 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p, 1086 (debug_type **) NULL); 1087 if (dtype == DEBUG_TYPE_NULL) 1088 return FALSE; 1089 if (! debug_record_parameter (dhandle, name, dtype, DEBUG_PARM_REF_REG, 1090 value)) 1091 return FALSE; 1092 break; 1093 1094 case 'X': 1095 /* This is used by Sun FORTRAN for "function result value". 1096 Sun claims ("dbx and dbxtool interfaces", 2nd ed) 1097 that Pascal uses it too, but when I tried it Pascal used 1098 "x:3" (local symbol) instead. */ 1099 dtype = parse_stab_type (dhandle, info, (const char *) NULL, &p, 1100 (debug_type **) NULL); 1101 if (dtype == DEBUG_TYPE_NULL) 1102 return FALSE; 1103 if (! stab_record_variable (dhandle, info, name, dtype, DEBUG_LOCAL, 1104 value)) 1105 return FALSE; 1106 break; 1107 1108 default: 1109 bad_stab (string); 1110 return FALSE; 1111 } 1112 1113 /* FIXME: gdb converts structure values to structure pointers in a 1114 couple of cases, depending upon the target. */ 1115 1116 return TRUE; 1117 } 1118 1119 /* Parse a stabs type. The typename argument is non-NULL if this is a 1120 typedef or a tag definition. The pp argument points to the stab 1121 string, and is updated. The slotp argument points to a place to 1122 store the slot used if the type is being defined. */ 1123 1124 static debug_type 1125 parse_stab_type (void *dhandle, struct stab_handle *info, const char *typename, const char **pp, debug_type **slotp) 1126 { 1127 const char *orig; 1128 int typenums[2]; 1129 int size; 1130 bfd_boolean stringp; 1131 int descriptor; 1132 debug_type dtype; 1133 1134 if (slotp != NULL) 1135 *slotp = NULL; 1136 1137 orig = *pp; 1138 1139 size = -1; 1140 stringp = FALSE; 1141 1142 info->self_crossref = FALSE; 1143 1144 /* Read type number if present. The type number may be omitted. 1145 for instance in a two-dimensional array declared with type 1146 "ar1;1;10;ar1;1;10;4". */ 1147 if (! ISDIGIT (**pp) && **pp != '(' && **pp != '-') 1148 { 1149 /* 'typenums=' not present, type is anonymous. Read and return 1150 the definition, but don't put it in the type vector. */ 1151 typenums[0] = typenums[1] = -1; 1152 } 1153 else 1154 { 1155 if (! parse_stab_type_number (pp, typenums)) 1156 return DEBUG_TYPE_NULL; 1157 1158 if (**pp != '=') 1159 /* Type is not being defined here. Either it already 1160 exists, or this is a forward reference to it. */ 1161 return stab_find_type (dhandle, info, typenums); 1162 1163 /* Only set the slot if the type is being defined. This means 1164 that the mapping from type numbers to types will only record 1165 the name of the typedef which defines a type. If we don't do 1166 this, then something like 1167 typedef int foo; 1168 int i; 1169 will record that i is of type foo. Unfortunately, stabs 1170 information is ambiguous about variable types. For this code, 1171 typedef int foo; 1172 int i; 1173 foo j; 1174 the stabs information records both i and j as having the same 1175 type. This could be fixed by patching the compiler. */ 1176 if (slotp != NULL && typenums[0] >= 0 && typenums[1] >= 0) 1177 *slotp = stab_find_slot (info, typenums); 1178 1179 /* Type is being defined here. */ 1180 /* Skip the '='. */ 1181 ++*pp; 1182 1183 while (**pp == '@') 1184 { 1185 const char *p = *pp + 1; 1186 const char *attr; 1187 1188 if (ISDIGIT (*p) || *p == '(' || *p == '-') 1189 /* Member type. */ 1190 break; 1191 1192 /* Type attributes. */ 1193 attr = p; 1194 1195 for (; *p != ';'; ++p) 1196 { 1197 if (*p == '\0') 1198 { 1199 bad_stab (orig); 1200 return DEBUG_TYPE_NULL; 1201 } 1202 } 1203 *pp = p + 1; 1204 1205 switch (*attr) 1206 { 1207 case 's': 1208 size = atoi (attr + 1); 1209 size /= 8; /* Size is in bits. We store it in bytes. */ 1210 if (size <= 0) 1211 size = -1; 1212 break; 1213 1214 case 'S': 1215 stringp = TRUE; 1216 break; 1217 1218 default: 1219 /* Ignore unrecognized type attributes, so future 1220 compilers can invent new ones. */ 1221 break; 1222 } 1223 } 1224 } 1225 1226 descriptor = **pp; 1227 ++*pp; 1228 1229 switch (descriptor) 1230 { 1231 case 'x': 1232 { 1233 enum debug_type_kind code; 1234 const char *q1, *q2, *p; 1235 1236 /* A cross reference to another type. */ 1237 switch (**pp) 1238 { 1239 case 's': 1240 code = DEBUG_KIND_STRUCT; 1241 break; 1242 case 'u': 1243 code = DEBUG_KIND_UNION; 1244 break; 1245 case 'e': 1246 code = DEBUG_KIND_ENUM; 1247 break; 1248 default: 1249 /* Complain and keep going, so compilers can invent new 1250 cross-reference types. */ 1251 warn_stab (orig, _("unrecognized cross reference type")); 1252 code = DEBUG_KIND_STRUCT; 1253 break; 1254 } 1255 ++*pp; 1256 1257 q1 = strchr (*pp, '<'); 1258 p = strchr (*pp, ':'); 1259 if (p == NULL) 1260 { 1261 bad_stab (orig); 1262 return DEBUG_TYPE_NULL; 1263 } 1264 if (q1 != NULL && p > q1 && p[1] == ':') 1265 { 1266 int nest = 0; 1267 1268 for (q2 = q1; *q2 != '\0'; ++q2) 1269 { 1270 if (*q2 == '<') 1271 ++nest; 1272 else if (*q2 == '>') 1273 --nest; 1274 else if (*q2 == ':' && nest == 0) 1275 break; 1276 } 1277 p = q2; 1278 if (*p != ':') 1279 { 1280 bad_stab (orig); 1281 return DEBUG_TYPE_NULL; 1282 } 1283 } 1284 1285 /* Some versions of g++ can emit stabs like 1286 fleep:T20=xsfleep: 1287 which define structures in terms of themselves. We need to 1288 tell the caller to avoid building a circular structure. */ 1289 if (typename != NULL 1290 && strncmp (typename, *pp, p - *pp) == 0 1291 && typename[p - *pp] == '\0') 1292 info->self_crossref = TRUE; 1293 1294 dtype = stab_find_tagged_type (dhandle, info, *pp, p - *pp, code); 1295 1296 *pp = p + 1; 1297 } 1298 break; 1299 1300 case '-': 1301 case '0': 1302 case '1': 1303 case '2': 1304 case '3': 1305 case '4': 1306 case '5': 1307 case '6': 1308 case '7': 1309 case '8': 1310 case '9': 1311 case '(': 1312 { 1313 const char *hold; 1314 int xtypenums[2]; 1315 1316 /* This type is defined as another type. */ 1317 (*pp)--; 1318 hold = *pp; 1319 1320 /* Peek ahead at the number to detect void. */ 1321 if (! parse_stab_type_number (pp, xtypenums)) 1322 return DEBUG_TYPE_NULL; 1323 1324 if (typenums[0] == xtypenums[0] && typenums[1] == xtypenums[1]) 1325 { 1326 /* This type is being defined as itself, which means that 1327 it is void. */ 1328 dtype = debug_make_void_type (dhandle); 1329 } 1330 else 1331 { 1332 *pp = hold; 1333 1334 /* Go back to the number and have parse_stab_type get it. 1335 This means that we can deal with something like 1336 t(1,2)=(3,4)=... which the Lucid compiler uses. */ 1337 dtype = parse_stab_type (dhandle, info, (const char *) NULL, 1338 pp, (debug_type **) NULL); 1339 if (dtype == DEBUG_TYPE_NULL) 1340 return DEBUG_TYPE_NULL; 1341 } 1342 1343 if (typenums[0] != -1) 1344 { 1345 if (! stab_record_type (dhandle, info, typenums, dtype)) 1346 return DEBUG_TYPE_NULL; 1347 } 1348 1349 break; 1350 } 1351 1352 case '*': 1353 dtype = debug_make_pointer_type (dhandle, 1354 parse_stab_type (dhandle, info, 1355 (const char *) NULL, 1356 pp, 1357 (debug_type **) NULL)); 1358 break; 1359 1360 case '&': 1361 /* Reference to another type. */ 1362 dtype = (debug_make_reference_type 1363 (dhandle, 1364 parse_stab_type (dhandle, info, (const char *) NULL, pp, 1365 (debug_type **) NULL))); 1366 break; 1367 1368 case 'f': 1369 /* Function returning another type. */ 1370 /* FIXME: gdb checks os9k_stabs here. */ 1371 dtype = (debug_make_function_type 1372 (dhandle, 1373 parse_stab_type (dhandle, info, (const char *) NULL, pp, 1374 (debug_type **) NULL), 1375 (debug_type *) NULL, FALSE)); 1376 break; 1377 1378 case 'k': 1379 /* Const qualifier on some type (Sun). */ 1380 /* FIXME: gdb accepts 'c' here if os9k_stabs. */ 1381 dtype = debug_make_const_type (dhandle, 1382 parse_stab_type (dhandle, info, 1383 (const char *) NULL, 1384 pp, 1385 (debug_type **) NULL)); 1386 break; 1387 1388 case 'B': 1389 /* Volatile qual on some type (Sun). */ 1390 /* FIXME: gdb accepts 'i' here if os9k_stabs. */ 1391 dtype = (debug_make_volatile_type 1392 (dhandle, 1393 parse_stab_type (dhandle, info, (const char *) NULL, pp, 1394 (debug_type **) NULL))); 1395 break; 1396 1397 case '@': 1398 /* Offset (class & variable) type. This is used for a pointer 1399 relative to an object. */ 1400 { 1401 debug_type domain; 1402 debug_type memtype; 1403 1404 /* Member type. */ 1405 1406 domain = parse_stab_type (dhandle, info, (const char *) NULL, pp, 1407 (debug_type **) NULL); 1408 if (domain == DEBUG_TYPE_NULL) 1409 return DEBUG_TYPE_NULL; 1410 1411 if (**pp != ',') 1412 { 1413 bad_stab (orig); 1414 return DEBUG_TYPE_NULL; 1415 } 1416 ++*pp; 1417 1418 memtype = parse_stab_type (dhandle, info, (const char *) NULL, pp, 1419 (debug_type **) NULL); 1420 if (memtype == DEBUG_TYPE_NULL) 1421 return DEBUG_TYPE_NULL; 1422 1423 dtype = debug_make_offset_type (dhandle, domain, memtype); 1424 } 1425 break; 1426 1427 case '#': 1428 /* Method (class & fn) type. */ 1429 if (**pp == '#') 1430 { 1431 debug_type return_type; 1432 1433 ++*pp; 1434 return_type = parse_stab_type (dhandle, info, (const char *) NULL, 1435 pp, (debug_type **) NULL); 1436 if (return_type == DEBUG_TYPE_NULL) 1437 return DEBUG_TYPE_NULL; 1438 if (**pp != ';') 1439 { 1440 bad_stab (orig); 1441 return DEBUG_TYPE_NULL; 1442 } 1443 ++*pp; 1444 dtype = debug_make_method_type (dhandle, return_type, 1445 DEBUG_TYPE_NULL, 1446 (debug_type *) NULL, FALSE); 1447 } 1448 else 1449 { 1450 debug_type domain; 1451 debug_type return_type; 1452 debug_type *args; 1453 unsigned int n; 1454 unsigned int alloc; 1455 bfd_boolean varargs; 1456 1457 domain = parse_stab_type (dhandle, info, (const char *) NULL, 1458 pp, (debug_type **) NULL); 1459 if (domain == DEBUG_TYPE_NULL) 1460 return DEBUG_TYPE_NULL; 1461 1462 if (**pp != ',') 1463 { 1464 bad_stab (orig); 1465 return DEBUG_TYPE_NULL; 1466 } 1467 ++*pp; 1468 1469 return_type = parse_stab_type (dhandle, info, (const char *) NULL, 1470 pp, (debug_type **) NULL); 1471 if (return_type == DEBUG_TYPE_NULL) 1472 return DEBUG_TYPE_NULL; 1473 1474 alloc = 10; 1475 args = (debug_type *) xmalloc (alloc * sizeof *args); 1476 n = 0; 1477 while (**pp != ';') 1478 { 1479 if (**pp != ',') 1480 { 1481 bad_stab (orig); 1482 return DEBUG_TYPE_NULL; 1483 } 1484 ++*pp; 1485 1486 if (n + 1 >= alloc) 1487 { 1488 alloc += 10; 1489 args = ((debug_type *) 1490 xrealloc (args, alloc * sizeof *args)); 1491 } 1492 1493 args[n] = parse_stab_type (dhandle, info, (const char *) NULL, 1494 pp, (debug_type **) NULL); 1495 if (args[n] == DEBUG_TYPE_NULL) 1496 return DEBUG_TYPE_NULL; 1497 ++n; 1498 } 1499 ++*pp; 1500 1501 /* If the last type is not void, then this function takes a 1502 variable number of arguments. Otherwise, we must strip 1503 the void type. */ 1504 if (n == 0 1505 || debug_get_type_kind (dhandle, args[n - 1]) != DEBUG_KIND_VOID) 1506 varargs = TRUE; 1507 else 1508 { 1509 --n; 1510 varargs = FALSE; 1511 } 1512 1513 args[n] = DEBUG_TYPE_NULL; 1514 1515 dtype = debug_make_method_type (dhandle, return_type, domain, args, 1516 varargs); 1517 } 1518 break; 1519 1520 case 'r': 1521 /* Range type. */ 1522 dtype = parse_stab_range_type (dhandle, info, typename, pp, typenums); 1523 break; 1524 1525 case 'b': 1526 /* FIXME: gdb checks os9k_stabs here. */ 1527 /* Sun ACC builtin int type. */ 1528 dtype = parse_stab_sun_builtin_type (dhandle, pp); 1529 break; 1530 1531 case 'R': 1532 /* Sun ACC builtin float type. */ 1533 dtype = parse_stab_sun_floating_type (dhandle, pp); 1534 break; 1535 1536 case 'e': 1537 /* Enumeration type. */ 1538 dtype = parse_stab_enum_type (dhandle, pp); 1539 break; 1540 1541 case 's': 1542 case 'u': 1543 /* Struct or union type. */ 1544 dtype = parse_stab_struct_type (dhandle, info, typename, pp, 1545 descriptor == 's', typenums); 1546 break; 1547 1548 case 'a': 1549 /* Array type. */ 1550 if (**pp != 'r') 1551 { 1552 bad_stab (orig); 1553 return DEBUG_TYPE_NULL; 1554 } 1555 ++*pp; 1556 1557 dtype = parse_stab_array_type (dhandle, info, pp, stringp); 1558 break; 1559 1560 case 'S': 1561 dtype = debug_make_set_type (dhandle, 1562 parse_stab_type (dhandle, info, 1563 (const char *) NULL, 1564 pp, 1565 (debug_type **) NULL), 1566 stringp); 1567 break; 1568 1569 default: 1570 bad_stab (orig); 1571 return DEBUG_TYPE_NULL; 1572 } 1573 1574 if (dtype == DEBUG_TYPE_NULL) 1575 return DEBUG_TYPE_NULL; 1576 1577 if (typenums[0] != -1) 1578 { 1579 if (! stab_record_type (dhandle, info, typenums, dtype)) 1580 return DEBUG_TYPE_NULL; 1581 } 1582 1583 if (size != -1) 1584 { 1585 if (! debug_record_type_size (dhandle, dtype, (unsigned int) size)) 1586 return DEBUG_TYPE_NULL; 1587 } 1588 1589 return dtype; 1590 } 1591 1592 /* Read a number by which a type is referred to in dbx data, or 1593 perhaps read a pair (FILENUM, TYPENUM) in parentheses. Just a 1594 single number N is equivalent to (0,N). Return the two numbers by 1595 storing them in the vector TYPENUMS. */ 1596 1597 static bfd_boolean 1598 parse_stab_type_number (const char **pp, int *typenums) 1599 { 1600 const char *orig; 1601 1602 orig = *pp; 1603 1604 if (**pp != '(') 1605 { 1606 typenums[0] = 0; 1607 typenums[1] = (int) parse_number (pp, (bfd_boolean *) NULL); 1608 } 1609 else 1610 { 1611 ++*pp; 1612 typenums[0] = (int) parse_number (pp, (bfd_boolean *) NULL); 1613 if (**pp != ',') 1614 { 1615 bad_stab (orig); 1616 return FALSE; 1617 } 1618 ++*pp; 1619 typenums[1] = (int) parse_number (pp, (bfd_boolean *) NULL); 1620 if (**pp != ')') 1621 { 1622 bad_stab (orig); 1623 return FALSE; 1624 } 1625 ++*pp; 1626 } 1627 1628 return TRUE; 1629 } 1630 1631 /* Parse a range type. */ 1632 1633 static debug_type 1634 parse_stab_range_type (void *dhandle, struct stab_handle *info, const char *typename, const char **pp, const int *typenums) 1635 { 1636 const char *orig; 1637 int rangenums[2]; 1638 bfd_boolean self_subrange; 1639 debug_type index_type; 1640 const char *s2, *s3; 1641 bfd_signed_vma n2, n3; 1642 bfd_boolean ov2, ov3; 1643 1644 orig = *pp; 1645 1646 index_type = DEBUG_TYPE_NULL; 1647 1648 /* First comes a type we are a subrange of. 1649 In C it is usually 0, 1 or the type being defined. */ 1650 if (! parse_stab_type_number (pp, rangenums)) 1651 return DEBUG_TYPE_NULL; 1652 1653 self_subrange = (rangenums[0] == typenums[0] 1654 && rangenums[1] == typenums[1]); 1655 1656 if (**pp == '=') 1657 { 1658 *pp = orig; 1659 index_type = parse_stab_type (dhandle, info, (const char *) NULL, 1660 pp, (debug_type **) NULL); 1661 if (index_type == DEBUG_TYPE_NULL) 1662 return DEBUG_TYPE_NULL; 1663 } 1664 1665 if (**pp == ';') 1666 ++*pp; 1667 1668 /* The remaining two operands are usually lower and upper bounds of 1669 the range. But in some special cases they mean something else. */ 1670 s2 = *pp; 1671 n2 = parse_number (pp, &ov2); 1672 if (**pp != ';') 1673 { 1674 bad_stab (orig); 1675 return DEBUG_TYPE_NULL; 1676 } 1677 ++*pp; 1678 1679 s3 = *pp; 1680 n3 = parse_number (pp, &ov3); 1681 if (**pp != ';') 1682 { 1683 bad_stab (orig); 1684 return DEBUG_TYPE_NULL; 1685 } 1686 ++*pp; 1687 1688 if (ov2 || ov3) 1689 { 1690 /* gcc will emit range stabs for long long types. Handle this 1691 as a special case. FIXME: This needs to be more general. */ 1692 #define LLLOW "01000000000000000000000;" 1693 #define LLHIGH "0777777777777777777777;" 1694 #define ULLHIGH "01777777777777777777777;" 1695 if (index_type == DEBUG_TYPE_NULL) 1696 { 1697 if (CONST_STRNEQ (s2, LLLOW) 1698 && CONST_STRNEQ (s3, LLHIGH)) 1699 return debug_make_int_type (dhandle, 8, FALSE); 1700 if (! ov2 1701 && n2 == 0 1702 && CONST_STRNEQ (s3, ULLHIGH)) 1703 return debug_make_int_type (dhandle, 8, TRUE); 1704 } 1705 1706 warn_stab (orig, _("numeric overflow")); 1707 } 1708 1709 if (index_type == DEBUG_TYPE_NULL) 1710 { 1711 /* A type defined as a subrange of itself, with both bounds 0, 1712 is void. */ 1713 if (self_subrange && n2 == 0 && n3 == 0) 1714 return debug_make_void_type (dhandle); 1715 1716 /* A type defined as a subrange of itself, with n2 positive and 1717 n3 zero, is a complex type, and n2 is the number of bytes. */ 1718 if (self_subrange && n3 == 0 && n2 > 0) 1719 return debug_make_complex_type (dhandle, n2); 1720 1721 /* If n3 is zero and n2 is positive, this is a floating point 1722 type, and n2 is the number of bytes. */ 1723 if (n3 == 0 && n2 > 0) 1724 return debug_make_float_type (dhandle, n2); 1725 1726 /* If the upper bound is -1, this is an unsigned int. */ 1727 if (n2 == 0 && n3 == -1) 1728 { 1729 /* When gcc is used with -gstabs, but not -gstabs+, it will emit 1730 long long int:t6=r1;0;-1; 1731 long long unsigned int:t7=r1;0;-1; 1732 We hack here to handle this reasonably. */ 1733 if (typename != NULL) 1734 { 1735 if (strcmp (typename, "long long int") == 0) 1736 return debug_make_int_type (dhandle, 8, FALSE); 1737 else if (strcmp (typename, "long long unsigned int") == 0) 1738 return debug_make_int_type (dhandle, 8, TRUE); 1739 } 1740 /* FIXME: The size here really depends upon the target. */ 1741 return debug_make_int_type (dhandle, 4, TRUE); 1742 } 1743 1744 /* A range of 0 to 127 is char. */ 1745 if (self_subrange && n2 == 0 && n3 == 127) 1746 return debug_make_int_type (dhandle, 1, FALSE); 1747 1748 /* FIXME: gdb checks for the language CHILL here. */ 1749 1750 if (n2 == 0) 1751 { 1752 if (n3 < 0) 1753 return debug_make_int_type (dhandle, - n3, TRUE); 1754 else if (n3 == 0xff) 1755 return debug_make_int_type (dhandle, 1, TRUE); 1756 else if (n3 == 0xffff) 1757 return debug_make_int_type (dhandle, 2, TRUE); 1758 else if (n3 == (bfd_signed_vma) 0xffffffff) 1759 return debug_make_int_type (dhandle, 4, TRUE); 1760 #ifdef BFD64 1761 else if (n3 == ((((bfd_signed_vma) 0xffffffff) << 32) | 0xffffffff)) 1762 return debug_make_int_type (dhandle, 8, TRUE); 1763 #endif 1764 } 1765 else if (n3 == 0 1766 && n2 < 0 1767 && (self_subrange || n2 == -8)) 1768 return debug_make_int_type (dhandle, - n2, TRUE); 1769 else if (n2 == - n3 - 1 || n2 == n3 + 1) 1770 { 1771 if (n3 == 0x7f) 1772 return debug_make_int_type (dhandle, 1, FALSE); 1773 else if (n3 == 0x7fff) 1774 return debug_make_int_type (dhandle, 2, FALSE); 1775 else if (n3 == 0x7fffffff) 1776 return debug_make_int_type (dhandle, 4, FALSE); 1777 #ifdef BFD64 1778 else if (n3 == ((((bfd_vma) 0x7fffffff) << 32) | 0xffffffff)) 1779 return debug_make_int_type (dhandle, 8, FALSE); 1780 #endif 1781 } 1782 } 1783 1784 /* At this point I don't have the faintest idea how to deal with a 1785 self_subrange type; I'm going to assume that this is used as an 1786 idiom, and that all of them are special cases. So . . . */ 1787 if (self_subrange) 1788 { 1789 bad_stab (orig); 1790 return DEBUG_TYPE_NULL; 1791 } 1792 1793 index_type = stab_find_type (dhandle, info, rangenums); 1794 if (index_type == DEBUG_TYPE_NULL) 1795 { 1796 /* Does this actually ever happen? Is that why we are worrying 1797 about dealing with it rather than just calling error_type? */ 1798 warn_stab (orig, _("missing index type")); 1799 index_type = debug_make_int_type (dhandle, 4, FALSE); 1800 } 1801 1802 return debug_make_range_type (dhandle, index_type, n2, n3); 1803 } 1804 1805 /* Sun's ACC uses a somewhat saner method for specifying the builtin 1806 typedefs in every file (for int, long, etc): 1807 1808 type = b <signed> <width>; <offset>; <nbits> 1809 signed = u or s. Possible c in addition to u or s (for char?). 1810 offset = offset from high order bit to start bit of type. 1811 width is # bytes in object of this type, nbits is # bits in type. 1812 1813 The width/offset stuff appears to be for small objects stored in 1814 larger ones (e.g. `shorts' in `int' registers). We ignore it for now, 1815 FIXME. */ 1816 1817 static debug_type 1818 parse_stab_sun_builtin_type (void *dhandle, const char **pp) 1819 { 1820 const char *orig; 1821 bfd_boolean unsignedp; 1822 bfd_vma bits; 1823 1824 orig = *pp; 1825 1826 switch (**pp) 1827 { 1828 case 's': 1829 unsignedp = FALSE; 1830 break; 1831 case 'u': 1832 unsignedp = TRUE; 1833 break; 1834 default: 1835 bad_stab (orig); 1836 return DEBUG_TYPE_NULL; 1837 } 1838 ++*pp; 1839 1840 /* For some odd reason, all forms of char put a c here. This is strange 1841 because no other type has this honor. We can safely ignore this because 1842 we actually determine 'char'acterness by the number of bits specified in 1843 the descriptor. */ 1844 if (**pp == 'c') 1845 ++*pp; 1846 1847 /* The first number appears to be the number of bytes occupied 1848 by this type, except that unsigned short is 4 instead of 2. 1849 Since this information is redundant with the third number, 1850 we will ignore it. */ 1851 (void) parse_number (pp, (bfd_boolean *) NULL); 1852 if (**pp != ';') 1853 { 1854 bad_stab (orig); 1855 return DEBUG_TYPE_NULL; 1856 } 1857 ++*pp; 1858 1859 /* The second number is always 0, so ignore it too. */ 1860 (void) parse_number (pp, (bfd_boolean *) NULL); 1861 if (**pp != ';') 1862 { 1863 bad_stab (orig); 1864 return DEBUG_TYPE_NULL; 1865 } 1866 ++*pp; 1867 1868 /* The third number is the number of bits for this type. */ 1869 bits = parse_number (pp, (bfd_boolean *) NULL); 1870 1871 /* The type *should* end with a semicolon. If it are embedded 1872 in a larger type the semicolon may be the only way to know where 1873 the type ends. If this type is at the end of the stabstring we 1874 can deal with the omitted semicolon (but we don't have to like 1875 it). Don't bother to complain(), Sun's compiler omits the semicolon 1876 for "void". */ 1877 if (**pp == ';') 1878 ++*pp; 1879 1880 if (bits == 0) 1881 return debug_make_void_type (dhandle); 1882 1883 return debug_make_int_type (dhandle, bits / 8, unsignedp); 1884 } 1885 1886 /* Parse a builtin floating type generated by the Sun compiler. */ 1887 1888 static debug_type 1889 parse_stab_sun_floating_type (void *dhandle, const char **pp) 1890 { 1891 const char *orig; 1892 bfd_vma details; 1893 bfd_vma bytes; 1894 1895 orig = *pp; 1896 1897 /* The first number has more details about the type, for example 1898 FN_COMPLEX. */ 1899 details = parse_number (pp, (bfd_boolean *) NULL); 1900 if (**pp != ';') 1901 { 1902 bad_stab (orig); 1903 return DEBUG_TYPE_NULL; 1904 } 1905 1906 /* The second number is the number of bytes occupied by this type */ 1907 bytes = parse_number (pp, (bfd_boolean *) NULL); 1908 if (**pp != ';') 1909 { 1910 bad_stab (orig); 1911 return DEBUG_TYPE_NULL; 1912 } 1913 1914 if (details == NF_COMPLEX 1915 || details == NF_COMPLEX16 1916 || details == NF_COMPLEX32) 1917 return debug_make_complex_type (dhandle, bytes); 1918 1919 return debug_make_float_type (dhandle, bytes); 1920 } 1921 1922 /* Handle an enum type. */ 1923 1924 static debug_type 1925 parse_stab_enum_type (void *dhandle, const char **pp) 1926 { 1927 const char *orig; 1928 const char **names; 1929 bfd_signed_vma *values; 1930 unsigned int n; 1931 unsigned int alloc; 1932 1933 orig = *pp; 1934 1935 /* FIXME: gdb checks os9k_stabs here. */ 1936 1937 /* The aix4 compiler emits an extra field before the enum members; 1938 my guess is it's a type of some sort. Just ignore it. */ 1939 if (**pp == '-') 1940 { 1941 while (**pp != ':') 1942 ++*pp; 1943 ++*pp; 1944 } 1945 1946 /* Read the value-names and their values. 1947 The input syntax is NAME:VALUE,NAME:VALUE, and so on. 1948 A semicolon or comma instead of a NAME means the end. */ 1949 alloc = 10; 1950 names = (const char **) xmalloc (alloc * sizeof *names); 1951 values = (bfd_signed_vma *) xmalloc (alloc * sizeof *values); 1952 n = 0; 1953 while (**pp != '\0' && **pp != ';' && **pp != ',') 1954 { 1955 const char *p; 1956 char *name; 1957 bfd_signed_vma val; 1958 1959 p = *pp; 1960 while (*p != ':') 1961 ++p; 1962 1963 name = savestring (*pp, p - *pp); 1964 1965 *pp = p + 1; 1966 val = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL); 1967 if (**pp != ',') 1968 { 1969 bad_stab (orig); 1970 return DEBUG_TYPE_NULL; 1971 } 1972 ++*pp; 1973 1974 if (n + 1 >= alloc) 1975 { 1976 alloc += 10; 1977 names = ((const char **) 1978 xrealloc (names, alloc * sizeof *names)); 1979 values = ((bfd_signed_vma *) 1980 xrealloc (values, alloc * sizeof *values)); 1981 } 1982 1983 names[n] = name; 1984 values[n] = val; 1985 ++n; 1986 } 1987 1988 names[n] = NULL; 1989 values[n] = 0; 1990 1991 if (**pp == ';') 1992 ++*pp; 1993 1994 return debug_make_enum_type (dhandle, names, values); 1995 } 1996 1997 /* Read the description of a structure (or union type) and return an object 1998 describing the type. 1999 2000 PP points to a character pointer that points to the next unconsumed token 2001 in the stabs string. For example, given stabs "A:T4=s4a:1,0,32;;", 2002 *PP will point to "4a:1,0,32;;". */ 2003 2004 static debug_type 2005 parse_stab_struct_type (void *dhandle, struct stab_handle *info, 2006 const char *tagname, const char **pp, 2007 bfd_boolean structp, const int *typenums) 2008 { 2009 const char *orig; 2010 bfd_vma size; 2011 debug_baseclass *baseclasses; 2012 debug_field *fields; 2013 bfd_boolean statics; 2014 debug_method *methods; 2015 debug_type vptrbase; 2016 bfd_boolean ownvptr; 2017 2018 orig = *pp; 2019 2020 /* Get the size. */ 2021 size = parse_number (pp, (bfd_boolean *) NULL); 2022 2023 /* Get the other information. */ 2024 if (! parse_stab_baseclasses (dhandle, info, pp, &baseclasses) 2025 || ! parse_stab_struct_fields (dhandle, info, pp, &fields, &statics) 2026 || ! parse_stab_members (dhandle, info, tagname, pp, typenums, &methods) 2027 || ! parse_stab_tilde_field (dhandle, info, pp, typenums, &vptrbase, 2028 &ownvptr)) 2029 return DEBUG_TYPE_NULL; 2030 2031 if (! statics 2032 && baseclasses == NULL 2033 && methods == NULL 2034 && vptrbase == DEBUG_TYPE_NULL 2035 && ! ownvptr) 2036 return debug_make_struct_type (dhandle, structp, size, fields); 2037 2038 return debug_make_object_type (dhandle, structp, size, fields, baseclasses, 2039 methods, vptrbase, ownvptr); 2040 } 2041 2042 /* The stabs for C++ derived classes contain baseclass information which 2043 is marked by a '!' character after the total size. This function is 2044 called when we encounter the baseclass marker, and slurps up all the 2045 baseclass information. 2046 2047 Immediately following the '!' marker is the number of base classes that 2048 the class is derived from, followed by information for each base class. 2049 For each base class, there are two visibility specifiers, a bit offset 2050 to the base class information within the derived class, a reference to 2051 the type for the base class, and a terminating semicolon. 2052 2053 A typical example, with two base classes, would be "!2,020,19;0264,21;". 2054 ^^ ^ ^ ^ ^ ^ ^ 2055 Baseclass information marker __________________|| | | | | | | 2056 Number of baseclasses __________________________| | | | | | | 2057 Visibility specifiers (2) ________________________| | | | | | 2058 Offset in bits from start of class _________________| | | | | 2059 Type number for base class ___________________________| | | | 2060 Visibility specifiers (2) _______________________________| | | 2061 Offset in bits from start of class ________________________| | 2062 Type number of base class ____________________________________| 2063 2064 Return TRUE for success, FALSE for failure. */ 2065 2066 static bfd_boolean 2067 parse_stab_baseclasses (void *dhandle, struct stab_handle *info, 2068 const char **pp, debug_baseclass **retp) 2069 { 2070 const char *orig; 2071 unsigned int c, i; 2072 debug_baseclass *classes; 2073 2074 *retp = NULL; 2075 2076 orig = *pp; 2077 2078 if (**pp != '!') 2079 { 2080 /* No base classes. */ 2081 return TRUE; 2082 } 2083 ++*pp; 2084 2085 c = (unsigned int) parse_number (pp, (bfd_boolean *) NULL); 2086 2087 if (**pp != ',') 2088 { 2089 bad_stab (orig); 2090 return FALSE; 2091 } 2092 ++*pp; 2093 2094 classes = (debug_baseclass *) xmalloc ((c + 1) * sizeof (**retp)); 2095 2096 for (i = 0; i < c; i++) 2097 { 2098 bfd_boolean virtual; 2099 enum debug_visibility visibility; 2100 bfd_vma bitpos; 2101 debug_type type; 2102 2103 switch (**pp) 2104 { 2105 case '0': 2106 virtual = FALSE; 2107 break; 2108 case '1': 2109 virtual = TRUE; 2110 break; 2111 default: 2112 warn_stab (orig, _("unknown virtual character for baseclass")); 2113 virtual = FALSE; 2114 break; 2115 } 2116 ++*pp; 2117 2118 switch (**pp) 2119 { 2120 case '0': 2121 visibility = DEBUG_VISIBILITY_PRIVATE; 2122 break; 2123 case '1': 2124 visibility = DEBUG_VISIBILITY_PROTECTED; 2125 break; 2126 case '2': 2127 visibility = DEBUG_VISIBILITY_PUBLIC; 2128 break; 2129 default: 2130 warn_stab (orig, _("unknown visibility character for baseclass")); 2131 visibility = DEBUG_VISIBILITY_PUBLIC; 2132 break; 2133 } 2134 ++*pp; 2135 2136 /* The remaining value is the bit offset of the portion of the 2137 object corresponding to this baseclass. Always zero in the 2138 absence of multiple inheritance. */ 2139 bitpos = parse_number (pp, (bfd_boolean *) NULL); 2140 if (**pp != ',') 2141 { 2142 bad_stab (orig); 2143 return FALSE; 2144 } 2145 ++*pp; 2146 2147 type = parse_stab_type (dhandle, info, (const char *) NULL, pp, 2148 (debug_type **) NULL); 2149 if (type == DEBUG_TYPE_NULL) 2150 return FALSE; 2151 2152 classes[i] = debug_make_baseclass (dhandle, type, bitpos, virtual, 2153 visibility); 2154 if (classes[i] == DEBUG_BASECLASS_NULL) 2155 return FALSE; 2156 2157 if (**pp != ';') 2158 return FALSE; 2159 ++*pp; 2160 } 2161 2162 classes[i] = DEBUG_BASECLASS_NULL; 2163 2164 *retp = classes; 2165 2166 return TRUE; 2167 } 2168 2169 /* Read struct or class data fields. They have the form: 2170 2171 NAME : [VISIBILITY] TYPENUM , BITPOS , BITSIZE ; 2172 2173 At the end, we see a semicolon instead of a field. 2174 2175 In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for 2176 a static field. 2177 2178 The optional VISIBILITY is one of: 2179 2180 '/0' (VISIBILITY_PRIVATE) 2181 '/1' (VISIBILITY_PROTECTED) 2182 '/2' (VISIBILITY_PUBLIC) 2183 '/9' (VISIBILITY_IGNORE) 2184 2185 or nothing, for C style fields with public visibility. 2186 2187 Returns 1 for success, 0 for failure. */ 2188 2189 static bfd_boolean 2190 parse_stab_struct_fields (void *dhandle, struct stab_handle *info, 2191 const char **pp, debug_field **retp, 2192 bfd_boolean *staticsp) 2193 { 2194 const char *orig; 2195 const char *p; 2196 debug_field *fields; 2197 unsigned int c; 2198 unsigned int alloc; 2199 2200 *retp = NULL; 2201 *staticsp = FALSE; 2202 2203 orig = *pp; 2204 2205 c = 0; 2206 alloc = 10; 2207 fields = (debug_field *) xmalloc (alloc * sizeof *fields); 2208 while (**pp != ';') 2209 { 2210 /* FIXME: gdb checks os9k_stabs here. */ 2211 2212 p = *pp; 2213 2214 /* Add 1 to c to leave room for NULL pointer at end. */ 2215 if (c + 1 >= alloc) 2216 { 2217 alloc += 10; 2218 fields = ((debug_field *) 2219 xrealloc (fields, alloc * sizeof *fields)); 2220 } 2221 2222 /* If it starts with CPLUS_MARKER it is a special abbreviation, 2223 unless the CPLUS_MARKER is followed by an underscore, in 2224 which case it is just the name of an anonymous type, which we 2225 should handle like any other type name. We accept either '$' 2226 or '.', because a field name can never contain one of these 2227 characters except as a CPLUS_MARKER. */ 2228 2229 if ((*p == '$' || *p == '.') && p[1] != '_') 2230 { 2231 ++*pp; 2232 if (! parse_stab_cpp_abbrev (dhandle, info, pp, fields + c)) 2233 return FALSE; 2234 ++c; 2235 continue; 2236 } 2237 2238 /* Look for the ':' that separates the field name from the field 2239 values. Data members are delimited by a single ':', while member 2240 functions are delimited by a pair of ':'s. When we hit the member 2241 functions (if any), terminate scan loop and return. */ 2242 2243 p = strchr (p, ':'); 2244 if (p == NULL) 2245 { 2246 bad_stab (orig); 2247 return FALSE; 2248 } 2249 2250 if (p[1] == ':') 2251 break; 2252 2253 if (! parse_stab_one_struct_field (dhandle, info, pp, p, fields + c, 2254 staticsp)) 2255 return FALSE; 2256 2257 ++c; 2258 } 2259 2260 fields[c] = DEBUG_FIELD_NULL; 2261 2262 *retp = fields; 2263 2264 return TRUE; 2265 } 2266 2267 /* Special GNU C++ name. */ 2268 2269 static bfd_boolean 2270 parse_stab_cpp_abbrev (void *dhandle, struct stab_handle *info, 2271 const char **pp, debug_field *retp) 2272 { 2273 const char *orig; 2274 int cpp_abbrev; 2275 debug_type context; 2276 const char *name; 2277 const char *typename; 2278 debug_type type; 2279 bfd_vma bitpos; 2280 2281 *retp = DEBUG_FIELD_NULL; 2282 2283 orig = *pp; 2284 2285 if (**pp != 'v') 2286 { 2287 bad_stab (*pp); 2288 return FALSE; 2289 } 2290 ++*pp; 2291 2292 cpp_abbrev = **pp; 2293 ++*pp; 2294 2295 /* At this point, *pp points to something like "22:23=*22...", where 2296 the type number before the ':' is the "context" and everything 2297 after is a regular type definition. Lookup the type, find it's 2298 name, and construct the field name. */ 2299 2300 context = parse_stab_type (dhandle, info, (const char *) NULL, pp, 2301 (debug_type **) NULL); 2302 if (context == DEBUG_TYPE_NULL) 2303 return FALSE; 2304 2305 switch (cpp_abbrev) 2306 { 2307 case 'f': 2308 /* $vf -- a virtual function table pointer. */ 2309 name = "_vptr$"; 2310 break; 2311 case 'b': 2312 /* $vb -- a virtual bsomethingorother */ 2313 typename = debug_get_type_name (dhandle, context); 2314 if (typename == NULL) 2315 { 2316 warn_stab (orig, _("unnamed $vb type")); 2317 typename = "FOO"; 2318 } 2319 name = concat ("_vb$", typename, (const char *) NULL); 2320 break; 2321 default: 2322 warn_stab (orig, _("unrecognized C++ abbreviation")); 2323 name = "INVALID_CPLUSPLUS_ABBREV"; 2324 break; 2325 } 2326 2327 if (**pp != ':') 2328 { 2329 bad_stab (orig); 2330 return FALSE; 2331 } 2332 ++*pp; 2333 2334 type = parse_stab_type (dhandle, info, (const char *) NULL, pp, 2335 (debug_type **) NULL); 2336 if (**pp != ',') 2337 { 2338 bad_stab (orig); 2339 return FALSE; 2340 } 2341 ++*pp; 2342 2343 bitpos = parse_number (pp, (bfd_boolean *) NULL); 2344 if (**pp != ';') 2345 { 2346 bad_stab (orig); 2347 return FALSE; 2348 } 2349 ++*pp; 2350 2351 *retp = debug_make_field (dhandle, name, type, bitpos, 0, 2352 DEBUG_VISIBILITY_PRIVATE); 2353 if (*retp == DEBUG_FIELD_NULL) 2354 return FALSE; 2355 2356 return TRUE; 2357 } 2358 2359 /* Parse a single field in a struct or union. */ 2360 2361 static bfd_boolean 2362 parse_stab_one_struct_field (void *dhandle, struct stab_handle *info, 2363 const char **pp, const char *p, 2364 debug_field *retp, bfd_boolean *staticsp) 2365 { 2366 const char *orig; 2367 char *name; 2368 enum debug_visibility visibility; 2369 debug_type type; 2370 bfd_vma bitpos; 2371 bfd_vma bitsize; 2372 2373 orig = *pp; 2374 2375 /* FIXME: gdb checks ARM_DEMANGLING here. */ 2376 2377 name = savestring (*pp, p - *pp); 2378 2379 *pp = p + 1; 2380 2381 if (**pp != '/') 2382 visibility = DEBUG_VISIBILITY_PUBLIC; 2383 else 2384 { 2385 ++*pp; 2386 switch (**pp) 2387 { 2388 case '0': 2389 visibility = DEBUG_VISIBILITY_PRIVATE; 2390 break; 2391 case '1': 2392 visibility = DEBUG_VISIBILITY_PROTECTED; 2393 break; 2394 case '2': 2395 visibility = DEBUG_VISIBILITY_PUBLIC; 2396 break; 2397 default: 2398 warn_stab (orig, _("unknown visibility character for field")); 2399 visibility = DEBUG_VISIBILITY_PUBLIC; 2400 break; 2401 } 2402 ++*pp; 2403 } 2404 2405 type = parse_stab_type (dhandle, info, (const char *) NULL, pp, 2406 (debug_type **) NULL); 2407 if (type == DEBUG_TYPE_NULL) 2408 return FALSE; 2409 2410 if (**pp == ':') 2411 { 2412 char *varname; 2413 2414 /* This is a static class member. */ 2415 ++*pp; 2416 p = strchr (*pp, ';'); 2417 if (p == NULL) 2418 { 2419 bad_stab (orig); 2420 return FALSE; 2421 } 2422 2423 varname = savestring (*pp, p - *pp); 2424 2425 *pp = p + 1; 2426 2427 *retp = debug_make_static_member (dhandle, name, type, varname, 2428 visibility); 2429 *staticsp = TRUE; 2430 2431 return TRUE; 2432 } 2433 2434 if (**pp != ',') 2435 { 2436 bad_stab (orig); 2437 return FALSE; 2438 } 2439 ++*pp; 2440 2441 bitpos = parse_number (pp, (bfd_boolean *) NULL); 2442 if (**pp != ',') 2443 { 2444 bad_stab (orig); 2445 return FALSE; 2446 } 2447 ++*pp; 2448 2449 bitsize = parse_number (pp, (bfd_boolean *) NULL); 2450 if (**pp != ';') 2451 { 2452 bad_stab (orig); 2453 return FALSE; 2454 } 2455 ++*pp; 2456 2457 if (bitpos == 0 && bitsize == 0) 2458 { 2459 /* This can happen in two cases: (1) at least for gcc 2.4.5 or 2460 so, it is a field which has been optimized out. The correct 2461 stab for this case is to use VISIBILITY_IGNORE, but that is a 2462 recent invention. (2) It is a 0-size array. For example 2463 union { int num; char str[0]; } foo. Printing "<no value>" 2464 for str in "p foo" is OK, since foo.str (and thus foo.str[3]) 2465 will continue to work, and a 0-size array as a whole doesn't 2466 have any contents to print. 2467 2468 I suspect this probably could also happen with gcc -gstabs 2469 (not -gstabs+) for static fields, and perhaps other C++ 2470 extensions. Hopefully few people use -gstabs with gdb, since 2471 it is intended for dbx compatibility. */ 2472 visibility = DEBUG_VISIBILITY_IGNORE; 2473 } 2474 2475 /* FIXME: gdb does some stuff here to mark fields as unpacked. */ 2476 2477 *retp = debug_make_field (dhandle, name, type, bitpos, bitsize, visibility); 2478 2479 return TRUE; 2480 } 2481 2482 /* Read member function stabs info for C++ classes. The form of each member 2483 function data is: 2484 2485 NAME :: TYPENUM[=type definition] ARGS : PHYSNAME ; 2486 2487 An example with two member functions is: 2488 2489 afunc1::20=##15;:i;2A.;afunc2::20:i;2A.; 2490 2491 For the case of overloaded operators, the format is op$::*.funcs, where 2492 $ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator 2493 name (such as `+=') and `.' marks the end of the operator name. */ 2494 2495 static bfd_boolean 2496 parse_stab_members (void *dhandle, struct stab_handle *info, 2497 const char *tagname, const char **pp, 2498 const int *typenums, debug_method **retp) 2499 { 2500 const char *orig; 2501 debug_method *methods; 2502 unsigned int c; 2503 unsigned int alloc; 2504 2505 *retp = NULL; 2506 2507 orig = *pp; 2508 2509 alloc = 0; 2510 methods = NULL; 2511 c = 0; 2512 2513 while (**pp != ';') 2514 { 2515 const char *p; 2516 char *name; 2517 debug_method_variant *variants; 2518 unsigned int cvars; 2519 unsigned int allocvars; 2520 debug_type look_ahead_type; 2521 2522 p = strchr (*pp, ':'); 2523 if (p == NULL || p[1] != ':') 2524 break; 2525 2526 /* FIXME: Some systems use something other than '$' here. */ 2527 if ((*pp)[0] != 'o' || (*pp)[1] != 'p' || (*pp)[2] != '$') 2528 { 2529 name = savestring (*pp, p - *pp); 2530 *pp = p + 2; 2531 } 2532 else 2533 { 2534 /* This is a completely weird case. In order to stuff in the 2535 names that might contain colons (the usual name delimiter), 2536 Mike Tiemann defined a different name format which is 2537 signalled if the identifier is "op$". In that case, the 2538 format is "op$::XXXX." where XXXX is the name. This is 2539 used for names like "+" or "=". YUUUUUUUK! FIXME! */ 2540 *pp = p + 2; 2541 for (p = *pp; *p != '.' && *p != '\0'; p++) 2542 ; 2543 if (*p != '.') 2544 { 2545 bad_stab (orig); 2546 return FALSE; 2547 } 2548 name = savestring (*pp, p - *pp); 2549 *pp = p + 1; 2550 } 2551 2552 allocvars = 10; 2553 variants = ((debug_method_variant *) 2554 xmalloc (allocvars * sizeof *variants)); 2555 cvars = 0; 2556 2557 look_ahead_type = DEBUG_TYPE_NULL; 2558 2559 do 2560 { 2561 debug_type type; 2562 bfd_boolean stub; 2563 char *argtypes; 2564 enum debug_visibility visibility; 2565 bfd_boolean constp, volatilep, staticp; 2566 bfd_vma voffset; 2567 debug_type context; 2568 const char *physname; 2569 bfd_boolean varargs; 2570 2571 if (look_ahead_type != DEBUG_TYPE_NULL) 2572 { 2573 /* g++ version 1 kludge */ 2574 type = look_ahead_type; 2575 look_ahead_type = DEBUG_TYPE_NULL; 2576 } 2577 else 2578 { 2579 type = parse_stab_type (dhandle, info, (const char *) NULL, pp, 2580 (debug_type **) NULL); 2581 if (type == DEBUG_TYPE_NULL) 2582 return FALSE; 2583 if (**pp != ':') 2584 { 2585 bad_stab (orig); 2586 return FALSE; 2587 } 2588 } 2589 2590 ++*pp; 2591 p = strchr (*pp, ';'); 2592 if (p == NULL) 2593 { 2594 bad_stab (orig); 2595 return FALSE; 2596 } 2597 2598 stub = FALSE; 2599 if (debug_get_type_kind (dhandle, type) == DEBUG_KIND_METHOD 2600 && debug_get_parameter_types (dhandle, type, &varargs) == NULL) 2601 stub = TRUE; 2602 2603 argtypes = savestring (*pp, p - *pp); 2604 *pp = p + 1; 2605 2606 switch (**pp) 2607 { 2608 case '0': 2609 visibility = DEBUG_VISIBILITY_PRIVATE; 2610 break; 2611 case '1': 2612 visibility = DEBUG_VISIBILITY_PROTECTED; 2613 break; 2614 default: 2615 visibility = DEBUG_VISIBILITY_PUBLIC; 2616 break; 2617 } 2618 ++*pp; 2619 2620 constp = FALSE; 2621 volatilep = FALSE; 2622 switch (**pp) 2623 { 2624 case 'A': 2625 /* Normal function. */ 2626 ++*pp; 2627 break; 2628 case 'B': 2629 /* const member function. */ 2630 constp = TRUE; 2631 ++*pp; 2632 break; 2633 case 'C': 2634 /* volatile member function. */ 2635 volatilep = TRUE; 2636 ++*pp; 2637 break; 2638 case 'D': 2639 /* const volatile member function. */ 2640 constp = TRUE; 2641 volatilep = TRUE; 2642 ++*pp; 2643 break; 2644 case '*': 2645 case '?': 2646 case '.': 2647 /* File compiled with g++ version 1; no information. */ 2648 break; 2649 default: 2650 warn_stab (orig, _("const/volatile indicator missing")); 2651 break; 2652 } 2653 2654 staticp = FALSE; 2655 switch (**pp) 2656 { 2657 case '*': 2658 /* virtual member function, followed by index. The sign 2659 bit is supposedly set to distinguish 2660 pointers-to-methods from virtual function indicies. */ 2661 ++*pp; 2662 voffset = parse_number (pp, (bfd_boolean *) NULL); 2663 if (**pp != ';') 2664 { 2665 bad_stab (orig); 2666 return FALSE; 2667 } 2668 ++*pp; 2669 voffset &= 0x7fffffff; 2670 2671 if (**pp == ';' || *pp == '\0') 2672 { 2673 /* Must be g++ version 1. */ 2674 context = DEBUG_TYPE_NULL; 2675 } 2676 else 2677 { 2678 /* Figure out from whence this virtual function 2679 came. It may belong to virtual function table of 2680 one of its baseclasses. */ 2681 look_ahead_type = parse_stab_type (dhandle, info, 2682 (const char *) NULL, 2683 pp, 2684 (debug_type **) NULL); 2685 if (**pp == ':') 2686 { 2687 /* g++ version 1 overloaded methods. */ 2688 context = DEBUG_TYPE_NULL; 2689 } 2690 else 2691 { 2692 context = look_ahead_type; 2693 look_ahead_type = DEBUG_TYPE_NULL; 2694 if (**pp != ';') 2695 { 2696 bad_stab (orig); 2697 return FALSE; 2698 } 2699 ++*pp; 2700 } 2701 } 2702 break; 2703 2704 case '?': 2705 /* static member function. */ 2706 ++*pp; 2707 staticp = TRUE; 2708 voffset = 0; 2709 context = DEBUG_TYPE_NULL; 2710 if (strncmp (argtypes, name, strlen (name)) != 0) 2711 stub = TRUE; 2712 break; 2713 2714 default: 2715 warn_stab (orig, "member function type missing"); 2716 voffset = 0; 2717 context = DEBUG_TYPE_NULL; 2718 break; 2719 2720 case '.': 2721 ++*pp; 2722 voffset = 0; 2723 context = DEBUG_TYPE_NULL; 2724 break; 2725 } 2726 2727 /* If the type is not a stub, then the argtypes string is 2728 the physical name of the function. Otherwise the 2729 argtypes string is the mangled form of the argument 2730 types, and the full type and the physical name must be 2731 extracted from them. */ 2732 if (! stub) 2733 physname = argtypes; 2734 else 2735 { 2736 debug_type class_type, return_type; 2737 2738 class_type = stab_find_type (dhandle, info, typenums); 2739 if (class_type == DEBUG_TYPE_NULL) 2740 return FALSE; 2741 return_type = debug_get_return_type (dhandle, type); 2742 if (return_type == DEBUG_TYPE_NULL) 2743 { 2744 bad_stab (orig); 2745 return FALSE; 2746 } 2747 type = parse_stab_argtypes (dhandle, info, class_type, name, 2748 tagname, return_type, argtypes, 2749 constp, volatilep, &physname); 2750 if (type == DEBUG_TYPE_NULL) 2751 return FALSE; 2752 } 2753 2754 if (cvars + 1 >= allocvars) 2755 { 2756 allocvars += 10; 2757 variants = ((debug_method_variant *) 2758 xrealloc (variants, 2759 allocvars * sizeof *variants)); 2760 } 2761 2762 if (! staticp) 2763 variants[cvars] = debug_make_method_variant (dhandle, physname, 2764 type, visibility, 2765 constp, volatilep, 2766 voffset, context); 2767 else 2768 variants[cvars] = debug_make_static_method_variant (dhandle, 2769 physname, 2770 type, 2771 visibility, 2772 constp, 2773 volatilep); 2774 if (variants[cvars] == DEBUG_METHOD_VARIANT_NULL) 2775 return FALSE; 2776 2777 ++cvars; 2778 } 2779 while (**pp != ';' && **pp != '\0'); 2780 2781 variants[cvars] = DEBUG_METHOD_VARIANT_NULL; 2782 2783 if (**pp != '\0') 2784 ++*pp; 2785 2786 if (c + 1 >= alloc) 2787 { 2788 alloc += 10; 2789 methods = ((debug_method *) 2790 xrealloc (methods, alloc * sizeof *methods)); 2791 } 2792 2793 methods[c] = debug_make_method (dhandle, name, variants); 2794 2795 ++c; 2796 } 2797 2798 if (methods != NULL) 2799 methods[c] = DEBUG_METHOD_NULL; 2800 2801 *retp = methods; 2802 2803 return TRUE; 2804 } 2805 2806 /* Parse a string representing argument types for a method. Stabs 2807 tries to save space by packing argument types into a mangled 2808 string. This string should give us enough information to extract 2809 both argument types and the physical name of the function, given 2810 the tag name. */ 2811 2812 static debug_type 2813 parse_stab_argtypes (void *dhandle, struct stab_handle *info, 2814 debug_type class_type, const char *fieldname, 2815 const char *tagname, debug_type return_type, 2816 const char *argtypes, bfd_boolean constp, 2817 bfd_boolean volatilep, const char **pphysname) 2818 { 2819 bfd_boolean is_full_physname_constructor; 2820 bfd_boolean is_constructor; 2821 bfd_boolean is_destructor; 2822 bfd_boolean is_v3; 2823 debug_type *args; 2824 bfd_boolean varargs; 2825 unsigned int physname_len = 0; 2826 2827 /* Constructors are sometimes handled specially. */ 2828 is_full_physname_constructor = ((argtypes[0] == '_' 2829 && argtypes[1] == '_' 2830 && (ISDIGIT (argtypes[2]) 2831 || argtypes[2] == 'Q' 2832 || argtypes[2] == 't')) 2833 || CONST_STRNEQ (argtypes, "__ct")); 2834 2835 is_constructor = (is_full_physname_constructor 2836 || (tagname != NULL 2837 && strcmp (fieldname, tagname) == 0)); 2838 is_destructor = ((argtypes[0] == '_' 2839 && (argtypes[1] == '$' || argtypes[1] == '.') 2840 && argtypes[2] == '_') 2841 || CONST_STRNEQ (argtypes, "__dt")); 2842 is_v3 = argtypes[0] == '_' && argtypes[1] == 'Z'; 2843 2844 if (is_destructor || is_full_physname_constructor || is_v3) 2845 *pphysname = argtypes; 2846 else 2847 { 2848 unsigned int len; 2849 const char *const_prefix; 2850 const char *volatile_prefix; 2851 char buf[20]; 2852 unsigned int mangled_name_len; 2853 char *physname; 2854 2855 len = tagname == NULL ? 0 : strlen (tagname); 2856 const_prefix = constp ? "C" : ""; 2857 volatile_prefix = volatilep ? "V" : ""; 2858 2859 if (len == 0) 2860 sprintf (buf, "__%s%s", const_prefix, volatile_prefix); 2861 else if (tagname != NULL && strchr (tagname, '<') != NULL) 2862 { 2863 /* Template methods are fully mangled. */ 2864 sprintf (buf, "__%s%s", const_prefix, volatile_prefix); 2865 tagname = NULL; 2866 len = 0; 2867 } 2868 else 2869 sprintf (buf, "__%s%s%d", const_prefix, volatile_prefix, len); 2870 2871 mangled_name_len = ((is_constructor ? 0 : strlen (fieldname)) 2872 + strlen (buf) 2873 + len 2874 + strlen (argtypes) 2875 + 1); 2876 2877 if (fieldname[0] == 'o' 2878 && fieldname[1] == 'p' 2879 && (fieldname[2] == '$' || fieldname[2] == '.')) 2880 { 2881 const char *opname; 2882 2883 opname = cplus_mangle_opname (fieldname + 3, 0); 2884 if (opname == NULL) 2885 { 2886 fprintf (stderr, _("No mangling for \"%s\"\n"), fieldname); 2887 return DEBUG_TYPE_NULL; 2888 } 2889 mangled_name_len += strlen (opname); 2890 physname = (char *) xmalloc (mangled_name_len); 2891 strncpy (physname, fieldname, 3); 2892 strcpy (physname + 3, opname); 2893 } 2894 else 2895 { 2896 physname = (char *) xmalloc (mangled_name_len); 2897 if (is_constructor) 2898 physname[0] = '\0'; 2899 else 2900 strcpy (physname, fieldname); 2901 } 2902 2903 physname_len = strlen (physname); 2904 strcat (physname, buf); 2905 if (tagname != NULL) 2906 strcat (physname, tagname); 2907 strcat (physname, argtypes); 2908 2909 *pphysname = physname; 2910 } 2911 2912 if (*argtypes == '\0' || is_destructor) 2913 { 2914 args = (debug_type *) xmalloc (sizeof *args); 2915 *args = NULL; 2916 return debug_make_method_type (dhandle, return_type, class_type, args, 2917 FALSE); 2918 } 2919 2920 args = stab_demangle_argtypes (dhandle, info, *pphysname, &varargs, physname_len); 2921 if (args == NULL) 2922 return DEBUG_TYPE_NULL; 2923 2924 return debug_make_method_type (dhandle, return_type, class_type, args, 2925 varargs); 2926 } 2927 2928 /* The tail end of stabs for C++ classes that contain a virtual function 2929 pointer contains a tilde, a %, and a type number. 2930 The type number refers to the base class (possibly this class itself) which 2931 contains the vtable pointer for the current class. 2932 2933 This function is called when we have parsed all the method declarations, 2934 so we can look for the vptr base class info. */ 2935 2936 static bfd_boolean 2937 parse_stab_tilde_field (void *dhandle, struct stab_handle *info, 2938 const char **pp, const int *typenums, 2939 debug_type *retvptrbase, bfd_boolean *retownvptr) 2940 { 2941 const char *orig; 2942 const char *hold; 2943 int vtypenums[2]; 2944 2945 *retvptrbase = DEBUG_TYPE_NULL; 2946 *retownvptr = FALSE; 2947 2948 orig = *pp; 2949 2950 /* If we are positioned at a ';', then skip it. */ 2951 if (**pp == ';') 2952 ++*pp; 2953 2954 if (**pp != '~') 2955 return TRUE; 2956 2957 ++*pp; 2958 2959 if (**pp == '=' || **pp == '+' || **pp == '-') 2960 { 2961 /* Obsolete flags that used to indicate the presence of 2962 constructors and/or destructors. */ 2963 ++*pp; 2964 } 2965 2966 if (**pp != '%') 2967 return TRUE; 2968 2969 ++*pp; 2970 2971 hold = *pp; 2972 2973 /* The next number is the type number of the base class (possibly 2974 our own class) which supplies the vtable for this class. */ 2975 if (! parse_stab_type_number (pp, vtypenums)) 2976 return FALSE; 2977 2978 if (vtypenums[0] == typenums[0] 2979 && vtypenums[1] == typenums[1]) 2980 *retownvptr = TRUE; 2981 else 2982 { 2983 debug_type vtype; 2984 const char *p; 2985 2986 *pp = hold; 2987 2988 vtype = parse_stab_type (dhandle, info, (const char *) NULL, pp, 2989 (debug_type **) NULL); 2990 for (p = *pp; *p != ';' && *p != '\0'; p++) 2991 ; 2992 if (*p != ';') 2993 { 2994 bad_stab (orig); 2995 return FALSE; 2996 } 2997 2998 *retvptrbase = vtype; 2999 3000 *pp = p + 1; 3001 } 3002 3003 return TRUE; 3004 } 3005 3006 /* Read a definition of an array type. */ 3007 3008 static debug_type 3009 parse_stab_array_type (void *dhandle, struct stab_handle *info, 3010 const char **pp, bfd_boolean stringp) 3011 { 3012 const char *orig; 3013 const char *p; 3014 int typenums[2]; 3015 debug_type index_type; 3016 bfd_boolean adjustable; 3017 bfd_signed_vma lower, upper; 3018 debug_type element_type; 3019 3020 /* Format of an array type: 3021 "ar<index type>;lower;upper;<array_contents_type>". 3022 OS9000: "arlower,upper;<array_contents_type>". 3023 3024 Fortran adjustable arrays use Adigits or Tdigits for lower or upper; 3025 for these, produce a type like float[][]. */ 3026 3027 orig = *pp; 3028 3029 /* FIXME: gdb checks os9k_stabs here. */ 3030 3031 /* If the index type is type 0, we take it as int. */ 3032 p = *pp; 3033 if (! parse_stab_type_number (&p, typenums)) 3034 return DEBUG_TYPE_NULL; 3035 if (typenums[0] == 0 && typenums[1] == 0 && **pp != '=') 3036 { 3037 index_type = debug_find_named_type (dhandle, "int"); 3038 if (index_type == DEBUG_TYPE_NULL) 3039 { 3040 index_type = debug_make_int_type (dhandle, 4, FALSE); 3041 if (index_type == DEBUG_TYPE_NULL) 3042 return DEBUG_TYPE_NULL; 3043 } 3044 *pp = p; 3045 } 3046 else 3047 { 3048 index_type = parse_stab_type (dhandle, info, (const char *) NULL, pp, 3049 (debug_type **) NULL); 3050 } 3051 3052 if (**pp != ';') 3053 { 3054 bad_stab (orig); 3055 return DEBUG_TYPE_NULL; 3056 } 3057 ++*pp; 3058 3059 adjustable = FALSE; 3060 3061 if (! ISDIGIT (**pp) && **pp != '-') 3062 { 3063 ++*pp; 3064 adjustable = TRUE; 3065 } 3066 3067 lower = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL); 3068 if (**pp != ';') 3069 { 3070 bad_stab (orig); 3071 return DEBUG_TYPE_NULL; 3072 } 3073 ++*pp; 3074 3075 if (! ISDIGIT (**pp) && **pp != '-') 3076 { 3077 ++*pp; 3078 adjustable = TRUE; 3079 } 3080 3081 upper = (bfd_signed_vma) parse_number (pp, (bfd_boolean *) NULL); 3082 if (**pp != ';') 3083 { 3084 bad_stab (orig); 3085 return DEBUG_TYPE_NULL; 3086 } 3087 ++*pp; 3088 3089 element_type = parse_stab_type (dhandle, info, (const char *) NULL, pp, 3090 (debug_type **) NULL); 3091 if (element_type == DEBUG_TYPE_NULL) 3092 return DEBUG_TYPE_NULL; 3093 3094 if (adjustable) 3095 { 3096 lower = 0; 3097 upper = -1; 3098 } 3099 3100 return debug_make_array_type (dhandle, element_type, index_type, lower, 3101 upper, stringp); 3102 } 3103 3104 /* This struct holds information about files we have seen using 3105 N_BINCL. */ 3106 3107 struct bincl_file 3108 { 3109 /* The next N_BINCL file. */ 3110 struct bincl_file *next; 3111 /* The next N_BINCL on the stack. */ 3112 struct bincl_file *next_stack; 3113 /* The file name. */ 3114 const char *name; 3115 /* The hash value. */ 3116 bfd_vma hash; 3117 /* The file index. */ 3118 unsigned int file; 3119 /* The list of types defined in this file. */ 3120 struct stab_types *file_types; 3121 }; 3122 3123 /* Start a new N_BINCL file, pushing it onto the stack. */ 3124 3125 static void 3126 push_bincl (struct stab_handle *info, const char *name, bfd_vma hash) 3127 { 3128 struct bincl_file *n; 3129 3130 n = (struct bincl_file *) xmalloc (sizeof *n); 3131 n->next = info->bincl_list; 3132 n->next_stack = info->bincl_stack; 3133 n->name = name; 3134 n->hash = hash; 3135 n->file = info->files; 3136 n->file_types = NULL; 3137 info->bincl_list = n; 3138 info->bincl_stack = n; 3139 3140 ++info->files; 3141 info->file_types = ((struct stab_types **) 3142 xrealloc (info->file_types, 3143 (info->files 3144 * sizeof *info->file_types))); 3145 info->file_types[n->file] = NULL; 3146 } 3147 3148 /* Finish an N_BINCL file, at an N_EINCL, popping the name off the 3149 stack. */ 3150 3151 static const char * 3152 pop_bincl (struct stab_handle *info) 3153 { 3154 struct bincl_file *o; 3155 3156 o = info->bincl_stack; 3157 if (o == NULL) 3158 return info->main_filename; 3159 info->bincl_stack = o->next_stack; 3160 3161 o->file_types = info->file_types[o->file]; 3162 3163 if (info->bincl_stack == NULL) 3164 return info->main_filename; 3165 return info->bincl_stack->name; 3166 } 3167 3168 /* Handle an N_EXCL: get the types from the corresponding N_BINCL. */ 3169 3170 static bfd_boolean 3171 find_excl (struct stab_handle *info, const char *name, bfd_vma hash) 3172 { 3173 struct bincl_file *l; 3174 3175 ++info->files; 3176 info->file_types = ((struct stab_types **) 3177 xrealloc (info->file_types, 3178 (info->files 3179 * sizeof *info->file_types))); 3180 3181 for (l = info->bincl_list; l != NULL; l = l->next) 3182 if (l->hash == hash && strcmp (l->name, name) == 0) 3183 break; 3184 if (l == NULL) 3185 { 3186 warn_stab (name, _("Undefined N_EXCL")); 3187 info->file_types[info->files - 1] = NULL; 3188 return TRUE; 3189 } 3190 3191 info->file_types[info->files - 1] = l->file_types; 3192 3193 return TRUE; 3194 } 3195 3196 /* Handle a variable definition. gcc emits variable definitions for a 3197 block before the N_LBRAC, so we must hold onto them until we see 3198 it. The SunPRO compiler emits variable definitions after the 3199 N_LBRAC, so we can call debug_record_variable immediately. */ 3200 3201 static bfd_boolean 3202 stab_record_variable (void *dhandle, struct stab_handle *info, 3203 const char *name, debug_type type, 3204 enum debug_var_kind kind, bfd_vma val) 3205 { 3206 struct stab_pending_var *v; 3207 3208 if ((kind == DEBUG_GLOBAL || kind == DEBUG_STATIC) 3209 || ! info->within_function 3210 || (info->gcc_compiled == 0 && info->n_opt_found)) 3211 return debug_record_variable (dhandle, name, type, kind, val); 3212 3213 v = (struct stab_pending_var *) xmalloc (sizeof *v); 3214 memset (v, 0, sizeof *v); 3215 3216 v->next = info->pending; 3217 v->name = name; 3218 v->type = type; 3219 v->kind = kind; 3220 v->val = val; 3221 info->pending = v; 3222 3223 return TRUE; 3224 } 3225 3226 /* Emit pending variable definitions. This is called after we see the 3227 N_LBRAC that starts the block. */ 3228 3229 static bfd_boolean 3230 stab_emit_pending_vars (void *dhandle, struct stab_handle *info) 3231 { 3232 struct stab_pending_var *v; 3233 3234 v = info->pending; 3235 while (v != NULL) 3236 { 3237 struct stab_pending_var *next; 3238 3239 if (! debug_record_variable (dhandle, v->name, v->type, v->kind, v->val)) 3240 return FALSE; 3241 3242 next = v->next; 3243 free (v); 3244 v = next; 3245 } 3246 3247 info->pending = NULL; 3248 3249 return TRUE; 3250 } 3251 3252 /* Find the slot for a type in the database. */ 3253 3254 static debug_type * 3255 stab_find_slot (struct stab_handle *info, const int *typenums) 3256 { 3257 int filenum; 3258 int index; 3259 struct stab_types **ps; 3260 3261 filenum = typenums[0]; 3262 index = typenums[1]; 3263 3264 if (filenum < 0 || (unsigned int) filenum >= info->files) 3265 { 3266 fprintf (stderr, _("Type file number %d out of range\n"), filenum); 3267 return NULL; 3268 } 3269 if (index < 0) 3270 { 3271 fprintf (stderr, _("Type index number %d out of range\n"), index); 3272 return NULL; 3273 } 3274 3275 ps = info->file_types + filenum; 3276 3277 while (index >= STAB_TYPES_SLOTS) 3278 { 3279 if (*ps == NULL) 3280 { 3281 *ps = (struct stab_types *) xmalloc (sizeof **ps); 3282 memset (*ps, 0, sizeof **ps); 3283 } 3284 ps = &(*ps)->next; 3285 index -= STAB_TYPES_SLOTS; 3286 } 3287 if (*ps == NULL) 3288 { 3289 *ps = (struct stab_types *) xmalloc (sizeof **ps); 3290 memset (*ps, 0, sizeof **ps); 3291 } 3292 3293 return (*ps)->types + index; 3294 } 3295 3296 /* Find a type given a type number. If the type has not been 3297 allocated yet, create an indirect type. */ 3298 3299 static debug_type 3300 stab_find_type (void *dhandle, struct stab_handle *info, const int *typenums) 3301 { 3302 debug_type *slot; 3303 3304 if (typenums[0] == 0 && typenums[1] < 0) 3305 { 3306 /* A negative type number indicates an XCOFF builtin type. */ 3307 return stab_xcoff_builtin_type (dhandle, info, typenums[1]); 3308 } 3309 3310 slot = stab_find_slot (info, typenums); 3311 if (slot == NULL) 3312 return DEBUG_TYPE_NULL; 3313 3314 if (*slot == DEBUG_TYPE_NULL) 3315 return debug_make_indirect_type (dhandle, slot, (const char *) NULL); 3316 3317 return *slot; 3318 } 3319 3320 /* Record that a given type number refers to a given type. */ 3321 3322 static bfd_boolean 3323 stab_record_type (void *dhandle ATTRIBUTE_UNUSED, struct stab_handle *info, 3324 const int *typenums, debug_type type) 3325 { 3326 debug_type *slot; 3327 3328 slot = stab_find_slot (info, typenums); 3329 if (slot == NULL) 3330 return FALSE; 3331 3332 /* gdb appears to ignore type redefinitions, so we do as well. */ 3333 3334 *slot = type; 3335 3336 return TRUE; 3337 } 3338 3339 /* Return an XCOFF builtin type. */ 3340 3341 static debug_type 3342 stab_xcoff_builtin_type (void *dhandle, struct stab_handle *info, 3343 int typenum) 3344 { 3345 debug_type rettype; 3346 const char *name; 3347 3348 if (typenum >= 0 || typenum < -XCOFF_TYPE_COUNT) 3349 { 3350 fprintf (stderr, _("Unrecognized XCOFF type %d\n"), typenum); 3351 return DEBUG_TYPE_NULL; 3352 } 3353 if (info->xcoff_types[-typenum] != NULL) 3354 return info->xcoff_types[-typenum]; 3355 3356 switch (-typenum) 3357 { 3358 case 1: 3359 /* The size of this and all the other types are fixed, defined 3360 by the debugging format. */ 3361 name = "int"; 3362 rettype = debug_make_int_type (dhandle, 4, FALSE); 3363 break; 3364 case 2: 3365 name = "char"; 3366 rettype = debug_make_int_type (dhandle, 1, FALSE); 3367 break; 3368 case 3: 3369 name = "short"; 3370 rettype = debug_make_int_type (dhandle, 2, FALSE); 3371 break; 3372 case 4: 3373 name = "long"; 3374 rettype = debug_make_int_type (dhandle, 4, FALSE); 3375 break; 3376 case 5: 3377 name = "unsigned char"; 3378 rettype = debug_make_int_type (dhandle, 1, TRUE); 3379 break; 3380 case 6: 3381 name = "signed char"; 3382 rettype = debug_make_int_type (dhandle, 1, FALSE); 3383 break; 3384 case 7: 3385 name = "unsigned short"; 3386 rettype = debug_make_int_type (dhandle, 2, TRUE); 3387 break; 3388 case 8: 3389 name = "unsigned int"; 3390 rettype = debug_make_int_type (dhandle, 4, TRUE); 3391 break; 3392 case 9: 3393 name = "unsigned"; 3394 rettype = debug_make_int_type (dhandle, 4, TRUE); 3395 case 10: 3396 name = "unsigned long"; 3397 rettype = debug_make_int_type (dhandle, 4, TRUE); 3398 break; 3399 case 11: 3400 name = "void"; 3401 rettype = debug_make_void_type (dhandle); 3402 break; 3403 case 12: 3404 /* IEEE single precision (32 bit). */ 3405 name = "float"; 3406 rettype = debug_make_float_type (dhandle, 4); 3407 break; 3408 case 13: 3409 /* IEEE double precision (64 bit). */ 3410 name = "double"; 3411 rettype = debug_make_float_type (dhandle, 8); 3412 break; 3413 case 14: 3414 /* This is an IEEE double on the RS/6000, and different machines 3415 with different sizes for "long double" should use different 3416 negative type numbers. See stabs.texinfo. */ 3417 name = "long double"; 3418 rettype = debug_make_float_type (dhandle, 8); 3419 break; 3420 case 15: 3421 name = "integer"; 3422 rettype = debug_make_int_type (dhandle, 4, FALSE); 3423 break; 3424 case 16: 3425 name = "boolean"; 3426 rettype = debug_make_bool_type (dhandle, 4); 3427 break; 3428 case 17: 3429 name = "short real"; 3430 rettype = debug_make_float_type (dhandle, 4); 3431 break; 3432 case 18: 3433 name = "real"; 3434 rettype = debug_make_float_type (dhandle, 8); 3435 break; 3436 case 19: 3437 /* FIXME */ 3438 name = "stringptr"; 3439 rettype = NULL; 3440 break; 3441 case 20: 3442 /* FIXME */ 3443 name = "character"; 3444 rettype = debug_make_int_type (dhandle, 1, TRUE); 3445 break; 3446 case 21: 3447 name = "logical*1"; 3448 rettype = debug_make_bool_type (dhandle, 1); 3449 break; 3450 case 22: 3451 name = "logical*2"; 3452 rettype = debug_make_bool_type (dhandle, 2); 3453 break; 3454 case 23: 3455 name = "logical*4"; 3456 rettype = debug_make_bool_type (dhandle, 4); 3457 break; 3458 case 24: 3459 name = "logical"; 3460 rettype = debug_make_bool_type (dhandle, 4); 3461 break; 3462 case 25: 3463 /* Complex type consisting of two IEEE single precision values. */ 3464 name = "complex"; 3465 rettype = debug_make_complex_type (dhandle, 8); 3466 break; 3467 case 26: 3468 /* Complex type consisting of two IEEE double precision values. */ 3469 name = "double complex"; 3470 rettype = debug_make_complex_type (dhandle, 16); 3471 break; 3472 case 27: 3473 name = "integer*1"; 3474 rettype = debug_make_int_type (dhandle, 1, FALSE); 3475 break; 3476 case 28: 3477 name = "integer*2"; 3478 rettype = debug_make_int_type (dhandle, 2, FALSE); 3479 break; 3480 case 29: 3481 name = "integer*4"; 3482 rettype = debug_make_int_type (dhandle, 4, FALSE); 3483 break; 3484 case 30: 3485 /* FIXME */ 3486 name = "wchar"; 3487 rettype = debug_make_int_type (dhandle, 2, FALSE); 3488 break; 3489 case 31: 3490 name = "long long"; 3491 rettype = debug_make_int_type (dhandle, 8, FALSE); 3492 break; 3493 case 32: 3494 name = "unsigned long long"; 3495 rettype = debug_make_int_type (dhandle, 8, TRUE); 3496 break; 3497 case 33: 3498 name = "logical*8"; 3499 rettype = debug_make_bool_type (dhandle, 8); 3500 break; 3501 case 34: 3502 name = "integer*8"; 3503 rettype = debug_make_int_type (dhandle, 8, FALSE); 3504 break; 3505 default: 3506 abort (); 3507 } 3508 3509 rettype = debug_name_type (dhandle, name, rettype); 3510 3511 info->xcoff_types[-typenum] = rettype; 3512 3513 return rettype; 3514 } 3515 3516 /* Find or create a tagged type. */ 3517 3518 static debug_type 3519 stab_find_tagged_type (void *dhandle, struct stab_handle *info, 3520 const char *p, int len, enum debug_type_kind kind) 3521 { 3522 char *name; 3523 debug_type dtype; 3524 struct stab_tag *st; 3525 3526 name = savestring (p, len); 3527 3528 /* We pass DEBUG_KIND_ILLEGAL because we want all tags in the same 3529 namespace. This is right for C, and I don't know how to handle 3530 other languages. FIXME. */ 3531 dtype = debug_find_tagged_type (dhandle, name, DEBUG_KIND_ILLEGAL); 3532 if (dtype != DEBUG_TYPE_NULL) 3533 { 3534 free (name); 3535 return dtype; 3536 } 3537 3538 /* We need to allocate an entry on the undefined tag list. */ 3539 for (st = info->tags; st != NULL; st = st->next) 3540 { 3541 if (st->name[0] == name[0] 3542 && strcmp (st->name, name) == 0) 3543 { 3544 if (st->kind == DEBUG_KIND_ILLEGAL) 3545 st->kind = kind; 3546 free (name); 3547 break; 3548 } 3549 } 3550 if (st == NULL) 3551 { 3552 st = (struct stab_tag *) xmalloc (sizeof *st); 3553 memset (st, 0, sizeof *st); 3554 3555 st->next = info->tags; 3556 st->name = name; 3557 st->kind = kind; 3558 st->slot = DEBUG_TYPE_NULL; 3559 st->type = debug_make_indirect_type (dhandle, &st->slot, name); 3560 info->tags = st; 3561 } 3562 3563 return st->type; 3564 } 3565 3566 /* In order to get the correct argument types for a stubbed method, we 3567 need to extract the argument types from a C++ mangled string. 3568 Since the argument types can refer back to the return type, this 3569 means that we must demangle the entire physical name. In gdb this 3570 is done by calling cplus_demangle and running the results back 3571 through the C++ expression parser. Since we have no expression 3572 parser, we must duplicate much of the work of cplus_demangle here. 3573 3574 We assume that GNU style demangling is used, since this is only 3575 done for method stubs, and only g++ should output that form of 3576 debugging information. */ 3577 3578 /* This structure is used to hold a pointer to type information which 3579 demangling a string. */ 3580 3581 struct stab_demangle_typestring 3582 { 3583 /* The start of the type. This is not null terminated. */ 3584 const char *typestring; 3585 /* The length of the type. */ 3586 unsigned int len; 3587 }; 3588 3589 /* This structure is used to hold information while demangling a 3590 string. */ 3591 3592 struct stab_demangle_info 3593 { 3594 /* The debugging information handle. */ 3595 void *dhandle; 3596 /* The stab information handle. */ 3597 struct stab_handle *info; 3598 /* The array of arguments we are building. */ 3599 debug_type *args; 3600 /* Whether the method takes a variable number of arguments. */ 3601 bfd_boolean varargs; 3602 /* The array of types we have remembered. */ 3603 struct stab_demangle_typestring *typestrings; 3604 /* The number of typestrings. */ 3605 unsigned int typestring_count; 3606 /* The number of typestring slots we have allocated. */ 3607 unsigned int typestring_alloc; 3608 }; 3609 3610 static void stab_bad_demangle (const char *); 3611 static unsigned int stab_demangle_count (const char **); 3612 static bfd_boolean stab_demangle_get_count (const char **, unsigned int *); 3613 static bfd_boolean stab_demangle_prefix 3614 (struct stab_demangle_info *, const char **, unsigned int); 3615 static bfd_boolean stab_demangle_function_name 3616 (struct stab_demangle_info *, const char **, const char *); 3617 static bfd_boolean stab_demangle_signature 3618 (struct stab_demangle_info *, const char **); 3619 static bfd_boolean stab_demangle_qualified 3620 (struct stab_demangle_info *, const char **, debug_type *); 3621 static bfd_boolean stab_demangle_template 3622 (struct stab_demangle_info *, const char **, char **); 3623 static bfd_boolean stab_demangle_class 3624 (struct stab_demangle_info *, const char **, const char **); 3625 static bfd_boolean stab_demangle_args 3626 (struct stab_demangle_info *, const char **, debug_type **, bfd_boolean *); 3627 static bfd_boolean stab_demangle_arg 3628 (struct stab_demangle_info *, const char **, debug_type **, 3629 unsigned int *, unsigned int *); 3630 static bfd_boolean stab_demangle_type 3631 (struct stab_demangle_info *, const char **, debug_type *); 3632 static bfd_boolean stab_demangle_fund_type 3633 (struct stab_demangle_info *, const char **, debug_type *); 3634 static bfd_boolean stab_demangle_remember_type 3635 (struct stab_demangle_info *, const char *, int); 3636 3637 /* Warn about a bad demangling. */ 3638 3639 static void 3640 stab_bad_demangle (const char *s) 3641 { 3642 fprintf (stderr, _("bad mangled name `%s'\n"), s); 3643 } 3644 3645 /* Get a count from a stab string. */ 3646 3647 static unsigned int 3648 stab_demangle_count (const char **pp) 3649 { 3650 unsigned int count; 3651 3652 count = 0; 3653 while (ISDIGIT (**pp)) 3654 { 3655 count *= 10; 3656 count += **pp - '0'; 3657 ++*pp; 3658 } 3659 return count; 3660 } 3661 3662 /* Require a count in a string. The count may be multiple digits, in 3663 which case it must end in an underscore. */ 3664 3665 static bfd_boolean 3666 stab_demangle_get_count (const char **pp, unsigned int *pi) 3667 { 3668 if (! ISDIGIT (**pp)) 3669 return FALSE; 3670 3671 *pi = **pp - '0'; 3672 ++*pp; 3673 if (ISDIGIT (**pp)) 3674 { 3675 unsigned int count; 3676 const char *p; 3677 3678 count = *pi; 3679 p = *pp; 3680 do 3681 { 3682 count *= 10; 3683 count += *p - '0'; 3684 ++p; 3685 } 3686 while (ISDIGIT (*p)); 3687 if (*p == '_') 3688 { 3689 *pp = p + 1; 3690 *pi = count; 3691 } 3692 } 3693 3694 return TRUE; 3695 } 3696 3697 /* This function demangles a physical name, returning a NULL 3698 terminated array of argument types. */ 3699 3700 static debug_type * 3701 stab_demangle_argtypes (void *dhandle, struct stab_handle *info, 3702 const char *physname, bfd_boolean *pvarargs, 3703 unsigned int physname_len) 3704 { 3705 struct stab_demangle_info minfo; 3706 3707 /* Check for the g++ V3 ABI. */ 3708 if (physname[0] == '_' && physname[1] == 'Z') 3709 return stab_demangle_v3_argtypes (dhandle, info, physname, pvarargs); 3710 3711 minfo.dhandle = dhandle; 3712 minfo.info = info; 3713 minfo.args = NULL; 3714 minfo.varargs = FALSE; 3715 minfo.typestring_alloc = 10; 3716 minfo.typestrings = ((struct stab_demangle_typestring *) 3717 xmalloc (minfo.typestring_alloc 3718 * sizeof *minfo.typestrings)); 3719 minfo.typestring_count = 0; 3720 3721 /* cplus_demangle checks for special GNU mangled forms, but we can't 3722 see any of them in mangled method argument types. */ 3723 3724 if (! stab_demangle_prefix (&minfo, &physname, physname_len)) 3725 goto error_return; 3726 3727 if (*physname != '\0') 3728 { 3729 if (! stab_demangle_signature (&minfo, &physname)) 3730 goto error_return; 3731 } 3732 3733 free (minfo.typestrings); 3734 minfo.typestrings = NULL; 3735 3736 if (minfo.args == NULL) 3737 fprintf (stderr, _("no argument types in mangled string\n")); 3738 3739 *pvarargs = minfo.varargs; 3740 return minfo.args; 3741 3742 error_return: 3743 if (minfo.typestrings != NULL) 3744 free (minfo.typestrings); 3745 return NULL; 3746 } 3747 3748 /* Demangle the prefix of the mangled name. */ 3749 3750 static bfd_boolean 3751 stab_demangle_prefix (struct stab_demangle_info *minfo, const char **pp, 3752 unsigned int physname_len) 3753 { 3754 const char *scan; 3755 unsigned int i; 3756 3757 /* cplus_demangle checks for global constructors and destructors, 3758 but we can't see them in mangled argument types. */ 3759 3760 if (physname_len) 3761 scan = *pp + physname_len; 3762 else 3763 { 3764 /* Look for `__'. */ 3765 scan = *pp; 3766 do 3767 scan = strchr (scan, '_'); 3768 while (scan != NULL && *++scan != '_'); 3769 3770 if (scan == NULL) 3771 { 3772 stab_bad_demangle (*pp); 3773 return FALSE; 3774 } 3775 3776 --scan; 3777 3778 /* We found `__'; move ahead to the last contiguous `__' pair. */ 3779 i = strspn (scan, "_"); 3780 if (i > 2) 3781 scan += i - 2; 3782 } 3783 3784 if (scan == *pp 3785 && (ISDIGIT (scan[2]) 3786 || scan[2] == 'Q' 3787 || scan[2] == 't')) 3788 { 3789 /* This is a GNU style constructor name. */ 3790 *pp = scan + 2; 3791 return TRUE; 3792 } 3793 else if (scan == *pp 3794 && ! ISDIGIT (scan[2]) 3795 && scan[2] != 't') 3796 { 3797 /* Look for the `__' that separates the prefix from the 3798 signature. */ 3799 while (*scan == '_') 3800 ++scan; 3801 scan = strstr (scan, "__"); 3802 if (scan == NULL || scan[2] == '\0') 3803 { 3804 stab_bad_demangle (*pp); 3805 return FALSE; 3806 } 3807 3808 return stab_demangle_function_name (minfo, pp, scan); 3809 } 3810 else if (scan[2] != '\0') 3811 { 3812 /* The name doesn't start with `__', but it does contain `__'. */ 3813 return stab_demangle_function_name (minfo, pp, scan); 3814 } 3815 else 3816 { 3817 stab_bad_demangle (*pp); 3818 return FALSE; 3819 } 3820 /*NOTREACHED*/ 3821 } 3822 3823 /* Demangle a function name prefix. The scan argument points to the 3824 double underscore which separates the function name from the 3825 signature. */ 3826 3827 static bfd_boolean 3828 stab_demangle_function_name (struct stab_demangle_info *minfo, 3829 const char **pp, const char *scan) 3830 { 3831 const char *name; 3832 3833 /* The string from *pp to scan is the name of the function. We 3834 don't care about the name, since we just looking for argument 3835 types. However, for conversion operators, the name may include a 3836 type which we must remember in order to handle backreferences. */ 3837 3838 name = *pp; 3839 *pp = scan + 2; 3840 3841 if (*pp - name >= 5 3842 && CONST_STRNEQ (name, "type") 3843 && (name[4] == '$' || name[4] == '.')) 3844 { 3845 const char *tem; 3846 3847 /* This is a type conversion operator. */ 3848 tem = name + 5; 3849 if (! stab_demangle_type (minfo, &tem, (debug_type *) NULL)) 3850 return FALSE; 3851 } 3852 else if (name[0] == '_' 3853 && name[1] == '_' 3854 && name[2] == 'o' 3855 && name[3] == 'p') 3856 { 3857 const char *tem; 3858 3859 /* This is a type conversion operator. */ 3860 tem = name + 4; 3861 if (! stab_demangle_type (minfo, &tem, (debug_type *) NULL)) 3862 return FALSE; 3863 } 3864 3865 return TRUE; 3866 } 3867 3868 /* Demangle the signature. This is where the argument types are 3869 found. */ 3870 3871 static bfd_boolean 3872 stab_demangle_signature (struct stab_demangle_info *minfo, const char **pp) 3873 { 3874 const char *orig; 3875 bfd_boolean expect_func, func_done; 3876 const char *hold; 3877 3878 orig = *pp; 3879 3880 expect_func = FALSE; 3881 func_done = FALSE; 3882 hold = NULL; 3883 3884 while (**pp != '\0') 3885 { 3886 switch (**pp) 3887 { 3888 case 'Q': 3889 hold = *pp; 3890 if (! stab_demangle_qualified (minfo, pp, (debug_type *) NULL) 3891 || ! stab_demangle_remember_type (minfo, hold, *pp - hold)) 3892 return FALSE; 3893 expect_func = TRUE; 3894 hold = NULL; 3895 break; 3896 3897 case 'S': 3898 /* Static member function. FIXME: Can this happen? */ 3899 if (hold == NULL) 3900 hold = *pp; 3901 ++*pp; 3902 break; 3903 3904 case 'C': 3905 /* Const member function. */ 3906 if (hold == NULL) 3907 hold = *pp; 3908 ++*pp; 3909 break; 3910 3911 case '0': case '1': case '2': case '3': case '4': 3912 case '5': case '6': case '7': case '8': case '9': 3913 if (hold == NULL) 3914 hold = *pp; 3915 if (! stab_demangle_class (minfo, pp, (const char **) NULL) 3916 || ! stab_demangle_remember_type (minfo, hold, *pp - hold)) 3917 return FALSE; 3918 expect_func = TRUE; 3919 hold = NULL; 3920 break; 3921 3922 case 'F': 3923 /* Function. I don't know if this actually happens with g++ 3924 output. */ 3925 hold = NULL; 3926 func_done = TRUE; 3927 ++*pp; 3928 if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs)) 3929 return FALSE; 3930 break; 3931 3932 case 't': 3933 /* Template. */ 3934 if (hold == NULL) 3935 hold = *pp; 3936 if (! stab_demangle_template (minfo, pp, (char **) NULL) 3937 || ! stab_demangle_remember_type (minfo, hold, *pp - hold)) 3938 return FALSE; 3939 hold = NULL; 3940 expect_func = TRUE; 3941 break; 3942 3943 case '_': 3944 /* At the outermost level, we cannot have a return type 3945 specified, so if we run into another '_' at this point we 3946 are dealing with a mangled name that is either bogus, or 3947 has been mangled by some algorithm we don't know how to 3948 deal with. So just reject the entire demangling. */ 3949 stab_bad_demangle (orig); 3950 return FALSE; 3951 3952 default: 3953 /* Assume we have stumbled onto the first outermost function 3954 argument token, and start processing args. */ 3955 func_done = TRUE; 3956 if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs)) 3957 return FALSE; 3958 break; 3959 } 3960 3961 if (expect_func) 3962 { 3963 func_done = TRUE; 3964 if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs)) 3965 return FALSE; 3966 } 3967 } 3968 3969 if (! func_done) 3970 { 3971 /* With GNU style demangling, bar__3foo is 'foo::bar(void)', and 3972 bar__3fooi is 'foo::bar(int)'. We get here when we find the 3973 first case, and need to ensure that the '(void)' gets added 3974 to the current declp. */ 3975 if (! stab_demangle_args (minfo, pp, &minfo->args, &minfo->varargs)) 3976 return FALSE; 3977 } 3978 3979 return TRUE; 3980 } 3981 3982 /* Demangle a qualified name, such as "Q25Outer5Inner" which is the 3983 mangled form of "Outer::Inner". */ 3984 3985 static bfd_boolean 3986 stab_demangle_qualified (struct stab_demangle_info *minfo, const char **pp, 3987 debug_type *ptype) 3988 { 3989 const char *orig; 3990 const char *p; 3991 unsigned int qualifiers; 3992 debug_type context; 3993 3994 orig = *pp; 3995 3996 switch ((*pp)[1]) 3997 { 3998 case '_': 3999 /* GNU mangled name with more than 9 classes. The count is 4000 preceded by an underscore (to distinguish it from the <= 9 4001 case) and followed by an underscore. */ 4002 p = *pp + 2; 4003 if (! ISDIGIT (*p) || *p == '0') 4004 { 4005 stab_bad_demangle (orig); 4006 return FALSE; 4007 } 4008 qualifiers = atoi (p); 4009 while (ISDIGIT (*p)) 4010 ++p; 4011 if (*p != '_') 4012 { 4013 stab_bad_demangle (orig); 4014 return FALSE; 4015 } 4016 *pp = p + 1; 4017 break; 4018 4019 case '1': case '2': case '3': case '4': case '5': 4020 case '6': case '7': case '8': case '9': 4021 qualifiers = (*pp)[1] - '0'; 4022 /* Skip an optional underscore after the count. */ 4023 if ((*pp)[2] == '_') 4024 ++*pp; 4025 *pp += 2; 4026 break; 4027 4028 case '0': 4029 default: 4030 stab_bad_demangle (orig); 4031 return FALSE; 4032 } 4033 4034 context = DEBUG_TYPE_NULL; 4035 4036 /* Pick off the names. */ 4037 while (qualifiers-- > 0) 4038 { 4039 if (**pp == '_') 4040 ++*pp; 4041 if (**pp == 't') 4042 { 4043 char *name; 4044 4045 if (! stab_demangle_template (minfo, pp, 4046 ptype != NULL ? &name : NULL)) 4047 return FALSE; 4048 4049 if (ptype != NULL) 4050 { 4051 context = stab_find_tagged_type (minfo->dhandle, minfo->info, 4052 name, strlen (name), 4053 DEBUG_KIND_CLASS); 4054 free (name); 4055 if (context == DEBUG_TYPE_NULL) 4056 return FALSE; 4057 } 4058 } 4059 else 4060 { 4061 unsigned int len; 4062 4063 len = stab_demangle_count (pp); 4064 if (strlen (*pp) < len) 4065 { 4066 stab_bad_demangle (orig); 4067 return FALSE; 4068 } 4069 4070 if (ptype != NULL) 4071 { 4072 const debug_field *fields; 4073 4074 fields = NULL; 4075 if (context != DEBUG_TYPE_NULL) 4076 fields = debug_get_fields (minfo->dhandle, context); 4077 4078 context = DEBUG_TYPE_NULL; 4079 4080 if (fields != NULL) 4081 { 4082 char *name; 4083 4084 /* Try to find the type by looking through the 4085 fields of context until we find a field with the 4086 same type. This ought to work for a class 4087 defined within a class, but it won't work for, 4088 e.g., an enum defined within a class. stabs does 4089 not give us enough information to figure out the 4090 latter case. */ 4091 4092 name = savestring (*pp, len); 4093 4094 for (; *fields != DEBUG_FIELD_NULL; fields++) 4095 { 4096 debug_type ft; 4097 const char *dn; 4098 4099 ft = debug_get_field_type (minfo->dhandle, *fields); 4100 if (ft == NULL) 4101 return FALSE; 4102 dn = debug_get_type_name (minfo->dhandle, ft); 4103 if (dn != NULL && strcmp (dn, name) == 0) 4104 { 4105 context = ft; 4106 break; 4107 } 4108 } 4109 4110 free (name); 4111 } 4112 4113 if (context == DEBUG_TYPE_NULL) 4114 { 4115 /* We have to fall back on finding the type by name. 4116 If there are more types to come, then this must 4117 be a class. Otherwise, it could be anything. */ 4118 4119 if (qualifiers == 0) 4120 { 4121 char *name; 4122 4123 name = savestring (*pp, len); 4124 context = debug_find_named_type (minfo->dhandle, 4125 name); 4126 free (name); 4127 } 4128 4129 if (context == DEBUG_TYPE_NULL) 4130 { 4131 context = stab_find_tagged_type (minfo->dhandle, 4132 minfo->info, 4133 *pp, len, 4134 (qualifiers == 0 4135 ? DEBUG_KIND_ILLEGAL 4136 : DEBUG_KIND_CLASS)); 4137 if (context == DEBUG_TYPE_NULL) 4138 return FALSE; 4139 } 4140 } 4141 } 4142 4143 *pp += len; 4144 } 4145 } 4146 4147 if (ptype != NULL) 4148 *ptype = context; 4149 4150 return TRUE; 4151 } 4152 4153 /* Demangle a template. If PNAME is not NULL, this sets *PNAME to a 4154 string representation of the template. */ 4155 4156 static bfd_boolean 4157 stab_demangle_template (struct stab_demangle_info *minfo, const char **pp, 4158 char **pname) 4159 { 4160 const char *orig; 4161 unsigned int r, i; 4162 4163 orig = *pp; 4164 4165 ++*pp; 4166 4167 /* Skip the template name. */ 4168 r = stab_demangle_count (pp); 4169 if (r == 0 || strlen (*pp) < r) 4170 { 4171 stab_bad_demangle (orig); 4172 return FALSE; 4173 } 4174 *pp += r; 4175 4176 /* Get the size of the parameter list. */ 4177 if (stab_demangle_get_count (pp, &r) == 0) 4178 { 4179 stab_bad_demangle (orig); 4180 return FALSE; 4181 } 4182 4183 for (i = 0; i < r; i++) 4184 { 4185 if (**pp == 'Z') 4186 { 4187 /* This is a type parameter. */ 4188 ++*pp; 4189 if (! stab_demangle_type (minfo, pp, (debug_type *) NULL)) 4190 return FALSE; 4191 } 4192 else 4193 { 4194 const char *old_p; 4195 bfd_boolean pointerp, realp, integralp, charp, boolp; 4196 bfd_boolean done; 4197 4198 old_p = *pp; 4199 pointerp = FALSE; 4200 realp = FALSE; 4201 integralp = FALSE; 4202 charp = FALSE; 4203 boolp = FALSE; 4204 done = FALSE; 4205 4206 /* This is a value parameter. */ 4207 4208 if (! stab_demangle_type (minfo, pp, (debug_type *) NULL)) 4209 return FALSE; 4210 4211 while (*old_p != '\0' && ! done) 4212 { 4213 switch (*old_p) 4214 { 4215 case 'P': 4216 case 'p': 4217 case 'R': 4218 pointerp = TRUE; 4219 done = TRUE; 4220 break; 4221 case 'C': /* Const. */ 4222 case 'S': /* Signed. */ 4223 case 'U': /* Unsigned. */ 4224 case 'V': /* Volatile. */ 4225 case 'F': /* Function. */ 4226 case 'M': /* Member function. */ 4227 case 'O': /* ??? */ 4228 ++old_p; 4229 break; 4230 case 'Q': /* Qualified name. */ 4231 integralp = TRUE; 4232 done = TRUE; 4233 break; 4234 case 'T': /* Remembered type. */ 4235 abort (); 4236 case 'v': /* Void. */ 4237 abort (); 4238 case 'x': /* Long long. */ 4239 case 'l': /* Long. */ 4240 case 'i': /* Int. */ 4241 case 's': /* Short. */ 4242 case 'w': /* Wchar_t. */ 4243 integralp = TRUE; 4244 done = TRUE; 4245 break; 4246 case 'b': /* Bool. */ 4247 boolp = TRUE; 4248 done = TRUE; 4249 break; 4250 case 'c': /* Char. */ 4251 charp = TRUE; 4252 done = TRUE; 4253 break; 4254 case 'r': /* Long double. */ 4255 case 'd': /* Double. */ 4256 case 'f': /* Float. */ 4257 realp = TRUE; 4258 done = TRUE; 4259 break; 4260 default: 4261 /* Assume it's a user defined integral type. */ 4262 integralp = TRUE; 4263 done = TRUE; 4264 break; 4265 } 4266 } 4267 4268 if (integralp) 4269 { 4270 if (**pp == 'm') 4271 ++*pp; 4272 while (ISDIGIT (**pp)) 4273 ++*pp; 4274 } 4275 else if (charp) 4276 { 4277 unsigned int val; 4278 4279 if (**pp == 'm') 4280 ++*pp; 4281 val = stab_demangle_count (pp); 4282 if (val == 0) 4283 { 4284 stab_bad_demangle (orig); 4285 return FALSE; 4286 } 4287 } 4288 else if (boolp) 4289 { 4290 unsigned int val; 4291 4292 val = stab_demangle_count (pp); 4293 if (val != 0 && val != 1) 4294 { 4295 stab_bad_demangle (orig); 4296 return FALSE; 4297 } 4298 } 4299 else if (realp) 4300 { 4301 if (**pp == 'm') 4302 ++*pp; 4303 while (ISDIGIT (**pp)) 4304 ++*pp; 4305 if (**pp == '.') 4306 { 4307 ++*pp; 4308 while (ISDIGIT (**pp)) 4309 ++*pp; 4310 } 4311 if (**pp == 'e') 4312 { 4313 ++*pp; 4314 while (ISDIGIT (**pp)) 4315 ++*pp; 4316 } 4317 } 4318 else if (pointerp) 4319 { 4320 unsigned int len; 4321 4322 len = stab_demangle_count (pp); 4323 if (len == 0) 4324 { 4325 stab_bad_demangle (orig); 4326 return FALSE; 4327 } 4328 *pp += len; 4329 } 4330 } 4331 } 4332 4333 /* We can translate this to a string fairly easily by invoking the 4334 regular demangling routine. */ 4335 if (pname != NULL) 4336 { 4337 char *s1, *s2, *s3, *s4 = NULL; 4338 char *from, *to; 4339 4340 s1 = savestring (orig, *pp - orig); 4341 4342 s2 = concat ("NoSuchStrinG__", s1, (const char *) NULL); 4343 4344 free (s1); 4345 4346 s3 = cplus_demangle (s2, DMGL_ANSI); 4347 4348 free (s2); 4349 4350 if (s3 != NULL) 4351 s4 = strstr (s3, "::NoSuchStrinG"); 4352 if (s3 == NULL || s4 == NULL) 4353 { 4354 stab_bad_demangle (orig); 4355 if (s3 != NULL) 4356 free (s3); 4357 return FALSE; 4358 } 4359 4360 /* Eliminating all spaces, except those between > characters, 4361 makes it more likely that the demangled name will match the 4362 name which g++ used as the structure name. */ 4363 for (from = to = s3; from != s4; ++from) 4364 if (*from != ' ' 4365 || (from[1] == '>' && from > s3 && from[-1] == '>')) 4366 *to++ = *from; 4367 4368 *pname = savestring (s3, to - s3); 4369 4370 free (s3); 4371 } 4372 4373 return TRUE; 4374 } 4375 4376 /* Demangle a class name. */ 4377 4378 static bfd_boolean 4379 stab_demangle_class (struct stab_demangle_info *minfo ATTRIBUTE_UNUSED, 4380 const char **pp, const char **pstart) 4381 { 4382 const char *orig; 4383 unsigned int n; 4384 4385 orig = *pp; 4386 4387 n = stab_demangle_count (pp); 4388 if (strlen (*pp) < n) 4389 { 4390 stab_bad_demangle (orig); 4391 return FALSE; 4392 } 4393 4394 if (pstart != NULL) 4395 *pstart = *pp; 4396 4397 *pp += n; 4398 4399 return TRUE; 4400 } 4401 4402 /* Demangle function arguments. If the pargs argument is not NULL, it 4403 is set to a NULL terminated array holding the arguments. */ 4404 4405 static bfd_boolean 4406 stab_demangle_args (struct stab_demangle_info *minfo, const char **pp, 4407 debug_type **pargs, bfd_boolean *pvarargs) 4408 { 4409 const char *orig; 4410 unsigned int alloc, count; 4411 4412 orig = *pp; 4413 4414 alloc = 10; 4415 if (pargs != NULL) 4416 { 4417 *pargs = (debug_type *) xmalloc (alloc * sizeof **pargs); 4418 *pvarargs = FALSE; 4419 } 4420 count = 0; 4421 4422 while (**pp != '_' && **pp != '\0' && **pp != 'e') 4423 { 4424 if (**pp == 'N' || **pp == 'T') 4425 { 4426 char temptype; 4427 unsigned int r, t; 4428 4429 temptype = **pp; 4430 ++*pp; 4431 4432 if (temptype == 'T') 4433 r = 1; 4434 else 4435 { 4436 if (! stab_demangle_get_count (pp, &r)) 4437 { 4438 stab_bad_demangle (orig); 4439 return FALSE; 4440 } 4441 } 4442 4443 if (! stab_demangle_get_count (pp, &t)) 4444 { 4445 stab_bad_demangle (orig); 4446 return FALSE; 4447 } 4448 4449 if (t >= minfo->typestring_count) 4450 { 4451 stab_bad_demangle (orig); 4452 return FALSE; 4453 } 4454 while (r-- > 0) 4455 { 4456 const char *tem; 4457 4458 tem = minfo->typestrings[t].typestring; 4459 if (! stab_demangle_arg (minfo, &tem, pargs, &count, &alloc)) 4460 return FALSE; 4461 } 4462 } 4463 else 4464 { 4465 if (! stab_demangle_arg (minfo, pp, pargs, &count, &alloc)) 4466 return FALSE; 4467 } 4468 } 4469 4470 if (pargs != NULL) 4471 (*pargs)[count] = DEBUG_TYPE_NULL; 4472 4473 if (**pp == 'e') 4474 { 4475 if (pargs != NULL) 4476 *pvarargs = TRUE; 4477 ++*pp; 4478 } 4479 4480 return TRUE; 4481 } 4482 4483 /* Demangle a single argument. */ 4484 4485 static bfd_boolean 4486 stab_demangle_arg (struct stab_demangle_info *minfo, const char **pp, 4487 debug_type **pargs, unsigned int *pcount, 4488 unsigned int *palloc) 4489 { 4490 const char *start; 4491 debug_type type; 4492 4493 start = *pp; 4494 if (! stab_demangle_type (minfo, pp, 4495 pargs == NULL ? (debug_type *) NULL : &type) 4496 || ! stab_demangle_remember_type (minfo, start, *pp - start)) 4497 return FALSE; 4498 4499 if (pargs != NULL) 4500 { 4501 if (type == DEBUG_TYPE_NULL) 4502 return FALSE; 4503 4504 if (*pcount + 1 >= *palloc) 4505 { 4506 *palloc += 10; 4507 *pargs = ((debug_type *) 4508 xrealloc (*pargs, *palloc * sizeof **pargs)); 4509 } 4510 (*pargs)[*pcount] = type; 4511 ++*pcount; 4512 } 4513 4514 return TRUE; 4515 } 4516 4517 /* Demangle a type. If the ptype argument is not NULL, *ptype is set 4518 to the newly allocated type. */ 4519 4520 static bfd_boolean 4521 stab_demangle_type (struct stab_demangle_info *minfo, const char **pp, 4522 debug_type *ptype) 4523 { 4524 const char *orig; 4525 4526 orig = *pp; 4527 4528 switch (**pp) 4529 { 4530 case 'P': 4531 case 'p': 4532 /* A pointer type. */ 4533 ++*pp; 4534 if (! stab_demangle_type (minfo, pp, ptype)) 4535 return FALSE; 4536 if (ptype != NULL) 4537 *ptype = debug_make_pointer_type (minfo->dhandle, *ptype); 4538 break; 4539 4540 case 'R': 4541 /* A reference type. */ 4542 ++*pp; 4543 if (! stab_demangle_type (minfo, pp, ptype)) 4544 return FALSE; 4545 if (ptype != NULL) 4546 *ptype = debug_make_reference_type (minfo->dhandle, *ptype); 4547 break; 4548 4549 case 'A': 4550 /* An array. */ 4551 { 4552 unsigned long high; 4553 4554 ++*pp; 4555 high = 0; 4556 while (**pp != '\0' && **pp != '_') 4557 { 4558 if (! ISDIGIT (**pp)) 4559 { 4560 stab_bad_demangle (orig); 4561 return FALSE; 4562 } 4563 high *= 10; 4564 high += **pp - '0'; 4565 ++*pp; 4566 } 4567 if (**pp != '_') 4568 { 4569 stab_bad_demangle (orig); 4570 return FALSE; 4571 } 4572 ++*pp; 4573 4574 if (! stab_demangle_type (minfo, pp, ptype)) 4575 return FALSE; 4576 if (ptype != NULL) 4577 { 4578 debug_type int_type; 4579 4580 int_type = debug_find_named_type (minfo->dhandle, "int"); 4581 if (int_type == NULL) 4582 int_type = debug_make_int_type (minfo->dhandle, 4, FALSE); 4583 *ptype = debug_make_array_type (minfo->dhandle, *ptype, int_type, 4584 0, high, FALSE); 4585 } 4586 } 4587 break; 4588 4589 case 'T': 4590 /* A back reference to a remembered type. */ 4591 { 4592 unsigned int i; 4593 const char *p; 4594 4595 ++*pp; 4596 if (! stab_demangle_get_count (pp, &i)) 4597 { 4598 stab_bad_demangle (orig); 4599 return FALSE; 4600 } 4601 if (i >= minfo->typestring_count) 4602 { 4603 stab_bad_demangle (orig); 4604 return FALSE; 4605 } 4606 p = minfo->typestrings[i].typestring; 4607 if (! stab_demangle_type (minfo, &p, ptype)) 4608 return FALSE; 4609 } 4610 break; 4611 4612 case 'F': 4613 /* A function. */ 4614 { 4615 debug_type *args; 4616 bfd_boolean varargs; 4617 4618 ++*pp; 4619 if (! stab_demangle_args (minfo, pp, 4620 (ptype == NULL 4621 ? (debug_type **) NULL 4622 : &args), 4623 (ptype == NULL 4624 ? (bfd_boolean *) NULL 4625 : &varargs))) 4626 return FALSE; 4627 if (**pp != '_') 4628 { 4629 /* cplus_demangle will accept a function without a return 4630 type, but I don't know when that will happen, or what 4631 to do if it does. */ 4632 stab_bad_demangle (orig); 4633 return FALSE; 4634 } 4635 ++*pp; 4636 if (! stab_demangle_type (minfo, pp, ptype)) 4637 return FALSE; 4638 if (ptype != NULL) 4639 *ptype = debug_make_function_type (minfo->dhandle, *ptype, args, 4640 varargs); 4641 4642 } 4643 break; 4644 4645 case 'M': 4646 case 'O': 4647 { 4648 bfd_boolean memberp, constp, volatilep; 4649 debug_type class_type = DEBUG_TYPE_NULL; 4650 debug_type *args; 4651 bfd_boolean varargs; 4652 unsigned int n; 4653 const char *name; 4654 4655 memberp = **pp == 'M'; 4656 constp = FALSE; 4657 volatilep = FALSE; 4658 args = NULL; 4659 varargs = FALSE; 4660 4661 ++*pp; 4662 if (ISDIGIT (**pp)) 4663 { 4664 n = stab_demangle_count (pp); 4665 if (strlen (*pp) < n) 4666 { 4667 stab_bad_demangle (orig); 4668 return FALSE; 4669 } 4670 name = *pp; 4671 *pp += n; 4672 4673 if (ptype != NULL) 4674 { 4675 class_type = stab_find_tagged_type (minfo->dhandle, 4676 minfo->info, 4677 name, (int) n, 4678 DEBUG_KIND_CLASS); 4679 if (class_type == DEBUG_TYPE_NULL) 4680 return FALSE; 4681 } 4682 } 4683 else if (**pp == 'Q') 4684 { 4685 if (! stab_demangle_qualified (minfo, pp, 4686 (ptype == NULL 4687 ? (debug_type *) NULL 4688 : &class_type))) 4689 return FALSE; 4690 } 4691 else 4692 { 4693 stab_bad_demangle (orig); 4694 return FALSE; 4695 } 4696 4697 if (memberp) 4698 { 4699 if (**pp == 'C') 4700 { 4701 constp = TRUE; 4702 ++*pp; 4703 } 4704 else if (**pp == 'V') 4705 { 4706 volatilep = TRUE; 4707 ++*pp; 4708 } 4709 if (**pp != 'F') 4710 { 4711 stab_bad_demangle (orig); 4712 return FALSE; 4713 } 4714 ++*pp; 4715 if (! stab_demangle_args (minfo, pp, 4716 (ptype == NULL 4717 ? (debug_type **) NULL 4718 : &args), 4719 (ptype == NULL 4720 ? (bfd_boolean *) NULL 4721 : &varargs))) 4722 return FALSE; 4723 } 4724 4725 if (**pp != '_') 4726 { 4727 stab_bad_demangle (orig); 4728 return FALSE; 4729 } 4730 ++*pp; 4731 4732 if (! stab_demangle_type (minfo, pp, ptype)) 4733 return FALSE; 4734 4735 if (ptype != NULL) 4736 { 4737 if (! memberp) 4738 *ptype = debug_make_offset_type (minfo->dhandle, class_type, 4739 *ptype); 4740 else 4741 { 4742 /* FIXME: We have no way to record constp or 4743 volatilep. */ 4744 *ptype = debug_make_method_type (minfo->dhandle, *ptype, 4745 class_type, args, varargs); 4746 } 4747 } 4748 } 4749 break; 4750 4751 case 'G': 4752 ++*pp; 4753 if (! stab_demangle_type (minfo, pp, ptype)) 4754 return FALSE; 4755 break; 4756 4757 case 'C': 4758 ++*pp; 4759 if (! stab_demangle_type (minfo, pp, ptype)) 4760 return FALSE; 4761 if (ptype != NULL) 4762 *ptype = debug_make_const_type (minfo->dhandle, *ptype); 4763 break; 4764 4765 case 'Q': 4766 { 4767 const char *hold; 4768 4769 hold = *pp; 4770 if (! stab_demangle_qualified (minfo, pp, ptype)) 4771 return FALSE; 4772 } 4773 break; 4774 4775 default: 4776 if (! stab_demangle_fund_type (minfo, pp, ptype)) 4777 return FALSE; 4778 break; 4779 } 4780 4781 return TRUE; 4782 } 4783 4784 /* Demangle a fundamental type. If the ptype argument is not NULL, 4785 *ptype is set to the newly allocated type. */ 4786 4787 static bfd_boolean 4788 stab_demangle_fund_type (struct stab_demangle_info *minfo, const char **pp, 4789 debug_type *ptype) 4790 { 4791 const char *orig; 4792 bfd_boolean constp, volatilep, unsignedp, signedp; 4793 bfd_boolean done; 4794 4795 orig = *pp; 4796 4797 constp = FALSE; 4798 volatilep = FALSE; 4799 unsignedp = FALSE; 4800 signedp = FALSE; 4801 4802 done = FALSE; 4803 while (! done) 4804 { 4805 switch (**pp) 4806 { 4807 case 'C': 4808 constp = TRUE; 4809 ++*pp; 4810 break; 4811 4812 case 'U': 4813 unsignedp = TRUE; 4814 ++*pp; 4815 break; 4816 4817 case 'S': 4818 signedp = TRUE; 4819 ++*pp; 4820 break; 4821 4822 case 'V': 4823 volatilep = TRUE; 4824 ++*pp; 4825 break; 4826 4827 default: 4828 done = TRUE; 4829 break; 4830 } 4831 } 4832 4833 switch (**pp) 4834 { 4835 case '\0': 4836 case '_': 4837 /* cplus_demangle permits this, but I don't know what it means. */ 4838 stab_bad_demangle (orig); 4839 break; 4840 4841 case 'v': /* void */ 4842 if (ptype != NULL) 4843 { 4844 *ptype = debug_find_named_type (minfo->dhandle, "void"); 4845 if (*ptype == DEBUG_TYPE_NULL) 4846 *ptype = debug_make_void_type (minfo->dhandle); 4847 } 4848 ++*pp; 4849 break; 4850 4851 case 'x': /* long long */ 4852 if (ptype != NULL) 4853 { 4854 *ptype = debug_find_named_type (minfo->dhandle, 4855 (unsignedp 4856 ? "long long unsigned int" 4857 : "long long int")); 4858 if (*ptype == DEBUG_TYPE_NULL) 4859 *ptype = debug_make_int_type (minfo->dhandle, 8, unsignedp); 4860 } 4861 ++*pp; 4862 break; 4863 4864 case 'l': /* long */ 4865 if (ptype != NULL) 4866 { 4867 *ptype = debug_find_named_type (minfo->dhandle, 4868 (unsignedp 4869 ? "long unsigned int" 4870 : "long int")); 4871 if (*ptype == DEBUG_TYPE_NULL) 4872 *ptype = debug_make_int_type (minfo->dhandle, 4, unsignedp); 4873 } 4874 ++*pp; 4875 break; 4876 4877 case 'i': /* int */ 4878 if (ptype != NULL) 4879 { 4880 *ptype = debug_find_named_type (minfo->dhandle, 4881 (unsignedp 4882 ? "unsigned int" 4883 : "int")); 4884 if (*ptype == DEBUG_TYPE_NULL) 4885 *ptype = debug_make_int_type (minfo->dhandle, 4, unsignedp); 4886 } 4887 ++*pp; 4888 break; 4889 4890 case 's': /* short */ 4891 if (ptype != NULL) 4892 { 4893 *ptype = debug_find_named_type (minfo->dhandle, 4894 (unsignedp 4895 ? "short unsigned int" 4896 : "short int")); 4897 if (*ptype == DEBUG_TYPE_NULL) 4898 *ptype = debug_make_int_type (minfo->dhandle, 2, unsignedp); 4899 } 4900 ++*pp; 4901 break; 4902 4903 case 'b': /* bool */ 4904 if (ptype != NULL) 4905 { 4906 *ptype = debug_find_named_type (minfo->dhandle, "bool"); 4907 if (*ptype == DEBUG_TYPE_NULL) 4908 *ptype = debug_make_bool_type (minfo->dhandle, 4); 4909 } 4910 ++*pp; 4911 break; 4912 4913 case 'c': /* char */ 4914 if (ptype != NULL) 4915 { 4916 *ptype = debug_find_named_type (minfo->dhandle, 4917 (unsignedp 4918 ? "unsigned char" 4919 : (signedp 4920 ? "signed char" 4921 : "char"))); 4922 if (*ptype == DEBUG_TYPE_NULL) 4923 *ptype = debug_make_int_type (minfo->dhandle, 1, unsignedp); 4924 } 4925 ++*pp; 4926 break; 4927 4928 case 'w': /* wchar_t */ 4929 if (ptype != NULL) 4930 { 4931 *ptype = debug_find_named_type (minfo->dhandle, "__wchar_t"); 4932 if (*ptype == DEBUG_TYPE_NULL) 4933 *ptype = debug_make_int_type (minfo->dhandle, 2, TRUE); 4934 } 4935 ++*pp; 4936 break; 4937 4938 case 'r': /* long double */ 4939 if (ptype != NULL) 4940 { 4941 *ptype = debug_find_named_type (minfo->dhandle, "long double"); 4942 if (*ptype == DEBUG_TYPE_NULL) 4943 *ptype = debug_make_float_type (minfo->dhandle, 8); 4944 } 4945 ++*pp; 4946 break; 4947 4948 case 'd': /* double */ 4949 if (ptype != NULL) 4950 { 4951 *ptype = debug_find_named_type (minfo->dhandle, "double"); 4952 if (*ptype == DEBUG_TYPE_NULL) 4953 *ptype = debug_make_float_type (minfo->dhandle, 8); 4954 } 4955 ++*pp; 4956 break; 4957 4958 case 'f': /* float */ 4959 if (ptype != NULL) 4960 { 4961 *ptype = debug_find_named_type (minfo->dhandle, "float"); 4962 if (*ptype == DEBUG_TYPE_NULL) 4963 *ptype = debug_make_float_type (minfo->dhandle, 4); 4964 } 4965 ++*pp; 4966 break; 4967 4968 case 'G': 4969 ++*pp; 4970 if (! ISDIGIT (**pp)) 4971 { 4972 stab_bad_demangle (orig); 4973 return FALSE; 4974 } 4975 /* Fall through. */ 4976 case '0': case '1': case '2': case '3': case '4': 4977 case '5': case '6': case '7': case '8': case '9': 4978 { 4979 const char *hold; 4980 4981 if (! stab_demangle_class (minfo, pp, &hold)) 4982 return FALSE; 4983 if (ptype != NULL) 4984 { 4985 char *name; 4986 4987 name = savestring (hold, *pp - hold); 4988 *ptype = debug_find_named_type (minfo->dhandle, name); 4989 free (name); 4990 if (*ptype == DEBUG_TYPE_NULL) 4991 { 4992 /* FIXME: It is probably incorrect to assume that 4993 undefined types are tagged types. */ 4994 *ptype = stab_find_tagged_type (minfo->dhandle, minfo->info, 4995 hold, *pp - hold, 4996 DEBUG_KIND_ILLEGAL); 4997 if (*ptype == DEBUG_TYPE_NULL) 4998 return FALSE; 4999 } 5000 } 5001 } 5002 break; 5003 5004 case 't': 5005 { 5006 char *name; 5007 5008 if (! stab_demangle_template (minfo, pp, 5009 ptype != NULL ? &name : NULL)) 5010 return FALSE; 5011 if (ptype != NULL) 5012 { 5013 *ptype = stab_find_tagged_type (minfo->dhandle, minfo->info, 5014 name, strlen (name), 5015 DEBUG_KIND_CLASS); 5016 free (name); 5017 if (*ptype == DEBUG_TYPE_NULL) 5018 return FALSE; 5019 } 5020 } 5021 break; 5022 5023 default: 5024 stab_bad_demangle (orig); 5025 return FALSE; 5026 } 5027 5028 if (ptype != NULL) 5029 { 5030 if (constp) 5031 *ptype = debug_make_const_type (minfo->dhandle, *ptype); 5032 if (volatilep) 5033 *ptype = debug_make_volatile_type (minfo->dhandle, *ptype); 5034 } 5035 5036 return TRUE; 5037 } 5038 5039 /* Remember a type string in a demangled string. */ 5040 5041 static bfd_boolean 5042 stab_demangle_remember_type (struct stab_demangle_info *minfo, 5043 const char *p, int len) 5044 { 5045 if (minfo->typestring_count >= minfo->typestring_alloc) 5046 { 5047 minfo->typestring_alloc += 10; 5048 minfo->typestrings = ((struct stab_demangle_typestring *) 5049 xrealloc (minfo->typestrings, 5050 (minfo->typestring_alloc 5051 * sizeof *minfo->typestrings))); 5052 } 5053 5054 minfo->typestrings[minfo->typestring_count].typestring = p; 5055 minfo->typestrings[minfo->typestring_count].len = (unsigned int) len; 5056 ++minfo->typestring_count; 5057 5058 return TRUE; 5059 } 5060 5061 /* Demangle names encoded using the g++ V3 ABI. The newer versions of 5062 g++ which use this ABI do not encode ordinary method argument types 5063 in a mangled name; they simply output the argument types. However, 5064 for a static method, g++ simply outputs the return type and the 5065 physical name. So in that case we need to demangle the name here. 5066 Here PHYSNAME is the physical name of the function, and we set the 5067 variable pointed at by PVARARGS to indicate whether this function 5068 is varargs. This returns NULL, or a NULL terminated array of 5069 argument types. */ 5070 5071 static debug_type * 5072 stab_demangle_v3_argtypes (void *dhandle, struct stab_handle *info, 5073 const char *physname, bfd_boolean *pvarargs) 5074 { 5075 struct demangle_component *dc; 5076 void *mem; 5077 debug_type *pargs; 5078 5079 dc = cplus_demangle_v3_components (physname, DMGL_PARAMS | DMGL_ANSI, &mem); 5080 if (dc == NULL) 5081 { 5082 stab_bad_demangle (physname); 5083 return NULL; 5084 } 5085 5086 /* We expect to see TYPED_NAME, and the right subtree describes the 5087 function type. */ 5088 if (dc->type != DEMANGLE_COMPONENT_TYPED_NAME 5089 || dc->u.s_binary.right->type != DEMANGLE_COMPONENT_FUNCTION_TYPE) 5090 { 5091 fprintf (stderr, _("Demangled name is not a function\n")); 5092 free (mem); 5093 return NULL; 5094 } 5095 5096 pargs = stab_demangle_v3_arglist (dhandle, info, 5097 dc->u.s_binary.right->u.s_binary.right, 5098 pvarargs); 5099 5100 free (mem); 5101 5102 return pargs; 5103 } 5104 5105 /* Demangle an argument list in a struct demangle_component tree. 5106 Returns a DEBUG_TYPE_NULL terminated array of argument types, and 5107 sets *PVARARGS to indicate whether this is a varargs function. */ 5108 5109 static debug_type * 5110 stab_demangle_v3_arglist (void *dhandle, struct stab_handle *info, 5111 struct demangle_component *arglist, 5112 bfd_boolean *pvarargs) 5113 { 5114 struct demangle_component *dc; 5115 unsigned int alloc, count; 5116 debug_type *pargs; 5117 5118 alloc = 10; 5119 pargs = (debug_type *) xmalloc (alloc * sizeof *pargs); 5120 *pvarargs = FALSE; 5121 5122 count = 0; 5123 5124 for (dc = arglist; 5125 dc != NULL; 5126 dc = dc->u.s_binary.right) 5127 { 5128 debug_type arg; 5129 bfd_boolean varargs; 5130 5131 if (dc->type != DEMANGLE_COMPONENT_ARGLIST) 5132 { 5133 fprintf (stderr, _("Unexpected type in v3 arglist demangling\n")); 5134 free (pargs); 5135 return NULL; 5136 } 5137 5138 arg = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left, 5139 NULL, &varargs); 5140 if (arg == NULL) 5141 { 5142 if (varargs) 5143 { 5144 *pvarargs = TRUE; 5145 continue; 5146 } 5147 free (pargs); 5148 return NULL; 5149 } 5150 5151 if (count + 1 >= alloc) 5152 { 5153 alloc += 10; 5154 pargs = (debug_type *) xrealloc (pargs, alloc * sizeof *pargs); 5155 } 5156 5157 pargs[count] = arg; 5158 ++count; 5159 } 5160 5161 pargs[count] = DEBUG_TYPE_NULL; 5162 5163 return pargs; 5164 } 5165 5166 /* Convert a struct demangle_component tree describing an argument 5167 type into a debug_type. */ 5168 5169 static debug_type 5170 stab_demangle_v3_arg (void *dhandle, struct stab_handle *info, 5171 struct demangle_component *dc, debug_type context, 5172 bfd_boolean *pvarargs) 5173 { 5174 debug_type dt; 5175 5176 if (pvarargs != NULL) 5177 *pvarargs = FALSE; 5178 5179 switch (dc->type) 5180 { 5181 /* FIXME: These are demangle component types which we probably 5182 need to handle one way or another. */ 5183 case DEMANGLE_COMPONENT_LOCAL_NAME: 5184 case DEMANGLE_COMPONENT_TYPED_NAME: 5185 case DEMANGLE_COMPONENT_TEMPLATE_PARAM: 5186 case DEMANGLE_COMPONENT_CTOR: 5187 case DEMANGLE_COMPONENT_DTOR: 5188 case DEMANGLE_COMPONENT_JAVA_CLASS: 5189 case DEMANGLE_COMPONENT_RESTRICT_THIS: 5190 case DEMANGLE_COMPONENT_VOLATILE_THIS: 5191 case DEMANGLE_COMPONENT_CONST_THIS: 5192 case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL: 5193 case DEMANGLE_COMPONENT_COMPLEX: 5194 case DEMANGLE_COMPONENT_IMAGINARY: 5195 case DEMANGLE_COMPONENT_VENDOR_TYPE: 5196 case DEMANGLE_COMPONENT_ARRAY_TYPE: 5197 case DEMANGLE_COMPONENT_PTRMEM_TYPE: 5198 case DEMANGLE_COMPONENT_ARGLIST: 5199 default: 5200 fprintf (stderr, _("Unrecognized demangle component %d\n"), 5201 (int) dc->type); 5202 return NULL; 5203 5204 case DEMANGLE_COMPONENT_NAME: 5205 if (context != NULL) 5206 { 5207 const debug_field *fields; 5208 5209 fields = debug_get_fields (dhandle, context); 5210 if (fields != NULL) 5211 { 5212 /* Try to find this type by looking through the context 5213 class. */ 5214 for (; *fields != DEBUG_FIELD_NULL; fields++) 5215 { 5216 debug_type ft; 5217 const char *dn; 5218 5219 ft = debug_get_field_type (dhandle, *fields); 5220 if (ft == NULL) 5221 return NULL; 5222 dn = debug_get_type_name (dhandle, ft); 5223 if (dn != NULL 5224 && (int) strlen (dn) == dc->u.s_name.len 5225 && strncmp (dn, dc->u.s_name.s, dc->u.s_name.len) == 0) 5226 return ft; 5227 } 5228 } 5229 } 5230 return stab_find_tagged_type (dhandle, info, dc->u.s_name.s, 5231 dc->u.s_name.len, DEBUG_KIND_ILLEGAL); 5232 5233 case DEMANGLE_COMPONENT_QUAL_NAME: 5234 context = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left, 5235 context, NULL); 5236 if (context == NULL) 5237 return NULL; 5238 return stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.right, 5239 context, NULL); 5240 5241 case DEMANGLE_COMPONENT_TEMPLATE: 5242 { 5243 char *p; 5244 size_t alc; 5245 5246 /* We print this component to get a class name which we can 5247 use. FIXME: This probably won't work if the template uses 5248 template parameters which refer to an outer template. */ 5249 p = cplus_demangle_print (DMGL_PARAMS | DMGL_ANSI, dc, 20, &alc); 5250 if (p == NULL) 5251 { 5252 fprintf (stderr, _("Failed to print demangled template\n")); 5253 return NULL; 5254 } 5255 dt = stab_find_tagged_type (dhandle, info, p, strlen (p), 5256 DEBUG_KIND_CLASS); 5257 free (p); 5258 return dt; 5259 } 5260 5261 case DEMANGLE_COMPONENT_SUB_STD: 5262 return stab_find_tagged_type (dhandle, info, dc->u.s_string.string, 5263 dc->u.s_string.len, DEBUG_KIND_ILLEGAL); 5264 5265 case DEMANGLE_COMPONENT_RESTRICT: 5266 case DEMANGLE_COMPONENT_VOLATILE: 5267 case DEMANGLE_COMPONENT_CONST: 5268 case DEMANGLE_COMPONENT_POINTER: 5269 case DEMANGLE_COMPONENT_REFERENCE: 5270 dt = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left, NULL, 5271 NULL); 5272 if (dt == NULL) 5273 return NULL; 5274 5275 switch (dc->type) 5276 { 5277 default: 5278 abort (); 5279 case DEMANGLE_COMPONENT_RESTRICT: 5280 /* FIXME: We have no way to represent restrict. */ 5281 return dt; 5282 case DEMANGLE_COMPONENT_VOLATILE: 5283 return debug_make_volatile_type (dhandle, dt); 5284 case DEMANGLE_COMPONENT_CONST: 5285 return debug_make_const_type (dhandle, dt); 5286 case DEMANGLE_COMPONENT_POINTER: 5287 return debug_make_pointer_type (dhandle, dt); 5288 case DEMANGLE_COMPONENT_REFERENCE: 5289 return debug_make_reference_type (dhandle, dt); 5290 } 5291 5292 case DEMANGLE_COMPONENT_FUNCTION_TYPE: 5293 { 5294 debug_type *pargs; 5295 bfd_boolean varargs; 5296 5297 if (dc->u.s_binary.left == NULL) 5298 { 5299 /* In this case the return type is actually unknown. 5300 However, I'm not sure this will ever arise in practice; 5301 normally an unknown return type would only appear at 5302 the top level, which is handled above. */ 5303 dt = debug_make_void_type (dhandle); 5304 } 5305 else 5306 dt = stab_demangle_v3_arg (dhandle, info, dc->u.s_binary.left, NULL, 5307 NULL); 5308 if (dt == NULL) 5309 return NULL; 5310 5311 pargs = stab_demangle_v3_arglist (dhandle, info, 5312 dc->u.s_binary.right, 5313 &varargs); 5314 if (pargs == NULL) 5315 return NULL; 5316 5317 return debug_make_function_type (dhandle, dt, pargs, varargs); 5318 } 5319 5320 case DEMANGLE_COMPONENT_BUILTIN_TYPE: 5321 { 5322 char *p; 5323 size_t alc; 5324 debug_type ret; 5325 5326 /* We print this component in order to find out the type name. 5327 FIXME: Should we instead expose the 5328 demangle_builtin_type_info structure? */ 5329 p = cplus_demangle_print (DMGL_PARAMS | DMGL_ANSI, dc, 20, &alc); 5330 if (p == NULL) 5331 { 5332 fprintf (stderr, _("Couldn't get demangled builtin type\n")); 5333 return NULL; 5334 } 5335 5336 /* The mangling is based on the type, but does not itself 5337 indicate what the sizes are. So we have to guess. */ 5338 if (strcmp (p, "signed char") == 0) 5339 ret = debug_make_int_type (dhandle, 1, FALSE); 5340 else if (strcmp (p, "bool") == 0) 5341 ret = debug_make_bool_type (dhandle, 1); 5342 else if (strcmp (p, "char") == 0) 5343 ret = debug_make_int_type (dhandle, 1, FALSE); 5344 else if (strcmp (p, "double") == 0) 5345 ret = debug_make_float_type (dhandle, 8); 5346 else if (strcmp (p, "long double") == 0) 5347 ret = debug_make_float_type (dhandle, 8); 5348 else if (strcmp (p, "float") == 0) 5349 ret = debug_make_float_type (dhandle, 4); 5350 else if (strcmp (p, "__float128") == 0) 5351 ret = debug_make_float_type (dhandle, 16); 5352 else if (strcmp (p, "unsigned char") == 0) 5353 ret = debug_make_int_type (dhandle, 1, TRUE); 5354 else if (strcmp (p, "int") == 0) 5355 ret = debug_make_int_type (dhandle, 4, FALSE); 5356 else if (strcmp (p, "unsigned int") == 0) 5357 ret = debug_make_int_type (dhandle, 4, TRUE); 5358 else if (strcmp (p, "long") == 0) 5359 ret = debug_make_int_type (dhandle, 4, FALSE); 5360 else if (strcmp (p, "unsigned long") == 0) 5361 ret = debug_make_int_type (dhandle, 4, TRUE); 5362 else if (strcmp (p, "__int128") == 0) 5363 ret = debug_make_int_type (dhandle, 16, FALSE); 5364 else if (strcmp (p, "unsigned __int128") == 0) 5365 ret = debug_make_int_type (dhandle, 16, TRUE); 5366 else if (strcmp (p, "short") == 0) 5367 ret = debug_make_int_type (dhandle, 2, FALSE); 5368 else if (strcmp (p, "unsigned short") == 0) 5369 ret = debug_make_int_type (dhandle, 2, TRUE); 5370 else if (strcmp (p, "void") == 0) 5371 ret = debug_make_void_type (dhandle); 5372 else if (strcmp (p, "wchar_t") == 0) 5373 ret = debug_make_int_type (dhandle, 4, TRUE); 5374 else if (strcmp (p, "long long") == 0) 5375 ret = debug_make_int_type (dhandle, 8, FALSE); 5376 else if (strcmp (p, "unsigned long long") == 0) 5377 ret = debug_make_int_type (dhandle, 8, TRUE); 5378 else if (strcmp (p, "...") == 0) 5379 { 5380 if (pvarargs == NULL) 5381 fprintf (stderr, _("Unexpected demangled varargs\n")); 5382 else 5383 *pvarargs = TRUE; 5384 ret = NULL; 5385 } 5386 else 5387 { 5388 fprintf (stderr, _("Unrecognized demangled builtin type\n")); 5389 ret = NULL; 5390 } 5391 5392 free (p); 5393 5394 return ret; 5395 } 5396 } 5397 } 5398