1 /* Support routines for decoding "stabs" debugging information format.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
21 /* Support routines for reading and decoding debugging information in
22 the "stabs" format. This format is used with many systems that use
23 the a.out object file format, as well as some systems that use
24 COFF or ELF where the stabs data is placed in a special section.
25 Avoid placing any object file format specific code in this file. */
34 #include "aout/stab_gnu.h" /* We always use GNU stabs, not native */
36 #include "complaints.h"
41 /* Ask stabsread.h to define the vars it normally declares `extern'. */
43 #include "stabsread.h" /* Our own declarations */
46 /* The routines that read and process a complete stabs for a C struct or
47 C++ class pass lists of data member fields and lists of member function
48 fields in an instance of a field_info structure, as defined below.
49 This is part of some reorganization of low level C++ support and is
50 expected to eventually go away... (FIXME) */
56 struct nextfield
*next
;
60 struct next_fnfieldlist
62 struct next_fnfieldlist
*next
;
63 struct fn_fieldlist fn_fieldlist
;
68 dbx_alloc_type
PARAMS ((int [2], struct objfile
*));
70 static long read_huge_number
PARAMS ((char **, int, int *));
72 static struct type
*error_type
PARAMS ((char **));
75 patch_block_stabs
PARAMS ((struct pending
*, struct pending_stabs
*,
79 fix_common_block
PARAMS ((struct symbol
*, int));
82 read_type_number
PARAMS ((char **, int *));
85 read_range_type
PARAMS ((char **, int [2], struct objfile
*));
88 read_sun_builtin_type
PARAMS ((char **, int [2], struct objfile
*));
91 read_sun_floating_type
PARAMS ((char **, int [2], struct objfile
*));
94 read_enum_type
PARAMS ((char **, struct type
*, struct objfile
*));
97 rs6000_builtin_type
PARAMS ((int));
100 read_member_functions
PARAMS ((struct field_info
*, char **, struct type
*,
104 read_struct_fields
PARAMS ((struct field_info
*, char **, struct type
*,
108 read_baseclasses
PARAMS ((struct field_info
*, char **, struct type
*,
112 read_tilde_fields
PARAMS ((struct field_info
*, char **, struct type
*,
116 attach_fn_fields_to_type
PARAMS ((struct field_info
*, struct type
*));
119 attach_fields_to_type
PARAMS ((struct field_info
*, struct type
*,
123 read_struct_type
PARAMS ((char **, struct type
*, struct objfile
*));
126 read_array_type
PARAMS ((char **, struct type
*, struct objfile
*));
128 static struct type
**
129 read_args
PARAMS ((char **, int, struct objfile
*));
132 read_cpp_abbrev
PARAMS ((struct field_info
*, char **, struct type
*,
135 static const char vptr_name
[] = { '_','v','p','t','r',CPLUS_MARKER
,'\0' };
136 static const char vb_name
[] = { '_','v','b',CPLUS_MARKER
,'\0' };
138 /* Define this as 1 if a pcc declaration of a char or short argument
139 gives the correct address. Otherwise assume pcc gives the
140 address of the corresponding int, which is not the same on a
141 big-endian machine. */
143 #ifndef BELIEVE_PCC_PROMOTION
144 #define BELIEVE_PCC_PROMOTION 0
148 struct complaint dbx_class_complaint
=
150 "encountered DBX-style class variable debugging information.\n\
151 You seem to have compiled your program with \
152 \"g++ -g0\" instead of \"g++ -g\".\n\
153 Therefore GDB will not know about your class variables", 0, 0
157 struct complaint invalid_cpp_abbrev_complaint
=
158 {"invalid C++ abbreviation `%s'", 0, 0};
160 struct complaint invalid_cpp_type_complaint
=
161 {"C++ abbreviated type name unknown at symtab pos %d", 0, 0};
163 struct complaint member_fn_complaint
=
164 {"member function type missing, got '%c'", 0, 0};
166 struct complaint const_vol_complaint
=
167 {"const/volatile indicator missing, got '%c'", 0, 0};
169 struct complaint error_type_complaint
=
170 {"debug info mismatch between compiler and debugger", 0, 0};
172 struct complaint invalid_member_complaint
=
173 {"invalid (minimal) member type data format at symtab pos %d.", 0, 0};
175 struct complaint range_type_base_complaint
=
176 {"base type %d of range type is not defined", 0, 0};
178 struct complaint reg_value_complaint
=
179 {"register number too large in symbol %s", 0, 0};
181 struct complaint vtbl_notfound_complaint
=
182 {"virtual function table pointer not found when defining class `%s'", 0, 0};
184 struct complaint unrecognized_cplus_name_complaint
=
185 {"Unknown C++ symbol name `%s'", 0, 0};
187 struct complaint rs6000_builtin_complaint
=
188 {"Unknown builtin type %d", 0, 0};
190 struct complaint stabs_general_complaint
=
193 /* Make a list of forward references which haven't been defined. */
195 static struct type
**undef_types
;
196 static int undef_types_allocated
;
197 static int undef_types_length
;
199 /* Check for and handle cretinous stabs symbol name continuation! */
200 #define STABS_CONTINUE(pp) \
202 if (**(pp) == '\\') *(pp) = next_symbol_text (); \
206 /* Look up a dbx type-number pair. Return the address of the slot
207 where the type for that number-pair is stored.
208 The number-pair is in TYPENUMS.
210 This can be used for finding the type associated with that pair
211 or for associating a new type with the pair. */
214 dbx_lookup_type (typenums
)
217 register int filenum
= typenums
[0];
218 register int index
= typenums
[1];
220 register int real_filenum
;
221 register struct header_file
*f
;
224 if (filenum
== -1) /* -1,-1 is for temporary types. */
227 if (filenum
< 0 || filenum
>= n_this_object_header_files
)
229 static struct complaint msg
= {"\
230 Invalid symbol data: type number (%d,%d) out of range at symtab pos %d.",
232 complain (&msg
, filenum
, index
, symnum
);
240 /* Caller wants address of address of type. We think
241 that negative (rs6k builtin) types will never appear as
242 "lvalues", (nor should they), so we stuff the real type
243 pointer into a temp, and return its address. If referenced,
244 this will do the right thing. */
245 static struct type
*temp_type
;
247 temp_type
= rs6000_builtin_type(index
);
251 /* Type is defined outside of header files.
252 Find it in this object file's type vector. */
253 if (index
>= type_vector_length
)
255 old_len
= type_vector_length
;
258 type_vector_length
= INITIAL_TYPE_VECTOR_LENGTH
;
259 type_vector
= (struct type
**)
260 malloc (type_vector_length
* sizeof (struct type
*));
262 while (index
>= type_vector_length
)
264 type_vector_length
*= 2;
266 type_vector
= (struct type
**)
267 xrealloc ((char *) type_vector
,
268 (type_vector_length
* sizeof (struct type
*)));
269 memset (&type_vector
[old_len
], 0,
270 (type_vector_length
- old_len
) * sizeof (struct type
*));
272 return (&type_vector
[index
]);
276 real_filenum
= this_object_header_files
[filenum
];
278 if (real_filenum
>= n_header_files
)
280 struct type
*temp_type
;
281 struct type
**temp_type_p
;
283 warning ("GDB internal error: bad real_filenum");
286 temp_type
= init_type (TYPE_CODE_ERROR
, 0, 0, NULL
, NULL
);
287 temp_type_p
= (struct type
**) xmalloc (sizeof (struct type
*));
288 *temp_type_p
= temp_type
;
292 f
= &header_files
[real_filenum
];
294 f_orig_length
= f
->length
;
295 if (index
>= f_orig_length
)
297 while (index
>= f
->length
)
301 f
->vector
= (struct type
**)
302 xrealloc ((char *) f
->vector
, f
->length
* sizeof (struct type
*));
303 memset (&f
->vector
[f_orig_length
], 0,
304 (f
->length
- f_orig_length
) * sizeof (struct type
*));
306 return (&f
->vector
[index
]);
310 /* Make sure there is a type allocated for type numbers TYPENUMS
311 and return the type object.
312 This can create an empty (zeroed) type object.
313 TYPENUMS may be (-1, -1) to return a new type object that is not
314 put into the type vector, and so may not be referred to by number. */
317 dbx_alloc_type (typenums
, objfile
)
319 struct objfile
*objfile
;
321 register struct type
**type_addr
;
323 if (typenums
[0] == -1)
325 return (alloc_type (objfile
));
328 type_addr
= dbx_lookup_type (typenums
);
330 /* If we are referring to a type not known at all yet,
331 allocate an empty type for it.
332 We will fill it in later if we find out how. */
335 *type_addr
= alloc_type (objfile
);
341 /* for all the stabs in a given stab vector, build appropriate types
342 and fix their symbols in given symbol vector. */
345 patch_block_stabs (symbols
, stabs
, objfile
)
346 struct pending
*symbols
;
347 struct pending_stabs
*stabs
;
348 struct objfile
*objfile
;
358 /* for all the stab entries, find their corresponding symbols and
359 patch their types! */
361 for (ii
= 0; ii
< stabs
->count
; ++ii
)
363 name
= stabs
->stab
[ii
];
364 pp
= (char*) strchr (name
, ':');
365 sym
= find_symbol_in_list (symbols
, name
, pp
-name
);
368 /* On xcoff, if a global is defined and never referenced,
369 ld will remove it from the executable. There is then
370 a N_GSYM stab for it, but no regular (C_EXT) symbol. */
371 sym
= (struct symbol
*)
372 obstack_alloc (&objfile
->symbol_obstack
,
373 sizeof (struct symbol
));
375 memset (sym
, 0, sizeof (struct symbol
));
376 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
377 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
379 obstack_copy0 (&objfile
->symbol_obstack
, name
, pp
- name
);
381 if (*(pp
-1) == 'F' || *(pp
-1) == 'f')
383 /* I don't think the linker does this with functions,
384 so as far as I know this is never executed.
385 But it doesn't hurt to check. */
387 lookup_function_type (read_type (&pp
, objfile
));
391 SYMBOL_TYPE (sym
) = read_type (&pp
, objfile
);
393 add_symbol_to_list (sym
, &global_symbols
);
398 if (*(pp
-1) == 'F' || *(pp
-1) == 'f')
401 lookup_function_type (read_type (&pp
, objfile
));
405 SYMBOL_TYPE (sym
) = read_type (&pp
, objfile
);
413 /* Read a number by which a type is referred to in dbx data,
414 or perhaps read a pair (FILENUM, TYPENUM) in parentheses.
415 Just a single number N is equivalent to (0,N).
416 Return the two numbers by storing them in the vector TYPENUMS.
417 TYPENUMS will then be used as an argument to dbx_lookup_type.
419 Returns 0 for success, -1 for error. */
422 read_type_number (pp
, typenums
)
424 register int *typenums
;
430 typenums
[0] = read_huge_number (pp
, ',', &nbits
);
431 if (nbits
!= 0) return -1;
432 typenums
[1] = read_huge_number (pp
, ')', &nbits
);
433 if (nbits
!= 0) return -1;
438 typenums
[1] = read_huge_number (pp
, 0, &nbits
);
439 if (nbits
!= 0) return -1;
445 /* To handle GNU C++ typename abbreviation, we need to be able to
446 fill in a type's name as soon as space for that type is allocated.
447 `type_synonym_name' is the name of the type being allocated.
448 It is cleared as soon as it is used (lest all allocated types
451 static char *type_synonym_name
;
455 define_symbol (valu
, string
, desc
, type
, objfile
)
460 struct objfile
*objfile
;
462 register struct symbol
*sym
;
463 char *p
= (char *) strchr (string
, ':');
468 /* We would like to eliminate nameless symbols, but keep their types.
469 E.g. stab entry ":t10=*2" should produce a type 10, which is a pointer
470 to type 2, but, should not create a symbol to address that type. Since
471 the symbol will be nameless, there is no way any user can refer to it. */
475 /* Ignore syms with empty names. */
479 /* Ignore old-style symbols from cc -go */
483 /* If a nameless stab entry, all we need is the type, not the symbol.
484 e.g. ":t10=*2" or a nameless enum like " :T16=ered:0,green:1,blue:2,;" */
485 nameless
= (p
== string
|| ((string
[0] == ' ') && (string
[1] == ':')));
487 sym
= (struct symbol
*)
488 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
489 memset (sym
, 0, sizeof (struct symbol
));
491 if (processing_gcc_compilation
)
493 /* GCC 2.x puts the line number in desc. SunOS apparently puts in the
494 number of bytes occupied by a type or object, which we ignore. */
495 SYMBOL_LINE(sym
) = desc
;
499 SYMBOL_LINE(sym
) = 0; /* unknown */
502 if (string
[0] == CPLUS_MARKER
)
504 /* Special GNU C++ names. */
508 SYMBOL_NAME (sym
) = obsavestring ("this", strlen ("this"),
509 &objfile
-> symbol_obstack
);
512 case 'v': /* $vtbl_ptr_type */
513 /* Was: SYMBOL_NAME (sym) = "vptr"; */
517 SYMBOL_NAME (sym
) = obsavestring ("eh_throw", strlen ("eh_throw"),
518 &objfile
-> symbol_obstack
);
522 /* This was an anonymous type that was never fixed up. */
526 complain (&unrecognized_cplus_name_complaint
, string
);
527 goto normal
; /* Do *something* with it */
533 SYMBOL_LANGUAGE (sym
) = current_subfile
-> language
;
534 SYMBOL_NAME (sym
) = (char *)
535 obstack_alloc (&objfile
-> symbol_obstack
, ((p
- string
) + 1));
536 /* Open-coded memcpy--saves function call time. */
537 /* FIXME: Does it really? Try replacing with simple strcpy and
538 try it on an executable with a large symbol table. */
539 /* FIXME: considering that gcc can open code memcpy anyway, I
540 doubt it. xoxorich. */
542 register char *p1
= string
;
543 register char *p2
= SYMBOL_NAME (sym
);
551 /* If this symbol is from a C++ compilation, then attempt to cache the
552 demangled form for future reference. This is a typical time versus
553 space tradeoff, that was decided in favor of time because it sped up
554 C++ symbol lookups by a factor of about 20. */
556 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
->symbol_obstack
);
560 /* Determine the type of name being defined. */
562 /* Getting GDB to correctly skip the symbol on an undefined symbol
563 descriptor and not ever dump core is a very dodgy proposition if
564 we do things this way. I say the acorn RISC machine can just
565 fix their compiler. */
566 /* The Acorn RISC machine's compiler can put out locals that don't
567 start with "234=" or "(3,4)=", so assume anything other than the
568 deftypes we know how to handle is a local. */
569 if (!strchr ("cfFGpPrStTvVXCR", *p
))
571 if (isdigit (*p
) || *p
== '(' || *p
== '-')
580 /* c is a special case, not followed by a type-number.
581 SYMBOL:c=iVALUE for an integer constant symbol.
582 SYMBOL:c=rVALUE for a floating constant symbol.
583 SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
584 e.g. "b:c=e6,0" for "const b = blob1"
585 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
588 SYMBOL_CLASS (sym
) = LOC_CONST
;
589 SYMBOL_TYPE (sym
) = error_type (&p
);
590 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
591 add_symbol_to_list (sym
, &file_symbols
);
602 /* FIXME-if-picky-about-floating-accuracy: Should be using
603 target arithmetic to get the value. real.c in GCC
604 probably has the necessary code. */
606 /* FIXME: lookup_fundamental_type is a hack. We should be
607 creating a type especially for the type of float constants.
608 Problem is, what type should it be?
610 Also, what should the name of this type be? Should we
611 be using 'S' constants (see stabs.texinfo) instead? */
613 SYMBOL_TYPE (sym
) = lookup_fundamental_type (objfile
,
616 obstack_alloc (&objfile
-> symbol_obstack
,
617 TYPE_LENGTH (SYMBOL_TYPE (sym
)));
618 store_floating (dbl_valu
, TYPE_LENGTH (SYMBOL_TYPE (sym
)), d
);
619 SYMBOL_VALUE_BYTES (sym
) = dbl_valu
;
620 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
625 /* Defining integer constants this way is kind of silly,
626 since 'e' constants allows the compiler to give not
627 only the value, but the type as well. C has at least
628 int, long, unsigned int, and long long as constant
629 types; other languages probably should have at least
630 unsigned as well as signed constants. */
632 /* We just need one int constant type for all objfiles.
633 It doesn't depend on languages or anything (arguably its
634 name should be a language-specific name for a type of
635 that size, but I'm inclined to say that if the compiler
636 wants a nice name for the type, it can use 'e'). */
637 static struct type
*int_const_type
;
639 /* Yes, this is as long as a *host* int. That is because we
641 if (int_const_type
== NULL
)
643 init_type (TYPE_CODE_INT
,
644 sizeof (int) * HOST_CHAR_BIT
/ TARGET_CHAR_BIT
, 0,
646 (struct objfile
*)NULL
);
647 SYMBOL_TYPE (sym
) = int_const_type
;
648 SYMBOL_VALUE (sym
) = atoi (p
);
649 SYMBOL_CLASS (sym
) = LOC_CONST
;
653 /* SYMBOL:c=eTYPE,INTVALUE for a constant symbol whose value
654 can be represented as integral.
655 e.g. "b:c=e6,0" for "const b = blob1"
656 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
658 SYMBOL_CLASS (sym
) = LOC_CONST
;
659 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
663 SYMBOL_TYPE (sym
) = error_type (&p
);
668 /* If the value is too big to fit in an int (perhaps because
669 it is unsigned), or something like that, we silently get
670 a bogus value. The type and everything else about it is
671 correct. Ideally, we should be using whatever we have
672 available for parsing unsigned and long long values,
674 SYMBOL_VALUE (sym
) = atoi (p
);
679 SYMBOL_CLASS (sym
) = LOC_CONST
;
680 SYMBOL_TYPE (sym
) = error_type (&p
);
683 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
684 add_symbol_to_list (sym
, &file_symbols
);
688 /* The name of a caught exception. */
689 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
690 SYMBOL_CLASS (sym
) = LOC_LABEL
;
691 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
692 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
693 add_symbol_to_list (sym
, &local_symbols
);
697 /* A static function definition. */
698 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
699 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
700 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
701 add_symbol_to_list (sym
, &file_symbols
);
702 /* fall into process_function_types. */
704 process_function_types
:
705 /* Function result types are described as the result type in stabs.
706 We need to convert this to the function-returning-type-X type
707 in GDB. E.g. "int" is converted to "function returning int". */
708 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_FUNC
)
711 /* This code doesn't work -- it needs to realloc and can't. */
712 /* Attempt to set up to record a function prototype... */
713 struct type
*new = alloc_type (objfile
);
715 /* Generate a template for the type of this function. The
716 types of the arguments will be added as we read the symbol
718 *new = *lookup_function_type (SYMBOL_TYPE(sym
));
719 SYMBOL_TYPE(sym
) = new;
720 TYPE_OBJFILE (new) = objfile
;
721 in_function_type
= new;
723 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
726 /* fall into process_prototype_types */
728 process_prototype_types
:
729 /* Sun acc puts declared types of arguments here. We don't care
730 about their actual types (FIXME -- we should remember the whole
731 function prototype), but the list may define some new types
732 that we have to remember, so we must scan it now. */
735 read_type (&p
, objfile
);
740 /* A global function definition. */
741 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
742 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
743 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
744 add_symbol_to_list (sym
, &global_symbols
);
745 goto process_function_types
;
748 /* For a class G (global) symbol, it appears that the
749 value is not correct. It is necessary to search for the
750 corresponding linker definition to find the value.
751 These definitions appear at the end of the namelist. */
752 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
753 i
= hashname (SYMBOL_NAME (sym
));
754 SYMBOL_VALUE_CHAIN (sym
) = global_sym_chain
[i
];
755 global_sym_chain
[i
] = sym
;
756 SYMBOL_CLASS (sym
) = LOC_STATIC
;
757 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
758 add_symbol_to_list (sym
, &global_symbols
);
761 /* This case is faked by a conditional above,
762 when there is no code letter in the dbx data.
763 Dbx data never actually contains 'l'. */
765 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
766 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
767 SYMBOL_VALUE (sym
) = valu
;
768 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
769 add_symbol_to_list (sym
, &local_symbols
);
774 /* pF is a two-letter code that means a function parameter in Fortran.
775 The type-number specifies the type of the return value.
776 Translate it into a pointer-to-function type. */
780 = lookup_pointer_type
781 (lookup_function_type (read_type (&p
, objfile
)));
784 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
786 /* Normally this is a parameter, a LOC_ARG. On the i960, it
787 can also be a LOC_LOCAL_ARG depending on symbol type. */
788 #ifndef DBX_PARM_SYMBOL_CLASS
789 #define DBX_PARM_SYMBOL_CLASS(type) LOC_ARG
792 SYMBOL_CLASS (sym
) = DBX_PARM_SYMBOL_CLASS (type
);
793 SYMBOL_VALUE (sym
) = valu
;
794 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
796 /* This doesn't work yet. */
797 add_param_to_type (&in_function_type
, sym
);
799 add_symbol_to_list (sym
, &local_symbols
);
801 #if TARGET_BYTE_ORDER == LITTLE_ENDIAN
802 /* On little-endian machines, this crud is never necessary, and,
803 if the extra bytes contain garbage, is harmful. */
805 #else /* Big endian. */
806 /* If it's gcc-compiled, if it says `short', believe it. */
807 if (processing_gcc_compilation
|| BELIEVE_PCC_PROMOTION
)
810 #if !BELIEVE_PCC_PROMOTION
812 /* This is the signed type which arguments get promoted to. */
813 static struct type
*pcc_promotion_type
;
814 /* This is the unsigned type which arguments get promoted to. */
815 static struct type
*pcc_unsigned_promotion_type
;
817 /* Call it "int" because this is mainly C lossage. */
818 if (pcc_promotion_type
== NULL
)
820 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
823 if (pcc_unsigned_promotion_type
== NULL
)
824 pcc_unsigned_promotion_type
=
825 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
826 TYPE_FLAG_UNSIGNED
, "unsigned int", NULL
);
828 #if defined(BELIEVE_PCC_PROMOTION_TYPE)
829 /* This macro is defined on machines (e.g. sparc) where
830 we should believe the type of a PCC 'short' argument,
831 but shouldn't believe the address (the address is
832 the address of the corresponding int).
834 My guess is that this correction, as opposed to changing
835 the parameter to an 'int' (as done below, for PCC
836 on most machines), is the right thing to do
837 on all machines, but I don't want to risk breaking
838 something that already works. On most PCC machines,
839 the sparc problem doesn't come up because the calling
840 function has to zero the top bytes (not knowing whether
841 the called function wants an int or a short), so there
842 is little practical difference between an int and a short
843 (except perhaps what happens when the GDB user types
844 "print short_arg = 0x10000;").
846 Hacked for SunOS 4.1 by gnu@cygnus.com. In 4.1, the compiler
847 actually produces the correct address (we don't need to fix it
848 up). I made this code adapt so that it will offset the symbol
849 if it was pointing at an int-aligned location and not
850 otherwise. This way you can use the same gdb for 4.0.x and
853 If the parameter is shorter than an int, and is integral
854 (e.g. char, short, or unsigned equivalent), and is claimed to
855 be passed on an integer boundary, don't believe it! Offset the
856 parameter's address to the tail-end of that integer. */
858 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (pcc_promotion_type
)
859 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
860 && 0 == SYMBOL_VALUE (sym
) % TYPE_LENGTH (pcc_promotion_type
))
862 SYMBOL_VALUE (sym
) += TYPE_LENGTH (pcc_promotion_type
)
863 - TYPE_LENGTH (SYMBOL_TYPE (sym
));
867 #else /* no BELIEVE_PCC_PROMOTION_TYPE. */
869 /* If PCC says a parameter is a short or a char,
870 it is really an int. */
871 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (pcc_promotion_type
)
872 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
)
875 TYPE_UNSIGNED (SYMBOL_TYPE (sym
))
876 ? pcc_unsigned_promotion_type
877 : pcc_promotion_type
;
881 #endif /* no BELIEVE_PCC_PROMOTION_TYPE. */
883 #endif /* !BELIEVE_PCC_PROMOTION. */
884 #endif /* Big endian. */
887 /* acc seems to use P to delare the prototypes of functions that
888 are referenced by this file. gdb is not prepared to deal
889 with this extra information. FIXME, it ought to. */
892 read_type (&p
, objfile
);
893 goto process_prototype_types
;
898 /* Parameter which is in a register. */
899 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
900 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
901 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (valu
);
902 if (SYMBOL_VALUE (sym
) >= NUM_REGS
)
904 complain (®_value_complaint
, SYMBOL_SOURCE_NAME (sym
));
905 SYMBOL_VALUE (sym
) = SP_REGNUM
; /* Known safe, though useless */
907 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
908 add_symbol_to_list (sym
, &local_symbols
);
912 /* Register variable (either global or local). */
913 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
914 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
915 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (valu
);
916 if (SYMBOL_VALUE (sym
) >= NUM_REGS
)
918 complain (®_value_complaint
, SYMBOL_SOURCE_NAME (sym
));
919 SYMBOL_VALUE (sym
) = SP_REGNUM
; /* Known safe, though useless */
921 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
924 /* Sun cc uses a pair of symbols, one 'p' and one 'r' with the same
925 name to represent an argument passed in a register.
926 GCC uses 'P' for the same case. So if we find such a symbol pair
927 we combine it into one 'P' symbol.
928 Note that this code illegally combines
929 main(argc) int argc; { register int argc = 1; }
930 but this case is considered pathological and causes a warning
931 from a decent compiler. */
933 && local_symbols
->nsyms
> 0)
935 struct symbol
*prev_sym
;
936 prev_sym
= local_symbols
->symbol
[local_symbols
->nsyms
- 1];
937 if (SYMBOL_CLASS (prev_sym
) == LOC_ARG
938 && STREQ (SYMBOL_NAME (prev_sym
), SYMBOL_NAME(sym
)))
940 SYMBOL_CLASS (prev_sym
) = LOC_REGPARM
;
941 /* Use the type from the LOC_REGISTER; that is the type
942 that is actually in that register. */
943 SYMBOL_TYPE (prev_sym
) = SYMBOL_TYPE (sym
);
944 SYMBOL_VALUE (prev_sym
) = SYMBOL_VALUE (sym
);
949 add_symbol_to_list (sym
, &local_symbols
);
952 add_symbol_to_list (sym
, &file_symbols
);
956 /* Static symbol at top level of file */
957 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
958 SYMBOL_CLASS (sym
) = LOC_STATIC
;
959 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
960 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
961 add_symbol_to_list (sym
, &file_symbols
);
965 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
967 /* For a nameless type, we don't want a create a symbol, thus we
968 did not use `sym'. Return without further processing. */
969 if (nameless
) return NULL
;
971 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
972 SYMBOL_VALUE (sym
) = valu
;
973 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
974 /* C++ vagaries: we may have a type which is derived from
975 a base type which did not have its name defined when the
976 derived class was output. We fill in the derived class's
977 base part member's name here in that case. */
978 if (TYPE_NAME (SYMBOL_TYPE (sym
)) != NULL
)
979 if ((TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
980 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_UNION
)
981 && TYPE_N_BASECLASSES (SYMBOL_TYPE (sym
)))
984 for (j
= TYPE_N_BASECLASSES (SYMBOL_TYPE (sym
)) - 1; j
>= 0; j
--)
985 if (TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym
), j
) == 0)
986 TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym
), j
) =
987 type_name_no_tag (TYPE_BASECLASS (SYMBOL_TYPE (sym
), j
));
990 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == NULL
)
992 if (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_PTR
993 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FUNC
)
995 /* If we are giving a name to a type such as "pointer to
996 foo" or "function returning foo", we better not set
997 the TYPE_NAME. If the program contains "typedef char
998 *caddr_t;", we don't want all variables of type char
999 * to print as caddr_t. This is not just a
1000 consequence of GDB's type management; PCC and GCC (at
1001 least through version 2.4) both output variables of
1002 either type char * or caddr_t with the type number
1003 defined in the 't' symbol for caddr_t. If a future
1004 compiler cleans this up it GDB is not ready for it
1005 yet, but if it becomes ready we somehow need to
1006 disable this check (without breaking the PCC/GCC2.4
1011 Fortunately, this check seems not to be necessary
1012 for anything except pointers or functions. */
1015 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_NAME (sym
);
1018 add_symbol_to_list (sym
, &file_symbols
);
1022 /* Struct, union, or enum tag. For GNU C++, this can be be followed
1023 by 't' which means we are typedef'ing it as well. */
1024 synonym
= *p
== 't';
1029 type_synonym_name
= obsavestring (SYMBOL_NAME (sym
),
1030 strlen (SYMBOL_NAME (sym
)),
1031 &objfile
-> symbol_obstack
);
1034 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1036 /* For a nameless type, we don't want a create a symbol, thus we
1037 did not use `sym'. Return without further processing. */
1038 if (nameless
) return NULL
;
1040 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1041 SYMBOL_VALUE (sym
) = valu
;
1042 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
1043 if (TYPE_TAG_NAME (SYMBOL_TYPE (sym
)) == 0)
1044 TYPE_TAG_NAME (SYMBOL_TYPE (sym
))
1045 = obconcat (&objfile
-> type_obstack
, "", "", SYMBOL_NAME (sym
));
1046 add_symbol_to_list (sym
, &file_symbols
);
1050 /* Clone the sym and then modify it. */
1051 register struct symbol
*typedef_sym
= (struct symbol
*)
1052 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
1053 *typedef_sym
= *sym
;
1054 SYMBOL_CLASS (typedef_sym
) = LOC_TYPEDEF
;
1055 SYMBOL_VALUE (typedef_sym
) = valu
;
1056 SYMBOL_NAMESPACE (typedef_sym
) = VAR_NAMESPACE
;
1057 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
1058 TYPE_NAME (SYMBOL_TYPE (sym
))
1059 = obconcat (&objfile
-> type_obstack
, "", "", SYMBOL_NAME (sym
));
1060 add_symbol_to_list (typedef_sym
, &file_symbols
);
1065 /* Static symbol of local scope */
1066 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1067 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1068 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
1069 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1070 add_symbol_to_list (sym
, &local_symbols
);
1074 /* Reference parameter */
1075 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1076 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
1077 SYMBOL_VALUE (sym
) = valu
;
1078 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1079 add_symbol_to_list (sym
, &local_symbols
);
1083 /* This is used by Sun FORTRAN for "function result value".
1084 Sun claims ("dbx and dbxtool interfaces", 2nd ed)
1085 that Pascal uses it too, but when I tried it Pascal used
1086 "x:3" (local symbol) instead. */
1087 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1088 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
1089 SYMBOL_VALUE (sym
) = valu
;
1090 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1091 add_symbol_to_list (sym
, &local_symbols
);
1095 SYMBOL_TYPE (sym
) = error_type (&p
);
1096 SYMBOL_CLASS (sym
) = LOC_CONST
;
1097 SYMBOL_VALUE (sym
) = 0;
1098 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1099 add_symbol_to_list (sym
, &file_symbols
);
1103 /* When passing structures to a function, some systems sometimes pass
1104 the address in a register, not the structure itself.
1106 If REG_STRUCT_HAS_ADDR yields non-zero we have to convert LOC_REGPARM
1107 to LOC_REGPARM_ADDR for structures and unions. */
1109 #if !defined (REG_STRUCT_HAS_ADDR)
1110 #define REG_STRUCT_HAS_ADDR(gcc_p) 0
1113 if (SYMBOL_CLASS (sym
) == LOC_REGPARM
1114 && REG_STRUCT_HAS_ADDR (processing_gcc_compilation
)
1115 && ( (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
)
1116 || (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_UNION
)))
1117 SYMBOL_CLASS (sym
) = LOC_REGPARM_ADDR
;
1123 /* Skip rest of this symbol and return an error type.
1125 General notes on error recovery: error_type always skips to the
1126 end of the symbol (modulo cretinous dbx symbol name continuation).
1127 Thus code like this:
1129 if (*(*pp)++ != ';')
1130 return error_type (pp);
1132 is wrong because if *pp starts out pointing at '\0' (typically as the
1133 result of an earlier error), it will be incremented to point to the
1134 start of the next symbol, which might produce strange results, at least
1135 if you run off the end of the string table. Instead use
1138 return error_type (pp);
1144 foo = error_type (pp);
1148 And in case it isn't obvious, the point of all this hair is so the compiler
1149 can define new types and new syntaxes, and old versions of the
1150 debugger will be able to read the new symbol tables. */
1152 static struct type
*
1156 complain (&error_type_complaint
);
1159 /* Skip to end of symbol. */
1160 while (**pp
!= '\0')
1165 /* Check for and handle cretinous dbx symbol name continuation! */
1166 if ((*pp
)[-1] == '\\')
1168 *pp
= next_symbol_text ();
1175 return (builtin_type_error
);
1179 /* Read type information or a type definition; return the type. Even
1180 though this routine accepts either type information or a type
1181 definition, the distinction is relevant--some parts of stabsread.c
1182 assume that type information starts with a digit, '-', or '(' in
1183 deciding whether to call read_type. */
1186 read_type (pp
, objfile
)
1188 struct objfile
*objfile
;
1190 register struct type
*type
= 0;
1194 char type_descriptor
;
1196 /* Size in bits of type if specified by a type attribute, or -1 if
1197 there is no size attribute. */
1200 /* Read type number if present. The type number may be omitted.
1201 for instance in a two-dimensional array declared with type
1202 "ar1;1;10;ar1;1;10;4". */
1203 if ((**pp
>= '0' && **pp
<= '9')
1207 if (read_type_number (pp
, typenums
) != 0)
1208 return error_type (pp
);
1210 /* Type is not being defined here. Either it already exists,
1211 or this is a forward reference to it. dbx_alloc_type handles
1214 return dbx_alloc_type (typenums
, objfile
);
1216 /* Type is being defined here. */
1223 /* It might be a type attribute or a member type. */
1224 if (isdigit (*p
) || *p
== '(' || *p
== '-')
1229 /* Type attributes. */
1232 /* Skip to the semicolon. */
1233 while (*p
!= ';' && *p
!= '\0')
1237 return error_type (pp
);
1239 /* Skip the semicolon. */
1245 type_size
= atoi (attr
+ 1);
1250 /* Ignore unrecognized type attributes, so future compilers
1251 can invent new ones. */
1256 /* Skip the type descriptor, we get it below with (*pp)[-1]. */
1261 /* 'typenums=' not present, type is anonymous. Read and return
1262 the definition, but don't put it in the type vector. */
1263 typenums
[0] = typenums
[1] = -1;
1267 type_descriptor
= (*pp
)[-1];
1268 switch (type_descriptor
)
1272 enum type_code code
;
1274 /* Used to index through file_symbols. */
1275 struct pending
*ppt
;
1278 /* Name including "struct", etc. */
1284 /* Set the type code according to the following letter. */
1288 code
= TYPE_CODE_STRUCT
;
1291 code
= TYPE_CODE_UNION
;
1294 code
= TYPE_CODE_ENUM
;
1297 return error_type (pp
);
1300 to
= type_name
= (char *)
1301 obstack_alloc (&objfile
-> type_obstack
,
1302 (((char *) strchr (*pp
, ':') - (*pp
)) + 1));
1304 /* Copy the name. */
1306 while ((*to
++ = *from
++) != ':')
1310 /* Set the pointer ahead of the name which we just read. */
1314 /* Now check to see whether the type has already been declared. */
1315 /* This is necessary at least in the case where the
1316 program says something like
1318 The compiler puts out a cross-reference; we better find
1319 set the length of the structure correctly so we can
1320 set the length of the array. */
1321 for (ppt
= file_symbols
; ppt
; ppt
= ppt
->next
)
1322 for (i
= 0; i
< ppt
->nsyms
; i
++)
1324 struct symbol
*sym
= ppt
->symbol
[i
];
1326 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
1327 && SYMBOL_NAMESPACE (sym
) == STRUCT_NAMESPACE
1328 && (TYPE_CODE (SYMBOL_TYPE (sym
)) == code
)
1329 && STREQ (SYMBOL_NAME (sym
), type_name
))
1331 obstack_free (&objfile
-> type_obstack
, type_name
);
1332 type
= SYMBOL_TYPE (sym
);
1337 /* Didn't find the type to which this refers, so we must
1338 be dealing with a forward reference. Allocate a type
1339 structure for it, and keep track of it so we can
1340 fill in the rest of the fields when we get the full
1342 type
= dbx_alloc_type (typenums
, objfile
);
1343 TYPE_CODE (type
) = code
;
1344 TYPE_TAG_NAME (type
) = type_name
;
1345 INIT_CPLUS_SPECIFIC(type
);
1346 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
1348 add_undefined_type (type
);
1352 case '-': /* RS/6000 built-in type */
1366 if (read_type_number (pp
, xtypenums
) != 0)
1367 return error_type (pp
);
1369 if (typenums
[0] == xtypenums
[0] && typenums
[1] == xtypenums
[1])
1370 /* It's being defined as itself. That means it is "void". */
1371 type
= init_type (TYPE_CODE_VOID
, 0, 0, NULL
, objfile
);
1374 struct type
*xtype
= *dbx_lookup_type (xtypenums
);
1376 /* This can happen if we had '-' followed by a garbage character,
1379 return error_type (pp
);
1381 /* The type is being defined to another type. So we copy the type.
1382 This loses if we copy a C++ class and so we lose track of how
1383 the names are mangled (but g++ doesn't output stabs like this
1386 type
= alloc_type (objfile
);
1387 memcpy (type
, xtype
, sizeof (struct type
));
1389 /* The idea behind clearing the names is that the only purpose
1390 for defining a type to another type is so that the name of
1391 one can be different. So we probably don't need to worry much
1392 about the case where the compiler doesn't give a name to the
1394 TYPE_NAME (type
) = NULL
;
1395 TYPE_TAG_NAME (type
) = NULL
;
1397 if (typenums
[0] != -1)
1398 *dbx_lookup_type (typenums
) = type
;
1401 /* In the following types, we must be sure to overwrite any existing
1402 type that the typenums refer to, rather than allocating a new one
1403 and making the typenums point to the new one. This is because there
1404 may already be pointers to the existing type (if it had been
1405 forward-referenced), and we must change it to a pointer, function,
1406 reference, or whatever, *in-place*. */
1409 type1
= read_type (pp
, objfile
);
1410 type
= make_pointer_type (type1
, dbx_lookup_type (typenums
));
1413 case '&': /* Reference to another type */
1414 type1
= read_type (pp
, objfile
);
1415 type
= make_reference_type (type1
, dbx_lookup_type (typenums
));
1418 case 'f': /* Function returning another type */
1419 type1
= read_type (pp
, objfile
);
1420 type
= make_function_type (type1
, dbx_lookup_type (typenums
));
1423 case 'k': /* Const qualifier on some type (Sun) */
1424 type
= read_type (pp
, objfile
);
1425 /* FIXME! For now, we ignore const and volatile qualifiers. */
1428 case 'B': /* Volatile qual on some type (Sun) */
1429 type
= read_type (pp
, objfile
);
1430 /* FIXME! For now, we ignore const and volatile qualifiers. */
1433 /* FIXME -- we should be doing smash_to_XXX types here. */
1434 case '@': /* Member (class & variable) type */
1436 struct type
*domain
= read_type (pp
, objfile
);
1437 struct type
*memtype
;
1440 /* Invalid member type data format. */
1441 return error_type (pp
);
1444 memtype
= read_type (pp
, objfile
);
1445 type
= dbx_alloc_type (typenums
, objfile
);
1446 smash_to_member_type (type
, domain
, memtype
);
1450 case '#': /* Method (class & fn) type */
1451 if ((*pp
)[0] == '#')
1453 /* We'll get the parameter types from the name. */
1454 struct type
*return_type
;
1457 return_type
= read_type (pp
, objfile
);
1458 if (*(*pp
)++ != ';')
1459 complain (&invalid_member_complaint
, symnum
);
1460 type
= allocate_stub_method (return_type
);
1461 if (typenums
[0] != -1)
1462 *dbx_lookup_type (typenums
) = type
;
1466 struct type
*domain
= read_type (pp
, objfile
);
1467 struct type
*return_type
;
1471 /* Invalid member type data format. */
1472 return error_type (pp
);
1476 return_type
= read_type (pp
, objfile
);
1477 args
= read_args (pp
, ';', objfile
);
1478 type
= dbx_alloc_type (typenums
, objfile
);
1479 smash_to_method_type (type
, domain
, return_type
, args
);
1483 case 'r': /* Range type */
1484 type
= read_range_type (pp
, typenums
, objfile
);
1485 if (typenums
[0] != -1)
1486 *dbx_lookup_type (typenums
) = type
;
1489 case 'b': /* Sun ACC builtin int type */
1490 type
= read_sun_builtin_type (pp
, typenums
, objfile
);
1491 if (typenums
[0] != -1)
1492 *dbx_lookup_type (typenums
) = type
;
1495 case 'R': /* Sun ACC builtin float type */
1496 type
= read_sun_floating_type (pp
, typenums
, objfile
);
1497 if (typenums
[0] != -1)
1498 *dbx_lookup_type (typenums
) = type
;
1501 case 'e': /* Enumeration type */
1502 type
= dbx_alloc_type (typenums
, objfile
);
1503 type
= read_enum_type (pp
, type
, objfile
);
1504 if (typenums
[0] != -1)
1505 *dbx_lookup_type (typenums
) = type
;
1508 case 's': /* Struct type */
1509 case 'u': /* Union type */
1510 type
= dbx_alloc_type (typenums
, objfile
);
1511 if (!TYPE_NAME (type
))
1513 TYPE_NAME (type
) = type_synonym_name
;
1515 type_synonym_name
= NULL
;
1516 switch (type_descriptor
)
1519 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
1522 TYPE_CODE (type
) = TYPE_CODE_UNION
;
1525 type
= read_struct_type (pp
, type
, objfile
);
1528 case 'a': /* Array type */
1530 return error_type (pp
);
1533 type
= dbx_alloc_type (typenums
, objfile
);
1534 type
= read_array_type (pp
, type
, objfile
);
1538 --*pp
; /* Go back to the symbol in error */
1539 /* Particularly important if it was \0! */
1540 return error_type (pp
);
1545 warning ("GDB internal error, type is NULL in stabsread.c\n");
1546 return error_type (pp
);
1549 /* Size specified in a type attribute overrides any other size. */
1550 if (type_size
!= -1)
1551 TYPE_LENGTH (type
) = type_size
/ TARGET_CHAR_BIT
;
1556 /* RS/6000 xlc/dbx combination uses a set of builtin types, starting from -1.
1557 Return the proper type node for a given builtin type number. */
1559 static struct type
*
1560 rs6000_builtin_type (typenum
)
1563 /* We recognize types numbered from -NUMBER_RECOGNIZED to -1. */
1564 #define NUMBER_RECOGNIZED 30
1565 /* This includes an empty slot for type number -0. */
1566 static struct type
*negative_types
[NUMBER_RECOGNIZED
+ 1];
1567 struct type
*rettype
= NULL
;
1569 if (typenum
>= 0 || typenum
< -NUMBER_RECOGNIZED
)
1571 complain (&rs6000_builtin_complaint
, typenum
);
1572 return builtin_type_error
;
1574 if (negative_types
[-typenum
] != NULL
)
1575 return negative_types
[-typenum
];
1577 #if TARGET_CHAR_BIT != 8
1578 #error This code wrong for TARGET_CHAR_BIT not 8
1579 /* These definitions all assume that TARGET_CHAR_BIT is 8. I think
1580 that if that ever becomes not true, the correct fix will be to
1581 make the size in the struct type to be in bits, not in units of
1588 /* The size of this and all the other types are fixed, defined
1589 by the debugging format. If there is a type called "int" which
1590 is other than 32 bits, then it should use a new negative type
1591 number (or avoid negative type numbers for that case).
1592 See stabs.texinfo. */
1593 rettype
= init_type (TYPE_CODE_INT
, 4, 0, "int", NULL
);
1596 rettype
= init_type (TYPE_CODE_INT
, 1, 0, "char", NULL
);
1599 rettype
= init_type (TYPE_CODE_INT
, 2, 0, "short", NULL
);
1602 rettype
= init_type (TYPE_CODE_INT
, 4, 0, "long", NULL
);
1605 rettype
= init_type (TYPE_CODE_INT
, 1, TYPE_FLAG_UNSIGNED
,
1606 "unsigned char", NULL
);
1609 rettype
= init_type (TYPE_CODE_INT
, 1, 0, "signed char", NULL
);
1612 rettype
= init_type (TYPE_CODE_INT
, 2, TYPE_FLAG_UNSIGNED
,
1613 "unsigned short", NULL
);
1616 rettype
= init_type (TYPE_CODE_INT
, 4, TYPE_FLAG_UNSIGNED
,
1617 "unsigned int", NULL
);
1620 rettype
= init_type (TYPE_CODE_INT
, 4, TYPE_FLAG_UNSIGNED
,
1623 rettype
= init_type (TYPE_CODE_INT
, 4, TYPE_FLAG_UNSIGNED
,
1624 "unsigned long", NULL
);
1627 rettype
= init_type (TYPE_CODE_VOID
, 0, 0, "void", NULL
);
1630 /* IEEE single precision (32 bit). */
1631 rettype
= init_type (TYPE_CODE_FLT
, 4, 0, "float", NULL
);
1634 /* IEEE double precision (64 bit). */
1635 rettype
= init_type (TYPE_CODE_FLT
, 8, 0, "double", NULL
);
1638 /* This is an IEEE double on the RS/6000, and different machines with
1639 different sizes for "long double" should use different negative
1640 type numbers. See stabs.texinfo. */
1641 rettype
= init_type (TYPE_CODE_FLT
, 8, 0, "long double", NULL
);
1644 rettype
= init_type (TYPE_CODE_INT
, 4, 0, "integer", NULL
);
1647 rettype
= init_type (TYPE_CODE_BOOL
, 4, 0, "boolean", NULL
);
1650 rettype
= init_type (TYPE_CODE_FLT
, 4, 0, "short real", NULL
);
1653 rettype
= init_type (TYPE_CODE_FLT
, 8, 0, "real", NULL
);
1656 rettype
= init_type (TYPE_CODE_ERROR
, 0, 0, "stringptr", NULL
);
1659 rettype
= init_type (TYPE_CODE_CHAR
, 1, TYPE_FLAG_UNSIGNED
,
1663 rettype
= init_type (TYPE_CODE_BOOL
, 1, TYPE_FLAG_UNSIGNED
,
1667 rettype
= init_type (TYPE_CODE_BOOL
, 2, TYPE_FLAG_UNSIGNED
,
1671 rettype
= init_type (TYPE_CODE_BOOL
, 4, TYPE_FLAG_UNSIGNED
,
1675 rettype
= init_type (TYPE_CODE_BOOL
, 4, TYPE_FLAG_UNSIGNED
,
1679 /* Complex type consisting of two IEEE single precision values. */
1680 rettype
= init_type (TYPE_CODE_ERROR
, 8, 0, "complex", NULL
);
1683 /* Complex type consisting of two IEEE double precision values. */
1684 rettype
= init_type (TYPE_CODE_ERROR
, 16, 0, "double complex", NULL
);
1687 rettype
= init_type (TYPE_CODE_INT
, 1, 0, "integer*1", NULL
);
1690 rettype
= init_type (TYPE_CODE_INT
, 2, 0, "integer*2", NULL
);
1693 rettype
= init_type (TYPE_CODE_INT
, 4, 0, "integer*4", NULL
);
1696 rettype
= init_type (TYPE_CODE_CHAR
, 2, 0, "wchar", NULL
);
1699 negative_types
[-typenum
] = rettype
;
1703 /* This page contains subroutines of read_type. */
1705 #define VISIBILITY_PRIVATE '0' /* Stabs character for private field */
1706 #define VISIBILITY_PROTECTED '1' /* Stabs character for protected fld */
1707 #define VISIBILITY_PUBLIC '2' /* Stabs character for public field */
1708 #define VISIBILITY_IGNORE '9' /* artificial character for ignore the field */
1710 /* Read member function stabs info for C++ classes. The form of each member
1713 NAME :: TYPENUM[=type definition] ARGS : PHYSNAME ;
1715 An example with two member functions is:
1717 afunc1::20=##15;:i;2A.;afunc2::20:i;2A.;
1719 For the case of overloaded operators, the format is op$::*.funcs, where
1720 $ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator
1721 name (such as `+=') and `.' marks the end of the operator name.
1723 Returns 1 for success, 0 for failure. */
1726 read_member_functions (fip
, pp
, type
, objfile
)
1727 struct field_info
*fip
;
1730 struct objfile
*objfile
;
1734 /* Total number of member functions defined in this class. If the class
1735 defines two `f' functions, and one `g' function, then this will have
1737 int total_length
= 0;
1741 struct next_fnfield
*next
;
1742 struct fn_field fn_field
;
1744 struct type
*look_ahead_type
;
1745 struct next_fnfieldlist
*new_fnlist
;
1746 struct next_fnfield
*new_sublist
;
1750 /* Process each list until we find something that is not a member function
1751 or find the end of the functions. */
1755 /* We should be positioned at the start of the function name.
1756 Scan forward to find the first ':' and if it is not the
1757 first of a "::" delimiter, then this is not a member function. */
1769 look_ahead_type
= NULL
;
1772 new_fnlist
= (struct next_fnfieldlist
*)
1773 xmalloc (sizeof (struct next_fnfieldlist
));
1774 make_cleanup (free
, new_fnlist
);
1775 memset (new_fnlist
, 0, sizeof (struct next_fnfieldlist
));
1777 if ((*pp
)[0] == 'o' && (*pp
)[1] == 'p' && (*pp
)[2] == CPLUS_MARKER
)
1779 /* This is a completely wierd case. In order to stuff in the
1780 names that might contain colons (the usual name delimiter),
1781 Mike Tiemann defined a different name format which is
1782 signalled if the identifier is "op$". In that case, the
1783 format is "op$::XXXX." where XXXX is the name. This is
1784 used for names like "+" or "=". YUUUUUUUK! FIXME! */
1785 /* This lets the user type "break operator+".
1786 We could just put in "+" as the name, but that wouldn't
1788 static char opname
[32] = {'o', 'p', CPLUS_MARKER
};
1789 char *o
= opname
+ 3;
1791 /* Skip past '::'. */
1794 STABS_CONTINUE (pp
);
1800 main_fn_name
= savestring (opname
, o
- opname
);
1806 main_fn_name
= savestring (*pp
, p
- *pp
);
1807 /* Skip past '::'. */
1810 new_fnlist
-> fn_fieldlist
.name
= main_fn_name
;
1815 (struct next_fnfield
*) xmalloc (sizeof (struct next_fnfield
));
1816 make_cleanup (free
, new_sublist
);
1817 memset (new_sublist
, 0, sizeof (struct next_fnfield
));
1819 /* Check for and handle cretinous dbx symbol name continuation! */
1820 if (look_ahead_type
== NULL
)
1823 STABS_CONTINUE (pp
);
1825 new_sublist
-> fn_field
.type
= read_type (pp
, objfile
);
1828 /* Invalid symtab info for member function. */
1834 /* g++ version 1 kludge */
1835 new_sublist
-> fn_field
.type
= look_ahead_type
;
1836 look_ahead_type
= NULL
;
1846 /* If this is just a stub, then we don't have the real name here. */
1848 if (TYPE_FLAGS (new_sublist
-> fn_field
.type
) & TYPE_FLAG_STUB
)
1850 if (!TYPE_DOMAIN_TYPE (new_sublist
-> fn_field
.type
))
1851 TYPE_DOMAIN_TYPE (new_sublist
-> fn_field
.type
) = type
;
1852 new_sublist
-> fn_field
.is_stub
= 1;
1854 new_sublist
-> fn_field
.physname
= savestring (*pp
, p
- *pp
);
1857 /* Set this member function's visibility fields. */
1860 case VISIBILITY_PRIVATE
:
1861 new_sublist
-> fn_field
.is_private
= 1;
1863 case VISIBILITY_PROTECTED
:
1864 new_sublist
-> fn_field
.is_protected
= 1;
1868 STABS_CONTINUE (pp
);
1871 case 'A': /* Normal functions. */
1872 new_sublist
-> fn_field
.is_const
= 0;
1873 new_sublist
-> fn_field
.is_volatile
= 0;
1876 case 'B': /* `const' member functions. */
1877 new_sublist
-> fn_field
.is_const
= 1;
1878 new_sublist
-> fn_field
.is_volatile
= 0;
1881 case 'C': /* `volatile' member function. */
1882 new_sublist
-> fn_field
.is_const
= 0;
1883 new_sublist
-> fn_field
.is_volatile
= 1;
1886 case 'D': /* `const volatile' member function. */
1887 new_sublist
-> fn_field
.is_const
= 1;
1888 new_sublist
-> fn_field
.is_volatile
= 1;
1891 case '*': /* File compiled with g++ version 1 -- no info */
1896 complain (&const_vol_complaint
, **pp
);
1905 /* virtual member function, followed by index.
1906 The sign bit is set to distinguish pointers-to-methods
1907 from virtual function indicies. Since the array is
1908 in words, the quantity must be shifted left by 1
1909 on 16 bit machine, and by 2 on 32 bit machine, forcing
1910 the sign bit out, and usable as a valid index into
1911 the array. Remove the sign bit here. */
1912 new_sublist
-> fn_field
.voffset
=
1913 (0x7fffffff & read_huge_number (pp
, ';', &nbits
)) + 2;
1917 STABS_CONTINUE (pp
);
1918 if (**pp
== ';' || **pp
== '\0')
1920 /* Must be g++ version 1. */
1921 new_sublist
-> fn_field
.fcontext
= 0;
1925 /* Figure out from whence this virtual function came.
1926 It may belong to virtual function table of
1927 one of its baseclasses. */
1928 look_ahead_type
= read_type (pp
, objfile
);
1931 /* g++ version 1 overloaded methods. */
1935 new_sublist
-> fn_field
.fcontext
= look_ahead_type
;
1944 look_ahead_type
= NULL
;
1950 /* static member function. */
1951 new_sublist
-> fn_field
.voffset
= VOFFSET_STATIC
;
1952 if (strncmp (new_sublist
-> fn_field
.physname
,
1953 main_fn_name
, strlen (main_fn_name
)))
1955 new_sublist
-> fn_field
.is_stub
= 1;
1961 complain (&member_fn_complaint
, (*pp
)[-1]);
1962 /* Fall through into normal member function. */
1965 /* normal member function. */
1966 new_sublist
-> fn_field
.voffset
= 0;
1967 new_sublist
-> fn_field
.fcontext
= 0;
1971 new_sublist
-> next
= sublist
;
1972 sublist
= new_sublist
;
1974 STABS_CONTINUE (pp
);
1976 while (**pp
!= ';' && **pp
!= '\0');
1980 new_fnlist
-> fn_fieldlist
.fn_fields
= (struct fn_field
*)
1981 obstack_alloc (&objfile
-> type_obstack
,
1982 sizeof (struct fn_field
) * length
);
1983 memset (new_fnlist
-> fn_fieldlist
.fn_fields
, 0,
1984 sizeof (struct fn_field
) * length
);
1985 for (i
= length
; (i
--, sublist
); sublist
= sublist
-> next
)
1987 new_fnlist
-> fn_fieldlist
.fn_fields
[i
] = sublist
-> fn_field
;
1990 new_fnlist
-> fn_fieldlist
.length
= length
;
1991 new_fnlist
-> next
= fip
-> fnlist
;
1992 fip
-> fnlist
= new_fnlist
;
1994 total_length
+= length
;
1995 STABS_CONTINUE (pp
);
2000 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2001 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
2002 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * nfn_fields
);
2003 memset (TYPE_FN_FIELDLISTS (type
), 0,
2004 sizeof (struct fn_fieldlist
) * nfn_fields
);
2005 TYPE_NFN_FIELDS (type
) = nfn_fields
;
2006 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
2012 /* Special GNU C++ name.
2014 Returns 1 for success, 0 for failure. "failure" means that we can't
2015 keep parsing and it's time for error_type(). */
2018 read_cpp_abbrev (fip
, pp
, type
, objfile
)
2019 struct field_info
*fip
;
2022 struct objfile
*objfile
;
2027 struct type
*context
;
2037 /* At this point, *pp points to something like "22:23=*22...",
2038 where the type number before the ':' is the "context" and
2039 everything after is a regular type definition. Lookup the
2040 type, find it's name, and construct the field name. */
2042 context
= read_type (pp
, objfile
);
2046 case 'f': /* $vf -- a virtual function table pointer */
2047 fip
->list
->field
.name
=
2048 obconcat (&objfile
->type_obstack
, vptr_name
, "", "");
2051 case 'b': /* $vb -- a virtual bsomethingorother */
2052 name
= type_name_no_tag (context
);
2055 complain (&invalid_cpp_type_complaint
, symnum
);
2058 fip
->list
->field
.name
=
2059 obconcat (&objfile
->type_obstack
, vb_name
, name
, "");
2063 complain (&invalid_cpp_abbrev_complaint
, *pp
);
2064 fip
->list
->field
.name
=
2065 obconcat (&objfile
->type_obstack
,
2066 "INVALID_CPLUSPLUS_ABBREV", "", "");
2070 /* At this point, *pp points to the ':'. Skip it and read the
2076 complain (&invalid_cpp_abbrev_complaint
, *pp
);
2079 fip
->list
->field
.type
= read_type (pp
, objfile
);
2081 (*pp
)++; /* Skip the comma. */
2087 fip
->list
->field
.bitpos
= read_huge_number (pp
, ';', &nbits
);
2091 /* This field is unpacked. */
2092 fip
->list
->field
.bitsize
= 0;
2093 fip
->list
->visibility
= VISIBILITY_PRIVATE
;
2097 complain (&invalid_cpp_abbrev_complaint
, *pp
);
2098 /* We have no idea what syntax an unrecognized abbrev would have, so
2099 better return 0. If we returned 1, we would need to at least advance
2100 *pp to avoid an infinite loop. */
2107 read_one_struct_field (fip
, pp
, p
, type
, objfile
)
2108 struct field_info
*fip
;
2112 struct objfile
*objfile
;
2114 fip
-> list
-> field
.name
=
2115 obsavestring (*pp
, p
- *pp
, &objfile
-> type_obstack
);
2118 /* This means we have a visibility for a field coming. */
2122 fip
-> list
-> visibility
= *(*pp
)++;
2123 switch (fip
-> list
-> visibility
)
2125 case VISIBILITY_PRIVATE
:
2126 case VISIBILITY_PROTECTED
:
2129 case VISIBILITY_PUBLIC
:
2134 /* Unknown visibility specifier. */
2135 complain (&stabs_general_complaint
,
2136 "unknown visibility specifier");
2143 /* normal dbx-style format, no explicit visibility */
2144 fip
-> list
-> visibility
= VISIBILITY_PUBLIC
;
2147 fip
-> list
-> field
.type
= read_type (pp
, objfile
);
2152 /* Possible future hook for nested types. */
2155 fip
-> list
-> field
.bitpos
= (long)-2; /* nested type */
2161 /* Static class member. */
2162 fip
-> list
-> field
.bitpos
= (long) -1;
2168 fip
-> list
-> field
.bitsize
= (long) savestring (*pp
, p
- *pp
);
2172 else if (**pp
!= ',')
2174 /* Bad structure-type format. */
2175 complain (&stabs_general_complaint
, "bad structure-type format");
2179 (*pp
)++; /* Skip the comma. */
2183 fip
-> list
-> field
.bitpos
= read_huge_number (pp
, ',', &nbits
);
2186 complain (&stabs_general_complaint
, "bad structure-type format");
2189 fip
-> list
-> field
.bitsize
= read_huge_number (pp
, ';', &nbits
);
2192 complain (&stabs_general_complaint
, "bad structure-type format");
2197 if (fip
-> list
-> field
.bitpos
== 0 && fip
-> list
-> field
.bitsize
== 0)
2199 /* This can happen in two cases: (1) at least for gcc 2.4.5 or so,
2200 it is a field which has been optimized out. The correct stab for
2201 this case is to use VISIBILITY_IGNORE, but that is a recent
2202 invention. (2) It is a 0-size array. For example
2203 union { int num; char str[0]; } foo. Printing "<no value>" for
2204 str in "p foo" is OK, since foo.str (and thus foo.str[3])
2205 will continue to work, and a 0-size array as a whole doesn't
2206 have any contents to print.
2208 I suspect this probably could also happen with gcc -gstabs (not
2209 -gstabs+) for static fields, and perhaps other C++ extensions.
2210 Hopefully few people use -gstabs with gdb, since it is intended
2211 for dbx compatibility. */
2213 /* Ignore this field. */
2214 fip
-> list
-> visibility
= VISIBILITY_IGNORE
;
2218 /* Detect an unpacked field and mark it as such.
2219 dbx gives a bit size for all fields.
2220 Note that forward refs cannot be packed,
2221 and treat enums as if they had the width of ints. */
2223 if (TYPE_CODE (fip
-> list
-> field
.type
) != TYPE_CODE_INT
2224 && TYPE_CODE (fip
-> list
-> field
.type
) != TYPE_CODE_ENUM
)
2226 fip
-> list
-> field
.bitsize
= 0;
2228 if ((fip
-> list
-> field
.bitsize
2229 == TARGET_CHAR_BIT
* TYPE_LENGTH (fip
-> list
-> field
.type
)
2230 || (TYPE_CODE (fip
-> list
-> field
.type
) == TYPE_CODE_ENUM
2231 && (fip
-> list
-> field
.bitsize
2236 fip
-> list
-> field
.bitpos
% 8 == 0)
2238 fip
-> list
-> field
.bitsize
= 0;
2244 /* Read struct or class data fields. They have the form:
2246 NAME : [VISIBILITY] TYPENUM , BITPOS , BITSIZE ;
2248 At the end, we see a semicolon instead of a field.
2250 In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
2253 The optional VISIBILITY is one of:
2255 '/0' (VISIBILITY_PRIVATE)
2256 '/1' (VISIBILITY_PROTECTED)
2257 '/2' (VISIBILITY_PUBLIC)
2259 or nothing, for C style fields with public visibility.
2261 Returns 1 for success, 0 for failure. */
2264 read_struct_fields (fip
, pp
, type
, objfile
)
2265 struct field_info
*fip
;
2268 struct objfile
*objfile
;
2271 struct nextfield
*new;
2273 /* We better set p right now, in case there are no fields at all... */
2277 /* Read each data member type until we find the terminating ';' at the end of
2278 the data member list, or break for some other reason such as finding the
2279 start of the member function list. */
2283 STABS_CONTINUE (pp
);
2284 /* Get space to record the next field's data. */
2285 new = (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
2286 make_cleanup (free
, new);
2287 memset (new, 0, sizeof (struct nextfield
));
2288 new -> next
= fip
-> list
;
2291 /* Get the field name. */
2294 /* If is starts with CPLUS_MARKER it is a special abbreviation,
2295 unless the CPLUS_MARKER is followed by an underscore, in
2296 which case it is just the name of an anonymous type, which we
2297 should handle like any other type name. We accept either '$'
2298 or '.', because a field name can never contain one of these
2299 characters except as a CPLUS_MARKER (we probably should be
2300 doing that in most parts of GDB). */
2302 if ((*p
== '$' || *p
== '.') && p
[1] != '_')
2304 if (!read_cpp_abbrev (fip
, pp
, type
, objfile
))
2309 /* Look for the ':' that separates the field name from the field
2310 values. Data members are delimited by a single ':', while member
2311 functions are delimited by a pair of ':'s. When we hit the member
2312 functions (if any), terminate scan loop and return. */
2314 while (*p
!= ':' && *p
!= '\0')
2321 /* Check to see if we have hit the member functions yet. */
2326 read_one_struct_field (fip
, pp
, p
, type
, objfile
);
2330 /* chill the list of fields: the last entry (at the head) is a
2331 partially constructed entry which we now scrub. */
2332 fip
-> list
= fip
-> list
-> next
;
2337 /* The stabs for C++ derived classes contain baseclass information which
2338 is marked by a '!' character after the total size. This function is
2339 called when we encounter the baseclass marker, and slurps up all the
2340 baseclass information.
2342 Immediately following the '!' marker is the number of base classes that
2343 the class is derived from, followed by information for each base class.
2344 For each base class, there are two visibility specifiers, a bit offset
2345 to the base class information within the derived class, a reference to
2346 the type for the base class, and a terminating semicolon.
2348 A typical example, with two base classes, would be "!2,020,19;0264,21;".
2350 Baseclass information marker __________________|| | | | | | |
2351 Number of baseclasses __________________________| | | | | | |
2352 Visibility specifiers (2) ________________________| | | | | |
2353 Offset in bits from start of class _________________| | | | |
2354 Type number for base class ___________________________| | | |
2355 Visibility specifiers (2) _______________________________| | |
2356 Offset in bits from start of class ________________________| |
2357 Type number of base class ____________________________________|
2359 Return 1 for success, 0 for (error-type-inducing) failure. */
2362 read_baseclasses (fip
, pp
, type
, objfile
)
2363 struct field_info
*fip
;
2366 struct objfile
*objfile
;
2369 struct nextfield
*new;
2377 /* Skip the '!' baseclass information marker. */
2381 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2384 TYPE_N_BASECLASSES (type
) = read_huge_number (pp
, ',', &nbits
);
2390 /* Some stupid compilers have trouble with the following, so break
2391 it up into simpler expressions. */
2392 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*)
2393 TYPE_ALLOC (type
, B_BYTES (TYPE_N_BASECLASSES (type
)));
2396 int num_bytes
= B_BYTES (TYPE_N_BASECLASSES (type
));
2399 pointer
= (char *) TYPE_ALLOC (type
, num_bytes
);
2400 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*) pointer
;
2404 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), TYPE_N_BASECLASSES (type
));
2406 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
2408 new = (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
2409 make_cleanup (free
, new);
2410 memset (new, 0, sizeof (struct nextfield
));
2411 new -> next
= fip
-> list
;
2413 new -> field
.bitsize
= 0; /* this should be an unpacked field! */
2415 STABS_CONTINUE (pp
);
2419 /* Nothing to do. */
2422 SET_TYPE_FIELD_VIRTUAL (type
, i
);
2425 /* Bad visibility format. */
2429 new -> visibility
= *(*pp
)++;
2430 switch (new -> visibility
)
2432 case VISIBILITY_PRIVATE
:
2433 case VISIBILITY_PROTECTED
:
2434 case VISIBILITY_PUBLIC
:
2437 /* Bad visibility format. */
2444 /* The remaining value is the bit offset of the portion of the object
2445 corresponding to this baseclass. Always zero in the absence of
2446 multiple inheritance. */
2448 new -> field
.bitpos
= read_huge_number (pp
, ',', &nbits
);
2453 /* The last piece of baseclass information is the type of the
2454 base class. Read it, and remember it's type name as this
2457 new -> field
.type
= read_type (pp
, objfile
);
2458 new -> field
.name
= type_name_no_tag (new -> field
.type
);
2460 /* skip trailing ';' and bump count of number of fields seen */
2469 /* The tail end of stabs for C++ classes that contain a virtual function
2470 pointer contains a tilde, a %, and a type number.
2471 The type number refers to the base class (possibly this class itself) which
2472 contains the vtable pointer for the current class.
2474 This function is called when we have parsed all the method declarations,
2475 so we can look for the vptr base class info. */
2478 read_tilde_fields (fip
, pp
, type
, objfile
)
2479 struct field_info
*fip
;
2482 struct objfile
*objfile
;
2486 STABS_CONTINUE (pp
);
2488 /* If we are positioned at a ';', then skip it. */
2498 if (**pp
== '=' || **pp
== '+' || **pp
== '-')
2500 /* Obsolete flags that used to indicate the presence
2501 of constructors and/or destructors. */
2505 /* Read either a '%' or the final ';'. */
2506 if (*(*pp
)++ == '%')
2508 /* The next number is the type number of the base class
2509 (possibly our own class) which supplies the vtable for
2510 this class. Parse it out, and search that class to find
2511 its vtable pointer, and install those into TYPE_VPTR_BASETYPE
2512 and TYPE_VPTR_FIELDNO. */
2517 t
= read_type (pp
, objfile
);
2519 while (*p
!= '\0' && *p
!= ';')
2525 /* Premature end of symbol. */
2529 TYPE_VPTR_BASETYPE (type
) = t
;
2530 if (type
== t
) /* Our own class provides vtbl ptr */
2532 for (i
= TYPE_NFIELDS (t
) - 1;
2533 i
>= TYPE_N_BASECLASSES (t
);
2536 if (! strncmp (TYPE_FIELD_NAME (t
, i
), vptr_name
,
2537 sizeof (vptr_name
) - 1))
2539 TYPE_VPTR_FIELDNO (type
) = i
;
2543 /* Virtual function table field not found. */
2544 complain (&vtbl_notfound_complaint
, TYPE_NAME (type
));
2549 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
2560 attach_fn_fields_to_type (fip
, type
)
2561 struct field_info
*fip
;
2562 register struct type
*type
;
2566 for (n
= 0; n
< TYPE_N_BASECLASSES (type
); n
++)
2568 if (TYPE_CODE (TYPE_BASECLASS (type
, n
)) == TYPE_CODE_UNDEF
)
2570 /* @@ Memory leak on objfile -> type_obstack? */
2573 TYPE_NFN_FIELDS_TOTAL (type
) +=
2574 TYPE_NFN_FIELDS_TOTAL (TYPE_BASECLASS (type
, n
));
2577 for (n
= TYPE_NFN_FIELDS (type
);
2578 fip
-> fnlist
!= NULL
;
2579 fip
-> fnlist
= fip
-> fnlist
-> next
)
2581 --n
; /* Circumvent Sun3 compiler bug */
2582 TYPE_FN_FIELDLISTS (type
)[n
] = fip
-> fnlist
-> fn_fieldlist
;
2587 /* Create the vector of fields, and record how big it is.
2588 We need this info to record proper virtual function table information
2589 for this class's virtual functions. */
2592 attach_fields_to_type (fip
, type
, objfile
)
2593 struct field_info
*fip
;
2594 register struct type
*type
;
2595 struct objfile
*objfile
;
2597 register int nfields
= 0;
2598 register int non_public_fields
= 0;
2599 register struct nextfield
*scan
;
2601 /* Count up the number of fields that we have, as well as taking note of
2602 whether or not there are any non-public fields, which requires us to
2603 allocate and build the private_field_bits and protected_field_bits
2606 for (scan
= fip
-> list
; scan
!= NULL
; scan
= scan
-> next
)
2609 if (scan
-> visibility
!= VISIBILITY_PUBLIC
)
2611 non_public_fields
++;
2615 /* Now we know how many fields there are, and whether or not there are any
2616 non-public fields. Record the field count, allocate space for the
2617 array of fields, and create blank visibility bitfields if necessary. */
2619 TYPE_NFIELDS (type
) = nfields
;
2620 TYPE_FIELDS (type
) = (struct field
*)
2621 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
2622 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
2624 if (non_public_fields
)
2626 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
2628 TYPE_FIELD_PRIVATE_BITS (type
) =
2629 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2630 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
2632 TYPE_FIELD_PROTECTED_BITS (type
) =
2633 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2634 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
2636 TYPE_FIELD_IGNORE_BITS (type
) =
2637 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
2638 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
2641 /* Copy the saved-up fields into the field vector. Start from the head
2642 of the list, adding to the tail of the field array, so that they end
2643 up in the same order in the array in which they were added to the list. */
2645 while (nfields
-- > 0)
2647 TYPE_FIELD (type
, nfields
) = fip
-> list
-> field
;
2648 switch (fip
-> list
-> visibility
)
2650 case VISIBILITY_PRIVATE
:
2651 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
2654 case VISIBILITY_PROTECTED
:
2655 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
2658 case VISIBILITY_IGNORE
:
2659 SET_TYPE_FIELD_IGNORE (type
, nfields
);
2661 case VISIBILITY_PUBLIC
:
2665 /* Should warn about this unknown visibility? */
2668 fip
-> list
= fip
-> list
-> next
;
2673 /* Read the description of a structure (or union type) and return an object
2674 describing the type.
2676 PP points to a character pointer that points to the next unconsumed token
2677 in the the stabs string. For example, given stabs "A:T4=s4a:1,0,32;;",
2678 *PP will point to "4a:1,0,32;;".
2680 TYPE points to an incomplete type that needs to be filled in.
2682 OBJFILE points to the current objfile from which the stabs information is
2683 being read. (Note that it is redundant in that TYPE also contains a pointer
2684 to this same objfile, so it might be a good idea to eliminate it. FIXME).
2687 static struct type
*
2688 read_struct_type (pp
, type
, objfile
)
2691 struct objfile
*objfile
;
2693 struct cleanup
*back_to
;
2694 struct field_info fi
;
2699 back_to
= make_cleanup (null_cleanup
, 0);
2701 INIT_CPLUS_SPECIFIC (type
);
2702 TYPE_FLAGS (type
) &= ~TYPE_FLAG_STUB
;
2704 /* First comes the total size in bytes. */
2708 TYPE_LENGTH (type
) = read_huge_number (pp
, 0, &nbits
);
2710 return error_type (pp
);
2713 /* Now read the baseclasses, if any, read the regular C struct or C++
2714 class member fields, attach the fields to the type, read the C++
2715 member functions, attach them to the type, and then read any tilde
2716 field (baseclass specifier for the class holding the main vtable). */
2718 if (!read_baseclasses (&fi
, pp
, type
, objfile
)
2719 || !read_struct_fields (&fi
, pp
, type
, objfile
)
2720 || !attach_fields_to_type (&fi
, type
, objfile
)
2721 || !read_member_functions (&fi
, pp
, type
, objfile
)
2722 || !attach_fn_fields_to_type (&fi
, type
)
2723 || !read_tilde_fields (&fi
, pp
, type
, objfile
))
2725 do_cleanups (back_to
);
2726 return (error_type (pp
));
2729 do_cleanups (back_to
);
2733 /* Read a definition of an array type,
2734 and create and return a suitable type object.
2735 Also creates a range type which represents the bounds of that
2738 static struct type
*
2739 read_array_type (pp
, type
, objfile
)
2741 register struct type
*type
;
2742 struct objfile
*objfile
;
2744 struct type
*index_type
, *element_type
, *range_type
;
2749 /* Format of an array type:
2750 "ar<index type>;lower;upper;<array_contents_type>". Put code in
2753 Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
2754 for these, produce a type like float[][]. */
2756 index_type
= read_type (pp
, objfile
);
2758 /* Improper format of array type decl. */
2759 return error_type (pp
);
2762 if (!(**pp
>= '0' && **pp
<= '9'))
2767 lower
= read_huge_number (pp
, ';', &nbits
);
2769 return error_type (pp
);
2771 if (!(**pp
>= '0' && **pp
<= '9'))
2776 upper
= read_huge_number (pp
, ';', &nbits
);
2778 return error_type (pp
);
2780 element_type
= read_type (pp
, objfile
);
2789 create_range_type ((struct type
*) NULL
, index_type
, lower
, upper
);
2790 type
= create_array_type (type
, element_type
, range_type
);
2792 /* If we have an array whose element type is not yet known, but whose
2793 bounds *are* known, record it to be adjusted at the end of the file. */
2795 if (TYPE_LENGTH (element_type
) == 0 && !adjustable
)
2797 add_undefined_type (type
);
2804 /* Read a definition of an enumeration type,
2805 and create and return a suitable type object.
2806 Also defines the symbols that represent the values of the type. */
2808 static struct type
*
2809 read_enum_type (pp
, type
, objfile
)
2811 register struct type
*type
;
2812 struct objfile
*objfile
;
2817 register struct symbol
*sym
;
2819 struct pending
**symlist
;
2820 struct pending
*osyms
, *syms
;
2824 /* FIXME! The stabs produced by Sun CC merrily define things that ought
2825 to be file-scope, between N_FN entries, using N_LSYM. What's a mother
2826 to do? For now, force all enum values to file scope. */
2827 if (within_function
)
2828 symlist
= &local_symbols
;
2831 symlist
= &file_symbols
;
2833 o_nsyms
= osyms
? osyms
->nsyms
: 0;
2835 /* Read the value-names and their values.
2836 The input syntax is NAME:VALUE,NAME:VALUE, and so on.
2837 A semicolon or comma instead of a NAME means the end. */
2838 while (**pp
&& **pp
!= ';' && **pp
!= ',')
2841 STABS_CONTINUE (pp
);
2843 while (*p
!= ':') p
++;
2844 name
= obsavestring (*pp
, p
- *pp
, &objfile
-> symbol_obstack
);
2846 n
= read_huge_number (pp
, ',', &nbits
);
2848 return error_type (pp
);
2850 sym
= (struct symbol
*)
2851 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
2852 memset (sym
, 0, sizeof (struct symbol
));
2853 SYMBOL_NAME (sym
) = name
;
2854 SYMBOL_LANGUAGE (sym
) = current_subfile
-> language
;
2855 SYMBOL_CLASS (sym
) = LOC_CONST
;
2856 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2857 SYMBOL_VALUE (sym
) = n
;
2858 add_symbol_to_list (sym
, symlist
);
2863 (*pp
)++; /* Skip the semicolon. */
2865 /* Now fill in the fields of the type-structure. */
2867 TYPE_LENGTH (type
) = sizeof (int);
2868 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
2869 TYPE_FLAGS (type
) &= ~TYPE_FLAG_STUB
;
2870 TYPE_NFIELDS (type
) = nsyms
;
2871 TYPE_FIELDS (type
) = (struct field
*)
2872 TYPE_ALLOC (type
, sizeof (struct field
) * nsyms
);
2873 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nsyms
);
2875 /* Find the symbols for the values and put them into the type.
2876 The symbols can be found in the symlist that we put them on
2877 to cause them to be defined. osyms contains the old value
2878 of that symlist; everything up to there was defined by us. */
2879 /* Note that we preserve the order of the enum constants, so
2880 that in something like "enum {FOO, LAST_THING=FOO}" we print
2881 FOO, not LAST_THING. */
2883 for (syms
= *symlist
, n
= 0; syms
; syms
= syms
->next
)
2888 for (; j
< syms
->nsyms
; j
++,n
++)
2890 struct symbol
*xsym
= syms
->symbol
[j
];
2891 SYMBOL_TYPE (xsym
) = type
;
2892 TYPE_FIELD_NAME (type
, n
) = SYMBOL_NAME (xsym
);
2893 TYPE_FIELD_VALUE (type
, n
) = 0;
2894 TYPE_FIELD_BITPOS (type
, n
) = SYMBOL_VALUE (xsym
);
2895 TYPE_FIELD_BITSIZE (type
, n
) = 0;
2902 /* This screws up perfectly good C programs with enums. FIXME. */
2903 /* Is this Modula-2's BOOLEAN type? Flag it as such if so. */
2904 if(TYPE_NFIELDS(type
) == 2 &&
2905 ((STREQ(TYPE_FIELD_NAME(type
,0),"TRUE") &&
2906 STREQ(TYPE_FIELD_NAME(type
,1),"FALSE")) ||
2907 (STREQ(TYPE_FIELD_NAME(type
,1),"TRUE") &&
2908 STREQ(TYPE_FIELD_NAME(type
,0),"FALSE"))))
2909 TYPE_CODE(type
) = TYPE_CODE_BOOL
;
2915 /* Sun's ACC uses a somewhat saner method for specifying the builtin
2916 typedefs in every file (for int, long, etc):
2918 type = b <signed> <width>; <offset>; <nbits>
2919 signed = u or s. Possible c in addition to u or s (for char?).
2920 offset = offset from high order bit to start bit of type.
2921 width is # bytes in object of this type, nbits is # bits in type.
2923 The width/offset stuff appears to be for small objects stored in
2924 larger ones (e.g. `shorts' in `int' registers). We ignore it for now,
2927 static struct type
*
2928 read_sun_builtin_type (pp
, typenums
, objfile
)
2931 struct objfile
*objfile
;
2946 return error_type (pp
);
2950 /* For some odd reason, all forms of char put a c here. This is strange
2951 because no other type has this honor. We can safely ignore this because
2952 we actually determine 'char'acterness by the number of bits specified in
2958 /* The first number appears to be the number of bytes occupied
2959 by this type, except that unsigned short is 4 instead of 2.
2960 Since this information is redundant with the third number,
2961 we will ignore it. */
2962 read_huge_number (pp
, ';', &nbits
);
2964 return error_type (pp
);
2966 /* The second number is always 0, so ignore it too. */
2967 read_huge_number (pp
, ';', &nbits
);
2969 return error_type (pp
);
2971 /* The third number is the number of bits for this type. */
2972 type_bits
= read_huge_number (pp
, 0, &nbits
);
2974 return error_type (pp
);
2976 return init_type (type_bits
== 0 ? TYPE_CODE_VOID
: TYPE_CODE_INT
,
2977 type_bits
/ TARGET_CHAR_BIT
,
2978 signed_type
? 0 : TYPE_FLAG_UNSIGNED
, (char *)NULL
,
2982 static struct type
*
2983 read_sun_floating_type (pp
, typenums
, objfile
)
2986 struct objfile
*objfile
;
2992 /* The first number has more details about the type, for example
2994 details
= read_huge_number (pp
, ';', &nbits
);
2996 return error_type (pp
);
2998 /* The second number is the number of bytes occupied by this type */
2999 nbytes
= read_huge_number (pp
, ';', &nbits
);
3001 return error_type (pp
);
3003 if (details
== NF_COMPLEX
|| details
== NF_COMPLEX16
3004 || details
== NF_COMPLEX32
)
3005 /* This is a type we can't handle, but we do know the size.
3006 We also will be able to give it a name. */
3007 return init_type (TYPE_CODE_ERROR
, nbytes
, 0, NULL
, objfile
);
3009 return init_type (TYPE_CODE_FLT
, nbytes
, 0, NULL
, objfile
);
3012 /* Read a number from the string pointed to by *PP.
3013 The value of *PP is advanced over the number.
3014 If END is nonzero, the character that ends the
3015 number must match END, or an error happens;
3016 and that character is skipped if it does match.
3017 If END is zero, *PP is left pointing to that character.
3019 If the number fits in a long, set *BITS to 0 and return the value.
3020 If not, set *BITS to be the number of bits in the number and return 0.
3022 If encounter garbage, set *BITS to -1 and return 0. */
3025 read_huge_number (pp
, end
, bits
)
3045 /* Leading zero means octal. GCC uses this to output values larger
3046 than an int (because that would be hard in decimal). */
3053 upper_limit
= LONG_MAX
/ radix
;
3054 while ((c
= *p
++) >= '0' && c
< ('0' + radix
))
3056 if (n
<= upper_limit
)
3059 n
+= c
- '0'; /* FIXME this overflows anyway */
3064 /* This depends on large values being output in octal, which is
3071 /* Ignore leading zeroes. */
3075 else if (c
== '2' || c
== '3')
3101 /* Large decimal constants are an error (because it is hard to
3102 count how many bits are in them). */
3108 /* -0x7f is the same as 0x80. So deal with it by adding one to
3109 the number of bits. */
3121 /* It's *BITS which has the interesting information. */
3125 static struct type
*
3126 read_range_type (pp
, typenums
, objfile
)
3129 struct objfile
*objfile
;
3135 struct type
*result_type
;
3136 struct type
*index_type
;
3138 /* First comes a type we are a subrange of.
3139 In C it is usually 0, 1 or the type being defined. */
3140 /* FIXME: according to stabs.texinfo and AIX doc, this can be a type-id
3141 not just a type number. */
3142 if (read_type_number (pp
, rangenums
) != 0)
3143 return error_type (pp
);
3144 self_subrange
= (rangenums
[0] == typenums
[0] &&
3145 rangenums
[1] == typenums
[1]);
3147 /* A semicolon should now follow; skip it. */
3151 /* The remaining two operands are usually lower and upper bounds
3152 of the range. But in some special cases they mean something else. */
3153 n2
= read_huge_number (pp
, ';', &n2bits
);
3154 n3
= read_huge_number (pp
, ';', &n3bits
);
3156 if (n2bits
== -1 || n3bits
== -1)
3157 return error_type (pp
);
3159 /* If limits are huge, must be large integral type. */
3160 if (n2bits
!= 0 || n3bits
!= 0)
3162 char got_signed
= 0;
3163 char got_unsigned
= 0;
3164 /* Number of bits in the type. */
3167 /* Range from 0 to <large number> is an unsigned large integral type. */
3168 if ((n2bits
== 0 && n2
== 0) && n3bits
!= 0)
3173 /* Range from <large number> to <large number>-1 is a large signed
3174 integral type. Take care of the case where <large number> doesn't
3175 fit in a long but <large number>-1 does. */
3176 else if ((n2bits
!= 0 && n3bits
!= 0 && n2bits
== n3bits
+ 1)
3177 || (n2bits
!= 0 && n3bits
== 0
3178 && (n2bits
== sizeof (long) * HOST_CHAR_BIT
)
3185 if (got_signed
|| got_unsigned
)
3187 return init_type (TYPE_CODE_INT
, nbits
/ TARGET_CHAR_BIT
,
3188 got_unsigned
? TYPE_FLAG_UNSIGNED
: 0, NULL
,
3192 return error_type (pp
);
3195 /* A type defined as a subrange of itself, with bounds both 0, is void. */
3196 if (self_subrange
&& n2
== 0 && n3
== 0)
3197 return init_type (TYPE_CODE_VOID
, 0, 0, NULL
, objfile
);
3199 /* If n3 is zero and n2 is not, we want a floating type,
3200 and n2 is the width in bytes.
3202 Fortran programs appear to use this for complex types also,
3203 and they give no way to distinguish between double and single-complex!
3205 GDB does not have complex types.
3207 Just return the complex as a float of that size. It won't work right
3208 for the complex values, but at least it makes the file loadable. */
3210 if (n3
== 0 && n2
> 0)
3212 return init_type (TYPE_CODE_FLT
, n2
, 0, NULL
, objfile
);
3215 /* If the upper bound is -1, it must really be an unsigned int. */
3217 else if (n2
== 0 && n3
== -1)
3219 /* It is unsigned int or unsigned long. */
3220 /* GCC 2.3.3 uses this for long long too, but that is just a GDB 3.5
3221 compatibility hack. */
3222 return init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
3223 TYPE_FLAG_UNSIGNED
, NULL
, objfile
);
3226 /* Special case: char is defined (Who knows why) as a subrange of
3227 itself with range 0-127. */
3228 else if (self_subrange
&& n2
== 0 && n3
== 127)
3229 return init_type (TYPE_CODE_INT
, 1, 0, NULL
, objfile
);
3231 /* We used to do this only for subrange of self or subrange of int. */
3235 /* n3 actually gives the size. */
3236 return init_type (TYPE_CODE_INT
, - n3
, TYPE_FLAG_UNSIGNED
,
3239 return init_type (TYPE_CODE_INT
, 1, TYPE_FLAG_UNSIGNED
, NULL
, objfile
);
3241 return init_type (TYPE_CODE_INT
, 2, TYPE_FLAG_UNSIGNED
, NULL
, objfile
);
3243 /* -1 is used for the upper bound of (4 byte) "unsigned int" and
3244 "unsigned long", and we already checked for that,
3245 so don't need to test for it here. */
3247 /* I think this is for Convex "long long". Since I don't know whether
3248 Convex sets self_subrange, I also accept that particular size regardless
3249 of self_subrange. */
3250 else if (n3
== 0 && n2
< 0
3252 || n2
== - TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
))
3253 return init_type (TYPE_CODE_INT
, - n2
, 0, NULL
, objfile
);
3254 else if (n2
== -n3
-1)
3257 return init_type (TYPE_CODE_INT
, 1, 0, NULL
, objfile
);
3259 return init_type (TYPE_CODE_INT
, 2, 0, NULL
, objfile
);
3260 if (n3
== 0x7fffffff)
3261 return init_type (TYPE_CODE_INT
, 4, 0, NULL
, objfile
);
3264 /* We have a real range type on our hands. Allocate space and
3265 return a real pointer. */
3267 /* At this point I don't have the faintest idea how to deal with
3268 a self_subrange type; I'm going to assume that this is used
3269 as an idiom, and that all of them are special cases. So . . . */
3271 return error_type (pp
);
3273 index_type
= *dbx_lookup_type (rangenums
);
3274 if (index_type
== NULL
)
3276 /* Does this actually ever happen? Is that why we are worrying
3277 about dealing with it rather than just calling error_type? */
3279 static struct type
*range_type_index
;
3281 complain (&range_type_base_complaint
, rangenums
[1]);
3282 if (range_type_index
== NULL
)
3284 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
3285 0, "range type index type", NULL
);
3286 index_type
= range_type_index
;
3289 result_type
= create_range_type ((struct type
*) NULL
, index_type
, n2
, n3
);
3290 return (result_type
);
3293 /* Read in an argument list. This is a list of types, separated by commas
3294 and terminated with END. Return the list of types read in, or (struct type
3295 **)-1 if there is an error. */
3297 static struct type
**
3298 read_args (pp
, end
, objfile
)
3301 struct objfile
*objfile
;
3303 /* FIXME! Remove this arbitrary limit! */
3304 struct type
*types
[1024], **rval
; /* allow for fns of 1023 parameters */
3310 /* Invalid argument list: no ','. */
3311 return (struct type
**)-1;
3313 STABS_CONTINUE (pp
);
3314 types
[n
++] = read_type (pp
, objfile
);
3316 (*pp
)++; /* get past `end' (the ':' character) */
3320 rval
= (struct type
**) xmalloc (2 * sizeof (struct type
*));
3322 else if (TYPE_CODE (types
[n
-1]) != TYPE_CODE_VOID
)
3324 rval
= (struct type
**) xmalloc ((n
+ 1) * sizeof (struct type
*));
3325 memset (rval
+ n
, 0, sizeof (struct type
*));
3329 rval
= (struct type
**) xmalloc (n
* sizeof (struct type
*));
3331 memcpy (rval
, types
, n
* sizeof (struct type
*));
3335 /* Common block handling. */
3337 /* List of symbols declared since the last BCOMM. This list is a tail
3338 of local_symbols. When ECOMM is seen, the symbols on the list
3339 are noted so their proper addresses can be filled in later,
3340 using the common block base address gotten from the assembler
3343 static struct pending
*common_block
;
3344 static int common_block_i
;
3346 /* Name of the current common block. We get it from the BCOMM instead of the
3347 ECOMM to match IBM documentation (even though IBM puts the name both places
3348 like everyone else). */
3349 static char *common_block_name
;
3351 /* Process a N_BCOMM symbol. The storage for NAME is not guaranteed
3352 to remain after this function returns. */
3355 common_block_start (name
, objfile
)
3357 struct objfile
*objfile
;
3359 if (common_block_name
!= NULL
)
3361 static struct complaint msg
= {
3362 "Invalid symbol data: common block within common block",
3366 common_block
= local_symbols
;
3367 common_block_i
= local_symbols
? local_symbols
->nsyms
: 0;
3368 common_block_name
= obsavestring (name
, strlen (name
),
3369 &objfile
-> symbol_obstack
);
3372 /* Process a N_ECOMM symbol. */
3375 common_block_end (objfile
)
3376 struct objfile
*objfile
;
3378 /* Symbols declared since the BCOMM are to have the common block
3379 start address added in when we know it. common_block and
3380 common_block_i point to the first symbol after the BCOMM in
3381 the local_symbols list; copy the list and hang it off the
3382 symbol for the common block name for later fixup. */
3385 struct pending
*new = 0;
3386 struct pending
*next
;
3389 if (common_block_name
== NULL
)
3391 static struct complaint msg
= {"ECOMM symbol unmatched by BCOMM", 0, 0};
3396 sym
= (struct symbol
*)
3397 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
3398 memset (sym
, 0, sizeof (struct symbol
));
3399 SYMBOL_NAME (sym
) = common_block_name
;
3400 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
3402 /* Now we copy all the symbols which have been defined since the BCOMM. */
3404 /* Copy all the struct pendings before common_block. */
3405 for (next
= local_symbols
;
3406 next
!= NULL
&& next
!= common_block
;
3409 for (j
= 0; j
< next
->nsyms
; j
++)
3410 add_symbol_to_list (next
->symbol
[j
], &new);
3413 /* Copy however much of COMMON_BLOCK we need. If COMMON_BLOCK is
3414 NULL, it means copy all the local symbols (which we already did
3417 if (common_block
!= NULL
)
3418 for (j
= common_block_i
; j
< common_block
->nsyms
; j
++)
3419 add_symbol_to_list (common_block
->symbol
[j
], &new);
3421 SYMBOL_NAMESPACE (sym
) = (enum namespace)((long) new);
3423 /* Should we be putting local_symbols back to what it was?
3426 i
= hashname (SYMBOL_NAME (sym
));
3427 SYMBOL_VALUE_CHAIN (sym
) = global_sym_chain
[i
];
3428 global_sym_chain
[i
] = sym
;
3429 common_block_name
= NULL
;
3432 /* Add a common block's start address to the offset of each symbol
3433 declared to be in it (by being between a BCOMM/ECOMM pair that uses
3434 the common block name). */
3437 fix_common_block (sym
, valu
)
3441 struct pending
*next
= (struct pending
*) SYMBOL_NAMESPACE (sym
);
3442 for ( ; next
; next
= next
->next
)
3445 for (j
= next
->nsyms
- 1; j
>= 0; j
--)
3446 SYMBOL_VALUE_ADDRESS (next
->symbol
[j
]) += valu
;
3452 /* What about types defined as forward references inside of a small lexical
3454 /* Add a type to the list of undefined types to be checked through
3455 once this file has been read in. */
3458 add_undefined_type (type
)
3461 if (undef_types_length
== undef_types_allocated
)
3463 undef_types_allocated
*= 2;
3464 undef_types
= (struct type
**)
3465 xrealloc ((char *) undef_types
,
3466 undef_types_allocated
* sizeof (struct type
*));
3468 undef_types
[undef_types_length
++] = type
;
3471 /* Go through each undefined type, see if it's still undefined, and fix it
3472 up if possible. We have two kinds of undefined types:
3474 TYPE_CODE_ARRAY: Array whose target type wasn't defined yet.
3475 Fix: update array length using the element bounds
3476 and the target type's length.
3477 TYPE_CODE_STRUCT, TYPE_CODE_UNION: Structure whose fields were not
3478 yet defined at the time a pointer to it was made.
3479 Fix: Do a full lookup on the struct/union tag. */
3481 cleanup_undefined_types ()
3485 for (type
= undef_types
; type
< undef_types
+ undef_types_length
; type
++)
3487 switch (TYPE_CODE (*type
))
3490 case TYPE_CODE_STRUCT
:
3491 case TYPE_CODE_UNION
:
3492 case TYPE_CODE_ENUM
:
3494 /* Check if it has been defined since. */
3495 if (TYPE_FLAGS (*type
) & TYPE_FLAG_STUB
)
3497 struct pending
*ppt
;
3499 /* Name of the type, without "struct" or "union" */
3500 char *typename
= TYPE_TAG_NAME (*type
);
3502 if (typename
== NULL
)
3504 static struct complaint msg
= {"need a type name", 0, 0};
3508 for (ppt
= file_symbols
; ppt
; ppt
= ppt
->next
)
3510 for (i
= 0; i
< ppt
->nsyms
; i
++)
3512 struct symbol
*sym
= ppt
->symbol
[i
];
3514 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
3515 && SYMBOL_NAMESPACE (sym
) == STRUCT_NAMESPACE
3516 && (TYPE_CODE (SYMBOL_TYPE (sym
)) ==
3518 && STREQ (SYMBOL_NAME (sym
), typename
))
3520 memcpy (*type
, SYMBOL_TYPE (sym
),
3521 sizeof (struct type
));
3529 case TYPE_CODE_ARRAY
:
3531 struct type
*range_type
;
3534 if (TYPE_LENGTH (*type
) != 0) /* Better be unknown */
3536 if (TYPE_NFIELDS (*type
) != 1)
3538 range_type
= TYPE_FIELD_TYPE (*type
, 0);
3539 if (TYPE_CODE (range_type
) != TYPE_CODE_RANGE
)
3542 /* Now recompute the length of the array type, based on its
3543 number of elements and the target type's length. */
3544 lower
= TYPE_FIELD_BITPOS (range_type
, 0);
3545 upper
= TYPE_FIELD_BITPOS (range_type
, 1);
3546 TYPE_LENGTH (*type
) = (upper
- lower
+ 1)
3547 * TYPE_LENGTH (TYPE_TARGET_TYPE (*type
));
3554 static struct complaint msg
= {"\
3555 GDB internal error. cleanup_undefined_types with bad type %d.", 0, 0};
3556 complain (&msg
, TYPE_CODE (*type
));
3561 undef_types_length
= 0;
3564 /* Scan through all of the global symbols defined in the object file,
3565 assigning values to the debugging symbols that need to be assigned
3566 to. Get these symbols from the minimal symbol table. */
3569 scan_file_globals (objfile
)
3570 struct objfile
*objfile
;
3573 struct minimal_symbol
*msymbol
;
3574 struct symbol
*sym
, *prev
;
3576 if (objfile
->msymbols
== 0) /* Beware the null file. */
3579 for (msymbol
= objfile
-> msymbols
; SYMBOL_NAME (msymbol
) != NULL
; msymbol
++)
3585 /* Get the hash index and check all the symbols
3586 under that hash index. */
3588 hash
= hashname (SYMBOL_NAME (msymbol
));
3590 for (sym
= global_sym_chain
[hash
]; sym
;)
3592 if (SYMBOL_NAME (msymbol
)[0] == SYMBOL_NAME (sym
)[0] &&
3593 STREQ(SYMBOL_NAME (msymbol
) + 1, SYMBOL_NAME (sym
) + 1))
3595 /* Splice this symbol out of the hash chain and
3596 assign the value we have to it. */
3599 SYMBOL_VALUE_CHAIN (prev
) = SYMBOL_VALUE_CHAIN (sym
);
3603 global_sym_chain
[hash
] = SYMBOL_VALUE_CHAIN (sym
);
3606 /* Check to see whether we need to fix up a common block. */
3607 /* Note: this code might be executed several times for
3608 the same symbol if there are multiple references. */
3610 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
3612 fix_common_block (sym
, SYMBOL_VALUE_ADDRESS (msymbol
));
3616 SYMBOL_VALUE_ADDRESS (sym
) = SYMBOL_VALUE_ADDRESS (msymbol
);
3621 sym
= SYMBOL_VALUE_CHAIN (prev
);
3625 sym
= global_sym_chain
[hash
];
3631 sym
= SYMBOL_VALUE_CHAIN (sym
);
3637 /* Initialize anything that needs initializing when starting to read
3638 a fresh piece of a symbol file, e.g. reading in the stuff corresponding
3646 /* Initialize anything that needs initializing when a completely new
3647 symbol file is specified (not just adding some symbols from another
3648 file, e.g. a shared library). */
3651 stabsread_new_init ()
3653 /* Empty the hash table of global syms looking for values. */
3654 memset (global_sym_chain
, 0, sizeof (global_sym_chain
));
3657 /* Initialize anything that needs initializing at the same time as
3658 start_symtab() is called. */
3662 global_stabs
= NULL
; /* AIX COFF */
3663 /* Leave FILENUM of 0 free for builtin types and this file's types. */
3664 n_this_object_header_files
= 1;
3665 type_vector_length
= 0;
3666 type_vector
= (struct type
**) 0;
3668 /* FIXME: If common_block_name is not already NULL, we should complain(). */
3669 common_block_name
= NULL
;
3672 /* Call after end_symtab() */
3678 free ((char *) type_vector
);
3681 type_vector_length
= 0;
3682 previous_stab_code
= 0;
3686 finish_global_stabs (objfile
)
3687 struct objfile
*objfile
;
3691 patch_block_stabs (global_symbols
, global_stabs
, objfile
);
3692 free ((PTR
) global_stabs
);
3693 global_stabs
= NULL
;
3697 /* Initializer for this module */
3700 _initialize_stabsread ()
3702 undef_types_allocated
= 20;
3703 undef_types_length
= 0;
3704 undef_types
= (struct type
**)
3705 xmalloc (undef_types_allocated
* sizeof (struct type
*));