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