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