1 /* Support routines for decoding "stabs" debugging information format. 2 3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 5 2008, 2009, 2010, 2011 Free Software Foundation, Inc. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22 /* Support routines for reading and decoding debugging information in 23 the "stabs" format. This format is used with many systems that use 24 the a.out object file format, as well as some systems that use 25 COFF or ELF where the stabs data is placed in a special section. 26 Avoid placing any object file format specific code in this file. */ 27 28 #include "defs.h" 29 #include "gdb_string.h" 30 #include "bfd.h" 31 #include "gdb_obstack.h" 32 #include "symtab.h" 33 #include "gdbtypes.h" 34 #include "expression.h" 35 #include "symfile.h" 36 #include "objfiles.h" 37 #include "aout/stab_gnu.h" /* We always use GNU stabs, not native. */ 38 #include "libaout.h" 39 #include "aout/aout64.h" 40 #include "gdb-stabs.h" 41 #include "buildsym.h" 42 #include "complaints.h" 43 #include "demangle.h" 44 #include "language.h" 45 #include "doublest.h" 46 #include "cp-abi.h" 47 #include "cp-support.h" 48 #include "gdb_assert.h" 49 50 #include <ctype.h> 51 52 /* Ask stabsread.h to define the vars it normally declares `extern'. */ 53 #define EXTERN 54 /**/ 55 #include "stabsread.h" /* Our own declarations */ 56 #undef EXTERN 57 58 extern void _initialize_stabsread (void); 59 60 /* The routines that read and process a complete stabs for a C struct or 61 C++ class pass lists of data member fields and lists of member function 62 fields in an instance of a field_info structure, as defined below. 63 This is part of some reorganization of low level C++ support and is 64 expected to eventually go away... (FIXME) */ 65 66 struct field_info 67 { 68 struct nextfield 69 { 70 struct nextfield *next; 71 72 /* This is the raw visibility from the stab. It is not checked 73 for being one of the visibilities we recognize, so code which 74 examines this field better be able to deal. */ 75 int visibility; 76 77 struct field field; 78 } 79 *list; 80 struct next_fnfieldlist 81 { 82 struct next_fnfieldlist *next; 83 struct fn_fieldlist fn_fieldlist; 84 } 85 *fnlist; 86 }; 87 88 static void 89 read_one_struct_field (struct field_info *, char **, char *, 90 struct type *, struct objfile *); 91 92 static struct type *dbx_alloc_type (int[2], struct objfile *); 93 94 static long read_huge_number (char **, int, int *, int); 95 96 static struct type *error_type (char **, struct objfile *); 97 98 static void 99 patch_block_stabs (struct pending *, struct pending_stabs *, 100 struct objfile *); 101 102 static void fix_common_block (struct symbol *, int); 103 104 static int read_type_number (char **, int *); 105 106 static struct type *read_type (char **, struct objfile *); 107 108 static struct type *read_range_type (char **, int[2], int, struct objfile *); 109 110 static struct type *read_sun_builtin_type (char **, int[2], struct objfile *); 111 112 static struct type *read_sun_floating_type (char **, int[2], 113 struct objfile *); 114 115 static struct type *read_enum_type (char **, struct type *, struct objfile *); 116 117 static struct type *rs6000_builtin_type (int, struct objfile *); 118 119 static int 120 read_member_functions (struct field_info *, char **, struct type *, 121 struct objfile *); 122 123 static int 124 read_struct_fields (struct field_info *, char **, struct type *, 125 struct objfile *); 126 127 static int 128 read_baseclasses (struct field_info *, char **, struct type *, 129 struct objfile *); 130 131 static int 132 read_tilde_fields (struct field_info *, char **, struct type *, 133 struct objfile *); 134 135 static int attach_fn_fields_to_type (struct field_info *, struct type *); 136 137 static int attach_fields_to_type (struct field_info *, struct type *, 138 struct objfile *); 139 140 static struct type *read_struct_type (char **, struct type *, 141 enum type_code, 142 struct objfile *); 143 144 static struct type *read_array_type (char **, struct type *, 145 struct objfile *); 146 147 static struct field *read_args (char **, int, struct objfile *, int *, int *); 148 149 static void add_undefined_type (struct type *, int[2]); 150 151 static int 152 read_cpp_abbrev (struct field_info *, char **, struct type *, 153 struct objfile *); 154 155 static char *find_name_end (char *name); 156 157 static int process_reference (char **string); 158 159 void stabsread_clear_cache (void); 160 161 static const char vptr_name[] = "_vptr$"; 162 static const char vb_name[] = "_vb$"; 163 164 static void 165 invalid_cpp_abbrev_complaint (const char *arg1) 166 { 167 complaint (&symfile_complaints, _("invalid C++ abbreviation `%s'"), arg1); 168 } 169 170 static void 171 reg_value_complaint (int regnum, int num_regs, const char *sym) 172 { 173 complaint (&symfile_complaints, 174 _("register number %d too large (max %d) in symbol %s"), 175 regnum, num_regs - 1, sym); 176 } 177 178 static void 179 stabs_general_complaint (const char *arg1) 180 { 181 complaint (&symfile_complaints, "%s", arg1); 182 } 183 184 /* Make a list of forward references which haven't been defined. */ 185 186 static struct type **undef_types; 187 static int undef_types_allocated; 188 static int undef_types_length; 189 static struct symbol *current_symbol = NULL; 190 191 /* Make a list of nameless types that are undefined. 192 This happens when another type is referenced by its number 193 before this type is actually defined. For instance "t(0,1)=k(0,2)" 194 and type (0,2) is defined only later. */ 195 196 struct nat 197 { 198 int typenums[2]; 199 struct type *type; 200 }; 201 static struct nat *noname_undefs; 202 static int noname_undefs_allocated; 203 static int noname_undefs_length; 204 205 /* Check for and handle cretinous stabs symbol name continuation! */ 206 #define STABS_CONTINUE(pp,objfile) \ 207 do { \ 208 if (**(pp) == '\\' || (**(pp) == '?' && (*(pp))[1] == '\0')) \ 209 *(pp) = next_symbol_text (objfile); \ 210 } while (0) 211 212 213 /* Look up a dbx type-number pair. Return the address of the slot 214 where the type for that number-pair is stored. 215 The number-pair is in TYPENUMS. 216 217 This can be used for finding the type associated with that pair 218 or for associating a new type with the pair. */ 219 220 static struct type ** 221 dbx_lookup_type (int typenums[2], struct objfile *objfile) 222 { 223 int filenum = typenums[0]; 224 int index = typenums[1]; 225 unsigned old_len; 226 int real_filenum; 227 struct header_file *f; 228 int f_orig_length; 229 230 if (filenum == -1) /* -1,-1 is for temporary types. */ 231 return 0; 232 233 if (filenum < 0 || filenum >= n_this_object_header_files) 234 { 235 complaint (&symfile_complaints, 236 _("Invalid symbol data: type number " 237 "(%d,%d) out of range at symtab pos %d."), 238 filenum, index, symnum); 239 goto error_return; 240 } 241 242 if (filenum == 0) 243 { 244 if (index < 0) 245 { 246 /* Caller wants address of address of type. We think 247 that negative (rs6k builtin) types will never appear as 248 "lvalues", (nor should they), so we stuff the real type 249 pointer into a temp, and return its address. If referenced, 250 this will do the right thing. */ 251 static struct type *temp_type; 252 253 temp_type = rs6000_builtin_type (index, objfile); 254 return &temp_type; 255 } 256 257 /* Type is defined outside of header files. 258 Find it in this object file's type vector. */ 259 if (index >= type_vector_length) 260 { 261 old_len = type_vector_length; 262 if (old_len == 0) 263 { 264 type_vector_length = INITIAL_TYPE_VECTOR_LENGTH; 265 type_vector = (struct type **) 266 xmalloc (type_vector_length * sizeof (struct type *)); 267 } 268 while (index >= type_vector_length) 269 { 270 type_vector_length *= 2; 271 } 272 type_vector = (struct type **) 273 xrealloc ((char *) type_vector, 274 (type_vector_length * sizeof (struct type *))); 275 memset (&type_vector[old_len], 0, 276 (type_vector_length - old_len) * sizeof (struct type *)); 277 } 278 return (&type_vector[index]); 279 } 280 else 281 { 282 real_filenum = this_object_header_files[filenum]; 283 284 if (real_filenum >= N_HEADER_FILES (objfile)) 285 { 286 static struct type *temp_type; 287 288 warning (_("GDB internal error: bad real_filenum")); 289 290 error_return: 291 temp_type = objfile_type (objfile)->builtin_error; 292 return &temp_type; 293 } 294 295 f = HEADER_FILES (objfile) + real_filenum; 296 297 f_orig_length = f->length; 298 if (index >= f_orig_length) 299 { 300 while (index >= f->length) 301 { 302 f->length *= 2; 303 } 304 f->vector = (struct type **) 305 xrealloc ((char *) f->vector, f->length * sizeof (struct type *)); 306 memset (&f->vector[f_orig_length], 0, 307 (f->length - f_orig_length) * sizeof (struct type *)); 308 } 309 return (&f->vector[index]); 310 } 311 } 312 313 /* Make sure there is a type allocated for type numbers TYPENUMS 314 and return the type object. 315 This can create an empty (zeroed) type object. 316 TYPENUMS may be (-1, -1) to return a new type object that is not 317 put into the type vector, and so may not be referred to by number. */ 318 319 static struct type * 320 dbx_alloc_type (int typenums[2], struct objfile *objfile) 321 { 322 struct type **type_addr; 323 324 if (typenums[0] == -1) 325 { 326 return (alloc_type (objfile)); 327 } 328 329 type_addr = dbx_lookup_type (typenums, objfile); 330 331 /* If we are referring to a type not known at all yet, 332 allocate an empty type for it. 333 We will fill it in later if we find out how. */ 334 if (*type_addr == 0) 335 { 336 *type_addr = alloc_type (objfile); 337 } 338 339 return (*type_addr); 340 } 341 342 /* for all the stabs in a given stab vector, build appropriate types 343 and fix their symbols in given symbol vector. */ 344 345 static void 346 patch_block_stabs (struct pending *symbols, struct pending_stabs *stabs, 347 struct objfile *objfile) 348 { 349 int ii; 350 char *name; 351 char *pp; 352 struct symbol *sym; 353 354 if (stabs) 355 { 356 /* for all the stab entries, find their corresponding symbols and 357 patch their types! */ 358 359 for (ii = 0; ii < stabs->count; ++ii) 360 { 361 name = stabs->stab[ii]; 362 pp = (char *) strchr (name, ':'); 363 gdb_assert (pp); /* Must find a ':' or game's over. */ 364 while (pp[1] == ':') 365 { 366 pp += 2; 367 pp = (char *) strchr (pp, ':'); 368 } 369 sym = find_symbol_in_list (symbols, name, pp - name); 370 if (!sym) 371 { 372 /* FIXME-maybe: it would be nice if we noticed whether 373 the variable was defined *anywhere*, not just whether 374 it is defined in this compilation unit. But neither 375 xlc or GCC seem to need such a definition, and until 376 we do psymtabs (so that the minimal symbols from all 377 compilation units are available now), I'm not sure 378 how to get the information. */ 379 380 /* On xcoff, if a global is defined and never referenced, 381 ld will remove it from the executable. There is then 382 a N_GSYM stab for it, but no regular (C_EXT) symbol. */ 383 sym = (struct symbol *) 384 obstack_alloc (&objfile->objfile_obstack, 385 sizeof (struct symbol)); 386 387 memset (sym, 0, sizeof (struct symbol)); 388 SYMBOL_DOMAIN (sym) = VAR_DOMAIN; 389 SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT; 390 SYMBOL_SET_LINKAGE_NAME 391 (sym, obsavestring (name, pp - name, 392 &objfile->objfile_obstack)); 393 pp += 2; 394 if (*(pp - 1) == 'F' || *(pp - 1) == 'f') 395 { 396 /* I don't think the linker does this with functions, 397 so as far as I know this is never executed. 398 But it doesn't hurt to check. */ 399 SYMBOL_TYPE (sym) = 400 lookup_function_type (read_type (&pp, objfile)); 401 } 402 else 403 { 404 SYMBOL_TYPE (sym) = read_type (&pp, objfile); 405 } 406 add_symbol_to_list (sym, &global_symbols); 407 } 408 else 409 { 410 pp += 2; 411 if (*(pp - 1) == 'F' || *(pp - 1) == 'f') 412 { 413 SYMBOL_TYPE (sym) = 414 lookup_function_type (read_type (&pp, objfile)); 415 } 416 else 417 { 418 SYMBOL_TYPE (sym) = read_type (&pp, objfile); 419 } 420 } 421 } 422 } 423 } 424 425 426 /* Read a number by which a type is referred to in dbx data, 427 or perhaps read a pair (FILENUM, TYPENUM) in parentheses. 428 Just a single number N is equivalent to (0,N). 429 Return the two numbers by storing them in the vector TYPENUMS. 430 TYPENUMS will then be used as an argument to dbx_lookup_type. 431 432 Returns 0 for success, -1 for error. */ 433 434 static int 435 read_type_number (char **pp, int *typenums) 436 { 437 int nbits; 438 439 if (**pp == '(') 440 { 441 (*pp)++; 442 typenums[0] = read_huge_number (pp, ',', &nbits, 0); 443 if (nbits != 0) 444 return -1; 445 typenums[1] = read_huge_number (pp, ')', &nbits, 0); 446 if (nbits != 0) 447 return -1; 448 } 449 else 450 { 451 typenums[0] = 0; 452 typenums[1] = read_huge_number (pp, 0, &nbits, 0); 453 if (nbits != 0) 454 return -1; 455 } 456 return 0; 457 } 458 459 460 #define VISIBILITY_PRIVATE '0' /* Stabs character for private field */ 461 #define VISIBILITY_PROTECTED '1' /* Stabs character for protected fld */ 462 #define VISIBILITY_PUBLIC '2' /* Stabs character for public field */ 463 #define VISIBILITY_IGNORE '9' /* Optimized out or zero length */ 464 465 /* Structure for storing pointers to reference definitions for fast lookup 466 during "process_later". */ 467 468 struct ref_map 469 { 470 char *stabs; 471 CORE_ADDR value; 472 struct symbol *sym; 473 }; 474 475 #define MAX_CHUNK_REFS 100 476 #define REF_CHUNK_SIZE (MAX_CHUNK_REFS * sizeof (struct ref_map)) 477 #define REF_MAP_SIZE(ref_chunk) ((ref_chunk) * REF_CHUNK_SIZE) 478 479 static struct ref_map *ref_map; 480 481 /* Ptr to free cell in chunk's linked list. */ 482 static int ref_count = 0; 483 484 /* Number of chunks malloced. */ 485 static int ref_chunk = 0; 486 487 /* This file maintains a cache of stabs aliases found in the symbol 488 table. If the symbol table changes, this cache must be cleared 489 or we are left holding onto data in invalid obstacks. */ 490 void 491 stabsread_clear_cache (void) 492 { 493 ref_count = 0; 494 ref_chunk = 0; 495 } 496 497 /* Create array of pointers mapping refids to symbols and stab strings. 498 Add pointers to reference definition symbols and/or their values as we 499 find them, using their reference numbers as our index. 500 These will be used later when we resolve references. */ 501 void 502 ref_add (int refnum, struct symbol *sym, char *stabs, CORE_ADDR value) 503 { 504 if (ref_count == 0) 505 ref_chunk = 0; 506 if (refnum >= ref_count) 507 ref_count = refnum + 1; 508 if (ref_count > ref_chunk * MAX_CHUNK_REFS) 509 { 510 int new_slots = ref_count - ref_chunk * MAX_CHUNK_REFS; 511 int new_chunks = new_slots / MAX_CHUNK_REFS + 1; 512 513 ref_map = (struct ref_map *) 514 xrealloc (ref_map, REF_MAP_SIZE (ref_chunk + new_chunks)); 515 memset (ref_map + ref_chunk * MAX_CHUNK_REFS, 0, 516 new_chunks * REF_CHUNK_SIZE); 517 ref_chunk += new_chunks; 518 } 519 ref_map[refnum].stabs = stabs; 520 ref_map[refnum].sym = sym; 521 ref_map[refnum].value = value; 522 } 523 524 /* Return defined sym for the reference REFNUM. */ 525 struct symbol * 526 ref_search (int refnum) 527 { 528 if (refnum < 0 || refnum > ref_count) 529 return 0; 530 return ref_map[refnum].sym; 531 } 532 533 /* Parse a reference id in STRING and return the resulting 534 reference number. Move STRING beyond the reference id. */ 535 536 static int 537 process_reference (char **string) 538 { 539 char *p; 540 int refnum = 0; 541 542 if (**string != '#') 543 return 0; 544 545 /* Advance beyond the initial '#'. */ 546 p = *string + 1; 547 548 /* Read number as reference id. */ 549 while (*p && isdigit (*p)) 550 { 551 refnum = refnum * 10 + *p - '0'; 552 p++; 553 } 554 *string = p; 555 return refnum; 556 } 557 558 /* If STRING defines a reference, store away a pointer to the reference 559 definition for later use. Return the reference number. */ 560 561 int 562 symbol_reference_defined (char **string) 563 { 564 char *p = *string; 565 int refnum = 0; 566 567 refnum = process_reference (&p); 568 569 /* Defining symbols end in '='. */ 570 if (*p == '=') 571 { 572 /* Symbol is being defined here. */ 573 *string = p + 1; 574 return refnum; 575 } 576 else 577 { 578 /* Must be a reference. Either the symbol has already been defined, 579 or this is a forward reference to it. */ 580 *string = p; 581 return -1; 582 } 583 } 584 585 static int 586 stab_reg_to_regnum (struct symbol *sym, struct gdbarch *gdbarch) 587 { 588 int regno = gdbarch_stab_reg_to_regnum (gdbarch, SYMBOL_VALUE (sym)); 589 590 if (regno >= gdbarch_num_regs (gdbarch) 591 + gdbarch_num_pseudo_regs (gdbarch)) 592 { 593 reg_value_complaint (regno, 594 gdbarch_num_regs (gdbarch) 595 + gdbarch_num_pseudo_regs (gdbarch), 596 SYMBOL_PRINT_NAME (sym)); 597 598 regno = gdbarch_sp_regnum (gdbarch); /* Known safe, though useless. */ 599 } 600 601 return regno; 602 } 603 604 static const struct symbol_register_ops stab_register_funcs = { 605 stab_reg_to_regnum 606 }; 607 608 struct symbol * 609 define_symbol (CORE_ADDR valu, char *string, int desc, int type, 610 struct objfile *objfile) 611 { 612 struct gdbarch *gdbarch = get_objfile_arch (objfile); 613 struct symbol *sym; 614 char *p = (char *) find_name_end (string); 615 int deftype; 616 int synonym = 0; 617 int i; 618 char *new_name = NULL; 619 620 /* We would like to eliminate nameless symbols, but keep their types. 621 E.g. stab entry ":t10=*2" should produce a type 10, which is a pointer 622 to type 2, but, should not create a symbol to address that type. Since 623 the symbol will be nameless, there is no way any user can refer to it. */ 624 625 int nameless; 626 627 /* Ignore syms with empty names. */ 628 if (string[0] == 0) 629 return 0; 630 631 /* Ignore old-style symbols from cc -go. */ 632 if (p == 0) 633 return 0; 634 635 while (p[1] == ':') 636 { 637 p += 2; 638 p = strchr (p, ':'); 639 if (p == NULL) 640 { 641 complaint (&symfile_complaints, 642 _("Bad stabs string '%s'"), string); 643 return NULL; 644 } 645 } 646 647 /* If a nameless stab entry, all we need is the type, not the symbol. 648 e.g. ":t10=*2" or a nameless enum like " :T16=ered:0,green:1,blue:2,;" */ 649 nameless = (p == string || ((string[0] == ' ') && (string[1] == ':'))); 650 651 current_symbol = sym = (struct symbol *) 652 obstack_alloc (&objfile->objfile_obstack, sizeof (struct symbol)); 653 memset (sym, 0, sizeof (struct symbol)); 654 655 switch (type & N_TYPE) 656 { 657 case N_TEXT: 658 SYMBOL_SECTION (sym) = SECT_OFF_TEXT (objfile); 659 break; 660 case N_DATA: 661 SYMBOL_SECTION (sym) = SECT_OFF_DATA (objfile); 662 break; 663 case N_BSS: 664 SYMBOL_SECTION (sym) = SECT_OFF_BSS (objfile); 665 break; 666 } 667 668 if (processing_gcc_compilation) 669 { 670 /* GCC 2.x puts the line number in desc. SunOS apparently puts in the 671 number of bytes occupied by a type or object, which we ignore. */ 672 SYMBOL_LINE (sym) = desc; 673 } 674 else 675 { 676 SYMBOL_LINE (sym) = 0; /* unknown */ 677 } 678 679 if (is_cplus_marker (string[0])) 680 { 681 /* Special GNU C++ names. */ 682 switch (string[1]) 683 { 684 case 't': 685 SYMBOL_SET_LINKAGE_NAME (sym, "this"); 686 break; 687 688 case 'v': /* $vtbl_ptr_type */ 689 goto normal; 690 691 case 'e': 692 SYMBOL_SET_LINKAGE_NAME (sym, "eh_throw"); 693 break; 694 695 case '_': 696 /* This was an anonymous type that was never fixed up. */ 697 goto normal; 698 699 case 'X': 700 /* SunPRO (3.0 at least) static variable encoding. */ 701 if (gdbarch_static_transform_name_p (gdbarch)) 702 goto normal; 703 /* ... fall through ... */ 704 705 default: 706 complaint (&symfile_complaints, _("Unknown C++ symbol name `%s'"), 707 string); 708 goto normal; /* Do *something* with it. */ 709 } 710 } 711 else 712 { 713 normal: 714 SYMBOL_SET_LANGUAGE (sym, current_subfile->language); 715 if (SYMBOL_LANGUAGE (sym) == language_cplus) 716 { 717 char *name = alloca (p - string + 1); 718 719 memcpy (name, string, p - string); 720 name[p - string] = '\0'; 721 new_name = cp_canonicalize_string (name); 722 } 723 if (new_name != NULL) 724 { 725 SYMBOL_SET_NAMES (sym, new_name, strlen (new_name), 1, objfile); 726 xfree (new_name); 727 } 728 else 729 SYMBOL_SET_NAMES (sym, string, p - string, 1, objfile); 730 731 if (SYMBOL_LANGUAGE (sym) == language_cplus) 732 cp_scan_for_anonymous_namespaces (sym); 733 734 } 735 p++; 736 737 /* Determine the type of name being defined. */ 738 #if 0 739 /* Getting GDB to correctly skip the symbol on an undefined symbol 740 descriptor and not ever dump core is a very dodgy proposition if 741 we do things this way. I say the acorn RISC machine can just 742 fix their compiler. */ 743 /* The Acorn RISC machine's compiler can put out locals that don't 744 start with "234=" or "(3,4)=", so assume anything other than the 745 deftypes we know how to handle is a local. */ 746 if (!strchr ("cfFGpPrStTvVXCR", *p)) 747 #else 748 if (isdigit (*p) || *p == '(' || *p == '-') 749 #endif 750 deftype = 'l'; 751 else 752 deftype = *p++; 753 754 switch (deftype) 755 { 756 case 'c': 757 /* c is a special case, not followed by a type-number. 758 SYMBOL:c=iVALUE for an integer constant symbol. 759 SYMBOL:c=rVALUE for a floating constant symbol. 760 SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol. 761 e.g. "b:c=e6,0" for "const b = blob1" 762 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */ 763 if (*p != '=') 764 { 765 SYMBOL_CLASS (sym) = LOC_CONST; 766 SYMBOL_TYPE (sym) = error_type (&p, objfile); 767 SYMBOL_DOMAIN (sym) = VAR_DOMAIN; 768 add_symbol_to_list (sym, &file_symbols); 769 return sym; 770 } 771 ++p; 772 switch (*p++) 773 { 774 case 'r': 775 { 776 double d = atof (p); 777 gdb_byte *dbl_valu; 778 struct type *dbl_type; 779 780 /* FIXME-if-picky-about-floating-accuracy: Should be using 781 target arithmetic to get the value. real.c in GCC 782 probably has the necessary code. */ 783 784 dbl_type = objfile_type (objfile)->builtin_double; 785 dbl_valu = 786 obstack_alloc (&objfile->objfile_obstack, 787 TYPE_LENGTH (dbl_type)); 788 store_typed_floating (dbl_valu, dbl_type, d); 789 790 SYMBOL_TYPE (sym) = dbl_type; 791 SYMBOL_VALUE_BYTES (sym) = dbl_valu; 792 SYMBOL_CLASS (sym) = LOC_CONST_BYTES; 793 } 794 break; 795 case 'i': 796 { 797 /* Defining integer constants this way is kind of silly, 798 since 'e' constants allows the compiler to give not 799 only the value, but the type as well. C has at least 800 int, long, unsigned int, and long long as constant 801 types; other languages probably should have at least 802 unsigned as well as signed constants. */ 803 804 SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_long; 805 SYMBOL_VALUE (sym) = atoi (p); 806 SYMBOL_CLASS (sym) = LOC_CONST; 807 } 808 break; 809 810 case 'c': 811 { 812 SYMBOL_TYPE (sym) = objfile_type (objfile)->builtin_char; 813 SYMBOL_VALUE (sym) = atoi (p); 814 SYMBOL_CLASS (sym) = LOC_CONST; 815 } 816 break; 817 818 case 's': 819 { 820 struct type *range_type; 821 int ind = 0; 822 char quote = *p++; 823 gdb_byte *string_local = (gdb_byte *) alloca (strlen (p)); 824 gdb_byte *string_value; 825 826 if (quote != '\'' && quote != '"') 827 { 828 SYMBOL_CLASS (sym) = LOC_CONST; 829 SYMBOL_TYPE (sym) = error_type (&p, objfile); 830 SYMBOL_DOMAIN (sym) = VAR_DOMAIN; 831 add_symbol_to_list (sym, &file_symbols); 832 return sym; 833 } 834 835 /* Find matching quote, rejecting escaped quotes. */ 836 while (*p && *p != quote) 837 { 838 if (*p == '\\' && p[1] == quote) 839 { 840 string_local[ind] = (gdb_byte) quote; 841 ind++; 842 p += 2; 843 } 844 else if (*p) 845 { 846 string_local[ind] = (gdb_byte) (*p); 847 ind++; 848 p++; 849 } 850 } 851 if (*p != quote) 852 { 853 SYMBOL_CLASS (sym) = LOC_CONST; 854 SYMBOL_TYPE (sym) = error_type (&p, objfile); 855 SYMBOL_DOMAIN (sym) = VAR_DOMAIN; 856 add_symbol_to_list (sym, &file_symbols); 857 return sym; 858 } 859 860 /* NULL terminate the string. */ 861 string_local[ind] = 0; 862 range_type 863 = create_range_type (NULL, 864 objfile_type (objfile)->builtin_int, 865 0, ind); 866 SYMBOL_TYPE (sym) = create_array_type (NULL, 867 objfile_type (objfile)->builtin_char, 868 range_type); 869 string_value = obstack_alloc (&objfile->objfile_obstack, ind + 1); 870 memcpy (string_value, string_local, ind + 1); 871 p++; 872 873 SYMBOL_VALUE_BYTES (sym) = string_value; 874 SYMBOL_CLASS (sym) = LOC_CONST_BYTES; 875 } 876 break; 877 878 case 'e': 879 /* SYMBOL:c=eTYPE,INTVALUE for a constant symbol whose value 880 can be represented as integral. 881 e.g. "b:c=e6,0" for "const b = blob1" 882 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */ 883 { 884 SYMBOL_CLASS (sym) = LOC_CONST; 885 SYMBOL_TYPE (sym) = read_type (&p, objfile); 886 887 if (*p != ',') 888 { 889 SYMBOL_TYPE (sym) = error_type (&p, objfile); 890 break; 891 } 892 ++p; 893 894 /* If the value is too big to fit in an int (perhaps because 895 it is unsigned), or something like that, we silently get 896 a bogus value. The type and everything else about it is 897 correct. Ideally, we should be using whatever we have 898 available for parsing unsigned and long long values, 899 however. */ 900 SYMBOL_VALUE (sym) = atoi (p); 901 } 902 break; 903 default: 904 { 905 SYMBOL_CLASS (sym) = LOC_CONST; 906 SYMBOL_TYPE (sym) = error_type (&p, objfile); 907 } 908 } 909 SYMBOL_DOMAIN (sym) = VAR_DOMAIN; 910 add_symbol_to_list (sym, &file_symbols); 911 return sym; 912 913 case 'C': 914 /* The name of a caught exception. */ 915 SYMBOL_TYPE (sym) = read_type (&p, objfile); 916 SYMBOL_CLASS (sym) = LOC_LABEL; 917 SYMBOL_DOMAIN (sym) = VAR_DOMAIN; 918 SYMBOL_VALUE_ADDRESS (sym) = valu; 919 add_symbol_to_list (sym, &local_symbols); 920 break; 921 922 case 'f': 923 /* A static function definition. */ 924 SYMBOL_TYPE (sym) = read_type (&p, objfile); 925 SYMBOL_CLASS (sym) = LOC_BLOCK; 926 SYMBOL_DOMAIN (sym) = VAR_DOMAIN; 927 add_symbol_to_list (sym, &file_symbols); 928 /* fall into process_function_types. */ 929 930 process_function_types: 931 /* Function result types are described as the result type in stabs. 932 We need to convert this to the function-returning-type-X type 933 in GDB. E.g. "int" is converted to "function returning int". */ 934 if (TYPE_CODE (SYMBOL_TYPE (sym)) != TYPE_CODE_FUNC) 935 SYMBOL_TYPE (sym) = lookup_function_type (SYMBOL_TYPE (sym)); 936 937 /* All functions in C++ have prototypes. Stabs does not offer an 938 explicit way to identify prototyped or unprototyped functions, 939 but both GCC and Sun CC emit stabs for the "call-as" type rather 940 than the "declared-as" type for unprototyped functions, so 941 we treat all functions as if they were prototyped. This is used 942 primarily for promotion when calling the function from GDB. */ 943 TYPE_PROTOTYPED (SYMBOL_TYPE (sym)) = 1; 944 945 /* fall into process_prototype_types. */ 946 947 process_prototype_types: 948 /* Sun acc puts declared types of arguments here. */ 949 if (*p == ';') 950 { 951 struct type *ftype = SYMBOL_TYPE (sym); 952 int nsemi = 0; 953 int nparams = 0; 954 char *p1 = p; 955 956 /* Obtain a worst case guess for the number of arguments 957 by counting the semicolons. */ 958 while (*p1) 959 { 960 if (*p1++ == ';') 961 nsemi++; 962 } 963 964 /* Allocate parameter information fields and fill them in. */ 965 TYPE_FIELDS (ftype) = (struct field *) 966 TYPE_ALLOC (ftype, nsemi * sizeof (struct field)); 967 while (*p++ == ';') 968 { 969 struct type *ptype; 970 971 /* A type number of zero indicates the start of varargs. 972 FIXME: GDB currently ignores vararg functions. */ 973 if (p[0] == '0' && p[1] == '\0') 974 break; 975 ptype = read_type (&p, objfile); 976 977 /* The Sun compilers mark integer arguments, which should 978 be promoted to the width of the calling conventions, with 979 a type which references itself. This type is turned into 980 a TYPE_CODE_VOID type by read_type, and we have to turn 981 it back into builtin_int here. 982 FIXME: Do we need a new builtin_promoted_int_arg ? */ 983 if (TYPE_CODE (ptype) == TYPE_CODE_VOID) 984 ptype = objfile_type (objfile)->builtin_int; 985 TYPE_FIELD_TYPE (ftype, nparams) = ptype; 986 TYPE_FIELD_ARTIFICIAL (ftype, nparams++) = 0; 987 } 988 TYPE_NFIELDS (ftype) = nparams; 989 TYPE_PROTOTYPED (ftype) = 1; 990 } 991 break; 992 993 case 'F': 994 /* A global function definition. */ 995 SYMBOL_TYPE (sym) = read_type (&p, objfile); 996 SYMBOL_CLASS (sym) = LOC_BLOCK; 997 SYMBOL_DOMAIN (sym) = VAR_DOMAIN; 998 add_symbol_to_list (sym, &global_symbols); 999 goto process_function_types; 1000 1001 case 'G': 1002 /* For a class G (global) symbol, it appears that the 1003 value is not correct. It is necessary to search for the 1004 corresponding linker definition to find the value. 1005 These definitions appear at the end of the namelist. */ 1006 SYMBOL_TYPE (sym) = read_type (&p, objfile); 1007 SYMBOL_CLASS (sym) = LOC_STATIC; 1008 SYMBOL_DOMAIN (sym) = VAR_DOMAIN; 1009 /* Don't add symbol references to global_sym_chain. 1010 Symbol references don't have valid names and wont't match up with 1011 minimal symbols when the global_sym_chain is relocated. 1012 We'll fixup symbol references when we fixup the defining symbol. */ 1013 if (SYMBOL_LINKAGE_NAME (sym) && SYMBOL_LINKAGE_NAME (sym)[0] != '#') 1014 { 1015 i = hashname (SYMBOL_LINKAGE_NAME (sym)); 1016 SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i]; 1017 global_sym_chain[i] = sym; 1018 } 1019 add_symbol_to_list (sym, &global_symbols); 1020 break; 1021 1022 /* This case is faked by a conditional above, 1023 when there is no code letter in the dbx data. 1024 Dbx data never actually contains 'l'. */ 1025 case 's': 1026 case 'l': 1027 SYMBOL_TYPE (sym) = read_type (&p, objfile); 1028 SYMBOL_CLASS (sym) = LOC_LOCAL; 1029 SYMBOL_VALUE (sym) = valu; 1030 SYMBOL_DOMAIN (sym) = VAR_DOMAIN; 1031 add_symbol_to_list (sym, &local_symbols); 1032 break; 1033 1034 case 'p': 1035 if (*p == 'F') 1036 /* pF is a two-letter code that means a function parameter in Fortran. 1037 The type-number specifies the type of the return value. 1038 Translate it into a pointer-to-function type. */ 1039 { 1040 p++; 1041 SYMBOL_TYPE (sym) 1042 = lookup_pointer_type 1043 (lookup_function_type (read_type (&p, objfile))); 1044 } 1045 else 1046 SYMBOL_TYPE (sym) = read_type (&p, objfile); 1047 1048 SYMBOL_CLASS (sym) = LOC_ARG; 1049 SYMBOL_VALUE (sym) = valu; 1050 SYMBOL_DOMAIN (sym) = VAR_DOMAIN; 1051 SYMBOL_IS_ARGUMENT (sym) = 1; 1052 add_symbol_to_list (sym, &local_symbols); 1053 1054 if (gdbarch_byte_order (gdbarch) != BFD_ENDIAN_BIG) 1055 { 1056 /* On little-endian machines, this crud is never necessary, 1057 and, if the extra bytes contain garbage, is harmful. */ 1058 break; 1059 } 1060 1061 /* If it's gcc-compiled, if it says `short', believe it. */ 1062 if (processing_gcc_compilation 1063 || gdbarch_believe_pcc_promotion (gdbarch)) 1064 break; 1065 1066 if (!gdbarch_believe_pcc_promotion (gdbarch)) 1067 { 1068 /* If PCC says a parameter is a short or a char, it is 1069 really an int. */ 1070 if (TYPE_LENGTH (SYMBOL_TYPE (sym)) 1071 < gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT 1072 && TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_INT) 1073 { 1074 SYMBOL_TYPE (sym) = 1075 TYPE_UNSIGNED (SYMBOL_TYPE (sym)) 1076 ? objfile_type (objfile)->builtin_unsigned_int 1077 : objfile_type (objfile)->builtin_int; 1078 } 1079 break; 1080 } 1081 1082 case 'P': 1083 /* acc seems to use P to declare the prototypes of functions that 1084 are referenced by this file. gdb is not prepared to deal 1085 with this extra information. FIXME, it ought to. */ 1086 if (type == N_FUN) 1087 { 1088 SYMBOL_TYPE (sym) = read_type (&p, objfile); 1089 goto process_prototype_types; 1090 } 1091 /*FALLTHROUGH */ 1092 1093 case 'R': 1094 /* Parameter which is in a register. */ 1095 SYMBOL_TYPE (sym) = read_type (&p, objfile); 1096 SYMBOL_CLASS (sym) = LOC_REGISTER; 1097 SYMBOL_REGISTER_OPS (sym) = &stab_register_funcs; 1098 SYMBOL_IS_ARGUMENT (sym) = 1; 1099 SYMBOL_VALUE (sym) = valu; 1100 SYMBOL_DOMAIN (sym) = VAR_DOMAIN; 1101 add_symbol_to_list (sym, &local_symbols); 1102 break; 1103 1104 case 'r': 1105 /* Register variable (either global or local). */ 1106 SYMBOL_TYPE (sym) = read_type (&p, objfile); 1107 SYMBOL_CLASS (sym) = LOC_REGISTER; 1108 SYMBOL_REGISTER_OPS (sym) = &stab_register_funcs; 1109 SYMBOL_VALUE (sym) = valu; 1110 SYMBOL_DOMAIN (sym) = VAR_DOMAIN; 1111 if (within_function) 1112 { 1113 /* Sun cc uses a pair of symbols, one 'p' and one 'r', with 1114 the same name to represent an argument passed in a 1115 register. GCC uses 'P' for the same case. So if we find 1116 such a symbol pair we combine it into one 'P' symbol. 1117 For Sun cc we need to do this regardless of 1118 stabs_argument_has_addr, because the compiler puts out 1119 the 'p' symbol even if it never saves the argument onto 1120 the stack. 1121 1122 On most machines, we want to preserve both symbols, so 1123 that we can still get information about what is going on 1124 with the stack (VAX for computing args_printed, using 1125 stack slots instead of saved registers in backtraces, 1126 etc.). 1127 1128 Note that this code illegally combines 1129 main(argc) struct foo argc; { register struct foo argc; } 1130 but this case is considered pathological and causes a warning 1131 from a decent compiler. */ 1132 1133 if (local_symbols 1134 && local_symbols->nsyms > 0 1135 && gdbarch_stabs_argument_has_addr (gdbarch, SYMBOL_TYPE (sym))) 1136 { 1137 struct symbol *prev_sym; 1138 1139 prev_sym = local_symbols->symbol[local_symbols->nsyms - 1]; 1140 if ((SYMBOL_CLASS (prev_sym) == LOC_REF_ARG 1141 || SYMBOL_CLASS (prev_sym) == LOC_ARG) 1142 && strcmp (SYMBOL_LINKAGE_NAME (prev_sym), 1143 SYMBOL_LINKAGE_NAME (sym)) == 0) 1144 { 1145 SYMBOL_CLASS (prev_sym) = LOC_REGISTER; 1146 SYMBOL_REGISTER_OPS (prev_sym) = &stab_register_funcs; 1147 /* Use the type from the LOC_REGISTER; that is the type 1148 that is actually in that register. */ 1149 SYMBOL_TYPE (prev_sym) = SYMBOL_TYPE (sym); 1150 SYMBOL_VALUE (prev_sym) = SYMBOL_VALUE (sym); 1151 sym = prev_sym; 1152 break; 1153 } 1154 } 1155 add_symbol_to_list (sym, &local_symbols); 1156 } 1157 else 1158 add_symbol_to_list (sym, &file_symbols); 1159 break; 1160 1161 case 'S': 1162 /* Static symbol at top level of file. */ 1163 SYMBOL_TYPE (sym) = read_type (&p, objfile); 1164 SYMBOL_CLASS (sym) = LOC_STATIC; 1165 SYMBOL_VALUE_ADDRESS (sym) = valu; 1166 if (gdbarch_static_transform_name_p (gdbarch) 1167 && gdbarch_static_transform_name (gdbarch, 1168 SYMBOL_LINKAGE_NAME (sym)) 1169 != SYMBOL_LINKAGE_NAME (sym)) 1170 { 1171 struct minimal_symbol *msym; 1172 1173 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym), 1174 NULL, objfile); 1175 if (msym != NULL) 1176 { 1177 char *new_name = gdbarch_static_transform_name 1178 (gdbarch, SYMBOL_LINKAGE_NAME (sym)); 1179 1180 SYMBOL_SET_LINKAGE_NAME (sym, new_name); 1181 SYMBOL_VALUE_ADDRESS (sym) = SYMBOL_VALUE_ADDRESS (msym); 1182 } 1183 } 1184 SYMBOL_DOMAIN (sym) = VAR_DOMAIN; 1185 add_symbol_to_list (sym, &file_symbols); 1186 break; 1187 1188 case 't': 1189 /* In Ada, there is no distinction between typedef and non-typedef; 1190 any type declaration implicitly has the equivalent of a typedef, 1191 and thus 't' is in fact equivalent to 'Tt'. 1192 1193 Therefore, for Ada units, we check the character immediately 1194 before the 't', and if we do not find a 'T', then make sure to 1195 create the associated symbol in the STRUCT_DOMAIN ('t' definitions 1196 will be stored in the VAR_DOMAIN). If the symbol was indeed 1197 defined as 'Tt' then the STRUCT_DOMAIN symbol will be created 1198 elsewhere, so we don't need to take care of that. 1199 1200 This is important to do, because of forward references: 1201 The cleanup of undefined types stored in undef_types only uses 1202 STRUCT_DOMAIN symbols to perform the replacement. */ 1203 synonym = (SYMBOL_LANGUAGE (sym) == language_ada && p[-2] != 'T'); 1204 1205 /* Typedef */ 1206 SYMBOL_TYPE (sym) = read_type (&p, objfile); 1207 1208 /* For a nameless type, we don't want a create a symbol, thus we 1209 did not use `sym'. Return without further processing. */ 1210 if (nameless) 1211 return NULL; 1212 1213 SYMBOL_CLASS (sym) = LOC_TYPEDEF; 1214 SYMBOL_VALUE (sym) = valu; 1215 SYMBOL_DOMAIN (sym) = VAR_DOMAIN; 1216 /* C++ vagaries: we may have a type which is derived from 1217 a base type which did not have its name defined when the 1218 derived class was output. We fill in the derived class's 1219 base part member's name here in that case. */ 1220 if (TYPE_NAME (SYMBOL_TYPE (sym)) != NULL) 1221 if ((TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT 1222 || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_UNION) 1223 && TYPE_N_BASECLASSES (SYMBOL_TYPE (sym))) 1224 { 1225 int j; 1226 1227 for (j = TYPE_N_BASECLASSES (SYMBOL_TYPE (sym)) - 1; j >= 0; j--) 1228 if (TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym), j) == 0) 1229 TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym), j) = 1230 type_name_no_tag (TYPE_BASECLASS (SYMBOL_TYPE (sym), j)); 1231 } 1232 1233 if (TYPE_NAME (SYMBOL_TYPE (sym)) == NULL) 1234 { 1235 /* gcc-2.6 or later (when using -fvtable-thunks) 1236 emits a unique named type for a vtable entry. 1237 Some gdb code depends on that specific name. */ 1238 extern const char vtbl_ptr_name[]; 1239 1240 if ((TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR 1241 && strcmp (SYMBOL_LINKAGE_NAME (sym), vtbl_ptr_name)) 1242 || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FUNC) 1243 { 1244 /* If we are giving a name to a type such as "pointer to 1245 foo" or "function returning foo", we better not set 1246 the TYPE_NAME. If the program contains "typedef char 1247 *caddr_t;", we don't want all variables of type char 1248 * to print as caddr_t. This is not just a 1249 consequence of GDB's type management; PCC and GCC (at 1250 least through version 2.4) both output variables of 1251 either type char * or caddr_t with the type number 1252 defined in the 't' symbol for caddr_t. If a future 1253 compiler cleans this up it GDB is not ready for it 1254 yet, but if it becomes ready we somehow need to 1255 disable this check (without breaking the PCC/GCC2.4 1256 case). 1257 1258 Sigh. 1259 1260 Fortunately, this check seems not to be necessary 1261 for anything except pointers or functions. */ 1262 /* ezannoni: 2000-10-26. This seems to apply for 1263 versions of gcc older than 2.8. This was the original 1264 problem: with the following code gdb would tell that 1265 the type for name1 is caddr_t, and func is char(). 1266 1267 typedef char *caddr_t; 1268 char *name2; 1269 struct x 1270 { 1271 char *name1; 1272 } xx; 1273 char *func() 1274 { 1275 } 1276 main () {} 1277 */ 1278 1279 /* Pascal accepts names for pointer types. */ 1280 if (current_subfile->language == language_pascal) 1281 { 1282 TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_LINKAGE_NAME (sym); 1283 } 1284 } 1285 else 1286 TYPE_NAME (SYMBOL_TYPE (sym)) = SYMBOL_LINKAGE_NAME (sym); 1287 } 1288 1289 add_symbol_to_list (sym, &file_symbols); 1290 1291 if (synonym) 1292 { 1293 /* Create the STRUCT_DOMAIN clone. */ 1294 struct symbol *struct_sym = (struct symbol *) 1295 obstack_alloc (&objfile->objfile_obstack, sizeof (struct symbol)); 1296 1297 *struct_sym = *sym; 1298 SYMBOL_CLASS (struct_sym) = LOC_TYPEDEF; 1299 SYMBOL_VALUE (struct_sym) = valu; 1300 SYMBOL_DOMAIN (struct_sym) = STRUCT_DOMAIN; 1301 if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0) 1302 TYPE_NAME (SYMBOL_TYPE (sym)) 1303 = obconcat (&objfile->objfile_obstack, 1304 SYMBOL_LINKAGE_NAME (sym), 1305 (char *) NULL); 1306 add_symbol_to_list (struct_sym, &file_symbols); 1307 } 1308 1309 break; 1310 1311 case 'T': 1312 /* Struct, union, or enum tag. For GNU C++, this can be be followed 1313 by 't' which means we are typedef'ing it as well. */ 1314 synonym = *p == 't'; 1315 1316 if (synonym) 1317 p++; 1318 1319 SYMBOL_TYPE (sym) = read_type (&p, objfile); 1320 1321 /* For a nameless type, we don't want a create a symbol, thus we 1322 did not use `sym'. Return without further processing. */ 1323 if (nameless) 1324 return NULL; 1325 1326 SYMBOL_CLASS (sym) = LOC_TYPEDEF; 1327 SYMBOL_VALUE (sym) = valu; 1328 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN; 1329 if (TYPE_TAG_NAME (SYMBOL_TYPE (sym)) == 0) 1330 TYPE_TAG_NAME (SYMBOL_TYPE (sym)) 1331 = obconcat (&objfile->objfile_obstack, 1332 SYMBOL_LINKAGE_NAME (sym), 1333 (char *) NULL); 1334 add_symbol_to_list (sym, &file_symbols); 1335 1336 if (synonym) 1337 { 1338 /* Clone the sym and then modify it. */ 1339 struct symbol *typedef_sym = (struct symbol *) 1340 obstack_alloc (&objfile->objfile_obstack, sizeof (struct symbol)); 1341 1342 *typedef_sym = *sym; 1343 SYMBOL_CLASS (typedef_sym) = LOC_TYPEDEF; 1344 SYMBOL_VALUE (typedef_sym) = valu; 1345 SYMBOL_DOMAIN (typedef_sym) = VAR_DOMAIN; 1346 if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0) 1347 TYPE_NAME (SYMBOL_TYPE (sym)) 1348 = obconcat (&objfile->objfile_obstack, 1349 SYMBOL_LINKAGE_NAME (sym), 1350 (char *) NULL); 1351 add_symbol_to_list (typedef_sym, &file_symbols); 1352 } 1353 break; 1354 1355 case 'V': 1356 /* Static symbol of local scope. */ 1357 SYMBOL_TYPE (sym) = read_type (&p, objfile); 1358 SYMBOL_CLASS (sym) = LOC_STATIC; 1359 SYMBOL_VALUE_ADDRESS (sym) = valu; 1360 if (gdbarch_static_transform_name_p (gdbarch) 1361 && gdbarch_static_transform_name (gdbarch, 1362 SYMBOL_LINKAGE_NAME (sym)) 1363 != SYMBOL_LINKAGE_NAME (sym)) 1364 { 1365 struct minimal_symbol *msym; 1366 1367 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym), 1368 NULL, objfile); 1369 if (msym != NULL) 1370 { 1371 char *new_name = gdbarch_static_transform_name 1372 (gdbarch, SYMBOL_LINKAGE_NAME (sym)); 1373 1374 SYMBOL_SET_LINKAGE_NAME (sym, new_name); 1375 SYMBOL_VALUE_ADDRESS (sym) = SYMBOL_VALUE_ADDRESS (msym); 1376 } 1377 } 1378 SYMBOL_DOMAIN (sym) = VAR_DOMAIN; 1379 add_symbol_to_list (sym, &local_symbols); 1380 break; 1381 1382 case 'v': 1383 /* Reference parameter */ 1384 SYMBOL_TYPE (sym) = read_type (&p, objfile); 1385 SYMBOL_CLASS (sym) = LOC_REF_ARG; 1386 SYMBOL_IS_ARGUMENT (sym) = 1; 1387 SYMBOL_VALUE (sym) = valu; 1388 SYMBOL_DOMAIN (sym) = VAR_DOMAIN; 1389 add_symbol_to_list (sym, &local_symbols); 1390 break; 1391 1392 case 'a': 1393 /* Reference parameter which is in a register. */ 1394 SYMBOL_TYPE (sym) = read_type (&p, objfile); 1395 SYMBOL_CLASS (sym) = LOC_REGPARM_ADDR; 1396 SYMBOL_REGISTER_OPS (sym) = &stab_register_funcs; 1397 SYMBOL_IS_ARGUMENT (sym) = 1; 1398 SYMBOL_VALUE (sym) = valu; 1399 SYMBOL_DOMAIN (sym) = VAR_DOMAIN; 1400 add_symbol_to_list (sym, &local_symbols); 1401 break; 1402 1403 case 'X': 1404 /* This is used by Sun FORTRAN for "function result value". 1405 Sun claims ("dbx and dbxtool interfaces", 2nd ed) 1406 that Pascal uses it too, but when I tried it Pascal used 1407 "x:3" (local symbol) instead. */ 1408 SYMBOL_TYPE (sym) = read_type (&p, objfile); 1409 SYMBOL_CLASS (sym) = LOC_LOCAL; 1410 SYMBOL_VALUE (sym) = valu; 1411 SYMBOL_DOMAIN (sym) = VAR_DOMAIN; 1412 add_symbol_to_list (sym, &local_symbols); 1413 break; 1414 1415 default: 1416 SYMBOL_TYPE (sym) = error_type (&p, objfile); 1417 SYMBOL_CLASS (sym) = LOC_CONST; 1418 SYMBOL_VALUE (sym) = 0; 1419 SYMBOL_DOMAIN (sym) = VAR_DOMAIN; 1420 add_symbol_to_list (sym, &file_symbols); 1421 break; 1422 } 1423 1424 /* Some systems pass variables of certain types by reference instead 1425 of by value, i.e. they will pass the address of a structure (in a 1426 register or on the stack) instead of the structure itself. */ 1427 1428 if (gdbarch_stabs_argument_has_addr (gdbarch, SYMBOL_TYPE (sym)) 1429 && SYMBOL_IS_ARGUMENT (sym)) 1430 { 1431 /* We have to convert LOC_REGISTER to LOC_REGPARM_ADDR (for 1432 variables passed in a register). */ 1433 if (SYMBOL_CLASS (sym) == LOC_REGISTER) 1434 SYMBOL_CLASS (sym) = LOC_REGPARM_ADDR; 1435 /* Likewise for converting LOC_ARG to LOC_REF_ARG (for the 7th 1436 and subsequent arguments on SPARC, for example). */ 1437 else if (SYMBOL_CLASS (sym) == LOC_ARG) 1438 SYMBOL_CLASS (sym) = LOC_REF_ARG; 1439 } 1440 1441 return sym; 1442 } 1443 1444 /* Skip rest of this symbol and return an error type. 1445 1446 General notes on error recovery: error_type always skips to the 1447 end of the symbol (modulo cretinous dbx symbol name continuation). 1448 Thus code like this: 1449 1450 if (*(*pp)++ != ';') 1451 return error_type (pp, objfile); 1452 1453 is wrong because if *pp starts out pointing at '\0' (typically as the 1454 result of an earlier error), it will be incremented to point to the 1455 start of the next symbol, which might produce strange results, at least 1456 if you run off the end of the string table. Instead use 1457 1458 if (**pp != ';') 1459 return error_type (pp, objfile); 1460 ++*pp; 1461 1462 or 1463 1464 if (**pp != ';') 1465 foo = error_type (pp, objfile); 1466 else 1467 ++*pp; 1468 1469 And in case it isn't obvious, the point of all this hair is so the compiler 1470 can define new types and new syntaxes, and old versions of the 1471 debugger will be able to read the new symbol tables. */ 1472 1473 static struct type * 1474 error_type (char **pp, struct objfile *objfile) 1475 { 1476 complaint (&symfile_complaints, 1477 _("couldn't parse type; debugger out of date?")); 1478 while (1) 1479 { 1480 /* Skip to end of symbol. */ 1481 while (**pp != '\0') 1482 { 1483 (*pp)++; 1484 } 1485 1486 /* Check for and handle cretinous dbx symbol name continuation! */ 1487 if ((*pp)[-1] == '\\' || (*pp)[-1] == '?') 1488 { 1489 *pp = next_symbol_text (objfile); 1490 } 1491 else 1492 { 1493 break; 1494 } 1495 } 1496 return objfile_type (objfile)->builtin_error; 1497 } 1498 1499 1500 /* Read type information or a type definition; return the type. Even 1501 though this routine accepts either type information or a type 1502 definition, the distinction is relevant--some parts of stabsread.c 1503 assume that type information starts with a digit, '-', or '(' in 1504 deciding whether to call read_type. */ 1505 1506 static struct type * 1507 read_type (char **pp, struct objfile *objfile) 1508 { 1509 struct type *type = 0; 1510 struct type *type1; 1511 int typenums[2]; 1512 char type_descriptor; 1513 1514 /* Size in bits of type if specified by a type attribute, or -1 if 1515 there is no size attribute. */ 1516 int type_size = -1; 1517 1518 /* Used to distinguish string and bitstring from char-array and set. */ 1519 int is_string = 0; 1520 1521 /* Used to distinguish vector from array. */ 1522 int is_vector = 0; 1523 1524 /* Read type number if present. The type number may be omitted. 1525 for instance in a two-dimensional array declared with type 1526 "ar1;1;10;ar1;1;10;4". */ 1527 if ((**pp >= '0' && **pp <= '9') 1528 || **pp == '(' 1529 || **pp == '-') 1530 { 1531 if (read_type_number (pp, typenums) != 0) 1532 return error_type (pp, objfile); 1533 1534 if (**pp != '=') 1535 { 1536 /* Type is not being defined here. Either it already 1537 exists, or this is a forward reference to it. 1538 dbx_alloc_type handles both cases. */ 1539 type = dbx_alloc_type (typenums, objfile); 1540 1541 /* If this is a forward reference, arrange to complain if it 1542 doesn't get patched up by the time we're done 1543 reading. */ 1544 if (TYPE_CODE (type) == TYPE_CODE_UNDEF) 1545 add_undefined_type (type, typenums); 1546 1547 return type; 1548 } 1549 1550 /* Type is being defined here. */ 1551 /* Skip the '='. 1552 Also skip the type descriptor - we get it below with (*pp)[-1]. */ 1553 (*pp) += 2; 1554 } 1555 else 1556 { 1557 /* 'typenums=' not present, type is anonymous. Read and return 1558 the definition, but don't put it in the type vector. */ 1559 typenums[0] = typenums[1] = -1; 1560 (*pp)++; 1561 } 1562 1563 again: 1564 type_descriptor = (*pp)[-1]; 1565 switch (type_descriptor) 1566 { 1567 case 'x': 1568 { 1569 enum type_code code; 1570 1571 /* Used to index through file_symbols. */ 1572 struct pending *ppt; 1573 int i; 1574 1575 /* Name including "struct", etc. */ 1576 char *type_name; 1577 1578 { 1579 char *from, *to, *p, *q1, *q2; 1580 1581 /* Set the type code according to the following letter. */ 1582 switch ((*pp)[0]) 1583 { 1584 case 's': 1585 code = TYPE_CODE_STRUCT; 1586 break; 1587 case 'u': 1588 code = TYPE_CODE_UNION; 1589 break; 1590 case 'e': 1591 code = TYPE_CODE_ENUM; 1592 break; 1593 default: 1594 { 1595 /* Complain and keep going, so compilers can invent new 1596 cross-reference types. */ 1597 complaint (&symfile_complaints, 1598 _("Unrecognized cross-reference type `%c'"), 1599 (*pp)[0]); 1600 code = TYPE_CODE_STRUCT; 1601 break; 1602 } 1603 } 1604 1605 q1 = strchr (*pp, '<'); 1606 p = strchr (*pp, ':'); 1607 if (p == NULL) 1608 return error_type (pp, objfile); 1609 if (q1 && p > q1 && p[1] == ':') 1610 { 1611 int nesting_level = 0; 1612 1613 for (q2 = q1; *q2; q2++) 1614 { 1615 if (*q2 == '<') 1616 nesting_level++; 1617 else if (*q2 == '>') 1618 nesting_level--; 1619 else if (*q2 == ':' && nesting_level == 0) 1620 break; 1621 } 1622 p = q2; 1623 if (*p != ':') 1624 return error_type (pp, objfile); 1625 } 1626 type_name = NULL; 1627 if (current_subfile->language == language_cplus) 1628 { 1629 char *new_name, *name = alloca (p - *pp + 1); 1630 1631 memcpy (name, *pp, p - *pp); 1632 name[p - *pp] = '\0'; 1633 new_name = cp_canonicalize_string (name); 1634 if (new_name != NULL) 1635 { 1636 type_name = obsavestring (new_name, strlen (new_name), 1637 &objfile->objfile_obstack); 1638 xfree (new_name); 1639 } 1640 } 1641 if (type_name == NULL) 1642 { 1643 to = type_name = (char *) 1644 obstack_alloc (&objfile->objfile_obstack, p - *pp + 1); 1645 1646 /* Copy the name. */ 1647 from = *pp + 1; 1648 while (from < p) 1649 *to++ = *from++; 1650 *to = '\0'; 1651 } 1652 1653 /* Set the pointer ahead of the name which we just read, and 1654 the colon. */ 1655 *pp = p + 1; 1656 } 1657 1658 /* If this type has already been declared, then reuse the same 1659 type, rather than allocating a new one. This saves some 1660 memory. */ 1661 1662 for (ppt = file_symbols; ppt; ppt = ppt->next) 1663 for (i = 0; i < ppt->nsyms; i++) 1664 { 1665 struct symbol *sym = ppt->symbol[i]; 1666 1667 if (SYMBOL_CLASS (sym) == LOC_TYPEDEF 1668 && SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN 1669 && (TYPE_CODE (SYMBOL_TYPE (sym)) == code) 1670 && strcmp (SYMBOL_LINKAGE_NAME (sym), type_name) == 0) 1671 { 1672 obstack_free (&objfile->objfile_obstack, type_name); 1673 type = SYMBOL_TYPE (sym); 1674 if (typenums[0] != -1) 1675 *dbx_lookup_type (typenums, objfile) = type; 1676 return type; 1677 } 1678 } 1679 1680 /* Didn't find the type to which this refers, so we must 1681 be dealing with a forward reference. Allocate a type 1682 structure for it, and keep track of it so we can 1683 fill in the rest of the fields when we get the full 1684 type. */ 1685 type = dbx_alloc_type (typenums, objfile); 1686 TYPE_CODE (type) = code; 1687 TYPE_TAG_NAME (type) = type_name; 1688 INIT_CPLUS_SPECIFIC (type); 1689 TYPE_STUB (type) = 1; 1690 1691 add_undefined_type (type, typenums); 1692 return type; 1693 } 1694 1695 case '-': /* RS/6000 built-in type */ 1696 case '0': 1697 case '1': 1698 case '2': 1699 case '3': 1700 case '4': 1701 case '5': 1702 case '6': 1703 case '7': 1704 case '8': 1705 case '9': 1706 case '(': 1707 (*pp)--; 1708 1709 /* We deal with something like t(1,2)=(3,4)=... which 1710 the Lucid compiler and recent gcc versions (post 2.7.3) use. */ 1711 1712 /* Allocate and enter the typedef type first. 1713 This handles recursive types. */ 1714 type = dbx_alloc_type (typenums, objfile); 1715 TYPE_CODE (type) = TYPE_CODE_TYPEDEF; 1716 { 1717 struct type *xtype = read_type (pp, objfile); 1718 1719 if (type == xtype) 1720 { 1721 /* It's being defined as itself. That means it is "void". */ 1722 TYPE_CODE (type) = TYPE_CODE_VOID; 1723 TYPE_LENGTH (type) = 1; 1724 } 1725 else if (type_size >= 0 || is_string) 1726 { 1727 /* This is the absolute wrong way to construct types. Every 1728 other debug format has found a way around this problem and 1729 the related problems with unnecessarily stubbed types; 1730 someone motivated should attempt to clean up the issue 1731 here as well. Once a type pointed to has been created it 1732 should not be modified. 1733 1734 Well, it's not *absolutely* wrong. Constructing recursive 1735 types (trees, linked lists) necessarily entails modifying 1736 types after creating them. Constructing any loop structure 1737 entails side effects. The Dwarf 2 reader does handle this 1738 more gracefully (it never constructs more than once 1739 instance of a type object, so it doesn't have to copy type 1740 objects wholesale), but it still mutates type objects after 1741 other folks have references to them. 1742 1743 Keep in mind that this circularity/mutation issue shows up 1744 at the source language level, too: C's "incomplete types", 1745 for example. So the proper cleanup, I think, would be to 1746 limit GDB's type smashing to match exactly those required 1747 by the source language. So GDB could have a 1748 "complete_this_type" function, but never create unnecessary 1749 copies of a type otherwise. */ 1750 replace_type (type, xtype); 1751 TYPE_NAME (type) = NULL; 1752 TYPE_TAG_NAME (type) = NULL; 1753 } 1754 else 1755 { 1756 TYPE_TARGET_STUB (type) = 1; 1757 TYPE_TARGET_TYPE (type) = xtype; 1758 } 1759 } 1760 break; 1761 1762 /* In the following types, we must be sure to overwrite any existing 1763 type that the typenums refer to, rather than allocating a new one 1764 and making the typenums point to the new one. This is because there 1765 may already be pointers to the existing type (if it had been 1766 forward-referenced), and we must change it to a pointer, function, 1767 reference, or whatever, *in-place*. */ 1768 1769 case '*': /* Pointer to another type */ 1770 type1 = read_type (pp, objfile); 1771 type = make_pointer_type (type1, dbx_lookup_type (typenums, objfile)); 1772 break; 1773 1774 case '&': /* Reference to another type */ 1775 type1 = read_type (pp, objfile); 1776 type = make_reference_type (type1, dbx_lookup_type (typenums, objfile)); 1777 break; 1778 1779 case 'f': /* Function returning another type */ 1780 type1 = read_type (pp, objfile); 1781 type = make_function_type (type1, dbx_lookup_type (typenums, objfile)); 1782 break; 1783 1784 case 'g': /* Prototyped function. (Sun) */ 1785 { 1786 /* Unresolved questions: 1787 1788 - According to Sun's ``STABS Interface Manual'', for 'f' 1789 and 'F' symbol descriptors, a `0' in the argument type list 1790 indicates a varargs function. But it doesn't say how 'g' 1791 type descriptors represent that info. Someone with access 1792 to Sun's toolchain should try it out. 1793 1794 - According to the comment in define_symbol (search for 1795 `process_prototype_types:'), Sun emits integer arguments as 1796 types which ref themselves --- like `void' types. Do we 1797 have to deal with that here, too? Again, someone with 1798 access to Sun's toolchain should try it out and let us 1799 know. */ 1800 1801 const char *type_start = (*pp) - 1; 1802 struct type *return_type = read_type (pp, objfile); 1803 struct type *func_type 1804 = make_function_type (return_type, 1805 dbx_lookup_type (typenums, objfile)); 1806 struct type_list { 1807 struct type *type; 1808 struct type_list *next; 1809 } *arg_types = 0; 1810 int num_args = 0; 1811 1812 while (**pp && **pp != '#') 1813 { 1814 struct type *arg_type = read_type (pp, objfile); 1815 struct type_list *new = alloca (sizeof (*new)); 1816 new->type = arg_type; 1817 new->next = arg_types; 1818 arg_types = new; 1819 num_args++; 1820 } 1821 if (**pp == '#') 1822 ++*pp; 1823 else 1824 { 1825 complaint (&symfile_complaints, 1826 _("Prototyped function type didn't " 1827 "end arguments with `#':\n%s"), 1828 type_start); 1829 } 1830 1831 /* If there is just one argument whose type is `void', then 1832 that's just an empty argument list. */ 1833 if (arg_types 1834 && ! arg_types->next 1835 && TYPE_CODE (arg_types->type) == TYPE_CODE_VOID) 1836 num_args = 0; 1837 1838 TYPE_FIELDS (func_type) 1839 = (struct field *) TYPE_ALLOC (func_type, 1840 num_args * sizeof (struct field)); 1841 memset (TYPE_FIELDS (func_type), 0, num_args * sizeof (struct field)); 1842 { 1843 int i; 1844 struct type_list *t; 1845 1846 /* We stuck each argument type onto the front of the list 1847 when we read it, so the list is reversed. Build the 1848 fields array right-to-left. */ 1849 for (t = arg_types, i = num_args - 1; t; t = t->next, i--) 1850 TYPE_FIELD_TYPE (func_type, i) = t->type; 1851 } 1852 TYPE_NFIELDS (func_type) = num_args; 1853 TYPE_PROTOTYPED (func_type) = 1; 1854 1855 type = func_type; 1856 break; 1857 } 1858 1859 case 'k': /* Const qualifier on some type (Sun) */ 1860 type = read_type (pp, objfile); 1861 type = make_cv_type (1, TYPE_VOLATILE (type), type, 1862 dbx_lookup_type (typenums, objfile)); 1863 break; 1864 1865 case 'B': /* Volatile qual on some type (Sun) */ 1866 type = read_type (pp, objfile); 1867 type = make_cv_type (TYPE_CONST (type), 1, type, 1868 dbx_lookup_type (typenums, objfile)); 1869 break; 1870 1871 case '@': 1872 if (isdigit (**pp) || **pp == '(' || **pp == '-') 1873 { /* Member (class & variable) type */ 1874 /* FIXME -- we should be doing smash_to_XXX types here. */ 1875 1876 struct type *domain = read_type (pp, objfile); 1877 struct type *memtype; 1878 1879 if (**pp != ',') 1880 /* Invalid member type data format. */ 1881 return error_type (pp, objfile); 1882 ++*pp; 1883 1884 memtype = read_type (pp, objfile); 1885 type = dbx_alloc_type (typenums, objfile); 1886 smash_to_memberptr_type (type, domain, memtype); 1887 } 1888 else 1889 /* type attribute */ 1890 { 1891 char *attr = *pp; 1892 1893 /* Skip to the semicolon. */ 1894 while (**pp != ';' && **pp != '\0') 1895 ++(*pp); 1896 if (**pp == '\0') 1897 return error_type (pp, objfile); 1898 else 1899 ++ * pp; /* Skip the semicolon. */ 1900 1901 switch (*attr) 1902 { 1903 case 's': /* Size attribute */ 1904 type_size = atoi (attr + 1); 1905 if (type_size <= 0) 1906 type_size = -1; 1907 break; 1908 1909 case 'S': /* String attribute */ 1910 /* FIXME: check to see if following type is array? */ 1911 is_string = 1; 1912 break; 1913 1914 case 'V': /* Vector attribute */ 1915 /* FIXME: check to see if following type is array? */ 1916 is_vector = 1; 1917 break; 1918 1919 default: 1920 /* Ignore unrecognized type attributes, so future compilers 1921 can invent new ones. */ 1922 break; 1923 } 1924 ++*pp; 1925 goto again; 1926 } 1927 break; 1928 1929 case '#': /* Method (class & fn) type */ 1930 if ((*pp)[0] == '#') 1931 { 1932 /* We'll get the parameter types from the name. */ 1933 struct type *return_type; 1934 1935 (*pp)++; 1936 return_type = read_type (pp, objfile); 1937 if (*(*pp)++ != ';') 1938 complaint (&symfile_complaints, 1939 _("invalid (minimal) member type " 1940 "data format at symtab pos %d."), 1941 symnum); 1942 type = allocate_stub_method (return_type); 1943 if (typenums[0] != -1) 1944 *dbx_lookup_type (typenums, objfile) = type; 1945 } 1946 else 1947 { 1948 struct type *domain = read_type (pp, objfile); 1949 struct type *return_type; 1950 struct field *args; 1951 int nargs, varargs; 1952 1953 if (**pp != ',') 1954 /* Invalid member type data format. */ 1955 return error_type (pp, objfile); 1956 else 1957 ++(*pp); 1958 1959 return_type = read_type (pp, objfile); 1960 args = read_args (pp, ';', objfile, &nargs, &varargs); 1961 if (args == NULL) 1962 return error_type (pp, objfile); 1963 type = dbx_alloc_type (typenums, objfile); 1964 smash_to_method_type (type, domain, return_type, args, 1965 nargs, varargs); 1966 } 1967 break; 1968 1969 case 'r': /* Range type */ 1970 type = read_range_type (pp, typenums, type_size, objfile); 1971 if (typenums[0] != -1) 1972 *dbx_lookup_type (typenums, objfile) = type; 1973 break; 1974 1975 case 'b': 1976 { 1977 /* Sun ACC builtin int type */ 1978 type = read_sun_builtin_type (pp, typenums, objfile); 1979 if (typenums[0] != -1) 1980 *dbx_lookup_type (typenums, objfile) = type; 1981 } 1982 break; 1983 1984 case 'R': /* Sun ACC builtin float type */ 1985 type = read_sun_floating_type (pp, typenums, objfile); 1986 if (typenums[0] != -1) 1987 *dbx_lookup_type (typenums, objfile) = type; 1988 break; 1989 1990 case 'e': /* Enumeration type */ 1991 type = dbx_alloc_type (typenums, objfile); 1992 type = read_enum_type (pp, type, objfile); 1993 if (typenums[0] != -1) 1994 *dbx_lookup_type (typenums, objfile) = type; 1995 break; 1996 1997 case 's': /* Struct type */ 1998 case 'u': /* Union type */ 1999 { 2000 enum type_code type_code = TYPE_CODE_UNDEF; 2001 type = dbx_alloc_type (typenums, objfile); 2002 switch (type_descriptor) 2003 { 2004 case 's': 2005 type_code = TYPE_CODE_STRUCT; 2006 break; 2007 case 'u': 2008 type_code = TYPE_CODE_UNION; 2009 break; 2010 } 2011 type = read_struct_type (pp, type, type_code, objfile); 2012 break; 2013 } 2014 2015 case 'a': /* Array type */ 2016 if (**pp != 'r') 2017 return error_type (pp, objfile); 2018 ++*pp; 2019 2020 type = dbx_alloc_type (typenums, objfile); 2021 type = read_array_type (pp, type, objfile); 2022 if (is_string) 2023 TYPE_CODE (type) = TYPE_CODE_STRING; 2024 if (is_vector) 2025 make_vector_type (type); 2026 break; 2027 2028 case 'S': /* Set or bitstring type */ 2029 type1 = read_type (pp, objfile); 2030 type = create_set_type ((struct type *) NULL, type1); 2031 if (is_string) 2032 TYPE_CODE (type) = TYPE_CODE_BITSTRING; 2033 if (typenums[0] != -1) 2034 *dbx_lookup_type (typenums, objfile) = type; 2035 break; 2036 2037 default: 2038 --*pp; /* Go back to the symbol in error. */ 2039 /* Particularly important if it was \0! */ 2040 return error_type (pp, objfile); 2041 } 2042 2043 if (type == 0) 2044 { 2045 warning (_("GDB internal error, type is NULL in stabsread.c.")); 2046 return error_type (pp, objfile); 2047 } 2048 2049 /* Size specified in a type attribute overrides any other size. */ 2050 if (type_size != -1) 2051 TYPE_LENGTH (type) = (type_size + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT; 2052 2053 return type; 2054 } 2055 2056 /* RS/6000 xlc/dbx combination uses a set of builtin types, starting from -1. 2057 Return the proper type node for a given builtin type number. */ 2058 2059 static const struct objfile_data *rs6000_builtin_type_data; 2060 2061 static struct type * 2062 rs6000_builtin_type (int typenum, struct objfile *objfile) 2063 { 2064 struct type **negative_types = objfile_data (objfile, 2065 rs6000_builtin_type_data); 2066 2067 /* We recognize types numbered from -NUMBER_RECOGNIZED to -1. */ 2068 #define NUMBER_RECOGNIZED 34 2069 struct type *rettype = NULL; 2070 2071 if (typenum >= 0 || typenum < -NUMBER_RECOGNIZED) 2072 { 2073 complaint (&symfile_complaints, _("Unknown builtin type %d"), typenum); 2074 return objfile_type (objfile)->builtin_error; 2075 } 2076 2077 if (!negative_types) 2078 { 2079 /* This includes an empty slot for type number -0. */ 2080 negative_types = OBSTACK_CALLOC (&objfile->objfile_obstack, 2081 NUMBER_RECOGNIZED + 1, struct type *); 2082 set_objfile_data (objfile, rs6000_builtin_type_data, negative_types); 2083 } 2084 2085 if (negative_types[-typenum] != NULL) 2086 return negative_types[-typenum]; 2087 2088 #if TARGET_CHAR_BIT != 8 2089 #error This code wrong for TARGET_CHAR_BIT not 8 2090 /* These definitions all assume that TARGET_CHAR_BIT is 8. I think 2091 that if that ever becomes not true, the correct fix will be to 2092 make the size in the struct type to be in bits, not in units of 2093 TARGET_CHAR_BIT. */ 2094 #endif 2095 2096 switch (-typenum) 2097 { 2098 case 1: 2099 /* The size of this and all the other types are fixed, defined 2100 by the debugging format. If there is a type called "int" which 2101 is other than 32 bits, then it should use a new negative type 2102 number (or avoid negative type numbers for that case). 2103 See stabs.texinfo. */ 2104 rettype = init_type (TYPE_CODE_INT, 4, 0, "int", objfile); 2105 break; 2106 case 2: 2107 rettype = init_type (TYPE_CODE_INT, 1, 0, "char", objfile); 2108 break; 2109 case 3: 2110 rettype = init_type (TYPE_CODE_INT, 2, 0, "short", objfile); 2111 break; 2112 case 4: 2113 rettype = init_type (TYPE_CODE_INT, 4, 0, "long", objfile); 2114 break; 2115 case 5: 2116 rettype = init_type (TYPE_CODE_INT, 1, TYPE_FLAG_UNSIGNED, 2117 "unsigned char", objfile); 2118 break; 2119 case 6: 2120 rettype = init_type (TYPE_CODE_INT, 1, 0, "signed char", objfile); 2121 break; 2122 case 7: 2123 rettype = init_type (TYPE_CODE_INT, 2, TYPE_FLAG_UNSIGNED, 2124 "unsigned short", objfile); 2125 break; 2126 case 8: 2127 rettype = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED, 2128 "unsigned int", objfile); 2129 break; 2130 case 9: 2131 rettype = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED, 2132 "unsigned", objfile); 2133 break; 2134 case 10: 2135 rettype = init_type (TYPE_CODE_INT, 4, TYPE_FLAG_UNSIGNED, 2136 "unsigned long", objfile); 2137 break; 2138 case 11: 2139 rettype = init_type (TYPE_CODE_VOID, 1, 0, "void", objfile); 2140 break; 2141 case 12: 2142 /* IEEE single precision (32 bit). */ 2143 rettype = init_type (TYPE_CODE_FLT, 4, 0, "float", objfile); 2144 break; 2145 case 13: 2146 /* IEEE double precision (64 bit). */ 2147 rettype = init_type (TYPE_CODE_FLT, 8, 0, "double", objfile); 2148 break; 2149 case 14: 2150 /* This is an IEEE double on the RS/6000, and different machines with 2151 different sizes for "long double" should use different negative 2152 type numbers. See stabs.texinfo. */ 2153 rettype = init_type (TYPE_CODE_FLT, 8, 0, "long double", objfile); 2154 break; 2155 case 15: 2156 rettype = init_type (TYPE_CODE_INT, 4, 0, "integer", objfile); 2157 break; 2158 case 16: 2159 rettype = init_type (TYPE_CODE_BOOL, 4, TYPE_FLAG_UNSIGNED, 2160 "boolean", objfile); 2161 break; 2162 case 17: 2163 rettype = init_type (TYPE_CODE_FLT, 4, 0, "short real", objfile); 2164 break; 2165 case 18: 2166 rettype = init_type (TYPE_CODE_FLT, 8, 0, "real", objfile); 2167 break; 2168 case 19: 2169 rettype = init_type (TYPE_CODE_ERROR, 0, 0, "stringptr", objfile); 2170 break; 2171 case 20: 2172 rettype = init_type (TYPE_CODE_CHAR, 1, TYPE_FLAG_UNSIGNED, 2173 "character", objfile); 2174 break; 2175 case 21: 2176 rettype = init_type (TYPE_CODE_BOOL, 1, TYPE_FLAG_UNSIGNED, 2177 "logical*1", objfile); 2178 break; 2179 case 22: 2180 rettype = init_type (TYPE_CODE_BOOL, 2, TYPE_FLAG_UNSIGNED, 2181 "logical*2", objfile); 2182 break; 2183 case 23: 2184 rettype = init_type (TYPE_CODE_BOOL, 4, TYPE_FLAG_UNSIGNED, 2185 "logical*4", objfile); 2186 break; 2187 case 24: 2188 rettype = init_type (TYPE_CODE_BOOL, 4, TYPE_FLAG_UNSIGNED, 2189 "logical", objfile); 2190 break; 2191 case 25: 2192 /* Complex type consisting of two IEEE single precision values. */ 2193 rettype = init_type (TYPE_CODE_COMPLEX, 8, 0, "complex", objfile); 2194 TYPE_TARGET_TYPE (rettype) = init_type (TYPE_CODE_FLT, 4, 0, "float", 2195 objfile); 2196 break; 2197 case 26: 2198 /* Complex type consisting of two IEEE double precision values. */ 2199 rettype = init_type (TYPE_CODE_COMPLEX, 16, 0, "double complex", NULL); 2200 TYPE_TARGET_TYPE (rettype) = init_type (TYPE_CODE_FLT, 8, 0, "double", 2201 objfile); 2202 break; 2203 case 27: 2204 rettype = init_type (TYPE_CODE_INT, 1, 0, "integer*1", objfile); 2205 break; 2206 case 28: 2207 rettype = init_type (TYPE_CODE_INT, 2, 0, "integer*2", objfile); 2208 break; 2209 case 29: 2210 rettype = init_type (TYPE_CODE_INT, 4, 0, "integer*4", objfile); 2211 break; 2212 case 30: 2213 rettype = init_type (TYPE_CODE_CHAR, 2, 0, "wchar", objfile); 2214 break; 2215 case 31: 2216 rettype = init_type (TYPE_CODE_INT, 8, 0, "long long", objfile); 2217 break; 2218 case 32: 2219 rettype = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED, 2220 "unsigned long long", objfile); 2221 break; 2222 case 33: 2223 rettype = init_type (TYPE_CODE_INT, 8, TYPE_FLAG_UNSIGNED, 2224 "logical*8", objfile); 2225 break; 2226 case 34: 2227 rettype = init_type (TYPE_CODE_INT, 8, 0, "integer*8", objfile); 2228 break; 2229 } 2230 negative_types[-typenum] = rettype; 2231 return rettype; 2232 } 2233 2234 /* This page contains subroutines of read_type. */ 2235 2236 /* Replace *OLD_NAME with the method name portion of PHYSNAME. */ 2237 2238 static void 2239 update_method_name_from_physname (char **old_name, char *physname) 2240 { 2241 char *method_name; 2242 2243 method_name = method_name_from_physname (physname); 2244 2245 if (method_name == NULL) 2246 { 2247 complaint (&symfile_complaints, 2248 _("Method has bad physname %s\n"), physname); 2249 return; 2250 } 2251 2252 if (strcmp (*old_name, method_name) != 0) 2253 { 2254 xfree (*old_name); 2255 *old_name = method_name; 2256 } 2257 else 2258 xfree (method_name); 2259 } 2260 2261 /* Read member function stabs info for C++ classes. The form of each member 2262 function data is: 2263 2264 NAME :: TYPENUM[=type definition] ARGS : PHYSNAME ; 2265 2266 An example with two member functions is: 2267 2268 afunc1::20=##15;:i;2A.;afunc2::20:i;2A.; 2269 2270 For the case of overloaded operators, the format is op$::*.funcs, where 2271 $ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator 2272 name (such as `+=') and `.' marks the end of the operator name. 2273 2274 Returns 1 for success, 0 for failure. */ 2275 2276 static int 2277 read_member_functions (struct field_info *fip, char **pp, struct type *type, 2278 struct objfile *objfile) 2279 { 2280 int nfn_fields = 0; 2281 int length = 0; 2282 /* Total number of member functions defined in this class. If the class 2283 defines two `f' functions, and one `g' function, then this will have 2284 the value 3. */ 2285 int total_length = 0; 2286 int i; 2287 struct next_fnfield 2288 { 2289 struct next_fnfield *next; 2290 struct fn_field fn_field; 2291 } 2292 *sublist; 2293 struct type *look_ahead_type; 2294 struct next_fnfieldlist *new_fnlist; 2295 struct next_fnfield *new_sublist; 2296 char *main_fn_name; 2297 char *p; 2298 2299 /* Process each list until we find something that is not a member function 2300 or find the end of the functions. */ 2301 2302 while (**pp != ';') 2303 { 2304 /* We should be positioned at the start of the function name. 2305 Scan forward to find the first ':' and if it is not the 2306 first of a "::" delimiter, then this is not a member function. */ 2307 p = *pp; 2308 while (*p != ':') 2309 { 2310 p++; 2311 } 2312 if (p[1] != ':') 2313 { 2314 break; 2315 } 2316 2317 sublist = NULL; 2318 look_ahead_type = NULL; 2319 length = 0; 2320 2321 new_fnlist = (struct next_fnfieldlist *) 2322 xmalloc (sizeof (struct next_fnfieldlist)); 2323 make_cleanup (xfree, new_fnlist); 2324 memset (new_fnlist, 0, sizeof (struct next_fnfieldlist)); 2325 2326 if ((*pp)[0] == 'o' && (*pp)[1] == 'p' && is_cplus_marker ((*pp)[2])) 2327 { 2328 /* This is a completely wierd case. In order to stuff in the 2329 names that might contain colons (the usual name delimiter), 2330 Mike Tiemann defined a different name format which is 2331 signalled if the identifier is "op$". In that case, the 2332 format is "op$::XXXX." where XXXX is the name. This is 2333 used for names like "+" or "=". YUUUUUUUK! FIXME! */ 2334 /* This lets the user type "break operator+". 2335 We could just put in "+" as the name, but that wouldn't 2336 work for "*". */ 2337 static char opname[32] = "op$"; 2338 char *o = opname + 3; 2339 2340 /* Skip past '::'. */ 2341 *pp = p + 2; 2342 2343 STABS_CONTINUE (pp, objfile); 2344 p = *pp; 2345 while (*p != '.') 2346 { 2347 *o++ = *p++; 2348 } 2349 main_fn_name = savestring (opname, o - opname); 2350 /* Skip past '.' */ 2351 *pp = p + 1; 2352 } 2353 else 2354 { 2355 main_fn_name = savestring (*pp, p - *pp); 2356 /* Skip past '::'. */ 2357 *pp = p + 2; 2358 } 2359 new_fnlist->fn_fieldlist.name = main_fn_name; 2360 2361 do 2362 { 2363 new_sublist = 2364 (struct next_fnfield *) xmalloc (sizeof (struct next_fnfield)); 2365 make_cleanup (xfree, new_sublist); 2366 memset (new_sublist, 0, sizeof (struct next_fnfield)); 2367 2368 /* Check for and handle cretinous dbx symbol name continuation! */ 2369 if (look_ahead_type == NULL) 2370 { 2371 /* Normal case. */ 2372 STABS_CONTINUE (pp, objfile); 2373 2374 new_sublist->fn_field.type = read_type (pp, objfile); 2375 if (**pp != ':') 2376 { 2377 /* Invalid symtab info for member function. */ 2378 return 0; 2379 } 2380 } 2381 else 2382 { 2383 /* g++ version 1 kludge */ 2384 new_sublist->fn_field.type = look_ahead_type; 2385 look_ahead_type = NULL; 2386 } 2387 2388 (*pp)++; 2389 p = *pp; 2390 while (*p != ';') 2391 { 2392 p++; 2393 } 2394 2395 /* If this is just a stub, then we don't have the real name here. */ 2396 2397 if (TYPE_STUB (new_sublist->fn_field.type)) 2398 { 2399 if (!TYPE_DOMAIN_TYPE (new_sublist->fn_field.type)) 2400 TYPE_DOMAIN_TYPE (new_sublist->fn_field.type) = type; 2401 new_sublist->fn_field.is_stub = 1; 2402 } 2403 new_sublist->fn_field.physname = savestring (*pp, p - *pp); 2404 *pp = p + 1; 2405 2406 /* Set this member function's visibility fields. */ 2407 switch (*(*pp)++) 2408 { 2409 case VISIBILITY_PRIVATE: 2410 new_sublist->fn_field.is_private = 1; 2411 break; 2412 case VISIBILITY_PROTECTED: 2413 new_sublist->fn_field.is_protected = 1; 2414 break; 2415 } 2416 2417 STABS_CONTINUE (pp, objfile); 2418 switch (**pp) 2419 { 2420 case 'A': /* Normal functions. */ 2421 new_sublist->fn_field.is_const = 0; 2422 new_sublist->fn_field.is_volatile = 0; 2423 (*pp)++; 2424 break; 2425 case 'B': /* `const' member functions. */ 2426 new_sublist->fn_field.is_const = 1; 2427 new_sublist->fn_field.is_volatile = 0; 2428 (*pp)++; 2429 break; 2430 case 'C': /* `volatile' member function. */ 2431 new_sublist->fn_field.is_const = 0; 2432 new_sublist->fn_field.is_volatile = 1; 2433 (*pp)++; 2434 break; 2435 case 'D': /* `const volatile' member function. */ 2436 new_sublist->fn_field.is_const = 1; 2437 new_sublist->fn_field.is_volatile = 1; 2438 (*pp)++; 2439 break; 2440 case '*': /* File compiled with g++ version 1 -- 2441 no info. */ 2442 case '?': 2443 case '.': 2444 break; 2445 default: 2446 complaint (&symfile_complaints, 2447 _("const/volatile indicator missing, got '%c'"), 2448 **pp); 2449 break; 2450 } 2451 2452 switch (*(*pp)++) 2453 { 2454 case '*': 2455 { 2456 int nbits; 2457 /* virtual member function, followed by index. 2458 The sign bit is set to distinguish pointers-to-methods 2459 from virtual function indicies. Since the array is 2460 in words, the quantity must be shifted left by 1 2461 on 16 bit machine, and by 2 on 32 bit machine, forcing 2462 the sign bit out, and usable as a valid index into 2463 the array. Remove the sign bit here. */ 2464 new_sublist->fn_field.voffset = 2465 (0x7fffffff & read_huge_number (pp, ';', &nbits, 0)) + 2; 2466 if (nbits != 0) 2467 return 0; 2468 2469 STABS_CONTINUE (pp, objfile); 2470 if (**pp == ';' || **pp == '\0') 2471 { 2472 /* Must be g++ version 1. */ 2473 new_sublist->fn_field.fcontext = 0; 2474 } 2475 else 2476 { 2477 /* Figure out from whence this virtual function came. 2478 It may belong to virtual function table of 2479 one of its baseclasses. */ 2480 look_ahead_type = read_type (pp, objfile); 2481 if (**pp == ':') 2482 { 2483 /* g++ version 1 overloaded methods. */ 2484 } 2485 else 2486 { 2487 new_sublist->fn_field.fcontext = look_ahead_type; 2488 if (**pp != ';') 2489 { 2490 return 0; 2491 } 2492 else 2493 { 2494 ++*pp; 2495 } 2496 look_ahead_type = NULL; 2497 } 2498 } 2499 break; 2500 } 2501 case '?': 2502 /* static member function. */ 2503 { 2504 int slen = strlen (main_fn_name); 2505 2506 new_sublist->fn_field.voffset = VOFFSET_STATIC; 2507 2508 /* For static member functions, we can't tell if they 2509 are stubbed, as they are put out as functions, and not as 2510 methods. 2511 GCC v2 emits the fully mangled name if 2512 dbxout.c:flag_minimal_debug is not set, so we have to 2513 detect a fully mangled physname here and set is_stub 2514 accordingly. Fully mangled physnames in v2 start with 2515 the member function name, followed by two underscores. 2516 GCC v3 currently always emits stubbed member functions, 2517 but with fully mangled physnames, which start with _Z. */ 2518 if (!(strncmp (new_sublist->fn_field.physname, 2519 main_fn_name, slen) == 0 2520 && new_sublist->fn_field.physname[slen] == '_' 2521 && new_sublist->fn_field.physname[slen + 1] == '_')) 2522 { 2523 new_sublist->fn_field.is_stub = 1; 2524 } 2525 break; 2526 } 2527 2528 default: 2529 /* error */ 2530 complaint (&symfile_complaints, 2531 _("member function type missing, got '%c'"), 2532 (*pp)[-1]); 2533 /* Fall through into normal member function. */ 2534 2535 case '.': 2536 /* normal member function. */ 2537 new_sublist->fn_field.voffset = 0; 2538 new_sublist->fn_field.fcontext = 0; 2539 break; 2540 } 2541 2542 new_sublist->next = sublist; 2543 sublist = new_sublist; 2544 length++; 2545 STABS_CONTINUE (pp, objfile); 2546 } 2547 while (**pp != ';' && **pp != '\0'); 2548 2549 (*pp)++; 2550 STABS_CONTINUE (pp, objfile); 2551 2552 /* Skip GCC 3.X member functions which are duplicates of the callable 2553 constructor/destructor. */ 2554 if (strcmp_iw (main_fn_name, "__base_ctor ") == 0 2555 || strcmp_iw (main_fn_name, "__base_dtor ") == 0 2556 || strcmp (main_fn_name, "__deleting_dtor") == 0) 2557 { 2558 xfree (main_fn_name); 2559 } 2560 else 2561 { 2562 int has_stub = 0; 2563 int has_destructor = 0, has_other = 0; 2564 int is_v3 = 0; 2565 struct next_fnfield *tmp_sublist; 2566 2567 /* Various versions of GCC emit various mostly-useless 2568 strings in the name field for special member functions. 2569 2570 For stub methods, we need to defer correcting the name 2571 until we are ready to unstub the method, because the current 2572 name string is used by gdb_mangle_name. The only stub methods 2573 of concern here are GNU v2 operators; other methods have their 2574 names correct (see caveat below). 2575 2576 For non-stub methods, in GNU v3, we have a complete physname. 2577 Therefore we can safely correct the name now. This primarily 2578 affects constructors and destructors, whose name will be 2579 __comp_ctor or __comp_dtor instead of Foo or ~Foo. Cast 2580 operators will also have incorrect names; for instance, 2581 "operator int" will be named "operator i" (i.e. the type is 2582 mangled). 2583 2584 For non-stub methods in GNU v2, we have no easy way to 2585 know if we have a complete physname or not. For most 2586 methods the result depends on the platform (if CPLUS_MARKER 2587 can be `$' or `.', it will use minimal debug information, or 2588 otherwise the full physname will be included). 2589 2590 Rather than dealing with this, we take a different approach. 2591 For v3 mangled names, we can use the full physname; for v2, 2592 we use cplus_demangle_opname (which is actually v2 specific), 2593 because the only interesting names are all operators - once again 2594 barring the caveat below. Skip this process if any method in the 2595 group is a stub, to prevent our fouling up the workings of 2596 gdb_mangle_name. 2597 2598 The caveat: GCC 2.95.x (and earlier?) put constructors and 2599 destructors in the same method group. We need to split this 2600 into two groups, because they should have different names. 2601 So for each method group we check whether it contains both 2602 routines whose physname appears to be a destructor (the physnames 2603 for and destructors are always provided, due to quirks in v2 2604 mangling) and routines whose physname does not appear to be a 2605 destructor. If so then we break up the list into two halves. 2606 Even if the constructors and destructors aren't in the same group 2607 the destructor will still lack the leading tilde, so that also 2608 needs to be fixed. 2609 2610 So, to summarize what we expect and handle here: 2611 2612 Given Given Real Real Action 2613 method name physname physname method name 2614 2615 __opi [none] __opi__3Foo operator int opname 2616 [now or later] 2617 Foo _._3Foo _._3Foo ~Foo separate and 2618 rename 2619 operator i _ZN3FoocviEv _ZN3FoocviEv operator int demangle 2620 __comp_ctor _ZN3FooC1ERKS_ _ZN3FooC1ERKS_ Foo demangle 2621 */ 2622 2623 tmp_sublist = sublist; 2624 while (tmp_sublist != NULL) 2625 { 2626 if (tmp_sublist->fn_field.is_stub) 2627 has_stub = 1; 2628 if (tmp_sublist->fn_field.physname[0] == '_' 2629 && tmp_sublist->fn_field.physname[1] == 'Z') 2630 is_v3 = 1; 2631 2632 if (is_destructor_name (tmp_sublist->fn_field.physname)) 2633 has_destructor++; 2634 else 2635 has_other++; 2636 2637 tmp_sublist = tmp_sublist->next; 2638 } 2639 2640 if (has_destructor && has_other) 2641 { 2642 struct next_fnfieldlist *destr_fnlist; 2643 struct next_fnfield *last_sublist; 2644 2645 /* Create a new fn_fieldlist for the destructors. */ 2646 2647 destr_fnlist = (struct next_fnfieldlist *) 2648 xmalloc (sizeof (struct next_fnfieldlist)); 2649 make_cleanup (xfree, destr_fnlist); 2650 memset (destr_fnlist, 0, sizeof (struct next_fnfieldlist)); 2651 destr_fnlist->fn_fieldlist.name 2652 = obconcat (&objfile->objfile_obstack, "~", 2653 new_fnlist->fn_fieldlist.name, (char *) NULL); 2654 2655 destr_fnlist->fn_fieldlist.fn_fields = (struct fn_field *) 2656 obstack_alloc (&objfile->objfile_obstack, 2657 sizeof (struct fn_field) * has_destructor); 2658 memset (destr_fnlist->fn_fieldlist.fn_fields, 0, 2659 sizeof (struct fn_field) * has_destructor); 2660 tmp_sublist = sublist; 2661 last_sublist = NULL; 2662 i = 0; 2663 while (tmp_sublist != NULL) 2664 { 2665 if (!is_destructor_name (tmp_sublist->fn_field.physname)) 2666 { 2667 tmp_sublist = tmp_sublist->next; 2668 continue; 2669 } 2670 2671 destr_fnlist->fn_fieldlist.fn_fields[i++] 2672 = tmp_sublist->fn_field; 2673 if (last_sublist) 2674 last_sublist->next = tmp_sublist->next; 2675 else 2676 sublist = tmp_sublist->next; 2677 last_sublist = tmp_sublist; 2678 tmp_sublist = tmp_sublist->next; 2679 } 2680 2681 destr_fnlist->fn_fieldlist.length = has_destructor; 2682 destr_fnlist->next = fip->fnlist; 2683 fip->fnlist = destr_fnlist; 2684 nfn_fields++; 2685 total_length += has_destructor; 2686 length -= has_destructor; 2687 } 2688 else if (is_v3) 2689 { 2690 /* v3 mangling prevents the use of abbreviated physnames, 2691 so we can do this here. There are stubbed methods in v3 2692 only: 2693 - in -gstabs instead of -gstabs+ 2694 - or for static methods, which are output as a function type 2695 instead of a method type. */ 2696 2697 update_method_name_from_physname (&new_fnlist->fn_fieldlist.name, 2698 sublist->fn_field.physname); 2699 } 2700 else if (has_destructor && new_fnlist->fn_fieldlist.name[0] != '~') 2701 { 2702 new_fnlist->fn_fieldlist.name = 2703 concat ("~", main_fn_name, (char *)NULL); 2704 xfree (main_fn_name); 2705 } 2706 else if (!has_stub) 2707 { 2708 char dem_opname[256]; 2709 int ret; 2710 2711 ret = cplus_demangle_opname (new_fnlist->fn_fieldlist.name, 2712 dem_opname, DMGL_ANSI); 2713 if (!ret) 2714 ret = cplus_demangle_opname (new_fnlist->fn_fieldlist.name, 2715 dem_opname, 0); 2716 if (ret) 2717 new_fnlist->fn_fieldlist.name 2718 = obsavestring (dem_opname, strlen (dem_opname), 2719 &objfile->objfile_obstack); 2720 } 2721 2722 new_fnlist->fn_fieldlist.fn_fields = (struct fn_field *) 2723 obstack_alloc (&objfile->objfile_obstack, 2724 sizeof (struct fn_field) * length); 2725 memset (new_fnlist->fn_fieldlist.fn_fields, 0, 2726 sizeof (struct fn_field) * length); 2727 for (i = length; (i--, sublist); sublist = sublist->next) 2728 { 2729 new_fnlist->fn_fieldlist.fn_fields[i] = sublist->fn_field; 2730 } 2731 2732 new_fnlist->fn_fieldlist.length = length; 2733 new_fnlist->next = fip->fnlist; 2734 fip->fnlist = new_fnlist; 2735 nfn_fields++; 2736 total_length += length; 2737 } 2738 } 2739 2740 if (nfn_fields) 2741 { 2742 ALLOCATE_CPLUS_STRUCT_TYPE (type); 2743 TYPE_FN_FIELDLISTS (type) = (struct fn_fieldlist *) 2744 TYPE_ALLOC (type, sizeof (struct fn_fieldlist) * nfn_fields); 2745 memset (TYPE_FN_FIELDLISTS (type), 0, 2746 sizeof (struct fn_fieldlist) * nfn_fields); 2747 TYPE_NFN_FIELDS (type) = nfn_fields; 2748 TYPE_NFN_FIELDS_TOTAL (type) = total_length; 2749 } 2750 2751 return 1; 2752 } 2753 2754 /* Special GNU C++ name. 2755 2756 Returns 1 for success, 0 for failure. "failure" means that we can't 2757 keep parsing and it's time for error_type(). */ 2758 2759 static int 2760 read_cpp_abbrev (struct field_info *fip, char **pp, struct type *type, 2761 struct objfile *objfile) 2762 { 2763 char *p; 2764 char *name; 2765 char cpp_abbrev; 2766 struct type *context; 2767 2768 p = *pp; 2769 if (*++p == 'v') 2770 { 2771 name = NULL; 2772 cpp_abbrev = *++p; 2773 2774 *pp = p + 1; 2775 2776 /* At this point, *pp points to something like "22:23=*22...", 2777 where the type number before the ':' is the "context" and 2778 everything after is a regular type definition. Lookup the 2779 type, find it's name, and construct the field name. */ 2780 2781 context = read_type (pp, objfile); 2782 2783 switch (cpp_abbrev) 2784 { 2785 case 'f': /* $vf -- a virtual function table pointer */ 2786 name = type_name_no_tag (context); 2787 if (name == NULL) 2788 { 2789 name = ""; 2790 } 2791 fip->list->field.name = obconcat (&objfile->objfile_obstack, 2792 vptr_name, name, (char *) NULL); 2793 break; 2794 2795 case 'b': /* $vb -- a virtual bsomethingorother */ 2796 name = type_name_no_tag (context); 2797 if (name == NULL) 2798 { 2799 complaint (&symfile_complaints, 2800 _("C++ abbreviated type name " 2801 "unknown at symtab pos %d"), 2802 symnum); 2803 name = "FOO"; 2804 } 2805 fip->list->field.name = obconcat (&objfile->objfile_obstack, vb_name, 2806 name, (char *) NULL); 2807 break; 2808 2809 default: 2810 invalid_cpp_abbrev_complaint (*pp); 2811 fip->list->field.name = obconcat (&objfile->objfile_obstack, 2812 "INVALID_CPLUSPLUS_ABBREV", 2813 (char *) NULL); 2814 break; 2815 } 2816 2817 /* At this point, *pp points to the ':'. Skip it and read the 2818 field type. */ 2819 2820 p = ++(*pp); 2821 if (p[-1] != ':') 2822 { 2823 invalid_cpp_abbrev_complaint (*pp); 2824 return 0; 2825 } 2826 fip->list->field.type = read_type (pp, objfile); 2827 if (**pp == ',') 2828 (*pp)++; /* Skip the comma. */ 2829 else 2830 return 0; 2831 2832 { 2833 int nbits; 2834 2835 FIELD_BITPOS (fip->list->field) = read_huge_number (pp, ';', &nbits, 2836 0); 2837 if (nbits != 0) 2838 return 0; 2839 } 2840 /* This field is unpacked. */ 2841 FIELD_BITSIZE (fip->list->field) = 0; 2842 fip->list->visibility = VISIBILITY_PRIVATE; 2843 } 2844 else 2845 { 2846 invalid_cpp_abbrev_complaint (*pp); 2847 /* We have no idea what syntax an unrecognized abbrev would have, so 2848 better return 0. If we returned 1, we would need to at least advance 2849 *pp to avoid an infinite loop. */ 2850 return 0; 2851 } 2852 return 1; 2853 } 2854 2855 static void 2856 read_one_struct_field (struct field_info *fip, char **pp, char *p, 2857 struct type *type, struct objfile *objfile) 2858 { 2859 struct gdbarch *gdbarch = get_objfile_arch (objfile); 2860 2861 fip->list->field.name = 2862 obsavestring (*pp, p - *pp, &objfile->objfile_obstack); 2863 *pp = p + 1; 2864 2865 /* This means we have a visibility for a field coming. */ 2866 if (**pp == '/') 2867 { 2868 (*pp)++; 2869 fip->list->visibility = *(*pp)++; 2870 } 2871 else 2872 { 2873 /* normal dbx-style format, no explicit visibility */ 2874 fip->list->visibility = VISIBILITY_PUBLIC; 2875 } 2876 2877 fip->list->field.type = read_type (pp, objfile); 2878 if (**pp == ':') 2879 { 2880 p = ++(*pp); 2881 #if 0 2882 /* Possible future hook for nested types. */ 2883 if (**pp == '!') 2884 { 2885 fip->list->field.bitpos = (long) -2; /* nested type */ 2886 p = ++(*pp); 2887 } 2888 else 2889 ...; 2890 #endif 2891 while (*p != ';') 2892 { 2893 p++; 2894 } 2895 /* Static class member. */ 2896 SET_FIELD_PHYSNAME (fip->list->field, savestring (*pp, p - *pp)); 2897 *pp = p + 1; 2898 return; 2899 } 2900 else if (**pp != ',') 2901 { 2902 /* Bad structure-type format. */ 2903 stabs_general_complaint ("bad structure-type format"); 2904 return; 2905 } 2906 2907 (*pp)++; /* Skip the comma. */ 2908 2909 { 2910 int nbits; 2911 2912 FIELD_BITPOS (fip->list->field) = read_huge_number (pp, ',', &nbits, 0); 2913 if (nbits != 0) 2914 { 2915 stabs_general_complaint ("bad structure-type format"); 2916 return; 2917 } 2918 FIELD_BITSIZE (fip->list->field) = read_huge_number (pp, ';', &nbits, 0); 2919 if (nbits != 0) 2920 { 2921 stabs_general_complaint ("bad structure-type format"); 2922 return; 2923 } 2924 } 2925 2926 if (FIELD_BITPOS (fip->list->field) == 0 2927 && FIELD_BITSIZE (fip->list->field) == 0) 2928 { 2929 /* This can happen in two cases: (1) at least for gcc 2.4.5 or so, 2930 it is a field which has been optimized out. The correct stab for 2931 this case is to use VISIBILITY_IGNORE, but that is a recent 2932 invention. (2) It is a 0-size array. For example 2933 union { int num; char str[0]; } foo. Printing _("<no value>" for 2934 str in "p foo" is OK, since foo.str (and thus foo.str[3]) 2935 will continue to work, and a 0-size array as a whole doesn't 2936 have any contents to print. 2937 2938 I suspect this probably could also happen with gcc -gstabs (not 2939 -gstabs+) for static fields, and perhaps other C++ extensions. 2940 Hopefully few people use -gstabs with gdb, since it is intended 2941 for dbx compatibility. */ 2942 2943 /* Ignore this field. */ 2944 fip->list->visibility = VISIBILITY_IGNORE; 2945 } 2946 else 2947 { 2948 /* Detect an unpacked field and mark it as such. 2949 dbx gives a bit size for all fields. 2950 Note that forward refs cannot be packed, 2951 and treat enums as if they had the width of ints. */ 2952 2953 struct type *field_type = check_typedef (FIELD_TYPE (fip->list->field)); 2954 2955 if (TYPE_CODE (field_type) != TYPE_CODE_INT 2956 && TYPE_CODE (field_type) != TYPE_CODE_RANGE 2957 && TYPE_CODE (field_type) != TYPE_CODE_BOOL 2958 && TYPE_CODE (field_type) != TYPE_CODE_ENUM) 2959 { 2960 FIELD_BITSIZE (fip->list->field) = 0; 2961 } 2962 if ((FIELD_BITSIZE (fip->list->field) 2963 == TARGET_CHAR_BIT * TYPE_LENGTH (field_type) 2964 || (TYPE_CODE (field_type) == TYPE_CODE_ENUM 2965 && FIELD_BITSIZE (fip->list->field) 2966 == gdbarch_int_bit (gdbarch)) 2967 ) 2968 && 2969 FIELD_BITPOS (fip->list->field) % 8 == 0) 2970 { 2971 FIELD_BITSIZE (fip->list->field) = 0; 2972 } 2973 } 2974 } 2975 2976 2977 /* Read struct or class data fields. They have the form: 2978 2979 NAME : [VISIBILITY] TYPENUM , BITPOS , BITSIZE ; 2980 2981 At the end, we see a semicolon instead of a field. 2982 2983 In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for 2984 a static field. 2985 2986 The optional VISIBILITY is one of: 2987 2988 '/0' (VISIBILITY_PRIVATE) 2989 '/1' (VISIBILITY_PROTECTED) 2990 '/2' (VISIBILITY_PUBLIC) 2991 '/9' (VISIBILITY_IGNORE) 2992 2993 or nothing, for C style fields with public visibility. 2994 2995 Returns 1 for success, 0 for failure. */ 2996 2997 static int 2998 read_struct_fields (struct field_info *fip, char **pp, struct type *type, 2999 struct objfile *objfile) 3000 { 3001 char *p; 3002 struct nextfield *new; 3003 3004 /* We better set p right now, in case there are no fields at all... */ 3005 3006 p = *pp; 3007 3008 /* Read each data member type until we find the terminating ';' at the end of 3009 the data member list, or break for some other reason such as finding the 3010 start of the member function list. */ 3011 /* Stab string for structure/union does not end with two ';' in 3012 SUN C compiler 5.3 i.e. F6U2, hence check for end of string. */ 3013 3014 while (**pp != ';' && **pp != '\0') 3015 { 3016 STABS_CONTINUE (pp, objfile); 3017 /* Get space to record the next field's data. */ 3018 new = (struct nextfield *) xmalloc (sizeof (struct nextfield)); 3019 make_cleanup (xfree, new); 3020 memset (new, 0, sizeof (struct nextfield)); 3021 new->next = fip->list; 3022 fip->list = new; 3023 3024 /* Get the field name. */ 3025 p = *pp; 3026 3027 /* If is starts with CPLUS_MARKER it is a special abbreviation, 3028 unless the CPLUS_MARKER is followed by an underscore, in 3029 which case it is just the name of an anonymous type, which we 3030 should handle like any other type name. */ 3031 3032 if (is_cplus_marker (p[0]) && p[1] != '_') 3033 { 3034 if (!read_cpp_abbrev (fip, pp, type, objfile)) 3035 return 0; 3036 continue; 3037 } 3038 3039 /* Look for the ':' that separates the field name from the field 3040 values. Data members are delimited by a single ':', while member 3041 functions are delimited by a pair of ':'s. When we hit the member 3042 functions (if any), terminate scan loop and return. */ 3043 3044 while (*p != ':' && *p != '\0') 3045 { 3046 p++; 3047 } 3048 if (*p == '\0') 3049 return 0; 3050 3051 /* Check to see if we have hit the member functions yet. */ 3052 if (p[1] == ':') 3053 { 3054 break; 3055 } 3056 read_one_struct_field (fip, pp, p, type, objfile); 3057 } 3058 if (p[0] == ':' && p[1] == ':') 3059 { 3060 /* (the deleted) chill the list of fields: the last entry (at 3061 the head) is a partially constructed entry which we now 3062 scrub. */ 3063 fip->list = fip->list->next; 3064 } 3065 return 1; 3066 } 3067 /* *INDENT-OFF* */ 3068 /* The stabs for C++ derived classes contain baseclass information which 3069 is marked by a '!' character after the total size. This function is 3070 called when we encounter the baseclass marker, and slurps up all the 3071 baseclass information. 3072 3073 Immediately following the '!' marker is the number of base classes that 3074 the class is derived from, followed by information for each base class. 3075 For each base class, there are two visibility specifiers, a bit offset 3076 to the base class information within the derived class, a reference to 3077 the type for the base class, and a terminating semicolon. 3078 3079 A typical example, with two base classes, would be "!2,020,19;0264,21;". 3080 ^^ ^ ^ ^ ^ ^ ^ 3081 Baseclass information marker __________________|| | | | | | | 3082 Number of baseclasses __________________________| | | | | | | 3083 Visibility specifiers (2) ________________________| | | | | | 3084 Offset in bits from start of class _________________| | | | | 3085 Type number for base class ___________________________| | | | 3086 Visibility specifiers (2) _______________________________| | | 3087 Offset in bits from start of class ________________________| | 3088 Type number of base class ____________________________________| 3089 3090 Return 1 for success, 0 for (error-type-inducing) failure. */ 3091 /* *INDENT-ON* */ 3092 3093 3094 3095 static int 3096 read_baseclasses (struct field_info *fip, char **pp, struct type *type, 3097 struct objfile *objfile) 3098 { 3099 int i; 3100 struct nextfield *new; 3101 3102 if (**pp != '!') 3103 { 3104 return 1; 3105 } 3106 else 3107 { 3108 /* Skip the '!' baseclass information marker. */ 3109 (*pp)++; 3110 } 3111 3112 ALLOCATE_CPLUS_STRUCT_TYPE (type); 3113 { 3114 int nbits; 3115 3116 TYPE_N_BASECLASSES (type) = read_huge_number (pp, ',', &nbits, 0); 3117 if (nbits != 0) 3118 return 0; 3119 } 3120 3121 #if 0 3122 /* Some stupid compilers have trouble with the following, so break 3123 it up into simpler expressions. */ 3124 TYPE_FIELD_VIRTUAL_BITS (type) = (B_TYPE *) 3125 TYPE_ALLOC (type, B_BYTES (TYPE_N_BASECLASSES (type))); 3126 #else 3127 { 3128 int num_bytes = B_BYTES (TYPE_N_BASECLASSES (type)); 3129 char *pointer; 3130 3131 pointer = (char *) TYPE_ALLOC (type, num_bytes); 3132 TYPE_FIELD_VIRTUAL_BITS (type) = (B_TYPE *) pointer; 3133 } 3134 #endif /* 0 */ 3135 3136 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type), TYPE_N_BASECLASSES (type)); 3137 3138 for (i = 0; i < TYPE_N_BASECLASSES (type); i++) 3139 { 3140 new = (struct nextfield *) xmalloc (sizeof (struct nextfield)); 3141 make_cleanup (xfree, new); 3142 memset (new, 0, sizeof (struct nextfield)); 3143 new->next = fip->list; 3144 fip->list = new; 3145 FIELD_BITSIZE (new->field) = 0; /* This should be an unpacked 3146 field! */ 3147 3148 STABS_CONTINUE (pp, objfile); 3149 switch (**pp) 3150 { 3151 case '0': 3152 /* Nothing to do. */ 3153 break; 3154 case '1': 3155 SET_TYPE_FIELD_VIRTUAL (type, i); 3156 break; 3157 default: 3158 /* Unknown character. Complain and treat it as non-virtual. */ 3159 { 3160 complaint (&symfile_complaints, 3161 _("Unknown virtual character `%c' for baseclass"), 3162 **pp); 3163 } 3164 } 3165 ++(*pp); 3166 3167 new->visibility = *(*pp)++; 3168 switch (new->visibility) 3169 { 3170 case VISIBILITY_PRIVATE: 3171 case VISIBILITY_PROTECTED: 3172 case VISIBILITY_PUBLIC: 3173 break; 3174 default: 3175 /* Bad visibility format. Complain and treat it as 3176 public. */ 3177 { 3178 complaint (&symfile_complaints, 3179 _("Unknown visibility `%c' for baseclass"), 3180 new->visibility); 3181 new->visibility = VISIBILITY_PUBLIC; 3182 } 3183 } 3184 3185 { 3186 int nbits; 3187 3188 /* The remaining value is the bit offset of the portion of the object 3189 corresponding to this baseclass. Always zero in the absence of 3190 multiple inheritance. */ 3191 3192 FIELD_BITPOS (new->field) = read_huge_number (pp, ',', &nbits, 0); 3193 if (nbits != 0) 3194 return 0; 3195 } 3196 3197 /* The last piece of baseclass information is the type of the 3198 base class. Read it, and remember it's type name as this 3199 field's name. */ 3200 3201 new->field.type = read_type (pp, objfile); 3202 new->field.name = type_name_no_tag (new->field.type); 3203 3204 /* Skip trailing ';' and bump count of number of fields seen. */ 3205 if (**pp == ';') 3206 (*pp)++; 3207 else 3208 return 0; 3209 } 3210 return 1; 3211 } 3212 3213 /* The tail end of stabs for C++ classes that contain a virtual function 3214 pointer contains a tilde, a %, and a type number. 3215 The type number refers to the base class (possibly this class itself) which 3216 contains the vtable pointer for the current class. 3217 3218 This function is called when we have parsed all the method declarations, 3219 so we can look for the vptr base class info. */ 3220 3221 static int 3222 read_tilde_fields (struct field_info *fip, char **pp, struct type *type, 3223 struct objfile *objfile) 3224 { 3225 char *p; 3226 3227 STABS_CONTINUE (pp, objfile); 3228 3229 /* If we are positioned at a ';', then skip it. */ 3230 if (**pp == ';') 3231 { 3232 (*pp)++; 3233 } 3234 3235 if (**pp == '~') 3236 { 3237 (*pp)++; 3238 3239 if (**pp == '=' || **pp == '+' || **pp == '-') 3240 { 3241 /* Obsolete flags that used to indicate the presence 3242 of constructors and/or destructors. */ 3243 (*pp)++; 3244 } 3245 3246 /* Read either a '%' or the final ';'. */ 3247 if (*(*pp)++ == '%') 3248 { 3249 /* The next number is the type number of the base class 3250 (possibly our own class) which supplies the vtable for 3251 this class. Parse it out, and search that class to find 3252 its vtable pointer, and install those into TYPE_VPTR_BASETYPE 3253 and TYPE_VPTR_FIELDNO. */ 3254 3255 struct type *t; 3256 int i; 3257 3258 t = read_type (pp, objfile); 3259 p = (*pp)++; 3260 while (*p != '\0' && *p != ';') 3261 { 3262 p++; 3263 } 3264 if (*p == '\0') 3265 { 3266 /* Premature end of symbol. */ 3267 return 0; 3268 } 3269 3270 TYPE_VPTR_BASETYPE (type) = t; 3271 if (type == t) /* Our own class provides vtbl ptr. */ 3272 { 3273 for (i = TYPE_NFIELDS (t) - 1; 3274 i >= TYPE_N_BASECLASSES (t); 3275 --i) 3276 { 3277 char *name = TYPE_FIELD_NAME (t, i); 3278 3279 if (!strncmp (name, vptr_name, sizeof (vptr_name) - 2) 3280 && is_cplus_marker (name[sizeof (vptr_name) - 2])) 3281 { 3282 TYPE_VPTR_FIELDNO (type) = i; 3283 goto gotit; 3284 } 3285 } 3286 /* Virtual function table field not found. */ 3287 complaint (&symfile_complaints, 3288 _("virtual function table pointer " 3289 "not found when defining class `%s'"), 3290 TYPE_NAME (type)); 3291 return 0; 3292 } 3293 else 3294 { 3295 TYPE_VPTR_FIELDNO (type) = TYPE_VPTR_FIELDNO (t); 3296 } 3297 3298 gotit: 3299 *pp = p + 1; 3300 } 3301 } 3302 return 1; 3303 } 3304 3305 static int 3306 attach_fn_fields_to_type (struct field_info *fip, struct type *type) 3307 { 3308 int n; 3309 3310 for (n = TYPE_NFN_FIELDS (type); 3311 fip->fnlist != NULL; 3312 fip->fnlist = fip->fnlist->next) 3313 { 3314 --n; /* Circumvent Sun3 compiler bug. */ 3315 TYPE_FN_FIELDLISTS (type)[n] = fip->fnlist->fn_fieldlist; 3316 } 3317 return 1; 3318 } 3319 3320 /* Create the vector of fields, and record how big it is. 3321 We need this info to record proper virtual function table information 3322 for this class's virtual functions. */ 3323 3324 static int 3325 attach_fields_to_type (struct field_info *fip, struct type *type, 3326 struct objfile *objfile) 3327 { 3328 int nfields = 0; 3329 int non_public_fields = 0; 3330 struct nextfield *scan; 3331 3332 /* Count up the number of fields that we have, as well as taking note of 3333 whether or not there are any non-public fields, which requires us to 3334 allocate and build the private_field_bits and protected_field_bits 3335 bitfields. */ 3336 3337 for (scan = fip->list; scan != NULL; scan = scan->next) 3338 { 3339 nfields++; 3340 if (scan->visibility != VISIBILITY_PUBLIC) 3341 { 3342 non_public_fields++; 3343 } 3344 } 3345 3346 /* Now we know how many fields there are, and whether or not there are any 3347 non-public fields. Record the field count, allocate space for the 3348 array of fields, and create blank visibility bitfields if necessary. */ 3349 3350 TYPE_NFIELDS (type) = nfields; 3351 TYPE_FIELDS (type) = (struct field *) 3352 TYPE_ALLOC (type, sizeof (struct field) * nfields); 3353 memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nfields); 3354 3355 if (non_public_fields) 3356 { 3357 ALLOCATE_CPLUS_STRUCT_TYPE (type); 3358 3359 TYPE_FIELD_PRIVATE_BITS (type) = 3360 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields)); 3361 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type), nfields); 3362 3363 TYPE_FIELD_PROTECTED_BITS (type) = 3364 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields)); 3365 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type), nfields); 3366 3367 TYPE_FIELD_IGNORE_BITS (type) = 3368 (B_TYPE *) TYPE_ALLOC (type, B_BYTES (nfields)); 3369 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type), nfields); 3370 } 3371 3372 /* Copy the saved-up fields into the field vector. Start from the 3373 head of the list, adding to the tail of the field array, so that 3374 they end up in the same order in the array in which they were 3375 added to the list. */ 3376 3377 while (nfields-- > 0) 3378 { 3379 TYPE_FIELD (type, nfields) = fip->list->field; 3380 switch (fip->list->visibility) 3381 { 3382 case VISIBILITY_PRIVATE: 3383 SET_TYPE_FIELD_PRIVATE (type, nfields); 3384 break; 3385 3386 case VISIBILITY_PROTECTED: 3387 SET_TYPE_FIELD_PROTECTED (type, nfields); 3388 break; 3389 3390 case VISIBILITY_IGNORE: 3391 SET_TYPE_FIELD_IGNORE (type, nfields); 3392 break; 3393 3394 case VISIBILITY_PUBLIC: 3395 break; 3396 3397 default: 3398 /* Unknown visibility. Complain and treat it as public. */ 3399 { 3400 complaint (&symfile_complaints, 3401 _("Unknown visibility `%c' for field"), 3402 fip->list->visibility); 3403 } 3404 break; 3405 } 3406 fip->list = fip->list->next; 3407 } 3408 return 1; 3409 } 3410 3411 3412 /* Complain that the compiler has emitted more than one definition for the 3413 structure type TYPE. */ 3414 static void 3415 complain_about_struct_wipeout (struct type *type) 3416 { 3417 char *name = ""; 3418 char *kind = ""; 3419 3420 if (TYPE_TAG_NAME (type)) 3421 { 3422 name = TYPE_TAG_NAME (type); 3423 switch (TYPE_CODE (type)) 3424 { 3425 case TYPE_CODE_STRUCT: kind = "struct "; break; 3426 case TYPE_CODE_UNION: kind = "union "; break; 3427 case TYPE_CODE_ENUM: kind = "enum "; break; 3428 default: kind = ""; 3429 } 3430 } 3431 else if (TYPE_NAME (type)) 3432 { 3433 name = TYPE_NAME (type); 3434 kind = ""; 3435 } 3436 else 3437 { 3438 name = "<unknown>"; 3439 kind = ""; 3440 } 3441 3442 complaint (&symfile_complaints, 3443 _("struct/union type gets multiply defined: %s%s"), kind, name); 3444 } 3445 3446 /* Set the length for all variants of a same main_type, which are 3447 connected in the closed chain. 3448 3449 This is something that needs to be done when a type is defined *after* 3450 some cross references to this type have already been read. Consider 3451 for instance the following scenario where we have the following two 3452 stabs entries: 3453 3454 .stabs "t:p(0,21)=*(0,22)=k(0,23)=xsdummy:",160,0,28,-24 3455 .stabs "dummy:T(0,23)=s16x:(0,1),0,3[...]" 3456 3457 A stubbed version of type dummy is created while processing the first 3458 stabs entry. The length of that type is initially set to zero, since 3459 it is unknown at this point. Also, a "constant" variation of type 3460 "dummy" is created as well (this is the "(0,22)=k(0,23)" section of 3461 the stabs line). 3462 3463 The second stabs entry allows us to replace the stubbed definition 3464 with the real definition. However, we still need to adjust the length 3465 of the "constant" variation of that type, as its length was left 3466 untouched during the main type replacement... */ 3467 3468 static void 3469 set_length_in_type_chain (struct type *type) 3470 { 3471 struct type *ntype = TYPE_CHAIN (type); 3472 3473 while (ntype != type) 3474 { 3475 if (TYPE_LENGTH(ntype) == 0) 3476 TYPE_LENGTH (ntype) = TYPE_LENGTH (type); 3477 else 3478 complain_about_struct_wipeout (ntype); 3479 ntype = TYPE_CHAIN (ntype); 3480 } 3481 } 3482 3483 /* Read the description of a structure (or union type) and return an object 3484 describing the type. 3485 3486 PP points to a character pointer that points to the next unconsumed token 3487 in the stabs string. For example, given stabs "A:T4=s4a:1,0,32;;", 3488 *PP will point to "4a:1,0,32;;". 3489 3490 TYPE points to an incomplete type that needs to be filled in. 3491 3492 OBJFILE points to the current objfile from which the stabs information is 3493 being read. (Note that it is redundant in that TYPE also contains a pointer 3494 to this same objfile, so it might be a good idea to eliminate it. FIXME). 3495 */ 3496 3497 static struct type * 3498 read_struct_type (char **pp, struct type *type, enum type_code type_code, 3499 struct objfile *objfile) 3500 { 3501 struct cleanup *back_to; 3502 struct field_info fi; 3503 3504 fi.list = NULL; 3505 fi.fnlist = NULL; 3506 3507 /* When describing struct/union/class types in stabs, G++ always drops 3508 all qualifications from the name. So if you've got: 3509 struct A { ... struct B { ... }; ... }; 3510 then G++ will emit stabs for `struct A::B' that call it simply 3511 `struct B'. Obviously, if you've got a real top-level definition for 3512 `struct B', or other nested definitions, this is going to cause 3513 problems. 3514 3515 Obviously, GDB can't fix this by itself, but it can at least avoid 3516 scribbling on existing structure type objects when new definitions 3517 appear. */ 3518 if (! (TYPE_CODE (type) == TYPE_CODE_UNDEF 3519 || TYPE_STUB (type))) 3520 { 3521 complain_about_struct_wipeout (type); 3522 3523 /* It's probably best to return the type unchanged. */ 3524 return type; 3525 } 3526 3527 back_to = make_cleanup (null_cleanup, 0); 3528 3529 INIT_CPLUS_SPECIFIC (type); 3530 TYPE_CODE (type) = type_code; 3531 TYPE_STUB (type) = 0; 3532 3533 /* First comes the total size in bytes. */ 3534 3535 { 3536 int nbits; 3537 3538 TYPE_LENGTH (type) = read_huge_number (pp, 0, &nbits, 0); 3539 if (nbits != 0) 3540 return error_type (pp, objfile); 3541 set_length_in_type_chain (type); 3542 } 3543 3544 /* Now read the baseclasses, if any, read the regular C struct or C++ 3545 class member fields, attach the fields to the type, read the C++ 3546 member functions, attach them to the type, and then read any tilde 3547 field (baseclass specifier for the class holding the main vtable). */ 3548 3549 if (!read_baseclasses (&fi, pp, type, objfile) 3550 || !read_struct_fields (&fi, pp, type, objfile) 3551 || !attach_fields_to_type (&fi, type, objfile) 3552 || !read_member_functions (&fi, pp, type, objfile) 3553 || !attach_fn_fields_to_type (&fi, type) 3554 || !read_tilde_fields (&fi, pp, type, objfile)) 3555 { 3556 type = error_type (pp, objfile); 3557 } 3558 3559 do_cleanups (back_to); 3560 return (type); 3561 } 3562 3563 /* Read a definition of an array type, 3564 and create and return a suitable type object. 3565 Also creates a range type which represents the bounds of that 3566 array. */ 3567 3568 static struct type * 3569 read_array_type (char **pp, struct type *type, 3570 struct objfile *objfile) 3571 { 3572 struct type *index_type, *element_type, *range_type; 3573 int lower, upper; 3574 int adjustable = 0; 3575 int nbits; 3576 3577 /* Format of an array type: 3578 "ar<index type>;lower;upper;<array_contents_type>". 3579 OS9000: "arlower,upper;<array_contents_type>". 3580 3581 Fortran adjustable arrays use Adigits or Tdigits for lower or upper; 3582 for these, produce a type like float[][]. */ 3583 3584 { 3585 index_type = read_type (pp, objfile); 3586 if (**pp != ';') 3587 /* Improper format of array type decl. */ 3588 return error_type (pp, objfile); 3589 ++*pp; 3590 } 3591 3592 if (!(**pp >= '0' && **pp <= '9') && **pp != '-') 3593 { 3594 (*pp)++; 3595 adjustable = 1; 3596 } 3597 lower = read_huge_number (pp, ';', &nbits, 0); 3598 3599 if (nbits != 0) 3600 return error_type (pp, objfile); 3601 3602 if (!(**pp >= '0' && **pp <= '9') && **pp != '-') 3603 { 3604 (*pp)++; 3605 adjustable = 1; 3606 } 3607 upper = read_huge_number (pp, ';', &nbits, 0); 3608 if (nbits != 0) 3609 return error_type (pp, objfile); 3610 3611 element_type = read_type (pp, objfile); 3612 3613 if (adjustable) 3614 { 3615 lower = 0; 3616 upper = -1; 3617 } 3618 3619 range_type = 3620 create_range_type ((struct type *) NULL, index_type, lower, upper); 3621 type = create_array_type (type, element_type, range_type); 3622 3623 return type; 3624 } 3625 3626 3627 /* Read a definition of an enumeration type, 3628 and create and return a suitable type object. 3629 Also defines the symbols that represent the values of the type. */ 3630 3631 static struct type * 3632 read_enum_type (char **pp, struct type *type, 3633 struct objfile *objfile) 3634 { 3635 struct gdbarch *gdbarch = get_objfile_arch (objfile); 3636 char *p; 3637 char *name; 3638 long n; 3639 struct symbol *sym; 3640 int nsyms = 0; 3641 struct pending **symlist; 3642 struct pending *osyms, *syms; 3643 int o_nsyms; 3644 int nbits; 3645 int unsigned_enum = 1; 3646 3647 #if 0 3648 /* FIXME! The stabs produced by Sun CC merrily define things that ought 3649 to be file-scope, between N_FN entries, using N_LSYM. What's a mother 3650 to do? For now, force all enum values to file scope. */ 3651 if (within_function) 3652 symlist = &local_symbols; 3653 else 3654 #endif 3655 symlist = &file_symbols; 3656 osyms = *symlist; 3657 o_nsyms = osyms ? osyms->nsyms : 0; 3658 3659 /* The aix4 compiler emits an extra field before the enum members; 3660 my guess is it's a type of some sort. Just ignore it. */ 3661 if (**pp == '-') 3662 { 3663 /* Skip over the type. */ 3664 while (**pp != ':') 3665 (*pp)++; 3666 3667 /* Skip over the colon. */ 3668 (*pp)++; 3669 } 3670 3671 /* Read the value-names and their values. 3672 The input syntax is NAME:VALUE,NAME:VALUE, and so on. 3673 A semicolon or comma instead of a NAME means the end. */ 3674 while (**pp && **pp != ';' && **pp != ',') 3675 { 3676 STABS_CONTINUE (pp, objfile); 3677 p = *pp; 3678 while (*p != ':') 3679 p++; 3680 name = obsavestring (*pp, p - *pp, &objfile->objfile_obstack); 3681 *pp = p + 1; 3682 n = read_huge_number (pp, ',', &nbits, 0); 3683 if (nbits != 0) 3684 return error_type (pp, objfile); 3685 3686 sym = (struct symbol *) 3687 obstack_alloc (&objfile->objfile_obstack, sizeof (struct symbol)); 3688 memset (sym, 0, sizeof (struct symbol)); 3689 SYMBOL_SET_LINKAGE_NAME (sym, name); 3690 SYMBOL_SET_LANGUAGE (sym, current_subfile->language); 3691 SYMBOL_CLASS (sym) = LOC_CONST; 3692 SYMBOL_DOMAIN (sym) = VAR_DOMAIN; 3693 SYMBOL_VALUE (sym) = n; 3694 if (n < 0) 3695 unsigned_enum = 0; 3696 add_symbol_to_list (sym, symlist); 3697 nsyms++; 3698 } 3699 3700 if (**pp == ';') 3701 (*pp)++; /* Skip the semicolon. */ 3702 3703 /* Now fill in the fields of the type-structure. */ 3704 3705 TYPE_LENGTH (type) = gdbarch_int_bit (gdbarch) / HOST_CHAR_BIT; 3706 set_length_in_type_chain (type); 3707 TYPE_CODE (type) = TYPE_CODE_ENUM; 3708 TYPE_STUB (type) = 0; 3709 if (unsigned_enum) 3710 TYPE_UNSIGNED (type) = 1; 3711 TYPE_NFIELDS (type) = nsyms; 3712 TYPE_FIELDS (type) = (struct field *) 3713 TYPE_ALLOC (type, sizeof (struct field) * nsyms); 3714 memset (TYPE_FIELDS (type), 0, sizeof (struct field) * nsyms); 3715 3716 /* Find the symbols for the values and put them into the type. 3717 The symbols can be found in the symlist that we put them on 3718 to cause them to be defined. osyms contains the old value 3719 of that symlist; everything up to there was defined by us. */ 3720 /* Note that we preserve the order of the enum constants, so 3721 that in something like "enum {FOO, LAST_THING=FOO}" we print 3722 FOO, not LAST_THING. */ 3723 3724 for (syms = *symlist, n = nsyms - 1; syms; syms = syms->next) 3725 { 3726 int last = syms == osyms ? o_nsyms : 0; 3727 int j = syms->nsyms; 3728 3729 for (; --j >= last; --n) 3730 { 3731 struct symbol *xsym = syms->symbol[j]; 3732 3733 SYMBOL_TYPE (xsym) = type; 3734 TYPE_FIELD_NAME (type, n) = SYMBOL_LINKAGE_NAME (xsym); 3735 TYPE_FIELD_BITPOS (type, n) = SYMBOL_VALUE (xsym); 3736 TYPE_FIELD_BITSIZE (type, n) = 0; 3737 } 3738 if (syms == osyms) 3739 break; 3740 } 3741 3742 return type; 3743 } 3744 3745 /* Sun's ACC uses a somewhat saner method for specifying the builtin 3746 typedefs in every file (for int, long, etc): 3747 3748 type = b <signed> <width> <format type>; <offset>; <nbits> 3749 signed = u or s. 3750 optional format type = c or b for char or boolean. 3751 offset = offset from high order bit to start bit of type. 3752 width is # bytes in object of this type, nbits is # bits in type. 3753 3754 The width/offset stuff appears to be for small objects stored in 3755 larger ones (e.g. `shorts' in `int' registers). We ignore it for now, 3756 FIXME. */ 3757 3758 static struct type * 3759 read_sun_builtin_type (char **pp, int typenums[2], struct objfile *objfile) 3760 { 3761 int type_bits; 3762 int nbits; 3763 int signed_type; 3764 enum type_code code = TYPE_CODE_INT; 3765 3766 switch (**pp) 3767 { 3768 case 's': 3769 signed_type = 1; 3770 break; 3771 case 'u': 3772 signed_type = 0; 3773 break; 3774 default: 3775 return error_type (pp, objfile); 3776 } 3777 (*pp)++; 3778 3779 /* For some odd reason, all forms of char put a c here. This is strange 3780 because no other type has this honor. We can safely ignore this because 3781 we actually determine 'char'acterness by the number of bits specified in 3782 the descriptor. 3783 Boolean forms, e.g Fortran logical*X, put a b here. */ 3784 3785 if (**pp == 'c') 3786 (*pp)++; 3787 else if (**pp == 'b') 3788 { 3789 code = TYPE_CODE_BOOL; 3790 (*pp)++; 3791 } 3792 3793 /* The first number appears to be the number of bytes occupied 3794 by this type, except that unsigned short is 4 instead of 2. 3795 Since this information is redundant with the third number, 3796 we will ignore it. */ 3797 read_huge_number (pp, ';', &nbits, 0); 3798 if (nbits != 0) 3799 return error_type (pp, objfile); 3800 3801 /* The second number is always 0, so ignore it too. */ 3802 read_huge_number (pp, ';', &nbits, 0); 3803 if (nbits != 0) 3804 return error_type (pp, objfile); 3805 3806 /* The third number is the number of bits for this type. */ 3807 type_bits = read_huge_number (pp, 0, &nbits, 0); 3808 if (nbits != 0) 3809 return error_type (pp, objfile); 3810 /* The type *should* end with a semicolon. If it are embedded 3811 in a larger type the semicolon may be the only way to know where 3812 the type ends. If this type is at the end of the stabstring we 3813 can deal with the omitted semicolon (but we don't have to like 3814 it). Don't bother to complain(), Sun's compiler omits the semicolon 3815 for "void". */ 3816 if (**pp == ';') 3817 ++(*pp); 3818 3819 if (type_bits == 0) 3820 return init_type (TYPE_CODE_VOID, 1, 3821 signed_type ? 0 : TYPE_FLAG_UNSIGNED, (char *) NULL, 3822 objfile); 3823 else 3824 return init_type (code, 3825 type_bits / TARGET_CHAR_BIT, 3826 signed_type ? 0 : TYPE_FLAG_UNSIGNED, (char *) NULL, 3827 objfile); 3828 } 3829 3830 static struct type * 3831 read_sun_floating_type (char **pp, int typenums[2], struct objfile *objfile) 3832 { 3833 int nbits; 3834 int details; 3835 int nbytes; 3836 struct type *rettype; 3837 3838 /* The first number has more details about the type, for example 3839 FN_COMPLEX. */ 3840 details = read_huge_number (pp, ';', &nbits, 0); 3841 if (nbits != 0) 3842 return error_type (pp, objfile); 3843 3844 /* The second number is the number of bytes occupied by this type. */ 3845 nbytes = read_huge_number (pp, ';', &nbits, 0); 3846 if (nbits != 0) 3847 return error_type (pp, objfile); 3848 3849 if (details == NF_COMPLEX || details == NF_COMPLEX16 3850 || details == NF_COMPLEX32) 3851 { 3852 rettype = init_type (TYPE_CODE_COMPLEX, nbytes, 0, NULL, objfile); 3853 TYPE_TARGET_TYPE (rettype) 3854 = init_type (TYPE_CODE_FLT, nbytes / 2, 0, NULL, objfile); 3855 return rettype; 3856 } 3857 3858 return init_type (TYPE_CODE_FLT, nbytes, 0, NULL, objfile); 3859 } 3860 3861 /* Read a number from the string pointed to by *PP. 3862 The value of *PP is advanced over the number. 3863 If END is nonzero, the character that ends the 3864 number must match END, or an error happens; 3865 and that character is skipped if it does match. 3866 If END is zero, *PP is left pointing to that character. 3867 3868 If TWOS_COMPLEMENT_BITS is set to a strictly positive value and if 3869 the number is represented in an octal representation, assume that 3870 it is represented in a 2's complement representation with a size of 3871 TWOS_COMPLEMENT_BITS. 3872 3873 If the number fits in a long, set *BITS to 0 and return the value. 3874 If not, set *BITS to be the number of bits in the number and return 0. 3875 3876 If encounter garbage, set *BITS to -1 and return 0. */ 3877 3878 static long 3879 read_huge_number (char **pp, int end, int *bits, int twos_complement_bits) 3880 { 3881 char *p = *pp; 3882 int sign = 1; 3883 int sign_bit = 0; 3884 long n = 0; 3885 int radix = 10; 3886 char overflow = 0; 3887 int nbits = 0; 3888 int c; 3889 long upper_limit; 3890 int twos_complement_representation = 0; 3891 3892 if (*p == '-') 3893 { 3894 sign = -1; 3895 p++; 3896 } 3897 3898 /* Leading zero means octal. GCC uses this to output values larger 3899 than an int (because that would be hard in decimal). */ 3900 if (*p == '0') 3901 { 3902 radix = 8; 3903 p++; 3904 } 3905 3906 /* Skip extra zeros. */ 3907 while (*p == '0') 3908 p++; 3909 3910 if (sign > 0 && radix == 8 && twos_complement_bits > 0) 3911 { 3912 /* Octal, possibly signed. Check if we have enough chars for a 3913 negative number. */ 3914 3915 size_t len; 3916 char *p1 = p; 3917 3918 while ((c = *p1) >= '0' && c < '8') 3919 p1++; 3920 3921 len = p1 - p; 3922 if (len > twos_complement_bits / 3 3923 || (twos_complement_bits % 3 == 0 3924 && len == twos_complement_bits / 3)) 3925 { 3926 /* Ok, we have enough characters for a signed value, check 3927 for signness by testing if the sign bit is set. */ 3928 sign_bit = (twos_complement_bits % 3 + 2) % 3; 3929 c = *p - '0'; 3930 if (c & (1 << sign_bit)) 3931 { 3932 /* Definitely signed. */ 3933 twos_complement_representation = 1; 3934 sign = -1; 3935 } 3936 } 3937 } 3938 3939 upper_limit = LONG_MAX / radix; 3940 3941 while ((c = *p++) >= '0' && c < ('0' + radix)) 3942 { 3943 if (n <= upper_limit) 3944 { 3945 if (twos_complement_representation) 3946 { 3947 /* Octal, signed, twos complement representation. In 3948 this case, n is the corresponding absolute value. */ 3949 if (n == 0) 3950 { 3951 long sn = c - '0' - ((2 * (c - '0')) | (2 << sign_bit)); 3952 3953 n = -sn; 3954 } 3955 else 3956 { 3957 n *= radix; 3958 n -= c - '0'; 3959 } 3960 } 3961 else 3962 { 3963 /* unsigned representation */ 3964 n *= radix; 3965 n += c - '0'; /* FIXME this overflows anyway. */ 3966 } 3967 } 3968 else 3969 overflow = 1; 3970 3971 /* This depends on large values being output in octal, which is 3972 what GCC does. */ 3973 if (radix == 8) 3974 { 3975 if (nbits == 0) 3976 { 3977 if (c == '0') 3978 /* Ignore leading zeroes. */ 3979 ; 3980 else if (c == '1') 3981 nbits = 1; 3982 else if (c == '2' || c == '3') 3983 nbits = 2; 3984 else 3985 nbits = 3; 3986 } 3987 else 3988 nbits += 3; 3989 } 3990 } 3991 if (end) 3992 { 3993 if (c && c != end) 3994 { 3995 if (bits != NULL) 3996 *bits = -1; 3997 return 0; 3998 } 3999 } 4000 else 4001 --p; 4002 4003 if (radix == 8 && twos_complement_bits > 0 && nbits > twos_complement_bits) 4004 { 4005 /* We were supposed to parse a number with maximum 4006 TWOS_COMPLEMENT_BITS bits, but something went wrong. */ 4007 if (bits != NULL) 4008 *bits = -1; 4009 return 0; 4010 } 4011 4012 *pp = p; 4013 if (overflow) 4014 { 4015 if (nbits == 0) 4016 { 4017 /* Large decimal constants are an error (because it is hard to 4018 count how many bits are in them). */ 4019 if (bits != NULL) 4020 *bits = -1; 4021 return 0; 4022 } 4023 4024 /* -0x7f is the same as 0x80. So deal with it by adding one to 4025 the number of bits. Two's complement represention octals 4026 can't have a '-' in front. */ 4027 if (sign == -1 && !twos_complement_representation) 4028 ++nbits; 4029 if (bits) 4030 *bits = nbits; 4031 } 4032 else 4033 { 4034 if (bits) 4035 *bits = 0; 4036 return n * sign; 4037 } 4038 /* It's *BITS which has the interesting information. */ 4039 return 0; 4040 } 4041 4042 static struct type * 4043 read_range_type (char **pp, int typenums[2], int type_size, 4044 struct objfile *objfile) 4045 { 4046 struct gdbarch *gdbarch = get_objfile_arch (objfile); 4047 char *orig_pp = *pp; 4048 int rangenums[2]; 4049 long n2, n3; 4050 int n2bits, n3bits; 4051 int self_subrange; 4052 struct type *result_type; 4053 struct type *index_type = NULL; 4054 4055 /* First comes a type we are a subrange of. 4056 In C it is usually 0, 1 or the type being defined. */ 4057 if (read_type_number (pp, rangenums) != 0) 4058 return error_type (pp, objfile); 4059 self_subrange = (rangenums[0] == typenums[0] && 4060 rangenums[1] == typenums[1]); 4061 4062 if (**pp == '=') 4063 { 4064 *pp = orig_pp; 4065 index_type = read_type (pp, objfile); 4066 } 4067 4068 /* A semicolon should now follow; skip it. */ 4069 if (**pp == ';') 4070 (*pp)++; 4071 4072 /* The remaining two operands are usually lower and upper bounds 4073 of the range. But in some special cases they mean something else. */ 4074 n2 = read_huge_number (pp, ';', &n2bits, type_size); 4075 n3 = read_huge_number (pp, ';', &n3bits, type_size); 4076 4077 if (n2bits == -1 || n3bits == -1) 4078 return error_type (pp, objfile); 4079 4080 if (index_type) 4081 goto handle_true_range; 4082 4083 /* If limits are huge, must be large integral type. */ 4084 if (n2bits != 0 || n3bits != 0) 4085 { 4086 char got_signed = 0; 4087 char got_unsigned = 0; 4088 /* Number of bits in the type. */ 4089 int nbits = 0; 4090 4091 /* If a type size attribute has been specified, the bounds of 4092 the range should fit in this size. If the lower bounds needs 4093 more bits than the upper bound, then the type is signed. */ 4094 if (n2bits <= type_size && n3bits <= type_size) 4095 { 4096 if (n2bits == type_size && n2bits > n3bits) 4097 got_signed = 1; 4098 else 4099 got_unsigned = 1; 4100 nbits = type_size; 4101 } 4102 /* Range from 0 to <large number> is an unsigned large integral type. */ 4103 else if ((n2bits == 0 && n2 == 0) && n3bits != 0) 4104 { 4105 got_unsigned = 1; 4106 nbits = n3bits; 4107 } 4108 /* Range from <large number> to <large number>-1 is a large signed 4109 integral type. Take care of the case where <large number> doesn't 4110 fit in a long but <large number>-1 does. */ 4111 else if ((n2bits != 0 && n3bits != 0 && n2bits == n3bits + 1) 4112 || (n2bits != 0 && n3bits == 0 4113 && (n2bits == sizeof (long) * HOST_CHAR_BIT) 4114 && n3 == LONG_MAX)) 4115 { 4116 got_signed = 1; 4117 nbits = n2bits; 4118 } 4119 4120 if (got_signed || got_unsigned) 4121 { 4122 return init_type (TYPE_CODE_INT, nbits / TARGET_CHAR_BIT, 4123 got_unsigned ? TYPE_FLAG_UNSIGNED : 0, NULL, 4124 objfile); 4125 } 4126 else 4127 return error_type (pp, objfile); 4128 } 4129 4130 /* A type defined as a subrange of itself, with bounds both 0, is void. */ 4131 if (self_subrange && n2 == 0 && n3 == 0) 4132 return init_type (TYPE_CODE_VOID, 1, 0, NULL, objfile); 4133 4134 /* If n3 is zero and n2 is positive, we want a floating type, and n2 4135 is the width in bytes. 4136 4137 Fortran programs appear to use this for complex types also. To 4138 distinguish between floats and complex, g77 (and others?) seem 4139 to use self-subranges for the complexes, and subranges of int for 4140 the floats. 4141 4142 Also note that for complexes, g77 sets n2 to the size of one of 4143 the member floats, not the whole complex beast. My guess is that 4144 this was to work well with pre-COMPLEX versions of gdb. */ 4145 4146 if (n3 == 0 && n2 > 0) 4147 { 4148 struct type *float_type 4149 = init_type (TYPE_CODE_FLT, n2, 0, NULL, objfile); 4150 4151 if (self_subrange) 4152 { 4153 struct type *complex_type = 4154 init_type (TYPE_CODE_COMPLEX, 2 * n2, 0, NULL, objfile); 4155 4156 TYPE_TARGET_TYPE (complex_type) = float_type; 4157 return complex_type; 4158 } 4159 else 4160 return float_type; 4161 } 4162 4163 /* If the upper bound is -1, it must really be an unsigned integral. */ 4164 4165 else if (n2 == 0 && n3 == -1) 4166 { 4167 int bits = type_size; 4168 4169 if (bits <= 0) 4170 { 4171 /* We don't know its size. It is unsigned int or unsigned 4172 long. GCC 2.3.3 uses this for long long too, but that is 4173 just a GDB 3.5 compatibility hack. */ 4174 bits = gdbarch_int_bit (gdbarch); 4175 } 4176 4177 return init_type (TYPE_CODE_INT, bits / TARGET_CHAR_BIT, 4178 TYPE_FLAG_UNSIGNED, NULL, objfile); 4179 } 4180 4181 /* Special case: char is defined (Who knows why) as a subrange of 4182 itself with range 0-127. */ 4183 else if (self_subrange && n2 == 0 && n3 == 127) 4184 return init_type (TYPE_CODE_INT, 1, TYPE_FLAG_NOSIGN, NULL, objfile); 4185 4186 /* We used to do this only for subrange of self or subrange of int. */ 4187 else if (n2 == 0) 4188 { 4189 /* -1 is used for the upper bound of (4 byte) "unsigned int" and 4190 "unsigned long", and we already checked for that, 4191 so don't need to test for it here. */ 4192 4193 if (n3 < 0) 4194 /* n3 actually gives the size. */ 4195 return init_type (TYPE_CODE_INT, -n3, TYPE_FLAG_UNSIGNED, 4196 NULL, objfile); 4197 4198 /* Is n3 == 2**(8n)-1 for some integer n? Then it's an 4199 unsigned n-byte integer. But do require n to be a power of 4200 two; we don't want 3- and 5-byte integers flying around. */ 4201 { 4202 int bytes; 4203 unsigned long bits; 4204 4205 bits = n3; 4206 for (bytes = 0; (bits & 0xff) == 0xff; bytes++) 4207 bits >>= 8; 4208 if (bits == 0 4209 && ((bytes - 1) & bytes) == 0) /* "bytes is a power of two" */ 4210 return init_type (TYPE_CODE_INT, bytes, TYPE_FLAG_UNSIGNED, NULL, 4211 objfile); 4212 } 4213 } 4214 /* I think this is for Convex "long long". Since I don't know whether 4215 Convex sets self_subrange, I also accept that particular size regardless 4216 of self_subrange. */ 4217 else if (n3 == 0 && n2 < 0 4218 && (self_subrange 4219 || n2 == -gdbarch_long_long_bit 4220 (gdbarch) / TARGET_CHAR_BIT)) 4221 return init_type (TYPE_CODE_INT, -n2, 0, NULL, objfile); 4222 else if (n2 == -n3 - 1) 4223 { 4224 if (n3 == 0x7f) 4225 return init_type (TYPE_CODE_INT, 1, 0, NULL, objfile); 4226 if (n3 == 0x7fff) 4227 return init_type (TYPE_CODE_INT, 2, 0, NULL, objfile); 4228 if (n3 == 0x7fffffff) 4229 return init_type (TYPE_CODE_INT, 4, 0, NULL, objfile); 4230 } 4231 4232 /* We have a real range type on our hands. Allocate space and 4233 return a real pointer. */ 4234 handle_true_range: 4235 4236 if (self_subrange) 4237 index_type = objfile_type (objfile)->builtin_int; 4238 else 4239 index_type = *dbx_lookup_type (rangenums, objfile); 4240 if (index_type == NULL) 4241 { 4242 /* Does this actually ever happen? Is that why we are worrying 4243 about dealing with it rather than just calling error_type? */ 4244 4245 complaint (&symfile_complaints, 4246 _("base type %d of range type is not defined"), rangenums[1]); 4247 4248 index_type = objfile_type (objfile)->builtin_int; 4249 } 4250 4251 result_type = create_range_type ((struct type *) NULL, index_type, n2, n3); 4252 return (result_type); 4253 } 4254 4255 /* Read in an argument list. This is a list of types, separated by commas 4256 and terminated with END. Return the list of types read in, or NULL 4257 if there is an error. */ 4258 4259 static struct field * 4260 read_args (char **pp, int end, struct objfile *objfile, int *nargsp, 4261 int *varargsp) 4262 { 4263 /* FIXME! Remove this arbitrary limit! */ 4264 struct type *types[1024]; /* Allow for fns of 1023 parameters. */ 4265 int n = 0, i; 4266 struct field *rval; 4267 4268 while (**pp != end) 4269 { 4270 if (**pp != ',') 4271 /* Invalid argument list: no ','. */ 4272 return NULL; 4273 (*pp)++; 4274 STABS_CONTINUE (pp, objfile); 4275 types[n++] = read_type (pp, objfile); 4276 } 4277 (*pp)++; /* get past `end' (the ':' character). */ 4278 4279 if (n == 0) 4280 { 4281 /* We should read at least the THIS parameter here. Some broken stabs 4282 output contained `(0,41),(0,42)=@s8;-16;,(0,43),(0,1);' where should 4283 have been present ";-16,(0,43)" reference instead. This way the 4284 excessive ";" marker prematurely stops the parameters parsing. */ 4285 4286 complaint (&symfile_complaints, _("Invalid (empty) method arguments")); 4287 *varargsp = 0; 4288 } 4289 else if (TYPE_CODE (types[n - 1]) != TYPE_CODE_VOID) 4290 *varargsp = 1; 4291 else 4292 { 4293 n--; 4294 *varargsp = 0; 4295 } 4296 4297 rval = (struct field *) xmalloc (n * sizeof (struct field)); 4298 memset (rval, 0, n * sizeof (struct field)); 4299 for (i = 0; i < n; i++) 4300 rval[i].type = types[i]; 4301 *nargsp = n; 4302 return rval; 4303 } 4304 4305 /* Common block handling. */ 4306 4307 /* List of symbols declared since the last BCOMM. This list is a tail 4308 of local_symbols. When ECOMM is seen, the symbols on the list 4309 are noted so their proper addresses can be filled in later, 4310 using the common block base address gotten from the assembler 4311 stabs. */ 4312 4313 static struct pending *common_block; 4314 static int common_block_i; 4315 4316 /* Name of the current common block. We get it from the BCOMM instead of the 4317 ECOMM to match IBM documentation (even though IBM puts the name both places 4318 like everyone else). */ 4319 static char *common_block_name; 4320 4321 /* Process a N_BCOMM symbol. The storage for NAME is not guaranteed 4322 to remain after this function returns. */ 4323 4324 void 4325 common_block_start (char *name, struct objfile *objfile) 4326 { 4327 if (common_block_name != NULL) 4328 { 4329 complaint (&symfile_complaints, 4330 _("Invalid symbol data: common block within common block")); 4331 } 4332 common_block = local_symbols; 4333 common_block_i = local_symbols ? local_symbols->nsyms : 0; 4334 common_block_name = obsavestring (name, strlen (name), 4335 &objfile->objfile_obstack); 4336 } 4337 4338 /* Process a N_ECOMM symbol. */ 4339 4340 void 4341 common_block_end (struct objfile *objfile) 4342 { 4343 /* Symbols declared since the BCOMM are to have the common block 4344 start address added in when we know it. common_block and 4345 common_block_i point to the first symbol after the BCOMM in 4346 the local_symbols list; copy the list and hang it off the 4347 symbol for the common block name for later fixup. */ 4348 int i; 4349 struct symbol *sym; 4350 struct pending *new = 0; 4351 struct pending *next; 4352 int j; 4353 4354 if (common_block_name == NULL) 4355 { 4356 complaint (&symfile_complaints, _("ECOMM symbol unmatched by BCOMM")); 4357 return; 4358 } 4359 4360 sym = (struct symbol *) 4361 obstack_alloc (&objfile->objfile_obstack, sizeof (struct symbol)); 4362 memset (sym, 0, sizeof (struct symbol)); 4363 /* Note: common_block_name already saved on objfile_obstack. */ 4364 SYMBOL_SET_LINKAGE_NAME (sym, common_block_name); 4365 SYMBOL_CLASS (sym) = LOC_BLOCK; 4366 4367 /* Now we copy all the symbols which have been defined since the BCOMM. */ 4368 4369 /* Copy all the struct pendings before common_block. */ 4370 for (next = local_symbols; 4371 next != NULL && next != common_block; 4372 next = next->next) 4373 { 4374 for (j = 0; j < next->nsyms; j++) 4375 add_symbol_to_list (next->symbol[j], &new); 4376 } 4377 4378 /* Copy however much of COMMON_BLOCK we need. If COMMON_BLOCK is 4379 NULL, it means copy all the local symbols (which we already did 4380 above). */ 4381 4382 if (common_block != NULL) 4383 for (j = common_block_i; j < common_block->nsyms; j++) 4384 add_symbol_to_list (common_block->symbol[j], &new); 4385 4386 SYMBOL_TYPE (sym) = (struct type *) new; 4387 4388 /* Should we be putting local_symbols back to what it was? 4389 Does it matter? */ 4390 4391 i = hashname (SYMBOL_LINKAGE_NAME (sym)); 4392 SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i]; 4393 global_sym_chain[i] = sym; 4394 common_block_name = NULL; 4395 } 4396 4397 /* Add a common block's start address to the offset of each symbol 4398 declared to be in it (by being between a BCOMM/ECOMM pair that uses 4399 the common block name). */ 4400 4401 static void 4402 fix_common_block (struct symbol *sym, int valu) 4403 { 4404 struct pending *next = (struct pending *) SYMBOL_TYPE (sym); 4405 4406 for (; next; next = next->next) 4407 { 4408 int j; 4409 4410 for (j = next->nsyms - 1; j >= 0; j--) 4411 SYMBOL_VALUE_ADDRESS (next->symbol[j]) += valu; 4412 } 4413 } 4414 4415 4416 4417 /* Add {TYPE, TYPENUMS} to the NONAME_UNDEFS vector. 4418 See add_undefined_type for more details. */ 4419 4420 static void 4421 add_undefined_type_noname (struct type *type, int typenums[2]) 4422 { 4423 struct nat nat; 4424 4425 nat.typenums[0] = typenums [0]; 4426 nat.typenums[1] = typenums [1]; 4427 nat.type = type; 4428 4429 if (noname_undefs_length == noname_undefs_allocated) 4430 { 4431 noname_undefs_allocated *= 2; 4432 noname_undefs = (struct nat *) 4433 xrealloc ((char *) noname_undefs, 4434 noname_undefs_allocated * sizeof (struct nat)); 4435 } 4436 noname_undefs[noname_undefs_length++] = nat; 4437 } 4438 4439 /* Add TYPE to the UNDEF_TYPES vector. 4440 See add_undefined_type for more details. */ 4441 4442 static void 4443 add_undefined_type_1 (struct type *type) 4444 { 4445 if (undef_types_length == undef_types_allocated) 4446 { 4447 undef_types_allocated *= 2; 4448 undef_types = (struct type **) 4449 xrealloc ((char *) undef_types, 4450 undef_types_allocated * sizeof (struct type *)); 4451 } 4452 undef_types[undef_types_length++] = type; 4453 } 4454 4455 /* What about types defined as forward references inside of a small lexical 4456 scope? */ 4457 /* Add a type to the list of undefined types to be checked through 4458 once this file has been read in. 4459 4460 In practice, we actually maintain two such lists: The first list 4461 (UNDEF_TYPES) is used for types whose name has been provided, and 4462 concerns forward references (eg 'xs' or 'xu' forward references); 4463 the second list (NONAME_UNDEFS) is used for types whose name is 4464 unknown at creation time, because they were referenced through 4465 their type number before the actual type was declared. 4466 This function actually adds the given type to the proper list. */ 4467 4468 static void 4469 add_undefined_type (struct type *type, int typenums[2]) 4470 { 4471 if (TYPE_TAG_NAME (type) == NULL) 4472 add_undefined_type_noname (type, typenums); 4473 else 4474 add_undefined_type_1 (type); 4475 } 4476 4477 /* Try to fix all undefined types pushed on the UNDEF_TYPES vector. */ 4478 4479 static void 4480 cleanup_undefined_types_noname (struct objfile *objfile) 4481 { 4482 int i; 4483 4484 for (i = 0; i < noname_undefs_length; i++) 4485 { 4486 struct nat nat = noname_undefs[i]; 4487 struct type **type; 4488 4489 type = dbx_lookup_type (nat.typenums, objfile); 4490 if (nat.type != *type && TYPE_CODE (*type) != TYPE_CODE_UNDEF) 4491 { 4492 /* The instance flags of the undefined type are still unset, 4493 and needs to be copied over from the reference type. 4494 Since replace_type expects them to be identical, we need 4495 to set these flags manually before hand. */ 4496 TYPE_INSTANCE_FLAGS (nat.type) = TYPE_INSTANCE_FLAGS (*type); 4497 replace_type (nat.type, *type); 4498 } 4499 } 4500 4501 noname_undefs_length = 0; 4502 } 4503 4504 /* Go through each undefined type, see if it's still undefined, and fix it 4505 up if possible. We have two kinds of undefined types: 4506 4507 TYPE_CODE_ARRAY: Array whose target type wasn't defined yet. 4508 Fix: update array length using the element bounds 4509 and the target type's length. 4510 TYPE_CODE_STRUCT, TYPE_CODE_UNION: Structure whose fields were not 4511 yet defined at the time a pointer to it was made. 4512 Fix: Do a full lookup on the struct/union tag. */ 4513 4514 static void 4515 cleanup_undefined_types_1 (void) 4516 { 4517 struct type **type; 4518 4519 /* Iterate over every undefined type, and look for a symbol whose type 4520 matches our undefined type. The symbol matches if: 4521 1. It is a typedef in the STRUCT domain; 4522 2. It has the same name, and same type code; 4523 3. The instance flags are identical. 4524 4525 It is important to check the instance flags, because we have seen 4526 examples where the debug info contained definitions such as: 4527 4528 "foo_t:t30=B31=xefoo_t:" 4529 4530 In this case, we have created an undefined type named "foo_t" whose 4531 instance flags is null (when processing "xefoo_t"), and then created 4532 another type with the same name, but with different instance flags 4533 ('B' means volatile). I think that the definition above is wrong, 4534 since the same type cannot be volatile and non-volatile at the same 4535 time, but we need to be able to cope with it when it happens. The 4536 approach taken here is to treat these two types as different. */ 4537 4538 for (type = undef_types; type < undef_types + undef_types_length; type++) 4539 { 4540 switch (TYPE_CODE (*type)) 4541 { 4542 4543 case TYPE_CODE_STRUCT: 4544 case TYPE_CODE_UNION: 4545 case TYPE_CODE_ENUM: 4546 { 4547 /* Check if it has been defined since. Need to do this here 4548 as well as in check_typedef to deal with the (legitimate in 4549 C though not C++) case of several types with the same name 4550 in different source files. */ 4551 if (TYPE_STUB (*type)) 4552 { 4553 struct pending *ppt; 4554 int i; 4555 /* Name of the type, without "struct" or "union". */ 4556 char *typename = TYPE_TAG_NAME (*type); 4557 4558 if (typename == NULL) 4559 { 4560 complaint (&symfile_complaints, _("need a type name")); 4561 break; 4562 } 4563 for (ppt = file_symbols; ppt; ppt = ppt->next) 4564 { 4565 for (i = 0; i < ppt->nsyms; i++) 4566 { 4567 struct symbol *sym = ppt->symbol[i]; 4568 4569 if (SYMBOL_CLASS (sym) == LOC_TYPEDEF 4570 && SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN 4571 && (TYPE_CODE (SYMBOL_TYPE (sym)) == 4572 TYPE_CODE (*type)) 4573 && (TYPE_INSTANCE_FLAGS (*type) == 4574 TYPE_INSTANCE_FLAGS (SYMBOL_TYPE (sym))) 4575 && strcmp (SYMBOL_LINKAGE_NAME (sym), 4576 typename) == 0) 4577 replace_type (*type, SYMBOL_TYPE (sym)); 4578 } 4579 } 4580 } 4581 } 4582 break; 4583 4584 default: 4585 { 4586 complaint (&symfile_complaints, 4587 _("forward-referenced types left unresolved, " 4588 "type code %d."), 4589 TYPE_CODE (*type)); 4590 } 4591 break; 4592 } 4593 } 4594 4595 undef_types_length = 0; 4596 } 4597 4598 /* Try to fix all the undefined types we ecountered while processing 4599 this unit. */ 4600 4601 void 4602 cleanup_undefined_types (struct objfile *objfile) 4603 { 4604 cleanup_undefined_types_1 (); 4605 cleanup_undefined_types_noname (objfile); 4606 } 4607 4608 /* Scan through all of the global symbols defined in the object file, 4609 assigning values to the debugging symbols that need to be assigned 4610 to. Get these symbols from the minimal symbol table. */ 4611 4612 void 4613 scan_file_globals (struct objfile *objfile) 4614 { 4615 int hash; 4616 struct minimal_symbol *msymbol; 4617 struct symbol *sym, *prev; 4618 struct objfile *resolve_objfile; 4619 4620 /* SVR4 based linkers copy referenced global symbols from shared 4621 libraries to the main executable. 4622 If we are scanning the symbols for a shared library, try to resolve 4623 them from the minimal symbols of the main executable first. */ 4624 4625 if (symfile_objfile && objfile != symfile_objfile) 4626 resolve_objfile = symfile_objfile; 4627 else 4628 resolve_objfile = objfile; 4629 4630 while (1) 4631 { 4632 /* Avoid expensive loop through all minimal symbols if there are 4633 no unresolved symbols. */ 4634 for (hash = 0; hash < HASHSIZE; hash++) 4635 { 4636 if (global_sym_chain[hash]) 4637 break; 4638 } 4639 if (hash >= HASHSIZE) 4640 return; 4641 4642 ALL_OBJFILE_MSYMBOLS (resolve_objfile, msymbol) 4643 { 4644 QUIT; 4645 4646 /* Skip static symbols. */ 4647 switch (MSYMBOL_TYPE (msymbol)) 4648 { 4649 case mst_file_text: 4650 case mst_file_data: 4651 case mst_file_bss: 4652 continue; 4653 default: 4654 break; 4655 } 4656 4657 prev = NULL; 4658 4659 /* Get the hash index and check all the symbols 4660 under that hash index. */ 4661 4662 hash = hashname (SYMBOL_LINKAGE_NAME (msymbol)); 4663 4664 for (sym = global_sym_chain[hash]; sym;) 4665 { 4666 if (strcmp (SYMBOL_LINKAGE_NAME (msymbol), 4667 SYMBOL_LINKAGE_NAME (sym)) == 0) 4668 { 4669 /* Splice this symbol out of the hash chain and 4670 assign the value we have to it. */ 4671 if (prev) 4672 { 4673 SYMBOL_VALUE_CHAIN (prev) = SYMBOL_VALUE_CHAIN (sym); 4674 } 4675 else 4676 { 4677 global_sym_chain[hash] = SYMBOL_VALUE_CHAIN (sym); 4678 } 4679 4680 /* Check to see whether we need to fix up a common block. */ 4681 /* Note: this code might be executed several times for 4682 the same symbol if there are multiple references. */ 4683 if (sym) 4684 { 4685 if (SYMBOL_CLASS (sym) == LOC_BLOCK) 4686 { 4687 fix_common_block (sym, 4688 SYMBOL_VALUE_ADDRESS (msymbol)); 4689 } 4690 else 4691 { 4692 SYMBOL_VALUE_ADDRESS (sym) 4693 = SYMBOL_VALUE_ADDRESS (msymbol); 4694 } 4695 SYMBOL_SECTION (sym) = SYMBOL_SECTION (msymbol); 4696 } 4697 4698 if (prev) 4699 { 4700 sym = SYMBOL_VALUE_CHAIN (prev); 4701 } 4702 else 4703 { 4704 sym = global_sym_chain[hash]; 4705 } 4706 } 4707 else 4708 { 4709 prev = sym; 4710 sym = SYMBOL_VALUE_CHAIN (sym); 4711 } 4712 } 4713 } 4714 if (resolve_objfile == objfile) 4715 break; 4716 resolve_objfile = objfile; 4717 } 4718 4719 /* Change the storage class of any remaining unresolved globals to 4720 LOC_UNRESOLVED and remove them from the chain. */ 4721 for (hash = 0; hash < HASHSIZE; hash++) 4722 { 4723 sym = global_sym_chain[hash]; 4724 while (sym) 4725 { 4726 prev = sym; 4727 sym = SYMBOL_VALUE_CHAIN (sym); 4728 4729 /* Change the symbol address from the misleading chain value 4730 to address zero. */ 4731 SYMBOL_VALUE_ADDRESS (prev) = 0; 4732 4733 /* Complain about unresolved common block symbols. */ 4734 if (SYMBOL_CLASS (prev) == LOC_STATIC) 4735 SYMBOL_CLASS (prev) = LOC_UNRESOLVED; 4736 else 4737 complaint (&symfile_complaints, 4738 _("%s: common block `%s' from " 4739 "global_sym_chain unresolved"), 4740 objfile->name, SYMBOL_PRINT_NAME (prev)); 4741 } 4742 } 4743 memset (global_sym_chain, 0, sizeof (global_sym_chain)); 4744 } 4745 4746 /* Initialize anything that needs initializing when starting to read 4747 a fresh piece of a symbol file, e.g. reading in the stuff corresponding 4748 to a psymtab. */ 4749 4750 void 4751 stabsread_init (void) 4752 { 4753 } 4754 4755 /* Initialize anything that needs initializing when a completely new 4756 symbol file is specified (not just adding some symbols from another 4757 file, e.g. a shared library). */ 4758 4759 void 4760 stabsread_new_init (void) 4761 { 4762 /* Empty the hash table of global syms looking for values. */ 4763 memset (global_sym_chain, 0, sizeof (global_sym_chain)); 4764 } 4765 4766 /* Initialize anything that needs initializing at the same time as 4767 start_symtab() is called. */ 4768 4769 void 4770 start_stabs (void) 4771 { 4772 global_stabs = NULL; /* AIX COFF */ 4773 /* Leave FILENUM of 0 free for builtin types and this file's types. */ 4774 n_this_object_header_files = 1; 4775 type_vector_length = 0; 4776 type_vector = (struct type **) 0; 4777 4778 /* FIXME: If common_block_name is not already NULL, we should complain(). */ 4779 common_block_name = NULL; 4780 } 4781 4782 /* Call after end_symtab(). */ 4783 4784 void 4785 end_stabs (void) 4786 { 4787 if (type_vector) 4788 { 4789 xfree (type_vector); 4790 } 4791 type_vector = 0; 4792 type_vector_length = 0; 4793 previous_stab_code = 0; 4794 } 4795 4796 void 4797 finish_global_stabs (struct objfile *objfile) 4798 { 4799 if (global_stabs) 4800 { 4801 patch_block_stabs (global_symbols, global_stabs, objfile); 4802 xfree (global_stabs); 4803 global_stabs = NULL; 4804 } 4805 } 4806 4807 /* Find the end of the name, delimited by a ':', but don't match 4808 ObjC symbols which look like -[Foo bar::]:bla. */ 4809 static char * 4810 find_name_end (char *name) 4811 { 4812 char *s = name; 4813 4814 if (s[0] == '-' || *s == '+') 4815 { 4816 /* Must be an ObjC method symbol. */ 4817 if (s[1] != '[') 4818 { 4819 error (_("invalid symbol name \"%s\""), name); 4820 } 4821 s = strchr (s, ']'); 4822 if (s == NULL) 4823 { 4824 error (_("invalid symbol name \"%s\""), name); 4825 } 4826 return strchr (s, ':'); 4827 } 4828 else 4829 { 4830 return strchr (s, ':'); 4831 } 4832 } 4833 4834 /* Initializer for this module. */ 4835 4836 void 4837 _initialize_stabsread (void) 4838 { 4839 rs6000_builtin_type_data = register_objfile_data (); 4840 4841 undef_types_allocated = 20; 4842 undef_types_length = 0; 4843 undef_types = (struct type **) 4844 xmalloc (undef_types_allocated * sizeof (struct type *)); 4845 4846 noname_undefs_allocated = 20; 4847 noname_undefs_length = 0; 4848 noname_undefs = (struct nat *) 4849 xmalloc (noname_undefs_allocated * sizeof (struct nat)); 4850 } 4851