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"
39 /* Ask stabsread.h to define the vars it normally declares `extern'. */
41 #include "stabsread.h" /* Our own declarations */
44 /* The routines that read and process a complete stabs for a C struct or
45 C++ class pass lists of data member fields and lists of member function
46 fields in an instance of a field_info structure, as defined below.
47 This is part of some reorganization of low level C++ support and is
48 expected to eventually go away... (FIXME) */
54 struct nextfield
*next
;
58 struct next_fnfieldlist
60 struct next_fnfieldlist
*next
;
61 struct fn_fieldlist fn_fieldlist
;
66 dbx_alloc_type
PARAMS ((int [2], struct objfile
*));
68 static long read_huge_number
PARAMS ((char **, int, int *));
70 static struct type
*error_type
PARAMS ((char **));
73 patch_block_stabs
PARAMS ((struct pending
*, struct pending_stabs
*,
77 fix_common_block
PARAMS ((struct symbol
*, int));
80 read_type_number
PARAMS ((char **, int *));
83 read_range_type
PARAMS ((char **, int [2], struct objfile
*));
86 read_sun_builtin_type
PARAMS ((char **, int [2], struct objfile
*));
89 read_sun_floating_type
PARAMS ((char **, int [2], struct objfile
*));
92 read_enum_type
PARAMS ((char **, struct type
*, struct objfile
*));
95 rs6000_builtin_type
PARAMS ((int));
98 read_member_functions
PARAMS ((struct field_info
*, char **, struct type
*,
102 read_struct_fields
PARAMS ((struct field_info
*, char **, struct type
*,
106 read_baseclasses
PARAMS ((struct field_info
*, char **, struct type
*,
110 read_tilde_fields
PARAMS ((struct field_info
*, char **, struct type
*,
114 attach_fn_fields_to_type
PARAMS ((struct field_info
*, struct type
*));
117 attach_fields_to_type
PARAMS ((struct field_info
*, struct type
*,
121 read_struct_type
PARAMS ((char **, struct type
*, struct objfile
*));
124 read_array_type
PARAMS ((char **, struct type
*, struct objfile
*));
126 static struct type
**
127 read_args
PARAMS ((char **, int, struct objfile
*));
130 read_cpp_abbrev
PARAMS ((struct field_info
*, char **, struct type
*,
133 static const char vptr_name
[] = { '_','v','p','t','r',CPLUS_MARKER
,'\0' };
134 static const char vb_name
[] = { '_','v','b',CPLUS_MARKER
,'\0' };
136 /* Define this as 1 if a pcc declaration of a char or short argument
137 gives the correct address. Otherwise assume pcc gives the
138 address of the corresponding int, which is not the same on a
139 big-endian machine. */
141 #ifndef BELIEVE_PCC_PROMOTION
142 #define BELIEVE_PCC_PROMOTION 0
146 /* I think this can go away, all current uses have been removed.
147 GCC emits a few crazy types which can only be distinguished by the
148 name (complex, long long on some machines), but I'd say fix GCC. */
150 /* During some calls to read_type (and thus to read_range_type), this
151 contains the name of the type being defined. Range types are only
152 used in C as basic types. We use the name to distinguish the otherwise
153 identical basic types "int" and "long" and their unsigned versions.
154 FIXME, this should disappear with better type management. */
156 static char *long_kludge_name
;
160 struct complaint dbx_class_complaint
=
162 "encountered DBX-style class variable debugging information.\n\
163 You seem to have compiled your program with \
164 \"g++ -g0\" instead of \"g++ -g\".\n\
165 Therefore GDB will not know about your class variables", 0, 0
169 struct complaint invalid_cpp_abbrev_complaint
=
170 {"invalid C++ abbreviation `%s'", 0, 0};
172 struct complaint invalid_cpp_type_complaint
=
173 {"C++ abbreviated type name unknown at symtab pos %d", 0, 0};
175 struct complaint member_fn_complaint
=
176 {"member function type missing, got '%c'", 0, 0};
178 struct complaint const_vol_complaint
=
179 {"const/volatile indicator missing, got '%c'", 0, 0};
181 struct complaint error_type_complaint
=
182 {"debug info mismatch between compiler and debugger", 0, 0};
184 struct complaint invalid_member_complaint
=
185 {"invalid (minimal) member type data format at symtab pos %d.", 0, 0};
187 struct complaint range_type_base_complaint
=
188 {"base type %d of range type is not defined", 0, 0};
190 struct complaint reg_value_complaint
=
191 {"register number too large in symbol %s", 0, 0};
193 struct complaint vtbl_notfound_complaint
=
194 {"virtual function table pointer not found when defining class `%s'", 0, 0};
196 struct complaint unrecognized_cplus_name_complaint
=
197 {"Unknown C++ symbol name `%s'", 0, 0};
199 struct complaint rs6000_builtin_complaint
=
200 {"Unknown builtin type %d", 0, 0};
202 struct complaint stabs_general_complaint
=
205 /* Make a list of forward references which haven't been defined. */
207 static struct type
**undef_types
;
208 static int undef_types_allocated
;
209 static int undef_types_length
;
211 /* Check for and handle cretinous stabs symbol name continuation! */
212 #define STABS_CONTINUE(pp) \
214 if (**(pp) == '\\') *(pp) = next_symbol_text (); \
218 /* This is used by other symbol readers besides stabs, so for cleanliness
219 should probably be in buildsym.c. */
225 register char *p
= name
;
226 register int total
= p
[0];
241 /* Ensure result is positive. */
244 total
+= (1000 << 6);
246 return (total
% HASHSIZE
);
250 /* Look up a dbx type-number pair. Return the address of the slot
251 where the type for that number-pair is stored.
252 The number-pair is in TYPENUMS.
254 This can be used for finding the type associated with that pair
255 or for associating a new type with the pair. */
258 dbx_lookup_type (typenums
)
261 register int filenum
= typenums
[0];
262 register int index
= typenums
[1];
264 register int real_filenum
;
265 register struct header_file
*f
;
268 if (filenum
== -1) /* -1,-1 is for temporary types. */
271 if (filenum
< 0 || filenum
>= n_this_object_header_files
)
273 static struct complaint msg
= {"\
274 Invalid symbol data: type number (%d,%d) out of range at symtab pos %d.",
276 complain (&msg
, filenum
, index
, symnum
);
284 /* Caller wants address of address of type. We think
285 that negative (rs6k builtin) types will never appear as
286 "lvalues", (nor should they), so we stuff the real type
287 pointer into a temp, and return its address. If referenced,
288 this will do the right thing. */
289 static struct type
*temp_type
;
291 temp_type
= rs6000_builtin_type(index
);
295 /* Type is defined outside of header files.
296 Find it in this object file's type vector. */
297 if (index
>= type_vector_length
)
299 old_len
= type_vector_length
;
302 type_vector_length
= INITIAL_TYPE_VECTOR_LENGTH
;
303 type_vector
= (struct type
**)
304 malloc (type_vector_length
* sizeof (struct type
*));
306 while (index
>= type_vector_length
)
308 type_vector_length
*= 2;
310 type_vector
= (struct type
**)
311 xrealloc ((char *) type_vector
,
312 (type_vector_length
* sizeof (struct type
*)));
313 memset (&type_vector
[old_len
], 0,
314 (type_vector_length
- old_len
) * sizeof (struct type
*));
316 return (&type_vector
[index
]);
320 real_filenum
= this_object_header_files
[filenum
];
322 if (real_filenum
>= n_header_files
)
324 struct type
*temp_type
;
325 struct type
**temp_type_p
;
327 warning ("GDB internal error: bad real_filenum");
330 temp_type
= init_type (TYPE_CODE_ERROR
, 0, 0, NULL
, NULL
);
331 temp_type_p
= (struct type
**) xmalloc (sizeof (struct type
*));
332 *temp_type_p
= temp_type
;
336 f
= &header_files
[real_filenum
];
338 f_orig_length
= f
->length
;
339 if (index
>= f_orig_length
)
341 while (index
>= f
->length
)
345 f
->vector
= (struct type
**)
346 xrealloc ((char *) f
->vector
, f
->length
* sizeof (struct type
*));
347 memset (&f
->vector
[f_orig_length
], 0,
348 (f
->length
- f_orig_length
) * sizeof (struct type
*));
350 return (&f
->vector
[index
]);
354 /* Make sure there is a type allocated for type numbers TYPENUMS
355 and return the type object.
356 This can create an empty (zeroed) type object.
357 TYPENUMS may be (-1, -1) to return a new type object that is not
358 put into the type vector, and so may not be referred to by number. */
361 dbx_alloc_type (typenums
, objfile
)
363 struct objfile
*objfile
;
365 register struct type
**type_addr
;
367 if (typenums
[0] == -1)
369 return (alloc_type (objfile
));
372 type_addr
= dbx_lookup_type (typenums
);
374 /* If we are referring to a type not known at all yet,
375 allocate an empty type for it.
376 We will fill it in later if we find out how. */
379 *type_addr
= alloc_type (objfile
);
385 /* for all the stabs in a given stab vector, build appropriate types
386 and fix their symbols in given symbol vector. */
389 patch_block_stabs (symbols
, stabs
, objfile
)
390 struct pending
*symbols
;
391 struct pending_stabs
*stabs
;
392 struct objfile
*objfile
;
402 /* for all the stab entries, find their corresponding symbols and
403 patch their types! */
405 for (ii
= 0; ii
< stabs
->count
; ++ii
)
407 name
= stabs
->stab
[ii
];
408 pp
= (char*) strchr (name
, ':');
409 sym
= find_symbol_in_list (symbols
, name
, pp
-name
);
412 /* On xcoff, if a global is defined and never referenced,
413 ld will remove it from the executable. There is then
414 a N_GSYM stab for it, but no regular (C_EXT) symbol. */
415 sym
= (struct symbol
*)
416 obstack_alloc (&objfile
->symbol_obstack
,
417 sizeof (struct symbol
));
419 memset (sym
, 0, sizeof (struct symbol
));
420 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
421 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
423 obstack_copy0 (&objfile
->symbol_obstack
, name
, pp
- name
);
425 if (*(pp
-1) == 'F' || *(pp
-1) == 'f')
427 /* I don't think the linker does this with functions,
428 so as far as I know this is never executed.
429 But it doesn't hurt to check. */
431 lookup_function_type (read_type (&pp
, objfile
));
435 SYMBOL_TYPE (sym
) = read_type (&pp
, objfile
);
437 add_symbol_to_list (sym
, &global_symbols
);
442 if (*(pp
-1) == 'F' || *(pp
-1) == 'f')
445 lookup_function_type (read_type (&pp
, objfile
));
449 SYMBOL_TYPE (sym
) = read_type (&pp
, objfile
);
457 /* Read a number by which a type is referred to in dbx data,
458 or perhaps read a pair (FILENUM, TYPENUM) in parentheses.
459 Just a single number N is equivalent to (0,N).
460 Return the two numbers by storing them in the vector TYPENUMS.
461 TYPENUMS will then be used as an argument to dbx_lookup_type.
463 Returns 0 for success, -1 for error. */
466 read_type_number (pp
, typenums
)
468 register int *typenums
;
474 typenums
[0] = read_huge_number (pp
, ',', &nbits
);
475 if (nbits
!= 0) return -1;
476 typenums
[1] = read_huge_number (pp
, ')', &nbits
);
477 if (nbits
!= 0) return -1;
482 typenums
[1] = read_huge_number (pp
, 0, &nbits
);
483 if (nbits
!= 0) return -1;
489 /* To handle GNU C++ typename abbreviation, we need to be able to
490 fill in a type's name as soon as space for that type is allocated.
491 `type_synonym_name' is the name of the type being allocated.
492 It is cleared as soon as it is used (lest all allocated types
495 static char *type_synonym_name
;
499 define_symbol (valu
, string
, desc
, type
, objfile
)
504 struct objfile
*objfile
;
506 register struct symbol
*sym
;
507 char *p
= (char *) strchr (string
, ':');
512 /* We would like to eliminate nameless symbols, but keep their types.
513 E.g. stab entry ":t10=*2" should produce a type 10, which is a pointer
514 to type 2, but, should not create a symbol to address that type. Since
515 the symbol will be nameless, there is no way any user can refer to it. */
519 /* Ignore syms with empty names. */
523 /* Ignore old-style symbols from cc -go */
527 /* If a nameless stab entry, all we need is the type, not the symbol.
528 e.g. ":t10=*2" or a nameless enum like " :T16=ered:0,green:1,blue:2,;" */
529 nameless
= (p
== string
|| ((string
[0] == ' ') && (string
[1] == ':')));
531 sym
= (struct symbol
*)
532 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
533 memset (sym
, 0, sizeof (struct symbol
));
535 if (processing_gcc_compilation
)
537 /* GCC 2.x puts the line number in desc. SunOS apparently puts in the
538 number of bytes occupied by a type or object, which we ignore. */
539 SYMBOL_LINE(sym
) = desc
;
543 SYMBOL_LINE(sym
) = 0; /* unknown */
546 if (string
[0] == CPLUS_MARKER
)
548 /* Special GNU C++ names. */
552 SYMBOL_NAME (sym
) = obsavestring ("this", strlen ("this"),
553 &objfile
-> symbol_obstack
);
556 case 'v': /* $vtbl_ptr_type */
557 /* Was: SYMBOL_NAME (sym) = "vptr"; */
561 SYMBOL_NAME (sym
) = obsavestring ("eh_throw", strlen ("eh_throw"),
562 &objfile
-> symbol_obstack
);
566 /* This was an anonymous type that was never fixed up. */
570 complain (&unrecognized_cplus_name_complaint
, string
);
571 goto normal
; /* Do *something* with it */
577 SYMBOL_LANGUAGE (sym
) = current_subfile
-> language
;
578 SYMBOL_NAME (sym
) = (char *)
579 obstack_alloc (&objfile
-> symbol_obstack
, ((p
- string
) + 1));
580 /* Open-coded bcopy--saves function call time. */
581 /* FIXME: Does it really? Try replacing with simple strcpy and
582 try it on an executable with a large symbol table. */
584 register char *p1
= string
;
585 register char *p2
= SYMBOL_NAME (sym
);
593 /* If this symbol is from a C++ compilation, then attempt to cache the
594 demangled form for future reference. This is a typical time versus
595 space tradeoff, that was decided in favor of time because it sped up
596 C++ symbol lookups by a factor of about 20. */
598 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
->symbol_obstack
);
602 /* Determine the type of name being defined. */
604 /* Getting GDB to correctly skip the symbol on an undefined symbol
605 descriptor and not ever dump core is a very dodgy proposition if
606 we do things this way. I say the acorn RISC machine can just
607 fix their compiler. */
608 /* The Acorn RISC machine's compiler can put out locals that don't
609 start with "234=" or "(3,4)=", so assume anything other than the
610 deftypes we know how to handle is a local. */
611 if (!strchr ("cfFGpPrStTvVXCR", *p
))
613 if (isdigit (*p
) || *p
== '(' || *p
== '-')
622 /* c is a special case, not followed by a type-number.
623 SYMBOL:c=iVALUE for an integer constant symbol.
624 SYMBOL:c=rVALUE for a floating constant symbol.
625 SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
626 e.g. "b:c=e6,0" for "const b = blob1"
627 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
630 SYMBOL_CLASS (sym
) = LOC_CONST
;
631 SYMBOL_TYPE (sym
) = error_type (&p
);
632 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
633 add_symbol_to_list (sym
, &file_symbols
);
644 /* FIXME: lookup_fundamental_type is a hack. We should be
645 creating a type especially for the type of float constants.
646 Problem is, what type should it be? We currently have to
647 read this in host floating point format, but what type
648 represents a host format "double"?
650 Also, what should the name of this type be? Should we
651 be using 'S' constants (see stabs.texinfo) instead? */
653 SYMBOL_TYPE (sym
) = lookup_fundamental_type (objfile
,
656 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (double));
657 memcpy (dbl_valu
, &d
, sizeof (double));
658 /* Put it in target byte order, but it's still in host
659 floating point format. */
660 SWAP_TARGET_AND_HOST (dbl_valu
, sizeof (double));
661 SYMBOL_VALUE_BYTES (sym
) = dbl_valu
;
662 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
667 /* Defining integer constants this way is kind of silly,
668 since 'e' constants allows the compiler to give not
669 only the value, but the type as well. C has at least
670 int, long, unsigned int, and long long as constant
671 types; other languages probably should have at least
672 unsigned as well as signed constants. */
674 /* We just need one int constant type for all objfiles.
675 It doesn't depend on languages or anything (arguably its
676 name should be a language-specific name for a type of
677 that size, but I'm inclined to say that if the compiler
678 wants a nice name for the type, it can use 'e'). */
679 static struct type
*int_const_type
;
681 /* Yes, this is as long as a *host* int. That is because we
683 if (int_const_type
== NULL
)
685 init_type (TYPE_CODE_INT
,
686 sizeof (int) * HOST_CHAR_BIT
/ TARGET_CHAR_BIT
, 0,
688 (struct objfile
*)NULL
);
689 SYMBOL_TYPE (sym
) = int_const_type
;
690 SYMBOL_VALUE (sym
) = atoi (p
);
691 SYMBOL_CLASS (sym
) = LOC_CONST
;
695 /* SYMBOL:c=eTYPE,INTVALUE for a constant symbol whose value
696 can be represented as integral.
697 e.g. "b:c=e6,0" for "const b = blob1"
698 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
700 SYMBOL_CLASS (sym
) = LOC_CONST
;
701 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
705 SYMBOL_TYPE (sym
) = error_type (&p
);
710 /* If the value is too big to fit in an int (perhaps because
711 it is unsigned), or something like that, we silently get
712 a bogus value. The type and everything else about it is
713 correct. Ideally, we should be using whatever we have
714 available for parsing unsigned and long long values,
716 SYMBOL_VALUE (sym
) = atoi (p
);
721 SYMBOL_CLASS (sym
) = LOC_CONST
;
722 SYMBOL_TYPE (sym
) = error_type (&p
);
725 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
726 add_symbol_to_list (sym
, &file_symbols
);
730 /* The name of a caught exception. */
731 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
732 SYMBOL_CLASS (sym
) = LOC_LABEL
;
733 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
734 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
735 add_symbol_to_list (sym
, &local_symbols
);
739 /* A static function definition. */
740 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
741 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
742 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
743 add_symbol_to_list (sym
, &file_symbols
);
744 /* fall into process_function_types. */
746 process_function_types
:
747 /* Function result types are described as the result type in stabs.
748 We need to convert this to the function-returning-type-X type
749 in GDB. E.g. "int" is converted to "function returning int". */
750 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_FUNC
)
753 /* This code doesn't work -- it needs to realloc and can't. */
754 /* Attempt to set up to record a function prototype... */
755 struct type
*new = alloc_type (objfile
);
757 /* Generate a template for the type of this function. The
758 types of the arguments will be added as we read the symbol
760 *new = *lookup_function_type (SYMBOL_TYPE(sym
));
761 SYMBOL_TYPE(sym
) = new;
762 TYPE_OBJFILE (new) = objfile
;
763 in_function_type
= new;
765 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
768 /* fall into process_prototype_types */
770 process_prototype_types
:
771 /* Sun acc puts declared types of arguments here. We don't care
772 about their actual types (FIXME -- we should remember the whole
773 function prototype), but the list may define some new types
774 that we have to remember, so we must scan it now. */
777 read_type (&p
, objfile
);
782 /* A global function definition. */
783 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
784 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
785 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
786 add_symbol_to_list (sym
, &global_symbols
);
787 goto process_function_types
;
790 /* For a class G (global) symbol, it appears that the
791 value is not correct. It is necessary to search for the
792 corresponding linker definition to find the value.
793 These definitions appear at the end of the namelist. */
794 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
795 i
= hashname (SYMBOL_NAME (sym
));
796 SYMBOL_VALUE_CHAIN (sym
) = global_sym_chain
[i
];
797 global_sym_chain
[i
] = sym
;
798 SYMBOL_CLASS (sym
) = LOC_STATIC
;
799 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
800 add_symbol_to_list (sym
, &global_symbols
);
803 /* This case is faked by a conditional above,
804 when there is no code letter in the dbx data.
805 Dbx data never actually contains 'l'. */
807 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
808 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
809 SYMBOL_VALUE (sym
) = valu
;
810 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
811 add_symbol_to_list (sym
, &local_symbols
);
816 /* pF is a two-letter code that means a function parameter in Fortran.
817 The type-number specifies the type of the return value.
818 Translate it into a pointer-to-function type. */
822 = lookup_pointer_type
823 (lookup_function_type (read_type (&p
, objfile
)));
826 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
828 /* Normally this is a parameter, a LOC_ARG. On the i960, it
829 can also be a LOC_LOCAL_ARG depending on symbol type. */
830 #ifndef DBX_PARM_SYMBOL_CLASS
831 #define DBX_PARM_SYMBOL_CLASS(type) LOC_ARG
834 SYMBOL_CLASS (sym
) = DBX_PARM_SYMBOL_CLASS (type
);
835 SYMBOL_VALUE (sym
) = valu
;
836 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
838 /* This doesn't work yet. */
839 add_param_to_type (&in_function_type
, sym
);
841 add_symbol_to_list (sym
, &local_symbols
);
843 /* If it's gcc-compiled, if it says `short', believe it. */
844 if (processing_gcc_compilation
|| BELIEVE_PCC_PROMOTION
)
847 #if !BELIEVE_PCC_PROMOTION
849 /* This is the signed type which arguments get promoted to. */
850 static struct type
*pcc_promotion_type
;
851 /* This is the unsigned type which arguments get promoted to. */
852 static struct type
*pcc_unsigned_promotion_type
;
854 /* Call it "int" because this is mainly C lossage. */
855 if (pcc_promotion_type
== NULL
)
857 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
860 if (pcc_unsigned_promotion_type
== NULL
)
861 pcc_unsigned_promotion_type
=
862 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
863 TYPE_FLAG_UNSIGNED
, "unsigned int", NULL
);
865 #if defined(BELIEVE_PCC_PROMOTION_TYPE)
866 /* This macro is defined on machines (e.g. sparc) where
867 we should believe the type of a PCC 'short' argument,
868 but shouldn't believe the address (the address is
869 the address of the corresponding int). Note that
870 this is only different from the BELIEVE_PCC_PROMOTION
871 case on big-endian machines.
873 My guess is that this correction, as opposed to changing
874 the parameter to an 'int' (as done below, for PCC
875 on most machines), is the right thing to do
876 on all machines, but I don't want to risk breaking
877 something that already works. On most PCC machines,
878 the sparc problem doesn't come up because the calling
879 function has to zero the top bytes (not knowing whether
880 the called function wants an int or a short), so there
881 is no practical difference between an int and a short
882 (except perhaps what happens when the GDB user types
883 "print short_arg = 0x10000;").
885 Hacked for SunOS 4.1 by gnu@cygnus.com. In 4.1, the compiler
886 actually produces the correct address (we don't need to fix it
887 up). I made this code adapt so that it will offset the symbol
888 if it was pointing at an int-aligned location and not
889 otherwise. This way you can use the same gdb for 4.0.x and
892 If the parameter is shorter than an int, and is integral
893 (e.g. char, short, or unsigned equivalent), and is claimed to
894 be passed on an integer boundary, don't believe it! Offset the
895 parameter's address to the tail-end of that integer. */
897 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (pcc_promotion_type
)
898 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
899 && 0 == SYMBOL_VALUE (sym
) % TYPE_LENGTH (pcc_promotion_type
))
901 SYMBOL_VALUE (sym
) += TYPE_LENGTH (pcc_promotion_type
)
902 - TYPE_LENGTH (SYMBOL_TYPE (sym
));
906 #else /* no BELIEVE_PCC_PROMOTION_TYPE. */
908 /* If PCC says a parameter is a short or a char,
909 it is really an int. */
910 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (pcc_promotion_type
)
911 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
)
914 TYPE_UNSIGNED (SYMBOL_TYPE (sym
))
915 ? pcc_unsigned_promotion_type
916 : pcc_promotion_type
;
920 #endif /* no BELIEVE_PCC_PROMOTION_TYPE. */
922 #endif /* !BELIEVE_PCC_PROMOTION. */
925 /* acc seems to use P to delare the prototypes of functions that
926 are referenced by this file. gdb is not prepared to deal
927 with this extra information. FIXME, it ought to. */
930 read_type (&p
, objfile
);
931 goto process_prototype_types
;
936 /* Parameter which is in a register. */
937 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
938 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
939 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (valu
);
940 if (SYMBOL_VALUE (sym
) >= NUM_REGS
)
942 complain (®_value_complaint
, SYMBOL_SOURCE_NAME (sym
));
943 SYMBOL_VALUE (sym
) = SP_REGNUM
; /* Known safe, though useless */
945 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
946 add_symbol_to_list (sym
, &local_symbols
);
950 /* Register variable (either global or local). */
951 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
952 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
953 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (valu
);
954 if (SYMBOL_VALUE (sym
) >= NUM_REGS
)
956 complain (®_value_complaint
, SYMBOL_SOURCE_NAME (sym
));
957 SYMBOL_VALUE (sym
) = SP_REGNUM
; /* Known safe, though useless */
959 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
962 /* Sun cc uses a pair of symbols, one 'p' and one 'r' with the same
963 name to represent an argument passed in a register.
964 GCC uses 'P' for the same case. So if we find such a symbol pair
965 we combine it into one 'P' symbol.
966 Note that this code illegally combines
967 main(argc) int argc; { register int argc = 1; }
968 but this case is considered pathological and causes a warning
969 from a decent compiler. */
971 && local_symbols
->nsyms
> 0)
973 struct symbol
*prev_sym
;
974 prev_sym
= local_symbols
->symbol
[local_symbols
->nsyms
- 1];
975 if (SYMBOL_CLASS (prev_sym
) == LOC_ARG
976 && STREQ (SYMBOL_NAME (prev_sym
), SYMBOL_NAME(sym
)))
978 SYMBOL_CLASS (prev_sym
) = LOC_REGPARM
;
979 SYMBOL_VALUE (prev_sym
) = SYMBOL_VALUE (sym
);
984 add_symbol_to_list (sym
, &local_symbols
);
987 add_symbol_to_list (sym
, &file_symbols
);
991 /* Static symbol at top level of file */
992 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
993 SYMBOL_CLASS (sym
) = LOC_STATIC
;
994 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
995 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
996 add_symbol_to_list (sym
, &file_symbols
);
1001 /* See comment where long_kludge_name is declared. */
1002 /* Here we save the name of the symbol for read_range_type, which
1003 ends up reading in the basic types. In stabs, unfortunately there
1004 is no distinction between "int" and "long" types except their
1005 names. Until we work out a saner type policy (eliminating most
1006 builtin types and using the names specified in the files), we
1007 save away the name so that far away from here in read_range_type,
1008 we can examine it to decide between "int" and "long". FIXME. */
1009 long_kludge_name
= SYMBOL_NAME (sym
);
1011 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1013 /* For a nameless type, we don't want a create a symbol, thus we
1014 did not use `sym'. Return without further processing. */
1015 if (nameless
) return NULL
;
1017 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1018 SYMBOL_VALUE (sym
) = valu
;
1019 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1020 /* C++ vagaries: we may have a type which is derived from
1021 a base type which did not have its name defined when the
1022 derived class was output. We fill in the derived class's
1023 base part member's name here in that case. */
1024 if (TYPE_NAME (SYMBOL_TYPE (sym
)) != NULL
)
1025 if ((TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
1026 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_UNION
)
1027 && TYPE_N_BASECLASSES (SYMBOL_TYPE (sym
)))
1030 for (j
= TYPE_N_BASECLASSES (SYMBOL_TYPE (sym
)) - 1; j
>= 0; j
--)
1031 if (TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym
), j
) == 0)
1032 TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym
), j
) =
1033 type_name_no_tag (TYPE_BASECLASS (SYMBOL_TYPE (sym
), j
));
1036 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == NULL
)
1038 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_PTR
)
1040 /* If we are giving a name to a type such as "pointer
1041 to foo", we better not set the TYPE_NAME. If the
1042 program contains "typedef char *caddr_t;", we don't
1043 want all variables of type char * to print as
1044 caddr_t. This is not just a consequence of GDB's
1045 type management; PCC and GCC (at least through
1046 version 2.4) both output variables of either type
1047 char * or caddr_t with the type number defined in
1048 the 't' symbol for caddr_t. If a future compiler
1049 cleans this up it GDB is not ready for it yet, but
1050 if it becomes ready we somehow need to disable this
1051 check (without breaking the PCC/GCC2.4 case).
1055 Fortunately, this check seems not to be necessary
1056 for anything except pointers. */
1059 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_NAME (sym
);
1062 add_symbol_to_list (sym
, &file_symbols
);
1066 /* Struct, union, or enum tag. For GNU C++, this can be be followed
1067 by 't' which means we are typedef'ing it as well. */
1068 synonym
= *p
== 't';
1073 type_synonym_name
= obsavestring (SYMBOL_NAME (sym
),
1074 strlen (SYMBOL_NAME (sym
)),
1075 &objfile
-> symbol_obstack
);
1078 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1080 /* For a nameless type, we don't want a create a symbol, thus we
1081 did not use `sym'. Return without further processing. */
1082 if (nameless
) return NULL
;
1084 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1085 SYMBOL_VALUE (sym
) = valu
;
1086 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
1087 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
1088 TYPE_NAME (SYMBOL_TYPE (sym
))
1089 = obconcat (&objfile
-> type_obstack
, "",
1090 (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_ENUM
1092 : (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
1093 ? "struct " : "union ")),
1095 add_symbol_to_list (sym
, &file_symbols
);
1099 /* Clone the sym and then modify it. */
1100 register struct symbol
*typedef_sym
= (struct symbol
*)
1101 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
1102 *typedef_sym
= *sym
;
1103 SYMBOL_CLASS (typedef_sym
) = LOC_TYPEDEF
;
1104 SYMBOL_VALUE (typedef_sym
) = valu
;
1105 SYMBOL_NAMESPACE (typedef_sym
) = VAR_NAMESPACE
;
1106 add_symbol_to_list (typedef_sym
, &file_symbols
);
1111 /* Static symbol of local scope */
1112 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1113 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1114 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
1115 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1116 add_symbol_to_list (sym
, &local_symbols
);
1120 /* Reference parameter */
1121 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1122 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
1123 SYMBOL_VALUE (sym
) = valu
;
1124 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1125 add_symbol_to_list (sym
, &local_symbols
);
1129 /* This is used by Sun FORTRAN for "function result value".
1130 Sun claims ("dbx and dbxtool interfaces", 2nd ed)
1131 that Pascal uses it too, but when I tried it Pascal used
1132 "x:3" (local symbol) instead. */
1133 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1134 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
1135 SYMBOL_VALUE (sym
) = valu
;
1136 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1137 add_symbol_to_list (sym
, &local_symbols
);
1141 SYMBOL_TYPE (sym
) = error_type (&p
);
1142 SYMBOL_CLASS (sym
) = LOC_CONST
;
1143 SYMBOL_VALUE (sym
) = 0;
1144 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1145 add_symbol_to_list (sym
, &file_symbols
);
1149 /* When passing structures to a function, some systems sometimes pass
1150 the address in a register, not the structure itself.
1152 If REG_STRUCT_HAS_ADDR yields non-zero we have to convert LOC_REGPARM
1153 to LOC_REGPARM_ADDR for structures and unions. */
1155 #if !defined (REG_STRUCT_HAS_ADDR)
1156 #define REG_STRUCT_HAS_ADDR(gcc_p) 0
1159 if (SYMBOL_CLASS (sym
) == LOC_REGPARM
1160 && REG_STRUCT_HAS_ADDR (processing_gcc_compilation
)
1161 && ( (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
1162 || (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_UNION
)))
1163 SYMBOL_CLASS (sym
) = LOC_REGPARM_ADDR
;
1169 /* Skip rest of this symbol and return an error type.
1171 General notes on error recovery: error_type always skips to the
1172 end of the symbol (modulo cretinous dbx symbol name continuation).
1173 Thus code like this:
1175 if (*(*pp)++ != ';')
1176 return error_type (pp);
1178 is wrong because if *pp starts out pointing at '\0' (typically as the
1179 result of an earlier error), it will be incremented to point to the
1180 start of the next symbol, which might produce strange results, at least
1181 if you run off the end of the string table. Instead use
1184 return error_type (pp);
1190 foo = error_type (pp);
1194 And in case it isn't obvious, the point of all this hair is so the compiler
1195 can define new types and new syntaxes, and old versions of the
1196 debugger will be able to read the new symbol tables. */
1198 static struct type
*
1202 complain (&error_type_complaint
);
1205 /* Skip to end of symbol. */
1206 while (**pp
!= '\0')
1211 /* Check for and handle cretinous dbx symbol name continuation! */
1212 if ((*pp
)[-1] == '\\')
1214 *pp
= next_symbol_text ();
1221 return (builtin_type_error
);
1225 /* Read type information or a type definition; return the type. Even
1226 though this routine accepts either type information or a type
1227 definition, the distinction is relevant--some parts of stabsread.c
1228 assume that type information starts with a digit, '-', or '(' in
1229 deciding whether to call read_type. */
1232 read_type (pp
, objfile
)
1234 struct objfile
*objfile
;
1236 register struct type
*type
= 0;
1240 char type_descriptor
;
1242 /* Read type number if present. The type number may be omitted.
1243 for instance in a two-dimensional array declared with type
1244 "ar1;1;10;ar1;1;10;4". */
1245 if ((**pp
>= '0' && **pp
<= '9')
1248 if (read_type_number (pp
, typenums
) != 0)
1249 return error_type (pp
);
1251 /* Type is not being defined here. Either it already exists,
1252 or this is a forward reference to it. dbx_alloc_type handles
1255 return dbx_alloc_type (typenums
, objfile
);
1257 /* Type is being defined here. */
1264 /* It might be a type attribute or a member type. */
1265 if (isdigit (*p
) || *p
== '(' || *p
== '-')
1270 /* Type attributes; skip to the semicolon. */
1271 while (*p
!= ';' && *p
!= '\0')
1275 return error_type (pp
);
1277 /* Skip the semicolon. */
1281 /* Skip the type descriptor, we get it below with (*pp)[-1]. */
1286 /* 'typenums=' not present, type is anonymous. Read and return
1287 the definition, but don't put it in the type vector. */
1288 typenums
[0] = typenums
[1] = -1;
1292 type_descriptor
= (*pp
)[-1];
1293 switch (type_descriptor
)
1297 enum type_code code
;
1299 /* Used to index through file_symbols. */
1300 struct pending
*ppt
;
1303 /* Name including "struct", etc. */
1306 /* Name without "struct", etc. */
1307 char *type_name_only
;
1313 /* Set the type code according to the following letter. */
1317 code
= TYPE_CODE_STRUCT
;
1321 code
= TYPE_CODE_UNION
;
1325 code
= TYPE_CODE_ENUM
;
1329 return error_type (pp
);
1332 to
= type_name
= (char *)
1333 obstack_alloc (&objfile
-> type_obstack
,
1335 ((char *) strchr (*pp
, ':') - (*pp
)) + 1));
1337 /* Copy the prefix. */
1339 while ((*to
++ = *from
++) != '\0')
1343 type_name_only
= to
;
1345 /* Copy the name. */
1347 while ((*to
++ = *from
++) != ':')
1351 /* Set the pointer ahead of the name which we just read. */
1355 /* The following hack is clearly wrong, because it doesn't
1356 check whether we are in a baseclass. I tried to reproduce
1357 the case that it is trying to fix, but I couldn't get
1358 g++ to put out a cross reference to a basetype. Perhaps
1359 it doesn't do it anymore. */
1360 /* Note: for C++, the cross reference may be to a base type which
1361 has not yet been seen. In this case, we skip to the comma,
1362 which will mark the end of the base class name. (The ':'
1363 at the end of the base class name will be skipped as well.)
1364 But sometimes (ie. when the cross ref is the last thing on
1365 the line) there will be no ','. */
1366 from
= (char *) strchr (*pp
, ',');
1372 /* Now check to see whether the type has already been declared. */
1373 /* This is necessary at least in the case where the
1374 program says something like
1376 The compiler puts out a cross-reference; we better find
1377 set the length of the structure correctly so we can
1378 set the length of the array. */
1379 for (ppt
= file_symbols
; ppt
; ppt
= ppt
->next
)
1380 for (i
= 0; i
< ppt
->nsyms
; i
++)
1382 struct symbol
*sym
= ppt
->symbol
[i
];
1384 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
1385 && SYMBOL_NAMESPACE (sym
) == STRUCT_NAMESPACE
1386 && (TYPE_CODE (SYMBOL_TYPE (sym
)) == code
)
1387 && STREQ (SYMBOL_NAME (sym
), type_name_only
))
1389 obstack_free (&objfile
-> type_obstack
, type_name
);
1390 type
= SYMBOL_TYPE (sym
);
1395 /* Didn't find the type to which this refers, so we must
1396 be dealing with a forward reference. Allocate a type
1397 structure for it, and keep track of it so we can
1398 fill in the rest of the fields when we get the full
1400 type
= dbx_alloc_type (typenums
, objfile
);
1401 TYPE_CODE (type
) = code
;
1402 TYPE_NAME (type
) = type_name
;
1403 INIT_CPLUS_SPECIFIC(type
);
1404 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
1406 add_undefined_type (type
);
1410 case '-': /* RS/6000 built-in type */
1423 /* The type is being defined to another type. When we support
1424 Ada (and arguably for C, so "whatis foo" can give "size_t",
1425 "wchar_t", or whatever it was declared as) we'll need to
1426 allocate a distinct type here rather than returning the
1427 existing one. GCC is currently (deliberately) incapable of
1428 putting out the debugging information to do that, however. */
1431 if (read_type_number (pp
, xtypenums
) != 0)
1432 return error_type (pp
);
1433 if (typenums
[0] == xtypenums
[0] && typenums
[1] == xtypenums
[1])
1434 /* It's being defined as itself. That means it is "void". */
1435 type
= init_type (TYPE_CODE_VOID
, 0, 0, NULL
, objfile
);
1437 type
= *dbx_lookup_type (xtypenums
);
1438 if (typenums
[0] != -1)
1439 *dbx_lookup_type (typenums
) = type
;
1440 /* This can happen if we had '-' followed by a garbage character,
1443 return error_type (pp
);
1446 /* In the following types, we must be sure to overwrite any existing
1447 type that the typenums refer to, rather than allocating a new one
1448 and making the typenums point to the new one. This is because there
1449 may already be pointers to the existing type (if it had been
1450 forward-referenced), and we must change it to a pointer, function,
1451 reference, or whatever, *in-place*. */
1454 type1
= read_type (pp
, objfile
);
1455 type
= make_pointer_type (type1
, dbx_lookup_type (typenums
));
1458 case '&': /* Reference to another type */
1459 type1
= read_type (pp
, objfile
);
1460 type
= make_reference_type (type1
, dbx_lookup_type (typenums
));
1463 case 'f': /* Function returning another type */
1464 type1
= read_type (pp
, objfile
);
1465 type
= make_function_type (type1
, dbx_lookup_type (typenums
));
1468 case 'k': /* Const qualifier on some type (Sun) */
1469 type
= read_type (pp
, objfile
);
1470 /* FIXME! For now, we ignore const and volatile qualifiers. */
1473 case 'B': /* Volatile qual on some type (Sun) */
1474 type
= read_type (pp
, objfile
);
1475 /* FIXME! For now, we ignore const and volatile qualifiers. */
1478 /* FIXME -- we should be doing smash_to_XXX types here. */
1479 case '@': /* Member (class & variable) type */
1481 struct type
*domain
= read_type (pp
, objfile
);
1482 struct type
*memtype
;
1485 /* Invalid member type data format. */
1486 return error_type (pp
);
1489 memtype
= read_type (pp
, objfile
);
1490 type
= dbx_alloc_type (typenums
, objfile
);
1491 smash_to_member_type (type
, domain
, memtype
);
1495 case '#': /* Method (class & fn) type */
1496 if ((*pp
)[0] == '#')
1498 /* We'll get the parameter types from the name. */
1499 struct type
*return_type
;
1502 return_type
= read_type (pp
, objfile
);
1503 if (*(*pp
)++ != ';')
1504 complain (&invalid_member_complaint
, symnum
);
1505 type
= allocate_stub_method (return_type
);
1506 if (typenums
[0] != -1)
1507 *dbx_lookup_type (typenums
) = type
;
1511 struct type
*domain
= read_type (pp
, objfile
);
1512 struct type
*return_type
;
1516 /* Invalid member type data format. */
1517 return error_type (pp
);
1521 return_type
= read_type (pp
, objfile
);
1522 args
= read_args (pp
, ';', objfile
);
1523 type
= dbx_alloc_type (typenums
, objfile
);
1524 smash_to_method_type (type
, domain
, return_type
, args
);
1528 case 'r': /* Range type */
1529 type
= read_range_type (pp
, typenums
, objfile
);
1530 if (typenums
[0] != -1)
1531 *dbx_lookup_type (typenums
) = type
;
1534 case 'b': /* Sun ACC builtin int type */
1535 type
= read_sun_builtin_type (pp
, typenums
, objfile
);
1536 if (typenums
[0] != -1)
1537 *dbx_lookup_type (typenums
) = type
;
1540 case 'R': /* Sun ACC builtin float type */
1541 type
= read_sun_floating_type (pp
, typenums
, objfile
);
1542 if (typenums
[0] != -1)
1543 *dbx_lookup_type (typenums
) = type
;
1546 case 'e': /* Enumeration type */
1547 type
= dbx_alloc_type (typenums
, objfile
);
1548 type
= read_enum_type (pp
, type
, objfile
);
1549 if (typenums
[0] != -1)
1550 *dbx_lookup_type (typenums
) = type
;
1553 case 's': /* Struct type */
1554 case 'u': /* Union type */
1555 type
= dbx_alloc_type (typenums
, objfile
);
1556 if (!TYPE_NAME (type
))
1558 TYPE_NAME (type
) = type_synonym_name
;
1560 type_synonym_name
= NULL
;
1561 switch (type_descriptor
)
1564 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
1567 TYPE_CODE (type
) = TYPE_CODE_UNION
;
1570 type
= read_struct_type (pp
, type
, objfile
);
1573 case 'a': /* Array type */
1575 return error_type (pp
);
1578 type
= dbx_alloc_type (typenums
, objfile
);
1579 type
= read_array_type (pp
, type
, objfile
);
1583 --*pp
; /* Go back to the symbol in error */
1584 /* Particularly important if it was \0! */
1585 return error_type (pp
);
1590 warning ("GDB internal error, type is NULL in stabsread.c\n");
1591 return error_type (pp
);
1597 /* RS/6000 xlc/dbx combination uses a set of builtin types, starting from -1.
1598 Return the proper type node for a given builtin type number. */
1600 static struct type
*
1601 rs6000_builtin_type (typenum
)
1604 /* We recognize types numbered from -NUMBER_RECOGNIZED to -1. */
1605 #define NUMBER_RECOGNIZED 30
1606 /* This includes an empty slot for type number -0. */
1607 static struct type
*negative_types
[NUMBER_RECOGNIZED
+ 1];
1608 struct type
*rettype
;
1610 if (typenum
>= 0 || typenum
< -NUMBER_RECOGNIZED
)
1612 complain (&rs6000_builtin_complaint
, typenum
);
1613 return builtin_type_error
;
1615 if (negative_types
[-typenum
] != NULL
)
1616 return negative_types
[-typenum
];
1618 #if TARGET_CHAR_BIT != 8
1619 #error This code wrong for TARGET_CHAR_BIT not 8
1620 /* These definitions all assume that TARGET_CHAR_BIT is 8. I think
1621 that if that ever becomes not true, the correct fix will be to
1622 make the size in the struct type to be in bits, not in units of
1629 /* The size of this and all the other types are fixed, defined
1630 by the debugging format. If there is a type called "int" which
1631 is other than 32 bits, then it should use a new negative type
1632 number (or avoid negative type numbers for that case).
1633 See stabs.texinfo. */
1634 rettype
= init_type (TYPE_CODE_INT
, 4, 0, "int", NULL
);
1637 rettype
= init_type (TYPE_CODE_INT
, 1, 0, "char", NULL
);
1640 rettype
= init_type (TYPE_CODE_INT
, 2, 0, "short", NULL
);
1643 rettype
= init_type (TYPE_CODE_INT
, 4, 0, "long", NULL
);
1646 rettype
= init_type (TYPE_CODE_INT
, 1, TYPE_FLAG_UNSIGNED
,
1647 "unsigned char", NULL
);
1650 rettype
= init_type (TYPE_CODE_INT
, 1, 0, "signed char", NULL
);
1653 rettype
= init_type (TYPE_CODE_INT
, 2, TYPE_FLAG_UNSIGNED
,
1654 "unsigned short", NULL
);
1657 rettype
= init_type (TYPE_CODE_INT
, 4, TYPE_FLAG_UNSIGNED
,
1658 "unsigned int", NULL
);
1661 rettype
= init_type (TYPE_CODE_INT
, 4, TYPE_FLAG_UNSIGNED
,
1664 rettype
= init_type (TYPE_CODE_INT
, 4, TYPE_FLAG_UNSIGNED
,
1665 "unsigned long", NULL
);
1668 rettype
= init_type (TYPE_CODE_VOID
, 0, 0, "void", NULL
);
1671 /* IEEE single precision (32 bit). */
1672 rettype
= init_type (TYPE_CODE_FLT
, 4, 0, "float", NULL
);
1675 /* IEEE double precision (64 bit). */
1676 rettype
= init_type (TYPE_CODE_FLT
, 8, 0, "double", NULL
);
1679 /* This is an IEEE double on the RS/6000, and different machines with
1680 different sizes for "long double" should use different negative
1681 type numbers. See stabs.texinfo. */
1682 rettype
= init_type (TYPE_CODE_FLT
, 8, 0, "long double", NULL
);
1685 rettype
= init_type (TYPE_CODE_INT
, 4, 0, "integer", NULL
);
1688 /* What is the proper size of this type? */
1689 rettype
= init_type (TYPE_CODE_BOOL
, 1, 0, "boolean", NULL
);
1692 rettype
= init_type (TYPE_CODE_FLT
, 4, 0, "short real", NULL
);
1695 rettype
= init_type (TYPE_CODE_FLT
, 8, 0, "real", NULL
);
1698 rettype
= init_type (TYPE_CODE_ERROR
, 0, 0, "stringptr", NULL
);
1701 rettype
= init_type (TYPE_CODE_CHAR
, 1, TYPE_FLAG_UNSIGNED
,
1705 rettype
= init_type (TYPE_CODE_INT
, 1, TYPE_FLAG_UNSIGNED
,
1709 rettype
= init_type (TYPE_CODE_INT
, 2, TYPE_FLAG_UNSIGNED
,
1713 rettype
= init_type (TYPE_CODE_INT
, 4, TYPE_FLAG_UNSIGNED
,
1717 rettype
= init_type (TYPE_CODE_INT
, 4, TYPE_FLAG_UNSIGNED
,
1721 /* Complex type consisting of two IEEE single precision values. */
1722 rettype
= init_type (TYPE_CODE_ERROR
, 8, 0, "complex", NULL
);
1725 /* Complex type consisting of two IEEE double precision values. */
1726 rettype
= init_type (TYPE_CODE_ERROR
, 16, 0, "double complex", NULL
);
1729 rettype
= init_type (TYPE_CODE_INT
, 1, 0, "integer*1", NULL
);
1732 rettype
= init_type (TYPE_CODE_INT
, 2, 0, "integer*2", NULL
);
1735 rettype
= init_type (TYPE_CODE_INT
, 4, 0, "integer*4", NULL
);
1738 rettype
= init_type (TYPE_CODE_CHAR
, 2, 0, "wchar", NULL
);
1741 negative_types
[-typenum
] = rettype
;
1745 /* This page contains subroutines of read_type. */
1747 #define VISIBILITY_PRIVATE '0' /* Stabs character for private field */
1748 #define VISIBILITY_PROTECTED '1' /* Stabs character for protected fld */
1749 #define VISIBILITY_PUBLIC '2' /* Stabs character for public field */
1751 /* Read member function stabs info for C++ classes. The form of each member
1754 NAME :: TYPENUM[=type definition] ARGS : PHYSNAME ;
1756 An example with two member functions is:
1758 afunc1::20=##15;:i;2A.;afunc2::20:i;2A.;
1760 For the case of overloaded operators, the format is op$::*.funcs, where
1761 $ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator
1762 name (such as `+=') and `.' marks the end of the operator name.
1764 Returns 1 for success, 0 for failure. */
1767 read_member_functions (fip
, pp
, type
, objfile
)
1768 struct field_info
*fip
;
1771 struct objfile
*objfile
;
1775 /* Total number of member functions defined in this class. If the class
1776 defines two `f' functions, and one `g' function, then this will have
1778 int total_length
= 0;
1782 struct next_fnfield
*next
;
1783 struct fn_field fn_field
;
1785 struct type
*look_ahead_type
;
1786 struct next_fnfieldlist
*new_fnlist
;
1787 struct next_fnfield
*new_sublist
;
1791 /* Process each list until we find something that is not a member function
1792 or find the end of the functions. */
1796 /* We should be positioned at the start of the function name.
1797 Scan forward to find the first ':' and if it is not the
1798 first of a "::" delimiter, then this is not a member function. */
1810 look_ahead_type
= NULL
;
1813 new_fnlist
= (struct next_fnfieldlist
*)
1814 xmalloc (sizeof (struct next_fnfieldlist
));
1815 make_cleanup (free
, new_fnlist
);
1816 memset (new_fnlist
, 0, sizeof (struct next_fnfieldlist
));
1818 if ((*pp
)[0] == 'o' && (*pp
)[1] == 'p' && (*pp
)[2] == CPLUS_MARKER
)
1820 /* This is a completely wierd case. In order to stuff in the
1821 names that might contain colons (the usual name delimiter),
1822 Mike Tiemann defined a different name format which is
1823 signalled if the identifier is "op$". In that case, the
1824 format is "op$::XXXX." where XXXX is the name. This is
1825 used for names like "+" or "=". YUUUUUUUK! FIXME! */
1826 /* This lets the user type "break operator+".
1827 We could just put in "+" as the name, but that wouldn't
1829 static char opname
[32] = {'o', 'p', CPLUS_MARKER
};
1830 char *o
= opname
+ 3;
1832 /* Skip past '::'. */
1835 STABS_CONTINUE (pp
);
1841 main_fn_name
= savestring (opname
, o
- opname
);
1847 main_fn_name
= savestring (*pp
, p
- *pp
);
1848 /* Skip past '::'. */
1851 new_fnlist
-> fn_fieldlist
.name
= main_fn_name
;
1856 (struct next_fnfield
*) xmalloc (sizeof (struct next_fnfield
));
1857 make_cleanup (free
, new_sublist
);
1858 memset (new_sublist
, 0, sizeof (struct next_fnfield
));
1860 /* Check for and handle cretinous dbx symbol name continuation! */
1861 if (look_ahead_type
== NULL
)
1864 STABS_CONTINUE (pp
);
1866 new_sublist
-> fn_field
.type
= read_type (pp
, objfile
);
1869 /* Invalid symtab info for member function. */
1875 /* g++ version 1 kludge */
1876 new_sublist
-> fn_field
.type
= look_ahead_type
;
1877 look_ahead_type
= NULL
;
1887 /* If this is just a stub, then we don't have the real name here. */
1889 if (TYPE_FLAGS (new_sublist
-> fn_field
.type
) & TYPE_FLAG_STUB
)
1891 if (!TYPE_DOMAIN_TYPE (new_sublist
-> fn_field
.type
))
1892 TYPE_DOMAIN_TYPE (new_sublist
-> fn_field
.type
) = type
;
1893 new_sublist
-> fn_field
.is_stub
= 1;
1895 new_sublist
-> fn_field
.physname
= savestring (*pp
, p
- *pp
);
1898 /* Set this member function's visibility fields. */
1901 case VISIBILITY_PRIVATE
:
1902 new_sublist
-> fn_field
.is_private
= 1;
1904 case VISIBILITY_PROTECTED
:
1905 new_sublist
-> fn_field
.is_protected
= 1;
1909 STABS_CONTINUE (pp
);
1912 case 'A': /* Normal functions. */
1913 new_sublist
-> fn_field
.is_const
= 0;
1914 new_sublist
-> fn_field
.is_volatile
= 0;
1917 case 'B': /* `const' member functions. */
1918 new_sublist
-> fn_field
.is_const
= 1;
1919 new_sublist
-> fn_field
.is_volatile
= 0;
1922 case 'C': /* `volatile' member function. */
1923 new_sublist
-> fn_field
.is_const
= 0;
1924 new_sublist
-> fn_field
.is_volatile
= 1;
1927 case 'D': /* `const volatile' member function. */
1928 new_sublist
-> fn_field
.is_const
= 1;
1929 new_sublist
-> fn_field
.is_volatile
= 1;
1932 case '*': /* File compiled with g++ version 1 -- no info */
1937 complain (&const_vol_complaint
, **pp
);
1946 /* virtual member function, followed by index.
1947 The sign bit is set to distinguish pointers-to-methods
1948 from virtual function indicies. Since the array is
1949 in words, the quantity must be shifted left by 1
1950 on 16 bit machine, and by 2 on 32 bit machine, forcing
1951 the sign bit out, and usable as a valid index into
1952 the array. Remove the sign bit here. */
1953 new_sublist
-> fn_field
.voffset
=
1954 (0x7fffffff & read_huge_number (pp
, ';', &nbits
)) + 2;
1958 STABS_CONTINUE (pp
);
1959 if (**pp
== ';' || **pp
== '\0')
1961 /* Must be g++ version 1. */
1962 new_sublist
-> fn_field
.fcontext
= 0;
1966 /* Figure out from whence this virtual function came.
1967 It may belong to virtual function table of
1968 one of its baseclasses. */
1969 look_ahead_type
= read_type (pp
, objfile
);
1972 /* g++ version 1 overloaded methods. */
1976 new_sublist
-> fn_field
.fcontext
= look_ahead_type
;
1985 look_ahead_type
= NULL
;
1991 /* static member function. */
1992 new_sublist
-> fn_field
.voffset
= VOFFSET_STATIC
;
1993 if (strncmp (new_sublist
-> fn_field
.physname
,
1994 main_fn_name
, strlen (main_fn_name
)))
1996 new_sublist
-> fn_field
.is_stub
= 1;
2002 complain (&member_fn_complaint
, (*pp
)[-1]);
2003 /* Fall through into normal member function. */
2006 /* normal member function. */
2007 new_sublist
-> fn_field
.voffset
= 0;
2008 new_sublist
-> fn_field
.fcontext
= 0;
2012 new_sublist
-> next
= sublist
;
2013 sublist
= new_sublist
;
2015 STABS_CONTINUE (pp
);
2017 while (**pp
!= ';' && **pp
!= '\0');
2021 new_fnlist
-> fn_fieldlist
.fn_fields
= (struct fn_field
*)
2022 obstack_alloc (&objfile
-> type_obstack
,
2023 sizeof (struct fn_field
) * length
);
2024 memset (new_fnlist
-> fn_fieldlist
.fn_fields
, 0,
2025 sizeof (struct fn_field
) * length
);
2026 for (i
= length
; (i
--, sublist
); sublist
= sublist
-> next
)
2028 new_fnlist
-> fn_fieldlist
.fn_fields
[i
] = sublist
-> fn_field
;
2031 new_fnlist
-> fn_fieldlist
.length
= length
;
2032 new_fnlist
-> next
= fip
-> fnlist
;
2033 fip
-> fnlist
= new_fnlist
;
2035 total_length
+= length
;
2036 STABS_CONTINUE (pp
);
2041 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2042 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
2043 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * nfn_fields
);
2044 memset (TYPE_FN_FIELDLISTS (type
), 0,
2045 sizeof (struct fn_fieldlist
) * nfn_fields
);
2046 TYPE_NFN_FIELDS (type
) = nfn_fields
;
2047 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
2053 /* Special GNU C++ name.
2055 Returns 1 for success, 0 for failure. "failure" means that we can't
2056 keep parsing and it's time for error_type(). */
2059 read_cpp_abbrev (fip
, pp
, type
, objfile
)
2060 struct field_info
*fip
;
2063 struct objfile
*objfile
;
2069 struct type
*context
;
2079 /* At this point, *pp points to something like "22:23=*22...",
2080 where the type number before the ':' is the "context" and
2081 everything after is a regular type definition. Lookup the
2082 type, find it's name, and construct the field name. */
2084 context
= read_type (pp
, objfile
);
2088 case 'f': /* $vf -- a virtual function table pointer */
2089 fip
->list
->field
.name
=
2090 obconcat (&objfile
->type_obstack
, vptr_name
, "", "");
2093 case 'b': /* $vb -- a virtual bsomethingorother */
2094 name
= type_name_no_tag (context
);
2097 complain (&invalid_cpp_type_complaint
, symnum
);
2100 fip
->list
->field
.name
=
2101 obconcat (&objfile
->type_obstack
, vb_name
, name
, "");
2105 complain (&invalid_cpp_abbrev_complaint
, *pp
);
2106 fip
->list
->field
.name
=
2107 obconcat (&objfile
->type_obstack
,
2108 "INVALID_CPLUSPLUS_ABBREV", "", "");
2112 /* At this point, *pp points to the ':'. Skip it and read the
2118 complain (&invalid_cpp_abbrev_complaint
, *pp
);
2121 fip
->list
->field
.type
= read_type (pp
, objfile
);
2123 (*pp
)++; /* Skip the comma. */
2129 fip
->list
->field
.bitpos
= read_huge_number (pp
, ';', &nbits
);
2133 /* This field is unpacked. */
2134 fip
->list
->field
.bitsize
= 0;
2135 fip
->list
->visibility
= VISIBILITY_PRIVATE
;
2139 complain (&invalid_cpp_abbrev_complaint
, *pp
);
2140 /* We have no idea what syntax an unrecognized abbrev would have, so
2141 better return 0. If we returned 1, we would need to at least advance
2142 *pp to avoid an infinite loop. */
2149 read_one_struct_field (fip
, pp
, p
, type
, objfile
)
2150 struct field_info
*fip
;
2154 struct objfile
*objfile
;
2156 fip
-> list
-> field
.name
=
2157 obsavestring (*pp
, p
- *pp
, &objfile
-> type_obstack
);
2160 /* This means we have a visibility for a field coming. */
2164 fip
-> list
-> visibility
= *(*pp
)++;
2165 switch (fip
-> list
-> visibility
)
2167 case VISIBILITY_PRIVATE
:
2168 case VISIBILITY_PROTECTED
:
2171 case VISIBILITY_PUBLIC
:
2176 /* Unknown visibility specifier. */
2177 complain (&stabs_general_complaint
,
2178 "unknown visibility specifier");
2185 /* normal dbx-style format, no explicit visibility */
2186 fip
-> list
-> visibility
= VISIBILITY_PUBLIC
;
2189 fip
-> list
-> field
.type
= read_type (pp
, objfile
);
2194 /* Possible future hook for nested types. */
2197 fip
-> list
-> field
.bitpos
= (long)-2; /* nested type */
2203 /* Static class member. */
2204 fip
-> list
-> field
.bitpos
= (long) -1;
2210 fip
-> list
-> field
.bitsize
= (long) savestring (*pp
, p
- *pp
);
2214 else if (**pp
!= ',')
2216 /* Bad structure-type format. */
2217 complain (&stabs_general_complaint
, "bad structure-type format");
2221 (*pp
)++; /* Skip the comma. */
2225 fip
-> list
-> field
.bitpos
= read_huge_number (pp
, ',', &nbits
);
2228 complain (&stabs_general_complaint
, "bad structure-type format");
2231 fip
-> list
-> field
.bitsize
= read_huge_number (pp
, ';', &nbits
);
2234 complain (&stabs_general_complaint
, "bad structure-type format");
2239 /* FIXME-tiemann: Can't the compiler put out something which
2240 lets us distinguish these? (or maybe just not put out anything
2241 for the field). What is the story here? What does the compiler
2242 really do? Also, patch gdb.texinfo for this case; I document
2243 it as a possible problem there. Search for "DBX-style". */
2245 /* This is wrong because this is identical to the symbols
2246 produced for GCC 0-size arrays. For example:
2251 The code which dumped core in such circumstances should be
2252 fixed not to dump core. */
2254 /* g++ -g0 can put out bitpos & bitsize zero for a static
2255 field. This does not give us any way of getting its
2256 class, so we can't know its name. But we can just
2257 ignore the field so we don't dump core and other nasty
2259 if (fip
-> list
-> field
.bitpos
== 0 && fip
-> list
-> field
.bitsize
== 0)
2261 complain (&dbx_class_complaint
);
2262 /* Ignore this field. */
2263 fip
-> list
= fip
-> list
-> next
;
2268 /* Detect an unpacked field and mark it as such.
2269 dbx gives a bit size for all fields.
2270 Note that forward refs cannot be packed,
2271 and treat enums as if they had the width of ints. */
2273 if (TYPE_CODE (fip
-> list
-> field
.type
) != TYPE_CODE_INT
2274 && TYPE_CODE (fip
-> list
-> field
.type
) != TYPE_CODE_ENUM
)
2276 fip
-> list
-> field
.bitsize
= 0;
2278 if ((fip
-> list
-> field
.bitsize
2279 == TARGET_CHAR_BIT
* TYPE_LENGTH (fip
-> list
-> field
.type
)
2280 || (TYPE_CODE (fip
-> list
-> field
.type
) == TYPE_CODE_ENUM
2281 && (fip
-> list
-> field
.bitsize
2286 fip
-> list
-> field
.bitpos
% 8 == 0)
2288 fip
-> list
-> field
.bitsize
= 0;
2294 /* Read struct or class data fields. They have the form:
2296 NAME : [VISIBILITY] TYPENUM , BITPOS , BITSIZE ;
2298 At the end, we see a semicolon instead of a field.
2300 In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
2303 The optional VISIBILITY is one of:
2305 '/0' (VISIBILITY_PRIVATE)
2306 '/1' (VISIBILITY_PROTECTED)
2307 '/2' (VISIBILITY_PUBLIC)
2309 or nothing, for C style fields with public visibility.
2311 Returns 1 for success, 0 for failure. */
2314 read_struct_fields (fip
, pp
, type
, objfile
)
2315 struct field_info
*fip
;
2318 struct objfile
*objfile
;
2321 struct nextfield
*new;
2323 /* We better set p right now, in case there are no fields at all... */
2327 /* Read each data member type until we find the terminating ';' at the end of
2328 the data member list, or break for some other reason such as finding the
2329 start of the member function list. */
2333 STABS_CONTINUE (pp
);
2334 /* Get space to record the next field's data. */
2335 new = (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
2336 make_cleanup (free
, new);
2337 memset (new, 0, sizeof (struct nextfield
));
2338 new -> next
= fip
-> list
;
2341 /* Get the field name. */
2343 /* If is starts with CPLUS_MARKER it is a special abbreviation, unless
2344 the CPLUS_MARKER is followed by an underscore, in which case it is
2345 just the name of an anonymous type, which we should handle like any
2347 if (*p
== CPLUS_MARKER
&& p
[1] != '_')
2349 if (!read_cpp_abbrev (fip
, pp
, type
, objfile
))
2354 /* Look for the ':' that separates the field name from the field
2355 values. Data members are delimited by a single ':', while member
2356 functions are delimited by a pair of ':'s. When we hit the member
2357 functions (if any), terminate scan loop and return. */
2359 while (*p
!= ':' && *p
!= '\0')
2366 /* Check to see if we have hit the member functions yet. */
2371 read_one_struct_field (fip
, pp
, p
, type
, objfile
);
2375 /* chill the list of fields: the last entry (at the head) is a
2376 partially constructed entry which we now scrub. */
2377 fip
-> list
= fip
-> list
-> next
;
2382 /* The stabs for C++ derived classes contain baseclass information which
2383 is marked by a '!' character after the total size. This function is
2384 called when we encounter the baseclass marker, and slurps up all the
2385 baseclass information.
2387 Immediately following the '!' marker is the number of base classes that
2388 the class is derived from, followed by information for each base class.
2389 For each base class, there are two visibility specifiers, a bit offset
2390 to the base class information within the derived class, a reference to
2391 the type for the base class, and a terminating semicolon.
2393 A typical example, with two base classes, would be "!2,020,19;0264,21;".
2395 Baseclass information marker __________________|| | | | | | |
2396 Number of baseclasses __________________________| | | | | | |
2397 Visibility specifiers (2) ________________________| | | | | |
2398 Offset in bits from start of class _________________| | | | |
2399 Type number for base class ___________________________| | | |
2400 Visibility specifiers (2) _______________________________| | |
2401 Offset in bits from start of class ________________________| |
2402 Type number of base class ____________________________________|
2404 Return 1 for success, 0 for (error-type-inducing) failure. */
2407 read_baseclasses (fip
, pp
, type
, objfile
)
2408 struct field_info
*fip
;
2411 struct objfile
*objfile
;
2414 struct nextfield
*new;
2422 /* Skip the '!' baseclass information marker. */
2426 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2429 TYPE_N_BASECLASSES (type
) = read_huge_number (pp
, ',', &nbits
);
2435 /* Some stupid compilers have trouble with the following, so break
2436 it up into simpler expressions. */
2437 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*)
2438 TYPE_ALLOC (type
, B_BYTES (TYPE_N_BASECLASSES (type
)));
2441 int num_bytes
= B_BYTES (TYPE_N_BASECLASSES (type
));
2444 pointer
= (char *) TYPE_ALLOC (type
, num_bytes
);
2445 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*) pointer
;
2449 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), TYPE_N_BASECLASSES (type
));
2451 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
2453 new = (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
2454 make_cleanup (free
, new);
2455 memset (new, 0, sizeof (struct nextfield
));
2456 new -> next
= fip
-> list
;
2458 new -> field
.bitsize
= 0; /* this should be an unpacked field! */
2460 STABS_CONTINUE (pp
);
2464 /* Nothing to do. */
2467 SET_TYPE_FIELD_VIRTUAL (type
, i
);
2470 /* Bad visibility format. */
2474 new -> visibility
= *(*pp
)++;
2475 switch (new -> visibility
)
2477 case VISIBILITY_PRIVATE
:
2478 case VISIBILITY_PROTECTED
:
2479 case VISIBILITY_PUBLIC
:
2482 /* Bad visibility format. */
2489 /* The remaining value is the bit offset of the portion of the object
2490 corresponding to this baseclass. Always zero in the absence of
2491 multiple inheritance. */
2493 new -> field
.bitpos
= read_huge_number (pp
, ',', &nbits
);
2498 /* The last piece of baseclass information is the type of the
2499 base class. Read it, and remember it's type name as this
2502 new -> field
.type
= read_type (pp
, objfile
);
2503 new -> field
.name
= type_name_no_tag (new -> field
.type
);
2505 /* skip trailing ';' and bump count of number of fields seen */
2514 /* The tail end of stabs for C++ classes that contain a virtual function
2515 pointer contains a tilde, a %, and a type number.
2516 The type number refers to the base class (possibly this class itself) which
2517 contains the vtable pointer for the current class.
2519 This function is called when we have parsed all the method declarations,
2520 so we can look for the vptr base class info. */
2523 read_tilde_fields (fip
, pp
, type
, objfile
)
2524 struct field_info
*fip
;
2527 struct objfile
*objfile
;
2531 STABS_CONTINUE (pp
);
2533 /* If we are positioned at a ';', then skip it. */
2543 if (**pp
== '=' || **pp
== '+' || **pp
== '-')
2545 /* Obsolete flags that used to indicate the presence
2546 of constructors and/or destructors. */
2550 /* Read either a '%' or the final ';'. */
2551 if (*(*pp
)++ == '%')
2553 /* The next number is the type number of the base class
2554 (possibly our own class) which supplies the vtable for
2555 this class. Parse it out, and search that class to find
2556 its vtable pointer, and install those into TYPE_VPTR_BASETYPE
2557 and TYPE_VPTR_FIELDNO. */
2562 t
= read_type (pp
, objfile
);
2564 while (*p
!= '\0' && *p
!= ';')
2570 /* Premature end of symbol. */
2574 TYPE_VPTR_BASETYPE (type
) = t
;
2575 if (type
== t
) /* Our own class provides vtbl ptr */
2577 for (i
= TYPE_NFIELDS (t
) - 1;
2578 i
>= TYPE_N_BASECLASSES (t
);
2581 if (! strncmp (TYPE_FIELD_NAME (t
, i
), vptr_name
,
2582 sizeof (vptr_name
) - 1))
2584 TYPE_VPTR_FIELDNO (type
) = i
;
2588 /* Virtual function table field not found. */
2589 complain (&vtbl_notfound_complaint
, TYPE_NAME (type
));
2594 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
2605 attach_fn_fields_to_type (fip
, type
)
2606 struct field_info
*fip
;
2607 register struct type
*type
;
2611 for (n
= 0; n
< TYPE_N_BASECLASSES (type
); n
++)
2613 if (TYPE_CODE (TYPE_BASECLASS (type
, n
)) == TYPE_CODE_UNDEF
)
2615 /* @@ Memory leak on objfile -> type_obstack? */
2618 TYPE_NFN_FIELDS_TOTAL (type
) +=
2619 TYPE_NFN_FIELDS_TOTAL (TYPE_BASECLASS (type
, n
));
2622 for (n
= TYPE_NFN_FIELDS (type
);
2623 fip
-> fnlist
!= NULL
;
2624 fip
-> fnlist
= fip
-> fnlist
-> next
)
2626 --n
; /* Circumvent Sun3 compiler bug */
2627 TYPE_FN_FIELDLISTS (type
)[n
] = fip
-> fnlist
-> fn_fieldlist
;
2632 /* Create the vector of fields, and record how big it is.
2633 We need this info to record proper virtual function table information
2634 for this class's virtual functions. */
2637 attach_fields_to_type (fip
, type
, objfile
)
2638 struct field_info
*fip
;
2639 register struct type
*type
;
2640 struct objfile
*objfile
;
2642 register int nfields
= 0;
2643 register int non_public_fields
= 0;
2644 register struct nextfield
*scan
;
2646 /* Count up the number of fields that we have, as well as taking note of
2647 whether or not there are any non-public fields, which requires us to
2648 allocate and build the private_field_bits and protected_field_bits
2651 for (scan
= fip
-> list
; scan
!= NULL
; scan
= scan
-> next
)
2654 if (scan
-> visibility
!= VISIBILITY_PUBLIC
)
2656 non_public_fields
++;
2660 /* Now we know how many fields there are, and whether or not there are any
2661 non-public fields. Record the field count, allocate space for the
2662 array of fields, and create blank visibility bitfields if necessary. */
2664 TYPE_NFIELDS (type
) = nfields
;
2665 TYPE_FIELDS (type
) = (struct field
*)
2666 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
2667 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
2669 if (non_public_fields
)
2671 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2673 TYPE_FIELD_PRIVATE_BITS (type
) =
2674 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2675 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
2677 TYPE_FIELD_PROTECTED_BITS (type
) =
2678 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2679 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
2682 /* Copy the saved-up fields into the field vector. Start from the head
2683 of the list, adding to the tail of the field array, so that they end
2684 up in the same order in the array in which they were added to the list. */
2686 while (nfields
-- > 0)
2688 TYPE_FIELD (type
, nfields
) = fip
-> list
-> field
;
2689 switch (fip
-> list
-> visibility
)
2691 case VISIBILITY_PRIVATE
:
2692 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
2695 case VISIBILITY_PROTECTED
:
2696 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
2699 case VISIBILITY_PUBLIC
:
2703 /* Should warn about this unknown visibility? */
2706 fip
-> list
= fip
-> list
-> next
;
2711 /* Read the description of a structure (or union type) and return an object
2712 describing the type.
2714 PP points to a character pointer that points to the next unconsumed token
2715 in the the stabs string. For example, given stabs "A:T4=s4a:1,0,32;;",
2716 *PP will point to "4a:1,0,32;;".
2718 TYPE points to an incomplete type that needs to be filled in.
2720 OBJFILE points to the current objfile from which the stabs information is
2721 being read. (Note that it is redundant in that TYPE also contains a pointer
2722 to this same objfile, so it might be a good idea to eliminate it. FIXME).
2725 static struct type
*
2726 read_struct_type (pp
, type
, objfile
)
2729 struct objfile
*objfile
;
2731 struct cleanup
*back_to
;
2732 struct field_info fi
;
2737 back_to
= make_cleanup (null_cleanup
, 0);
2739 INIT_CPLUS_SPECIFIC (type
);
2740 TYPE_FLAGS (type
) &= ~TYPE_FLAG_STUB
;
2742 /* First comes the total size in bytes. */
2746 TYPE_LENGTH (type
) = read_huge_number (pp
, 0, &nbits
);
2748 return error_type (pp
);
2751 /* Now read the baseclasses, if any, read the regular C struct or C++
2752 class member fields, attach the fields to the type, read the C++
2753 member functions, attach them to the type, and then read any tilde
2754 field (baseclass specifier for the class holding the main vtable). */
2756 if (!read_baseclasses (&fi
, pp
, type
, objfile
)
2757 || !read_struct_fields (&fi
, pp
, type
, objfile
)
2758 || !attach_fields_to_type (&fi
, type
, objfile
)
2759 || !read_member_functions (&fi
, pp
, type
, objfile
)
2760 || !attach_fn_fields_to_type (&fi
, type
)
2761 || !read_tilde_fields (&fi
, pp
, type
, objfile
))
2763 do_cleanups (back_to
);
2764 return (error_type (pp
));
2767 do_cleanups (back_to
);
2771 /* Read a definition of an array type,
2772 and create and return a suitable type object.
2773 Also creates a range type which represents the bounds of that
2776 static struct type
*
2777 read_array_type (pp
, type
, objfile
)
2779 register struct type
*type
;
2780 struct objfile
*objfile
;
2782 struct type
*index_type
, *element_type
, *range_type
;
2787 /* Format of an array type:
2788 "ar<index type>;lower;upper;<array_contents_type>". Put code in
2791 Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
2792 for these, produce a type like float[][]. */
2794 index_type
= read_type (pp
, objfile
);
2796 /* Improper format of array type decl. */
2797 return error_type (pp
);
2800 if (!(**pp
>= '0' && **pp
<= '9'))
2805 lower
= read_huge_number (pp
, ';', &nbits
);
2807 return error_type (pp
);
2809 if (!(**pp
>= '0' && **pp
<= '9'))
2814 upper
= read_huge_number (pp
, ';', &nbits
);
2816 return error_type (pp
);
2818 element_type
= read_type (pp
, objfile
);
2827 create_range_type ((struct type
*) NULL
, index_type
, lower
, upper
);
2828 type
= create_array_type (type
, element_type
, range_type
);
2830 /* If we have an array whose element type is not yet known, but whose
2831 bounds *are* known, record it to be adjusted at the end of the file. */
2833 if (TYPE_LENGTH (element_type
) == 0 && !adjustable
)
2835 add_undefined_type (type
);
2842 /* Read a definition of an enumeration type,
2843 and create and return a suitable type object.
2844 Also defines the symbols that represent the values of the type. */
2846 static struct type
*
2847 read_enum_type (pp
, type
, objfile
)
2849 register struct type
*type
;
2850 struct objfile
*objfile
;
2855 register struct symbol
*sym
;
2857 struct pending
**symlist
;
2858 struct pending
*osyms
, *syms
;
2862 /* FIXME! The stabs produced by Sun CC merrily define things that ought
2863 to be file-scope, between N_FN entries, using N_LSYM. What's a mother
2864 to do? For now, force all enum values to file scope. */
2865 if (within_function
)
2866 symlist
= &local_symbols
;
2869 symlist
= &file_symbols
;
2871 o_nsyms
= osyms
? osyms
->nsyms
: 0;
2873 /* Read the value-names and their values.
2874 The input syntax is NAME:VALUE,NAME:VALUE, and so on.
2875 A semicolon or comma instead of a NAME means the end. */
2876 while (**pp
&& **pp
!= ';' && **pp
!= ',')
2879 STABS_CONTINUE (pp
);
2881 while (*p
!= ':') p
++;
2882 name
= obsavestring (*pp
, p
- *pp
, &objfile
-> symbol_obstack
);
2884 n
= read_huge_number (pp
, ',', &nbits
);
2886 return error_type (pp
);
2888 sym
= (struct symbol
*)
2889 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
2890 memset (sym
, 0, sizeof (struct symbol
));
2891 SYMBOL_NAME (sym
) = name
;
2892 SYMBOL_LANGUAGE (sym
) = current_subfile
-> language
;
2893 SYMBOL_CLASS (sym
) = LOC_CONST
;
2894 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2895 SYMBOL_VALUE (sym
) = n
;
2896 add_symbol_to_list (sym
, symlist
);
2901 (*pp
)++; /* Skip the semicolon. */
2903 /* Now fill in the fields of the type-structure. */
2905 TYPE_LENGTH (type
) = sizeof (int);
2906 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
2907 TYPE_FLAGS (type
) &= ~TYPE_FLAG_STUB
;
2908 TYPE_NFIELDS (type
) = nsyms
;
2909 TYPE_FIELDS (type
) = (struct field
*)
2910 TYPE_ALLOC (type
, sizeof (struct field
) * nsyms
);
2911 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nsyms
);
2913 /* Find the symbols for the values and put them into the type.
2914 The symbols can be found in the symlist that we put them on
2915 to cause them to be defined. osyms contains the old value
2916 of that symlist; everything up to there was defined by us. */
2917 /* Note that we preserve the order of the enum constants, so
2918 that in something like "enum {FOO, LAST_THING=FOO}" we print
2919 FOO, not LAST_THING. */
2921 for (syms
= *symlist
, n
= 0; syms
; syms
= syms
->next
)
2926 for (; j
< syms
->nsyms
; j
++,n
++)
2928 struct symbol
*xsym
= syms
->symbol
[j
];
2929 SYMBOL_TYPE (xsym
) = type
;
2930 TYPE_FIELD_NAME (type
, n
) = SYMBOL_NAME (xsym
);
2931 TYPE_FIELD_VALUE (type
, n
) = 0;
2932 TYPE_FIELD_BITPOS (type
, n
) = SYMBOL_VALUE (xsym
);
2933 TYPE_FIELD_BITSIZE (type
, n
) = 0;
2940 /* This screws up perfectly good C programs with enums. FIXME. */
2941 /* Is this Modula-2's BOOLEAN type? Flag it as such if so. */
2942 if(TYPE_NFIELDS(type
) == 2 &&
2943 ((STREQ(TYPE_FIELD_NAME(type
,0),"TRUE") &&
2944 STREQ(TYPE_FIELD_NAME(type
,1),"FALSE")) ||
2945 (STREQ(TYPE_FIELD_NAME(type
,1),"TRUE") &&
2946 STREQ(TYPE_FIELD_NAME(type
,0),"FALSE"))))
2947 TYPE_CODE(type
) = TYPE_CODE_BOOL
;
2953 /* Sun's ACC uses a somewhat saner method for specifying the builtin
2954 typedefs in every file (for int, long, etc):
2956 type = b <signed> <width>; <offset>; <nbits>
2957 signed = u or s. Possible c in addition to u or s (for char?).
2958 offset = offset from high order bit to start bit of type.
2959 width is # bytes in object of this type, nbits is # bits in type.
2961 The width/offset stuff appears to be for small objects stored in
2962 larger ones (e.g. `shorts' in `int' registers). We ignore it for now,
2965 static struct type
*
2966 read_sun_builtin_type (pp
, typenums
, objfile
)
2969 struct objfile
*objfile
;
2984 return error_type (pp
);
2988 /* For some odd reason, all forms of char put a c here. This is strange
2989 because no other type has this honor. We can safely ignore this because
2990 we actually determine 'char'acterness by the number of bits specified in
2996 /* The first number appears to be the number of bytes occupied
2997 by this type, except that unsigned short is 4 instead of 2.
2998 Since this information is redundant with the third number,
2999 we will ignore it. */
3000 read_huge_number (pp
, ';', &nbits
);
3002 return error_type (pp
);
3004 /* The second number is always 0, so ignore it too. */
3005 read_huge_number (pp
, ';', &nbits
);
3007 return error_type (pp
);
3009 /* The third number is the number of bits for this type. */
3010 type_bits
= read_huge_number (pp
, 0, &nbits
);
3012 return error_type (pp
);
3015 /* FIXME. Here we should just be able to make a type of the right
3016 number of bits and signedness. FIXME. */
3018 if (type_bits
== TARGET_LONG_LONG_BIT
)
3019 return (lookup_fundamental_type (objfile
,
3020 signed_type
? FT_LONG_LONG
: FT_UNSIGNED_LONG_LONG
));
3022 if (type_bits
== TARGET_INT_BIT
)
3024 /* FIXME -- the only way to distinguish `int' from `long'
3025 is to look at its name! */
3028 if (long_kludge_name
&& long_kludge_name
[0] == 'l' /* long */)
3029 return lookup_fundamental_type (objfile
, FT_LONG
);
3031 return lookup_fundamental_type (objfile
, FT_INTEGER
);
3035 if (long_kludge_name
3036 && ((long_kludge_name
[0] == 'u' /* unsigned */ &&
3037 long_kludge_name
[9] == 'l' /* long */)
3038 || (long_kludge_name
[0] == 'l' /* long unsigned */)))
3039 return lookup_fundamental_type (objfile
, FT_UNSIGNED_LONG
);
3041 return lookup_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
);
3045 if (type_bits
== TARGET_SHORT_BIT
)
3046 return (lookup_fundamental_type (objfile
,
3047 signed_type
? FT_SHORT
: FT_UNSIGNED_SHORT
));
3049 if (type_bits
== TARGET_CHAR_BIT
)
3050 return (lookup_fundamental_type (objfile
,
3051 signed_type
? FT_CHAR
: FT_UNSIGNED_CHAR
));
3054 return lookup_fundamental_type (objfile
, FT_VOID
);
3056 return error_type (pp
);
3058 return init_type (type_bits
== 0 ? TYPE_CODE_VOID
: TYPE_CODE_INT
,
3059 type_bits
/ TARGET_CHAR_BIT
,
3060 signed_type
? 0 : TYPE_FLAG_UNSIGNED
, (char *)NULL
,
3065 static struct type
*
3066 read_sun_floating_type (pp
, typenums
, objfile
)
3069 struct objfile
*objfile
;
3075 /* The first number has more details about the type, for example
3077 details
= read_huge_number (pp
, ';', &nbits
);
3079 return error_type (pp
);
3081 /* The second number is the number of bytes occupied by this type */
3082 nbytes
= read_huge_number (pp
, ';', &nbits
);
3084 return error_type (pp
);
3086 if (details
== NF_COMPLEX
|| details
== NF_COMPLEX16
3087 || details
== NF_COMPLEX32
)
3088 /* This is a type we can't handle, but we do know the size.
3089 We also will be able to give it a name. */
3090 return init_type (TYPE_CODE_ERROR
, nbytes
, 0, NULL
, objfile
);
3092 return init_type (TYPE_CODE_FLT
, nbytes
, 0, NULL
, objfile
);
3095 /* Read a number from the string pointed to by *PP.
3096 The value of *PP is advanced over the number.
3097 If END is nonzero, the character that ends the
3098 number must match END, or an error happens;
3099 and that character is skipped if it does match.
3100 If END is zero, *PP is left pointing to that character.
3102 If the number fits in a long, set *BITS to 0 and return the value.
3103 If not, set *BITS to be the number of bits in the number and return 0.
3105 If encounter garbage, set *BITS to -1 and return 0. */
3108 read_huge_number (pp
, end
, bits
)
3128 /* Leading zero means octal. GCC uses this to output values larger
3129 than an int (because that would be hard in decimal). */
3136 upper_limit
= LONG_MAX
/ radix
;
3137 while ((c
= *p
++) >= '0' && c
< ('0' + radix
))
3139 if (n
<= upper_limit
)
3142 n
+= c
- '0'; /* FIXME this overflows anyway */
3147 /* This depends on large values being output in octal, which is
3154 /* Ignore leading zeroes. */
3158 else if (c
== '2' || c
== '3')
3184 /* Large decimal constants are an error (because it is hard to
3185 count how many bits are in them). */
3191 /* -0x7f is the same as 0x80. So deal with it by adding one to
3192 the number of bits. */
3204 /* It's *BITS which has the interesting information. */
3208 static struct type
*
3209 read_range_type (pp
, typenums
, objfile
)
3212 struct objfile
*objfile
;
3218 struct type
*result_type
;
3219 struct type
*index_type
;
3221 /* First comes a type we are a subrange of.
3222 In C it is usually 0, 1 or the type being defined. */
3223 /* FIXME: according to stabs.texinfo and AIX doc, this can be a type-id
3224 not just a type number. */
3225 if (read_type_number (pp
, rangenums
) != 0)
3226 return error_type (pp
);
3227 self_subrange
= (rangenums
[0] == typenums
[0] &&
3228 rangenums
[1] == typenums
[1]);
3230 /* A semicolon should now follow; skip it. */
3234 /* The remaining two operands are usually lower and upper bounds
3235 of the range. But in some special cases they mean something else. */
3236 n2
= read_huge_number (pp
, ';', &n2bits
);
3237 n3
= read_huge_number (pp
, ';', &n3bits
);
3239 if (n2bits
== -1 || n3bits
== -1)
3240 return error_type (pp
);
3242 /* If limits are huge, must be large integral type. */
3243 if (n2bits
!= 0 || n3bits
!= 0)
3245 char got_signed
= 0;
3246 char got_unsigned
= 0;
3247 /* Number of bits in the type. */
3250 /* Range from 0 to <large number> is an unsigned large integral type. */
3251 if ((n2bits
== 0 && n2
== 0) && n3bits
!= 0)
3256 /* Range from <large number> to <large number>-1 is a large signed
3258 else if (n2bits
!= 0 && n3bits
!= 0 && n2bits
== n3bits
+ 1)
3264 if (got_signed
|| got_unsigned
)
3266 return init_type (TYPE_CODE_INT
, nbits
/ TARGET_CHAR_BIT
,
3267 got_unsigned
? TYPE_FLAG_UNSIGNED
: 0, NULL
,
3271 return error_type (pp
);
3274 /* A type defined as a subrange of itself, with bounds both 0, is void. */
3275 if (self_subrange
&& n2
== 0 && n3
== 0)
3276 return init_type (TYPE_CODE_VOID
, 0, 0, NULL
, objfile
);
3278 /* If n3 is zero and n2 is not, we want a floating type,
3279 and n2 is the width in bytes.
3281 Fortran programs appear to use this for complex types also,
3282 and they give no way to distinguish between double and single-complex!
3284 GDB does not have complex types.
3286 Just return the complex as a float of that size. It won't work right
3287 for the complex values, but at least it makes the file loadable.
3289 FIXME, we may be able to distinguish these by their names. FIXME. */
3291 if (n3
== 0 && n2
> 0)
3293 return init_type (TYPE_CODE_FLT
, n2
, 0, NULL
, objfile
);
3296 /* If the upper bound is -1, it must really be an unsigned int. */
3298 else if (n2
== 0 && n3
== -1)
3300 /* It is unsigned int or unsigned long. */
3301 /* GCC sometimes uses this for long long too. We could
3302 distinguish it by the name, but we don't. */
3303 return init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
3304 TYPE_FLAG_UNSIGNED
, NULL
, objfile
);
3307 /* Special case: char is defined (Who knows why) as a subrange of
3308 itself with range 0-127. */
3309 else if (self_subrange
&& n2
== 0 && n3
== 127)
3310 return init_type (TYPE_CODE_INT
, 1, 0, NULL
, objfile
);
3312 /* We used to do this only for subrange of self or subrange of int. */
3316 /* n3 actually gives the size. */
3317 return init_type (TYPE_CODE_INT
, - n3
, TYPE_FLAG_UNSIGNED
,
3320 return init_type (TYPE_CODE_INT
, 1, TYPE_FLAG_UNSIGNED
, NULL
, objfile
);
3322 return init_type (TYPE_CODE_INT
, 2, TYPE_FLAG_UNSIGNED
, NULL
, objfile
);
3324 /* -1 is used for the upper bound of (4 byte) "unsigned int" and
3325 "unsigned long", and we already checked for that,
3326 so don't need to test for it here. */
3328 /* I think this is for Convex "long long". Since I don't know whether
3329 Convex sets self_subrange, I also accept that particular size regardless
3330 of self_subrange. */
3331 else if (n3
== 0 && n2
< 0
3333 || n2
== - TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
))
3334 return init_type (TYPE_CODE_INT
, - n2
, 0, NULL
, objfile
);
3335 else if (n2
== -n3
-1)
3338 return init_type (TYPE_CODE_INT
, 1, 0, NULL
, objfile
);
3340 return init_type (TYPE_CODE_INT
, 2, 0, NULL
, objfile
);
3341 if (n3
== 0x7fffffff)
3342 return init_type (TYPE_CODE_INT
, 4, 0, NULL
, objfile
);
3345 /* We have a real range type on our hands. Allocate space and
3346 return a real pointer. */
3348 /* At this point I don't have the faintest idea how to deal with
3349 a self_subrange type; I'm going to assume that this is used
3350 as an idiom, and that all of them are special cases. So . . . */
3352 return error_type (pp
);
3354 index_type
= *dbx_lookup_type (rangenums
);
3355 if (index_type
== NULL
)
3357 /* Does this actually ever happen? Is that why we are worrying
3358 about dealing with it rather than just calling error_type? */
3360 static struct type
*range_type_index
;
3362 complain (&range_type_base_complaint
, rangenums
[1]);
3363 if (range_type_index
== NULL
)
3365 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
3366 0, "range type index type", NULL
);
3367 index_type
= range_type_index
;
3370 result_type
= create_range_type ((struct type
*) NULL
, index_type
, n2
, n3
);
3371 return (result_type
);
3374 /* Read in an argument list. This is a list of types, separated by commas
3375 and terminated with END. Return the list of types read in, or (struct type
3376 **)-1 if there is an error. */
3378 static struct type
**
3379 read_args (pp
, end
, objfile
)
3382 struct objfile
*objfile
;
3384 /* FIXME! Remove this arbitrary limit! */
3385 struct type
*types
[1024], **rval
; /* allow for fns of 1023 parameters */
3391 /* Invalid argument list: no ','. */
3392 return (struct type
**)-1;
3394 STABS_CONTINUE (pp
);
3395 types
[n
++] = read_type (pp
, objfile
);
3397 (*pp
)++; /* get past `end' (the ':' character) */
3401 rval
= (struct type
**) xmalloc (2 * sizeof (struct type
*));
3403 else if (TYPE_CODE (types
[n
-1]) != TYPE_CODE_VOID
)
3405 rval
= (struct type
**) xmalloc ((n
+ 1) * sizeof (struct type
*));
3406 memset (rval
+ n
, 0, sizeof (struct type
*));
3410 rval
= (struct type
**) xmalloc (n
* sizeof (struct type
*));
3412 memcpy (rval
, types
, n
* sizeof (struct type
*));
3416 /* Add a common block's start address to the offset of each symbol
3417 declared to be in it (by being between a BCOMM/ECOMM pair that uses
3418 the common block name). */
3421 fix_common_block (sym
, valu
)
3425 struct pending
*next
= (struct pending
*) SYMBOL_NAMESPACE (sym
);
3426 for ( ; next
; next
= next
->next
)
3429 for (j
= next
->nsyms
- 1; j
>= 0; j
--)
3430 SYMBOL_VALUE_ADDRESS (next
->symbol
[j
]) += valu
;
3436 /* What about types defined as forward references inside of a small lexical
3438 /* Add a type to the list of undefined types to be checked through
3439 once this file has been read in. */
3442 add_undefined_type (type
)
3445 if (undef_types_length
== undef_types_allocated
)
3447 undef_types_allocated
*= 2;
3448 undef_types
= (struct type
**)
3449 xrealloc ((char *) undef_types
,
3450 undef_types_allocated
* sizeof (struct type
*));
3452 undef_types
[undef_types_length
++] = type
;
3455 /* Go through each undefined type, see if it's still undefined, and fix it
3456 up if possible. We have two kinds of undefined types:
3458 TYPE_CODE_ARRAY: Array whose target type wasn't defined yet.
3459 Fix: update array length using the element bounds
3460 and the target type's length.
3461 TYPE_CODE_STRUCT, TYPE_CODE_UNION: Structure whose fields were not
3462 yet defined at the time a pointer to it was made.
3463 Fix: Do a full lookup on the struct/union tag. */
3465 cleanup_undefined_types ()
3469 for (type
= undef_types
; type
< undef_types
+ undef_types_length
; type
++)
3471 switch (TYPE_CODE (*type
))
3474 case TYPE_CODE_STRUCT
:
3475 case TYPE_CODE_UNION
:
3476 case TYPE_CODE_ENUM
:
3478 /* Check if it has been defined since. */
3479 if (TYPE_FLAGS (*type
) & TYPE_FLAG_STUB
)
3481 struct pending
*ppt
;
3483 /* Name of the type, without "struct" or "union" */
3484 char *typename
= type_name_no_tag (*type
);
3486 if (typename
== NULL
)
3488 static struct complaint msg
= {"need a type name", 0, 0};
3492 for (ppt
= file_symbols
; ppt
; ppt
= ppt
->next
)
3494 for (i
= 0; i
< ppt
->nsyms
; i
++)
3496 struct symbol
*sym
= ppt
->symbol
[i
];
3498 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
3499 && SYMBOL_NAMESPACE (sym
) == STRUCT_NAMESPACE
3500 && (TYPE_CODE (SYMBOL_TYPE (sym
)) ==
3502 && STREQ (SYMBOL_NAME (sym
), typename
))
3504 memcpy (*type
, SYMBOL_TYPE (sym
),
3505 sizeof (struct type
));
3513 case TYPE_CODE_ARRAY
:
3515 struct type
*range_type
;
3518 if (TYPE_LENGTH (*type
) != 0) /* Better be unknown */
3520 if (TYPE_NFIELDS (*type
) != 1)
3522 range_type
= TYPE_FIELD_TYPE (*type
, 0);
3523 if (TYPE_CODE (range_type
) != TYPE_CODE_RANGE
)
3526 /* Now recompute the length of the array type, based on its
3527 number of elements and the target type's length. */
3528 lower
= TYPE_FIELD_BITPOS (range_type
, 0);
3529 upper
= TYPE_FIELD_BITPOS (range_type
, 1);
3530 TYPE_LENGTH (*type
) = (upper
- lower
+ 1)
3531 * TYPE_LENGTH (TYPE_TARGET_TYPE (*type
));
3538 static struct complaint msg
= {"\
3539 GDB internal error. cleanup_undefined_types with bad type %d.", 0, 0};
3540 complain (&msg
, TYPE_CODE (*type
));
3545 undef_types_length
= 0;
3548 /* Scan through all of the global symbols defined in the object file,
3549 assigning values to the debugging symbols that need to be assigned
3550 to. Get these symbols from the minimal symbol table. */
3553 scan_file_globals (objfile
)
3554 struct objfile
*objfile
;
3557 struct minimal_symbol
*msymbol
;
3558 struct symbol
*sym
, *prev
;
3560 if (objfile
->msymbols
== 0) /* Beware the null file. */
3563 for (msymbol
= objfile
-> msymbols
; SYMBOL_NAME (msymbol
) != NULL
; msymbol
++)
3569 /* Get the hash index and check all the symbols
3570 under that hash index. */
3572 hash
= hashname (SYMBOL_NAME (msymbol
));
3574 for (sym
= global_sym_chain
[hash
]; sym
;)
3576 if (SYMBOL_NAME (msymbol
)[0] == SYMBOL_NAME (sym
)[0] &&
3577 STREQ(SYMBOL_NAME (msymbol
) + 1, SYMBOL_NAME (sym
) + 1))
3579 /* Splice this symbol out of the hash chain and
3580 assign the value we have to it. */
3583 SYMBOL_VALUE_CHAIN (prev
) = SYMBOL_VALUE_CHAIN (sym
);
3587 global_sym_chain
[hash
] = SYMBOL_VALUE_CHAIN (sym
);
3590 /* Check to see whether we need to fix up a common block. */
3591 /* Note: this code might be executed several times for
3592 the same symbol if there are multiple references. */
3594 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
3596 fix_common_block (sym
, SYMBOL_VALUE_ADDRESS (msymbol
));
3600 SYMBOL_VALUE_ADDRESS (sym
) = SYMBOL_VALUE_ADDRESS (msymbol
);
3605 sym
= SYMBOL_VALUE_CHAIN (prev
);
3609 sym
= global_sym_chain
[hash
];
3615 sym
= SYMBOL_VALUE_CHAIN (sym
);
3621 /* Initialize anything that needs initializing when starting to read
3622 a fresh piece of a symbol file, e.g. reading in the stuff corresponding
3630 /* Initialize anything that needs initializing when a completely new
3631 symbol file is specified (not just adding some symbols from another
3632 file, e.g. a shared library). */
3635 stabsread_new_init ()
3637 /* Empty the hash table of global syms looking for values. */
3638 memset (global_sym_chain
, 0, sizeof (global_sym_chain
));
3641 /* Initialize anything that needs initializing at the same time as
3642 start_symtab() is called. */
3646 global_stabs
= NULL
; /* AIX COFF */
3647 /* Leave FILENUM of 0 free for builtin types and this file's types. */
3648 n_this_object_header_files
= 1;
3649 type_vector_length
= 0;
3650 type_vector
= (struct type
**) 0;
3653 /* Call after end_symtab() */
3659 free ((char *) type_vector
);
3662 type_vector_length
= 0;
3663 previous_stab_code
= 0;
3667 finish_global_stabs (objfile
)
3668 struct objfile
*objfile
;
3672 patch_block_stabs (global_symbols
, global_stabs
, objfile
);
3673 free ((PTR
) global_stabs
);
3674 global_stabs
= NULL
;
3678 /* Initializer for this module */
3681 _initialize_stabsread ()
3683 undef_types_allocated
= 20;
3684 undef_types_length
= 0;
3685 undef_types
= (struct type
**)
3686 xmalloc (undef_types_allocated
* sizeof (struct type
*));