1 /* Support routines for decoding "stabs" debugging information format.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
21 /* Support routines for reading and decoding debugging information in
22 the "stabs" format. This format is used with many systems that use
23 the a.out object file format, as well as some systems that use
24 COFF or ELF where the stabs data is placed in a special section.
25 Avoid placing any object file format specific code in this file. */
32 #include "symfile.h" /* Needed for "struct complaint" */
34 #include "aout/stab_gnu.h" /* We always use GNU stabs, not native */
37 /* Ask stabsread.h to define the vars it normally declares `extern'. */
39 #include "stabsread.h" /* Our own declarations */
43 dbx_alloc_type
PARAMS ((int [2], struct objfile
*));
46 read_huge_number
PARAMS ((char **, int, long *, int *));
49 patch_block_stabs
PARAMS ((struct pending
*, struct pending_stabs
*,
53 fix_common_block
PARAMS ((struct symbol
*, int));
56 read_range_type
PARAMS ((char **, int [2], struct objfile
*));
59 read_sun_builtin_type
PARAMS ((char **, int [2], struct objfile
*));
62 read_sun_floating_type
PARAMS ((char **, int [2], struct objfile
*));
65 read_enum_type
PARAMS ((char **, struct type
*, struct objfile
*));
68 read_struct_type
PARAMS ((char **, struct type
*, struct objfile
*));
71 read_array_type
PARAMS ((char **, struct type
*, struct objfile
*));
74 read_args
PARAMS ((char **, int, struct objfile
*));
76 static const char vptr_name
[] = { '_','v','p','t','r',CPLUS_MARKER
,'\0' };
77 static const char vb_name
[] = { '_','v','b',CPLUS_MARKER
,'\0' };
79 /* Define this as 1 if a pcc declaration of a char or short argument
80 gives the correct address. Otherwise assume pcc gives the
81 address of the corresponding int, which is not the same on a
82 big-endian machine. */
84 #ifndef BELIEVE_PCC_PROMOTION
85 #define BELIEVE_PCC_PROMOTION 0
88 /* During some calls to read_type (and thus to read_range_type), this
89 contains the name of the type being defined. Range types are only
90 used in C as basic types. We use the name to distinguish the otherwise
91 identical basic types "int" and "long" and their unsigned versions.
92 FIXME, this should disappear with better type management. */
94 static char *long_kludge_name
;
97 struct complaint dbx_class_complaint
=
99 "encountered DBX-style class variable debugging information.\n\
100 You seem to have compiled your program with \
101 \"g++ -g0\" instead of \"g++ -g\".\n\
102 Therefore GDB will not know about your class variables", 0, 0
106 struct complaint invalid_cpp_abbrev_complaint
=
107 {"invalid C++ abbreviation `%s'", 0, 0};
109 struct complaint invalid_cpp_type_complaint
=
110 {"C++ abbreviated type name unknown at symtab pos %d", 0, 0};
112 struct complaint member_fn_complaint
=
113 {"member function type missing, got '%c'", 0, 0};
115 struct complaint const_vol_complaint
=
116 {"const/volatile indicator missing, got '%c'", 0, 0};
118 struct complaint error_type_complaint
=
119 {"debug info mismatch between compiler and debugger", 0, 0};
121 struct complaint invalid_member_complaint
=
122 {"invalid (minimal) member type data format at symtab pos %d.", 0, 0};
124 struct complaint range_type_base_complaint
=
125 {"base type %d of range type is not defined", 0, 0};
127 struct complaint reg_value_complaint
=
128 {"register number too large in symbol %s", 0, 0};
130 /* Make a list of forward references which haven't been defined. */
132 static struct type
**undef_types
;
133 static int undef_types_allocated
;
134 static int undef_types_length
;
141 register char *p
= name
;
142 register int total
= p
[0];
157 /* Ensure result is positive. */
160 total
+= (1000 << 6);
162 return (total
% HASHSIZE
);
166 /* Look up a dbx type-number pair. Return the address of the slot
167 where the type for that number-pair is stored.
168 The number-pair is in TYPENUMS.
170 This can be used for finding the type associated with that pair
171 or for associating a new type with the pair. */
174 dbx_lookup_type (typenums
)
177 register int filenum
= typenums
[0];
178 register int index
= typenums
[1];
180 register int real_filenum
;
181 register struct header_file
*f
;
184 if (filenum
== -1) /* -1,-1 is for temporary types. */
187 if (filenum
< 0 || filenum
>= n_this_object_header_files
)
188 error ("Invalid symbol data: type number (%d,%d) out of range at symtab pos %d.",
189 filenum
, index
, symnum
);
193 /* Type is defined outside of header files.
194 Find it in this object file's type vector. */
195 if (index
>= type_vector_length
)
197 old_len
= type_vector_length
;
200 type_vector_length
= INITIAL_TYPE_VECTOR_LENGTH
;
201 type_vector
= (struct type
**)
202 malloc (type_vector_length
* sizeof (struct type
*));
204 while (index
>= type_vector_length
)
206 type_vector_length
*= 2;
208 type_vector
= (struct type
**)
209 xrealloc ((char *) type_vector
,
210 (type_vector_length
* sizeof (struct type
*)));
211 memset (&type_vector
[old_len
], 0,
212 (type_vector_length
- old_len
) * sizeof (struct type
*));
214 return (&type_vector
[index
]);
218 real_filenum
= this_object_header_files
[filenum
];
220 if (real_filenum
>= n_header_files
)
225 f
= &header_files
[real_filenum
];
227 f_orig_length
= f
->length
;
228 if (index
>= f_orig_length
)
230 while (index
>= f
->length
)
234 f
->vector
= (struct type
**)
235 xrealloc ((char *) f
->vector
, f
->length
* sizeof (struct type
*));
236 memset (&f
->vector
[f_orig_length
], 0,
237 (f
->length
- f_orig_length
) * sizeof (struct type
*));
239 return (&f
->vector
[index
]);
243 /* Make sure there is a type allocated for type numbers TYPENUMS
244 and return the type object.
245 This can create an empty (zeroed) type object.
246 TYPENUMS may be (-1, -1) to return a new type object that is not
247 put into the type vector, and so may not be referred to by number. */
250 dbx_alloc_type (typenums
, objfile
)
252 struct objfile
*objfile
;
254 register struct type
**type_addr
;
256 if (typenums
[0] == -1)
258 return (alloc_type (objfile
));
261 type_addr
= dbx_lookup_type (typenums
);
263 /* If we are referring to a type not known at all yet,
264 allocate an empty type for it.
265 We will fill it in later if we find out how. */
268 *type_addr
= alloc_type (objfile
);
274 /* for all the stabs in a given stab vector, build appropriate types
275 and fix their symbols in given symbol vector. */
278 patch_block_stabs (symbols
, stabs
, objfile
)
279 struct pending
*symbols
;
280 struct pending_stabs
*stabs
;
281 struct objfile
*objfile
;
291 /* for all the stab entries, find their corresponding symbols and
292 patch their types! */
294 for (ii
= 0; ii
< stabs
->count
; ++ii
)
296 name
= stabs
->stab
[ii
];
297 pp
= (char*) strchr (name
, ':');
298 sym
= find_symbol_in_list (symbols
, name
, pp
-name
);
301 #ifndef IBM6000_TARGET
302 printf ("ERROR! stab symbol not found!\n"); /* FIXME */
308 if (*(pp
-1) == 'F' || *(pp
-1) == 'f')
311 lookup_function_type (read_type (&pp
, objfile
));
315 SYMBOL_TYPE (sym
) = read_type (&pp
, objfile
);
323 /* Read a number by which a type is referred to in dbx data,
324 or perhaps read a pair (FILENUM, TYPENUM) in parentheses.
325 Just a single number N is equivalent to (0,N).
326 Return the two numbers by storing them in the vector TYPENUMS.
327 TYPENUMS will then be used as an argument to dbx_lookup_type. */
330 read_type_number (pp
, typenums
)
332 register int *typenums
;
337 typenums
[0] = read_number (pp
, ',');
338 typenums
[1] = read_number (pp
, ')');
343 typenums
[1] = read_number (pp
, 0);
348 /* To handle GNU C++ typename abbreviation, we need to be able to
349 fill in a type's name as soon as space for that type is allocated.
350 `type_synonym_name' is the name of the type being allocated.
351 It is cleared as soon as it is used (lest all allocated types
354 static char *type_synonym_name
;
358 define_symbol (valu
, string
, desc
, type
, objfile
)
363 struct objfile
*objfile
;
365 register struct symbol
*sym
;
366 char *p
= (char *) strchr (string
, ':');
370 struct type
*temptype
;
372 /* We would like to eliminate nameless symbols, but keep their types.
373 E.g. stab entry ":t10=*2" should produce a type 10, which is a pointer
374 to type 2, but, should not creat a symbol to address that type. Since
375 the symbol will be nameless, there is no way any user can refer to it. */
379 /* Ignore syms with empty names. */
383 /* Ignore old-style symbols from cc -go */
387 /* If a nameless stab entry, all we need is the type, not the symbol.
389 nameless
= (p
== string
);
391 sym
= (struct symbol
*)
392 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
393 memset (sym
, 0, sizeof (struct symbol
));
395 if (processing_gcc_compilation
)
397 /* GCC 2.x puts the line number in desc. SunOS apparently puts in the
398 number of bytes occupied by a type or object, which we ignore. */
399 SYMBOL_LINE(sym
) = desc
;
403 SYMBOL_LINE(sym
) = 0; /* unknown */
406 if (string
[0] == CPLUS_MARKER
)
408 /* Special GNU C++ names. */
412 SYMBOL_NAME (sym
) = obsavestring ("this", strlen ("this"),
413 &objfile
-> symbol_obstack
);
416 case 'v': /* $vtbl_ptr_type */
417 /* Was: SYMBOL_NAME (sym) = "vptr"; */
421 SYMBOL_NAME (sym
) = obsavestring ("eh_throw", strlen ("eh_throw"),
422 &objfile
-> symbol_obstack
);
426 /* This was an anonymous type that was never fixed up. */
436 SYMBOL_NAME (sym
) = (char *)
437 obstack_alloc (&objfile
-> symbol_obstack
, ((p
- string
) + 1));
438 /* Open-coded bcopy--saves function call time. */
440 register char *p1
= string
;
441 register char *p2
= SYMBOL_NAME (sym
);
450 /* Determine the type of name being defined. */
451 /* The Acorn RISC machine's compiler can put out locals that don't
452 start with "234=" or "(3,4)=", so assume anything other than the
453 deftypes we know how to handle is a local. */
454 /* (Peter Watkins @ Computervision)
455 Handle Sun-style local fortran array types 'ar...' .
456 (gnu@cygnus.com) -- this strchr() handles them properly?
457 (tiemann@cygnus.com) -- 'C' is for catch. */
459 #ifdef IBM6000_TARGET
461 /* 'R' is for register parameters. */
463 if (!strchr ("cfFGpPrStTvVXCR", *p
))
467 if (!strchr ("cfFGpPrStTvVXC", *p
))
474 /* c is a special case, not followed by a type-number.
475 SYMBOL:c=iVALUE for an integer constant symbol.
476 SYMBOL:c=rVALUE for a floating constant symbol.
477 SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
478 e.g. "b:c=e6,0" for "const b = blob1"
479 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
483 error ("Invalid symbol data at symtab pos %d.", symnum
);
491 SYMBOL_TYPE (sym
) = lookup_fundamental_type (objfile
,
494 obstack_alloc (&objfile
-> type_obstack
, sizeof (double));
495 memcpy (dbl_valu
, &d
, sizeof (double));
496 SWAP_TARGET_AND_HOST (dbl_valu
, sizeof (double));
497 SYMBOL_VALUE_BYTES (sym
) = dbl_valu
;
498 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
503 SYMBOL_TYPE (sym
) = lookup_fundamental_type (objfile
,
505 SYMBOL_VALUE (sym
) = atoi (p
);
506 SYMBOL_CLASS (sym
) = LOC_CONST
;
510 /* SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
511 e.g. "b:c=e6,0" for "const b = blob1"
512 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
516 read_type_number (&p
, typenums
);
518 error ("Invalid symbol data: no comma in enum const symbol");
520 SYMBOL_TYPE (sym
) = *dbx_lookup_type (typenums
);
521 SYMBOL_VALUE (sym
) = atoi (p
);
522 SYMBOL_CLASS (sym
) = LOC_CONST
;
526 error ("Invalid symbol data at symtab pos %d.", symnum
);
528 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
529 add_symbol_to_list (sym
, &file_symbols
);
533 /* Now usually comes a number that says which data type,
534 and possibly more stuff to define the type
535 (all of which is handled by read_type) */
537 if (deftype
== 'p' && *p
== 'F')
538 /* pF is a two-letter code that means a function parameter in Fortran.
539 The type-number specifies the type of the return value.
540 Translate it into a pointer-to-function type. */
544 = lookup_pointer_type (lookup_function_type (read_type (&p
, objfile
)));
547 #ifdef IBM6000_TARGET
548 else if (deftype
== 'R')
549 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
554 /* The symbol class letter is followed by a type (typically the
555 type of the symbol, or its return-type, or etc). Read it. */
562 type_synonym_name
= obsavestring (SYMBOL_NAME (sym
),
563 strlen (SYMBOL_NAME (sym
)),
564 &objfile
-> symbol_obstack
);
567 /* Here we save the name of the symbol for read_range_type, which
568 ends up reading in the basic types. In stabs, unfortunately there
569 is no distinction between "int" and "long" types except their
570 names. Until we work out a saner type policy (eliminating most
571 builtin types and using the names specified in the files), we
572 save away the name so that far away from here in read_range_type,
573 we can examine it to decide between "int" and "long". FIXME. */
574 long_kludge_name
= SYMBOL_NAME (sym
);
576 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
582 /* The name of a caught exception. */
583 SYMBOL_CLASS (sym
) = LOC_LABEL
;
584 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
585 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
586 add_symbol_to_list (sym
, &local_symbols
);
590 /* A static function definition. */
591 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
592 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
593 add_symbol_to_list (sym
, &file_symbols
);
594 /* fall into process_function_types. */
596 process_function_types
:
597 /* Function result types are described as the result type in stabs.
598 We need to convert this to the function-returning-type-X type
599 in GDB. E.g. "int" is converted to "function returning int". */
600 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_FUNC
)
603 /* This code doesn't work -- it needs to realloc and can't. */
604 /* Attempt to set up to record a function prototype... */
605 struct type
*new = (struct type
*)
606 obstack_alloc (&objfile
-> type_obstack
, sizeof (struct type
));
608 /* Generate a template for the type of this function. The
609 types of the arguments will be added as we read the symbol
611 *new = *lookup_function_type (SYMBOL_TYPE(sym
));
612 SYMBOL_TYPE(sym
) = new;
613 TYPE_OBJFILE (new) = objfile
;
614 in_function_type
= new;
616 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
619 /* fall into process_prototype_types */
621 process_prototype_types
:
622 /* Sun acc puts declared types of arguments here. We don't care
623 about their actual types (FIXME -- we should remember the whole
624 function prototype), but the list may define some new types
625 that we have to remember, so we must scan it now. */
628 read_type (&p
, objfile
);
633 /* A global function definition. */
634 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
635 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
636 add_symbol_to_list (sym
, &global_symbols
);
637 goto process_function_types
;
640 /* For a class G (global) symbol, it appears that the
641 value is not correct. It is necessary to search for the
642 corresponding linker definition to find the value.
643 These definitions appear at the end of the namelist. */
644 i
= hashname (SYMBOL_NAME (sym
));
645 SYMBOL_VALUE_CHAIN (sym
) = global_sym_chain
[i
];
646 global_sym_chain
[i
] = sym
;
647 SYMBOL_CLASS (sym
) = LOC_STATIC
;
648 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
649 add_symbol_to_list (sym
, &global_symbols
);
652 /* This case is faked by a conditional above,
653 when there is no code letter in the dbx data.
654 Dbx data never actually contains 'l'. */
656 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
657 SYMBOL_VALUE (sym
) = valu
;
658 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
659 add_symbol_to_list (sym
, &local_symbols
);
663 /* Normally this is a parameter, a LOC_ARG. On the i960, it
664 can also be a LOC_LOCAL_ARG depending on symbol type. */
665 #ifndef DBX_PARM_SYMBOL_CLASS
666 #define DBX_PARM_SYMBOL_CLASS(type) LOC_ARG
668 SYMBOL_CLASS (sym
) = DBX_PARM_SYMBOL_CLASS (type
);
669 SYMBOL_VALUE (sym
) = valu
;
670 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
672 /* This doesn't work yet. */
673 add_param_to_type (&in_function_type
, sym
);
675 add_symbol_to_list (sym
, &local_symbols
);
677 /* If it's gcc-compiled, if it says `short', believe it. */
678 if (processing_gcc_compilation
|| BELIEVE_PCC_PROMOTION
)
681 #if defined(BELIEVE_PCC_PROMOTION_TYPE)
682 /* This macro is defined on machines (e.g. sparc) where
683 we should believe the type of a PCC 'short' argument,
684 but shouldn't believe the address (the address is
685 the address of the corresponding int). Note that
686 this is only different from the BELIEVE_PCC_PROMOTION
687 case on big-endian machines.
689 My guess is that this correction, as opposed to changing
690 the parameter to an 'int' (as done below, for PCC
691 on most machines), is the right thing to do
692 on all machines, but I don't want to risk breaking
693 something that already works. On most PCC machines,
694 the sparc problem doesn't come up because the calling
695 function has to zero the top bytes (not knowing whether
696 the called function wants an int or a short), so there
697 is no practical difference between an int and a short
698 (except perhaps what happens when the GDB user types
699 "print short_arg = 0x10000;").
701 Hacked for SunOS 4.1 by gnu@cygnus.com. In 4.1, the compiler
702 actually produces the correct address (we don't need to fix it
703 up). I made this code adapt so that it will offset the symbol
704 if it was pointing at an int-aligned location and not
705 otherwise. This way you can use the same gdb for 4.0.x and
708 If the parameter is shorter than an int, and is integral
709 (e.g. char, short, or unsigned equivalent), and is claimed to
710 be passed on an integer boundary, don't believe it! Offset the
711 parameter's address to the tail-end of that integer. */
713 temptype
= lookup_fundamental_type (objfile
, FT_INTEGER
);
714 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (temptype
)
715 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
716 && 0 == SYMBOL_VALUE (sym
) % TYPE_LENGTH (temptype
))
718 SYMBOL_VALUE (sym
) += TYPE_LENGTH (temptype
)
719 - TYPE_LENGTH (SYMBOL_TYPE (sym
));
723 #else /* no BELIEVE_PCC_PROMOTION_TYPE. */
725 /* If PCC says a parameter is a short or a char,
726 it is really an int. */
727 temptype
= lookup_fundamental_type (objfile
, FT_INTEGER
);
728 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (temptype
)
729 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
)
731 SYMBOL_TYPE (sym
) = TYPE_UNSIGNED (SYMBOL_TYPE (sym
))
732 ? lookup_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
)
737 #endif /* no BELIEVE_PCC_PROMOTION_TYPE. */
740 /* acc seems to use P to delare the prototypes of functions that
741 are referenced by this file. gdb is not prepared to deal
742 with this extra information. FIXME, it ought to. */
744 goto process_prototype_types
;
746 /* Parameter which is in a register. */
747 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
748 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (valu
);
749 if (SYMBOL_VALUE (sym
) >= NUM_REGS
)
751 complain (®_value_complaint
, SYMBOL_NAME (sym
));
752 SYMBOL_VALUE (sym
) = SP_REGNUM
; /* Known safe, though useless */
754 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
755 add_symbol_to_list (sym
, &local_symbols
);
758 #ifdef IBM6000_TARGET
762 /* Register variable (either global or local). */
763 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
764 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (valu
);
765 if (SYMBOL_VALUE (sym
) >= NUM_REGS
)
767 complain (®_value_complaint
, SYMBOL_NAME (sym
));
768 SYMBOL_VALUE (sym
) = SP_REGNUM
; /* Known safe, though useless */
770 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
772 add_symbol_to_list (sym
, &local_symbols
);
774 add_symbol_to_list (sym
, &file_symbols
);
778 /* Static symbol at top level of file */
779 SYMBOL_CLASS (sym
) = LOC_STATIC
;
780 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
781 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
782 add_symbol_to_list (sym
, &file_symbols
);
786 /* For a nameless type, we don't want a create a symbol, thus we
787 did not use `sym'. Return without further processing. */
788 if (nameless
) return NULL
;
790 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
791 SYMBOL_VALUE (sym
) = valu
;
792 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
793 /* C++ vagaries: we may have a type which is derived from
794 a base type which did not have its name defined when the
795 derived class was output. We fill in the derived class's
796 base part member's name here in that case. */
797 if (TYPE_NAME (SYMBOL_TYPE (sym
)) != NULL
)
798 if ((TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
799 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_UNION
)
800 && TYPE_N_BASECLASSES (SYMBOL_TYPE (sym
)))
803 for (j
= TYPE_N_BASECLASSES (SYMBOL_TYPE (sym
)) - 1; j
>= 0; j
--)
804 if (TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym
), j
) == 0)
805 TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym
), j
) =
806 type_name_no_tag (TYPE_BASECLASS (SYMBOL_TYPE (sym
), j
));
809 add_symbol_to_list (sym
, &file_symbols
);
813 /* For a nameless type, we don't want a create a symbol, thus we
814 did not use `sym'. Return without further processing. */
815 if (nameless
) return NULL
;
817 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
818 SYMBOL_VALUE (sym
) = valu
;
819 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
820 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
821 TYPE_NAME (SYMBOL_TYPE (sym
))
822 = obconcat (&objfile
-> type_obstack
, "",
823 (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_ENUM
825 : (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
826 ? "struct " : "union ")),
828 add_symbol_to_list (sym
, &file_symbols
);
832 register struct symbol
*typedef_sym
= (struct symbol
*)
833 obstack_alloc (&objfile
-> type_obstack
, sizeof (struct symbol
));
834 memset (typedef_sym
, 0, sizeof (struct symbol
));
835 SYMBOL_NAME (typedef_sym
) = SYMBOL_NAME (sym
);
836 SYMBOL_TYPE (typedef_sym
) = SYMBOL_TYPE (sym
);
838 SYMBOL_CLASS (typedef_sym
) = LOC_TYPEDEF
;
839 SYMBOL_VALUE (typedef_sym
) = valu
;
840 SYMBOL_NAMESPACE (typedef_sym
) = VAR_NAMESPACE
;
841 add_symbol_to_list (typedef_sym
, &file_symbols
);
846 /* Static symbol of local scope */
847 SYMBOL_CLASS (sym
) = LOC_STATIC
;
848 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
849 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
850 add_symbol_to_list (sym
, &local_symbols
);
854 /* Reference parameter */
855 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
856 SYMBOL_VALUE (sym
) = valu
;
857 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
858 add_symbol_to_list (sym
, &local_symbols
);
862 /* This is used by Sun FORTRAN for "function result value".
863 Sun claims ("dbx and dbxtool interfaces", 2nd ed)
864 that Pascal uses it too, but when I tried it Pascal used
865 "x:3" (local symbol) instead. */
866 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
867 SYMBOL_VALUE (sym
) = valu
;
868 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
869 add_symbol_to_list (sym
, &local_symbols
);
873 error ("Invalid symbol data: unknown symbol-type code `%c' at symtab pos %d.", deftype
, symnum
);
879 /* Skip rest of this symbol and return an error type.
881 General notes on error recovery: error_type always skips to the
882 end of the symbol (modulo cretinous dbx symbol name continuation).
886 return error_type (pp);
888 is wrong because if *pp starts out pointing at '\0' (typically as the
889 result of an earlier error), it will be incremented to point to the
890 start of the next symbol, which might produce strange results, at least
891 if you run off the end of the string table. Instead use
894 return error_type (pp);
900 foo = error_type (pp);
904 And in case it isn't obvious, the point of all this hair is so the compiler
905 can define new types and new syntaxes, and old versions of the
906 debugger will be able to read the new symbol tables. */
912 complain (&error_type_complaint
, 0);
915 /* Skip to end of symbol. */
919 /* Check for and handle cretinous dbx symbol name continuation! */
920 if ((*pp
)[-1] == '\\')
921 *pp
= next_symbol_text ();
925 return builtin_type_error
;
929 /* Read a dbx type reference or definition;
930 return the type that is meant.
931 This can be just a number, in which case it references
932 a type already defined and placed in type_vector.
933 Or the number can be followed by an =, in which case
934 it means to define a new type according to the text that
938 read_type (pp
, objfile
)
940 struct objfile
*objfile
;
942 register struct type
*type
= 0;
947 /* Read type number if present. The type number may be omitted.
948 for instance in a two-dimensional array declared with type
949 "ar1;1;10;ar1;1;10;4". */
950 if ((**pp
>= '0' && **pp
<= '9')
953 read_type_number (pp
, typenums
);
955 /* Type is not being defined here. Either it already exists,
956 or this is a forward reference to it. dbx_alloc_type handles
959 return dbx_alloc_type (typenums
, objfile
);
961 /* Type is being defined here. */
962 #if 0 /* Callers aren't prepared for a NULL result! FIXME -- metin! */
966 /* if such a type already exists, this is an unnecessary duplication
967 of the stab string, which is common in (RS/6000) xlc generated
968 objects. In that case, simply return NULL and let the caller take
971 tt
= *dbx_lookup_type (typenums
);
972 if (tt
&& tt
->length
&& tt
->code
)
981 /* 'typenums=' not present, type is anonymous. Read and return
982 the definition, but don't put it in the type vector. */
983 typenums
[0] = typenums
[1] = -1;
993 /* Used to index through file_symbols. */
997 /* Name including "struct", etc. */
1000 /* Name without "struct", etc. */
1001 char *type_name_only
;
1007 /* Set the type code according to the following letter. */
1011 code
= TYPE_CODE_STRUCT
;
1015 code
= TYPE_CODE_UNION
;
1019 code
= TYPE_CODE_ENUM
;
1023 return error_type (pp
);
1026 to
= type_name
= (char *)
1027 obstack_alloc (&objfile
-> type_obstack
,
1029 ((char *) strchr (*pp
, ':') - (*pp
)) + 1));
1031 /* Copy the prefix. */
1033 while (*to
++ = *from
++)
1037 type_name_only
= to
;
1039 /* Copy the name. */
1041 while ((*to
++ = *from
++) != ':')
1045 /* Set the pointer ahead of the name which we just read. */
1049 /* The following hack is clearly wrong, because it doesn't
1050 check whether we are in a baseclass. I tried to reproduce
1051 the case that it is trying to fix, but I couldn't get
1052 g++ to put out a cross reference to a basetype. Perhaps
1053 it doesn't do it anymore. */
1054 /* Note: for C++, the cross reference may be to a base type which
1055 has not yet been seen. In this case, we skip to the comma,
1056 which will mark the end of the base class name. (The ':'
1057 at the end of the base class name will be skipped as well.)
1058 But sometimes (ie. when the cross ref is the last thing on
1059 the line) there will be no ','. */
1060 from
= (char *) strchr (*pp
, ',');
1066 /* Now check to see whether the type has already been declared. */
1067 /* This is necessary at least in the case where the
1068 program says something like
1070 The compiler puts out a cross-reference; we better find
1071 set the length of the structure correctly so we can
1072 set the length of the array. */
1073 for (ppt
= file_symbols
; ppt
; ppt
= ppt
->next
)
1074 for (i
= 0; i
< ppt
->nsyms
; i
++)
1076 struct symbol
*sym
= ppt
->symbol
[i
];
1078 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
1079 && SYMBOL_NAMESPACE (sym
) == STRUCT_NAMESPACE
1080 && (TYPE_CODE (SYMBOL_TYPE (sym
)) == code
)
1081 && !strcmp (SYMBOL_NAME (sym
), type_name_only
))
1083 obstack_free (&objfile
-> type_obstack
, type_name
);
1084 type
= SYMBOL_TYPE (sym
);
1089 /* Didn't find the type to which this refers, so we must
1090 be dealing with a forward reference. Allocate a type
1091 structure for it, and keep track of it so we can
1092 fill in the rest of the fields when we get the full
1094 type
= dbx_alloc_type (typenums
, objfile
);
1095 TYPE_CODE (type
) = code
;
1096 TYPE_NAME (type
) = type_name
;
1097 INIT_CPLUS_SPECIFIC(type
);
1098 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
1100 add_undefined_type (type
);
1104 case '-': /* RS/6000 built-in type */
1106 type
= builtin_type (pp
); /* (in xcoffread.c) */
1121 read_type_number (pp
, xtypenums
);
1122 type
= *dbx_lookup_type (xtypenums
);
1127 type
= lookup_fundamental_type (objfile
, FT_VOID
);
1128 if (typenums
[0] != -1)
1129 *dbx_lookup_type (typenums
) = type
;
1132 /* In the following types, we must be sure to overwrite any existing
1133 type that the typenums refer to, rather than allocating a new one
1134 and making the typenums point to the new one. This is because there
1135 may already be pointers to the existing type (if it had been
1136 forward-referenced), and we must change it to a pointer, function,
1137 reference, or whatever, *in-place*. */
1140 type1
= read_type (pp
, objfile
);
1141 type
= make_pointer_type (type1
, dbx_lookup_type (typenums
));
1144 case '&': /* Reference to another type */
1145 type1
= read_type (pp
, objfile
);
1146 type
= make_reference_type (type1
, dbx_lookup_type (typenums
));
1149 case 'f': /* Function returning another type */
1150 type1
= read_type (pp
, objfile
);
1151 type
= make_function_type (type1
, dbx_lookup_type (typenums
));
1154 case 'k': /* Const qualifier on some type (Sun) */
1155 type
= read_type (pp
, objfile
);
1156 /* FIXME! For now, we ignore const and volatile qualifiers. */
1159 case 'B': /* Volatile qual on some type (Sun) */
1160 type
= read_type (pp
, objfile
);
1161 /* FIXME! For now, we ignore const and volatile qualifiers. */
1164 /* FIXME -- we should be doing smash_to_XXX types here. */
1165 case '@': /* Member (class & variable) type */
1167 struct type
*domain
= read_type (pp
, objfile
);
1168 struct type
*memtype
;
1171 /* Invalid member type data format. */
1172 return error_type (pp
);
1175 memtype
= read_type (pp
, objfile
);
1176 type
= dbx_alloc_type (typenums
, objfile
);
1177 smash_to_member_type (type
, domain
, memtype
);
1181 case '#': /* Method (class & fn) type */
1182 if ((*pp
)[0] == '#')
1184 /* We'll get the parameter types from the name. */
1185 struct type
*return_type
;
1188 return_type
= read_type (pp
, objfile
);
1189 if (*(*pp
)++ != ';')
1190 complain (&invalid_member_complaint
, (char *) symnum
);
1191 type
= allocate_stub_method (return_type
);
1192 if (typenums
[0] != -1)
1193 *dbx_lookup_type (typenums
) = type
;
1197 struct type
*domain
= read_type (pp
, objfile
);
1198 struct type
*return_type
;
1201 if (*(*pp
)++ != ',')
1202 error ("invalid member type data format, at symtab pos %d.",
1205 return_type
= read_type (pp
, objfile
);
1206 args
= read_args (pp
, ';', objfile
);
1207 type
= dbx_alloc_type (typenums
, objfile
);
1208 smash_to_method_type (type
, domain
, return_type
, args
);
1212 case 'r': /* Range type */
1213 type
= read_range_type (pp
, typenums
, objfile
);
1214 if (typenums
[0] != -1)
1215 *dbx_lookup_type (typenums
) = type
;
1218 case 'b': /* Sun ACC builtin int type */
1219 type
= read_sun_builtin_type (pp
, typenums
, objfile
);
1220 if (typenums
[0] != -1)
1221 *dbx_lookup_type (typenums
) = type
;
1224 case 'R': /* Sun ACC builtin float type */
1225 type
= read_sun_floating_type (pp
, typenums
, objfile
);
1226 if (typenums
[0] != -1)
1227 *dbx_lookup_type (typenums
) = type
;
1230 case 'e': /* Enumeration type */
1231 type
= dbx_alloc_type (typenums
, objfile
);
1232 type
= read_enum_type (pp
, type
, objfile
);
1233 *dbx_lookup_type (typenums
) = type
;
1236 case 's': /* Struct type */
1237 type
= dbx_alloc_type (typenums
, objfile
);
1238 if (!TYPE_NAME (type
))
1239 TYPE_NAME (type
) = type_synonym_name
;
1240 type_synonym_name
= 0;
1241 type
= read_struct_type (pp
, type
, objfile
);
1244 case 'u': /* Union type */
1245 type
= dbx_alloc_type (typenums
, objfile
);
1246 if (!TYPE_NAME (type
))
1247 TYPE_NAME (type
) = type_synonym_name
;
1248 type_synonym_name
= 0;
1249 type
= read_struct_type (pp
, type
, objfile
);
1250 TYPE_CODE (type
) = TYPE_CODE_UNION
;
1253 case 'a': /* Array type */
1255 return error_type (pp
);
1258 type
= dbx_alloc_type (typenums
, objfile
);
1259 type
= read_array_type (pp
, type
, objfile
);
1263 --*pp
; /* Go back to the symbol in error */
1264 /* Particularly important if it was \0! */
1265 return error_type (pp
);
1274 /* This page contains subroutines of read_type. */
1276 /* Read the description of a structure (or union type)
1277 and return an object describing the type. */
1279 static struct type
*
1280 read_struct_type (pp
, type
, objfile
)
1282 register struct type
*type
;
1283 struct objfile
*objfile
;
1285 /* Total number of methods defined in this class.
1286 If the class defines two `f' methods, and one `g' method,
1287 then this will have the value 3. */
1288 int total_length
= 0;
1292 struct nextfield
*next
;
1293 int visibility
; /* 0=public, 1=protected, 2=public */
1299 struct next_fnfield
*next
;
1300 struct fn_field fn_field
;
1303 struct next_fnfieldlist
1305 struct next_fnfieldlist
*next
;
1306 struct fn_fieldlist fn_fieldlist
;
1309 register struct nextfield
*list
= 0;
1310 struct nextfield
*new;
1313 int non_public_fields
= 0;
1316 register struct next_fnfieldlist
*mainlist
= 0;
1319 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
1320 INIT_CPLUS_SPECIFIC(type
);
1321 TYPE_FLAGS (type
) &= ~TYPE_FLAG_STUB
;
1323 /* First comes the total size in bytes. */
1325 TYPE_LENGTH (type
) = read_number (pp
, 0);
1327 /* C++: Now, if the class is a derived class, then the next character
1328 will be a '!', followed by the number of base classes derived from.
1329 Each element in the list contains visibility information,
1330 the offset of this base class in the derived structure,
1331 and then the base type. */
1334 int i
, n_baseclasses
, offset
;
1335 struct type
*baseclass
;
1338 /* Nonzero if it is a virtual baseclass, i.e.,
1342 struct C : public B, public virtual A {};
1344 B is a baseclass of C; A is a virtual baseclass for C. This is a C++
1345 2.0 language feature. */
1350 ALLOCATE_CPLUS_STRUCT_TYPE(type
);
1352 n_baseclasses
= read_number (pp
, ',');
1353 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*)
1354 obstack_alloc (&objfile
-> type_obstack
, B_BYTES (n_baseclasses
));
1355 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), n_baseclasses
);
1357 for (i
= 0; i
< n_baseclasses
; i
++)
1360 *pp
= next_symbol_text ();
1371 /* Bad visibility format. */
1372 return error_type (pp
);
1380 non_public_fields
++;
1386 /* Bad visibility format. */
1387 return error_type (pp
);
1390 SET_TYPE_FIELD_VIRTUAL (type
, i
);
1393 /* Offset of the portion of the object corresponding to
1394 this baseclass. Always zero in the absence of
1395 multiple inheritance. */
1396 offset
= read_number (pp
, ',');
1397 baseclass
= read_type (pp
, objfile
);
1398 *pp
+= 1; /* skip trailing ';' */
1400 /* Make this baseclass visible for structure-printing purposes. */
1401 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1402 memset (new, 0, sizeof (struct nextfield
));
1405 list
->visibility
= via_public
;
1406 list
->field
.type
= baseclass
;
1407 list
->field
.name
= type_name_no_tag (baseclass
);
1408 list
->field
.bitpos
= offset
;
1409 list
->field
.bitsize
= 0; /* this should be an unpacked field! */
1412 TYPE_N_BASECLASSES (type
) = n_baseclasses
;
1415 /* Now come the fields, as NAME:?TYPENUM,BITPOS,BITSIZE; for each one.
1416 At the end, we see a semicolon instead of a field.
1418 In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
1421 The `?' is a placeholder for one of '/2' (public visibility),
1422 '/1' (protected visibility), '/0' (private visibility), or nothing
1423 (C style symbol table, public visibility). */
1425 /* We better set p right now, in case there are no fields at all... */
1430 /* Check for and handle cretinous dbx symbol name continuation! */
1431 if (**pp
== '\\') *pp
= next_symbol_text ();
1433 /* Get space to record the next field's data. */
1434 new = (struct nextfield
*) alloca (sizeof (struct nextfield
));
1435 memset (new, 0, sizeof (struct nextfield
));
1439 /* Get the field name. */
1441 if (*p
== CPLUS_MARKER
)
1443 /* Special GNU C++ name. */
1448 struct type
*context
;
1459 complain (&invalid_cpp_abbrev_complaint
, *pp
);
1460 prefix
= "INVALID_C++_ABBREV";
1464 context
= read_type (pp
, objfile
);
1465 name
= type_name_no_tag (context
);
1468 complain (&invalid_cpp_type_complaint
, (char *) symnum
);
1471 list
->field
.name
= obconcat (&objfile
-> type_obstack
,
1475 complain (&invalid_cpp_abbrev_complaint
, *pp
);
1476 list
->field
.type
= read_type (pp
, objfile
);
1477 (*pp
)++; /* Skip the comma. */
1478 list
->field
.bitpos
= read_number (pp
, ';');
1479 /* This field is unpacked. */
1480 list
->field
.bitsize
= 0;
1481 list
->visibility
= 0; /* private */
1482 non_public_fields
++;
1484 /* GNU C++ anonymous type. */
1488 complain (&invalid_cpp_abbrev_complaint
, *pp
);
1494 while (*p
!= ':') p
++;
1495 list
->field
.name
= obsavestring (*pp
, p
- *pp
,
1496 &objfile
-> type_obstack
);
1498 /* C++: Check to see if we have hit the methods yet. */
1504 /* This means we have a visibility for a field coming. */
1510 list
->visibility
= 0; /* private */
1511 non_public_fields
++;
1516 list
->visibility
= 1; /* protected */
1517 non_public_fields
++;
1522 list
->visibility
= 2; /* public */
1527 else /* normal dbx-style format. */
1528 list
->visibility
= 2; /* public */
1530 list
->field
.type
= read_type (pp
, objfile
);
1535 /* Possible future hook for nested types. */
1538 list
->field
.bitpos
= (long)-2; /* nested type */
1543 { /* Static class member. */
1544 list
->field
.bitpos
= (long)-1;
1546 while (*p
!= ';') p
++;
1547 list
->field
.bitsize
= (long) savestring (*pp
, p
- *pp
);
1552 else if (**pp
!= ',')
1553 /* Bad structure-type format. */
1554 return error_type (pp
);
1556 (*pp
)++; /* Skip the comma. */
1557 list
->field
.bitpos
= read_number (pp
, ',');
1558 list
->field
.bitsize
= read_number (pp
, ';');
1561 /* FIXME-tiemann: Can't the compiler put out something which
1562 lets us distinguish these? (or maybe just not put out anything
1563 for the field). What is the story here? What does the compiler
1564 really do? Also, patch gdb.texinfo for this case; I document
1565 it as a possible problem there. Search for "DBX-style". */
1567 /* This is wrong because this is identical to the symbols
1568 produced for GCC 0-size arrays. For example:
1573 The code which dumped core in such circumstances should be
1574 fixed not to dump core. */
1576 /* g++ -g0 can put out bitpos & bitsize zero for a static
1577 field. This does not give us any way of getting its
1578 class, so we can't know its name. But we can just
1579 ignore the field so we don't dump core and other nasty
1581 if (list
->field
.bitpos
== 0
1582 && list
->field
.bitsize
== 0)
1584 complain (&dbx_class_complaint
, 0);
1585 /* Ignore this field. */
1591 /* Detect an unpacked field and mark it as such.
1592 dbx gives a bit size for all fields.
1593 Note that forward refs cannot be packed,
1594 and treat enums as if they had the width of ints. */
1595 if (TYPE_CODE (list
->field
.type
) != TYPE_CODE_INT
1596 && TYPE_CODE (list
->field
.type
) != TYPE_CODE_ENUM
)
1597 list
->field
.bitsize
= 0;
1598 if ((list
->field
.bitsize
== 8 * TYPE_LENGTH (list
->field
.type
)
1599 || (TYPE_CODE (list
->field
.type
) == TYPE_CODE_ENUM
1600 && (list
->field
.bitsize
1601 == 8 * TYPE_LENGTH (lookup_fundamental_type (objfile
, FT_INTEGER
)))
1605 list
->field
.bitpos
% 8 == 0)
1606 list
->field
.bitsize
= 0;
1612 /* chill the list of fields: the last entry (at the head)
1613 is a partially constructed entry which we now scrub. */
1616 /* Now create the vector of fields, and record how big it is.
1617 We need this info to record proper virtual function table information
1618 for this class's virtual functions. */
1620 TYPE_NFIELDS (type
) = nfields
;
1621 TYPE_FIELDS (type
) = (struct field
*)
1622 obstack_alloc (&objfile
-> type_obstack
, sizeof (struct field
) * nfields
);
1623 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
1625 if (non_public_fields
)
1627 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
1629 TYPE_FIELD_PRIVATE_BITS (type
) = (B_TYPE
*)
1630 obstack_alloc (&objfile
-> type_obstack
, B_BYTES (nfields
));
1631 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
1633 TYPE_FIELD_PROTECTED_BITS (type
) = (B_TYPE
*)
1634 obstack_alloc (&objfile
-> type_obstack
, B_BYTES (nfields
));
1635 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
1638 /* Copy the saved-up fields into the field vector. */
1640 for (n
= nfields
; list
; list
= list
->next
)
1643 TYPE_FIELD (type
, n
) = list
->field
;
1644 if (list
->visibility
== 0)
1645 SET_TYPE_FIELD_PRIVATE (type
, n
);
1646 else if (list
->visibility
== 1)
1647 SET_TYPE_FIELD_PROTECTED (type
, n
);
1650 /* Now come the method fields, as NAME::methods
1651 where each method is of the form TYPENUM,ARGS,...:PHYSNAME;
1652 At the end, we see a semicolon instead of a field.
1654 For the case of overloaded operators, the format is
1655 op$::*.methods, where $ is the CPLUS_MARKER (usually '$'),
1656 `*' holds the place for an operator name (such as `+=')
1657 and `.' marks the end of the operator name. */
1660 /* Now, read in the methods. To simplify matters, we
1661 "unread" the name that has been read, so that we can
1662 start from the top. */
1664 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
1665 /* For each list of method lists... */
1669 struct next_fnfield
*sublist
= 0;
1670 struct type
*look_ahead_type
= NULL
;
1672 struct next_fnfieldlist
*new_mainlist
;
1675 new_mainlist
= (struct next_fnfieldlist
*)
1676 alloca (sizeof (struct next_fnfieldlist
));
1677 memset (new_mainlist
, 0, sizeof (struct next_fnfieldlist
));
1681 /* read in the name. */
1682 while (*p
!= ':') p
++;
1683 if ((*pp
)[0] == 'o' && (*pp
)[1] == 'p' && (*pp
)[2] == CPLUS_MARKER
)
1685 /* This is a completely wierd case. In order to stuff in the
1686 names that might contain colons (the usual name delimiter),
1687 Mike Tiemann defined a different name format which is
1688 signalled if the identifier is "op$". In that case, the
1689 format is "op$::XXXX." where XXXX is the name. This is
1690 used for names like "+" or "=". YUUUUUUUK! FIXME! */
1691 /* This lets the user type "break operator+".
1692 We could just put in "+" as the name, but that wouldn't
1694 static char opname
[32] = {'o', 'p', CPLUS_MARKER
};
1695 char *o
= opname
+ 3;
1697 /* Skip past '::'. */
1699 if (**pp
== '\\') *pp
= next_symbol_text ();
1703 main_fn_name
= savestring (opname
, o
- opname
);
1709 main_fn_name
= savestring (*pp
, p
- *pp
);
1710 /* Skip past '::'. */
1713 new_mainlist
->fn_fieldlist
.name
= main_fn_name
;
1717 struct next_fnfield
*new_sublist
=
1718 (struct next_fnfield
*) alloca (sizeof (struct next_fnfield
));
1719 memset (new_sublist
, 0, sizeof (struct next_fnfield
));
1721 /* Check for and handle cretinous dbx symbol name continuation! */
1722 if (look_ahead_type
== NULL
) /* Normal case. */
1724 if (**pp
== '\\') *pp
= next_symbol_text ();
1726 new_sublist
->fn_field
.type
= read_type (pp
, objfile
);
1728 /* Invalid symtab info for method. */
1729 return error_type (pp
);
1732 { /* g++ version 1 kludge */
1733 new_sublist
->fn_field
.type
= look_ahead_type
;
1734 look_ahead_type
= NULL
;
1739 while (*p
!= ';') p
++;
1741 /* If this is just a stub, then we don't have the
1743 if (TYPE_FLAGS (new_sublist
->fn_field
.type
) & TYPE_FLAG_STUB
)
1744 new_sublist
->fn_field
.is_stub
= 1;
1745 new_sublist
->fn_field
.physname
= savestring (*pp
, p
- *pp
);
1748 /* Set this method's visibility fields. */
1749 switch (*(*pp
)++ - '0')
1752 new_sublist
->fn_field
.is_private
= 1;
1755 new_sublist
->fn_field
.is_protected
= 1;
1759 if (**pp
== '\\') *pp
= next_symbol_text ();
1762 case 'A': /* Normal functions. */
1763 new_sublist
->fn_field
.is_const
= 0;
1764 new_sublist
->fn_field
.is_volatile
= 0;
1767 case 'B': /* `const' member functions. */
1768 new_sublist
->fn_field
.is_const
= 1;
1769 new_sublist
->fn_field
.is_volatile
= 0;
1772 case 'C': /* `volatile' member function. */
1773 new_sublist
->fn_field
.is_const
= 0;
1774 new_sublist
->fn_field
.is_volatile
= 1;
1777 case 'D': /* `const volatile' member function. */
1778 new_sublist
->fn_field
.is_const
= 1;
1779 new_sublist
->fn_field
.is_volatile
= 1;
1782 case '*': /* File compiled with g++ version 1 -- no info */
1787 complain (&const_vol_complaint
, (char *) (long) **pp
);
1794 /* virtual member function, followed by index. */
1795 /* The sign bit is set to distinguish pointers-to-methods
1796 from virtual function indicies. Since the array is
1797 in words, the quantity must be shifted left by 1
1798 on 16 bit machine, and by 2 on 32 bit machine, forcing
1799 the sign bit out, and usable as a valid index into
1800 the array. Remove the sign bit here. */
1801 new_sublist
->fn_field
.voffset
=
1802 (0x7fffffff & read_number (pp
, ';')) + 2;
1804 if (**pp
== '\\') *pp
= next_symbol_text ();
1806 if (**pp
== ';' || **pp
== '\0')
1807 /* Must be g++ version 1. */
1808 new_sublist
->fn_field
.fcontext
= 0;
1811 /* Figure out from whence this virtual function came.
1812 It may belong to virtual function table of
1813 one of its baseclasses. */
1814 look_ahead_type
= read_type (pp
, objfile
);
1816 { /* g++ version 1 overloaded methods. */ }
1819 new_sublist
->fn_field
.fcontext
= look_ahead_type
;
1821 return error_type (pp
);
1824 look_ahead_type
= NULL
;
1830 /* static member function. */
1831 new_sublist
->fn_field
.voffset
= VOFFSET_STATIC
;
1832 if (strncmp (new_sublist
->fn_field
.physname
,
1833 main_fn_name
, strlen (main_fn_name
)))
1834 new_sublist
->fn_field
.is_stub
= 1;
1839 complain (&member_fn_complaint
, (char *) (long) (*pp
)[-1]);
1840 /* Fall through into normal member function. */
1843 /* normal member function. */
1844 new_sublist
->fn_field
.voffset
= 0;
1845 new_sublist
->fn_field
.fcontext
= 0;
1849 new_sublist
->next
= sublist
;
1850 sublist
= new_sublist
;
1852 if (**pp
== '\\') *pp
= next_symbol_text ();
1854 while (**pp
!= ';' && **pp
!= '\0');
1858 new_mainlist
->fn_fieldlist
.fn_fields
= (struct fn_field
*)
1859 obstack_alloc (&objfile
-> type_obstack
,
1860 sizeof (struct fn_field
) * length
);
1861 memset (new_mainlist
->fn_fieldlist
.fn_fields
, 0,
1862 sizeof (struct fn_field
) * length
);
1863 for (i
= length
; (i
--, sublist
); sublist
= sublist
->next
)
1864 new_mainlist
->fn_fieldlist
.fn_fields
[i
] = sublist
->fn_field
;
1866 new_mainlist
->fn_fieldlist
.length
= length
;
1867 new_mainlist
->next
= mainlist
;
1868 mainlist
= new_mainlist
;
1870 total_length
+= length
;
1871 if (**pp
== '\\') *pp
= next_symbol_text ();
1873 while (**pp
!= ';');
1881 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
1882 obstack_alloc (&objfile
-> type_obstack
,
1883 sizeof (struct fn_fieldlist
) * nfn_fields
);
1884 memset (TYPE_FN_FIELDLISTS (type
), 0,
1885 sizeof (struct fn_fieldlist
) * nfn_fields
);
1886 TYPE_NFN_FIELDS (type
) = nfn_fields
;
1887 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
1892 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); ++i
)
1894 if (TYPE_CODE (TYPE_BASECLASS (type
, i
)) == TYPE_CODE_UNDEF
)
1895 /* @@ Memory leak on objfile->type_obstack? */
1896 return error_type (pp
);
1897 TYPE_NFN_FIELDS_TOTAL (type
) +=
1898 TYPE_NFN_FIELDS_TOTAL (TYPE_BASECLASS (type
, i
));
1902 for (n
= nfn_fields
; mainlist
; mainlist
= mainlist
->next
) {
1903 --n
; /* Circumvent Sun3 compiler bug */
1904 TYPE_FN_FIELDLISTS (type
)[n
] = mainlist
->fn_fieldlist
;
1911 if (**pp
== '=' || **pp
== '+' || **pp
== '-')
1913 /* Obsolete flags that used to indicate the presence
1914 of constructors and/or destructors. */
1918 /* Read either a '%' or the final ';'. */
1919 if (*(*pp
)++ == '%')
1921 /* We'd like to be able to derive the vtable pointer field
1922 from the type information, but when it's inherited, that's
1923 hard. A reason it's hard is because we may read in the
1924 info about a derived class before we read in info about
1925 the base class that provides the vtable pointer field.
1926 Once the base info has been read, we could fill in the info
1927 for the derived classes, but for the fact that by then,
1928 we don't remember who needs what. */
1931 int predicted_fieldno
= -1;
1934 /* Now we must record the virtual function table pointer's
1935 field information. */
1943 /* In version 2, we derive the vfield ourselves. */
1944 for (n
= 0; n
< nfields
; n
++)
1946 if (! strncmp (TYPE_FIELD_NAME (type
, n
), vptr_name
,
1947 sizeof (vptr_name
) -1))
1949 predicted_fieldno
= n
;
1953 if (predicted_fieldno
< 0)
1954 for (n
= 0; n
< TYPE_N_BASECLASSES (type
); n
++)
1955 if (! TYPE_FIELD_VIRTUAL (type
, n
)
1956 && TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, n
)) >= 0)
1958 predicted_fieldno
= TYPE_VPTR_FIELDNO (TYPE_BASECLASS (type
, n
));
1964 t
= read_type (pp
, objfile
);
1966 while (*p
!= '\0' && *p
!= ';')
1969 /* Premature end of symbol. */
1970 return error_type (pp
);
1972 TYPE_VPTR_BASETYPE (type
) = t
;
1975 if (TYPE_FIELD_NAME (t
, TYPE_N_BASECLASSES (t
)) == 0)
1977 /* FIXME-tiemann: what's this? */
1979 TYPE_VPTR_FIELDNO (type
) = i
= TYPE_N_BASECLASSES (t
);
1984 else for (i
= TYPE_NFIELDS (t
) - 1; i
>= TYPE_N_BASECLASSES (t
); --i
)
1985 if (! strncmp (TYPE_FIELD_NAME (t
, i
), vptr_name
,
1986 sizeof (vptr_name
) - 1))
1988 TYPE_VPTR_FIELDNO (type
) = i
;
1992 /* Virtual function table field not found. */
1993 return error_type (pp
);
1996 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
1999 if (TYPE_VPTR_FIELDNO (type
) != predicted_fieldno
)
2000 error ("TYPE_VPTR_FIELDNO miscalculated");
2010 /* Read a definition of an array type,
2011 and create and return a suitable type object.
2012 Also creates a range type which represents the bounds of that
2015 static struct type
*
2016 read_array_type (pp
, type
, objfile
)
2018 register struct type
*type
;
2019 struct objfile
*objfile
;
2021 struct type
*index_type
, *element_type
, *range_type
;
2025 /* Format of an array type:
2026 "ar<index type>;lower;upper;<array_contents_type>". Put code in
2029 Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
2030 for these, produce a type like float[][]. */
2032 index_type
= read_type (pp
, objfile
);
2034 /* Improper format of array type decl. */
2035 return error_type (pp
);
2038 if (!(**pp
>= '0' && **pp
<= '9'))
2043 lower
= read_number (pp
, ';');
2045 if (!(**pp
>= '0' && **pp
<= '9'))
2050 upper
= read_number (pp
, ';');
2052 element_type
= read_type (pp
, objfile
);
2061 /* Create range type. */
2062 range_type
= (struct type
*)
2063 obstack_alloc (&objfile
-> type_obstack
, sizeof (struct type
));
2064 memset (range_type
, 0, sizeof (struct type
));
2065 TYPE_OBJFILE (range_type
) = objfile
;
2066 TYPE_CODE (range_type
) = TYPE_CODE_RANGE
;
2067 TYPE_TARGET_TYPE (range_type
) = index_type
;
2069 /* This should never be needed. */
2070 TYPE_LENGTH (range_type
) = sizeof (int);
2072 TYPE_NFIELDS (range_type
) = 2;
2073 TYPE_FIELDS (range_type
) = (struct field
*)
2074 obstack_alloc (&objfile
-> type_obstack
, 2 * sizeof (struct field
));
2075 memset (TYPE_FIELDS (range_type
), 0, 2 * sizeof (struct field
));
2076 TYPE_FIELD_BITPOS (range_type
, 0) = lower
;
2077 TYPE_FIELD_BITPOS (range_type
, 1) = upper
;
2080 TYPE_CODE (type
) = TYPE_CODE_ARRAY
;
2081 TYPE_TARGET_TYPE (type
) = element_type
;
2082 TYPE_LENGTH (type
) = (upper
- lower
+ 1) * TYPE_LENGTH (element_type
);
2083 TYPE_NFIELDS (type
) = 1;
2084 TYPE_FIELDS (type
) = (struct field
*)
2085 obstack_alloc (&objfile
-> type_obstack
, sizeof (struct field
));
2086 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
));
2087 TYPE_FIELD_TYPE (type
, 0) = range_type
;
2089 /* If we have an array whose element type is not yet known, but whose
2090 bounds *are* known, record it to be adjusted at the end of the file. */
2091 if (TYPE_LENGTH (element_type
) == 0 && !adjustable
)
2092 add_undefined_type (type
);
2098 /* Read a definition of an enumeration type,
2099 and create and return a suitable type object.
2100 Also defines the symbols that represent the values of the type. */
2102 static struct type
*
2103 read_enum_type (pp
, type
, objfile
)
2105 register struct type
*type
;
2106 struct objfile
*objfile
;
2111 register struct symbol
*sym
;
2113 struct pending
**symlist
;
2114 struct pending
*osyms
, *syms
;
2118 /* FIXME! The stabs produced by Sun CC merrily define things that ought
2119 to be file-scope, between N_FN entries, using N_LSYM. What's a mother
2120 to do? For now, force all enum values to file scope. */
2121 if (within_function
)
2122 symlist
= &local_symbols
;
2125 symlist
= &file_symbols
;
2127 o_nsyms
= osyms
? osyms
->nsyms
: 0;
2129 /* Read the value-names and their values.
2130 The input syntax is NAME:VALUE,NAME:VALUE, and so on.
2131 A semicolon or comma instead of a NAME means the end. */
2132 while (**pp
&& **pp
!= ';' && **pp
!= ',')
2134 /* Check for and handle cretinous dbx symbol name continuation! */
2135 if (**pp
== '\\') *pp
= next_symbol_text ();
2138 while (*p
!= ':') p
++;
2139 name
= obsavestring (*pp
, p
- *pp
, &objfile
-> symbol_obstack
);
2141 n
= read_number (pp
, ',');
2143 sym
= (struct symbol
*)
2144 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
2145 memset (sym
, 0, sizeof (struct symbol
));
2146 SYMBOL_NAME (sym
) = name
;
2147 SYMBOL_CLASS (sym
) = LOC_CONST
;
2148 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2149 SYMBOL_VALUE (sym
) = n
;
2150 add_symbol_to_list (sym
, symlist
);
2155 (*pp
)++; /* Skip the semicolon. */
2157 /* Now fill in the fields of the type-structure. */
2159 TYPE_LENGTH (type
) = sizeof (int);
2160 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
2161 TYPE_FLAGS (type
) &= ~TYPE_FLAG_STUB
;
2162 TYPE_NFIELDS (type
) = nsyms
;
2163 TYPE_FIELDS (type
) = (struct field
*)
2164 obstack_alloc (&objfile
-> type_obstack
, sizeof (struct field
) * nsyms
);
2165 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nsyms
);
2167 /* Find the symbols for the values and put them into the type.
2168 The symbols can be found in the symlist that we put them on
2169 to cause them to be defined. osyms contains the old value
2170 of that symlist; everything up to there was defined by us. */
2171 /* Note that we preserve the order of the enum constants, so
2172 that in something like "enum {FOO, LAST_THING=FOO}" we print
2173 FOO, not LAST_THING. */
2175 for (syms
= *symlist
, n
= 0; syms
; syms
= syms
->next
)
2180 for (; j
< syms
->nsyms
; j
++,n
++)
2182 struct symbol
*xsym
= syms
->symbol
[j
];
2183 SYMBOL_TYPE (xsym
) = type
;
2184 TYPE_FIELD_NAME (type
, n
) = SYMBOL_NAME (xsym
);
2185 TYPE_FIELD_VALUE (type
, n
) = 0;
2186 TYPE_FIELD_BITPOS (type
, n
) = SYMBOL_VALUE (xsym
);
2187 TYPE_FIELD_BITSIZE (type
, n
) = 0;
2194 /* This screws up perfectly good C programs with enums. FIXME. */
2195 /* Is this Modula-2's BOOLEAN type? Flag it as such if so. */
2196 if(TYPE_NFIELDS(type
) == 2 &&
2197 ((!strcmp(TYPE_FIELD_NAME(type
,0),"TRUE") &&
2198 !strcmp(TYPE_FIELD_NAME(type
,1),"FALSE")) ||
2199 (!strcmp(TYPE_FIELD_NAME(type
,1),"TRUE") &&
2200 !strcmp(TYPE_FIELD_NAME(type
,0),"FALSE"))))
2201 TYPE_CODE(type
) = TYPE_CODE_BOOL
;
2207 /* Sun's ACC uses a somewhat saner method for specifying the builtin
2208 typedefs in every file (for int, long, etc):
2210 type = b <signed> <width>; <offset>; <nbits>
2211 signed = u or s. Possible c in addition to u or s (for char?).
2212 offset = offset from high order bit to start bit of type.
2213 width is # bytes in object of this type, nbits is # bits in type.
2215 The width/offset stuff appears to be for small objects stored in
2216 larger ones (e.g. `shorts' in `int' registers). We ignore it for now,
2219 static struct type
*
2220 read_sun_builtin_type (pp
, typenums
, objfile
)
2223 struct objfile
*objfile
;
2237 return error_type (pp
);
2241 /* For some odd reason, all forms of char put a c here. This is strange
2242 because no other type has this honor. We can safely ignore this because
2243 we actually determine 'char'acterness by the number of bits specified in
2249 /* The first number appears to be the number of bytes occupied
2250 by this type, except that unsigned short is 4 instead of 2.
2251 Since this information is redundant with the third number,
2252 we will ignore it. */
2253 read_number (pp
, ';');
2255 /* The second number is always 0, so ignore it too. */
2256 read_number (pp
, ';');
2258 /* The third number is the number of bits for this type. */
2259 nbits
= read_number (pp
, 0);
2261 /* FIXME. Here we should just be able to make a type of the right
2262 number of bits and signedness. FIXME. */
2264 if (nbits
== TARGET_LONG_LONG_BIT
)
2265 return (lookup_fundamental_type (objfile
,
2266 signed_type
? FT_LONG_LONG
: FT_UNSIGNED_LONG_LONG
));
2268 if (nbits
== TARGET_INT_BIT
)
2270 /* FIXME -- the only way to distinguish `int' from `long'
2271 is to look at its name! */
2274 if (long_kludge_name
&& long_kludge_name
[0] == 'l' /* long */)
2275 return lookup_fundamental_type (objfile
, FT_LONG
);
2277 return lookup_fundamental_type (objfile
, FT_INTEGER
);
2281 if (long_kludge_name
2282 && ((long_kludge_name
[0] == 'u' /* unsigned */ &&
2283 long_kludge_name
[9] == 'l' /* long */)
2284 || (long_kludge_name
[0] == 'l' /* long unsigned */)))
2285 return lookup_fundamental_type (objfile
, FT_UNSIGNED_LONG
);
2287 return lookup_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
);
2291 if (nbits
== TARGET_SHORT_BIT
)
2292 return (lookup_fundamental_type (objfile
,
2293 signed_type
? FT_SHORT
: FT_UNSIGNED_SHORT
));
2295 if (nbits
== TARGET_CHAR_BIT
)
2296 return (lookup_fundamental_type (objfile
,
2297 signed_type
? FT_CHAR
: FT_UNSIGNED_CHAR
));
2300 return lookup_fundamental_type (objfile
, FT_VOID
);
2302 return error_type (pp
);
2305 static struct type
*
2306 read_sun_floating_type (pp
, typenums
, objfile
)
2309 struct objfile
*objfile
;
2313 /* The first number has more details about the type, for example
2314 FN_COMPLEX. See the sun stab.h. */
2315 read_number (pp
, ';');
2317 /* The second number is the number of bytes occupied by this type */
2318 nbytes
= read_number (pp
, ';');
2321 return error_type (pp
);
2323 if (nbytes
== TARGET_FLOAT_BIT
/ TARGET_CHAR_BIT
)
2324 return lookup_fundamental_type (objfile
, FT_FLOAT
);
2326 if (nbytes
== TARGET_DOUBLE_BIT
/ TARGET_CHAR_BIT
)
2327 return lookup_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
);
2329 if (nbytes
== TARGET_LONG_DOUBLE_BIT
/ TARGET_CHAR_BIT
)
2330 return lookup_fundamental_type (objfile
, FT_EXT_PREC_FLOAT
);
2332 return error_type (pp
);
2335 /* Read a number from the string pointed to by *PP.
2336 The value of *PP is advanced over the number.
2337 If END is nonzero, the character that ends the
2338 number must match END, or an error happens;
2339 and that character is skipped if it does match.
2340 If END is zero, *PP is left pointing to that character.
2342 If the number fits in a long, set *VALUE and set *BITS to 0.
2343 If not, set *BITS to be the number of bits in the number.
2345 If encounter garbage, set *BITS to -1. */
2348 read_huge_number (pp
, end
, valu
, bits
)
2369 /* Leading zero means octal. GCC uses this to output values larger
2370 than an int (because that would be hard in decimal). */
2377 upper_limit
= LONG_MAX
/ radix
;
2378 while ((c
= *p
++) >= '0' && c
<= ('0' + radix
))
2380 if (n
<= upper_limit
)
2383 n
+= c
- '0'; /* FIXME this overflows anyway */
2388 /* This depends on large values being output in octal, which is
2395 /* Ignore leading zeroes. */
2399 else if (c
== '2' || c
== '3')
2425 /* Large decimal constants are an error (because it is hard to
2426 count how many bits are in them). */
2432 /* -0x7f is the same as 0x80. So deal with it by adding one to
2433 the number of bits. */
2448 static struct type
*
2449 read_range_type (pp
, typenums
, objfile
)
2452 struct objfile
*objfile
;
2458 struct type
*result_type
;
2460 /* First comes a type we are a subrange of.
2461 In C it is usually 0, 1 or the type being defined. */
2462 read_type_number (pp
, rangenums
);
2463 self_subrange
= (rangenums
[0] == typenums
[0] &&
2464 rangenums
[1] == typenums
[1]);
2466 /* A semicolon should now follow; skip it. */
2470 /* The remaining two operands are usually lower and upper bounds
2471 of the range. But in some special cases they mean something else. */
2472 read_huge_number (pp
, ';', &n2
, &n2bits
);
2473 read_huge_number (pp
, ';', &n3
, &n3bits
);
2475 if (n2bits
== -1 || n3bits
== -1)
2476 return error_type (pp
);
2478 /* If limits are huge, must be large integral type. */
2479 if (n2bits
!= 0 || n3bits
!= 0)
2481 char got_signed
= 0;
2482 char got_unsigned
= 0;
2483 /* Number of bits in the type. */
2486 /* Range from 0 to <large number> is an unsigned large integral type. */
2487 if ((n2bits
== 0 && n2
== 0) && n3bits
!= 0)
2492 /* Range from <large number> to <large number>-1 is a large signed
2494 else if (n2bits
!= 0 && n3bits
!= 0 && n2bits
== n3bits
+ 1)
2500 /* Check for "long long". */
2501 if (got_signed
&& nbits
== TARGET_LONG_LONG_BIT
)
2502 return (lookup_fundamental_type (objfile
, FT_LONG_LONG
));
2503 if (got_unsigned
&& nbits
== TARGET_LONG_LONG_BIT
)
2504 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_LONG_LONG
));
2506 if (got_signed
|| got_unsigned
)
2508 result_type
= (struct type
*)
2509 obstack_alloc (&objfile
-> type_obstack
, sizeof (struct type
));
2510 memset (result_type
, 0, sizeof (struct type
));
2511 TYPE_OBJFILE (result_type
) = objfile
;
2512 TYPE_LENGTH (result_type
) = nbits
/ TARGET_CHAR_BIT
;
2513 TYPE_CODE (result_type
) = TYPE_CODE_INT
;
2515 TYPE_FLAGS (result_type
) |= TYPE_FLAG_UNSIGNED
;
2519 return error_type (pp
);
2522 /* A type defined as a subrange of itself, with bounds both 0, is void. */
2523 if (self_subrange
&& n2
== 0 && n3
== 0)
2524 return (lookup_fundamental_type (objfile
, FT_VOID
));
2526 /* If n3 is zero and n2 is not, we want a floating type,
2527 and n2 is the width in bytes.
2529 Fortran programs appear to use this for complex types also,
2530 and they give no way to distinguish between double and single-complex!
2531 We don't have complex types, so we would lose on all fortran files!
2532 So return type `double' for all of those. It won't work right
2533 for the complex values, but at least it makes the file loadable.
2535 FIXME, we may be able to distinguish these by their names. FIXME. */
2537 if (n3
== 0 && n2
> 0)
2539 if (n2
== sizeof (float))
2540 return (lookup_fundamental_type (objfile
, FT_FLOAT
));
2541 return (lookup_fundamental_type (objfile
, FT_DBL_PREC_FLOAT
));
2544 /* If the upper bound is -1, it must really be an unsigned int. */
2546 else if (n2
== 0 && n3
== -1)
2548 /* FIXME -- the only way to distinguish `unsigned int' from `unsigned
2549 long' is to look at its name! */
2551 long_kludge_name
&& ((long_kludge_name
[0] == 'u' /* unsigned */ &&
2552 long_kludge_name
[9] == 'l' /* long */)
2553 || (long_kludge_name
[0] == 'l' /* long unsigned */)))
2554 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_LONG
));
2556 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
));
2559 /* Special case: char is defined (Who knows why) as a subrange of
2560 itself with range 0-127. */
2561 else if (self_subrange
&& n2
== 0 && n3
== 127)
2562 return (lookup_fundamental_type (objfile
, FT_CHAR
));
2564 /* Assumptions made here: Subrange of self is equivalent to subrange
2565 of int. FIXME: Host and target type-sizes assumed the same. */
2566 /* FIXME: This is the *only* place in GDB that depends on comparing
2567 some type to a builtin type with ==. Fix it! */
2569 && (self_subrange
||
2570 *dbx_lookup_type (rangenums
) == lookup_fundamental_type (objfile
, FT_INTEGER
)))
2572 /* an unsigned type */
2574 if (n3
== - sizeof (long long))
2575 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_LONG_LONG
));
2577 /* FIXME -- the only way to distinguish `unsigned int' from `unsigned
2578 long' is to look at its name! */
2579 if (n3
== (unsigned long)~0L &&
2580 long_kludge_name
&& ((long_kludge_name
[0] == 'u' /* unsigned */ &&
2581 long_kludge_name
[9] == 'l' /* long */)
2582 || (long_kludge_name
[0] == 'l' /* long unsigned */)))
2583 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_LONG
));
2584 if (n3
== (unsigned int)~0L)
2585 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_INTEGER
));
2586 if (n3
== (unsigned short)~0L)
2587 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_SHORT
));
2588 if (n3
== (unsigned char)~0L)
2589 return (lookup_fundamental_type (objfile
, FT_UNSIGNED_CHAR
));
2592 else if (n3
== 0 && n2
== -sizeof (long long))
2593 return (lookup_fundamental_type (objfile
, FT_LONG_LONG
));
2595 else if (n2
== -n3
-1)
2598 /* FIXME -- the only way to distinguish `int' from `long' is to look
2600 if ((n3
==(long)(((unsigned long)1 << (8 * sizeof (long) - 1)) - 1)) &&
2601 long_kludge_name
&& long_kludge_name
[0] == 'l' /* long */)
2602 return (lookup_fundamental_type (objfile
, FT_LONG
));
2603 if (n3
== (long)(((unsigned long)1 << (8 * sizeof (int) - 1)) - 1))
2604 return (lookup_fundamental_type (objfile
, FT_INTEGER
));
2605 if (n3
== ( 1 << (8 * sizeof (short) - 1)) - 1)
2606 return (lookup_fundamental_type (objfile
, FT_SHORT
));
2607 if (n3
== ( 1 << (8 * sizeof (char) - 1)) - 1)
2608 return (lookup_fundamental_type (objfile
, FT_SIGNED_CHAR
));
2611 /* We have a real range type on our hands. Allocate space and
2612 return a real pointer. */
2614 /* At this point I don't have the faintest idea how to deal with
2615 a self_subrange type; I'm going to assume that this is used
2616 as an idiom, and that all of them are special cases. So . . . */
2618 return error_type (pp
);
2620 result_type
= (struct type
*)
2621 obstack_alloc (&objfile
-> type_obstack
, sizeof (struct type
));
2622 memset (result_type
, 0, sizeof (struct type
));
2623 TYPE_OBJFILE (result_type
) = objfile
;
2625 TYPE_CODE (result_type
) = TYPE_CODE_RANGE
;
2627 TYPE_TARGET_TYPE (result_type
) = *dbx_lookup_type(rangenums
);
2628 if (TYPE_TARGET_TYPE (result_type
) == 0) {
2629 complain (&range_type_base_complaint
, (char *) rangenums
[1]);
2630 TYPE_TARGET_TYPE (result_type
) = lookup_fundamental_type (objfile
, FT_INTEGER
);
2633 TYPE_NFIELDS (result_type
) = 2;
2634 TYPE_FIELDS (result_type
) = (struct field
*)
2635 obstack_alloc (&objfile
-> type_obstack
, 2 * sizeof (struct field
));
2636 memset (TYPE_FIELDS (result_type
), 0, 2 * sizeof (struct field
));
2637 TYPE_FIELD_BITPOS (result_type
, 0) = n2
;
2638 TYPE_FIELD_BITPOS (result_type
, 1) = n3
;
2640 TYPE_LENGTH (result_type
) = TYPE_LENGTH (TYPE_TARGET_TYPE (result_type
));
2645 /* Read a number from the string pointed to by *PP.
2646 The value of *PP is advanced over the number.
2647 If END is nonzero, the character that ends the
2648 number must match END, or an error happens;
2649 and that character is skipped if it does match.
2650 If END is zero, *PP is left pointing to that character. */
2653 read_number (pp
, end
)
2657 register char *p
= *pp
;
2658 register long n
= 0;
2662 /* Handle an optional leading minus sign. */
2670 /* Read the digits, as far as they go. */
2672 while ((c
= *p
++) >= '0' && c
<= '9')
2680 error ("Invalid symbol data: invalid character \\%03o at symbol pos %d.", c
, symnum
);
2689 /* Read in an argument list. This is a list of types, separated by commas
2690 and terminated with END. Return the list of types read in, or (struct type
2691 **)-1 if there is an error. */
2693 static struct type
**
2694 read_args (pp
, end
, objfile
)
2697 struct objfile
*objfile
;
2699 /* FIXME! Remove this arbitrary limit! */
2700 struct type
*types
[1024], **rval
; /* allow for fns of 1023 parameters */
2706 /* Invalid argument list: no ','. */
2707 return (struct type
**)-1;
2710 /* Check for and handle cretinous dbx symbol name continuation! */
2712 *pp
= next_symbol_text ();
2714 types
[n
++] = read_type (pp
, objfile
);
2716 *pp
+= 1; /* get past `end' (the ':' character) */
2720 rval
= (struct type
**) xmalloc (2 * sizeof (struct type
*));
2722 else if (TYPE_CODE (types
[n
-1]) != TYPE_CODE_VOID
)
2724 rval
= (struct type
**) xmalloc ((n
+ 1) * sizeof (struct type
*));
2725 memset (rval
+ n
, 0, sizeof (struct type
*));
2729 rval
= (struct type
**) xmalloc (n
* sizeof (struct type
*));
2731 memcpy (rval
, types
, n
* sizeof (struct type
*));
2735 /* Add a common block's start address to the offset of each symbol
2736 declared to be in it (by being between a BCOMM/ECOMM pair that uses
2737 the common block name). */
2740 fix_common_block (sym
, valu
)
2744 struct pending
*next
= (struct pending
*) SYMBOL_NAMESPACE (sym
);
2745 for ( ; next
; next
= next
->next
)
2748 for (j
= next
->nsyms
- 1; j
>= 0; j
--)
2749 SYMBOL_VALUE_ADDRESS (next
->symbol
[j
]) += valu
;
2755 /* What about types defined as forward references inside of a small lexical
2757 /* Add a type to the list of undefined types to be checked through
2758 once this file has been read in. */
2761 add_undefined_type (type
)
2764 if (undef_types_length
== undef_types_allocated
)
2766 undef_types_allocated
*= 2;
2767 undef_types
= (struct type
**)
2768 xrealloc ((char *) undef_types
,
2769 undef_types_allocated
* sizeof (struct type
*));
2771 undef_types
[undef_types_length
++] = type
;
2774 /* Go through each undefined type, see if it's still undefined, and fix it
2775 up if possible. We have two kinds of undefined types:
2777 TYPE_CODE_ARRAY: Array whose target type wasn't defined yet.
2778 Fix: update array length using the element bounds
2779 and the target type's length.
2780 TYPE_CODE_STRUCT, TYPE_CODE_UNION: Structure whose fields were not
2781 yet defined at the time a pointer to it was made.
2782 Fix: Do a full lookup on the struct/union tag. */
2784 cleanup_undefined_types ()
2788 for (type
= undef_types
; type
< undef_types
+ undef_types_length
; type
++)
2790 switch (TYPE_CODE (*type
))
2793 case TYPE_CODE_STRUCT
:
2794 case TYPE_CODE_UNION
:
2795 case TYPE_CODE_ENUM
:
2797 /* Check if it has been defined since. */
2798 if (TYPE_FLAGS (*type
) & TYPE_FLAG_STUB
)
2800 struct pending
*ppt
;
2802 /* Name of the type, without "struct" or "union" */
2803 char *typename
= TYPE_NAME (*type
);
2805 if (!strncmp (typename
, "struct ", 7))
2807 if (!strncmp (typename
, "union ", 6))
2809 if (!strncmp (typename
, "enum ", 5))
2812 for (ppt
= file_symbols
; ppt
; ppt
= ppt
->next
)
2814 for (i
= 0; i
< ppt
->nsyms
; i
++)
2816 struct symbol
*sym
= ppt
->symbol
[i
];
2818 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
2819 && SYMBOL_NAMESPACE (sym
) == STRUCT_NAMESPACE
2820 && (TYPE_CODE (SYMBOL_TYPE (sym
)) ==
2822 && !strcmp (SYMBOL_NAME (sym
), typename
))
2824 memcpy (*type
, SYMBOL_TYPE (sym
),
2825 sizeof (struct type
));
2833 case TYPE_CODE_ARRAY
:
2835 struct type
*range_type
;
2838 if (TYPE_LENGTH (*type
) != 0) /* Better be unknown */
2840 if (TYPE_NFIELDS (*type
) != 1)
2842 range_type
= TYPE_FIELD_TYPE (*type
, 0);
2843 if (TYPE_CODE (range_type
) != TYPE_CODE_RANGE
)
2846 /* Now recompute the length of the array type, based on its
2847 number of elements and the target type's length. */
2848 lower
= TYPE_FIELD_BITPOS (range_type
, 0);
2849 upper
= TYPE_FIELD_BITPOS (range_type
, 1);
2850 TYPE_LENGTH (*type
) = (upper
- lower
+ 1)
2851 * TYPE_LENGTH (TYPE_TARGET_TYPE (*type
));
2857 error ("GDB internal error. cleanup_undefined_types with bad type %d.", TYPE_CODE (*type
));
2861 undef_types_length
= 0;
2864 /* Scan through all of the global symbols defined in the object file,
2865 assigning values to the debugging symbols that need to be assigned
2866 to. Get these symbols from the minimal symbol table. */
2869 scan_file_globals (objfile
)
2870 struct objfile
*objfile
;
2873 struct minimal_symbol
*msymbol
;
2874 struct symbol
*sym
, *prev
;
2876 if (objfile
->msymbols
== 0) /* Beware the null file. */
2879 for (msymbol
= objfile
-> msymbols
; msymbol
-> name
!= NULL
; msymbol
++)
2885 /* Get the hash index and check all the symbols
2886 under that hash index. */
2888 hash
= hashname (msymbol
-> name
);
2890 for (sym
= global_sym_chain
[hash
]; sym
;)
2892 if (*(msymbol
-> name
) == SYMBOL_NAME (sym
)[0]
2893 && !strcmp(msymbol
-> name
+ 1, SYMBOL_NAME (sym
) + 1))
2895 /* Splice this symbol out of the hash chain and
2896 assign the value we have to it. */
2899 SYMBOL_VALUE_CHAIN (prev
) = SYMBOL_VALUE_CHAIN (sym
);
2903 global_sym_chain
[hash
] = SYMBOL_VALUE_CHAIN (sym
);
2906 /* Check to see whether we need to fix up a common block. */
2907 /* Note: this code might be executed several times for
2908 the same symbol if there are multiple references. */
2910 if (SYMBOL_CLASS (sym
) == LOC_BLOCK
)
2912 fix_common_block (sym
, msymbol
-> address
);
2916 SYMBOL_VALUE_ADDRESS (sym
) = msymbol
-> address
;
2921 sym
= SYMBOL_VALUE_CHAIN (prev
);
2925 sym
= global_sym_chain
[hash
];
2931 sym
= SYMBOL_VALUE_CHAIN (sym
);
2937 /* Initialize anything that needs initializing when starting to read
2938 a fresh piece of a symbol file, e.g. reading in the stuff corresponding
2946 /* Initialize anything that needs initializing when a completely new
2947 symbol file is specified (not just adding some symbols from another
2948 file, e.g. a shared library). */
2951 stabsread_new_init ()
2953 /* Empty the hash table of global syms looking for values. */
2954 memset (global_sym_chain
, 0, sizeof (global_sym_chain
));
2957 /* Initialize anything that needs initializing at the same time as
2958 start_symtab() is called. */
2962 global_stabs
= NULL
; /* AIX COFF */
2963 /* Leave FILENUM of 0 free for builtin types and this file's types. */
2964 n_this_object_header_files
= 1;
2965 type_vector_length
= 0;
2966 type_vector
= (struct type
**) 0;
2969 /* Call after end_symtab() */
2975 free ((char *) type_vector
);
2978 type_vector_length
= 0;
2979 previous_stab_code
= 0;
2983 finish_global_stabs (objfile
)
2985 struct objfile
*objfile
;
2989 patch_block_stabs (global_symbols
, global_stabs
, objfile
);
2990 free ((PTR
) global_stabs
);
2991 global_stabs
= NULL
;
2995 /* Initializer for this module */
2998 _initialize_stabsread ()
3000 undef_types_allocated
= 20;
3001 undef_types_length
= 0;
3002 undef_types
= (struct type
**)
3003 xmalloc (undef_types_allocated
* sizeof (struct type
*));