1 /* Support routines for decoding "stabs" debugging information format.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993
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. */
34 #include "aout/stab_gnu.h" /* We always use GNU stabs, not native */
36 #include "complaints.h"
41 /* Ask stabsread.h to define the vars it normally declares `extern'. */
43 #include "stabsread.h" /* Our own declarations */
46 /* The routines that read and process a complete stabs for a C struct or
47 C++ class pass lists of data member fields and lists of member function
48 fields in an instance of a field_info structure, as defined below.
49 This is part of some reorganization of low level C++ support and is
50 expected to eventually go away... (FIXME) */
56 struct nextfield
*next
;
60 struct next_fnfieldlist
62 struct next_fnfieldlist
*next
;
63 struct fn_fieldlist fn_fieldlist
;
68 dbx_alloc_type
PARAMS ((int [2], struct objfile
*));
70 static long read_huge_number
PARAMS ((char **, int, int *));
72 static struct type
*error_type
PARAMS ((char **));
75 patch_block_stabs
PARAMS ((struct pending
*, struct pending_stabs
*,
79 fix_common_block
PARAMS ((struct symbol
*, int));
82 read_type_number
PARAMS ((char **, int *));
85 read_range_type
PARAMS ((char **, int [2], struct objfile
*));
88 read_sun_builtin_type
PARAMS ((char **, int [2], struct objfile
*));
91 read_sun_floating_type
PARAMS ((char **, int [2], struct objfile
*));
94 read_enum_type
PARAMS ((char **, struct type
*, struct objfile
*));
97 rs6000_builtin_type
PARAMS ((int));
100 read_member_functions
PARAMS ((struct field_info
*, char **, struct type
*,
104 read_struct_fields
PARAMS ((struct field_info
*, char **, struct type
*,
108 read_baseclasses
PARAMS ((struct field_info
*, char **, struct type
*,
112 read_tilde_fields
PARAMS ((struct field_info
*, char **, struct type
*,
116 attach_fn_fields_to_type
PARAMS ((struct field_info
*, struct type
*));
119 attach_fields_to_type
PARAMS ((struct field_info
*, struct type
*,
123 read_struct_type
PARAMS ((char **, struct type
*, struct objfile
*));
126 read_array_type
PARAMS ((char **, struct type
*, struct objfile
*));
128 static struct type
**
129 read_args
PARAMS ((char **, int, struct objfile
*));
132 read_cpp_abbrev
PARAMS ((struct field_info
*, char **, struct type
*,
135 static const char vptr_name
[] = { '_','v','p','t','r',CPLUS_MARKER
,'\0' };
136 static const char vb_name
[] = { '_','v','b',CPLUS_MARKER
,'\0' };
138 /* Define this as 1 if a pcc declaration of a char or short argument
139 gives the correct address. Otherwise assume pcc gives the
140 address of the corresponding int, which is not the same on a
141 big-endian machine. */
143 #ifndef BELIEVE_PCC_PROMOTION
144 #define BELIEVE_PCC_PROMOTION 0
148 /* I think this can go away, all current uses have been removed.
149 GCC emits a few crazy types which can only be distinguished by the
150 name (complex, long long on some machines), but I'd say fix GCC. */
152 /* During some calls to read_type (and thus to read_range_type), this
153 contains the name of the type being defined. Range types are only
154 used in C as basic types. We use the name to distinguish the otherwise
155 identical basic types "int" and "long" and their unsigned versions.
156 FIXME, this should disappear with better type management. */
158 static char *long_kludge_name
;
162 struct complaint dbx_class_complaint
=
164 "encountered DBX-style class variable debugging information.\n\
165 You seem to have compiled your program with \
166 \"g++ -g0\" instead of \"g++ -g\".\n\
167 Therefore GDB will not know about your class variables", 0, 0
171 struct complaint invalid_cpp_abbrev_complaint
=
172 {"invalid C++ abbreviation `%s'", 0, 0};
174 struct complaint invalid_cpp_type_complaint
=
175 {"C++ abbreviated type name unknown at symtab pos %d", 0, 0};
177 struct complaint member_fn_complaint
=
178 {"member function type missing, got '%c'", 0, 0};
180 struct complaint const_vol_complaint
=
181 {"const/volatile indicator missing, got '%c'", 0, 0};
183 struct complaint error_type_complaint
=
184 {"debug info mismatch between compiler and debugger", 0, 0};
186 struct complaint invalid_member_complaint
=
187 {"invalid (minimal) member type data format at symtab pos %d.", 0, 0};
189 struct complaint range_type_base_complaint
=
190 {"base type %d of range type is not defined", 0, 0};
192 struct complaint reg_value_complaint
=
193 {"register number too large in symbol %s", 0, 0};
195 struct complaint vtbl_notfound_complaint
=
196 {"virtual function table pointer not found when defining class `%s'", 0, 0};
198 struct complaint unrecognized_cplus_name_complaint
=
199 {"Unknown C++ symbol name `%s'", 0, 0};
201 struct complaint rs6000_builtin_complaint
=
202 {"Unknown builtin type %d", 0, 0};
204 struct complaint stabs_general_complaint
=
207 /* Make a list of forward references which haven't been defined. */
209 static struct type
**undef_types
;
210 static int undef_types_allocated
;
211 static int undef_types_length
;
213 /* Check for and handle cretinous stabs symbol name continuation! */
214 #define STABS_CONTINUE(pp) \
216 if (**(pp) == '\\') *(pp) = next_symbol_text (); \
220 /* Look up a dbx type-number pair. Return the address of the slot
221 where the type for that number-pair is stored.
222 The number-pair is in TYPENUMS.
224 This can be used for finding the type associated with that pair
225 or for associating a new type with the pair. */
228 dbx_lookup_type (typenums
)
231 register int filenum
= typenums
[0];
232 register int index
= typenums
[1];
234 register int real_filenum
;
235 register struct header_file
*f
;
238 if (filenum
== -1) /* -1,-1 is for temporary types. */
241 if (filenum
< 0 || filenum
>= n_this_object_header_files
)
243 static struct complaint msg
= {"\
244 Invalid symbol data: type number (%d,%d) out of range at symtab pos %d.",
246 complain (&msg
, filenum
, index
, symnum
);
254 /* Caller wants address of address of type. We think
255 that negative (rs6k builtin) types will never appear as
256 "lvalues", (nor should they), so we stuff the real type
257 pointer into a temp, and return its address. If referenced,
258 this will do the right thing. */
259 static struct type
*temp_type
;
261 temp_type
= rs6000_builtin_type(index
);
265 /* Type is defined outside of header files.
266 Find it in this object file's type vector. */
267 if (index
>= type_vector_length
)
269 old_len
= type_vector_length
;
272 type_vector_length
= INITIAL_TYPE_VECTOR_LENGTH
;
273 type_vector
= (struct type
**)
274 malloc (type_vector_length
* sizeof (struct type
*));
276 while (index
>= type_vector_length
)
278 type_vector_length
*= 2;
280 type_vector
= (struct type
**)
281 xrealloc ((char *) type_vector
,
282 (type_vector_length
* sizeof (struct type
*)));
283 memset (&type_vector
[old_len
], 0,
284 (type_vector_length
- old_len
) * sizeof (struct type
*));
286 return (&type_vector
[index
]);
290 real_filenum
= this_object_header_files
[filenum
];
292 if (real_filenum
>= n_header_files
)
294 struct type
*temp_type
;
295 struct type
**temp_type_p
;
297 warning ("GDB internal error: bad real_filenum");
300 temp_type
= init_type (TYPE_CODE_ERROR
, 0, 0, NULL
, NULL
);
301 temp_type_p
= (struct type
**) xmalloc (sizeof (struct type
*));
302 *temp_type_p
= temp_type
;
306 f
= &header_files
[real_filenum
];
308 f_orig_length
= f
->length
;
309 if (index
>= f_orig_length
)
311 while (index
>= f
->length
)
315 f
->vector
= (struct type
**)
316 xrealloc ((char *) f
->vector
, f
->length
* sizeof (struct type
*));
317 memset (&f
->vector
[f_orig_length
], 0,
318 (f
->length
- f_orig_length
) * sizeof (struct type
*));
320 return (&f
->vector
[index
]);
324 /* Make sure there is a type allocated for type numbers TYPENUMS
325 and return the type object.
326 This can create an empty (zeroed) type object.
327 TYPENUMS may be (-1, -1) to return a new type object that is not
328 put into the type vector, and so may not be referred to by number. */
331 dbx_alloc_type (typenums
, objfile
)
333 struct objfile
*objfile
;
335 register struct type
**type_addr
;
337 if (typenums
[0] == -1)
339 return (alloc_type (objfile
));
342 type_addr
= dbx_lookup_type (typenums
);
344 /* If we are referring to a type not known at all yet,
345 allocate an empty type for it.
346 We will fill it in later if we find out how. */
349 *type_addr
= alloc_type (objfile
);
355 /* for all the stabs in a given stab vector, build appropriate types
356 and fix their symbols in given symbol vector. */
359 patch_block_stabs (symbols
, stabs
, objfile
)
360 struct pending
*symbols
;
361 struct pending_stabs
*stabs
;
362 struct objfile
*objfile
;
372 /* for all the stab entries, find their corresponding symbols and
373 patch their types! */
375 for (ii
= 0; ii
< stabs
->count
; ++ii
)
377 name
= stabs
->stab
[ii
];
378 pp
= (char*) strchr (name
, ':');
379 sym
= find_symbol_in_list (symbols
, name
, pp
-name
);
382 /* On xcoff, if a global is defined and never referenced,
383 ld will remove it from the executable. There is then
384 a N_GSYM stab for it, but no regular (C_EXT) symbol. */
385 sym
= (struct symbol
*)
386 obstack_alloc (&objfile
->symbol_obstack
,
387 sizeof (struct symbol
));
389 memset (sym
, 0, sizeof (struct symbol
));
390 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
391 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
393 obstack_copy0 (&objfile
->symbol_obstack
, name
, pp
- name
);
395 if (*(pp
-1) == 'F' || *(pp
-1) == 'f')
397 /* I don't think the linker does this with functions,
398 so as far as I know this is never executed.
399 But it doesn't hurt to check. */
401 lookup_function_type (read_type (&pp
, objfile
));
405 SYMBOL_TYPE (sym
) = read_type (&pp
, objfile
);
407 add_symbol_to_list (sym
, &global_symbols
);
412 if (*(pp
-1) == 'F' || *(pp
-1) == 'f')
415 lookup_function_type (read_type (&pp
, objfile
));
419 SYMBOL_TYPE (sym
) = read_type (&pp
, objfile
);
427 /* Read a number by which a type is referred to in dbx data,
428 or perhaps read a pair (FILENUM, TYPENUM) in parentheses.
429 Just a single number N is equivalent to (0,N).
430 Return the two numbers by storing them in the vector TYPENUMS.
431 TYPENUMS will then be used as an argument to dbx_lookup_type.
433 Returns 0 for success, -1 for error. */
436 read_type_number (pp
, typenums
)
438 register int *typenums
;
444 typenums
[0] = read_huge_number (pp
, ',', &nbits
);
445 if (nbits
!= 0) return -1;
446 typenums
[1] = read_huge_number (pp
, ')', &nbits
);
447 if (nbits
!= 0) return -1;
452 typenums
[1] = read_huge_number (pp
, 0, &nbits
);
453 if (nbits
!= 0) return -1;
459 /* To handle GNU C++ typename abbreviation, we need to be able to
460 fill in a type's name as soon as space for that type is allocated.
461 `type_synonym_name' is the name of the type being allocated.
462 It is cleared as soon as it is used (lest all allocated types
465 static char *type_synonym_name
;
469 define_symbol (valu
, string
, desc
, type
, objfile
)
474 struct objfile
*objfile
;
476 register struct symbol
*sym
;
477 char *p
= (char *) strchr (string
, ':');
482 /* We would like to eliminate nameless symbols, but keep their types.
483 E.g. stab entry ":t10=*2" should produce a type 10, which is a pointer
484 to type 2, but, should not create a symbol to address that type. Since
485 the symbol will be nameless, there is no way any user can refer to it. */
489 /* Ignore syms with empty names. */
493 /* Ignore old-style symbols from cc -go */
497 /* If a nameless stab entry, all we need is the type, not the symbol.
498 e.g. ":t10=*2" or a nameless enum like " :T16=ered:0,green:1,blue:2,;" */
499 nameless
= (p
== string
|| ((string
[0] == ' ') && (string
[1] == ':')));
501 sym
= (struct symbol
*)
502 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
503 memset (sym
, 0, sizeof (struct symbol
));
505 if (processing_gcc_compilation
)
507 /* GCC 2.x puts the line number in desc. SunOS apparently puts in the
508 number of bytes occupied by a type or object, which we ignore. */
509 SYMBOL_LINE(sym
) = desc
;
513 SYMBOL_LINE(sym
) = 0; /* unknown */
516 if (string
[0] == CPLUS_MARKER
)
518 /* Special GNU C++ names. */
522 SYMBOL_NAME (sym
) = obsavestring ("this", strlen ("this"),
523 &objfile
-> symbol_obstack
);
526 case 'v': /* $vtbl_ptr_type */
527 /* Was: SYMBOL_NAME (sym) = "vptr"; */
531 SYMBOL_NAME (sym
) = obsavestring ("eh_throw", strlen ("eh_throw"),
532 &objfile
-> symbol_obstack
);
536 /* This was an anonymous type that was never fixed up. */
540 complain (&unrecognized_cplus_name_complaint
, string
);
541 goto normal
; /* Do *something* with it */
547 SYMBOL_LANGUAGE (sym
) = current_subfile
-> language
;
548 SYMBOL_NAME (sym
) = (char *)
549 obstack_alloc (&objfile
-> symbol_obstack
, ((p
- string
) + 1));
550 /* Open-coded memcpy--saves function call time. */
551 /* FIXME: Does it really? Try replacing with simple strcpy and
552 try it on an executable with a large symbol table. */
553 /* FIXME: considering that gcc can open code memcpy anyway, I
554 doubt it. xoxorich. */
556 register char *p1
= string
;
557 register char *p2
= SYMBOL_NAME (sym
);
565 /* If this symbol is from a C++ compilation, then attempt to cache the
566 demangled form for future reference. This is a typical time versus
567 space tradeoff, that was decided in favor of time because it sped up
568 C++ symbol lookups by a factor of about 20. */
570 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
->symbol_obstack
);
574 /* Determine the type of name being defined. */
576 /* Getting GDB to correctly skip the symbol on an undefined symbol
577 descriptor and not ever dump core is a very dodgy proposition if
578 we do things this way. I say the acorn RISC machine can just
579 fix their compiler. */
580 /* The Acorn RISC machine's compiler can put out locals that don't
581 start with "234=" or "(3,4)=", so assume anything other than the
582 deftypes we know how to handle is a local. */
583 if (!strchr ("cfFGpPrStTvVXCR", *p
))
585 if (isdigit (*p
) || *p
== '(' || *p
== '-')
594 /* c is a special case, not followed by a type-number.
595 SYMBOL:c=iVALUE for an integer constant symbol.
596 SYMBOL:c=rVALUE for a floating constant symbol.
597 SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
598 e.g. "b:c=e6,0" for "const b = blob1"
599 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
602 SYMBOL_CLASS (sym
) = LOC_CONST
;
603 SYMBOL_TYPE (sym
) = error_type (&p
);
604 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
605 add_symbol_to_list (sym
, &file_symbols
);
616 /* FIXME: lookup_fundamental_type is a hack. We should be
617 creating a type especially for the type of float constants.
618 Problem is, what type should it be? We currently have to
619 read this in host floating point format, but what type
620 represents a host format "double"?
622 Also, what should the name of this type be? Should we
623 be using 'S' constants (see stabs.texinfo) instead? */
625 SYMBOL_TYPE (sym
) = lookup_fundamental_type (objfile
,
628 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (double));
629 memcpy (dbl_valu
, &d
, sizeof (double));
630 /* Put it in target byte order, but it's still in host
631 floating point format. */
632 SWAP_TARGET_AND_HOST (dbl_valu
, sizeof (double));
633 SYMBOL_VALUE_BYTES (sym
) = dbl_valu
;
634 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
639 /* Defining integer constants this way is kind of silly,
640 since 'e' constants allows the compiler to give not
641 only the value, but the type as well. C has at least
642 int, long, unsigned int, and long long as constant
643 types; other languages probably should have at least
644 unsigned as well as signed constants. */
646 /* We just need one int constant type for all objfiles.
647 It doesn't depend on languages or anything (arguably its
648 name should be a language-specific name for a type of
649 that size, but I'm inclined to say that if the compiler
650 wants a nice name for the type, it can use 'e'). */
651 static struct type
*int_const_type
;
653 /* Yes, this is as long as a *host* int. That is because we
655 if (int_const_type
== NULL
)
657 init_type (TYPE_CODE_INT
,
658 sizeof (int) * HOST_CHAR_BIT
/ TARGET_CHAR_BIT
, 0,
660 (struct objfile
*)NULL
);
661 SYMBOL_TYPE (sym
) = int_const_type
;
662 SYMBOL_VALUE (sym
) = atoi (p
);
663 SYMBOL_CLASS (sym
) = LOC_CONST
;
667 /* SYMBOL:c=eTYPE,INTVALUE for a constant symbol whose value
668 can be represented as integral.
669 e.g. "b:c=e6,0" for "const b = blob1"
670 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
672 SYMBOL_CLASS (sym
) = LOC_CONST
;
673 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
677 SYMBOL_TYPE (sym
) = error_type (&p
);
682 /* If the value is too big to fit in an int (perhaps because
683 it is unsigned), or something like that, we silently get
684 a bogus value. The type and everything else about it is
685 correct. Ideally, we should be using whatever we have
686 available for parsing unsigned and long long values,
688 SYMBOL_VALUE (sym
) = atoi (p
);
693 SYMBOL_CLASS (sym
) = LOC_CONST
;
694 SYMBOL_TYPE (sym
) = error_type (&p
);
697 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
698 add_symbol_to_list (sym
, &file_symbols
);
702 /* The name of a caught exception. */
703 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
704 SYMBOL_CLASS (sym
) = LOC_LABEL
;
705 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
706 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
707 add_symbol_to_list (sym
, &local_symbols
);
711 /* A static function definition. */
712 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
713 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
714 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
715 add_symbol_to_list (sym
, &file_symbols
);
716 /* fall into process_function_types. */
718 process_function_types
:
719 /* Function result types are described as the result type in stabs.
720 We need to convert this to the function-returning-type-X type
721 in GDB. E.g. "int" is converted to "function returning int". */
722 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_FUNC
)
725 /* This code doesn't work -- it needs to realloc and can't. */
726 /* Attempt to set up to record a function prototype... */
727 struct type
*new = alloc_type (objfile
);
729 /* Generate a template for the type of this function. The
730 types of the arguments will be added as we read the symbol
732 *new = *lookup_function_type (SYMBOL_TYPE(sym
));
733 SYMBOL_TYPE(sym
) = new;
734 TYPE_OBJFILE (new) = objfile
;
735 in_function_type
= new;
737 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
740 /* fall into process_prototype_types */
742 process_prototype_types
:
743 /* Sun acc puts declared types of arguments here. We don't care
744 about their actual types (FIXME -- we should remember the whole
745 function prototype), but the list may define some new types
746 that we have to remember, so we must scan it now. */
749 read_type (&p
, objfile
);
754 /* A global function definition. */
755 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
756 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
757 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
758 add_symbol_to_list (sym
, &global_symbols
);
759 goto process_function_types
;
762 /* For a class G (global) symbol, it appears that the
763 value is not correct. It is necessary to search for the
764 corresponding linker definition to find the value.
765 These definitions appear at the end of the namelist. */
766 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
767 i
= hashname (SYMBOL_NAME (sym
));
768 SYMBOL_VALUE_CHAIN (sym
) = global_sym_chain
[i
];
769 global_sym_chain
[i
] = sym
;
770 SYMBOL_CLASS (sym
) = LOC_STATIC
;
771 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
772 add_symbol_to_list (sym
, &global_symbols
);
775 /* This case is faked by a conditional above,
776 when there is no code letter in the dbx data.
777 Dbx data never actually contains 'l'. */
779 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
780 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
781 SYMBOL_VALUE (sym
) = valu
;
782 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
783 add_symbol_to_list (sym
, &local_symbols
);
788 /* pF is a two-letter code that means a function parameter in Fortran.
789 The type-number specifies the type of the return value.
790 Translate it into a pointer-to-function type. */
794 = lookup_pointer_type
795 (lookup_function_type (read_type (&p
, objfile
)));
798 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
800 /* Normally this is a parameter, a LOC_ARG. On the i960, it
801 can also be a LOC_LOCAL_ARG depending on symbol type. */
802 #ifndef DBX_PARM_SYMBOL_CLASS
803 #define DBX_PARM_SYMBOL_CLASS(type) LOC_ARG
806 SYMBOL_CLASS (sym
) = DBX_PARM_SYMBOL_CLASS (type
);
807 SYMBOL_VALUE (sym
) = valu
;
808 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
810 /* This doesn't work yet. */
811 add_param_to_type (&in_function_type
, sym
);
813 add_symbol_to_list (sym
, &local_symbols
);
815 /* If it's gcc-compiled, if it says `short', believe it. */
816 if (processing_gcc_compilation
|| BELIEVE_PCC_PROMOTION
)
819 #if !BELIEVE_PCC_PROMOTION
821 /* This is the signed type which arguments get promoted to. */
822 static struct type
*pcc_promotion_type
;
823 /* This is the unsigned type which arguments get promoted to. */
824 static struct type
*pcc_unsigned_promotion_type
;
826 /* Call it "int" because this is mainly C lossage. */
827 if (pcc_promotion_type
== NULL
)
829 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
832 if (pcc_unsigned_promotion_type
== NULL
)
833 pcc_unsigned_promotion_type
=
834 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
835 TYPE_FLAG_UNSIGNED
, "unsigned int", NULL
);
837 #if defined(BELIEVE_PCC_PROMOTION_TYPE)
838 /* This macro is defined on machines (e.g. sparc) where
839 we should believe the type of a PCC 'short' argument,
840 but shouldn't believe the address (the address is
841 the address of the corresponding int). Note that
842 this is only different from the BELIEVE_PCC_PROMOTION
843 case on big-endian machines.
845 My guess is that this correction, as opposed to changing
846 the parameter to an 'int' (as done below, for PCC
847 on most machines), is the right thing to do
848 on all machines, but I don't want to risk breaking
849 something that already works. On most PCC machines,
850 the sparc problem doesn't come up because the calling
851 function has to zero the top bytes (not knowing whether
852 the called function wants an int or a short), so there
853 is no practical difference between an int and a short
854 (except perhaps what happens when the GDB user types
855 "print short_arg = 0x10000;").
857 Hacked for SunOS 4.1 by gnu@cygnus.com. In 4.1, the compiler
858 actually produces the correct address (we don't need to fix it
859 up). I made this code adapt so that it will offset the symbol
860 if it was pointing at an int-aligned location and not
861 otherwise. This way you can use the same gdb for 4.0.x and
864 If the parameter is shorter than an int, and is integral
865 (e.g. char, short, or unsigned equivalent), and is claimed to
866 be passed on an integer boundary, don't believe it! Offset the
867 parameter's address to the tail-end of that integer. */
869 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (pcc_promotion_type
)
870 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
871 && 0 == SYMBOL_VALUE (sym
) % TYPE_LENGTH (pcc_promotion_type
))
873 SYMBOL_VALUE (sym
) += TYPE_LENGTH (pcc_promotion_type
)
874 - TYPE_LENGTH (SYMBOL_TYPE (sym
));
878 #else /* no BELIEVE_PCC_PROMOTION_TYPE. */
880 /* If PCC says a parameter is a short or a char,
881 it is really an int. */
882 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (pcc_promotion_type
)
883 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
)
886 TYPE_UNSIGNED (SYMBOL_TYPE (sym
))
887 ? pcc_unsigned_promotion_type
888 : pcc_promotion_type
;
892 #endif /* no BELIEVE_PCC_PROMOTION_TYPE. */
894 #endif /* !BELIEVE_PCC_PROMOTION. */
897 /* acc seems to use P to delare the prototypes of functions that
898 are referenced by this file. gdb is not prepared to deal
899 with this extra information. FIXME, it ought to. */
902 read_type (&p
, objfile
);
903 goto process_prototype_types
;
908 /* Parameter which is in a register. */
909 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
910 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
911 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (valu
);
912 if (SYMBOL_VALUE (sym
) >= NUM_REGS
)
914 complain (®_value_complaint
, SYMBOL_SOURCE_NAME (sym
));
915 SYMBOL_VALUE (sym
) = SP_REGNUM
; /* Known safe, though useless */
917 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
918 add_symbol_to_list (sym
, &local_symbols
);
922 /* Register variable (either global or local). */
923 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
924 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
925 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (valu
);
926 if (SYMBOL_VALUE (sym
) >= NUM_REGS
)
928 complain (®_value_complaint
, SYMBOL_SOURCE_NAME (sym
));
929 SYMBOL_VALUE (sym
) = SP_REGNUM
; /* Known safe, though useless */
931 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
934 /* Sun cc uses a pair of symbols, one 'p' and one 'r' with the same
935 name to represent an argument passed in a register.
936 GCC uses 'P' for the same case. So if we find such a symbol pair
937 we combine it into one 'P' symbol.
938 Note that this code illegally combines
939 main(argc) int argc; { register int argc = 1; }
940 but this case is considered pathological and causes a warning
941 from a decent compiler. */
943 && local_symbols
->nsyms
> 0)
945 struct symbol
*prev_sym
;
946 prev_sym
= local_symbols
->symbol
[local_symbols
->nsyms
- 1];
947 if (SYMBOL_CLASS (prev_sym
) == LOC_ARG
948 && STREQ (SYMBOL_NAME (prev_sym
), SYMBOL_NAME(sym
)))
950 SYMBOL_CLASS (prev_sym
) = LOC_REGPARM
;
951 /* Use the type from the LOC_REGISTER; that is the type
952 that is actually in that register. */
953 SYMBOL_TYPE (prev_sym
) = SYMBOL_TYPE (sym
);
954 SYMBOL_VALUE (prev_sym
) = SYMBOL_VALUE (sym
);
959 add_symbol_to_list (sym
, &local_symbols
);
962 add_symbol_to_list (sym
, &file_symbols
);
966 /* Static symbol at top level of file */
967 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
968 SYMBOL_CLASS (sym
) = LOC_STATIC
;
969 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
970 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
971 add_symbol_to_list (sym
, &file_symbols
);
976 /* See comment where long_kludge_name is declared. */
977 /* Here we save the name of the symbol for read_range_type, which
978 ends up reading in the basic types. In stabs, unfortunately there
979 is no distinction between "int" and "long" types except their
980 names. Until we work out a saner type policy (eliminating most
981 builtin types and using the names specified in the files), we
982 save away the name so that far away from here in read_range_type,
983 we can examine it to decide between "int" and "long". FIXME. */
984 long_kludge_name
= SYMBOL_NAME (sym
);
986 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
988 /* For a nameless type, we don't want a create a symbol, thus we
989 did not use `sym'. Return without further processing. */
990 if (nameless
) return NULL
;
992 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
993 SYMBOL_VALUE (sym
) = valu
;
994 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
995 /* C++ vagaries: we may have a type which is derived from
996 a base type which did not have its name defined when the
997 derived class was output. We fill in the derived class's
998 base part member's name here in that case. */
999 if (TYPE_NAME (SYMBOL_TYPE (sym
)) != NULL
)
1000 if ((TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
1001 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_UNION
)
1002 && TYPE_N_BASECLASSES (SYMBOL_TYPE (sym
)))
1005 for (j
= TYPE_N_BASECLASSES (SYMBOL_TYPE (sym
)) - 1; j
>= 0; j
--)
1006 if (TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym
), j
) == 0)
1007 TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym
), j
) =
1008 type_name_no_tag (TYPE_BASECLASS (SYMBOL_TYPE (sym
), j
));
1011 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == NULL
)
1013 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_PTR
1014 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FUNC
)
1016 /* If we are giving a name to a type such as "pointer to
1017 foo" or "function returning foo", we better not set
1018 the TYPE_NAME. If the program contains "typedef char
1019 *caddr_t;", we don't want all variables of type char
1020 * to print as caddr_t. This is not just a
1021 consequence of GDB's type management; PCC and GCC (at
1022 least through version 2.4) both output variables of
1023 either type char * or caddr_t with the type number
1024 defined in the 't' symbol for caddr_t. If a future
1025 compiler cleans this up it GDB is not ready for it
1026 yet, but if it becomes ready we somehow need to
1027 disable this check (without breaking the PCC/GCC2.4
1032 Fortunately, this check seems not to be necessary
1033 for anything except pointers or functions. */
1036 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_NAME (sym
);
1039 add_symbol_to_list (sym
, &file_symbols
);
1043 /* Struct, union, or enum tag. For GNU C++, this can be be followed
1044 by 't' which means we are typedef'ing it as well. */
1045 synonym
= *p
== 't';
1050 type_synonym_name
= obsavestring (SYMBOL_NAME (sym
),
1051 strlen (SYMBOL_NAME (sym
)),
1052 &objfile
-> symbol_obstack
);
1055 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1057 /* For a nameless type, we don't want a create a symbol, thus we
1058 did not use `sym'. Return without further processing. */
1059 if (nameless
) return NULL
;
1061 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1062 SYMBOL_VALUE (sym
) = valu
;
1063 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
1064 if (TYPE_TAG_NAME (SYMBOL_TYPE (sym
)) == 0)
1065 TYPE_TAG_NAME (SYMBOL_TYPE (sym
))
1066 = obconcat (&objfile
-> type_obstack
, "", "", SYMBOL_NAME (sym
));
1067 add_symbol_to_list (sym
, &file_symbols
);
1071 /* Clone the sym and then modify it. */
1072 register struct symbol
*typedef_sym
= (struct symbol
*)
1073 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
1074 *typedef_sym
= *sym
;
1075 SYMBOL_CLASS (typedef_sym
) = LOC_TYPEDEF
;
1076 SYMBOL_VALUE (typedef_sym
) = valu
;
1077 SYMBOL_NAMESPACE (typedef_sym
) = VAR_NAMESPACE
;
1078 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
1079 TYPE_NAME (SYMBOL_TYPE (sym
))
1080 = obconcat (&objfile
-> type_obstack
, "", "", SYMBOL_NAME (sym
));
1081 add_symbol_to_list (typedef_sym
, &file_symbols
);
1086 /* Static symbol of local scope */
1087 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1088 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1089 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
1090 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1091 add_symbol_to_list (sym
, &local_symbols
);
1095 /* Reference parameter */
1096 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1097 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
1098 SYMBOL_VALUE (sym
) = valu
;
1099 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1100 add_symbol_to_list (sym
, &local_symbols
);
1104 /* This is used by Sun FORTRAN for "function result value".
1105 Sun claims ("dbx and dbxtool interfaces", 2nd ed)
1106 that Pascal uses it too, but when I tried it Pascal used
1107 "x:3" (local symbol) instead. */
1108 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1109 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
1110 SYMBOL_VALUE (sym
) = valu
;
1111 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1112 add_symbol_to_list (sym
, &local_symbols
);
1116 SYMBOL_TYPE (sym
) = error_type (&p
);
1117 SYMBOL_CLASS (sym
) = LOC_CONST
;
1118 SYMBOL_VALUE (sym
) = 0;
1119 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1120 add_symbol_to_list (sym
, &file_symbols
);
1124 /* When passing structures to a function, some systems sometimes pass
1125 the address in a register, not the structure itself.
1127 If REG_STRUCT_HAS_ADDR yields non-zero we have to convert LOC_REGPARM
1128 to LOC_REGPARM_ADDR for structures and unions. */
1130 #if !defined (REG_STRUCT_HAS_ADDR)
1131 #define REG_STRUCT_HAS_ADDR(gcc_p) 0
1134 if (SYMBOL_CLASS (sym
) == LOC_REGPARM
1135 && REG_STRUCT_HAS_ADDR (processing_gcc_compilation
)
1136 && ( (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
1137 || (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_UNION
)))
1138 SYMBOL_CLASS (sym
) = LOC_REGPARM_ADDR
;
1144 /* Skip rest of this symbol and return an error type.
1146 General notes on error recovery: error_type always skips to the
1147 end of the symbol (modulo cretinous dbx symbol name continuation).
1148 Thus code like this:
1150 if (*(*pp)++ != ';')
1151 return error_type (pp);
1153 is wrong because if *pp starts out pointing at '\0' (typically as the
1154 result of an earlier error), it will be incremented to point to the
1155 start of the next symbol, which might produce strange results, at least
1156 if you run off the end of the string table. Instead use
1159 return error_type (pp);
1165 foo = error_type (pp);
1169 And in case it isn't obvious, the point of all this hair is so the compiler
1170 can define new types and new syntaxes, and old versions of the
1171 debugger will be able to read the new symbol tables. */
1173 static struct type
*
1177 complain (&error_type_complaint
);
1180 /* Skip to end of symbol. */
1181 while (**pp
!= '\0')
1186 /* Check for and handle cretinous dbx symbol name continuation! */
1187 if ((*pp
)[-1] == '\\')
1189 *pp
= next_symbol_text ();
1196 return (builtin_type_error
);
1200 /* Read type information or a type definition; return the type. Even
1201 though this routine accepts either type information or a type
1202 definition, the distinction is relevant--some parts of stabsread.c
1203 assume that type information starts with a digit, '-', or '(' in
1204 deciding whether to call read_type. */
1207 read_type (pp
, objfile
)
1209 struct objfile
*objfile
;
1211 register struct type
*type
= 0;
1215 char type_descriptor
;
1217 /* Size in bits of type if specified by a type attribute, or -1 if
1218 there is no size attribute. */
1221 /* Read type number if present. The type number may be omitted.
1222 for instance in a two-dimensional array declared with type
1223 "ar1;1;10;ar1;1;10;4". */
1224 if ((**pp
>= '0' && **pp
<= '9')
1228 if (read_type_number (pp
, typenums
) != 0)
1229 return error_type (pp
);
1231 /* Type is not being defined here. Either it already exists,
1232 or this is a forward reference to it. dbx_alloc_type handles
1235 return dbx_alloc_type (typenums
, objfile
);
1237 /* Type is being defined here. */
1244 /* It might be a type attribute or a member type. */
1245 if (isdigit (*p
) || *p
== '(' || *p
== '-')
1250 /* Type attributes. */
1253 /* Skip to the semicolon. */
1254 while (*p
!= ';' && *p
!= '\0')
1258 return error_type (pp
);
1260 /* Skip the semicolon. */
1266 type_size
= atoi (attr
+ 1);
1271 /* Ignore unrecognized type attributes, so future compilers
1272 can invent new ones. */
1277 /* Skip the type descriptor, we get it below with (*pp)[-1]. */
1282 /* 'typenums=' not present, type is anonymous. Read and return
1283 the definition, but don't put it in the type vector. */
1284 typenums
[0] = typenums
[1] = -1;
1288 type_descriptor
= (*pp
)[-1];
1289 switch (type_descriptor
)
1293 enum type_code code
;
1295 /* Used to index through file_symbols. */
1296 struct pending
*ppt
;
1299 /* Name including "struct", etc. */
1305 /* Set the type code according to the following letter. */
1309 code
= TYPE_CODE_STRUCT
;
1312 code
= TYPE_CODE_UNION
;
1315 code
= TYPE_CODE_ENUM
;
1318 return error_type (pp
);
1321 to
= type_name
= (char *)
1322 obstack_alloc (&objfile
-> type_obstack
,
1323 (((char *) strchr (*pp
, ':') - (*pp
)) + 1));
1325 /* Copy the name. */
1327 while ((*to
++ = *from
++) != ':')
1331 /* Set the pointer ahead of the name which we just read. */
1335 /* Now check to see whether the type has already been declared. */
1336 /* This is necessary at least in the case where the
1337 program says something like
1339 The compiler puts out a cross-reference; we better find
1340 set the length of the structure correctly so we can
1341 set the length of the array. */
1342 for (ppt
= file_symbols
; ppt
; ppt
= ppt
->next
)
1343 for (i
= 0; i
< ppt
->nsyms
; i
++)
1345 struct symbol
*sym
= ppt
->symbol
[i
];
1347 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
1348 && SYMBOL_NAMESPACE (sym
) == STRUCT_NAMESPACE
1349 && (TYPE_CODE (SYMBOL_TYPE (sym
)) == code
)
1350 && STREQ (SYMBOL_NAME (sym
), type_name
))
1352 obstack_free (&objfile
-> type_obstack
, type_name
);
1353 type
= SYMBOL_TYPE (sym
);
1358 /* Didn't find the type to which this refers, so we must
1359 be dealing with a forward reference. Allocate a type
1360 structure for it, and keep track of it so we can
1361 fill in the rest of the fields when we get the full
1363 type
= dbx_alloc_type (typenums
, objfile
);
1364 TYPE_CODE (type
) = code
;
1365 TYPE_TAG_NAME (type
) = type_name
;
1366 INIT_CPLUS_SPECIFIC(type
);
1367 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
1369 add_undefined_type (type
);
1373 case '-': /* RS/6000 built-in type */
1387 if (read_type_number (pp
, xtypenums
) != 0)
1388 return error_type (pp
);
1390 if (typenums
[0] == xtypenums
[0] && typenums
[1] == xtypenums
[1])
1391 /* It's being defined as itself. That means it is "void". */
1392 type
= init_type (TYPE_CODE_VOID
, 0, 0, NULL
, objfile
);
1395 struct type
*xtype
= *dbx_lookup_type (xtypenums
);
1397 /* This can happen if we had '-' followed by a garbage character,
1400 return error_type (pp
);
1402 /* The type is being defined to another type. So we copy the type.
1403 This loses if we copy a C++ class and so we lose track of how
1404 the names are mangled (but g++ doesn't output stabs like this
1407 type
= alloc_type (objfile
);
1408 memcpy (type
, xtype
, sizeof (struct type
));
1410 /* The idea behind clearing the names is that the only purpose
1411 for defining a type to another type is so that the name of
1412 one can be different. So we probably don't need to worry much
1413 about the case where the compiler doesn't give a name to the
1415 TYPE_NAME (type
) = NULL
;
1416 TYPE_TAG_NAME (type
) = NULL
;
1418 if (typenums
[0] != -1)
1419 *dbx_lookup_type (typenums
) = type
;
1422 /* In the following types, we must be sure to overwrite any existing
1423 type that the typenums refer to, rather than allocating a new one
1424 and making the typenums point to the new one. This is because there
1425 may already be pointers to the existing type (if it had been
1426 forward-referenced), and we must change it to a pointer, function,
1427 reference, or whatever, *in-place*. */
1430 type1
= read_type (pp
, objfile
);
1431 type
= make_pointer_type (type1
, dbx_lookup_type (typenums
));
1434 case '&': /* Reference to another type */
1435 type1
= read_type (pp
, objfile
);
1436 type
= make_reference_type (type1
, dbx_lookup_type (typenums
));
1439 case 'f': /* Function returning another type */
1440 type1
= read_type (pp
, objfile
);
1441 type
= make_function_type (type1
, dbx_lookup_type (typenums
));
1444 case 'k': /* Const qualifier on some type (Sun) */
1445 type
= read_type (pp
, objfile
);
1446 /* FIXME! For now, we ignore const and volatile qualifiers. */
1449 case 'B': /* Volatile qual on some type (Sun) */
1450 type
= read_type (pp
, objfile
);
1451 /* FIXME! For now, we ignore const and volatile qualifiers. */
1454 /* FIXME -- we should be doing smash_to_XXX types here. */
1455 case '@': /* Member (class & variable) type */
1457 struct type
*domain
= read_type (pp
, objfile
);
1458 struct type
*memtype
;
1461 /* Invalid member type data format. */
1462 return error_type (pp
);
1465 memtype
= read_type (pp
, objfile
);
1466 type
= dbx_alloc_type (typenums
, objfile
);
1467 smash_to_member_type (type
, domain
, memtype
);
1471 case '#': /* Method (class & fn) type */
1472 if ((*pp
)[0] == '#')
1474 /* We'll get the parameter types from the name. */
1475 struct type
*return_type
;
1478 return_type
= read_type (pp
, objfile
);
1479 if (*(*pp
)++ != ';')
1480 complain (&invalid_member_complaint
, symnum
);
1481 type
= allocate_stub_method (return_type
);
1482 if (typenums
[0] != -1)
1483 *dbx_lookup_type (typenums
) = type
;
1487 struct type
*domain
= read_type (pp
, objfile
);
1488 struct type
*return_type
;
1492 /* Invalid member type data format. */
1493 return error_type (pp
);
1497 return_type
= read_type (pp
, objfile
);
1498 args
= read_args (pp
, ';', objfile
);
1499 type
= dbx_alloc_type (typenums
, objfile
);
1500 smash_to_method_type (type
, domain
, return_type
, args
);
1504 case 'r': /* Range type */
1505 type
= read_range_type (pp
, typenums
, objfile
);
1506 if (typenums
[0] != -1)
1507 *dbx_lookup_type (typenums
) = type
;
1510 case 'b': /* Sun ACC builtin int type */
1511 type
= read_sun_builtin_type (pp
, typenums
, objfile
);
1512 if (typenums
[0] != -1)
1513 *dbx_lookup_type (typenums
) = type
;
1516 case 'R': /* Sun ACC builtin float type */
1517 type
= read_sun_floating_type (pp
, typenums
, objfile
);
1518 if (typenums
[0] != -1)
1519 *dbx_lookup_type (typenums
) = type
;
1522 case 'e': /* Enumeration type */
1523 type
= dbx_alloc_type (typenums
, objfile
);
1524 type
= read_enum_type (pp
, type
, objfile
);
1525 if (typenums
[0] != -1)
1526 *dbx_lookup_type (typenums
) = type
;
1529 case 's': /* Struct type */
1530 case 'u': /* Union type */
1531 type
= dbx_alloc_type (typenums
, objfile
);
1532 if (!TYPE_NAME (type
))
1534 TYPE_NAME (type
) = type_synonym_name
;
1536 type_synonym_name
= NULL
;
1537 switch (type_descriptor
)
1540 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
1543 TYPE_CODE (type
) = TYPE_CODE_UNION
;
1546 type
= read_struct_type (pp
, type
, objfile
);
1549 case 'a': /* Array type */
1551 return error_type (pp
);
1554 type
= dbx_alloc_type (typenums
, objfile
);
1555 type
= read_array_type (pp
, type
, objfile
);
1559 --*pp
; /* Go back to the symbol in error */
1560 /* Particularly important if it was \0! */
1561 return error_type (pp
);
1566 warning ("GDB internal error, type is NULL in stabsread.c\n");
1567 return error_type (pp
);
1570 /* Size specified in a type attribute overrides any other size. */
1571 if (type_size
!= -1)
1572 TYPE_LENGTH (type
) = type_size
/ TARGET_CHAR_BIT
;
1577 /* RS/6000 xlc/dbx combination uses a set of builtin types, starting from -1.
1578 Return the proper type node for a given builtin type number. */
1580 static struct type
*
1581 rs6000_builtin_type (typenum
)
1584 /* We recognize types numbered from -NUMBER_RECOGNIZED to -1. */
1585 #define NUMBER_RECOGNIZED 30
1586 /* This includes an empty slot for type number -0. */
1587 static struct type
*negative_types
[NUMBER_RECOGNIZED
+ 1];
1588 struct type
*rettype
= NULL
;
1590 if (typenum
>= 0 || typenum
< -NUMBER_RECOGNIZED
)
1592 complain (&rs6000_builtin_complaint
, typenum
);
1593 return builtin_type_error
;
1595 if (negative_types
[-typenum
] != NULL
)
1596 return negative_types
[-typenum
];
1598 #if TARGET_CHAR_BIT != 8
1599 #error This code wrong for TARGET_CHAR_BIT not 8
1600 /* These definitions all assume that TARGET_CHAR_BIT is 8. I think
1601 that if that ever becomes not true, the correct fix will be to
1602 make the size in the struct type to be in bits, not in units of
1609 /* The size of this and all the other types are fixed, defined
1610 by the debugging format. If there is a type called "int" which
1611 is other than 32 bits, then it should use a new negative type
1612 number (or avoid negative type numbers for that case).
1613 See stabs.texinfo. */
1614 rettype
= init_type (TYPE_CODE_INT
, 4, 0, "int", NULL
);
1617 rettype
= init_type (TYPE_CODE_INT
, 1, 0, "char", NULL
);
1620 rettype
= init_type (TYPE_CODE_INT
, 2, 0, "short", NULL
);
1623 rettype
= init_type (TYPE_CODE_INT
, 4, 0, "long", NULL
);
1626 rettype
= init_type (TYPE_CODE_INT
, 1, TYPE_FLAG_UNSIGNED
,
1627 "unsigned char", NULL
);
1630 rettype
= init_type (TYPE_CODE_INT
, 1, 0, "signed char", NULL
);
1633 rettype
= init_type (TYPE_CODE_INT
, 2, TYPE_FLAG_UNSIGNED
,
1634 "unsigned short", NULL
);
1637 rettype
= init_type (TYPE_CODE_INT
, 4, TYPE_FLAG_UNSIGNED
,
1638 "unsigned int", NULL
);
1641 rettype
= init_type (TYPE_CODE_INT
, 4, TYPE_FLAG_UNSIGNED
,
1644 rettype
= init_type (TYPE_CODE_INT
, 4, TYPE_FLAG_UNSIGNED
,
1645 "unsigned long", NULL
);
1648 rettype
= init_type (TYPE_CODE_VOID
, 0, 0, "void", NULL
);
1651 /* IEEE single precision (32 bit). */
1652 rettype
= init_type (TYPE_CODE_FLT
, 4, 0, "float", NULL
);
1655 /* IEEE double precision (64 bit). */
1656 rettype
= init_type (TYPE_CODE_FLT
, 8, 0, "double", NULL
);
1659 /* This is an IEEE double on the RS/6000, and different machines with
1660 different sizes for "long double" should use different negative
1661 type numbers. See stabs.texinfo. */
1662 rettype
= init_type (TYPE_CODE_FLT
, 8, 0, "long double", NULL
);
1665 rettype
= init_type (TYPE_CODE_INT
, 4, 0, "integer", NULL
);
1668 rettype
= init_type (TYPE_CODE_BOOL
, 4, 0, "boolean", NULL
);
1671 rettype
= init_type (TYPE_CODE_FLT
, 4, 0, "short real", NULL
);
1674 rettype
= init_type (TYPE_CODE_FLT
, 8, 0, "real", NULL
);
1677 rettype
= init_type (TYPE_CODE_ERROR
, 0, 0, "stringptr", NULL
);
1680 rettype
= init_type (TYPE_CODE_CHAR
, 1, TYPE_FLAG_UNSIGNED
,
1684 rettype
= init_type (TYPE_CODE_BOOL
, 1, TYPE_FLAG_UNSIGNED
,
1688 rettype
= init_type (TYPE_CODE_BOOL
, 2, TYPE_FLAG_UNSIGNED
,
1692 rettype
= init_type (TYPE_CODE_BOOL
, 4, TYPE_FLAG_UNSIGNED
,
1696 rettype
= init_type (TYPE_CODE_BOOL
, 4, TYPE_FLAG_UNSIGNED
,
1700 /* Complex type consisting of two IEEE single precision values. */
1701 rettype
= init_type (TYPE_CODE_ERROR
, 8, 0, "complex", NULL
);
1704 /* Complex type consisting of two IEEE double precision values. */
1705 rettype
= init_type (TYPE_CODE_ERROR
, 16, 0, "double complex", NULL
);
1708 rettype
= init_type (TYPE_CODE_INT
, 1, 0, "integer*1", NULL
);
1711 rettype
= init_type (TYPE_CODE_INT
, 2, 0, "integer*2", NULL
);
1714 rettype
= init_type (TYPE_CODE_INT
, 4, 0, "integer*4", NULL
);
1717 rettype
= init_type (TYPE_CODE_CHAR
, 2, 0, "wchar", NULL
);
1720 negative_types
[-typenum
] = rettype
;
1724 /* This page contains subroutines of read_type. */
1726 #define VISIBILITY_PRIVATE '0' /* Stabs character for private field */
1727 #define VISIBILITY_PROTECTED '1' /* Stabs character for protected fld */
1728 #define VISIBILITY_PUBLIC '2' /* Stabs character for public field */
1730 /* Read member function stabs info for C++ classes. The form of each member
1733 NAME :: TYPENUM[=type definition] ARGS : PHYSNAME ;
1735 An example with two member functions is:
1737 afunc1::20=##15;:i;2A.;afunc2::20:i;2A.;
1739 For the case of overloaded operators, the format is op$::*.funcs, where
1740 $ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator
1741 name (such as `+=') and `.' marks the end of the operator name.
1743 Returns 1 for success, 0 for failure. */
1746 read_member_functions (fip
, pp
, type
, objfile
)
1747 struct field_info
*fip
;
1750 struct objfile
*objfile
;
1754 /* Total number of member functions defined in this class. If the class
1755 defines two `f' functions, and one `g' function, then this will have
1757 int total_length
= 0;
1761 struct next_fnfield
*next
;
1762 struct fn_field fn_field
;
1764 struct type
*look_ahead_type
;
1765 struct next_fnfieldlist
*new_fnlist
;
1766 struct next_fnfield
*new_sublist
;
1770 /* Process each list until we find something that is not a member function
1771 or find the end of the functions. */
1775 /* We should be positioned at the start of the function name.
1776 Scan forward to find the first ':' and if it is not the
1777 first of a "::" delimiter, then this is not a member function. */
1789 look_ahead_type
= NULL
;
1792 new_fnlist
= (struct next_fnfieldlist
*)
1793 xmalloc (sizeof (struct next_fnfieldlist
));
1794 make_cleanup (free
, new_fnlist
);
1795 memset (new_fnlist
, 0, sizeof (struct next_fnfieldlist
));
1797 if ((*pp
)[0] == 'o' && (*pp
)[1] == 'p' && (*pp
)[2] == CPLUS_MARKER
)
1799 /* This is a completely wierd case. In order to stuff in the
1800 names that might contain colons (the usual name delimiter),
1801 Mike Tiemann defined a different name format which is
1802 signalled if the identifier is "op$". In that case, the
1803 format is "op$::XXXX." where XXXX is the name. This is
1804 used for names like "+" or "=". YUUUUUUUK! FIXME! */
1805 /* This lets the user type "break operator+".
1806 We could just put in "+" as the name, but that wouldn't
1808 static char opname
[32] = {'o', 'p', CPLUS_MARKER
};
1809 char *o
= opname
+ 3;
1811 /* Skip past '::'. */
1814 STABS_CONTINUE (pp
);
1820 main_fn_name
= savestring (opname
, o
- opname
);
1826 main_fn_name
= savestring (*pp
, p
- *pp
);
1827 /* Skip past '::'. */
1830 new_fnlist
-> fn_fieldlist
.name
= main_fn_name
;
1835 (struct next_fnfield
*) xmalloc (sizeof (struct next_fnfield
));
1836 make_cleanup (free
, new_sublist
);
1837 memset (new_sublist
, 0, sizeof (struct next_fnfield
));
1839 /* Check for and handle cretinous dbx symbol name continuation! */
1840 if (look_ahead_type
== NULL
)
1843 STABS_CONTINUE (pp
);
1845 new_sublist
-> fn_field
.type
= read_type (pp
, objfile
);
1848 /* Invalid symtab info for member function. */
1854 /* g++ version 1 kludge */
1855 new_sublist
-> fn_field
.type
= look_ahead_type
;
1856 look_ahead_type
= NULL
;
1866 /* If this is just a stub, then we don't have the real name here. */
1868 if (TYPE_FLAGS (new_sublist
-> fn_field
.type
) & TYPE_FLAG_STUB
)
1870 if (!TYPE_DOMAIN_TYPE (new_sublist
-> fn_field
.type
))
1871 TYPE_DOMAIN_TYPE (new_sublist
-> fn_field
.type
) = type
;
1872 new_sublist
-> fn_field
.is_stub
= 1;
1874 new_sublist
-> fn_field
.physname
= savestring (*pp
, p
- *pp
);
1877 /* Set this member function's visibility fields. */
1880 case VISIBILITY_PRIVATE
:
1881 new_sublist
-> fn_field
.is_private
= 1;
1883 case VISIBILITY_PROTECTED
:
1884 new_sublist
-> fn_field
.is_protected
= 1;
1888 STABS_CONTINUE (pp
);
1891 case 'A': /* Normal functions. */
1892 new_sublist
-> fn_field
.is_const
= 0;
1893 new_sublist
-> fn_field
.is_volatile
= 0;
1896 case 'B': /* `const' member functions. */
1897 new_sublist
-> fn_field
.is_const
= 1;
1898 new_sublist
-> fn_field
.is_volatile
= 0;
1901 case 'C': /* `volatile' member function. */
1902 new_sublist
-> fn_field
.is_const
= 0;
1903 new_sublist
-> fn_field
.is_volatile
= 1;
1906 case 'D': /* `const volatile' member function. */
1907 new_sublist
-> fn_field
.is_const
= 1;
1908 new_sublist
-> fn_field
.is_volatile
= 1;
1911 case '*': /* File compiled with g++ version 1 -- no info */
1916 complain (&const_vol_complaint
, **pp
);
1925 /* virtual member function, followed by index.
1926 The sign bit is set to distinguish pointers-to-methods
1927 from virtual function indicies. Since the array is
1928 in words, the quantity must be shifted left by 1
1929 on 16 bit machine, and by 2 on 32 bit machine, forcing
1930 the sign bit out, and usable as a valid index into
1931 the array. Remove the sign bit here. */
1932 new_sublist
-> fn_field
.voffset
=
1933 (0x7fffffff & read_huge_number (pp
, ';', &nbits
)) + 2;
1937 STABS_CONTINUE (pp
);
1938 if (**pp
== ';' || **pp
== '\0')
1940 /* Must be g++ version 1. */
1941 new_sublist
-> fn_field
.fcontext
= 0;
1945 /* Figure out from whence this virtual function came.
1946 It may belong to virtual function table of
1947 one of its baseclasses. */
1948 look_ahead_type
= read_type (pp
, objfile
);
1951 /* g++ version 1 overloaded methods. */
1955 new_sublist
-> fn_field
.fcontext
= look_ahead_type
;
1964 look_ahead_type
= NULL
;
1970 /* static member function. */
1971 new_sublist
-> fn_field
.voffset
= VOFFSET_STATIC
;
1972 if (strncmp (new_sublist
-> fn_field
.physname
,
1973 main_fn_name
, strlen (main_fn_name
)))
1975 new_sublist
-> fn_field
.is_stub
= 1;
1981 complain (&member_fn_complaint
, (*pp
)[-1]);
1982 /* Fall through into normal member function. */
1985 /* normal member function. */
1986 new_sublist
-> fn_field
.voffset
= 0;
1987 new_sublist
-> fn_field
.fcontext
= 0;
1991 new_sublist
-> next
= sublist
;
1992 sublist
= new_sublist
;
1994 STABS_CONTINUE (pp
);
1996 while (**pp
!= ';' && **pp
!= '\0');
2000 new_fnlist
-> fn_fieldlist
.fn_fields
= (struct fn_field
*)
2001 obstack_alloc (&objfile
-> type_obstack
,
2002 sizeof (struct fn_field
) * length
);
2003 memset (new_fnlist
-> fn_fieldlist
.fn_fields
, 0,
2004 sizeof (struct fn_field
) * length
);
2005 for (i
= length
; (i
--, sublist
); sublist
= sublist
-> next
)
2007 new_fnlist
-> fn_fieldlist
.fn_fields
[i
] = sublist
-> fn_field
;
2010 new_fnlist
-> fn_fieldlist
.length
= length
;
2011 new_fnlist
-> next
= fip
-> fnlist
;
2012 fip
-> fnlist
= new_fnlist
;
2014 total_length
+= length
;
2015 STABS_CONTINUE (pp
);
2020 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2021 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
2022 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * nfn_fields
);
2023 memset (TYPE_FN_FIELDLISTS (type
), 0,
2024 sizeof (struct fn_fieldlist
) * nfn_fields
);
2025 TYPE_NFN_FIELDS (type
) = nfn_fields
;
2026 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
2032 /* Special GNU C++ name.
2034 Returns 1 for success, 0 for failure. "failure" means that we can't
2035 keep parsing and it's time for error_type(). */
2038 read_cpp_abbrev (fip
, pp
, type
, objfile
)
2039 struct field_info
*fip
;
2042 struct objfile
*objfile
;
2047 struct type
*context
;
2057 /* At this point, *pp points to something like "22:23=*22...",
2058 where the type number before the ':' is the "context" and
2059 everything after is a regular type definition. Lookup the
2060 type, find it's name, and construct the field name. */
2062 context
= read_type (pp
, objfile
);
2066 case 'f': /* $vf -- a virtual function table pointer */
2067 fip
->list
->field
.name
=
2068 obconcat (&objfile
->type_obstack
, vptr_name
, "", "");
2071 case 'b': /* $vb -- a virtual bsomethingorother */
2072 name
= type_name_no_tag (context
);
2075 complain (&invalid_cpp_type_complaint
, symnum
);
2078 fip
->list
->field
.name
=
2079 obconcat (&objfile
->type_obstack
, vb_name
, name
, "");
2083 complain (&invalid_cpp_abbrev_complaint
, *pp
);
2084 fip
->list
->field
.name
=
2085 obconcat (&objfile
->type_obstack
,
2086 "INVALID_CPLUSPLUS_ABBREV", "", "");
2090 /* At this point, *pp points to the ':'. Skip it and read the
2096 complain (&invalid_cpp_abbrev_complaint
, *pp
);
2099 fip
->list
->field
.type
= read_type (pp
, objfile
);
2101 (*pp
)++; /* Skip the comma. */
2107 fip
->list
->field
.bitpos
= read_huge_number (pp
, ';', &nbits
);
2111 /* This field is unpacked. */
2112 fip
->list
->field
.bitsize
= 0;
2113 fip
->list
->visibility
= VISIBILITY_PRIVATE
;
2117 complain (&invalid_cpp_abbrev_complaint
, *pp
);
2118 /* We have no idea what syntax an unrecognized abbrev would have, so
2119 better return 0. If we returned 1, we would need to at least advance
2120 *pp to avoid an infinite loop. */
2127 read_one_struct_field (fip
, pp
, p
, type
, objfile
)
2128 struct field_info
*fip
;
2132 struct objfile
*objfile
;
2134 fip
-> list
-> field
.name
=
2135 obsavestring (*pp
, p
- *pp
, &objfile
-> type_obstack
);
2138 /* This means we have a visibility for a field coming. */
2142 fip
-> list
-> visibility
= *(*pp
)++;
2143 switch (fip
-> list
-> visibility
)
2145 case VISIBILITY_PRIVATE
:
2146 case VISIBILITY_PROTECTED
:
2149 case VISIBILITY_PUBLIC
:
2154 /* Unknown visibility specifier. */
2155 complain (&stabs_general_complaint
,
2156 "unknown visibility specifier");
2163 /* normal dbx-style format, no explicit visibility */
2164 fip
-> list
-> visibility
= VISIBILITY_PUBLIC
;
2167 fip
-> list
-> field
.type
= read_type (pp
, objfile
);
2172 /* Possible future hook for nested types. */
2175 fip
-> list
-> field
.bitpos
= (long)-2; /* nested type */
2181 /* Static class member. */
2182 fip
-> list
-> field
.bitpos
= (long) -1;
2188 fip
-> list
-> field
.bitsize
= (long) savestring (*pp
, p
- *pp
);
2192 else if (**pp
!= ',')
2194 /* Bad structure-type format. */
2195 complain (&stabs_general_complaint
, "bad structure-type format");
2199 (*pp
)++; /* Skip the comma. */
2203 fip
-> list
-> field
.bitpos
= read_huge_number (pp
, ',', &nbits
);
2206 complain (&stabs_general_complaint
, "bad structure-type format");
2209 fip
-> list
-> field
.bitsize
= read_huge_number (pp
, ';', &nbits
);
2212 complain (&stabs_general_complaint
, "bad structure-type format");
2217 /* FIXME-tiemann: Can't the compiler put out something which
2218 lets us distinguish these? (or maybe just not put out anything
2219 for the field). What is the story here? What does the compiler
2220 really do? Also, patch gdb.texinfo for this case; I document
2221 it as a possible problem there. Search for "DBX-style". */
2223 /* This is wrong because this is identical to the symbols
2224 produced for GCC 0-size arrays. For example:
2229 The code which dumped core in such circumstances should be
2230 fixed not to dump core. */
2232 /* g++ -g0 can put out bitpos & bitsize zero for a static
2233 field. This does not give us any way of getting its
2234 class, so we can't know its name. But we can just
2235 ignore the field so we don't dump core and other nasty
2237 if (fip
-> list
-> field
.bitpos
== 0 && fip
-> list
-> field
.bitsize
== 0)
2239 complain (&dbx_class_complaint
);
2240 /* Ignore this field. */
2241 fip
-> list
= fip
-> list
-> next
;
2246 /* Detect an unpacked field and mark it as such.
2247 dbx gives a bit size for all fields.
2248 Note that forward refs cannot be packed,
2249 and treat enums as if they had the width of ints. */
2251 if (TYPE_CODE (fip
-> list
-> field
.type
) != TYPE_CODE_INT
2252 && TYPE_CODE (fip
-> list
-> field
.type
) != TYPE_CODE_ENUM
)
2254 fip
-> list
-> field
.bitsize
= 0;
2256 if ((fip
-> list
-> field
.bitsize
2257 == TARGET_CHAR_BIT
* TYPE_LENGTH (fip
-> list
-> field
.type
)
2258 || (TYPE_CODE (fip
-> list
-> field
.type
) == TYPE_CODE_ENUM
2259 && (fip
-> list
-> field
.bitsize
2264 fip
-> list
-> field
.bitpos
% 8 == 0)
2266 fip
-> list
-> field
.bitsize
= 0;
2272 /* Read struct or class data fields. They have the form:
2274 NAME : [VISIBILITY] TYPENUM , BITPOS , BITSIZE ;
2276 At the end, we see a semicolon instead of a field.
2278 In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
2281 The optional VISIBILITY is one of:
2283 '/0' (VISIBILITY_PRIVATE)
2284 '/1' (VISIBILITY_PROTECTED)
2285 '/2' (VISIBILITY_PUBLIC)
2287 or nothing, for C style fields with public visibility.
2289 Returns 1 for success, 0 for failure. */
2292 read_struct_fields (fip
, pp
, type
, objfile
)
2293 struct field_info
*fip
;
2296 struct objfile
*objfile
;
2299 struct nextfield
*new;
2301 /* We better set p right now, in case there are no fields at all... */
2305 /* Read each data member type until we find the terminating ';' at the end of
2306 the data member list, or break for some other reason such as finding the
2307 start of the member function list. */
2311 STABS_CONTINUE (pp
);
2312 /* Get space to record the next field's data. */
2313 new = (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
2314 make_cleanup (free
, new);
2315 memset (new, 0, sizeof (struct nextfield
));
2316 new -> next
= fip
-> list
;
2319 /* Get the field name. */
2321 /* If is starts with CPLUS_MARKER it is a special abbreviation, unless
2322 the CPLUS_MARKER is followed by an underscore, in which case it is
2323 just the name of an anonymous type, which we should handle like any
2325 if (*p
== CPLUS_MARKER
&& p
[1] != '_')
2327 if (!read_cpp_abbrev (fip
, pp
, type
, objfile
))
2332 /* Look for the ':' that separates the field name from the field
2333 values. Data members are delimited by a single ':', while member
2334 functions are delimited by a pair of ':'s. When we hit the member
2335 functions (if any), terminate scan loop and return. */
2337 while (*p
!= ':' && *p
!= '\0')
2344 /* Check to see if we have hit the member functions yet. */
2349 read_one_struct_field (fip
, pp
, p
, type
, objfile
);
2353 /* chill the list of fields: the last entry (at the head) is a
2354 partially constructed entry which we now scrub. */
2355 fip
-> list
= fip
-> list
-> next
;
2360 /* The stabs for C++ derived classes contain baseclass information which
2361 is marked by a '!' character after the total size. This function is
2362 called when we encounter the baseclass marker, and slurps up all the
2363 baseclass information.
2365 Immediately following the '!' marker is the number of base classes that
2366 the class is derived from, followed by information for each base class.
2367 For each base class, there are two visibility specifiers, a bit offset
2368 to the base class information within the derived class, a reference to
2369 the type for the base class, and a terminating semicolon.
2371 A typical example, with two base classes, would be "!2,020,19;0264,21;".
2373 Baseclass information marker __________________|| | | | | | |
2374 Number of baseclasses __________________________| | | | | | |
2375 Visibility specifiers (2) ________________________| | | | | |
2376 Offset in bits from start of class _________________| | | | |
2377 Type number for base class ___________________________| | | |
2378 Visibility specifiers (2) _______________________________| | |
2379 Offset in bits from start of class ________________________| |
2380 Type number of base class ____________________________________|
2382 Return 1 for success, 0 for (error-type-inducing) failure. */
2385 read_baseclasses (fip
, pp
, type
, objfile
)
2386 struct field_info
*fip
;
2389 struct objfile
*objfile
;
2392 struct nextfield
*new;
2400 /* Skip the '!' baseclass information marker. */
2404 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2407 TYPE_N_BASECLASSES (type
) = read_huge_number (pp
, ',', &nbits
);
2413 /* Some stupid compilers have trouble with the following, so break
2414 it up into simpler expressions. */
2415 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*)
2416 TYPE_ALLOC (type
, B_BYTES (TYPE_N_BASECLASSES (type
)));
2419 int num_bytes
= B_BYTES (TYPE_N_BASECLASSES (type
));
2422 pointer
= (char *) TYPE_ALLOC (type
, num_bytes
);
2423 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*) pointer
;
2427 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), TYPE_N_BASECLASSES (type
));
2429 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
2431 new = (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
2432 make_cleanup (free
, new);
2433 memset (new, 0, sizeof (struct nextfield
));
2434 new -> next
= fip
-> list
;
2436 new -> field
.bitsize
= 0; /* this should be an unpacked field! */
2438 STABS_CONTINUE (pp
);
2442 /* Nothing to do. */
2445 SET_TYPE_FIELD_VIRTUAL (type
, i
);
2448 /* Bad visibility format. */
2452 new -> visibility
= *(*pp
)++;
2453 switch (new -> visibility
)
2455 case VISIBILITY_PRIVATE
:
2456 case VISIBILITY_PROTECTED
:
2457 case VISIBILITY_PUBLIC
:
2460 /* Bad visibility format. */
2467 /* The remaining value is the bit offset of the portion of the object
2468 corresponding to this baseclass. Always zero in the absence of
2469 multiple inheritance. */
2471 new -> field
.bitpos
= read_huge_number (pp
, ',', &nbits
);
2476 /* The last piece of baseclass information is the type of the
2477 base class. Read it, and remember it's type name as this
2480 new -> field
.type
= read_type (pp
, objfile
);
2481 new -> field
.name
= type_name_no_tag (new -> field
.type
);
2483 /* skip trailing ';' and bump count of number of fields seen */
2492 /* The tail end of stabs for C++ classes that contain a virtual function
2493 pointer contains a tilde, a %, and a type number.
2494 The type number refers to the base class (possibly this class itself) which
2495 contains the vtable pointer for the current class.
2497 This function is called when we have parsed all the method declarations,
2498 so we can look for the vptr base class info. */
2501 read_tilde_fields (fip
, pp
, type
, objfile
)
2502 struct field_info
*fip
;
2505 struct objfile
*objfile
;
2509 STABS_CONTINUE (pp
);
2511 /* If we are positioned at a ';', then skip it. */
2521 if (**pp
== '=' || **pp
== '+' || **pp
== '-')
2523 /* Obsolete flags that used to indicate the presence
2524 of constructors and/or destructors. */
2528 /* Read either a '%' or the final ';'. */
2529 if (*(*pp
)++ == '%')
2531 /* The next number is the type number of the base class
2532 (possibly our own class) which supplies the vtable for
2533 this class. Parse it out, and search that class to find
2534 its vtable pointer, and install those into TYPE_VPTR_BASETYPE
2535 and TYPE_VPTR_FIELDNO. */
2540 t
= read_type (pp
, objfile
);
2542 while (*p
!= '\0' && *p
!= ';')
2548 /* Premature end of symbol. */
2552 TYPE_VPTR_BASETYPE (type
) = t
;
2553 if (type
== t
) /* Our own class provides vtbl ptr */
2555 for (i
= TYPE_NFIELDS (t
) - 1;
2556 i
>= TYPE_N_BASECLASSES (t
);
2559 if (! strncmp (TYPE_FIELD_NAME (t
, i
), vptr_name
,
2560 sizeof (vptr_name
) - 1))
2562 TYPE_VPTR_FIELDNO (type
) = i
;
2566 /* Virtual function table field not found. */
2567 complain (&vtbl_notfound_complaint
, TYPE_NAME (type
));
2572 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
2583 attach_fn_fields_to_type (fip
, type
)
2584 struct field_info
*fip
;
2585 register struct type
*type
;
2589 for (n
= 0; n
< TYPE_N_BASECLASSES (type
); n
++)
2591 if (TYPE_CODE (TYPE_BASECLASS (type
, n
)) == TYPE_CODE_UNDEF
)
2593 /* @@ Memory leak on objfile -> type_obstack? */
2596 TYPE_NFN_FIELDS_TOTAL (type
) +=
2597 TYPE_NFN_FIELDS_TOTAL (TYPE_BASECLASS (type
, n
));
2600 for (n
= TYPE_NFN_FIELDS (type
);
2601 fip
-> fnlist
!= NULL
;
2602 fip
-> fnlist
= fip
-> fnlist
-> next
)
2604 --n
; /* Circumvent Sun3 compiler bug */
2605 TYPE_FN_FIELDLISTS (type
)[n
] = fip
-> fnlist
-> fn_fieldlist
;
2610 /* Create the vector of fields, and record how big it is.
2611 We need this info to record proper virtual function table information
2612 for this class's virtual functions. */
2615 attach_fields_to_type (fip
, type
, objfile
)
2616 struct field_info
*fip
;
2617 register struct type
*type
;
2618 struct objfile
*objfile
;
2620 register int nfields
= 0;
2621 register int non_public_fields
= 0;
2622 register struct nextfield
*scan
;
2624 /* Count up the number of fields that we have, as well as taking note of
2625 whether or not there are any non-public fields, which requires us to
2626 allocate and build the private_field_bits and protected_field_bits
2629 for (scan
= fip
-> list
; scan
!= NULL
; scan
= scan
-> next
)
2632 if (scan
-> visibility
!= VISIBILITY_PUBLIC
)
2634 non_public_fields
++;
2638 /* Now we know how many fields there are, and whether or not there are any
2639 non-public fields. Record the field count, allocate space for the
2640 array of fields, and create blank visibility bitfields if necessary. */
2642 TYPE_NFIELDS (type
) = nfields
;
2643 TYPE_FIELDS (type
) = (struct field
*)
2644 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
2645 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
2647 if (non_public_fields
)
2649 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2651 TYPE_FIELD_PRIVATE_BITS (type
) =
2652 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2653 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
2655 TYPE_FIELD_PROTECTED_BITS (type
) =
2656 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2657 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
2660 /* Copy the saved-up fields into the field vector. Start from the head
2661 of the list, adding to the tail of the field array, so that they end
2662 up in the same order in the array in which they were added to the list. */
2664 while (nfields
-- > 0)
2666 TYPE_FIELD (type
, nfields
) = fip
-> list
-> field
;
2667 switch (fip
-> list
-> visibility
)
2669 case VISIBILITY_PRIVATE
:
2670 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
2673 case VISIBILITY_PROTECTED
:
2674 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
2677 case VISIBILITY_PUBLIC
:
2681 /* Should warn about this unknown visibility? */
2684 fip
-> list
= fip
-> list
-> next
;
2689 /* Read the description of a structure (or union type) and return an object
2690 describing the type.
2692 PP points to a character pointer that points to the next unconsumed token
2693 in the the stabs string. For example, given stabs "A:T4=s4a:1,0,32;;",
2694 *PP will point to "4a:1,0,32;;".
2696 TYPE points to an incomplete type that needs to be filled in.
2698 OBJFILE points to the current objfile from which the stabs information is
2699 being read. (Note that it is redundant in that TYPE also contains a pointer
2700 to this same objfile, so it might be a good idea to eliminate it. FIXME).
2703 static struct type
*
2704 read_struct_type (pp
, type
, objfile
)
2707 struct objfile
*objfile
;
2709 struct cleanup
*back_to
;
2710 struct field_info fi
;
2715 back_to
= make_cleanup (null_cleanup
, 0);
2717 INIT_CPLUS_SPECIFIC (type
);
2718 TYPE_FLAGS (type
) &= ~TYPE_FLAG_STUB
;
2720 /* First comes the total size in bytes. */
2724 TYPE_LENGTH (type
) = read_huge_number (pp
, 0, &nbits
);
2726 return error_type (pp
);
2729 /* Now read the baseclasses, if any, read the regular C struct or C++
2730 class member fields, attach the fields to the type, read the C++
2731 member functions, attach them to the type, and then read any tilde
2732 field (baseclass specifier for the class holding the main vtable). */
2734 if (!read_baseclasses (&fi
, pp
, type
, objfile
)
2735 || !read_struct_fields (&fi
, pp
, type
, objfile
)
2736 || !attach_fields_to_type (&fi
, type
, objfile
)
2737 || !read_member_functions (&fi
, pp
, type
, objfile
)
2738 || !attach_fn_fields_to_type (&fi
, type
)
2739 || !read_tilde_fields (&fi
, pp
, type
, objfile
))
2741 do_cleanups (back_to
);
2742 return (error_type (pp
));
2745 do_cleanups (back_to
);
2749 /* Read a definition of an array type,
2750 and create and return a suitable type object.
2751 Also creates a range type which represents the bounds of that
2754 static struct type
*
2755 read_array_type (pp
, type
, objfile
)
2757 register struct type
*type
;
2758 struct objfile
*objfile
;
2760 struct type
*index_type
, *element_type
, *range_type
;
2765 /* Format of an array type:
2766 "ar<index type>;lower;upper;<array_contents_type>". Put code in
2769 Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
2770 for these, produce a type like float[][]. */
2772 index_type
= read_type (pp
, objfile
);
2774 /* Improper format of array type decl. */
2775 return error_type (pp
);
2778 if (!(**pp
>= '0' && **pp
<= '9'))
2783 lower
= read_huge_number (pp
, ';', &nbits
);
2785 return error_type (pp
);
2787 if (!(**pp
>= '0' && **pp
<= '9'))
2792 upper
= read_huge_number (pp
, ';', &nbits
);
2794 return error_type (pp
);
2796 element_type
= read_type (pp
, objfile
);
2805 create_range_type ((struct type
*) NULL
, index_type
, lower
, upper
);
2806 type
= create_array_type (type
, element_type
, range_type
);
2808 /* If we have an array whose element type is not yet known, but whose
2809 bounds *are* known, record it to be adjusted at the end of the file. */
2811 if (TYPE_LENGTH (element_type
) == 0 && !adjustable
)
2813 add_undefined_type (type
);
2820 /* Read a definition of an enumeration type,
2821 and create and return a suitable type object.
2822 Also defines the symbols that represent the values of the type. */
2824 static struct type
*
2825 read_enum_type (pp
, type
, objfile
)
2827 register struct type
*type
;
2828 struct objfile
*objfile
;
2833 register struct symbol
*sym
;
2835 struct pending
**symlist
;
2836 struct pending
*osyms
, *syms
;
2840 /* FIXME! The stabs produced by Sun CC merrily define things that ought
2841 to be file-scope, between N_FN entries, using N_LSYM. What's a mother
2842 to do? For now, force all enum values to file scope. */
2843 if (within_function
)
2844 symlist
= &local_symbols
;
2847 symlist
= &file_symbols
;
2849 o_nsyms
= osyms
? osyms
->nsyms
: 0;
2851 /* Read the value-names and their values.
2852 The input syntax is NAME:VALUE,NAME:VALUE, and so on.
2853 A semicolon or comma instead of a NAME means the end. */
2854 while (**pp
&& **pp
!= ';' && **pp
!= ',')
2857 STABS_CONTINUE (pp
);
2859 while (*p
!= ':') p
++;
2860 name
= obsavestring (*pp
, p
- *pp
, &objfile
-> symbol_obstack
);
2862 n
= read_huge_number (pp
, ',', &nbits
);
2864 return error_type (pp
);
2866 sym
= (struct symbol
*)
2867 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
2868 memset (sym
, 0, sizeof (struct symbol
));
2869 SYMBOL_NAME (sym
) = name
;
2870 SYMBOL_LANGUAGE (sym
) = current_subfile
-> language
;
2871 SYMBOL_CLASS (sym
) = LOC_CONST
;
2872 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2873 SYMBOL_VALUE (sym
) = n
;
2874 add_symbol_to_list (sym
, symlist
);
2879 (*pp
)++; /* Skip the semicolon. */
2881 /* Now fill in the fields of the type-structure. */
2883 TYPE_LENGTH (type
) = sizeof (int);
2884 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
2885 TYPE_FLAGS (type
) &= ~TYPE_FLAG_STUB
;
2886 TYPE_NFIELDS (type
) = nsyms
;
2887 TYPE_FIELDS (type
) = (struct field
*)
2888 TYPE_ALLOC (type
, sizeof (struct field
) * nsyms
);
2889 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nsyms
);
2891 /* Find the symbols for the values and put them into the type.
2892 The symbols can be found in the symlist that we put them on
2893 to cause them to be defined. osyms contains the old value
2894 of that symlist; everything up to there was defined by us. */
2895 /* Note that we preserve the order of the enum constants, so
2896 that in something like "enum {FOO, LAST_THING=FOO}" we print
2897 FOO, not LAST_THING. */
2899 for (syms
= *symlist
, n
= 0; syms
; syms
= syms
->next
)
2904 for (; j
< syms
->nsyms
; j
++,n
++)
2906 struct symbol
*xsym
= syms
->symbol
[j
];
2907 SYMBOL_TYPE (xsym
) = type
;
2908 TYPE_FIELD_NAME (type
, n
) = SYMBOL_NAME (xsym
);
2909 TYPE_FIELD_VALUE (type
, n
) = 0;
2910 TYPE_FIELD_BITPOS (type
, n
) = SYMBOL_VALUE (xsym
);
2911 TYPE_FIELD_BITSIZE (type
, n
) = 0;
2918 /* This screws up perfectly good C programs with enums. FIXME. */
2919 /* Is this Modula-2's BOOLEAN type? Flag it as such if so. */
2920 if(TYPE_NFIELDS(type
) == 2 &&
2921 ((STREQ(TYPE_FIELD_NAME(type
,0),"TRUE") &&
2922 STREQ(TYPE_FIELD_NAME(type
,1),"FALSE")) ||
2923 (STREQ(TYPE_FIELD_NAME(type
,1),"TRUE") &&
2924 STREQ(TYPE_FIELD_NAME(type
,0),"FALSE"))))
2925 TYPE_CODE(type
) = TYPE_CODE_BOOL
;
2931 /* Sun's ACC uses a somewhat saner method for specifying the builtin
2932 typedefs in every file (for int, long, etc):
2934 type = b <signed> <width>; <offset>; <nbits>
2935 signed = u or s. Possible c in addition to u or s (for char?).
2936 offset = offset from high order bit to start bit of type.
2937 width is # bytes in object of this type, nbits is # bits in type.
2939 The width/offset stuff appears to be for small objects stored in
2940 larger ones (e.g. `shorts' in `int' registers). We ignore it for now,
2943 static struct type
*
2944 read_sun_builtin_type (pp
, typenums
, objfile
)
2947 struct objfile
*objfile
;
2962 return error_type (pp
);
2966 /* For some odd reason, all forms of char put a c here. This is strange
2967 because no other type has this honor. We can safely ignore this because
2968 we actually determine 'char'acterness by the number of bits specified in
2974 /* The first number appears to be the number of bytes occupied
2975 by this type, except that unsigned short is 4 instead of 2.
2976 Since this information is redundant with the third number,
2977 we will ignore it. */
2978 read_huge_number (pp
, ';', &nbits
);
2980 return error_type (pp
);
2982 /* The second number is always 0, so ignore it too. */
2983 read_huge_number (pp
, ';', &nbits
);
2985 return error_type (pp
);
2987 /* The third number is the number of bits for this type. */
2988 type_bits
= read_huge_number (pp
, 0, &nbits
);
2990 return error_type (pp
);
2993 /* FIXME. Here we should just be able to make a type of the right
2994 number of bits and signedness. FIXME. */
2996 if (type_bits
== TARGET_LONG_LONG_BIT
)
2997 return (lookup_fundamental_type (objfile
,
2998 signed_type
? FT_LONG_LONG
: FT_UNSIGNED_LONG_LONG
));
3000 if (type_bits
== TARGET_INT_BIT
)
3002 /* FIXME -- the only way to distinguish `int' from `long'
3003 is to look at its name! */
3006 if (long_kludge_name
&& long_kludge_name
[0] == 'l' /* long */)
3007 return lookup_fundamental_type (objfile
, FT_LONG
);
3009 return lookup_fundamental_type (objfile
, FT_INTEGER
);
3013 if (long_kludge_name
3014 && ((long_kludge_name
[0] == 'u' /* unsigned */ &&
3015 long_kludge_name
[9] == 'l' /* long */)
3016 || (long_kludge_name
[0] == 'l' /* long unsigned */)))
3017 return lookup_fundamental_type (objfile
, FT_UNSIGNED_LONG
);
3019 return lookup_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
);
3023 if (type_bits
== TARGET_SHORT_BIT
)
3024 return (lookup_fundamental_type (objfile
,
3025 signed_type
? FT_SHORT
: FT_UNSIGNED_SHORT
));
3027 if (type_bits
== TARGET_CHAR_BIT
)
3028 return (lookup_fundamental_type (objfile
,
3029 signed_type
? FT_CHAR
: FT_UNSIGNED_CHAR
));
3032 return lookup_fundamental_type (objfile
, FT_VOID
);
3034 return error_type (pp
);
3036 return init_type (type_bits
== 0 ? TYPE_CODE_VOID
: TYPE_CODE_INT
,
3037 type_bits
/ TARGET_CHAR_BIT
,
3038 signed_type
? 0 : TYPE_FLAG_UNSIGNED
, (char *)NULL
,
3043 static struct type
*
3044 read_sun_floating_type (pp
, typenums
, objfile
)
3047 struct objfile
*objfile
;
3053 /* The first number has more details about the type, for example
3055 details
= read_huge_number (pp
, ';', &nbits
);
3057 return error_type (pp
);
3059 /* The second number is the number of bytes occupied by this type */
3060 nbytes
= read_huge_number (pp
, ';', &nbits
);
3062 return error_type (pp
);
3064 if (details
== NF_COMPLEX
|| details
== NF_COMPLEX16
3065 || details
== NF_COMPLEX32
)
3066 /* This is a type we can't handle, but we do know the size.
3067 We also will be able to give it a name. */
3068 return init_type (TYPE_CODE_ERROR
, nbytes
, 0, NULL
, objfile
);
3070 return init_type (TYPE_CODE_FLT
, nbytes
, 0, NULL
, objfile
);
3073 /* Read a number from the string pointed to by *PP.
3074 The value of *PP is advanced over the number.
3075 If END is nonzero, the character that ends the
3076 number must match END, or an error happens;
3077 and that character is skipped if it does match.
3078 If END is zero, *PP is left pointing to that character.
3080 If the number fits in a long, set *BITS to 0 and return the value.
3081 If not, set *BITS to be the number of bits in the number and return 0.
3083 If encounter garbage, set *BITS to -1 and return 0. */
3086 read_huge_number (pp
, end
, bits
)
3106 /* Leading zero means octal. GCC uses this to output values larger
3107 than an int (because that would be hard in decimal). */
3114 upper_limit
= LONG_MAX
/ radix
;
3115 while ((c
= *p
++) >= '0' && c
< ('0' + radix
))
3117 if (n
<= upper_limit
)
3120 n
+= c
- '0'; /* FIXME this overflows anyway */
3125 /* This depends on large values being output in octal, which is
3132 /* Ignore leading zeroes. */
3136 else if (c
== '2' || c
== '3')
3162 /* Large decimal constants are an error (because it is hard to
3163 count how many bits are in them). */
3169 /* -0x7f is the same as 0x80. So deal with it by adding one to
3170 the number of bits. */
3182 /* It's *BITS which has the interesting information. */
3186 static struct type
*
3187 read_range_type (pp
, typenums
, objfile
)
3190 struct objfile
*objfile
;
3196 struct type
*result_type
;
3197 struct type
*index_type
;
3199 /* First comes a type we are a subrange of.
3200 In C it is usually 0, 1 or the type being defined. */
3201 /* FIXME: according to stabs.texinfo and AIX doc, this can be a type-id
3202 not just a type number. */
3203 if (read_type_number (pp
, rangenums
) != 0)
3204 return error_type (pp
);
3205 self_subrange
= (rangenums
[0] == typenums
[0] &&
3206 rangenums
[1] == typenums
[1]);
3208 /* A semicolon should now follow; skip it. */
3212 /* The remaining two operands are usually lower and upper bounds
3213 of the range. But in some special cases they mean something else. */
3214 n2
= read_huge_number (pp
, ';', &n2bits
);
3215 n3
= read_huge_number (pp
, ';', &n3bits
);
3217 if (n2bits
== -1 || n3bits
== -1)
3218 return error_type (pp
);
3220 /* If limits are huge, must be large integral type. */
3221 if (n2bits
!= 0 || n3bits
!= 0)
3223 char got_signed
= 0;
3224 char got_unsigned
= 0;
3225 /* Number of bits in the type. */
3228 /* Range from 0 to <large number> is an unsigned large integral type. */
3229 if ((n2bits
== 0 && n2
== 0) && n3bits
!= 0)
3234 /* Range from <large number> to <large number>-1 is a large signed
3235 integral type. Take care of the case where <large number> doesn't
3236 fit in a long but <large number>-1 does. */
3237 else if ((n2bits
!= 0 && n3bits
!= 0 && n2bits
== n3bits
+ 1)
3238 || (n2bits
!= 0 && n3bits
== 0
3239 && (n2bits
== sizeof (long) * HOST_CHAR_BIT
)
3246 if (got_signed
|| got_unsigned
)
3248 return init_type (TYPE_CODE_INT
, nbits
/ TARGET_CHAR_BIT
,
3249 got_unsigned
? TYPE_FLAG_UNSIGNED
: 0, NULL
,
3253 return error_type (pp
);
3256 /* A type defined as a subrange of itself, with bounds both 0, is void. */
3257 if (self_subrange
&& n2
== 0 && n3
== 0)
3258 return init_type (TYPE_CODE_VOID
, 0, 0, NULL
, objfile
);
3260 /* If n3 is zero and n2 is not, we want a floating type,
3261 and n2 is the width in bytes.
3263 Fortran programs appear to use this for complex types also,
3264 and they give no way to distinguish between double and single-complex!
3266 GDB does not have complex types.
3268 Just return the complex as a float of that size. It won't work right
3269 for the complex values, but at least it makes the file loadable. */
3271 if (n3
== 0 && n2
> 0)
3273 return init_type (TYPE_CODE_FLT
, n2
, 0, NULL
, objfile
);
3276 /* If the upper bound is -1, it must really be an unsigned int. */
3278 else if (n2
== 0 && n3
== -1)
3280 /* It is unsigned int or unsigned long. */
3281 /* GCC 2.3.3 uses this for long long too, but that is just a GDB 3.5
3282 compatibility hack. */
3283 return init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
3284 TYPE_FLAG_UNSIGNED
, NULL
, objfile
);
3287 /* Special case: char is defined (Who knows why) as a subrange of
3288 itself with range 0-127. */
3289 else if (self_subrange
&& n2
== 0 && n3
== 127)
3290 return init_type (TYPE_CODE_INT
, 1, 0, NULL
, objfile
);
3292 /* We used to do this only for subrange of self or subrange of int. */
3296 /* n3 actually gives the size. */
3297 return init_type (TYPE_CODE_INT
, - n3
, TYPE_FLAG_UNSIGNED
,
3300 return init_type (TYPE_CODE_INT
, 1, TYPE_FLAG_UNSIGNED
, NULL
, objfile
);
3302 return init_type (TYPE_CODE_INT
, 2, TYPE_FLAG_UNSIGNED
, NULL
, objfile
);
3304 /* -1 is used for the upper bound of (4 byte) "unsigned int" and
3305 "unsigned long", and we already checked for that,
3306 so don't need to test for it here. */
3308 /* I think this is for Convex "long long". Since I don't know whether
3309 Convex sets self_subrange, I also accept that particular size regardless
3310 of self_subrange. */
3311 else if (n3
== 0 && n2
< 0
3313 || n2
== - TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
))
3314 return init_type (TYPE_CODE_INT
, - n2
, 0, NULL
, objfile
);
3315 else if (n2
== -n3
-1)
3318 return init_type (TYPE_CODE_INT
, 1, 0, NULL
, objfile
);
3320 return init_type (TYPE_CODE_INT
, 2, 0, NULL
, objfile
);
3321 if (n3
== 0x7fffffff)
3322 return init_type (TYPE_CODE_INT
, 4, 0, NULL
, objfile
);
3325 /* We have a real range type on our hands. Allocate space and
3326 return a real pointer. */
3328 /* At this point I don't have the faintest idea how to deal with
3329 a self_subrange type; I'm going to assume that this is used
3330 as an idiom, and that all of them are special cases. So . . . */
3332 return error_type (pp
);
3334 index_type
= *dbx_lookup_type (rangenums
);
3335 if (index_type
== NULL
)
3337 /* Does this actually ever happen? Is that why we are worrying
3338 about dealing with it rather than just calling error_type? */
3340 static struct type
*range_type_index
;
3342 complain (&range_type_base_complaint
, rangenums
[1]);
3343 if (range_type_index
== NULL
)
3345 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
3346 0, "range type index type", NULL
);
3347 index_type
= range_type_index
;
3350 result_type
= create_range_type ((struct type
*) NULL
, index_type
, n2
, n3
);
3351 return (result_type
);
3354 /* Read in an argument list. This is a list of types, separated by commas
3355 and terminated with END. Return the list of types read in, or (struct type
3356 **)-1 if there is an error. */
3358 static struct type
**
3359 read_args (pp
, end
, objfile
)
3362 struct objfile
*objfile
;
3364 /* FIXME! Remove this arbitrary limit! */
3365 struct type
*types
[1024], **rval
; /* allow for fns of 1023 parameters */
3371 /* Invalid argument list: no ','. */
3372 return (struct type
**)-1;
3374 STABS_CONTINUE (pp
);
3375 types
[n
++] = read_type (pp
, objfile
);
3377 (*pp
)++; /* get past `end' (the ':' character) */
3381 rval
= (struct type
**) xmalloc (2 * sizeof (struct type
*));
3383 else if (TYPE_CODE (types
[n
-1]) != TYPE_CODE_VOID
)
3385 rval
= (struct type
**) xmalloc ((n
+ 1) * sizeof (struct type
*));
3386 memset (rval
+ n
, 0, sizeof (struct type
*));
3390 rval
= (struct type
**) xmalloc (n
* sizeof (struct type
*));
3392 memcpy (rval
, types
, n
* sizeof (struct type
*));
3396 /* Common block handling. */
3398 /* List of symbols declared since the last BCOMM. This list is a tail
3399 of local_symbols. When ECOMM is seen, the symbols on the list
3400 are noted so their proper addresses can be filled in later,
3401 using the common block base address gotten from the assembler
3404 static struct pending
*common_block
;
3405 static int common_block_i
;
3407 /* Name of the current common block. We get it from the BCOMM instead of the
3408 ECOMM to match IBM documentation (even though IBM puts the name both places
3409 like everyone else). */
3410 static char *common_block_name
;
3412 /* Process a N_BCOMM symbol. The storage for NAME is not guaranteed
3413 to remain after this function returns. */
3416 common_block_start (name
, objfile
)
3418 struct objfile
*objfile
;
3420 if (common_block_name
!= NULL
)
3422 static struct complaint msg
= {
3423 "Invalid symbol data: common block within common block",
3427 common_block
= local_symbols
;
3428 common_block_i
= local_symbols
? local_symbols
->nsyms
: 0;
3429 common_block_name
= obsavestring (name
, strlen (name
),
3430 &objfile
-> symbol_obstack
);
3433 /* Process a N_ECOMM symbol. */
3436 common_block_end (objfile
)
3437 struct objfile
*objfile
;
3439 /* Symbols declared since the BCOMM are to have the common block
3440 start address added in when we know it. common_block and
3441 common_block_i point to the first symbol after the BCOMM in
3442 the local_symbols list; copy the list and hang it off the
3443 symbol for the common block name for later fixup. */
3446 struct pending
*new = 0;
3447 struct pending
*next
;
3450 if (common_block_name
== NULL
)
3452 static struct complaint msg
= {"ECOMM symbol unmatched by BCOMM", 0, 0};
3457 sym
= (struct symbol
*)
3458 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
3459 memset (sym
, 0, sizeof (struct symbol
));
3460 SYMBOL_NAME (sym
) = common_block_name
;
3461 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
3463 /* Now we copy all the symbols which have been defined since the BCOMM. */
3465 /* Copy all the struct pendings before common_block. */
3466 for (next
= local_symbols
;
3467 next
!= NULL
&& next
!= common_block
;
3470 for (j
= 0; j
< next
->nsyms
; j
++)
3471 add_symbol_to_list (next
->symbol
[j
], &new);
3474 /* Copy however much of COMMON_BLOCK we need. If COMMON_BLOCK is
3475 NULL, it means copy all the local symbols (which we already did
3478 if (common_block
!= NULL
)
3479 for (j
= common_block_i
; j
< common_block
->nsyms
; j
++)
3480 add_symbol_to_list (common_block
->symbol
[j
], &new);
3482 SYMBOL_NAMESPACE (sym
) = (enum namespace)((long) new);
3484 /* Should we be putting local_symbols back to what it was?
3487 i
= hashname (SYMBOL_NAME (sym
));
3488 SYMBOL_VALUE_CHAIN (sym
) = global_sym_chain
[i
];
3489 global_sym_chain
[i
] = sym
;
3490 common_block_name
= NULL
;
3493 /* Add a common block's start address to the offset of each symbol
3494 declared to be in it (by being between a BCOMM/ECOMM pair that uses
3495 the common block name). */
3498 fix_common_block (sym
, valu
)
3502 struct pending
*next
= (struct pending
*) SYMBOL_NAMESPACE (sym
);
3503 for ( ; next
; next
= next
->next
)
3506 for (j
= next
->nsyms
- 1; j
>= 0; j
--)
3507 SYMBOL_VALUE_ADDRESS (next
->symbol
[j
]) += valu
;
3513 /* What about types defined as forward references inside of a small lexical
3515 /* Add a type to the list of undefined types to be checked through
3516 once this file has been read in. */
3519 add_undefined_type (type
)
3522 if (undef_types_length
== undef_types_allocated
)
3524 undef_types_allocated
*= 2;
3525 undef_types
= (struct type
**)
3526 xrealloc ((char *) undef_types
,
3527 undef_types_allocated
* sizeof (struct type
*));
3529 undef_types
[undef_types_length
++] = type
;
3532 /* Go through each undefined type, see if it's still undefined, and fix it
3533 up if possible. We have two kinds of undefined types:
3535 TYPE_CODE_ARRAY: Array whose target type wasn't defined yet.
3536 Fix: update array length using the element bounds
3537 and the target type's length.
3538 TYPE_CODE_STRUCT, TYPE_CODE_UNION: Structure whose fields were not
3539 yet defined at the time a pointer to it was made.
3540 Fix: Do a full lookup on the struct/union tag. */
3542 cleanup_undefined_types ()
3546 for (type
= undef_types
; type
< undef_types
+ undef_types_length
; type
++)
3548 switch (TYPE_CODE (*type
))
3551 case TYPE_CODE_STRUCT
:
3552 case TYPE_CODE_UNION
:
3553 case TYPE_CODE_ENUM
:
3555 /* Check if it has been defined since. */
3556 if (TYPE_FLAGS (*type
) & TYPE_FLAG_STUB
)
3558 struct pending
*ppt
;
3560 /* Name of the type, without "struct" or "union" */
3561 char *typename
= TYPE_TAG_NAME (*type
);
3563 if (typename
== NULL
)
3565 static struct complaint msg
= {"need a type name", 0, 0};
3569 for (ppt
= file_symbols
; ppt
; ppt
= ppt
->next
)
3571 for (i
= 0; i
< ppt
->nsyms
; i
++)
3573 struct symbol
*sym
= ppt
->symbol
[i
];
3575 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
3576 && SYMBOL_NAMESPACE (sym
) == STRUCT_NAMESPACE
3577 && (TYPE_CODE (SYMBOL_TYPE (sym
)) ==
3579 && STREQ (SYMBOL_NAME (sym
), typename
))
3581 memcpy (*type
, SYMBOL_TYPE (sym
),
3582 sizeof (struct type
));
3590 case TYPE_CODE_ARRAY
:
3592 struct type
*range_type
;
3595 if (TYPE_LENGTH (*type
) != 0) /* Better be unknown */
3597 if (TYPE_NFIELDS (*type
) != 1)
3599 range_type
= TYPE_FIELD_TYPE (*type
, 0);
3600 if (TYPE_CODE (range_type
) != TYPE_CODE_RANGE
)
3603 /* Now recompute the length of the array type, based on its
3604 number of elements and the target type's length. */
3605 lower
= TYPE_FIELD_BITPOS (range_type
, 0);
3606 upper
= TYPE_FIELD_BITPOS (range_type
, 1);
3607 TYPE_LENGTH (*type
) = (upper
- lower
+ 1)
3608 * TYPE_LENGTH (TYPE_TARGET_TYPE (*type
));
3615 static struct complaint msg
= {"\
3616 GDB internal error. cleanup_undefined_types with bad type %d.", 0, 0};
3617 complain (&msg
, TYPE_CODE (*type
));
3622 undef_types_length
= 0;
3625 /* Scan through all of the global symbols defined in the object file,
3626 assigning values to the debugging symbols that need to be assigned
3627 to. Get these symbols from the minimal symbol table. */
3630 scan_file_globals (objfile
)
3631 struct objfile
*objfile
;
3634 struct minimal_symbol
*msymbol
;
3635 struct symbol
*sym
, *prev
;
3637 if (objfile
->msymbols
== 0) /* Beware the null file. */
3640 for (msymbol
= objfile
-> msymbols
; SYMBOL_NAME (msymbol
) != NULL
; msymbol
++)
3646 /* Get the hash index and check all the symbols
3647 under that hash index. */
3649 hash
= hashname (SYMBOL_NAME (msymbol
));
3651 for (sym
= global_sym_chain
[hash
]; sym
;)
3653 if (SYMBOL_NAME (msymbol
)[0] == SYMBOL_NAME (sym
)[0] &&
3654 STREQ(SYMBOL_NAME (msymbol
) + 1, SYMBOL_NAME (sym
) + 1))
3656 /* Splice this symbol out of the hash chain and
3657 assign the value we have to it. */
3660 SYMBOL_VALUE_CHAIN (prev
) = SYMBOL_VALUE_CHAIN (sym
);
3664 global_sym_chain
[hash
] = SYMBOL_VALUE_CHAIN (sym
);
3667 /* Check to see whether we need to fix up a common block. */
3668 /* Note: this code might be executed several times for
3669 the same symbol if there are multiple references. */
3671 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
3673 fix_common_block (sym
, SYMBOL_VALUE_ADDRESS (msymbol
));
3677 SYMBOL_VALUE_ADDRESS (sym
) = SYMBOL_VALUE_ADDRESS (msymbol
);
3682 sym
= SYMBOL_VALUE_CHAIN (prev
);
3686 sym
= global_sym_chain
[hash
];
3692 sym
= SYMBOL_VALUE_CHAIN (sym
);
3698 /* Initialize anything that needs initializing when starting to read
3699 a fresh piece of a symbol file, e.g. reading in the stuff corresponding
3707 /* Initialize anything that needs initializing when a completely new
3708 symbol file is specified (not just adding some symbols from another
3709 file, e.g. a shared library). */
3712 stabsread_new_init ()
3714 /* Empty the hash table of global syms looking for values. */
3715 memset (global_sym_chain
, 0, sizeof (global_sym_chain
));
3718 /* Initialize anything that needs initializing at the same time as
3719 start_symtab() is called. */
3723 global_stabs
= NULL
; /* AIX COFF */
3724 /* Leave FILENUM of 0 free for builtin types and this file's types. */
3725 n_this_object_header_files
= 1;
3726 type_vector_length
= 0;
3727 type_vector
= (struct type
**) 0;
3729 /* FIXME: If common_block_name is not already NULL, we should complain(). */
3730 common_block_name
= NULL
;
3733 /* Call after end_symtab() */
3739 free ((char *) type_vector
);
3742 type_vector_length
= 0;
3743 previous_stab_code
= 0;
3747 finish_global_stabs (objfile
)
3748 struct objfile
*objfile
;
3752 patch_block_stabs (global_symbols
, global_stabs
, objfile
);
3753 free ((PTR
) global_stabs
);
3754 global_stabs
= NULL
;
3758 /* Initializer for this module */
3761 _initialize_stabsread ()
3763 undef_types_allocated
= 20;
3764 undef_types_length
= 0;
3765 undef_types
= (struct type
**)
3766 xmalloc (undef_types_allocated
* sizeof (struct type
*));