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