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