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