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 /* Some stupid compilers have trouble with the following, so break
1331 it up into simpler expressions. */
1333 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*)
1334 TYPE_ALLOC (type
, B_BYTES (n_baseclasses
));
1337 int num_bytes
= B_BYTES (n_baseclasses
);
1340 pointer
= (char *) TYPE_ALLOC (type
, num_bytes
);
1341 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*) pointer
;
1345 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), n_baseclasses
);
1347 for (i
= 0; i
< n_baseclasses
; i
++)
1350 *pp
= next_symbol_text ();
1361 /* Bad visibility format. */
1362 return error_type (pp
);
1370 non_public_fields
++;
1376 /* Bad visibility format. */
1377 return error_type (pp
);
1380 SET_TYPE_FIELD_VIRTUAL (type
, i
);
1383 /* Offset of the portion of the object corresponding to
1384 this baseclass. Always zero in the absence of
1385 multiple inheritance. */
1386 offset
= read_number (pp
, ',');
1387 baseclass
= read_type (pp
, objfile
);
1388 *pp
+= 1; /* skip trailing ';' */
1390 /* Make this baseclass visible for structure-printing purposes. */
1391 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1392 memset (new, 0, sizeof (struct nextfield
));
1395 list
->visibility
= via_public
;
1396 list
->field
.type
= baseclass
;
1397 list
->field
.name
= type_name_no_tag (baseclass
);
1398 list
->field
.bitpos
= offset
;
1399 list
->field
.bitsize
= 0; /* this should be an unpacked field! */
1402 TYPE_N_BASECLASSES (type
) = n_baseclasses
;
1405 /* Now come the fields, as NAME:?TYPENUM,BITPOS,BITSIZE; for each one.
1406 At the end, we see a semicolon instead of a field.
1408 In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
1411 The `?' is a placeholder for one of '/2' (public visibility),
1412 '/1' (protected visibility), '/0' (private visibility), or nothing
1413 (C style symbol table, public visibility). */
1415 /* We better set p right now, in case there are no fields at all... */
1420 /* Check for and handle cretinous dbx symbol name continuation! */
1421 if (**pp
== '\\') *pp
= next_symbol_text ();
1423 /* Get space to record the next field's data. */
1424 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1425 memset (new, 0, sizeof (struct nextfield
));
1429 /* Get the field name. */
1431 if (*p
== CPLUS_MARKER
)
1433 if (*p
== '_') /* GNU C++ anonymous type. */
1435 /* Special GNU C++ name. */
1436 else if (*++p
== 'v')
1440 struct type
*context
;
1451 complain (&invalid_cpp_abbrev_complaint
, *pp
);
1452 prefix
= "INVALID_C++_ABBREV";
1456 context
= read_type (pp
, objfile
);
1457 name
= type_name_no_tag (context
);
1460 complain (&invalid_cpp_type_complaint
, (char *) symnum
);
1463 list
->field
.name
= obconcat (&objfile
-> type_obstack
,
1467 complain (&invalid_cpp_abbrev_complaint
, *pp
);
1468 list
->field
.type
= read_type (pp
, objfile
);
1469 (*pp
)++; /* Skip the comma. */
1470 list
->field
.bitpos
= read_number (pp
, ';');
1471 /* This field is unpacked. */
1472 list
->field
.bitsize
= 0;
1473 list
->visibility
= 0; /* private */
1474 non_public_fields
++;
1480 complain (&invalid_cpp_abbrev_complaint
, *pp
);
1483 while (*p
!= ':') p
++;
1484 list
->field
.name
= obsavestring (*pp
, p
- *pp
,
1485 &objfile
-> type_obstack
);
1487 /* C++: Check to see if we have hit the methods yet. */
1493 /* This means we have a visibility for a field coming. */
1499 list
->visibility
= 0; /* private */
1500 non_public_fields
++;
1505 list
->visibility
= 1; /* protected */
1506 non_public_fields
++;
1511 list
->visibility
= 2; /* public */
1516 else /* normal dbx-style format. */
1517 list
->visibility
= 2; /* public */
1519 list
->field
.type
= read_type (pp
, objfile
);
1524 /* Possible future hook for nested types. */
1527 list
->field
.bitpos
= (long)-2; /* nested type */
1532 { /* Static class member. */
1533 list
->field
.bitpos
= (long)-1;
1535 while (*p
!= ';') p
++;
1536 list
->field
.bitsize
= (long) savestring (*pp
, p
- *pp
);
1541 else if (**pp
!= ',')
1542 /* Bad structure-type format. */
1543 return error_type (pp
);
1545 (*pp
)++; /* Skip the comma. */
1546 list
->field
.bitpos
= read_number (pp
, ',');
1547 list
->field
.bitsize
= read_number (pp
, ';');
1550 /* FIXME-tiemann: Can't the compiler put out something which
1551 lets us distinguish these? (or maybe just not put out anything
1552 for the field). What is the story here? What does the compiler
1553 really do? Also, patch gdb.texinfo for this case; I document
1554 it as a possible problem there. Search for "DBX-style". */
1556 /* This is wrong because this is identical to the symbols
1557 produced for GCC 0-size arrays. For example:
1562 The code which dumped core in such circumstances should be
1563 fixed not to dump core. */
1565 /* g++ -g0 can put out bitpos & bitsize zero for a static
1566 field. This does not give us any way of getting its
1567 class, so we can't know its name. But we can just
1568 ignore the field so we don't dump core and other nasty
1570 if (list
->field
.bitpos
== 0
1571 && list
->field
.bitsize
== 0)
1573 complain (&dbx_class_complaint
, 0);
1574 /* Ignore this field. */
1580 /* Detect an unpacked field and mark it as such.
1581 dbx gives a bit size for all fields.
1582 Note that forward refs cannot be packed,
1583 and treat enums as if they had the width of ints. */
1584 if (TYPE_CODE (list
->field
.type
) != TYPE_CODE_INT
1585 && TYPE_CODE (list
->field
.type
) != TYPE_CODE_ENUM
)
1586 list
->field
.bitsize
= 0;
1587 if ((list
->field
.bitsize
== 8 * TYPE_LENGTH (list
->field
.type
)
1588 || (TYPE_CODE (list
->field
.type
) == TYPE_CODE_ENUM
1589 && (list
->field
.bitsize
1590 == 8 * TYPE_LENGTH (lookup_fundamental_type (objfile
, FT_INTEGER
)))
1594 list
->field
.bitpos
% 8 == 0)
1595 list
->field
.bitsize
= 0;
1601 /* chill the list of fields: the last entry (at the head)
1602 is a partially constructed entry which we now scrub. */
1605 /* Now create the vector of fields, and record how big it is.
1606 We need this info to record proper virtual function table information
1607 for this class's virtual functions. */
1609 TYPE_NFIELDS (type
) = nfields
;
1610 TYPE_FIELDS (type
) = (struct field
*)
1611 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
1612 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
1614 if (non_public_fields
)
1616 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
1618 TYPE_FIELD_PRIVATE_BITS (type
) = (B_TYPE
*)
1619 TYPE_ALLOC (type
, B_BYTES (nfields
));
1620 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
1622 TYPE_FIELD_PROTECTED_BITS (type
) = (B_TYPE
*)
1623 TYPE_ALLOC (type
, B_BYTES (nfields
));
1624 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
1627 /* Copy the saved-up fields into the field vector. */
1629 for (n
= nfields
; list
; list
= list
->next
)
1632 TYPE_FIELD (type
, n
) = list
->field
;
1633 if (list
->visibility
== 0)
1634 SET_TYPE_FIELD_PRIVATE (type
, n
);
1635 else if (list
->visibility
== 1)
1636 SET_TYPE_FIELD_PROTECTED (type
, n
);
1639 /* Now come the method fields, as NAME::methods
1640 where each method is of the form TYPENUM,ARGS,...:PHYSNAME;
1641 At the end, we see a semicolon instead of a field.
1643 For the case of overloaded operators, the format is
1644 op$::*.methods, where $ is the CPLUS_MARKER (usually '$'),
1645 `*' holds the place for an operator name (such as `+=')
1646 and `.' marks the end of the operator name. */
1649 /* Now, read in the methods. To simplify matters, we
1650 "unread" the name that has been read, so that we can
1651 start from the top. */
1653 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
1654 /* For each list of method lists... */
1658 struct next_fnfield
*sublist
= 0;
1659 struct type
*look_ahead_type
= NULL
;
1661 struct next_fnfieldlist
*new_mainlist
;
1664 new_mainlist
= (struct next_fnfieldlist
*)
1665 alloca (sizeof (struct next_fnfieldlist
));
1666 memset (new_mainlist
, 0, sizeof (struct next_fnfieldlist
));
1670 /* read in the name. */
1671 while (*p
!= ':') p
++;
1672 if ((*pp
)[0] == 'o' && (*pp
)[1] == 'p' && (*pp
)[2] == CPLUS_MARKER
)
1674 /* This is a completely wierd case. In order to stuff in the
1675 names that might contain colons (the usual name delimiter),
1676 Mike Tiemann defined a different name format which is
1677 signalled if the identifier is "op$". In that case, the
1678 format is "op$::XXXX." where XXXX is the name. This is
1679 used for names like "+" or "=". YUUUUUUUK! FIXME! */
1680 /* This lets the user type "break operator+".
1681 We could just put in "+" as the name, but that wouldn't
1683 static char opname
[32] = {'o', 'p', CPLUS_MARKER
};
1684 char *o
= opname
+ 3;
1686 /* Skip past '::'. */
1688 if (**pp
== '\\') *pp
= next_symbol_text ();
1692 main_fn_name
= savestring (opname
, o
- opname
);
1698 main_fn_name
= savestring (*pp
, p
- *pp
);
1699 /* Skip past '::'. */
1702 new_mainlist
->fn_fieldlist
.name
= main_fn_name
;
1706 struct next_fnfield
*new_sublist
=
1707 (struct next_fnfield
*) alloca (sizeof (struct next_fnfield
));
1708 memset (new_sublist
, 0, sizeof (struct next_fnfield
));
1710 /* Check for and handle cretinous dbx symbol name continuation! */
1711 if (look_ahead_type
== NULL
) /* Normal case. */
1713 if (**pp
== '\\') *pp
= next_symbol_text ();
1715 new_sublist
->fn_field
.type
= read_type (pp
, objfile
);
1717 /* Invalid symtab info for method. */
1718 return error_type (pp
);
1721 { /* g++ version 1 kludge */
1722 new_sublist
->fn_field
.type
= look_ahead_type
;
1723 look_ahead_type
= NULL
;
1728 while (*p
!= ';') p
++;
1730 /* If this is just a stub, then we don't have the
1732 if (TYPE_FLAGS (new_sublist
->fn_field
.type
) & TYPE_FLAG_STUB
)
1733 new_sublist
->fn_field
.is_stub
= 1;
1734 new_sublist
->fn_field
.physname
= savestring (*pp
, p
- *pp
);
1737 /* Set this method's visibility fields. */
1738 switch (*(*pp
)++ - '0')
1741 new_sublist
->fn_field
.is_private
= 1;
1744 new_sublist
->fn_field
.is_protected
= 1;
1748 if (**pp
== '\\') *pp
= next_symbol_text ();
1751 case 'A': /* Normal functions. */
1752 new_sublist
->fn_field
.is_const
= 0;
1753 new_sublist
->fn_field
.is_volatile
= 0;
1756 case 'B': /* `const' member functions. */
1757 new_sublist
->fn_field
.is_const
= 1;
1758 new_sublist
->fn_field
.is_volatile
= 0;
1761 case 'C': /* `volatile' member function. */
1762 new_sublist
->fn_field
.is_const
= 0;
1763 new_sublist
->fn_field
.is_volatile
= 1;
1766 case 'D': /* `const volatile' member function. */
1767 new_sublist
->fn_field
.is_const
= 1;
1768 new_sublist
->fn_field
.is_volatile
= 1;
1771 case '*': /* File compiled with g++ version 1 -- no info */
1776 complain (&const_vol_complaint
, (char *) (long) **pp
);
1783 /* virtual member function, followed by index. */
1784 /* The sign bit is set to distinguish pointers-to-methods
1785 from virtual function indicies. Since the array is
1786 in words, the quantity must be shifted left by 1
1787 on 16 bit machine, and by 2 on 32 bit machine, forcing
1788 the sign bit out, and usable as a valid index into
1789 the array. Remove the sign bit here. */
1790 new_sublist
->fn_field
.voffset
=
1791 (0x7fffffff & read_number (pp
, ';')) + 2;
1793 if (**pp
== '\\') *pp
= next_symbol_text ();
1795 if (**pp
== ';' || **pp
== '\0')
1796 /* Must be g++ version 1. */
1797 new_sublist
->fn_field
.fcontext
= 0;
1800 /* Figure out from whence this virtual function came.
1801 It may belong to virtual function table of
1802 one of its baseclasses. */
1803 look_ahead_type
= read_type (pp
, objfile
);
1805 { /* g++ version 1 overloaded methods. */ }
1808 new_sublist
->fn_field
.fcontext
= look_ahead_type
;
1810 return error_type (pp
);
1813 look_ahead_type
= NULL
;
1819 /* static member function. */
1820 new_sublist
->fn_field
.voffset
= VOFFSET_STATIC
;
1821 if (strncmp (new_sublist
->fn_field
.physname
,
1822 main_fn_name
, strlen (main_fn_name
)))
1823 new_sublist
->fn_field
.is_stub
= 1;
1828 complain (&member_fn_complaint
, (char *) (long) (*pp
)[-1]);
1829 /* Fall through into normal member function. */
1832 /* normal member function. */
1833 new_sublist
->fn_field
.voffset
= 0;
1834 new_sublist
->fn_field
.fcontext
= 0;
1838 new_sublist
->next
= sublist
;
1839 sublist
= new_sublist
;
1841 if (**pp
== '\\') *pp
= next_symbol_text ();
1843 while (**pp
!= ';' && **pp
!= '\0');
1847 new_mainlist
->fn_fieldlist
.fn_fields
= (struct fn_field
*)
1848 obstack_alloc (&objfile
-> type_obstack
,
1849 sizeof (struct fn_field
) * length
);
1850 memset (new_mainlist
->fn_fieldlist
.fn_fields
, 0,
1851 sizeof (struct fn_field
) * length
);
1852 for (i
= length
; (i
--, sublist
); sublist
= sublist
->next
)
1853 new_mainlist
->fn_fieldlist
.fn_fields
[i
] = sublist
->fn_field
;
1855 new_mainlist
->fn_fieldlist
.length
= length
;
1856 new_mainlist
->next
= mainlist
;
1857 mainlist
= new_mainlist
;
1859 total_length
+= length
;
1860 if (**pp
== '\\') *pp
= next_symbol_text ();
1862 while (**pp
!= ';');
1870 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
1871 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * nfn_fields
);
1872 memset (TYPE_FN_FIELDLISTS (type
), 0,
1873 sizeof (struct fn_fieldlist
) * nfn_fields
);
1874 TYPE_NFN_FIELDS (type
) = nfn_fields
;
1875 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
1880 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); ++i
)
1882 if (TYPE_CODE (TYPE_BASECLASS (type
, i
)) == TYPE_CODE_UNDEF
)
1883 /* @@ Memory leak on objfile->type_obstack? */
1884 return error_type (pp
);
1885 TYPE_NFN_FIELDS_TOTAL (type
) +=
1886 TYPE_NFN_FIELDS_TOTAL (TYPE_BASECLASS (type
, i
));
1890 for (n
= nfn_fields
; mainlist
; mainlist
= mainlist
->next
) {
1891 --n
; /* Circumvent Sun3 compiler bug */
1892 TYPE_FN_FIELDLISTS (type
)[n
] = mainlist
->fn_fieldlist
;
1899 if (**pp
== '=' || **pp
== '+' || **pp
== '-')
1901 /* Obsolete flags that used to indicate the presence
1902 of constructors and/or destructors. */
1906 /* Read either a '%' or the final ';'. */
1907 if (*(*pp
)++ == '%')
1909 /* We'd like to be able to derive the vtable pointer field
1910 from the type information, but when it's inherited, that's
1911 hard. A reason it's hard is because we may read in the
1912 info about a derived class before we read in info about
1913 the base class that provides the vtable pointer field.
1914 Once the base info has been read, we could fill in the info
1915 for the derived classes, but for the fact that by then,
1916 we don't remember who needs what. */
1919 int predicted_fieldno
= -1;
1922 /* Now we must record the virtual function table pointer's
1923 field information. */
1931 /* In version 2, we derive the vfield ourselves. */
1932 for (n
= 0; n
< nfields
; n
++)
1934 if (! strncmp (TYPE_FIELD_NAME (type
, n
), vptr_name
,
1935 sizeof (vptr_name
) -1))
1937 predicted_fieldno
= n
;
1941 if (predicted_fieldno
< 0)
1942 for (n
= 0; n
< TYPE_N_BASECLASSES (type
); n
++)
1943 if (! TYPE_FIELD_VIRTUAL (type
, n
)
1944 && TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, n
)) >= 0)
1946 predicted_fieldno
= TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, n
));
1952 t
= read_type (pp
, objfile
);
1954 while (*p
!= '\0' && *p
!= ';')
1957 /* Premature end of symbol. */
1958 return error_type (pp
);
1960 TYPE_VPTR_BASETYPE (type
) = t
;
1963 if (TYPE_FIELD_NAME (t
, TYPE_N_BASECLASSES (t
)) == 0)
1965 /* FIXME-tiemann: what's this? */
1967 TYPE_VPTR_FIELDNO (type
) = i
= TYPE_N_BASECLASSES (t
);
1972 else for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); --i
)
1973 if (! strncmp (TYPE_FIELD_NAME (t
, i
), vptr_name
,
1974 sizeof (vptr_name
) - 1))
1976 TYPE_VPTR_FIELDNO (type
) = i
;
1980 /* Virtual function table field not found. */
1981 return error_type (pp
);
1984 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
1987 if (TYPE_VPTR_FIELDNO (type
) != predicted_fieldno
)
1988 error ("TYPE_VPTR_FIELDNO miscalculated");
1998 /* Read a definition of an array type,
1999 and create and return a suitable type object.
2000 Also creates a range type which represents the bounds of that
2003 static struct type
*
2004 read_array_type (pp
, type
, objfile
)
2006 register struct type
*type
;
2007 struct objfile
*objfile
;
2009 struct type
*index_type
, *element_type
, *range_type
;
2013 /* Format of an array type:
2014 "ar<index type>;lower;upper;<array_contents_type>". Put code in
2017 Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
2018 for these, produce a type like float[][]. */
2020 index_type
= read_type (pp
, objfile
);
2022 /* Improper format of array type decl. */
2023 return error_type (pp
);
2026 if (!(**pp
>= '0' && **pp
<= '9'))
2031 lower
= read_number (pp
, ';');
2033 if (!(**pp
>= '0' && **pp
<= '9'))
2038 upper
= read_number (pp
, ';');
2040 element_type
= read_type (pp
, objfile
);
2049 /* Create range type. */
2050 range_type
= alloc_type (objfile
);
2051 TYPE_CODE (range_type
) = TYPE_CODE_RANGE
;
2052 TYPE_TARGET_TYPE (range_type
) = index_type
;
2054 /* This should never be needed. */
2055 TYPE_LENGTH (range_type
) = sizeof (int);
2057 TYPE_NFIELDS (range_type
) = 2;
2058 TYPE_FIELDS (range_type
) = (struct field
*)
2059 TYPE_ALLOC (range_type
, 2 * sizeof (struct field
));
2060 memset (TYPE_FIELDS (range_type
), 0, 2 * sizeof (struct field
));
2061 TYPE_FIELD_BITPOS (range_type
, 0) = lower
;
2062 TYPE_FIELD_BITPOS (range_type
, 1) = upper
;
2065 TYPE_CODE (type
) = TYPE_CODE_ARRAY
;
2066 TYPE_TARGET_TYPE (type
) = element_type
;
2067 TYPE_LENGTH (type
) = (upper
- lower
+ 1) * TYPE_LENGTH (element_type
);
2068 TYPE_NFIELDS (type
) = 1;
2069 TYPE_FIELDS (type
) = (struct field
*)
2070 TYPE_ALLOC (type
, sizeof (struct field
));
2071 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
));
2072 TYPE_FIELD_TYPE (type
, 0) = range_type
;
2074 /* If we have an array whose element type is not yet known, but whose
2075 bounds *are* known, record it to be adjusted at the end of the file. */
2076 if (TYPE_LENGTH (element_type
) == 0 && !adjustable
)
2077 add_undefined_type (type
);
2083 /* Read a definition of an enumeration type,
2084 and create and return a suitable type object.
2085 Also defines the symbols that represent the values of the type. */
2087 static struct type
*
2088 read_enum_type (pp
, type
, objfile
)
2090 register struct type
*type
;
2091 struct objfile
*objfile
;
2096 register struct symbol
*sym
;
2098 struct pending
**symlist
;
2099 struct pending
*osyms
, *syms
;
2103 /* FIXME! The stabs produced by Sun CC merrily define things that ought
2104 to be file-scope, between N_FN entries, using N_LSYM. What's a mother
2105 to do? For now, force all enum values to file scope. */
2106 if (within_function
)
2107 symlist
= &local_symbols
;
2110 symlist
= &file_symbols
;
2112 o_nsyms
= osyms
? osyms
->nsyms
: 0;
2114 /* Read the value-names and their values.
2115 The input syntax is NAME:VALUE,NAME:VALUE, and so on.
2116 A semicolon or comma instead of a NAME means the end. */
2117 while (**pp
&& **pp
!= ';' && **pp
!= ',')
2119 /* Check for and handle cretinous dbx symbol name continuation! */
2120 if (**pp
== '\\') *pp
= next_symbol_text ();
2123 while (*p
!= ':') p
++;
2124 name
= obsavestring (*pp
, p
- *pp
, &objfile
-> symbol_obstack
);
2126 n
= read_number (pp
, ',');
2128 sym
= (struct symbol
*)
2129 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
2130 memset (sym
, 0, sizeof (struct symbol
));
2131 SYMBOL_NAME (sym
) = name
;
2132 SYMBOL_CLASS (sym
) = LOC_CONST
;
2133 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2134 SYMBOL_VALUE (sym
) = n
;
2135 add_symbol_to_list (sym
, symlist
);
2140 (*pp
)++; /* Skip the semicolon. */
2142 /* Now fill in the fields of the type-structure. */
2144 TYPE_LENGTH (type
) = sizeof (int);
2145 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
2146 TYPE_FLAGS (type
) &= ~TYPE_FLAG_STUB
;
2147 TYPE_NFIELDS (type
) = nsyms
;
2148 TYPE_FIELDS (type
) = (struct field
*)
2149 TYPE_ALLOC (type
, sizeof (struct field
) * nsyms
);
2150 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nsyms
);
2152 /* Find the symbols for the values and put them into the type.
2153 The symbols can be found in the symlist that we put them on
2154 to cause them to be defined. osyms contains the old value
2155 of that symlist; everything up to there was defined by us. */
2156 /* Note that we preserve the order of the enum constants, so
2157 that in something like "enum {FOO, LAST_THING=FOO}" we print
2158 FOO, not LAST_THING. */
2160 for (syms
= *symlist
, n
= 0; syms
; syms
= syms
->next
)
2165 for (; j
< syms
->nsyms
; j
++,n
++)
2167 struct symbol
*xsym
= syms
->symbol
[j
];
2168 SYMBOL_TYPE (xsym
) = type
;
2169 TYPE_FIELD_NAME (type
, n
) = SYMBOL_NAME (xsym
);
2170 TYPE_FIELD_VALUE (type
, n
) = 0;
2171 TYPE_FIELD_BITPOS (type
, n
) = SYMBOL_VALUE (xsym
);
2172 TYPE_FIELD_BITSIZE (type
, n
) = 0;
2179 /* This screws up perfectly good C programs with enums. FIXME. */
2180 /* Is this Modula-2's BOOLEAN type? Flag it as such if so. */
2181 if(TYPE_NFIELDS(type
) == 2 &&
2182 ((!strcmp(TYPE_FIELD_NAME(type
,0),"TRUE") &&
2183 !strcmp(TYPE_FIELD_NAME(type
,1),"FALSE")) ||
2184 (!strcmp(TYPE_FIELD_NAME(type
,1),"TRUE") &&
2185 !strcmp(TYPE_FIELD_NAME(type
,0),"FALSE"))))
2186 TYPE_CODE(type
) = TYPE_CODE_BOOL
;
2192 /* Sun's ACC uses a somewhat saner method for specifying the builtin
2193 typedefs in every file (for int, long, etc):
2195 type = b <signed> <width>; <offset>; <nbits>
2196 signed = u or s. Possible c in addition to u or s (for char?).
2197 offset = offset from high order bit to start bit of type.
2198 width is # bytes in object of this type, nbits is # bits in type.
2200 The width/offset stuff appears to be for small objects stored in
2201 larger ones (e.g. `shorts' in `int' registers). We ignore it for now,
2204 static struct type
*
2205 read_sun_builtin_type (pp
, typenums
, objfile
)
2208 struct objfile
*objfile
;
2222 return error_type (pp
);
2226 /* For some odd reason, all forms of char put a c here. This is strange
2227 because no other type has this honor. We can safely ignore this because
2228 we actually determine 'char'acterness by the number of bits specified in
2234 /* The first number appears to be the number of bytes occupied
2235 by this type, except that unsigned short is 4 instead of 2.
2236 Since this information is redundant with the third number,
2237 we will ignore it. */
2238 read_number (pp
, ';');
2240 /* The second number is always 0, so ignore it too. */
2241 read_number (pp
, ';');
2243 /* The third number is the number of bits for this type. */
2244 nbits
= read_number (pp
, 0);
2246 /* FIXME. Here we should just be able to make a type of the right
2247 number of bits and signedness. FIXME. */
2249 if (nbits
== TARGET_LONG_LONG_BIT
)
2250 return (lookup_fundamental_type (objfile
,
2251 signed_type
? FT_LONG_LONG
: FT_UNSIGNED_LONG_LONG
));
2253 if (nbits
== TARGET_INT_BIT
)
2255 /* FIXME -- the only way to distinguish `int' from `long'
2256 is to look at its name! */
2259 if (long_kludge_name
&& long_kludge_name
[0] == 'l' /* long */)
2260 return lookup_fundamental_type (objfile
, FT_LONG
);
2262 return lookup_fundamental_type (objfile
, FT_INTEGER
);
2266 if (long_kludge_name
2267 && ((long_kludge_name
[0] == 'u' /* unsigned */ &&
2268 long_kludge_name
[9] == 'l' /* long */)
2269 || (long_kludge_name
[0] == 'l' /* long unsigned */)))
2270 return lookup_fundamental_type (objfile
, FT_UNSIGNED_LONG
);
2272 return lookup_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
);
2276 if (nbits
== TARGET_SHORT_BIT
)
2277 return (lookup_fundamental_type (objfile
,
2278 signed_type
? FT_SHORT
: FT_UNSIGNED_SHORT
));
2280 if (nbits
== TARGET_CHAR_BIT
)
2281 return (lookup_fundamental_type (objfile
,
2282 signed_type
? FT_CHAR
: FT_UNSIGNED_CHAR
));
2285 return lookup_fundamental_type (objfile
, FT_VOID
);
2287 return error_type (pp
);
2290 static struct type
*
2291 read_sun_floating_type (pp
, typenums
, objfile
)
2294 struct objfile
*objfile
;
2298 /* The first number has more details about the type, for example
2299 FN_COMPLEX. See the sun stab.h. */
2300 read_number (pp
, ';');
2302 /* The second number is the number of bytes occupied by this type */
2303 nbytes
= read_number (pp
, ';');
2306 return error_type (pp
);
2308 if (nbytes
== TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
)
2309 return lookup_fundamental_type (objfile
, FT_FLOAT
);
2311 if (nbytes
== TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
)
2312 return lookup_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
);
2314 if (nbytes
== TARGET_LONG_DOUBLE_BIT
/ TARGET_CHAR_BIT
)
2315 return lookup_fundamental_type (objfile
, FT_EXT_PREC_FLOAT
);
2317 return error_type (pp
);
2320 /* Read a number from the string pointed to by *PP.
2321 The value of *PP is advanced over the number.
2322 If END is nonzero, the character that ends the
2323 number must match END, or an error happens;
2324 and that character is skipped if it does match.
2325 If END is zero, *PP is left pointing to that character.
2327 If the number fits in a long, set *VALUE and set *BITS to 0.
2328 If not, set *BITS to be the number of bits in the number.
2330 If encounter garbage, set *BITS to -1. */
2333 read_huge_number (pp
, end
, valu
, bits
)
2354 /* Leading zero means octal. GCC uses this to output values larger
2355 than an int (because that would be hard in decimal). */
2362 upper_limit
= LONG_MAX
/ radix
;
2363 while ((c
= *p
++) >= '0' && c
<= ('0' + radix
))
2365 if (n
<= upper_limit
)
2368 n
+= c
- '0'; /* FIXME this overflows anyway */
2373 /* This depends on large values being output in octal, which is
2380 /* Ignore leading zeroes. */
2384 else if (c
== '2' || c
== '3')
2410 /* Large decimal constants are an error (because it is hard to
2411 count how many bits are in them). */
2417 /* -0x7f is the same as 0x80. So deal with it by adding one to
2418 the number of bits. */
2433 static struct type
*
2434 read_range_type (pp
, typenums
, objfile
)
2437 struct objfile
*objfile
;
2443 struct type
*result_type
;
2445 /* First comes a type we are a subrange of.
2446 In C it is usually 0, 1 or the type being defined. */
2447 read_type_number (pp
, rangenums
);
2448 self_subrange
= (rangenums
[0] == typenums
[0] &&
2449 rangenums
[1] == typenums
[1]);
2451 /* A semicolon should now follow; skip it. */
2455 /* The remaining two operands are usually lower and upper bounds
2456 of the range. But in some special cases they mean something else. */
2457 read_huge_number (pp
, ';', &n2
, &n2bits
);
2458 read_huge_number (pp
, ';', &n3
, &n3bits
);
2460 if (n2bits
== -1 || n3bits
== -1)
2461 return error_type (pp
);
2463 /* If limits are huge, must be large integral type. */
2464 if (n2bits
!= 0 || n3bits
!= 0)
2466 char got_signed
= 0;
2467 char got_unsigned
= 0;
2468 /* Number of bits in the type. */
2471 /* Range from 0 to <large number> is an unsigned large integral type. */
2472 if ((n2bits
== 0 && n2
== 0) && n3bits
!= 0)
2477 /* Range from <large number> to <large number>-1 is a large signed
2479 else if (n2bits
!= 0 && n3bits
!= 0 && n2bits
== n3bits
+ 1)
2485 /* Check for "long long". */
2486 if (got_signed
&& nbits
== TARGET_LONG_LONG_BIT
)
2487 return (lookup_fundamental_type (objfile
, FT_LONG_LONG
));
2488 if (got_unsigned
&& nbits
== TARGET_LONG_LONG_BIT
)
2489 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_LONG_LONG
));
2491 if (got_signed
|| got_unsigned
)
2493 result_type
= alloc_type (objfile
);
2494 TYPE_LENGTH (result_type
) = nbits
/ TARGET_CHAR_BIT
;
2495 TYPE_CODE (result_type
) = TYPE_CODE_INT
;
2497 TYPE_FLAGS (result_type
) |= TYPE_FLAG_UNSIGNED
;
2501 return error_type (pp
);
2504 /* A type defined as a subrange of itself, with bounds both 0, is void. */
2505 if (self_subrange
&& n2
== 0 && n3
== 0)
2506 return (lookup_fundamental_type (objfile
, FT_VOID
));
2508 /* If n3 is zero and n2 is not, we want a floating type,
2509 and n2 is the width in bytes.
2511 Fortran programs appear to use this for complex types also,
2512 and they give no way to distinguish between double and single-complex!
2513 We don't have complex types, so we would lose on all fortran files!
2514 So return type `double' for all of those. It won't work right
2515 for the complex values, but at least it makes the file loadable.
2517 FIXME, we may be able to distinguish these by their names. FIXME. */
2519 if (n3
== 0 && n2
> 0)
2521 if (n2
== sizeof (float))
2522 return (lookup_fundamental_type (objfile
, FT_FLOAT
));
2523 return (lookup_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
));
2526 /* If the upper bound is -1, it must really be an unsigned int. */
2528 else if (n2
== 0 && n3
== -1)
2530 /* FIXME -- the only way to distinguish `unsigned int' from `unsigned
2531 long' is to look at its name! */
2533 long_kludge_name
&& ((long_kludge_name
[0] == 'u' /* unsigned */ &&
2534 long_kludge_name
[9] == 'l' /* long */)
2535 || (long_kludge_name
[0] == 'l' /* long unsigned */)))
2536 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_LONG
));
2538 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
));
2541 /* Special case: char is defined (Who knows why) as a subrange of
2542 itself with range 0-127. */
2543 else if (self_subrange
&& n2
== 0 && n3
== 127)
2544 return (lookup_fundamental_type (objfile
, FT_CHAR
));
2546 /* Assumptions made here: Subrange of self is equivalent to subrange
2547 of int. FIXME: Host and target type-sizes assumed the same. */
2548 /* FIXME: This is the *only* place in GDB that depends on comparing
2549 some type to a builtin type with ==. Fix it! */
2551 && (self_subrange
||
2552 *dbx_lookup_type (rangenums
) == lookup_fundamental_type (objfile
, FT_INTEGER
)))
2554 /* an unsigned type */
2556 if (n3
== - sizeof (long long))
2557 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_LONG_LONG
));
2559 /* FIXME -- the only way to distinguish `unsigned int' from `unsigned
2560 long' is to look at its name! */
2561 if (n3
== (unsigned long)~0L &&
2562 long_kludge_name
&& ((long_kludge_name
[0] == 'u' /* unsigned */ &&
2563 long_kludge_name
[9] == 'l' /* long */)
2564 || (long_kludge_name
[0] == 'l' /* long unsigned */)))
2565 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_LONG
));
2566 if (n3
== (unsigned int)~0L)
2567 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
));
2568 if (n3
== (unsigned short)~0L)
2569 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_SHORT
));
2570 if (n3
== (unsigned char)~0L)
2571 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_CHAR
));
2574 else if (n3
== 0 && n2
== -sizeof (long long))
2575 return (lookup_fundamental_type (objfile
, FT_LONG_LONG
));
2577 else if (n2
== -n3
-1)
2580 /* FIXME -- the only way to distinguish `int' from `long' is to look
2582 if ((n3
==(long)(((unsigned long)1 << (8 * sizeof (long) - 1)) - 1)) &&
2583 long_kludge_name
&& long_kludge_name
[0] == 'l' /* long */)
2584 return (lookup_fundamental_type (objfile
, FT_LONG
));
2585 if (n3
== (long)(((unsigned long)1 << (8 * sizeof (int) - 1)) - 1))
2586 return (lookup_fundamental_type (objfile
, FT_INTEGER
));
2587 if (n3
== ( 1 << (8 * sizeof (short) - 1)) - 1)
2588 return (lookup_fundamental_type (objfile
, FT_SHORT
));
2589 if (n3
== ( 1 << (8 * sizeof (char) - 1)) - 1)
2590 return (lookup_fundamental_type (objfile
, FT_SIGNED_CHAR
));
2593 /* We have a real range type on our hands. Allocate space and
2594 return a real pointer. */
2596 /* At this point I don't have the faintest idea how to deal with
2597 a self_subrange type; I'm going to assume that this is used
2598 as an idiom, and that all of them are special cases. So . . . */
2600 return error_type (pp
);
2602 result_type
= alloc_type (objfile
);
2604 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
2606 TYPE_TARGET_TYPE (result_type
) = *dbx_lookup_type(rangenums
);
2607 if (TYPE_TARGET_TYPE (result_type
) == 0) {
2608 complain (&range_type_base_complaint
, (char *) rangenums
[1]);
2609 TYPE_TARGET_TYPE (result_type
) = lookup_fundamental_type (objfile
, FT_INTEGER
);
2612 TYPE_NFIELDS (result_type
) = 2;
2613 TYPE_FIELDS (result_type
) = (struct field
*)
2614 TYPE_ALLOC (result_type
, 2 * sizeof (struct field
));
2615 memset (TYPE_FIELDS (result_type
), 0, 2 * sizeof (struct field
));
2616 TYPE_FIELD_BITPOS (result_type
, 0) = n2
;
2617 TYPE_FIELD_BITPOS (result_type
, 1) = n3
;
2619 TYPE_LENGTH (result_type
) = TYPE_LENGTH (TYPE_TARGET_TYPE (result_type
));
2624 /* Read a number from the string pointed to by *PP.
2625 The value of *PP is advanced over the number.
2626 If END is nonzero, the character that ends the
2627 number must match END, or an error happens;
2628 and that character is skipped if it does match.
2629 If END is zero, *PP is left pointing to that character. */
2632 read_number (pp
, end
)
2636 register char *p
= *pp
;
2637 register long n
= 0;
2641 /* Handle an optional leading minus sign. */
2649 /* Read the digits, as far as they go. */
2651 while ((c
= *p
++) >= '0' && c
<= '9')
2659 error ("Invalid symbol data: invalid character \\%03o at symbol pos %d.", c
, symnum
);
2668 /* Read in an argument list. This is a list of types, separated by commas
2669 and terminated with END. Return the list of types read in, or (struct type
2670 **)-1 if there is an error. */
2672 static struct type
**
2673 read_args (pp
, end
, objfile
)
2676 struct objfile
*objfile
;
2678 /* FIXME! Remove this arbitrary limit! */
2679 struct type
*types
[1024], **rval
; /* allow for fns of 1023 parameters */
2685 /* Invalid argument list: no ','. */
2686 return (struct type
**)-1;
2689 /* Check for and handle cretinous dbx symbol name continuation! */
2691 *pp
= next_symbol_text ();
2693 types
[n
++] = read_type (pp
, objfile
);
2695 *pp
+= 1; /* get past `end' (the ':' character) */
2699 rval
= (struct type
**) xmalloc (2 * sizeof (struct type
*));
2701 else if (TYPE_CODE (types
[n
-1]) != TYPE_CODE_VOID
)
2703 rval
= (struct type
**) xmalloc ((n
+ 1) * sizeof (struct type
*));
2704 memset (rval
+ n
, 0, sizeof (struct type
*));
2708 rval
= (struct type
**) xmalloc (n
* sizeof (struct type
*));
2710 memcpy (rval
, types
, n
* sizeof (struct type
*));
2714 /* Add a common block's start address to the offset of each symbol
2715 declared to be in it (by being between a BCOMM/ECOMM pair that uses
2716 the common block name). */
2719 fix_common_block (sym
, valu
)
2723 struct pending
*next
= (struct pending
*) SYMBOL_NAMESPACE (sym
);
2724 for ( ; next
; next
= next
->next
)
2727 for (j
= next
->nsyms
- 1; j
>= 0; j
--)
2728 SYMBOL_VALUE_ADDRESS (next
->symbol
[j
]) += valu
;
2734 /* What about types defined as forward references inside of a small lexical
2736 /* Add a type to the list of undefined types to be checked through
2737 once this file has been read in. */
2740 add_undefined_type (type
)
2743 if (undef_types_length
== undef_types_allocated
)
2745 undef_types_allocated
*= 2;
2746 undef_types
= (struct type
**)
2747 xrealloc ((char *) undef_types
,
2748 undef_types_allocated
* sizeof (struct type
*));
2750 undef_types
[undef_types_length
++] = type
;
2753 /* Go through each undefined type, see if it's still undefined, and fix it
2754 up if possible. We have two kinds of undefined types:
2756 TYPE_CODE_ARRAY: Array whose target type wasn't defined yet.
2757 Fix: update array length using the element bounds
2758 and the target type's length.
2759 TYPE_CODE_STRUCT, TYPE_CODE_UNION: Structure whose fields were not
2760 yet defined at the time a pointer to it was made.
2761 Fix: Do a full lookup on the struct/union tag. */
2763 cleanup_undefined_types ()
2767 for (type
= undef_types
; type
< undef_types
+ undef_types_length
; type
++)
2769 switch (TYPE_CODE (*type
))
2772 case TYPE_CODE_STRUCT
:
2773 case TYPE_CODE_UNION
:
2774 case TYPE_CODE_ENUM
:
2776 /* Check if it has been defined since. */
2777 if (TYPE_FLAGS (*type
) & TYPE_FLAG_STUB
)
2779 struct pending
*ppt
;
2781 /* Name of the type, without "struct" or "union" */
2782 char *typename
= TYPE_NAME (*type
);
2784 if (!strncmp (typename
, "struct ", 7))
2786 if (!strncmp (typename
, "union ", 6))
2788 if (!strncmp (typename
, "enum ", 5))
2791 for (ppt
= file_symbols
; ppt
; ppt
= ppt
->next
)
2793 for (i
= 0; i
< ppt
->nsyms
; i
++)
2795 struct symbol
*sym
= ppt
->symbol
[i
];
2797 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
2798 && SYMBOL_NAMESPACE (sym
) == STRUCT_NAMESPACE
2799 && (TYPE_CODE (SYMBOL_TYPE (sym
)) ==
2801 && !strcmp (SYMBOL_NAME (sym
), typename
))
2803 memcpy (*type
, SYMBOL_TYPE (sym
),
2804 sizeof (struct type
));
2812 case TYPE_CODE_ARRAY
:
2814 struct type
*range_type
;
2817 if (TYPE_LENGTH (*type
) != 0) /* Better be unknown */
2819 if (TYPE_NFIELDS (*type
) != 1)
2821 range_type
= TYPE_FIELD_TYPE (*type
, 0);
2822 if (TYPE_CODE (range_type
) != TYPE_CODE_RANGE
)
2825 /* Now recompute the length of the array type, based on its
2826 number of elements and the target type's length. */
2827 lower
= TYPE_FIELD_BITPOS (range_type
, 0);
2828 upper
= TYPE_FIELD_BITPOS (range_type
, 1);
2829 TYPE_LENGTH (*type
) = (upper
- lower
+ 1)
2830 * TYPE_LENGTH (TYPE_TARGET_TYPE (*type
));
2836 error ("GDB internal error. cleanup_undefined_types with bad type %d.", TYPE_CODE (*type
));
2840 undef_types_length
= 0;
2843 /* Scan through all of the global symbols defined in the object file,
2844 assigning values to the debugging symbols that need to be assigned
2845 to. Get these symbols from the minimal symbol table. */
2848 scan_file_globals (objfile
)
2849 struct objfile
*objfile
;
2852 struct minimal_symbol
*msymbol
;
2853 struct symbol
*sym
, *prev
;
2855 if (objfile
->msymbols
== 0) /* Beware the null file. */
2858 for (msymbol
= objfile
-> msymbols
; msymbol
-> name
!= NULL
; msymbol
++)
2864 /* Get the hash index and check all the symbols
2865 under that hash index. */
2867 hash
= hashname (msymbol
-> name
);
2869 for (sym
= global_sym_chain
[hash
]; sym
;)
2871 if (*(msymbol
-> name
) == SYMBOL_NAME (sym
)[0]
2872 && !strcmp(msymbol
-> name
+ 1, SYMBOL_NAME (sym
) + 1))
2874 /* Splice this symbol out of the hash chain and
2875 assign the value we have to it. */
2878 SYMBOL_VALUE_CHAIN (prev
) = SYMBOL_VALUE_CHAIN (sym
);
2882 global_sym_chain
[hash
] = SYMBOL_VALUE_CHAIN (sym
);
2885 /* Check to see whether we need to fix up a common block. */
2886 /* Note: this code might be executed several times for
2887 the same symbol if there are multiple references. */
2889 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2891 fix_common_block (sym
, msymbol
-> address
);
2895 SYMBOL_VALUE_ADDRESS (sym
) = msymbol
-> address
;
2900 sym
= SYMBOL_VALUE_CHAIN (prev
);
2904 sym
= global_sym_chain
[hash
];
2910 sym
= SYMBOL_VALUE_CHAIN (sym
);
2916 /* Initialize anything that needs initializing when starting to read
2917 a fresh piece of a symbol file, e.g. reading in the stuff corresponding
2925 /* Initialize anything that needs initializing when a completely new
2926 symbol file is specified (not just adding some symbols from another
2927 file, e.g. a shared library). */
2930 stabsread_new_init ()
2932 /* Empty the hash table of global syms looking for values. */
2933 memset (global_sym_chain
, 0, sizeof (global_sym_chain
));
2936 /* Initialize anything that needs initializing at the same time as
2937 start_symtab() is called. */
2941 global_stabs
= NULL
; /* AIX COFF */
2942 /* Leave FILENUM of 0 free for builtin types and this file's types. */
2943 n_this_object_header_files
= 1;
2944 type_vector_length
= 0;
2945 type_vector
= (struct type
**) 0;
2948 /* Call after end_symtab() */
2954 free ((char *) type_vector
);
2957 type_vector_length
= 0;
2958 previous_stab_code
= 0;
2962 finish_global_stabs (objfile
)
2963 struct objfile
*objfile
;
2967 patch_block_stabs (global_symbols
, global_stabs
, objfile
);
2968 free ((PTR
) global_stabs
);
2969 global_stabs
= NULL
;
2973 /* Initializer for this module */
2976 _initialize_stabsread ()
2978 undef_types_allocated
= 20;
2979 undef_types_length
= 0;
2980 undef_types
= (struct type
**)
2981 xmalloc (undef_types_allocated
* sizeof (struct type
*));