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