1 /* Support routines for decoding "stabs" debugging information format.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
21 /* Support routines for reading and decoding debugging information in
22 the "stabs" format. This format is used with many systems that use
23 the a.out object file format, as well as some systems that use
24 COFF or ELF where the stabs data is placed in a special section.
25 Avoid placing any object file format specific code in this file. */
32 #include "symfile.h" /* Needed for "struct complaint" */
34 #include "aout/stab_gnu.h" /* We always use GNU stabs, not native */
37 /* Ask stabsread.h to define the vars it normally declares `extern'. */
39 #include "stabsread.h" /* Our own declarations */
43 dbx_alloc_type
PARAMS ((int [2], struct objfile
*));
46 read_huge_number
PARAMS ((char **, int, long *, int *));
49 patch_block_stabs
PARAMS ((struct pending
*, struct pending_stabs
*,
53 fix_common_block
PARAMS ((struct symbol
*, int));
56 read_range_type
PARAMS ((char **, int [2], struct objfile
*));
59 read_sun_builtin_type
PARAMS ((char **, int [2], struct objfile
*));
62 read_sun_floating_type
PARAMS ((char **, int [2], struct objfile
*));
65 read_enum_type
PARAMS ((char **, struct type
*, struct objfile
*));
68 read_struct_type
PARAMS ((char **, struct type
*, struct objfile
*));
71 read_array_type
PARAMS ((char **, struct type
*, struct objfile
*));
74 read_args
PARAMS ((char **, int, struct objfile
*));
76 static const char vptr_name
[] = { '_','v','p','t','r',CPLUS_MARKER
,'\0' };
77 static const char vb_name
[] = { '_','v','b',CPLUS_MARKER
,'\0' };
79 /* Define this as 1 if a pcc declaration of a char or short argument
80 gives the correct address. Otherwise assume pcc gives the
81 address of the corresponding int, which is not the same on a
82 big-endian machine. */
84 #ifndef BELIEVE_PCC_PROMOTION
85 #define BELIEVE_PCC_PROMOTION 0
88 /* During some calls to read_type (and thus to read_range_type), this
89 contains the name of the type being defined. Range types are only
90 used in C as basic types. We use the name to distinguish the otherwise
91 identical basic types "int" and "long" and their unsigned versions.
92 FIXME, this should disappear with better type management. */
94 static char *long_kludge_name
;
97 struct complaint dbx_class_complaint
=
99 "encountered DBX-style class variable debugging information.\n\
100 You seem to have compiled your program with \
101 \"g++ -g0\" instead of \"g++ -g\".\n\
102 Therefore GDB will not know about your class variables", 0, 0
106 struct complaint invalid_cpp_abbrev_complaint
=
107 {"invalid C++ abbreviation `%s'", 0, 0};
109 struct complaint invalid_cpp_type_complaint
=
110 {"C++ abbreviated type name unknown at symtab pos %d", 0, 0};
112 struct complaint member_fn_complaint
=
113 {"member function type missing, got '%c'", 0, 0};
115 struct complaint const_vol_complaint
=
116 {"const/volatile indicator missing, got '%c'", 0, 0};
118 struct complaint error_type_complaint
=
119 {"debug info mismatch between compiler and debugger", 0, 0};
121 struct complaint invalid_member_complaint
=
122 {"invalid (minimal) member type data format at symtab pos %d.", 0, 0};
124 struct complaint range_type_base_complaint
=
125 {"base type %d of range type is not defined", 0, 0};
127 struct complaint reg_value_complaint
=
128 {"register number too large in symbol %s", 0, 0};
130 /* Make a list of forward references which haven't been defined. */
132 static struct type
**undef_types
;
133 static int undef_types_allocated
;
134 static int undef_types_length
;
141 register char *p
= name
;
142 register int total
= p
[0];
157 /* Ensure result is positive. */
160 total
+= (1000 << 6);
162 return (total
% HASHSIZE
);
166 /* Look up a dbx type-number pair. Return the address of the slot
167 where the type for that number-pair is stored.
168 The number-pair is in TYPENUMS.
170 This can be used for finding the type associated with that pair
171 or for associating a new type with the pair. */
174 dbx_lookup_type (typenums
)
177 register int filenum
= typenums
[0];
178 register int index
= typenums
[1];
180 register int real_filenum
;
181 register struct header_file
*f
;
184 if (filenum
== -1) /* -1,-1 is for temporary types. */
187 if (filenum
< 0 || filenum
>= n_this_object_header_files
)
188 error ("Invalid symbol data: type number (%d,%d) out of range at symtab pos %d.",
189 filenum
, index
, symnum
);
193 /* Type is defined outside of header files.
194 Find it in this object file's type vector. */
195 if (index
>= type_vector_length
)
197 old_len
= type_vector_length
;
200 type_vector_length
= INITIAL_TYPE_VECTOR_LENGTH
;
201 type_vector
= (struct type
**)
202 malloc (type_vector_length
* sizeof (struct type
*));
204 while (index
>= type_vector_length
)
206 type_vector_length
*= 2;
208 type_vector
= (struct type
**)
209 xrealloc ((char *) type_vector
,
210 (type_vector_length
* sizeof (struct type
*)));
211 memset (&type_vector
[old_len
], 0,
212 (type_vector_length
- old_len
) * sizeof (struct type
*));
214 return (&type_vector
[index
]);
218 real_filenum
= this_object_header_files
[filenum
];
220 if (real_filenum
>= n_header_files
)
225 f
= &header_files
[real_filenum
];
227 f_orig_length
= f
->length
;
228 if (index
>= f_orig_length
)
230 while (index
>= f
->length
)
234 f
->vector
= (struct type
**)
235 xrealloc ((char *) f
->vector
, f
->length
* sizeof (struct type
*));
236 memset (&f
->vector
[f_orig_length
], 0,
237 (f
->length
- f_orig_length
) * sizeof (struct type
*));
239 return (&f
->vector
[index
]);
243 /* Make sure there is a type allocated for type numbers TYPENUMS
244 and return the type object.
245 This can create an empty (zeroed) type object.
246 TYPENUMS may be (-1, -1) to return a new type object that is not
247 put into the type vector, and so may not be referred to by number. */
250 dbx_alloc_type (typenums
, objfile
)
252 struct objfile
*objfile
;
254 register struct type
**type_addr
;
256 if (typenums
[0] == -1)
258 return (alloc_type (objfile
));
261 type_addr
= dbx_lookup_type (typenums
);
263 /* If we are referring to a type not known at all yet,
264 allocate an empty type for it.
265 We will fill it in later if we find out how. */
268 *type_addr
= alloc_type (objfile
);
274 /* for all the stabs in a given stab vector, build appropriate types
275 and fix their symbols in given symbol vector. */
278 patch_block_stabs (symbols
, stabs
, objfile
)
279 struct pending
*symbols
;
280 struct pending_stabs
*stabs
;
281 struct objfile
*objfile
;
291 /* for all the stab entries, find their corresponding symbols and
292 patch their types! */
294 for (ii
= 0; ii
< stabs
->count
; ++ii
)
296 name
= stabs
->stab
[ii
];
297 pp
= (char*) strchr (name
, ':');
298 sym
= find_symbol_in_list (symbols
, name
, pp
-name
);
301 #ifndef IBM6000_TARGET
302 printf ("ERROR! stab symbol not found!\n"); /* FIXME */
308 if (*(pp
-1) == 'F' || *(pp
-1) == 'f')
311 lookup_function_type (read_type (&pp
, objfile
));
315 SYMBOL_TYPE (sym
) = read_type (&pp
, objfile
);
323 /* Read a number by which a type is referred to in dbx data,
324 or perhaps read a pair (FILENUM, TYPENUM) in parentheses.
325 Just a single number N is equivalent to (0,N).
326 Return the two numbers by storing them in the vector TYPENUMS.
327 TYPENUMS will then be used as an argument to dbx_lookup_type. */
330 read_type_number (pp
, typenums
)
332 register int *typenums
;
337 typenums
[0] = read_number (pp
, ',');
338 typenums
[1] = read_number (pp
, ')');
343 typenums
[1] = read_number (pp
, 0);
348 /* To handle GNU C++ typename abbreviation, we need to be able to
349 fill in a type's name as soon as space for that type is allocated.
350 `type_synonym_name' is the name of the type being allocated.
351 It is cleared as soon as it is used (lest all allocated types
354 static char *type_synonym_name
;
358 define_symbol (valu
, string
, desc
, type
, objfile
)
363 struct objfile
*objfile
;
365 register struct symbol
*sym
;
366 char *p
= (char *) strchr (string
, ':');
370 struct type
*temptype
;
372 /* We would like to eliminate nameless symbols, but keep their types.
373 E.g. stab entry ":t10=*2" should produce a type 10, which is a pointer
374 to type 2, but, should not creat a symbol to address that type. Since
375 the symbol will be nameless, there is no way any user can refer to it. */
379 /* Ignore syms with empty names. */
383 /* Ignore old-style symbols from cc -go */
387 /* If a nameless stab entry, all we need is the type, not the symbol.
389 nameless
= (p
== string
);
391 sym
= (struct symbol
*)
392 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
393 memset (sym
, 0, sizeof (struct symbol
));
395 if (processing_gcc_compilation
)
397 /* GCC 2.x puts the line number in desc. SunOS apparently puts in the
398 number of bytes occupied by a type or object, which we ignore. */
399 SYMBOL_LINE(sym
) = desc
;
403 SYMBOL_LINE(sym
) = 0; /* unknown */
406 if (string
[0] == CPLUS_MARKER
)
408 /* Special GNU C++ names. */
412 SYMBOL_NAME (sym
) = obsavestring ("this", strlen ("this"),
413 &objfile
-> symbol_obstack
);
416 case 'v': /* $vtbl_ptr_type */
417 /* Was: SYMBOL_NAME (sym) = "vptr"; */
421 SYMBOL_NAME (sym
) = obsavestring ("eh_throw", strlen ("eh_throw"),
422 &objfile
-> symbol_obstack
);
426 /* This was an anonymous type that was never fixed up. */
436 SYMBOL_NAME (sym
) = (char *)
437 obstack_alloc (&objfile
-> symbol_obstack
, ((p
- string
) + 1));
438 /* Open-coded bcopy--saves function call time. */
440 register char *p1
= string
;
441 register char *p2
= SYMBOL_NAME (sym
);
451 /* Determine the type of name being defined. */
452 /* The Acorn RISC machine's compiler can put out locals that don't
453 start with "234=" or "(3,4)=", so assume anything other than the
454 deftypes we know how to handle is a local. */
455 if (!strchr ("cfFGpPrStTvVXCR", *p
))
460 /* c is a special case, not followed by a type-number.
461 SYMBOL:c=iVALUE for an integer constant symbol.
462 SYMBOL:c=rVALUE for a floating constant symbol.
463 SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
464 e.g. "b:c=e6,0" for "const b = blob1"
465 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
469 error ("Invalid symbol data at symtab pos %d.", symnum
);
477 SYMBOL_TYPE (sym
) = lookup_fundamental_type (objfile
,
480 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (double));
481 memcpy (dbl_valu
, &d
, sizeof (double));
482 SWAP_TARGET_AND_HOST (dbl_valu
, sizeof (double));
483 SYMBOL_VALUE_BYTES (sym
) = dbl_valu
;
484 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
489 SYMBOL_TYPE (sym
) = lookup_fundamental_type (objfile
,
491 SYMBOL_VALUE (sym
) = atoi (p
);
492 SYMBOL_CLASS (sym
) = LOC_CONST
;
496 /* SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
497 e.g. "b:c=e6,0" for "const b = blob1"
498 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
502 read_type_number (&p
, typenums
);
504 error ("Invalid symbol data: no comma in enum const symbol");
506 SYMBOL_TYPE (sym
) = *dbx_lookup_type (typenums
);
507 SYMBOL_VALUE (sym
) = atoi (p
);
508 SYMBOL_CLASS (sym
) = LOC_CONST
;
512 error ("Invalid symbol data at symtab pos %d.", symnum
);
514 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
515 add_symbol_to_list (sym
, &file_symbols
);
519 /* Now usually comes a number that says which data type,
520 and possibly more stuff to define the type
521 (all of which is handled by read_type) */
523 if (deftype
== 'p' && *p
== 'F')
524 /* pF is a two-letter code that means a function parameter in Fortran.
525 The type-number specifies the type of the return value.
526 Translate it into a pointer-to-function type. */
530 = lookup_pointer_type (lookup_function_type (read_type (&p
, objfile
)));
534 /* The symbol class letter is followed by a type (typically the
535 type of the symbol, or its return-type, or etc). Read it. */
542 type_synonym_name
= obsavestring (SYMBOL_NAME (sym
),
543 strlen (SYMBOL_NAME (sym
)),
544 &objfile
-> symbol_obstack
);
547 /* Here we save the name of the symbol for read_range_type, which
548 ends up reading in the basic types. In stabs, unfortunately there
549 is no distinction between "int" and "long" types except their
550 names. Until we work out a saner type policy (eliminating most
551 builtin types and using the names specified in the files), we
552 save away the name so that far away from here in read_range_type,
553 we can examine it to decide between "int" and "long". FIXME. */
554 long_kludge_name
= SYMBOL_NAME (sym
);
556 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
562 /* The name of a caught exception. */
563 SYMBOL_CLASS (sym
) = LOC_LABEL
;
564 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
565 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
566 add_symbol_to_list (sym
, &local_symbols
);
570 /* A static function definition. */
571 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
572 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
573 add_symbol_to_list (sym
, &file_symbols
);
574 /* fall into process_function_types. */
576 process_function_types
:
577 /* Function result types are described as the result type in stabs.
578 We need to convert this to the function-returning-type-X type
579 in GDB. E.g. "int" is converted to "function returning int". */
580 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_FUNC
)
583 /* This code doesn't work -- it needs to realloc and can't. */
584 /* Attempt to set up to record a function prototype... */
585 struct type
*new = alloc_type (objfile
);
587 /* Generate a template for the type of this function. The
588 types of the arguments will be added as we read the symbol
590 *new = *lookup_function_type (SYMBOL_TYPE(sym
));
591 SYMBOL_TYPE(sym
) = new;
592 TYPE_OBJFILE (new) = objfile
;
593 in_function_type
= new;
595 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
598 /* fall into process_prototype_types */
600 process_prototype_types
:
601 /* Sun acc puts declared types of arguments here. We don't care
602 about their actual types (FIXME -- we should remember the whole
603 function prototype), but the list may define some new types
604 that we have to remember, so we must scan it now. */
607 read_type (&p
, objfile
);
612 /* A global function definition. */
613 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
614 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
615 add_symbol_to_list (sym
, &global_symbols
);
616 goto process_function_types
;
619 /* For a class G (global) symbol, it appears that the
620 value is not correct. It is necessary to search for the
621 corresponding linker definition to find the value.
622 These definitions appear at the end of the namelist. */
623 i
= hashname (SYMBOL_NAME (sym
));
624 SYMBOL_VALUE_CHAIN (sym
) = global_sym_chain
[i
];
625 global_sym_chain
[i
] = sym
;
626 SYMBOL_CLASS (sym
) = LOC_STATIC
;
627 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
628 add_symbol_to_list (sym
, &global_symbols
);
631 /* This case is faked by a conditional above,
632 when there is no code letter in the dbx data.
633 Dbx data never actually contains 'l'. */
635 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
636 SYMBOL_VALUE (sym
) = valu
;
637 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
638 add_symbol_to_list (sym
, &local_symbols
);
642 /* Normally this is a parameter, a LOC_ARG. On the i960, it
643 can also be a LOC_LOCAL_ARG depending on symbol type. */
644 #ifndef DBX_PARM_SYMBOL_CLASS
645 #define DBX_PARM_SYMBOL_CLASS(type) LOC_ARG
647 SYMBOL_CLASS (sym
) = DBX_PARM_SYMBOL_CLASS (type
);
648 SYMBOL_VALUE (sym
) = valu
;
649 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
651 /* This doesn't work yet. */
652 add_param_to_type (&in_function_type
, sym
);
654 add_symbol_to_list (sym
, &local_symbols
);
656 /* If it's gcc-compiled, if it says `short', believe it. */
657 if (processing_gcc_compilation
|| BELIEVE_PCC_PROMOTION
)
660 #if defined(BELIEVE_PCC_PROMOTION_TYPE)
661 /* This macro is defined on machines (e.g. sparc) where
662 we should believe the type of a PCC 'short' argument,
663 but shouldn't believe the address (the address is
664 the address of the corresponding int). Note that
665 this is only different from the BELIEVE_PCC_PROMOTION
666 case on big-endian machines.
668 My guess is that this correction, as opposed to changing
669 the parameter to an 'int' (as done below, for PCC
670 on most machines), is the right thing to do
671 on all machines, but I don't want to risk breaking
672 something that already works. On most PCC machines,
673 the sparc problem doesn't come up because the calling
674 function has to zero the top bytes (not knowing whether
675 the called function wants an int or a short), so there
676 is no practical difference between an int and a short
677 (except perhaps what happens when the GDB user types
678 "print short_arg = 0x10000;").
680 Hacked for SunOS 4.1 by gnu@cygnus.com. In 4.1, the compiler
681 actually produces the correct address (we don't need to fix it
682 up). I made this code adapt so that it will offset the symbol
683 if it was pointing at an int-aligned location and not
684 otherwise. This way you can use the same gdb for 4.0.x and
687 If the parameter is shorter than an int, and is integral
688 (e.g. char, short, or unsigned equivalent), and is claimed to
689 be passed on an integer boundary, don't believe it! Offset the
690 parameter's address to the tail-end of that integer. */
692 temptype
= lookup_fundamental_type (objfile
, FT_INTEGER
);
693 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (temptype
)
694 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
695 && 0 == SYMBOL_VALUE (sym
) % TYPE_LENGTH (temptype
))
697 SYMBOL_VALUE (sym
) += TYPE_LENGTH (temptype
)
698 - TYPE_LENGTH (SYMBOL_TYPE (sym
));
702 #else /* no BELIEVE_PCC_PROMOTION_TYPE. */
704 /* If PCC says a parameter is a short or a char,
705 it is really an int. */
706 temptype
= lookup_fundamental_type (objfile
, FT_INTEGER
);
707 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (temptype
)
708 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
)
710 SYMBOL_TYPE (sym
) = TYPE_UNSIGNED (SYMBOL_TYPE (sym
))
711 ? lookup_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
)
716 #endif /* no BELIEVE_PCC_PROMOTION_TYPE. */
719 /* acc seems to use P to delare the prototypes of functions that
720 are referenced by this file. gdb is not prepared to deal
721 with this extra information. FIXME, it ought to. */
723 goto process_prototype_types
;
725 /* Parameter which is in a register. */
726 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
727 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (valu
);
728 if (SYMBOL_VALUE (sym
) >= NUM_REGS
)
730 complain (®_value_complaint
, SYMBOL_NAME (sym
));
731 SYMBOL_VALUE (sym
) = SP_REGNUM
; /* Known safe, though useless */
733 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
734 add_symbol_to_list (sym
, &local_symbols
);
739 /* Register variable (either global or local). */
740 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
741 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (valu
);
742 if (SYMBOL_VALUE (sym
) >= NUM_REGS
)
744 complain (®_value_complaint
, SYMBOL_NAME (sym
));
745 SYMBOL_VALUE (sym
) = SP_REGNUM
; /* Known safe, though useless */
747 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
749 add_symbol_to_list (sym
, &local_symbols
);
751 add_symbol_to_list (sym
, &file_symbols
);
755 /* Static symbol at top level of file */
756 SYMBOL_CLASS (sym
) = LOC_STATIC
;
757 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
758 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
759 add_symbol_to_list (sym
, &file_symbols
);
763 /* For a nameless type, we don't want a create a symbol, thus we
764 did not use `sym'. Return without further processing. */
765 if (nameless
) return NULL
;
767 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
768 SYMBOL_VALUE (sym
) = valu
;
769 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
770 /* C++ vagaries: we may have a type which is derived from
771 a base type which did not have its name defined when the
772 derived class was output. We fill in the derived class's
773 base part member's name here in that case. */
774 if (TYPE_NAME (SYMBOL_TYPE (sym
)) != NULL
)
775 if ((TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
776 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_UNION
)
777 && TYPE_N_BASECLASSES (SYMBOL_TYPE (sym
)))
780 for (j
= TYPE_N_BASECLASSES (SYMBOL_TYPE (sym
)) - 1; j
>= 0; j
--)
781 if (TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym
), j
) == 0)
782 TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym
), j
) =
783 type_name_no_tag (TYPE_BASECLASS (SYMBOL_TYPE (sym
), j
));
786 add_symbol_to_list (sym
, &file_symbols
);
790 /* For a nameless type, we don't want a create a symbol, thus we
791 did not use `sym'. Return without further processing. */
792 if (nameless
) return NULL
;
794 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
795 SYMBOL_VALUE (sym
) = valu
;
796 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
797 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
798 TYPE_NAME (SYMBOL_TYPE (sym
))
799 = obconcat (&objfile
-> type_obstack
, "",
800 (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_ENUM
802 : (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
803 ? "struct " : "union ")),
805 add_symbol_to_list (sym
, &file_symbols
);
809 register struct symbol
*typedef_sym
= (struct symbol
*)
810 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
811 memset (typedef_sym
, 0, sizeof (struct symbol
));
812 SYMBOL_NAME (typedef_sym
) = SYMBOL_NAME (sym
);
813 SYMBOL_TYPE (typedef_sym
) = SYMBOL_TYPE (sym
);
815 SYMBOL_CLASS (typedef_sym
) = LOC_TYPEDEF
;
816 SYMBOL_VALUE (typedef_sym
) = valu
;
817 SYMBOL_NAMESPACE (typedef_sym
) = VAR_NAMESPACE
;
818 add_symbol_to_list (typedef_sym
, &file_symbols
);
823 /* Static symbol of local scope */
824 SYMBOL_CLASS (sym
) = LOC_STATIC
;
825 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
826 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
827 add_symbol_to_list (sym
, &local_symbols
);
831 /* Reference parameter */
832 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
833 SYMBOL_VALUE (sym
) = valu
;
834 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
835 add_symbol_to_list (sym
, &local_symbols
);
839 /* This is used by Sun FORTRAN for "function result value".
840 Sun claims ("dbx and dbxtool interfaces", 2nd ed)
841 that Pascal uses it too, but when I tried it Pascal used
842 "x:3" (local symbol) instead. */
843 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
844 SYMBOL_VALUE (sym
) = valu
;
845 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
846 add_symbol_to_list (sym
, &local_symbols
);
850 error ("Invalid symbol data: unknown symbol-type code `%c' at symtab pos %d.", deftype
, symnum
);
856 /* Skip rest of this symbol and return an error type.
858 General notes on error recovery: error_type always skips to the
859 end of the symbol (modulo cretinous dbx symbol name continuation).
863 return error_type (pp);
865 is wrong because if *pp starts out pointing at '\0' (typically as the
866 result of an earlier error), it will be incremented to point to the
867 start of the next symbol, which might produce strange results, at least
868 if you run off the end of the string table. Instead use
871 return error_type (pp);
877 foo = error_type (pp);
881 And in case it isn't obvious, the point of all this hair is so the compiler
882 can define new types and new syntaxes, and old versions of the
883 debugger will be able to read the new symbol tables. */
889 complain (&error_type_complaint
, 0);
892 /* Skip to end of symbol. */
896 /* Check for and handle cretinous dbx symbol name continuation! */
897 if ((*pp
)[-1] == '\\')
898 *pp
= next_symbol_text ();
902 return builtin_type_error
;
906 /* Read a dbx type reference or definition;
907 return the type that is meant.
908 This can be just a number, in which case it references
909 a type already defined and placed in type_vector.
910 Or the number can be followed by an =, in which case
911 it means to define a new type according to the text that
915 read_type (pp
, objfile
)
917 struct objfile
*objfile
;
919 register struct type
*type
= 0;
924 /* Read type number if present. The type number may be omitted.
925 for instance in a two-dimensional array declared with type
926 "ar1;1;10;ar1;1;10;4". */
927 if ((**pp
>= '0' && **pp
<= '9')
930 read_type_number (pp
, typenums
);
932 /* Type is not being defined here. Either it already exists,
933 or this is a forward reference to it. dbx_alloc_type handles
936 return dbx_alloc_type (typenums
, objfile
);
938 /* Type is being defined here. */
939 #if 0 /* Callers aren't prepared for a NULL result! FIXME -- metin! */
943 /* if such a type already exists, this is an unnecessary duplication
944 of the stab string, which is common in (RS/6000) xlc generated
945 objects. In that case, simply return NULL and let the caller take
948 tt
= *dbx_lookup_type (typenums
);
949 if (tt
&& tt
->length
&& tt
->code
)
958 /* 'typenums=' not present, type is anonymous. Read and return
959 the definition, but don't put it in the type vector. */
960 typenums
[0] = typenums
[1] = -1;
970 /* Used to index through file_symbols. */
974 /* Name including "struct", etc. */
977 /* Name without "struct", etc. */
978 char *type_name_only
;
984 /* Set the type code according to the following letter. */
988 code
= TYPE_CODE_STRUCT
;
992 code
= TYPE_CODE_UNION
;
996 code
= TYPE_CODE_ENUM
;
1000 return error_type (pp
);
1003 to
= type_name
= (char *)
1004 obstack_alloc (&objfile
-> type_obstack
,
1006 ((char *) strchr (*pp
, ':') - (*pp
)) + 1));
1008 /* Copy the prefix. */
1010 while (*to
++ = *from
++)
1014 type_name_only
= to
;
1016 /* Copy the name. */
1018 while ((*to
++ = *from
++) != ':')
1022 /* Set the pointer ahead of the name which we just read. */
1026 /* The following hack is clearly wrong, because it doesn't
1027 check whether we are in a baseclass. I tried to reproduce
1028 the case that it is trying to fix, but I couldn't get
1029 g++ to put out a cross reference to a basetype. Perhaps
1030 it doesn't do it anymore. */
1031 /* Note: for C++, the cross reference may be to a base type which
1032 has not yet been seen. In this case, we skip to the comma,
1033 which will mark the end of the base class name. (The ':'
1034 at the end of the base class name will be skipped as well.)
1035 But sometimes (ie. when the cross ref is the last thing on
1036 the line) there will be no ','. */
1037 from
= (char *) strchr (*pp
, ',');
1043 /* Now check to see whether the type has already been declared. */
1044 /* This is necessary at least in the case where the
1045 program says something like
1047 The compiler puts out a cross-reference; we better find
1048 set the length of the structure correctly so we can
1049 set the length of the array. */
1050 for (ppt
= file_symbols
; ppt
; ppt
= ppt
->next
)
1051 for (i
= 0; i
< ppt
->nsyms
; i
++)
1053 struct symbol
*sym
= ppt
->symbol
[i
];
1055 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
1056 && SYMBOL_NAMESPACE (sym
) == STRUCT_NAMESPACE
1057 && (TYPE_CODE (SYMBOL_TYPE (sym
)) == code
)
1058 && !strcmp (SYMBOL_NAME (sym
), type_name_only
))
1060 obstack_free (&objfile
-> type_obstack
, type_name
);
1061 type
= SYMBOL_TYPE (sym
);
1066 /* Didn't find the type to which this refers, so we must
1067 be dealing with a forward reference. Allocate a type
1068 structure for it, and keep track of it so we can
1069 fill in the rest of the fields when we get the full
1071 type
= dbx_alloc_type (typenums
, objfile
);
1072 TYPE_CODE (type
) = code
;
1073 TYPE_NAME (type
) = type_name
;
1074 INIT_CPLUS_SPECIFIC(type
);
1075 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
1077 add_undefined_type (type
);
1081 case '-': /* RS/6000 built-in type */
1083 type
= builtin_type (pp
); /* (in xcoffread.c) */
1098 read_type_number (pp
, xtypenums
);
1099 type
= *dbx_lookup_type (xtypenums
);
1104 type
= lookup_fundamental_type (objfile
, FT_VOID
);
1105 if (typenums
[0] != -1)
1106 *dbx_lookup_type (typenums
) = type
;
1109 /* In the following types, we must be sure to overwrite any existing
1110 type that the typenums refer to, rather than allocating a new one
1111 and making the typenums point to the new one. This is because there
1112 may already be pointers to the existing type (if it had been
1113 forward-referenced), and we must change it to a pointer, function,
1114 reference, or whatever, *in-place*. */
1117 type1
= read_type (pp
, objfile
);
1118 type
= make_pointer_type (type1
, dbx_lookup_type (typenums
));
1121 case '&': /* Reference to another type */
1122 type1
= read_type (pp
, objfile
);
1123 type
= make_reference_type (type1
, dbx_lookup_type (typenums
));
1126 case 'f': /* Function returning another type */
1127 type1
= read_type (pp
, objfile
);
1128 type
= make_function_type (type1
, dbx_lookup_type (typenums
));
1131 case 'k': /* Const qualifier on some type (Sun) */
1132 type
= read_type (pp
, objfile
);
1133 /* FIXME! For now, we ignore const and volatile qualifiers. */
1136 case 'B': /* Volatile qual on some type (Sun) */
1137 type
= read_type (pp
, objfile
);
1138 /* FIXME! For now, we ignore const and volatile qualifiers. */
1141 /* FIXME -- we should be doing smash_to_XXX types here. */
1142 case '@': /* Member (class & variable) type */
1144 struct type
*domain
= read_type (pp
, objfile
);
1145 struct type
*memtype
;
1148 /* Invalid member type data format. */
1149 return error_type (pp
);
1152 memtype
= read_type (pp
, objfile
);
1153 type
= dbx_alloc_type (typenums
, objfile
);
1154 smash_to_member_type (type
, domain
, memtype
);
1158 case '#': /* Method (class & fn) type */
1159 if ((*pp
)[0] == '#')
1161 /* We'll get the parameter types from the name. */
1162 struct type
*return_type
;
1165 return_type
= read_type (pp
, objfile
);
1166 if (*(*pp
)++ != ';')
1167 complain (&invalid_member_complaint
, (char *) symnum
);
1168 type
= allocate_stub_method (return_type
);
1169 if (typenums
[0] != -1)
1170 *dbx_lookup_type (typenums
) = type
;
1174 struct type
*domain
= read_type (pp
, objfile
);
1175 struct type
*return_type
;
1178 if (*(*pp
)++ != ',')
1179 error ("invalid member type data format, at symtab pos %d.",
1182 return_type
= read_type (pp
, objfile
);
1183 args
= read_args (pp
, ';', objfile
);
1184 type
= dbx_alloc_type (typenums
, objfile
);
1185 smash_to_method_type (type
, domain
, return_type
, args
);
1189 case 'r': /* Range type */
1190 type
= read_range_type (pp
, typenums
, objfile
);
1191 if (typenums
[0] != -1)
1192 *dbx_lookup_type (typenums
) = type
;
1195 case 'b': /* Sun ACC builtin int type */
1196 type
= read_sun_builtin_type (pp
, typenums
, objfile
);
1197 if (typenums
[0] != -1)
1198 *dbx_lookup_type (typenums
) = type
;
1201 case 'R': /* Sun ACC builtin float type */
1202 type
= read_sun_floating_type (pp
, typenums
, objfile
);
1203 if (typenums
[0] != -1)
1204 *dbx_lookup_type (typenums
) = type
;
1207 case 'e': /* Enumeration type */
1208 type
= dbx_alloc_type (typenums
, objfile
);
1209 type
= read_enum_type (pp
, type
, objfile
);
1210 *dbx_lookup_type (typenums
) = type
;
1213 case 's': /* Struct type */
1214 type
= dbx_alloc_type (typenums
, objfile
);
1215 if (!TYPE_NAME (type
))
1216 TYPE_NAME (type
) = type_synonym_name
;
1217 type_synonym_name
= 0;
1218 type
= read_struct_type (pp
, type
, objfile
);
1221 case 'u': /* Union type */
1222 type
= dbx_alloc_type (typenums
, objfile
);
1223 if (!TYPE_NAME (type
))
1224 TYPE_NAME (type
) = type_synonym_name
;
1225 type_synonym_name
= 0;
1226 type
= read_struct_type (pp
, type
, objfile
);
1227 TYPE_CODE (type
) = TYPE_CODE_UNION
;
1230 case 'a': /* Array type */
1232 return error_type (pp
);
1235 type
= dbx_alloc_type (typenums
, objfile
);
1236 type
= read_array_type (pp
, type
, objfile
);
1240 --*pp
; /* Go back to the symbol in error */
1241 /* Particularly important if it was \0! */
1242 return error_type (pp
);
1251 /* This page contains subroutines of read_type. */
1253 /* Read the description of a structure (or union type)
1254 and return an object describing the type. */
1256 static struct type
*
1257 read_struct_type (pp
, type
, objfile
)
1259 register struct type
*type
;
1260 struct objfile
*objfile
;
1262 /* Total number of methods defined in this class.
1263 If the class defines two `f' methods, and one `g' method,
1264 then this will have the value 3. */
1265 int total_length
= 0;
1269 struct nextfield
*next
;
1270 int visibility
; /* 0=public, 1=protected, 2=public */
1276 struct next_fnfield
*next
;
1277 struct fn_field fn_field
;
1280 struct next_fnfieldlist
1282 struct next_fnfieldlist
*next
;
1283 struct fn_fieldlist fn_fieldlist
;
1286 register struct nextfield
*list
= 0;
1287 struct nextfield
*new;
1290 int non_public_fields
= 0;
1293 register struct next_fnfieldlist
*mainlist
= 0;
1296 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
1297 INIT_CPLUS_SPECIFIC(type
);
1298 TYPE_FLAGS (type
) &= ~TYPE_FLAG_STUB
;
1300 /* First comes the total size in bytes. */
1302 TYPE_LENGTH (type
) = read_number (pp
, 0);
1304 /* C++: Now, if the class is a derived class, then the next character
1305 will be a '!', followed by the number of base classes derived from.
1306 Each element in the list contains visibility information,
1307 the offset of this base class in the derived structure,
1308 and then the base type. */
1311 int i
, n_baseclasses
, offset
;
1312 struct type
*baseclass
;
1315 /* Nonzero if it is a virtual baseclass, i.e.,
1319 struct C : public B, public virtual A {};
1321 B is a baseclass of C; A is a virtual baseclass for C. This is a C++
1322 2.0 language feature. */
1327 ALLOCATE_CPLUS_STRUCT_TYPE(type
);
1329 n_baseclasses
= read_number (pp
, ',');
1330 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*)
1331 TYPE_ALLOC (type
, B_BYTES (n_baseclasses
));
1332 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), n_baseclasses
);
1334 for (i
= 0; i
< n_baseclasses
; i
++)
1337 *pp
= next_symbol_text ();
1348 /* Bad visibility format. */
1349 return error_type (pp
);
1357 non_public_fields
++;
1363 /* Bad visibility format. */
1364 return error_type (pp
);
1367 SET_TYPE_FIELD_VIRTUAL (type
, i
);
1370 /* Offset of the portion of the object corresponding to
1371 this baseclass. Always zero in the absence of
1372 multiple inheritance. */
1373 offset
= read_number (pp
, ',');
1374 baseclass
= read_type (pp
, objfile
);
1375 *pp
+= 1; /* skip trailing ';' */
1377 /* Make this baseclass visible for structure-printing purposes. */
1378 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1379 memset (new, 0, sizeof (struct nextfield
));
1382 list
->visibility
= via_public
;
1383 list
->field
.type
= baseclass
;
1384 list
->field
.name
= type_name_no_tag (baseclass
);
1385 list
->field
.bitpos
= offset
;
1386 list
->field
.bitsize
= 0; /* this should be an unpacked field! */
1389 TYPE_N_BASECLASSES (type
) = n_baseclasses
;
1392 /* Now come the fields, as NAME:?TYPENUM,BITPOS,BITSIZE; for each one.
1393 At the end, we see a semicolon instead of a field.
1395 In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
1398 The `?' is a placeholder for one of '/2' (public visibility),
1399 '/1' (protected visibility), '/0' (private visibility), or nothing
1400 (C style symbol table, public visibility). */
1402 /* We better set p right now, in case there are no fields at all... */
1407 /* Check for and handle cretinous dbx symbol name continuation! */
1408 if (**pp
== '\\') *pp
= next_symbol_text ();
1410 /* Get space to record the next field's data. */
1411 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1412 memset (new, 0, sizeof (struct nextfield
));
1416 /* Get the field name. */
1418 if (*p
== CPLUS_MARKER
)
1420 /* Special GNU C++ name. */
1425 struct type
*context
;
1436 complain (&invalid_cpp_abbrev_complaint
, *pp
);
1437 prefix
= "INVALID_C++_ABBREV";
1441 context
= read_type (pp
, objfile
);
1442 name
= type_name_no_tag (context
);
1445 complain (&invalid_cpp_type_complaint
, (char *) symnum
);
1448 list
->field
.name
= obconcat (&objfile
-> type_obstack
,
1452 complain (&invalid_cpp_abbrev_complaint
, *pp
);
1453 list
->field
.type
= read_type (pp
, objfile
);
1454 (*pp
)++; /* Skip the comma. */
1455 list
->field
.bitpos
= read_number (pp
, ';');
1456 /* This field is unpacked. */
1457 list
->field
.bitsize
= 0;
1458 list
->visibility
= 0; /* private */
1459 non_public_fields
++;
1461 /* GNU C++ anonymous type. */
1465 complain (&invalid_cpp_abbrev_complaint
, *pp
);
1471 while (*p
!= ':') p
++;
1472 list
->field
.name
= obsavestring (*pp
, p
- *pp
,
1473 &objfile
-> type_obstack
);
1475 /* C++: Check to see if we have hit the methods yet. */
1481 /* This means we have a visibility for a field coming. */
1487 list
->visibility
= 0; /* private */
1488 non_public_fields
++;
1493 list
->visibility
= 1; /* protected */
1494 non_public_fields
++;
1499 list
->visibility
= 2; /* public */
1504 else /* normal dbx-style format. */
1505 list
->visibility
= 2; /* public */
1507 list
->field
.type
= read_type (pp
, objfile
);
1512 /* Possible future hook for nested types. */
1515 list
->field
.bitpos
= (long)-2; /* nested type */
1520 { /* Static class member. */
1521 list
->field
.bitpos
= (long)-1;
1523 while (*p
!= ';') p
++;
1524 list
->field
.bitsize
= (long) savestring (*pp
, p
- *pp
);
1529 else if (**pp
!= ',')
1530 /* Bad structure-type format. */
1531 return error_type (pp
);
1533 (*pp
)++; /* Skip the comma. */
1534 list
->field
.bitpos
= read_number (pp
, ',');
1535 list
->field
.bitsize
= read_number (pp
, ';');
1538 /* FIXME-tiemann: Can't the compiler put out something which
1539 lets us distinguish these? (or maybe just not put out anything
1540 for the field). What is the story here? What does the compiler
1541 really do? Also, patch gdb.texinfo for this case; I document
1542 it as a possible problem there. Search for "DBX-style". */
1544 /* This is wrong because this is identical to the symbols
1545 produced for GCC 0-size arrays. For example:
1550 The code which dumped core in such circumstances should be
1551 fixed not to dump core. */
1553 /* g++ -g0 can put out bitpos & bitsize zero for a static
1554 field. This does not give us any way of getting its
1555 class, so we can't know its name. But we can just
1556 ignore the field so we don't dump core and other nasty
1558 if (list
->field
.bitpos
== 0
1559 && list
->field
.bitsize
== 0)
1561 complain (&dbx_class_complaint
, 0);
1562 /* Ignore this field. */
1568 /* Detect an unpacked field and mark it as such.
1569 dbx gives a bit size for all fields.
1570 Note that forward refs cannot be packed,
1571 and treat enums as if they had the width of ints. */
1572 if (TYPE_CODE (list
->field
.type
) != TYPE_CODE_INT
1573 && TYPE_CODE (list
->field
.type
) != TYPE_CODE_ENUM
)
1574 list
->field
.bitsize
= 0;
1575 if ((list
->field
.bitsize
== 8 * TYPE_LENGTH (list
->field
.type
)
1576 || (TYPE_CODE (list
->field
.type
) == TYPE_CODE_ENUM
1577 && (list
->field
.bitsize
1578 == 8 * TYPE_LENGTH (lookup_fundamental_type (objfile
, FT_INTEGER
)))
1582 list
->field
.bitpos
% 8 == 0)
1583 list
->field
.bitsize
= 0;
1589 /* chill the list of fields: the last entry (at the head)
1590 is a partially constructed entry which we now scrub. */
1593 /* Now create the vector of fields, and record how big it is.
1594 We need this info to record proper virtual function table information
1595 for this class's virtual functions. */
1597 TYPE_NFIELDS (type
) = nfields
;
1598 TYPE_FIELDS (type
) = (struct field
*)
1599 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
1600 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
1602 if (non_public_fields
)
1604 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
1606 TYPE_FIELD_PRIVATE_BITS (type
) = (B_TYPE
*)
1607 TYPE_ALLOC (type
, B_BYTES (nfields
));
1608 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
1610 TYPE_FIELD_PROTECTED_BITS (type
) = (B_TYPE
*)
1611 TYPE_ALLOC (type
, B_BYTES (nfields
));
1612 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
1615 /* Copy the saved-up fields into the field vector. */
1617 for (n
= nfields
; list
; list
= list
->next
)
1620 TYPE_FIELD (type
, n
) = list
->field
;
1621 if (list
->visibility
== 0)
1622 SET_TYPE_FIELD_PRIVATE (type
, n
);
1623 else if (list
->visibility
== 1)
1624 SET_TYPE_FIELD_PROTECTED (type
, n
);
1627 /* Now come the method fields, as NAME::methods
1628 where each method is of the form TYPENUM,ARGS,...:PHYSNAME;
1629 At the end, we see a semicolon instead of a field.
1631 For the case of overloaded operators, the format is
1632 op$::*.methods, where $ is the CPLUS_MARKER (usually '$'),
1633 `*' holds the place for an operator name (such as `+=')
1634 and `.' marks the end of the operator name. */
1637 /* Now, read in the methods. To simplify matters, we
1638 "unread" the name that has been read, so that we can
1639 start from the top. */
1641 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
1642 /* For each list of method lists... */
1646 struct next_fnfield
*sublist
= 0;
1647 struct type
*look_ahead_type
= NULL
;
1649 struct next_fnfieldlist
*new_mainlist
;
1652 new_mainlist
= (struct next_fnfieldlist
*)
1653 alloca (sizeof (struct next_fnfieldlist
));
1654 memset (new_mainlist
, 0, sizeof (struct next_fnfieldlist
));
1658 /* read in the name. */
1659 while (*p
!= ':') p
++;
1660 if ((*pp
)[0] == 'o' && (*pp
)[1] == 'p' && (*pp
)[2] == CPLUS_MARKER
)
1662 /* This is a completely wierd case. In order to stuff in the
1663 names that might contain colons (the usual name delimiter),
1664 Mike Tiemann defined a different name format which is
1665 signalled if the identifier is "op$". In that case, the
1666 format is "op$::XXXX." where XXXX is the name. This is
1667 used for names like "+" or "=". YUUUUUUUK! FIXME! */
1668 /* This lets the user type "break operator+".
1669 We could just put in "+" as the name, but that wouldn't
1671 static char opname
[32] = {'o', 'p', CPLUS_MARKER
};
1672 char *o
= opname
+ 3;
1674 /* Skip past '::'. */
1676 if (**pp
== '\\') *pp
= next_symbol_text ();
1680 main_fn_name
= savestring (opname
, o
- opname
);
1686 main_fn_name
= savestring (*pp
, p
- *pp
);
1687 /* Skip past '::'. */
1690 new_mainlist
->fn_fieldlist
.name
= main_fn_name
;
1694 struct next_fnfield
*new_sublist
=
1695 (struct next_fnfield
*) alloca (sizeof (struct next_fnfield
));
1696 memset (new_sublist
, 0, sizeof (struct next_fnfield
));
1698 /* Check for and handle cretinous dbx symbol name continuation! */
1699 if (look_ahead_type
== NULL
) /* Normal case. */
1701 if (**pp
== '\\') *pp
= next_symbol_text ();
1703 new_sublist
->fn_field
.type
= read_type (pp
, objfile
);
1705 /* Invalid symtab info for method. */
1706 return error_type (pp
);
1709 { /* g++ version 1 kludge */
1710 new_sublist
->fn_field
.type
= look_ahead_type
;
1711 look_ahead_type
= NULL
;
1716 while (*p
!= ';') p
++;
1718 /* If this is just a stub, then we don't have the
1720 if (TYPE_FLAGS (new_sublist
->fn_field
.type
) & TYPE_FLAG_STUB
)
1721 new_sublist
->fn_field
.is_stub
= 1;
1722 new_sublist
->fn_field
.physname
= savestring (*pp
, p
- *pp
);
1725 /* Set this method's visibility fields. */
1726 switch (*(*pp
)++ - '0')
1729 new_sublist
->fn_field
.is_private
= 1;
1732 new_sublist
->fn_field
.is_protected
= 1;
1736 if (**pp
== '\\') *pp
= next_symbol_text ();
1739 case 'A': /* Normal functions. */
1740 new_sublist
->fn_field
.is_const
= 0;
1741 new_sublist
->fn_field
.is_volatile
= 0;
1744 case 'B': /* `const' member functions. */
1745 new_sublist
->fn_field
.is_const
= 1;
1746 new_sublist
->fn_field
.is_volatile
= 0;
1749 case 'C': /* `volatile' member function. */
1750 new_sublist
->fn_field
.is_const
= 0;
1751 new_sublist
->fn_field
.is_volatile
= 1;
1754 case 'D': /* `const volatile' member function. */
1755 new_sublist
->fn_field
.is_const
= 1;
1756 new_sublist
->fn_field
.is_volatile
= 1;
1759 case '*': /* File compiled with g++ version 1 -- no info */
1764 complain (&const_vol_complaint
, (char *) (long) **pp
);
1771 /* virtual member function, followed by index. */
1772 /* The sign bit is set to distinguish pointers-to-methods
1773 from virtual function indicies. Since the array is
1774 in words, the quantity must be shifted left by 1
1775 on 16 bit machine, and by 2 on 32 bit machine, forcing
1776 the sign bit out, and usable as a valid index into
1777 the array. Remove the sign bit here. */
1778 new_sublist
->fn_field
.voffset
=
1779 (0x7fffffff & read_number (pp
, ';')) + 2;
1781 if (**pp
== '\\') *pp
= next_symbol_text ();
1783 if (**pp
== ';' || **pp
== '\0')
1784 /* Must be g++ version 1. */
1785 new_sublist
->fn_field
.fcontext
= 0;
1788 /* Figure out from whence this virtual function came.
1789 It may belong to virtual function table of
1790 one of its baseclasses. */
1791 look_ahead_type
= read_type (pp
, objfile
);
1793 { /* g++ version 1 overloaded methods. */ }
1796 new_sublist
->fn_field
.fcontext
= look_ahead_type
;
1798 return error_type (pp
);
1801 look_ahead_type
= NULL
;
1807 /* static member function. */
1808 new_sublist
->fn_field
.voffset
= VOFFSET_STATIC
;
1809 if (strncmp (new_sublist
->fn_field
.physname
,
1810 main_fn_name
, strlen (main_fn_name
)))
1811 new_sublist
->fn_field
.is_stub
= 1;
1816 complain (&member_fn_complaint
, (char *) (long) (*pp
)[-1]);
1817 /* Fall through into normal member function. */
1820 /* normal member function. */
1821 new_sublist
->fn_field
.voffset
= 0;
1822 new_sublist
->fn_field
.fcontext
= 0;
1826 new_sublist
->next
= sublist
;
1827 sublist
= new_sublist
;
1829 if (**pp
== '\\') *pp
= next_symbol_text ();
1831 while (**pp
!= ';' && **pp
!= '\0');
1835 new_mainlist
->fn_fieldlist
.fn_fields
= (struct fn_field
*)
1836 obstack_alloc (&objfile
-> type_obstack
,
1837 sizeof (struct fn_field
) * length
);
1838 memset (new_mainlist
->fn_fieldlist
.fn_fields
, 0,
1839 sizeof (struct fn_field
) * length
);
1840 for (i
= length
; (i
--, sublist
); sublist
= sublist
->next
)
1841 new_mainlist
->fn_fieldlist
.fn_fields
[i
] = sublist
->fn_field
;
1843 new_mainlist
->fn_fieldlist
.length
= length
;
1844 new_mainlist
->next
= mainlist
;
1845 mainlist
= new_mainlist
;
1847 total_length
+= length
;
1848 if (**pp
== '\\') *pp
= next_symbol_text ();
1850 while (**pp
!= ';');
1858 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
1859 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * nfn_fields
);
1860 memset (TYPE_FN_FIELDLISTS (type
), 0,
1861 sizeof (struct fn_fieldlist
) * nfn_fields
);
1862 TYPE_NFN_FIELDS (type
) = nfn_fields
;
1863 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
1868 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); ++i
)
1870 if (TYPE_CODE (TYPE_BASECLASS (type
, i
)) == TYPE_CODE_UNDEF
)
1871 /* @@ Memory leak on objfile->type_obstack? */
1872 return error_type (pp
);
1873 TYPE_NFN_FIELDS_TOTAL (type
) +=
1874 TYPE_NFN_FIELDS_TOTAL (TYPE_BASECLASS (type
, i
));
1878 for (n
= nfn_fields
; mainlist
; mainlist
= mainlist
->next
) {
1879 --n
; /* Circumvent Sun3 compiler bug */
1880 TYPE_FN_FIELDLISTS (type
)[n
] = mainlist
->fn_fieldlist
;
1887 if (**pp
== '=' || **pp
== '+' || **pp
== '-')
1889 /* Obsolete flags that used to indicate the presence
1890 of constructors and/or destructors. */
1894 /* Read either a '%' or the final ';'. */
1895 if (*(*pp
)++ == '%')
1897 /* We'd like to be able to derive the vtable pointer field
1898 from the type information, but when it's inherited, that's
1899 hard. A reason it's hard is because we may read in the
1900 info about a derived class before we read in info about
1901 the base class that provides the vtable pointer field.
1902 Once the base info has been read, we could fill in the info
1903 for the derived classes, but for the fact that by then,
1904 we don't remember who needs what. */
1907 int predicted_fieldno
= -1;
1910 /* Now we must record the virtual function table pointer's
1911 field information. */
1919 /* In version 2, we derive the vfield ourselves. */
1920 for (n
= 0; n
< nfields
; n
++)
1922 if (! strncmp (TYPE_FIELD_NAME (type
, n
), vptr_name
,
1923 sizeof (vptr_name
) -1))
1925 predicted_fieldno
= n
;
1929 if (predicted_fieldno
< 0)
1930 for (n
= 0; n
< TYPE_N_BASECLASSES (type
); n
++)
1931 if (! TYPE_FIELD_VIRTUAL (type
, n
)
1932 && TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, n
)) >= 0)
1934 predicted_fieldno
= TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, n
));
1940 t
= read_type (pp
, objfile
);
1942 while (*p
!= '\0' && *p
!= ';')
1945 /* Premature end of symbol. */
1946 return error_type (pp
);
1948 TYPE_VPTR_BASETYPE (type
) = t
;
1951 if (TYPE_FIELD_NAME (t
, TYPE_N_BASECLASSES (t
)) == 0)
1953 /* FIXME-tiemann: what's this? */
1955 TYPE_VPTR_FIELDNO (type
) = i
= TYPE_N_BASECLASSES (t
);
1960 else for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); --i
)
1961 if (! strncmp (TYPE_FIELD_NAME (t
, i
), vptr_name
,
1962 sizeof (vptr_name
) - 1))
1964 TYPE_VPTR_FIELDNO (type
) = i
;
1968 /* Virtual function table field not found. */
1969 return error_type (pp
);
1972 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
1975 if (TYPE_VPTR_FIELDNO (type
) != predicted_fieldno
)
1976 error ("TYPE_VPTR_FIELDNO miscalculated");
1986 /* Read a definition of an array type,
1987 and create and return a suitable type object.
1988 Also creates a range type which represents the bounds of that
1991 static struct type
*
1992 read_array_type (pp
, type
, objfile
)
1994 register struct type
*type
;
1995 struct objfile
*objfile
;
1997 struct type
*index_type
, *element_type
, *range_type
;
2001 /* Format of an array type:
2002 "ar<index type>;lower;upper;<array_contents_type>". Put code in
2005 Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
2006 for these, produce a type like float[][]. */
2008 index_type
= read_type (pp
, objfile
);
2010 /* Improper format of array type decl. */
2011 return error_type (pp
);
2014 if (!(**pp
>= '0' && **pp
<= '9'))
2019 lower
= read_number (pp
, ';');
2021 if (!(**pp
>= '0' && **pp
<= '9'))
2026 upper
= read_number (pp
, ';');
2028 element_type
= read_type (pp
, objfile
);
2037 /* Create range type. */
2038 range_type
= alloc_type (objfile
);
2039 TYPE_CODE (range_type
) = TYPE_CODE_RANGE
;
2040 TYPE_TARGET_TYPE (range_type
) = index_type
;
2042 /* This should never be needed. */
2043 TYPE_LENGTH (range_type
) = sizeof (int);
2045 TYPE_NFIELDS (range_type
) = 2;
2046 TYPE_FIELDS (range_type
) = (struct field
*)
2047 TYPE_ALLOC (range_type
, 2 * sizeof (struct field
));
2048 memset (TYPE_FIELDS (range_type
), 0, 2 * sizeof (struct field
));
2049 TYPE_FIELD_BITPOS (range_type
, 0) = lower
;
2050 TYPE_FIELD_BITPOS (range_type
, 1) = upper
;
2053 TYPE_CODE (type
) = TYPE_CODE_ARRAY
;
2054 TYPE_TARGET_TYPE (type
) = element_type
;
2055 TYPE_LENGTH (type
) = (upper
- lower
+ 1) * TYPE_LENGTH (element_type
);
2056 TYPE_NFIELDS (type
) = 1;
2057 TYPE_FIELDS (type
) = (struct field
*)
2058 TYPE_ALLOC (type
, sizeof (struct field
));
2059 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
));
2060 TYPE_FIELD_TYPE (type
, 0) = range_type
;
2062 /* If we have an array whose element type is not yet known, but whose
2063 bounds *are* known, record it to be adjusted at the end of the file. */
2064 if (TYPE_LENGTH (element_type
) == 0 && !adjustable
)
2065 add_undefined_type (type
);
2071 /* Read a definition of an enumeration type,
2072 and create and return a suitable type object.
2073 Also defines the symbols that represent the values of the type. */
2075 static struct type
*
2076 read_enum_type (pp
, type
, objfile
)
2078 register struct type
*type
;
2079 struct objfile
*objfile
;
2084 register struct symbol
*sym
;
2086 struct pending
**symlist
;
2087 struct pending
*osyms
, *syms
;
2091 /* FIXME! The stabs produced by Sun CC merrily define things that ought
2092 to be file-scope, between N_FN entries, using N_LSYM. What's a mother
2093 to do? For now, force all enum values to file scope. */
2094 if (within_function
)
2095 symlist
= &local_symbols
;
2098 symlist
= &file_symbols
;
2100 o_nsyms
= osyms
? osyms
->nsyms
: 0;
2102 /* Read the value-names and their values.
2103 The input syntax is NAME:VALUE,NAME:VALUE, and so on.
2104 A semicolon or comma instead of a NAME means the end. */
2105 while (**pp
&& **pp
!= ';' && **pp
!= ',')
2107 /* Check for and handle cretinous dbx symbol name continuation! */
2108 if (**pp
== '\\') *pp
= next_symbol_text ();
2111 while (*p
!= ':') p
++;
2112 name
= obsavestring (*pp
, p
- *pp
, &objfile
-> symbol_obstack
);
2114 n
= read_number (pp
, ',');
2116 sym
= (struct symbol
*)
2117 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
2118 memset (sym
, 0, sizeof (struct symbol
));
2119 SYMBOL_NAME (sym
) = name
;
2120 SYMBOL_CLASS (sym
) = LOC_CONST
;
2121 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2122 SYMBOL_VALUE (sym
) = n
;
2123 add_symbol_to_list (sym
, symlist
);
2128 (*pp
)++; /* Skip the semicolon. */
2130 /* Now fill in the fields of the type-structure. */
2132 TYPE_LENGTH (type
) = sizeof (int);
2133 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
2134 TYPE_FLAGS (type
) &= ~TYPE_FLAG_STUB
;
2135 TYPE_NFIELDS (type
) = nsyms
;
2136 TYPE_FIELDS (type
) = (struct field
*)
2137 TYPE_ALLOC (type
, sizeof (struct field
) * nsyms
);
2138 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nsyms
);
2140 /* Find the symbols for the values and put them into the type.
2141 The symbols can be found in the symlist that we put them on
2142 to cause them to be defined. osyms contains the old value
2143 of that symlist; everything up to there was defined by us. */
2144 /* Note that we preserve the order of the enum constants, so
2145 that in something like "enum {FOO, LAST_THING=FOO}" we print
2146 FOO, not LAST_THING. */
2148 for (syms
= *symlist
, n
= 0; syms
; syms
= syms
->next
)
2153 for (; j
< syms
->nsyms
; j
++,n
++)
2155 struct symbol
*xsym
= syms
->symbol
[j
];
2156 SYMBOL_TYPE (xsym
) = type
;
2157 TYPE_FIELD_NAME (type
, n
) = SYMBOL_NAME (xsym
);
2158 TYPE_FIELD_VALUE (type
, n
) = 0;
2159 TYPE_FIELD_BITPOS (type
, n
) = SYMBOL_VALUE (xsym
);
2160 TYPE_FIELD_BITSIZE (type
, n
) = 0;
2167 /* This screws up perfectly good C programs with enums. FIXME. */
2168 /* Is this Modula-2's BOOLEAN type? Flag it as such if so. */
2169 if(TYPE_NFIELDS(type
) == 2 &&
2170 ((!strcmp(TYPE_FIELD_NAME(type
,0),"TRUE") &&
2171 !strcmp(TYPE_FIELD_NAME(type
,1),"FALSE")) ||
2172 (!strcmp(TYPE_FIELD_NAME(type
,1),"TRUE") &&
2173 !strcmp(TYPE_FIELD_NAME(type
,0),"FALSE"))))
2174 TYPE_CODE(type
) = TYPE_CODE_BOOL
;
2180 /* Sun's ACC uses a somewhat saner method for specifying the builtin
2181 typedefs in every file (for int, long, etc):
2183 type = b <signed> <width>; <offset>; <nbits>
2184 signed = u or s. Possible c in addition to u or s (for char?).
2185 offset = offset from high order bit to start bit of type.
2186 width is # bytes in object of this type, nbits is # bits in type.
2188 The width/offset stuff appears to be for small objects stored in
2189 larger ones (e.g. `shorts' in `int' registers). We ignore it for now,
2192 static struct type
*
2193 read_sun_builtin_type (pp
, typenums
, objfile
)
2196 struct objfile
*objfile
;
2210 return error_type (pp
);
2214 /* For some odd reason, all forms of char put a c here. This is strange
2215 because no other type has this honor. We can safely ignore this because
2216 we actually determine 'char'acterness by the number of bits specified in
2222 /* The first number appears to be the number of bytes occupied
2223 by this type, except that unsigned short is 4 instead of 2.
2224 Since this information is redundant with the third number,
2225 we will ignore it. */
2226 read_number (pp
, ';');
2228 /* The second number is always 0, so ignore it too. */
2229 read_number (pp
, ';');
2231 /* The third number is the number of bits for this type. */
2232 nbits
= read_number (pp
, 0);
2234 /* FIXME. Here we should just be able to make a type of the right
2235 number of bits and signedness. FIXME. */
2237 if (nbits
== TARGET_LONG_LONG_BIT
)
2238 return (lookup_fundamental_type (objfile
,
2239 signed_type
? FT_LONG_LONG
: FT_UNSIGNED_LONG_LONG
));
2241 if (nbits
== TARGET_INT_BIT
)
2243 /* FIXME -- the only way to distinguish `int' from `long'
2244 is to look at its name! */
2247 if (long_kludge_name
&& long_kludge_name
[0] == 'l' /* long */)
2248 return lookup_fundamental_type (objfile
, FT_LONG
);
2250 return lookup_fundamental_type (objfile
, FT_INTEGER
);
2254 if (long_kludge_name
2255 && ((long_kludge_name
[0] == 'u' /* unsigned */ &&
2256 long_kludge_name
[9] == 'l' /* long */)
2257 || (long_kludge_name
[0] == 'l' /* long unsigned */)))
2258 return lookup_fundamental_type (objfile
, FT_UNSIGNED_LONG
);
2260 return lookup_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
);
2264 if (nbits
== TARGET_SHORT_BIT
)
2265 return (lookup_fundamental_type (objfile
,
2266 signed_type
? FT_SHORT
: FT_UNSIGNED_SHORT
));
2268 if (nbits
== TARGET_CHAR_BIT
)
2269 return (lookup_fundamental_type (objfile
,
2270 signed_type
? FT_CHAR
: FT_UNSIGNED_CHAR
));
2273 return lookup_fundamental_type (objfile
, FT_VOID
);
2275 return error_type (pp
);
2278 static struct type
*
2279 read_sun_floating_type (pp
, typenums
, objfile
)
2282 struct objfile
*objfile
;
2286 /* The first number has more details about the type, for example
2287 FN_COMPLEX. See the sun stab.h. */
2288 read_number (pp
, ';');
2290 /* The second number is the number of bytes occupied by this type */
2291 nbytes
= read_number (pp
, ';');
2294 return error_type (pp
);
2296 if (nbytes
== TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
)
2297 return lookup_fundamental_type (objfile
, FT_FLOAT
);
2299 if (nbytes
== TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
)
2300 return lookup_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
);
2302 if (nbytes
== TARGET_LONG_DOUBLE_BIT
/ TARGET_CHAR_BIT
)
2303 return lookup_fundamental_type (objfile
, FT_EXT_PREC_FLOAT
);
2305 return error_type (pp
);
2308 /* Read a number from the string pointed to by *PP.
2309 The value of *PP is advanced over the number.
2310 If END is nonzero, the character that ends the
2311 number must match END, or an error happens;
2312 and that character is skipped if it does match.
2313 If END is zero, *PP is left pointing to that character.
2315 If the number fits in a long, set *VALUE and set *BITS to 0.
2316 If not, set *BITS to be the number of bits in the number.
2318 If encounter garbage, set *BITS to -1. */
2321 read_huge_number (pp
, end
, valu
, bits
)
2342 /* Leading zero means octal. GCC uses this to output values larger
2343 than an int (because that would be hard in decimal). */
2350 upper_limit
= LONG_MAX
/ radix
;
2351 while ((c
= *p
++) >= '0' && c
<= ('0' + radix
))
2353 if (n
<= upper_limit
)
2356 n
+= c
- '0'; /* FIXME this overflows anyway */
2361 /* This depends on large values being output in octal, which is
2368 /* Ignore leading zeroes. */
2372 else if (c
== '2' || c
== '3')
2398 /* Large decimal constants are an error (because it is hard to
2399 count how many bits are in them). */
2405 /* -0x7f is the same as 0x80. So deal with it by adding one to
2406 the number of bits. */
2421 static struct type
*
2422 read_range_type (pp
, typenums
, objfile
)
2425 struct objfile
*objfile
;
2431 struct type
*result_type
;
2433 /* First comes a type we are a subrange of.
2434 In C it is usually 0, 1 or the type being defined. */
2435 read_type_number (pp
, rangenums
);
2436 self_subrange
= (rangenums
[0] == typenums
[0] &&
2437 rangenums
[1] == typenums
[1]);
2439 /* A semicolon should now follow; skip it. */
2443 /* The remaining two operands are usually lower and upper bounds
2444 of the range. But in some special cases they mean something else. */
2445 read_huge_number (pp
, ';', &n2
, &n2bits
);
2446 read_huge_number (pp
, ';', &n3
, &n3bits
);
2448 if (n2bits
== -1 || n3bits
== -1)
2449 return error_type (pp
);
2451 /* If limits are huge, must be large integral type. */
2452 if (n2bits
!= 0 || n3bits
!= 0)
2454 char got_signed
= 0;
2455 char got_unsigned
= 0;
2456 /* Number of bits in the type. */
2459 /* Range from 0 to <large number> is an unsigned large integral type. */
2460 if ((n2bits
== 0 && n2
== 0) && n3bits
!= 0)
2465 /* Range from <large number> to <large number>-1 is a large signed
2467 else if (n2bits
!= 0 && n3bits
!= 0 && n2bits
== n3bits
+ 1)
2473 /* Check for "long long". */
2474 if (got_signed
&& nbits
== TARGET_LONG_LONG_BIT
)
2475 return (lookup_fundamental_type (objfile
, FT_LONG_LONG
));
2476 if (got_unsigned
&& nbits
== TARGET_LONG_LONG_BIT
)
2477 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_LONG_LONG
));
2479 if (got_signed
|| got_unsigned
)
2481 result_type
= alloc_type (objfile
);
2482 TYPE_LENGTH (result_type
) = nbits
/ TARGET_CHAR_BIT
;
2483 TYPE_CODE (result_type
) = TYPE_CODE_INT
;
2485 TYPE_FLAGS (result_type
) |= TYPE_FLAG_UNSIGNED
;
2489 return error_type (pp
);
2492 /* A type defined as a subrange of itself, with bounds both 0, is void. */
2493 if (self_subrange
&& n2
== 0 && n3
== 0)
2494 return (lookup_fundamental_type (objfile
, FT_VOID
));
2496 /* If n3 is zero and n2 is not, we want a floating type,
2497 and n2 is the width in bytes.
2499 Fortran programs appear to use this for complex types also,
2500 and they give no way to distinguish between double and single-complex!
2501 We don't have complex types, so we would lose on all fortran files!
2502 So return type `double' for all of those. It won't work right
2503 for the complex values, but at least it makes the file loadable.
2505 FIXME, we may be able to distinguish these by their names. FIXME. */
2507 if (n3
== 0 && n2
> 0)
2509 if (n2
== sizeof (float))
2510 return (lookup_fundamental_type (objfile
, FT_FLOAT
));
2511 return (lookup_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
));
2514 /* If the upper bound is -1, it must really be an unsigned int. */
2516 else if (n2
== 0 && n3
== -1)
2518 /* FIXME -- the only way to distinguish `unsigned int' from `unsigned
2519 long' is to look at its name! */
2521 long_kludge_name
&& ((long_kludge_name
[0] == 'u' /* unsigned */ &&
2522 long_kludge_name
[9] == 'l' /* long */)
2523 || (long_kludge_name
[0] == 'l' /* long unsigned */)))
2524 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_LONG
));
2526 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
));
2529 /* Special case: char is defined (Who knows why) as a subrange of
2530 itself with range 0-127. */
2531 else if (self_subrange
&& n2
== 0 && n3
== 127)
2532 return (lookup_fundamental_type (objfile
, FT_CHAR
));
2534 /* Assumptions made here: Subrange of self is equivalent to subrange
2535 of int. FIXME: Host and target type-sizes assumed the same. */
2536 /* FIXME: This is the *only* place in GDB that depends on comparing
2537 some type to a builtin type with ==. Fix it! */
2539 && (self_subrange
||
2540 *dbx_lookup_type (rangenums
) == lookup_fundamental_type (objfile
, FT_INTEGER
)))
2542 /* an unsigned type */
2544 if (n3
== - sizeof (long long))
2545 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_LONG_LONG
));
2547 /* FIXME -- the only way to distinguish `unsigned int' from `unsigned
2548 long' is to look at its name! */
2549 if (n3
== (unsigned long)~0L &&
2550 long_kludge_name
&& ((long_kludge_name
[0] == 'u' /* unsigned */ &&
2551 long_kludge_name
[9] == 'l' /* long */)
2552 || (long_kludge_name
[0] == 'l' /* long unsigned */)))
2553 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_LONG
));
2554 if (n3
== (unsigned int)~0L)
2555 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
));
2556 if (n3
== (unsigned short)~0L)
2557 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_SHORT
));
2558 if (n3
== (unsigned char)~0L)
2559 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_CHAR
));
2562 else if (n3
== 0 && n2
== -sizeof (long long))
2563 return (lookup_fundamental_type (objfile
, FT_LONG_LONG
));
2565 else if (n2
== -n3
-1)
2568 /* FIXME -- the only way to distinguish `int' from `long' is to look
2570 if ((n3
==(long)(((unsigned long)1 << (8 * sizeof (long) - 1)) - 1)) &&
2571 long_kludge_name
&& long_kludge_name
[0] == 'l' /* long */)
2572 return (lookup_fundamental_type (objfile
, FT_LONG
));
2573 if (n3
== (long)(((unsigned long)1 << (8 * sizeof (int) - 1)) - 1))
2574 return (lookup_fundamental_type (objfile
, FT_INTEGER
));
2575 if (n3
== ( 1 << (8 * sizeof (short) - 1)) - 1)
2576 return (lookup_fundamental_type (objfile
, FT_SHORT
));
2577 if (n3
== ( 1 << (8 * sizeof (char) - 1)) - 1)
2578 return (lookup_fundamental_type (objfile
, FT_SIGNED_CHAR
));
2581 /* We have a real range type on our hands. Allocate space and
2582 return a real pointer. */
2584 /* At this point I don't have the faintest idea how to deal with
2585 a self_subrange type; I'm going to assume that this is used
2586 as an idiom, and that all of them are special cases. So . . . */
2588 return error_type (pp
);
2590 result_type
= alloc_type (objfile
);
2592 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
2594 TYPE_TARGET_TYPE (result_type
) = *dbx_lookup_type(rangenums
);
2595 if (TYPE_TARGET_TYPE (result_type
) == 0) {
2596 complain (&range_type_base_complaint
, (char *) rangenums
[1]);
2597 TYPE_TARGET_TYPE (result_type
) = lookup_fundamental_type (objfile
, FT_INTEGER
);
2600 TYPE_NFIELDS (result_type
) = 2;
2601 TYPE_FIELDS (result_type
) = (struct field
*)
2602 TYPE_ALLOC (result_type
, 2 * sizeof (struct field
));
2603 memset (TYPE_FIELDS (result_type
), 0, 2 * sizeof (struct field
));
2604 TYPE_FIELD_BITPOS (result_type
, 0) = n2
;
2605 TYPE_FIELD_BITPOS (result_type
, 1) = n3
;
2607 TYPE_LENGTH (result_type
) = TYPE_LENGTH (TYPE_TARGET_TYPE (result_type
));
2612 /* Read a number from the string pointed to by *PP.
2613 The value of *PP is advanced over the number.
2614 If END is nonzero, the character that ends the
2615 number must match END, or an error happens;
2616 and that character is skipped if it does match.
2617 If END is zero, *PP is left pointing to that character. */
2620 read_number (pp
, end
)
2624 register char *p
= *pp
;
2625 register long n
= 0;
2629 /* Handle an optional leading minus sign. */
2637 /* Read the digits, as far as they go. */
2639 while ((c
= *p
++) >= '0' && c
<= '9')
2647 error ("Invalid symbol data: invalid character \\%03o at symbol pos %d.", c
, symnum
);
2656 /* Read in an argument list. This is a list of types, separated by commas
2657 and terminated with END. Return the list of types read in, or (struct type
2658 **)-1 if there is an error. */
2660 static struct type
**
2661 read_args (pp
, end
, objfile
)
2664 struct objfile
*objfile
;
2666 /* FIXME! Remove this arbitrary limit! */
2667 struct type
*types
[1024], **rval
; /* allow for fns of 1023 parameters */
2673 /* Invalid argument list: no ','. */
2674 return (struct type
**)-1;
2677 /* Check for and handle cretinous dbx symbol name continuation! */
2679 *pp
= next_symbol_text ();
2681 types
[n
++] = read_type (pp
, objfile
);
2683 *pp
+= 1; /* get past `end' (the ':' character) */
2687 rval
= (struct type
**) xmalloc (2 * sizeof (struct type
*));
2689 else if (TYPE_CODE (types
[n
-1]) != TYPE_CODE_VOID
)
2691 rval
= (struct type
**) xmalloc ((n
+ 1) * sizeof (struct type
*));
2692 memset (rval
+ n
, 0, sizeof (struct type
*));
2696 rval
= (struct type
**) xmalloc (n
* sizeof (struct type
*));
2698 memcpy (rval
, types
, n
* sizeof (struct type
*));
2702 /* Add a common block's start address to the offset of each symbol
2703 declared to be in it (by being between a BCOMM/ECOMM pair that uses
2704 the common block name). */
2707 fix_common_block (sym
, valu
)
2711 struct pending
*next
= (struct pending
*) SYMBOL_NAMESPACE (sym
);
2712 for ( ; next
; next
= next
->next
)
2715 for (j
= next
->nsyms
- 1; j
>= 0; j
--)
2716 SYMBOL_VALUE_ADDRESS (next
->symbol
[j
]) += valu
;
2722 /* What about types defined as forward references inside of a small lexical
2724 /* Add a type to the list of undefined types to be checked through
2725 once this file has been read in. */
2728 add_undefined_type (type
)
2731 if (undef_types_length
== undef_types_allocated
)
2733 undef_types_allocated
*= 2;
2734 undef_types
= (struct type
**)
2735 xrealloc ((char *) undef_types
,
2736 undef_types_allocated
* sizeof (struct type
*));
2738 undef_types
[undef_types_length
++] = type
;
2741 /* Go through each undefined type, see if it's still undefined, and fix it
2742 up if possible. We have two kinds of undefined types:
2744 TYPE_CODE_ARRAY: Array whose target type wasn't defined yet.
2745 Fix: update array length using the element bounds
2746 and the target type's length.
2747 TYPE_CODE_STRUCT, TYPE_CODE_UNION: Structure whose fields were not
2748 yet defined at the time a pointer to it was made.
2749 Fix: Do a full lookup on the struct/union tag. */
2751 cleanup_undefined_types ()
2755 for (type
= undef_types
; type
< undef_types
+ undef_types_length
; type
++)
2757 switch (TYPE_CODE (*type
))
2760 case TYPE_CODE_STRUCT
:
2761 case TYPE_CODE_UNION
:
2762 case TYPE_CODE_ENUM
:
2764 /* Check if it has been defined since. */
2765 if (TYPE_FLAGS (*type
) & TYPE_FLAG_STUB
)
2767 struct pending
*ppt
;
2769 /* Name of the type, without "struct" or "union" */
2770 char *typename
= TYPE_NAME (*type
);
2772 if (!strncmp (typename
, "struct ", 7))
2774 if (!strncmp (typename
, "union ", 6))
2776 if (!strncmp (typename
, "enum ", 5))
2779 for (ppt
= file_symbols
; ppt
; ppt
= ppt
->next
)
2781 for (i
= 0; i
< ppt
->nsyms
; i
++)
2783 struct symbol
*sym
= ppt
->symbol
[i
];
2785 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
2786 && SYMBOL_NAMESPACE (sym
) == STRUCT_NAMESPACE
2787 && (TYPE_CODE (SYMBOL_TYPE (sym
)) ==
2789 && !strcmp (SYMBOL_NAME (sym
), typename
))
2791 memcpy (*type
, SYMBOL_TYPE (sym
),
2792 sizeof (struct type
));
2800 case TYPE_CODE_ARRAY
:
2802 struct type
*range_type
;
2805 if (TYPE_LENGTH (*type
) != 0) /* Better be unknown */
2807 if (TYPE_NFIELDS (*type
) != 1)
2809 range_type
= TYPE_FIELD_TYPE (*type
, 0);
2810 if (TYPE_CODE (range_type
) != TYPE_CODE_RANGE
)
2813 /* Now recompute the length of the array type, based on its
2814 number of elements and the target type's length. */
2815 lower
= TYPE_FIELD_BITPOS (range_type
, 0);
2816 upper
= TYPE_FIELD_BITPOS (range_type
, 1);
2817 TYPE_LENGTH (*type
) = (upper
- lower
+ 1)
2818 * TYPE_LENGTH (TYPE_TARGET_TYPE (*type
));
2824 error ("GDB internal error. cleanup_undefined_types with bad type %d.", TYPE_CODE (*type
));
2828 undef_types_length
= 0;
2831 /* Scan through all of the global symbols defined in the object file,
2832 assigning values to the debugging symbols that need to be assigned
2833 to. Get these symbols from the minimal symbol table. */
2836 scan_file_globals (objfile
)
2837 struct objfile
*objfile
;
2840 struct minimal_symbol
*msymbol
;
2841 struct symbol
*sym
, *prev
;
2843 if (objfile
->msymbols
== 0) /* Beware the null file. */
2846 for (msymbol
= objfile
-> msymbols
; msymbol
-> name
!= NULL
; msymbol
++)
2852 /* Get the hash index and check all the symbols
2853 under that hash index. */
2855 hash
= hashname (msymbol
-> name
);
2857 for (sym
= global_sym_chain
[hash
]; sym
;)
2859 if (*(msymbol
-> name
) == SYMBOL_NAME (sym
)[0]
2860 && !strcmp(msymbol
-> name
+ 1, SYMBOL_NAME (sym
) + 1))
2862 /* Splice this symbol out of the hash chain and
2863 assign the value we have to it. */
2866 SYMBOL_VALUE_CHAIN (prev
) = SYMBOL_VALUE_CHAIN (sym
);
2870 global_sym_chain
[hash
] = SYMBOL_VALUE_CHAIN (sym
);
2873 /* Check to see whether we need to fix up a common block. */
2874 /* Note: this code might be executed several times for
2875 the same symbol if there are multiple references. */
2877 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2879 fix_common_block (sym
, msymbol
-> address
);
2883 SYMBOL_VALUE_ADDRESS (sym
) = msymbol
-> address
;
2888 sym
= SYMBOL_VALUE_CHAIN (prev
);
2892 sym
= global_sym_chain
[hash
];
2898 sym
= SYMBOL_VALUE_CHAIN (sym
);
2904 /* Initialize anything that needs initializing when starting to read
2905 a fresh piece of a symbol file, e.g. reading in the stuff corresponding
2913 /* Initialize anything that needs initializing when a completely new
2914 symbol file is specified (not just adding some symbols from another
2915 file, e.g. a shared library). */
2918 stabsread_new_init ()
2920 /* Empty the hash table of global syms looking for values. */
2921 memset (global_sym_chain
, 0, sizeof (global_sym_chain
));
2924 /* Initialize anything that needs initializing at the same time as
2925 start_symtab() is called. */
2929 global_stabs
= NULL
; /* AIX COFF */
2930 /* Leave FILENUM of 0 free for builtin types and this file's types. */
2931 n_this_object_header_files
= 1;
2932 type_vector_length
= 0;
2933 type_vector
= (struct type
**) 0;
2936 /* Call after end_symtab() */
2942 free ((char *) type_vector
);
2945 type_vector_length
= 0;
2946 previous_stab_code
= 0;
2950 finish_global_stabs (objfile
)
2951 struct objfile
*objfile
;
2955 patch_block_stabs (global_symbols
, global_stabs
, objfile
);
2956 free ((PTR
) global_stabs
);
2957 global_stabs
= NULL
;
2961 /* Initializer for this module */
2964 _initialize_stabsread ()
2966 undef_types_allocated
= 20;
2967 undef_types_length
= 0;
2968 undef_types
= (struct type
**)
2969 xmalloc (undef_types_allocated
* sizeof (struct type
*));