1 /* Support routines for decoding "stabs" debugging information format.
2 Copyright 1986, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 1998
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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. */
28 #include "gdb_string.h"
33 #include "expression.h"
36 #include "aout/stab_gnu.h" /* We always use GNU stabs, not native */
38 #include "aout/aout64.h"
39 #include "gdb-stabs.h"
41 #include "complaints.h"
47 /* Ask stabsread.h to define the vars it normally declares `extern'. */
49 #include "stabsread.h" /* Our own declarations */
52 /* The routines that read and process a complete stabs for a C struct or
53 C++ class pass lists of data member fields and lists of member function
54 fields in an instance of a field_info structure, as defined below.
55 This is part of some reorganization of low level C++ support and is
56 expected to eventually go away... (FIXME) */
62 struct nextfield
*next
;
64 /* This is the raw visibility from the stab. It is not checked
65 for being one of the visibilities we recognize, so code which
66 examines this field better be able to deal. */
71 struct next_fnfieldlist
73 struct next_fnfieldlist
*next
;
74 struct fn_fieldlist fn_fieldlist
;
79 read_one_struct_field
PARAMS ((struct field_info
*, char **, char *,
80 struct type
*, struct objfile
*));
83 get_substring
PARAMS ((char **, int));
86 dbx_alloc_type
PARAMS ((int [2], struct objfile
*));
88 static long read_huge_number
PARAMS ((char **, int, int *));
90 static struct type
*error_type
PARAMS ((char **, struct objfile
*));
93 patch_block_stabs
PARAMS ((struct pending
*, struct pending_stabs
*,
97 fix_common_block
PARAMS ((struct symbol
*, int));
100 read_type_number
PARAMS ((char **, int *));
103 read_range_type
PARAMS ((char **, int [2], struct objfile
*));
106 read_sun_builtin_type
PARAMS ((char **, int [2], struct objfile
*));
109 read_sun_floating_type
PARAMS ((char **, int [2], struct objfile
*));
112 read_enum_type
PARAMS ((char **, struct type
*, struct objfile
*));
115 rs6000_builtin_type
PARAMS ((int));
118 read_member_functions
PARAMS ((struct field_info
*, char **, struct type
*,
122 read_struct_fields
PARAMS ((struct field_info
*, char **, struct type
*,
126 read_baseclasses
PARAMS ((struct field_info
*, char **, struct type
*,
130 read_tilde_fields
PARAMS ((struct field_info
*, char **, struct type
*,
134 attach_fn_fields_to_type
PARAMS ((struct field_info
*, struct type
*));
137 attach_fields_to_type
PARAMS ((struct field_info
*, struct type
*,
141 read_struct_type
PARAMS ((char **, struct type
*, struct objfile
*));
144 read_array_type
PARAMS ((char **, struct type
*, struct objfile
*));
146 static struct type
**
147 read_args
PARAMS ((char **, int, struct objfile
*));
150 read_cpp_abbrev
PARAMS ((struct field_info
*, char **, struct type
*,
153 /* new functions added for cfront support */
156 copy_cfront_struct_fields
PARAMS ((struct field_info
*, struct type
*,
160 get_cfront_method_physname
PARAMS ((char *));
163 read_cfront_baseclasses
PARAMS ((struct field_info
*, char **,
164 struct type
*, struct objfile
*));
167 read_cfront_static_fields
PARAMS ((struct field_info
*, char**,
168 struct type
*, struct objfile
*));
170 read_cfront_member_functions
PARAMS ((struct field_info
*, char **,
171 struct type
*, struct objfile
*));
173 /* end new functions added for cfront support */
176 add_live_range
PARAMS ((struct objfile
*, struct symbol
*,
177 CORE_ADDR
, CORE_ADDR
));
180 resolve_live_range
PARAMS ((struct objfile
*, struct symbol
*, char *));
183 process_reference
PARAMS ((char **string
));
186 ref_search_value
PARAMS ((int refnum
));
189 resolve_symbol_reference
PARAMS ((struct objfile
*, struct symbol
*, char *));
191 static const char vptr_name
[] = { '_','v','p','t','r',CPLUS_MARKER
,'\0' };
192 static const char vb_name
[] = { '_','v','b',CPLUS_MARKER
,'\0' };
194 /* Define this as 1 if a pcc declaration of a char or short argument
195 gives the correct address. Otherwise assume pcc gives the
196 address of the corresponding int, which is not the same on a
197 big-endian machine. */
199 #ifndef BELIEVE_PCC_PROMOTION
200 #define BELIEVE_PCC_PROMOTION 0
203 static struct complaint invalid_cpp_abbrev_complaint
=
204 {"invalid C++ abbreviation `%s'", 0, 0};
206 static struct complaint invalid_cpp_type_complaint
=
207 {"C++ abbreviated type name unknown at symtab pos %d", 0, 0};
209 static struct complaint member_fn_complaint
=
210 {"member function type missing, got '%c'", 0, 0};
212 static struct complaint const_vol_complaint
=
213 {"const/volatile indicator missing, got '%c'", 0, 0};
215 static struct complaint error_type_complaint
=
216 {"debug info mismatch between compiler and debugger", 0, 0};
218 static struct complaint invalid_member_complaint
=
219 {"invalid (minimal) member type data format at symtab pos %d.", 0, 0};
221 static struct complaint range_type_base_complaint
=
222 {"base type %d of range type is not defined", 0, 0};
224 static struct complaint reg_value_complaint
=
225 {"register number %d too large (max %d) in symbol %s", 0, 0};
227 static struct complaint vtbl_notfound_complaint
=
228 {"virtual function table pointer not found when defining class `%s'", 0, 0};
230 static struct complaint unrecognized_cplus_name_complaint
=
231 {"Unknown C++ symbol name `%s'", 0, 0};
233 static struct complaint rs6000_builtin_complaint
=
234 {"Unknown builtin type %d", 0, 0};
236 static struct complaint unresolved_sym_chain_complaint
=
237 {"%s: common block `%s' from global_sym_chain unresolved", 0, 0};
239 static struct complaint stabs_general_complaint
=
242 static struct complaint lrs_general_complaint
=
245 /* Make a list of forward references which haven't been defined. */
247 static struct type
**undef_types
;
248 static int undef_types_allocated
;
249 static int undef_types_length
;
250 static struct symbol
*current_symbol
= NULL
;
252 /* Check for and handle cretinous stabs symbol name continuation! */
253 #define STABS_CONTINUE(pp,objfile) \
255 if (**(pp) == '\\' || (**(pp) == '?' && (*(pp))[1] == '\0')) \
256 *(pp) = next_symbol_text (objfile); \
259 /* FIXME: These probably should be our own types (like rs6000_builtin_type
260 has its own types) rather than builtin_type_*. */
261 static struct type
**os9k_type_vector
[] = {
267 &builtin_type_unsigned_char
,
268 &builtin_type_unsigned_short
,
269 &builtin_type_unsigned_long
,
270 &builtin_type_unsigned_int
,
272 &builtin_type_double
,
274 &builtin_type_long_double
277 static void os9k_init_type_vector
PARAMS ((struct type
**));
280 os9k_init_type_vector(tv
)
284 for (i
=0; i
<sizeof(os9k_type_vector
)/sizeof(struct type
**); i
++)
285 tv
[i
] = (os9k_type_vector
[i
] == 0 ? 0 : *(os9k_type_vector
[i
]));
288 /* Look up a dbx type-number pair. Return the address of the slot
289 where the type for that number-pair is stored.
290 The number-pair is in TYPENUMS.
292 This can be used for finding the type associated with that pair
293 or for associating a new type with the pair. */
296 dbx_lookup_type (typenums
)
299 register int filenum
= typenums
[0];
300 register int index
= typenums
[1];
302 register int real_filenum
;
303 register struct header_file
*f
;
306 if (filenum
== -1) /* -1,-1 is for temporary types. */
309 if (filenum
< 0 || filenum
>= n_this_object_header_files
)
311 static struct complaint msg
= {"\
312 Invalid symbol data: type number (%d,%d) out of range at symtab pos %d.",
314 complain (&msg
, filenum
, index
, symnum
);
322 /* Caller wants address of address of type. We think
323 that negative (rs6k builtin) types will never appear as
324 "lvalues", (nor should they), so we stuff the real type
325 pointer into a temp, and return its address. If referenced,
326 this will do the right thing. */
327 static struct type
*temp_type
;
329 temp_type
= rs6000_builtin_type(index
);
333 /* Type is defined outside of header files.
334 Find it in this object file's type vector. */
335 if (index
>= type_vector_length
)
337 old_len
= type_vector_length
;
340 type_vector_length
= INITIAL_TYPE_VECTOR_LENGTH
;
341 type_vector
= (struct type
**)
342 xmalloc (type_vector_length
* sizeof (struct type
*));
344 while (index
>= type_vector_length
)
346 type_vector_length
*= 2;
348 type_vector
= (struct type
**)
349 xrealloc ((char *) type_vector
,
350 (type_vector_length
* sizeof (struct type
*)));
351 memset (&type_vector
[old_len
], 0,
352 (type_vector_length
- old_len
) * sizeof (struct type
*));
355 /* Deal with OS9000 fundamental types. */
356 os9k_init_type_vector (type_vector
);
358 return (&type_vector
[index
]);
362 real_filenum
= this_object_header_files
[filenum
];
364 if (real_filenum
>= N_HEADER_FILES (current_objfile
))
366 struct type
*temp_type
;
367 struct type
**temp_type_p
;
369 warning ("GDB internal error: bad real_filenum");
372 temp_type
= init_type (TYPE_CODE_ERROR
, 0, 0, NULL
, NULL
);
373 temp_type_p
= (struct type
**) xmalloc (sizeof (struct type
*));
374 *temp_type_p
= temp_type
;
378 f
= HEADER_FILES (current_objfile
) + real_filenum
;
380 f_orig_length
= f
->length
;
381 if (index
>= f_orig_length
)
383 while (index
>= f
->length
)
387 f
->vector
= (struct type
**)
388 xrealloc ((char *) f
->vector
, f
->length
* sizeof (struct type
*));
389 memset (&f
->vector
[f_orig_length
], 0,
390 (f
->length
- f_orig_length
) * sizeof (struct type
*));
392 return (&f
->vector
[index
]);
396 /* Make sure there is a type allocated for type numbers TYPENUMS
397 and return the type object.
398 This can create an empty (zeroed) type object.
399 TYPENUMS may be (-1, -1) to return a new type object that is not
400 put into the type vector, and so may not be referred to by number. */
403 dbx_alloc_type (typenums
, objfile
)
405 struct objfile
*objfile
;
407 register struct type
**type_addr
;
409 if (typenums
[0] == -1)
411 return (alloc_type (objfile
));
414 type_addr
= dbx_lookup_type (typenums
);
416 /* If we are referring to a type not known at all yet,
417 allocate an empty type for it.
418 We will fill it in later if we find out how. */
421 *type_addr
= alloc_type (objfile
);
427 /* for all the stabs in a given stab vector, build appropriate types
428 and fix their symbols in given symbol vector. */
431 patch_block_stabs (symbols
, stabs
, objfile
)
432 struct pending
*symbols
;
433 struct pending_stabs
*stabs
;
434 struct objfile
*objfile
;
444 /* for all the stab entries, find their corresponding symbols and
445 patch their types! */
447 for (ii
= 0; ii
< stabs
->count
; ++ii
)
449 name
= stabs
->stab
[ii
];
450 pp
= (char*) strchr (name
, ':');
454 pp
= (char *)strchr(pp
, ':');
456 sym
= find_symbol_in_list (symbols
, name
, pp
-name
);
459 /* FIXME-maybe: it would be nice if we noticed whether
460 the variable was defined *anywhere*, not just whether
461 it is defined in this compilation unit. But neither
462 xlc or GCC seem to need such a definition, and until
463 we do psymtabs (so that the minimal symbols from all
464 compilation units are available now), I'm not sure
465 how to get the information. */
467 /* On xcoff, if a global is defined and never referenced,
468 ld will remove it from the executable. There is then
469 a N_GSYM stab for it, but no regular (C_EXT) symbol. */
470 sym
= (struct symbol
*)
471 obstack_alloc (&objfile
->symbol_obstack
,
472 sizeof (struct symbol
));
474 memset (sym
, 0, sizeof (struct symbol
));
475 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
476 SYMBOL_CLASS (sym
) = LOC_OPTIMIZED_OUT
;
478 obsavestring (name
, pp
- name
, &objfile
->symbol_obstack
);
480 if (*(pp
-1) == 'F' || *(pp
-1) == 'f')
482 /* I don't think the linker does this with functions,
483 so as far as I know this is never executed.
484 But it doesn't hurt to check. */
486 lookup_function_type (read_type (&pp
, objfile
));
490 SYMBOL_TYPE (sym
) = read_type (&pp
, objfile
);
492 add_symbol_to_list (sym
, &global_symbols
);
497 if (*(pp
-1) == 'F' || *(pp
-1) == 'f')
500 lookup_function_type (read_type (&pp
, objfile
));
504 SYMBOL_TYPE (sym
) = read_type (&pp
, objfile
);
512 /* Read a number by which a type is referred to in dbx data,
513 or perhaps read a pair (FILENUM, TYPENUM) in parentheses.
514 Just a single number N is equivalent to (0,N).
515 Return the two numbers by storing them in the vector TYPENUMS.
516 TYPENUMS will then be used as an argument to dbx_lookup_type.
518 Returns 0 for success, -1 for error. */
521 read_type_number (pp
, typenums
)
523 register int *typenums
;
529 typenums
[0] = read_huge_number (pp
, ',', &nbits
);
530 if (nbits
!= 0) return -1;
531 typenums
[1] = read_huge_number (pp
, ')', &nbits
);
532 if (nbits
!= 0) return -1;
537 typenums
[1] = read_huge_number (pp
, 0, &nbits
);
538 if (nbits
!= 0) return -1;
544 #if !defined (REG_STRUCT_HAS_ADDR)
545 #define REG_STRUCT_HAS_ADDR(gcc_p,type) 0
548 #define VISIBILITY_PRIVATE '0' /* Stabs character for private field */
549 #define VISIBILITY_PROTECTED '1' /* Stabs character for protected fld */
550 #define VISIBILITY_PUBLIC '2' /* Stabs character for public field */
551 #define VISIBILITY_IGNORE '9' /* Optimized out or zero length */
553 #define CFRONT_VISIBILITY_PRIVATE '2' /* Stabs character for private field */
554 #define CFRONT_VISIBILITY_PUBLIC '1' /* Stabs character for public field */
556 /* This code added to support parsing of ARM/Cfront stabs strings */
558 /* Get substring from string up to char c, advance string pointer past
579 /* Physname gets strcat'd onto sname in order to recreate the mangled
580 name (see funtion gdb_mangle_name in gdbtypes.c). For cfront, make
581 the physname look like that of g++ - take out the initial mangling
582 eg: for sname="a" and fname="foo__1aFPFs_i" return "FPFs_i" */
585 get_cfront_method_physname (fname
)
589 /* FIXME would like to make this generic for g++ too, but
590 that is already handled in read_member_funcctions */
593 /* search ahead to find the start of the mangled suffix */
594 if (*p
== '_' && *(p
+1)=='_') /* compiler generated; probably a ctor/dtor */
596 while (p
&& (unsigned) ((p
+1) - fname
) < strlen (fname
) && *(p
+1) != '_')
598 if (!(p
&& *p
== '_' && *(p
+1) == '_'))
599 error ("Invalid mangled function name %s",fname
);
600 p
+= 2; /* advance past '__' */
602 /* struct name length and name of type should come next; advance past it */
605 len
= len
* 10 + (*p
- '0');
613 /* Read base classes within cfront class definition.
614 eg: A:ZcA;1@Bpub v2@Bvirpri;__ct__1AFv func__1AFv *sfunc__1AFv ;as__1A ;;
617 A:ZcA;;foopri__1AFv foopro__1AFv __ct__1AFv __ct__1AFRC1A foopub__1AFv ;;;
622 read_cfront_baseclasses (fip
, pp
, type
, objfile
)
623 struct field_info
*fip
;
624 struct objfile
*objfile
;
628 static struct complaint msg_unknown
= {"\
629 Unsupported token in stabs string %s.\n",
631 static struct complaint msg_notfound
= {"\
632 Unable to find base type for %s.\n",
637 struct nextfield
*new;
639 if (**pp
== ';') /* no base classes; return */
645 /* first count base classes so we can allocate space before parsing */
646 for (p
= *pp
; p
&& *p
&& *p
!= ';'; p
++)
651 bnum
++; /* add one more for last one */
653 /* now parse the base classes until we get to the start of the methods
654 (code extracted and munged from read_baseclasses) */
655 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
656 TYPE_N_BASECLASSES(type
) = bnum
;
660 int num_bytes
= B_BYTES (TYPE_N_BASECLASSES (type
));
663 pointer
= (char *) TYPE_ALLOC (type
, num_bytes
);
664 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*) pointer
;
666 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), TYPE_N_BASECLASSES (type
));
668 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
670 new = (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
671 make_cleanup (free
, new);
672 memset (new, 0, sizeof (struct nextfield
));
673 new -> next
= fip
-> list
;
675 FIELD_BITSIZE (new->field
) = 0; /* this should be an unpacked field! */
677 STABS_CONTINUE (pp
, objfile
);
679 /* virtual? eg: v2@Bvir */
682 SET_TYPE_FIELD_VIRTUAL (type
, i
);
686 /* access? eg: 2@Bvir */
687 /* Note: protected inheritance not supported in cfront */
690 case CFRONT_VISIBILITY_PRIVATE
:
691 new -> visibility
= VISIBILITY_PRIVATE
;
693 case CFRONT_VISIBILITY_PUBLIC
:
694 new -> visibility
= VISIBILITY_PUBLIC
;
697 /* Bad visibility format. Complain and treat it as
700 static struct complaint msg
= {
701 "Unknown visibility `%c' for baseclass", 0, 0};
702 complain (&msg
, new -> visibility
);
703 new -> visibility
= VISIBILITY_PUBLIC
;
707 /* "@" comes next - eg: @Bvir */
710 complain (&msg_unknown
, *pp
);
716 /* Set the bit offset of the portion of the object corresponding
717 to this baseclass. Always zero in the absence of
718 multiple inheritance. */
719 /* Unable to read bit position from stabs;
720 Assuming no multiple inheritance for now FIXME! */
721 /* We may have read this in the structure definition;
722 now we should fixup the members to be the actual base classes */
723 FIELD_BITPOS (new->field
) = 0;
725 /* Get the base class name and type */
727 char * bname
; /* base class name */
728 struct symbol
* bsym
; /* base class */
730 p1
= strchr (*pp
,' ');
731 p2
= strchr (*pp
,';');
733 bname
= get_substring (pp
,' ');
735 bname
= get_substring (pp
,';');
736 if (!bname
|| !*bname
)
738 complain (&msg_unknown
, *pp
);
741 /* FIXME! attach base info to type */
742 bsym
= lookup_symbol (bname
, 0, STRUCT_NAMESPACE
, 0, 0); /*demangled_name*/
745 new -> field
.type
= SYMBOL_TYPE(bsym
);
746 new -> field
.name
= type_name_no_tag (new -> field
.type
);
750 complain (&msg_notfound
, *pp
);
755 /* If more base classes to parse, loop again.
756 We ate the last ' ' or ';' in get_substring,
757 so on exit we will have skipped the trailing ';' */
758 /* if invalid, return 0; add code to detect - FIXME! */
763 /* read cfront member functions.
764 pp points to string starting with list of functions
765 eg: A:ZcA;1@Bpub v2@Bvirpri;__ct__1AFv func__1AFv *sfunc__1AFv ;as__1A ;;
766 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
767 A:ZcA;;foopri__1AFv foopro__1AFv __ct__1AFv __ct__1AFRC1A foopub__1AFv ;;;
768 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
772 read_cfront_member_functions (fip
, pp
, type
, objfile
)
773 struct field_info
*fip
;
776 struct objfile
*objfile
;
778 /* This code extracted from read_member_functions
779 so as to do the similar thing for our funcs */
783 /* Total number of member functions defined in this class. If the class
784 defines two `f' functions, and one `g' function, then this will have
786 int total_length
= 0;
790 struct next_fnfield
*next
;
791 struct fn_field fn_field
;
793 struct type
*look_ahead_type
;
794 struct next_fnfieldlist
*new_fnlist
;
795 struct next_fnfield
*new_sublist
;
798 struct symbol
* ref_func
= 0;
800 /* Process each list until we find the end of the member functions.
801 eg: p = "__ct__1AFv foo__1AFv ;;;" */
803 STABS_CONTINUE (pp
, objfile
); /* handle \\ */
805 while (**pp
!= ';' && (fname
= get_substring (pp
, ' '), fname
))
808 int sublist_count
= 0;
810 if (fname
[0] == '*') /* static member */
816 ref_func
= lookup_symbol (fname
, 0, VAR_NAMESPACE
, 0, 0); /* demangled name */
819 static struct complaint msg
= {"\
820 Unable to find function symbol for %s\n",
822 complain (&msg
, fname
);
826 look_ahead_type
= NULL
;
829 new_fnlist
= (struct next_fnfieldlist
*)
830 xmalloc (sizeof (struct next_fnfieldlist
));
831 make_cleanup (free
, new_fnlist
);
832 memset (new_fnlist
, 0, sizeof (struct next_fnfieldlist
));
834 /* The following is code to work around cfront generated stabs.
835 The stabs contains full mangled name for each field.
836 We try to demangle the name and extract the field name out of it. */
838 char *dem
, *dem_p
, *dem_args
;
840 dem
= cplus_demangle (fname
, DMGL_ANSI
| DMGL_PARAMS
);
843 dem_p
= strrchr (dem
, ':');
844 if (dem_p
!= 0 && *(dem_p
-1) == ':')
846 /* get rid of args */
847 dem_args
= strchr (dem_p
, '(');
848 if (dem_args
== NULL
)
849 dem_len
= strlen (dem_p
);
851 dem_len
= dem_args
- dem_p
;
853 obsavestring (dem_p
, dem_len
, &objfile
-> type_obstack
);
858 obsavestring (fname
, strlen (fname
), &objfile
-> type_obstack
);
860 } /* end of code for cfront work around */
862 new_fnlist
-> fn_fieldlist
.name
= main_fn_name
;
864 /*-------------------------------------------------*/
865 /* Set up the sublists
866 Sublists are stuff like args, static, visibility, etc.
867 so in ARM, we have to set that info some other way.
868 Multiple sublists happen if overloading
869 eg: foo::26=##1;:;2A.;
870 In g++, we'd loop here thru all the sublists... */
873 (struct next_fnfield
*) xmalloc (sizeof (struct next_fnfield
));
874 make_cleanup (free
, new_sublist
);
875 memset (new_sublist
, 0, sizeof (struct next_fnfield
));
877 /* eat 1; from :;2A.; */
878 new_sublist
-> fn_field
.type
= SYMBOL_TYPE(ref_func
); /* normally takes a read_type */
879 /* Make this type look like a method stub for gdb */
880 TYPE_FLAGS (new_sublist
-> fn_field
.type
) |= TYPE_FLAG_STUB
;
881 TYPE_CODE (new_sublist
-> fn_field
.type
) = TYPE_CODE_METHOD
;
883 /* If this is just a stub, then we don't have the real name here. */
884 if (TYPE_FLAGS (new_sublist
-> fn_field
.type
) & TYPE_FLAG_STUB
)
886 if (!TYPE_DOMAIN_TYPE (new_sublist
-> fn_field
.type
))
887 TYPE_DOMAIN_TYPE (new_sublist
-> fn_field
.type
) = type
;
888 new_sublist
-> fn_field
.is_stub
= 1;
891 /* physname used later in mangling; eg PFs_i,5 for foo__1aFPFs_i
892 physname gets strcat'd in order to recreate the onto mangled name */
893 pname
= get_cfront_method_physname (fname
);
894 new_sublist
-> fn_field
.physname
= savestring (pname
, strlen (pname
));
897 /* Set this member function's visibility fields.
898 Unable to distinguish access from stabs definition!
899 Assuming public for now. FIXME!
900 (for private, set new_sublist->fn_field.is_private = 1,
901 for public, set new_sublist->fn_field.is_protected = 1) */
903 /* Unable to distinguish const/volatile from stabs definition!
904 Assuming normal for now. FIXME! */
906 new_sublist
-> fn_field
.is_const
= 0;
907 new_sublist
-> fn_field
.is_volatile
= 0; /* volatile not implemented in cfront */
909 /* Set virtual/static function info
910 How to get vtable offsets ?
911 Assuming normal for now FIXME!!
912 For vtables, figure out from whence this virtual function came.
913 It may belong to virtual function table of
914 one of its baseclasses.
916 new_sublist -> fn_field.voffset = vtable offset,
917 new_sublist -> fn_field.fcontext = look_ahead_type;
918 where look_ahead_type is type of baseclass */
920 new_sublist
-> fn_field
.voffset
= VOFFSET_STATIC
;
921 else /* normal member function. */
922 new_sublist
-> fn_field
.voffset
= 0;
923 new_sublist
-> fn_field
.fcontext
= 0;
926 /* Prepare new sublist */
927 new_sublist
-> next
= sublist
;
928 sublist
= new_sublist
;
931 /* In g++, we loop thu sublists - now we set from functions. */
932 new_fnlist
-> fn_fieldlist
.fn_fields
= (struct fn_field
*)
933 obstack_alloc (&objfile
-> type_obstack
,
934 sizeof (struct fn_field
) * length
);
935 memset (new_fnlist
-> fn_fieldlist
.fn_fields
, 0,
936 sizeof (struct fn_field
) * length
);
937 for (i
= length
; (i
--, sublist
); sublist
= sublist
-> next
)
939 new_fnlist
-> fn_fieldlist
.fn_fields
[i
] = sublist
-> fn_field
;
942 new_fnlist
-> fn_fieldlist
.length
= length
;
943 new_fnlist
-> next
= fip
-> fnlist
;
944 fip
-> fnlist
= new_fnlist
;
946 total_length
+= length
;
947 STABS_CONTINUE (pp
, objfile
); /* handle \\ */
952 /* type should already have space */
953 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
954 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * nfn_fields
);
955 memset (TYPE_FN_FIELDLISTS (type
), 0,
956 sizeof (struct fn_fieldlist
) * nfn_fields
);
957 TYPE_NFN_FIELDS (type
) = nfn_fields
;
958 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
961 /* end of scope for reading member func */
965 /* Skip trailing ';' and bump count of number of fields seen */
973 /* This routine fixes up partial cfront types that were created
974 while parsing the stabs. The main need for this function is
975 to add information such as methods to classes.
976 Examples of "p": "sA;;__ct__1AFv foo__1AFv ;;;" */
978 resolve_cfront_continuation (objfile
, sym
, p
)
979 struct objfile
* objfile
;
983 struct symbol
* ref_sym
=0;
985 /* snarfed from read_struct_type */
986 struct field_info fi
;
988 struct cleanup
*back_to
;
990 /* Need to make sure that fi isn't gunna conflict with struct
991 in case struct already had some fnfs */
994 back_to
= make_cleanup (null_cleanup
, 0);
996 /* We only accept structs, classes and unions at the moment.
997 Other continuation types include t (typedef), r (long dbl), ...
998 We may want to add support for them as well;
999 right now they are handled by duplicating the symbol information
1000 into the type information (see define_symbol) */
1001 if (*p
!= 's' /* structs */
1002 && *p
!= 'c' /* class */
1003 && *p
!= 'u') /* union */
1004 return 0; /* only handle C++ types */
1007 /* Get symbol typs name and validate
1008 eg: p = "A;;__ct__1AFv foo__1AFv ;;;" */
1009 sname
= get_substring (&p
, ';');
1010 if (!sname
|| strcmp (sname
, SYMBOL_NAME(sym
)))
1011 error ("Internal error: base symbol type name does not match\n");
1013 /* Find symbol's internal gdb reference using demangled_name.
1014 This is the real sym that we want;
1015 sym was a temp hack to make debugger happy */
1016 ref_sym
= lookup_symbol (SYMBOL_NAME(sym
), 0, STRUCT_NAMESPACE
, 0, 0);
1017 type
= SYMBOL_TYPE(ref_sym
);
1020 /* Now read the baseclasses, if any, read the regular C struct or C++
1021 class member fields, attach the fields to the type, read the C++
1022 member functions, attach them to the type, and then read any tilde
1023 field (baseclass specifier for the class holding the main vtable). */
1025 if (!read_cfront_baseclasses (&fi
, &p
, type
, objfile
)
1026 /* g++ does this next, but cfront already did this:
1027 || !read_struct_fields (&fi, &p, type, objfile) */
1028 || !copy_cfront_struct_fields (&fi
, type
, objfile
)
1029 || !read_cfront_member_functions (&fi
, &p
, type
, objfile
)
1030 || !read_cfront_static_fields (&fi
, &p
, type
, objfile
)
1031 || !attach_fields_to_type (&fi
, type
, objfile
)
1032 || !attach_fn_fields_to_type (&fi
, type
)
1033 /* g++ does this next, but cfront doesn't seem to have this:
1034 || !read_tilde_fields (&fi, &p, type, objfile) */
1037 type
= error_type (&p
, objfile
);
1040 do_cleanups (back_to
);
1043 /* End of code added to support parsing of ARM/Cfront stabs strings */
1046 /* This routine fixes up symbol references/aliases to point to the original
1047 symbol definition. Returns 0 on failure, non-zero on success. */
1050 resolve_symbol_reference (objfile
, sym
, p
)
1051 struct objfile
*objfile
;
1056 struct symbol
*ref_sym
=0;
1057 struct alias_list
*alias
;
1059 /* If this is not a symbol reference return now. */
1063 /* Use "#<num>" as the name; we'll fix the name later.
1064 We stored the original symbol name as "#<id>=<name>"
1065 so we can now search for "#<id>" to resolving the reference.
1066 We'll fix the names later by removing the "#<id>" or "#<id>=" */
1068 /*---------------------------------------------------------*/
1069 /* Get the reference id number, and
1070 advance p past the names so we can parse the rest.
1071 eg: id=2 for p : "2=", "2=z:r(0,1)" "2:r(0,1);l(#5,#6),l(#7,#4)" */
1072 /*---------------------------------------------------------*/
1074 /* This gets reference name from string. sym may not have a name. */
1076 /* Get the reference number associated with the reference id in the
1077 gdb stab string. From that reference number, get the main/primary
1078 symbol for this alias. */
1079 refnum
= process_reference (&p
);
1080 ref_sym
= ref_search (refnum
);
1083 complain (&lrs_general_complaint
, "symbol for reference not found");
1087 /* Parse the stab of the referencing symbol
1088 now that we have the referenced symbol.
1089 Add it as a new symbol and a link back to the referenced symbol.
1090 eg: p : "=", "=z:r(0,1)" ":r(0,1);l(#5,#6),l(#7,#4)" */
1093 /* If the stab symbol table and string contain:
1094 RSYM 0 5 00000000 868 #15=z:r(0,1)
1095 LBRAC 0 0 00000000 899 #5=
1096 SLINE 0 16 00000003 923 #6=
1097 Then the same symbols can be later referenced by:
1098 RSYM 0 5 00000000 927 #15:r(0,1);l(#5,#6)
1099 This is used in live range splitting to:
1100 1) specify that a symbol (#15) is actually just a new storage
1101 class for a symbol (#15=z) which was previously defined.
1102 2) specify that the beginning and ending ranges for a symbol
1103 (#15) are the values of the beginning (#5) and ending (#6)
1106 /* Read number as reference id.
1107 eg: p : "=", "=z:r(0,1)" ":r(0,1);l(#5,#6),l(#7,#4)" */
1108 /* FIXME! Might I want to use SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
1109 in case of "l(0,0)"? */
1111 /*--------------------------------------------------*/
1112 /* Add this symbol to the reference list. */
1113 /*--------------------------------------------------*/
1115 alias
= (struct alias_list
*) obstack_alloc (&objfile
->type_obstack
,
1116 sizeof (struct alias_list
));
1119 complain (&lrs_general_complaint
, "Unable to allocate alias list memory");
1126 if (!SYMBOL_ALIASES (ref_sym
))
1128 SYMBOL_ALIASES (ref_sym
) = alias
;
1132 struct alias_list
*temp
;
1134 /* Get to the end of the list. */
1135 for (temp
= SYMBOL_ALIASES (ref_sym
);
1142 /* Want to fix up name so that other functions (eg. valops)
1143 will correctly print the name.
1144 Don't add_symbol_to_list so that lookup_symbol won't find it.
1145 nope... needed for fixups. */
1146 SYMBOL_NAME (sym
) = SYMBOL_NAME (ref_sym
);
1152 /* Structure for storing pointers to reference definitions for fast lookup
1153 during "process_later". */
1162 #define MAX_CHUNK_REFS 100
1163 #define REF_CHUNK_SIZE (MAX_CHUNK_REFS * sizeof (struct ref_map))
1164 #define REF_MAP_SIZE(ref_chunk) ((ref_chunk) * REF_CHUNK_SIZE)
1166 static struct ref_map
*ref_map
;
1168 /* Ptr to free cell in chunk's linked list. */
1169 static int ref_count
= 0;
1171 /* Number of chunks malloced. */
1172 static int ref_chunk
= 0;
1174 /* Create array of pointers mapping refids to symbols and stab strings.
1175 Add pointers to reference definition symbols and/or their values as we
1176 find them, using their reference numbers as our index.
1177 These will be used later when we resolve references. */
1179 ref_add (refnum
, sym
, stabs
, value
)
1187 if (refnum
>= ref_count
)
1188 ref_count
= refnum
+ 1;
1189 if (ref_count
> ref_chunk
* MAX_CHUNK_REFS
)
1191 int new_slots
= ref_count
- ref_chunk
* MAX_CHUNK_REFS
;
1192 int new_chunks
= new_slots
/ MAX_CHUNK_REFS
+ 1;
1193 ref_map
= (struct ref_map
*)
1194 xrealloc (ref_map
, REF_MAP_SIZE (ref_chunk
+ new_chunks
));
1195 memset (ref_map
+ ref_chunk
* MAX_CHUNK_REFS
, 0, new_chunks
* REF_CHUNK_SIZE
);
1196 ref_chunk
+= new_chunks
;
1198 ref_map
[refnum
].stabs
= stabs
;
1199 ref_map
[refnum
].sym
= sym
;
1200 ref_map
[refnum
].value
= value
;
1203 /* Return defined sym for the reference REFNUM. */
1208 if (refnum
< 0 || refnum
> ref_count
)
1210 return ref_map
[refnum
].sym
;
1213 /* Return value for the reference REFNUM. */
1216 ref_search_value (refnum
)
1219 if (refnum
< 0 || refnum
> ref_count
)
1221 return ref_map
[refnum
].value
;
1224 /* Parse a reference id in STRING and return the resulting
1225 reference number. Move STRING beyond the reference id. */
1228 process_reference (string
)
1234 if (**string
!= '#')
1237 /* Advance beyond the initial '#'. */
1240 /* Read number as reference id. */
1241 while (*p
&& isdigit (*p
))
1243 refnum
= refnum
* 10 + *p
- '0';
1250 /* If STRING defines a reference, store away a pointer to the reference
1251 definition for later use. Return the reference number. */
1254 symbol_reference_defined (string
)
1260 refnum
= process_reference (&p
);
1262 /* Defining symbols end in '=' */
1265 /* Symbol is being defined here. */
1271 /* Must be a reference. Either the symbol has already been defined,
1272 or this is a forward reference to it. */
1280 define_symbol (valu
, string
, desc
, type
, objfile
)
1285 struct objfile
*objfile
;
1287 register struct symbol
*sym
;
1288 char *p
= (char *) strchr (string
, ':');
1293 /* We would like to eliminate nameless symbols, but keep their types.
1294 E.g. stab entry ":t10=*2" should produce a type 10, which is a pointer
1295 to type 2, but, should not create a symbol to address that type. Since
1296 the symbol will be nameless, there is no way any user can refer to it. */
1300 /* Ignore syms with empty names. */
1304 /* Ignore old-style symbols from cc -go */
1311 p
= strchr (p
, ':');
1314 /* If a nameless stab entry, all we need is the type, not the symbol.
1315 e.g. ":t10=*2" or a nameless enum like " :T16=ered:0,green:1,blue:2,;" */
1316 nameless
= (p
== string
|| ((string
[0] == ' ') && (string
[1] == ':')));
1318 current_symbol
= sym
= (struct symbol
*)
1319 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
1320 memset (sym
, 0, sizeof (struct symbol
));
1322 switch (type
& N_TYPE
)
1325 SYMBOL_SECTION(sym
) = SECT_OFF_TEXT
;
1328 SYMBOL_SECTION(sym
) = SECT_OFF_DATA
;
1331 SYMBOL_SECTION(sym
) = SECT_OFF_BSS
;
1335 if (processing_gcc_compilation
)
1337 /* GCC 2.x puts the line number in desc. SunOS apparently puts in the
1338 number of bytes occupied by a type or object, which we ignore. */
1339 SYMBOL_LINE(sym
) = desc
;
1343 SYMBOL_LINE(sym
) = 0; /* unknown */
1346 if (is_cplus_marker (string
[0]))
1348 /* Special GNU C++ names. */
1352 SYMBOL_NAME (sym
) = obsavestring ("this", strlen ("this"),
1353 &objfile
-> symbol_obstack
);
1356 case 'v': /* $vtbl_ptr_type */
1357 /* Was: SYMBOL_NAME (sym) = "vptr"; */
1361 SYMBOL_NAME (sym
) = obsavestring ("eh_throw", strlen ("eh_throw"),
1362 &objfile
-> symbol_obstack
);
1366 /* This was an anonymous type that was never fixed up. */
1369 #ifdef STATIC_TRANSFORM_NAME
1371 /* SunPRO (3.0 at least) static variable encoding. */
1376 complain (&unrecognized_cplus_name_complaint
, string
);
1377 goto normal
; /* Do *something* with it */
1380 else if (string
[0] == '#')
1382 /* Special GNU C extension for referencing symbols. */
1386 /* If STRING defines a new reference id, then add it to the
1387 reference map. Else it must be referring to a previously
1388 defined symbol, so add it to the alias list of the previously
1391 refnum
= symbol_reference_defined (&s
);
1393 ref_add (refnum
, sym
, string
, SYMBOL_VALUE (sym
));
1395 if (!resolve_symbol_reference (objfile
, sym
, string
))
1398 /* S..P contains the name of the symbol. We need to store
1399 the correct name into SYMBOL_NAME. */
1405 SYMBOL_NAME (sym
) = (char *)
1406 obstack_alloc (&objfile
-> symbol_obstack
, nlen
);
1407 strncpy (SYMBOL_NAME (sym
), s
, nlen
);
1408 SYMBOL_NAME (sym
)[nlen
] = '\0';
1409 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
->symbol_obstack
);
1412 /* FIXME! Want SYMBOL_NAME (sym) = 0;
1413 Get error if leave name 0. So give it something. */
1416 SYMBOL_NAME (sym
) = (char *)
1417 obstack_alloc (&objfile
-> symbol_obstack
, nlen
);
1418 strncpy (SYMBOL_NAME (sym
), string
, nlen
);
1419 SYMBOL_NAME (sym
)[nlen
] = '\0';
1420 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
->symbol_obstack
);
1423 /* Advance STRING beyond the reference id. */
1429 SYMBOL_LANGUAGE (sym
) = current_subfile
-> language
;
1430 SYMBOL_NAME (sym
) = (char *)
1431 obstack_alloc (&objfile
-> symbol_obstack
, ((p
- string
) + 1));
1432 /* Open-coded memcpy--saves function call time. */
1433 /* FIXME: Does it really? Try replacing with simple strcpy and
1434 try it on an executable with a large symbol table. */
1435 /* FIXME: considering that gcc can open code memcpy anyway, I
1436 doubt it. xoxorich. */
1438 register char *p1
= string
;
1439 register char *p2
= SYMBOL_NAME (sym
);
1447 /* If this symbol is from a C++ compilation, then attempt to cache the
1448 demangled form for future reference. This is a typical time versus
1449 space tradeoff, that was decided in favor of time because it sped up
1450 C++ symbol lookups by a factor of about 20. */
1452 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
->symbol_obstack
);
1456 /* Determine the type of name being defined. */
1458 /* Getting GDB to correctly skip the symbol on an undefined symbol
1459 descriptor and not ever dump core is a very dodgy proposition if
1460 we do things this way. I say the acorn RISC machine can just
1461 fix their compiler. */
1462 /* The Acorn RISC machine's compiler can put out locals that don't
1463 start with "234=" or "(3,4)=", so assume anything other than the
1464 deftypes we know how to handle is a local. */
1465 if (!strchr ("cfFGpPrStTvVXCR", *p
))
1467 if (isdigit (*p
) || *p
== '(' || *p
== '-')
1476 /* c is a special case, not followed by a type-number.
1477 SYMBOL:c=iVALUE for an integer constant symbol.
1478 SYMBOL:c=rVALUE for a floating constant symbol.
1479 SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
1480 e.g. "b:c=e6,0" for "const b = blob1"
1481 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
1484 SYMBOL_CLASS (sym
) = LOC_CONST
;
1485 SYMBOL_TYPE (sym
) = error_type (&p
, objfile
);
1486 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1487 add_symbol_to_list (sym
, &file_symbols
);
1495 double d
= atof (p
);
1498 /* FIXME-if-picky-about-floating-accuracy: Should be using
1499 target arithmetic to get the value. real.c in GCC
1500 probably has the necessary code. */
1502 /* FIXME: lookup_fundamental_type is a hack. We should be
1503 creating a type especially for the type of float constants.
1504 Problem is, what type should it be?
1506 Also, what should the name of this type be? Should we
1507 be using 'S' constants (see stabs.texinfo) instead? */
1509 SYMBOL_TYPE (sym
) = lookup_fundamental_type (objfile
,
1512 obstack_alloc (&objfile
-> symbol_obstack
,
1513 TYPE_LENGTH (SYMBOL_TYPE (sym
)));
1514 store_floating (dbl_valu
, TYPE_LENGTH (SYMBOL_TYPE (sym
)), d
);
1515 SYMBOL_VALUE_BYTES (sym
) = dbl_valu
;
1516 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
1521 /* Defining integer constants this way is kind of silly,
1522 since 'e' constants allows the compiler to give not
1523 only the value, but the type as well. C has at least
1524 int, long, unsigned int, and long long as constant
1525 types; other languages probably should have at least
1526 unsigned as well as signed constants. */
1528 /* We just need one int constant type for all objfiles.
1529 It doesn't depend on languages or anything (arguably its
1530 name should be a language-specific name for a type of
1531 that size, but I'm inclined to say that if the compiler
1532 wants a nice name for the type, it can use 'e'). */
1533 static struct type
*int_const_type
;
1535 /* Yes, this is as long as a *host* int. That is because we
1537 if (int_const_type
== NULL
)
1539 init_type (TYPE_CODE_INT
,
1540 sizeof (int) * HOST_CHAR_BIT
/ TARGET_CHAR_BIT
, 0,
1542 (struct objfile
*)NULL
);
1543 SYMBOL_TYPE (sym
) = int_const_type
;
1544 SYMBOL_VALUE (sym
) = atoi (p
);
1545 SYMBOL_CLASS (sym
) = LOC_CONST
;
1549 /* SYMBOL:c=eTYPE,INTVALUE for a constant symbol whose value
1550 can be represented as integral.
1551 e.g. "b:c=e6,0" for "const b = blob1"
1552 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
1554 SYMBOL_CLASS (sym
) = LOC_CONST
;
1555 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1559 SYMBOL_TYPE (sym
) = error_type (&p
, objfile
);
1564 /* If the value is too big to fit in an int (perhaps because
1565 it is unsigned), or something like that, we silently get
1566 a bogus value. The type and everything else about it is
1567 correct. Ideally, we should be using whatever we have
1568 available for parsing unsigned and long long values,
1570 SYMBOL_VALUE (sym
) = atoi (p
);
1575 SYMBOL_CLASS (sym
) = LOC_CONST
;
1576 SYMBOL_TYPE (sym
) = error_type (&p
, objfile
);
1579 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1580 add_symbol_to_list (sym
, &file_symbols
);
1584 /* The name of a caught exception. */
1585 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1586 SYMBOL_CLASS (sym
) = LOC_LABEL
;
1587 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1588 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
1589 add_symbol_to_list (sym
, &local_symbols
);
1593 /* A static function definition. */
1594 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1595 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1596 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1597 add_symbol_to_list (sym
, &file_symbols
);
1598 /* fall into process_function_types. */
1600 process_function_types
:
1601 /* Function result types are described as the result type in stabs.
1602 We need to convert this to the function-returning-type-X type
1603 in GDB. E.g. "int" is converted to "function returning int". */
1604 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_FUNC
)
1605 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
1607 /* All functions in C++ have prototypes. */
1608 if (SYMBOL_LANGUAGE (sym
) == language_cplus
)
1609 TYPE_FLAGS (SYMBOL_TYPE (sym
)) |= TYPE_FLAG_PROTOTYPED
;
1611 /* fall into process_prototype_types */
1613 process_prototype_types
:
1614 /* Sun acc puts declared types of arguments here. */
1617 struct type
*ftype
= SYMBOL_TYPE (sym
);
1622 /* Obtain a worst case guess for the number of arguments
1623 by counting the semicolons. */
1630 /* Allocate parameter information fields and fill them in. */
1631 TYPE_FIELDS (ftype
) = (struct field
*)
1632 TYPE_ALLOC (ftype
, nsemi
* sizeof (struct field
));
1637 /* A type number of zero indicates the start of varargs.
1638 FIXME: GDB currently ignores vararg functions. */
1639 if (p
[0] == '0' && p
[1] == '\0')
1641 ptype
= read_type (&p
, objfile
);
1643 /* The Sun compilers mark integer arguments, which should
1644 be promoted to the width of the calling conventions, with
1645 a type which references itself. This type is turned into
1646 a TYPE_CODE_VOID type by read_type, and we have to turn
1647 it back into builtin_type_int here.
1648 FIXME: Do we need a new builtin_type_promoted_int_arg ? */
1649 if (TYPE_CODE (ptype
) == TYPE_CODE_VOID
)
1650 ptype
= builtin_type_int
;
1651 TYPE_FIELD_TYPE (ftype
, nparams
++) = ptype
;
1653 TYPE_NFIELDS (ftype
) = nparams
;
1654 TYPE_FLAGS (ftype
) |= TYPE_FLAG_PROTOTYPED
;
1659 /* A global function definition. */
1660 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1661 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1662 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1663 add_symbol_to_list (sym
, &global_symbols
);
1664 goto process_function_types
;
1667 /* For a class G (global) symbol, it appears that the
1668 value is not correct. It is necessary to search for the
1669 corresponding linker definition to find the value.
1670 These definitions appear at the end of the namelist. */
1671 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1672 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1673 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1674 /* Don't add symbol references to global_sym_chain.
1675 Symbol references don't have valid names and wont't match up with
1676 minimal symbols when the global_sym_chain is relocated.
1677 We'll fixup symbol references when we fixup the defining symbol. */
1678 if (SYMBOL_NAME (sym
) && SYMBOL_NAME (sym
)[0] != '#')
1680 i
= hashname (SYMBOL_NAME (sym
));
1681 SYMBOL_VALUE_CHAIN (sym
) = global_sym_chain
[i
];
1682 global_sym_chain
[i
] = sym
;
1684 add_symbol_to_list (sym
, &global_symbols
);
1687 /* This case is faked by a conditional above,
1688 when there is no code letter in the dbx data.
1689 Dbx data never actually contains 'l'. */
1692 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1693 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
1694 SYMBOL_VALUE (sym
) = valu
;
1695 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1696 add_symbol_to_list (sym
, &local_symbols
);
1701 /* pF is a two-letter code that means a function parameter in Fortran.
1702 The type-number specifies the type of the return value.
1703 Translate it into a pointer-to-function type. */
1707 = lookup_pointer_type
1708 (lookup_function_type (read_type (&p
, objfile
)));
1711 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1713 /* Normally this is a parameter, a LOC_ARG. On the i960, it
1714 can also be a LOC_LOCAL_ARG depending on symbol type. */
1715 #ifndef DBX_PARM_SYMBOL_CLASS
1716 #define DBX_PARM_SYMBOL_CLASS(type) LOC_ARG
1719 SYMBOL_CLASS (sym
) = DBX_PARM_SYMBOL_CLASS (type
);
1720 SYMBOL_VALUE (sym
) = valu
;
1721 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1722 add_symbol_to_list (sym
, &local_symbols
);
1724 if (TARGET_BYTE_ORDER
!= BIG_ENDIAN
)
1726 /* On little-endian machines, this crud is never necessary,
1727 and, if the extra bytes contain garbage, is harmful. */
1731 /* If it's gcc-compiled, if it says `short', believe it. */
1732 if (processing_gcc_compilation
|| BELIEVE_PCC_PROMOTION
)
1735 #if !BELIEVE_PCC_PROMOTION
1737 /* This is the signed type which arguments get promoted to. */
1738 static struct type
*pcc_promotion_type
;
1739 /* This is the unsigned type which arguments get promoted to. */
1740 static struct type
*pcc_unsigned_promotion_type
;
1742 /* Call it "int" because this is mainly C lossage. */
1743 if (pcc_promotion_type
== NULL
)
1744 pcc_promotion_type
=
1745 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
1748 if (pcc_unsigned_promotion_type
== NULL
)
1749 pcc_unsigned_promotion_type
=
1750 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
1751 TYPE_FLAG_UNSIGNED
, "unsigned int", NULL
);
1753 #if defined(BELIEVE_PCC_PROMOTION_TYPE)
1754 /* This macro is defined on machines (e.g. sparc) where
1755 we should believe the type of a PCC 'short' argument,
1756 but shouldn't believe the address (the address is
1757 the address of the corresponding int).
1759 My guess is that this correction, as opposed to changing
1760 the parameter to an 'int' (as done below, for PCC
1761 on most machines), is the right thing to do
1762 on all machines, but I don't want to risk breaking
1763 something that already works. On most PCC machines,
1764 the sparc problem doesn't come up because the calling
1765 function has to zero the top bytes (not knowing whether
1766 the called function wants an int or a short), so there
1767 is little practical difference between an int and a short
1768 (except perhaps what happens when the GDB user types
1769 "print short_arg = 0x10000;").
1771 Hacked for SunOS 4.1 by gnu@cygnus.com. In 4.1, the compiler
1772 actually produces the correct address (we don't need to fix it
1773 up). I made this code adapt so that it will offset the symbol
1774 if it was pointing at an int-aligned location and not
1775 otherwise. This way you can use the same gdb for 4.0.x and
1778 If the parameter is shorter than an int, and is integral
1779 (e.g. char, short, or unsigned equivalent), and is claimed to
1780 be passed on an integer boundary, don't believe it! Offset the
1781 parameter's address to the tail-end of that integer. */
1783 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (pcc_promotion_type
)
1784 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
1785 && 0 == SYMBOL_VALUE (sym
) % TYPE_LENGTH (pcc_promotion_type
))
1787 SYMBOL_VALUE (sym
) += TYPE_LENGTH (pcc_promotion_type
)
1788 - TYPE_LENGTH (SYMBOL_TYPE (sym
));
1792 #else /* no BELIEVE_PCC_PROMOTION_TYPE. */
1794 /* If PCC says a parameter is a short or a char,
1795 it is really an int. */
1796 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (pcc_promotion_type
)
1797 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
)
1800 TYPE_UNSIGNED (SYMBOL_TYPE (sym
))
1801 ? pcc_unsigned_promotion_type
1802 : pcc_promotion_type
;
1806 #endif /* no BELIEVE_PCC_PROMOTION_TYPE. */
1808 #endif /* !BELIEVE_PCC_PROMOTION. */
1811 /* acc seems to use P to declare the prototypes of functions that
1812 are referenced by this file. gdb is not prepared to deal
1813 with this extra information. FIXME, it ought to. */
1816 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1817 goto process_prototype_types
;
1822 /* Parameter which is in a register. */
1823 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1824 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
1825 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (valu
);
1826 if (SYMBOL_VALUE (sym
) >= NUM_REGS
)
1828 complain (®_value_complaint
, SYMBOL_VALUE (sym
), NUM_REGS
,
1829 SYMBOL_SOURCE_NAME (sym
));
1830 SYMBOL_VALUE (sym
) = SP_REGNUM
; /* Known safe, though useless */
1832 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1833 add_symbol_to_list (sym
, &local_symbols
);
1837 /* Register variable (either global or local). */
1838 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1839 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
1840 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (valu
);
1841 if (SYMBOL_VALUE (sym
) >= NUM_REGS
)
1843 complain (®_value_complaint
, SYMBOL_VALUE (sym
), NUM_REGS
,
1844 SYMBOL_SOURCE_NAME (sym
));
1845 SYMBOL_VALUE (sym
) = SP_REGNUM
; /* Known safe, though useless */
1847 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1848 if (within_function
)
1850 /* Sun cc uses a pair of symbols, one 'p' and one 'r' with the same
1851 name to represent an argument passed in a register.
1852 GCC uses 'P' for the same case. So if we find such a symbol pair
1853 we combine it into one 'P' symbol. For Sun cc we need to do this
1854 regardless of REG_STRUCT_HAS_ADDR, because the compiler puts out
1855 the 'p' symbol even if it never saves the argument onto the stack.
1857 On most machines, we want to preserve both symbols, so that
1858 we can still get information about what is going on with the
1859 stack (VAX for computing args_printed, using stack slots instead
1860 of saved registers in backtraces, etc.).
1862 Note that this code illegally combines
1863 main(argc) struct foo argc; { register struct foo argc; }
1864 but this case is considered pathological and causes a warning
1865 from a decent compiler. */
1868 && local_symbols
->nsyms
> 0
1869 #ifndef USE_REGISTER_NOT_ARG
1870 && REG_STRUCT_HAS_ADDR (processing_gcc_compilation
,
1872 && (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
1873 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_UNION
1874 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_SET
1875 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_BITSTRING
)
1879 struct symbol
*prev_sym
;
1880 prev_sym
= local_symbols
->symbol
[local_symbols
->nsyms
- 1];
1881 if ((SYMBOL_CLASS (prev_sym
) == LOC_REF_ARG
1882 || SYMBOL_CLASS (prev_sym
) == LOC_ARG
)
1883 && STREQ (SYMBOL_NAME (prev_sym
), SYMBOL_NAME(sym
)))
1885 SYMBOL_CLASS (prev_sym
) = LOC_REGPARM
;
1886 /* Use the type from the LOC_REGISTER; that is the type
1887 that is actually in that register. */
1888 SYMBOL_TYPE (prev_sym
) = SYMBOL_TYPE (sym
);
1889 SYMBOL_VALUE (prev_sym
) = SYMBOL_VALUE (sym
);
1894 add_symbol_to_list (sym
, &local_symbols
);
1897 add_symbol_to_list (sym
, &file_symbols
);
1901 /* Static symbol at top level of file */
1902 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1903 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1904 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
1905 #ifdef STATIC_TRANSFORM_NAME
1906 if (IS_STATIC_TRANSFORM_NAME (SYMBOL_NAME (sym
)))
1908 struct minimal_symbol
*msym
;
1909 msym
= lookup_minimal_symbol (SYMBOL_NAME (sym
), NULL
, objfile
);
1912 SYMBOL_NAME (sym
) = STATIC_TRANSFORM_NAME (SYMBOL_NAME (sym
));
1913 SYMBOL_VALUE_ADDRESS (sym
) = SYMBOL_VALUE_ADDRESS (msym
);
1917 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1918 add_symbol_to_list (sym
, &file_symbols
);
1922 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1924 /* For a nameless type, we don't want a create a symbol, thus we
1925 did not use `sym'. Return without further processing. */
1926 if (nameless
) return NULL
;
1928 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1929 SYMBOL_VALUE (sym
) = valu
;
1930 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1931 /* C++ vagaries: we may have a type which is derived from
1932 a base type which did not have its name defined when the
1933 derived class was output. We fill in the derived class's
1934 base part member's name here in that case. */
1935 if (TYPE_NAME (SYMBOL_TYPE (sym
)) != NULL
)
1936 if ((TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
1937 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_UNION
)
1938 && TYPE_N_BASECLASSES (SYMBOL_TYPE (sym
)))
1941 for (j
= TYPE_N_BASECLASSES (SYMBOL_TYPE (sym
)) - 1; j
>= 0; j
--)
1942 if (TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym
), j
) == 0)
1943 TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym
), j
) =
1944 type_name_no_tag (TYPE_BASECLASS (SYMBOL_TYPE (sym
), j
));
1947 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == NULL
)
1949 /* gcc-2.6 or later (when using -fvtable-thunks)
1950 emits a unique named type for a vtable entry.
1951 Some gdb code depends on that specific name. */
1952 extern const char vtbl_ptr_name
[];
1954 if ((TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_PTR
1955 && strcmp (SYMBOL_NAME (sym
), vtbl_ptr_name
))
1956 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FUNC
)
1958 /* If we are giving a name to a type such as "pointer to
1959 foo" or "function returning foo", we better not set
1960 the TYPE_NAME. If the program contains "typedef char
1961 *caddr_t;", we don't want all variables of type char
1962 * to print as caddr_t. This is not just a
1963 consequence of GDB's type management; PCC and GCC (at
1964 least through version 2.4) both output variables of
1965 either type char * or caddr_t with the type number
1966 defined in the 't' symbol for caddr_t. If a future
1967 compiler cleans this up it GDB is not ready for it
1968 yet, but if it becomes ready we somehow need to
1969 disable this check (without breaking the PCC/GCC2.4
1974 Fortunately, this check seems not to be necessary
1975 for anything except pointers or functions. */
1978 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_NAME (sym
);
1981 add_symbol_to_list (sym
, &file_symbols
);
1985 /* Struct, union, or enum tag. For GNU C++, this can be be followed
1986 by 't' which means we are typedef'ing it as well. */
1987 synonym
= *p
== 't';
1991 /* The semantics of C++ state that "struct foo { ... }" also defines
1992 a typedef for "foo". Unfortunately, cfront never makes the typedef
1993 when translating C++ into C. We make the typedef here so that
1994 "ptype foo" works as expected for cfront translated code. */
1995 else if (current_subfile
->language
== language_cplus
)
1998 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
2000 /* For a nameless type, we don't want a create a symbol, thus we
2001 did not use `sym'. Return without further processing. */
2002 if (nameless
) return NULL
;
2004 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
2005 SYMBOL_VALUE (sym
) = valu
;
2006 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
2007 if (TYPE_TAG_NAME (SYMBOL_TYPE (sym
)) == 0)
2008 TYPE_TAG_NAME (SYMBOL_TYPE (sym
))
2009 = obconcat (&objfile
-> type_obstack
, "", "", SYMBOL_NAME (sym
));
2010 add_symbol_to_list (sym
, &file_symbols
);
2014 /* Clone the sym and then modify it. */
2015 register struct symbol
*typedef_sym
= (struct symbol
*)
2016 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
2017 *typedef_sym
= *sym
;
2018 SYMBOL_CLASS (typedef_sym
) = LOC_TYPEDEF
;
2019 SYMBOL_VALUE (typedef_sym
) = valu
;
2020 SYMBOL_NAMESPACE (typedef_sym
) = VAR_NAMESPACE
;
2021 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
2022 TYPE_NAME (SYMBOL_TYPE (sym
))
2023 = obconcat (&objfile
-> type_obstack
, "", "", SYMBOL_NAME (sym
));
2024 add_symbol_to_list (typedef_sym
, &file_symbols
);
2029 /* Static symbol of local scope */
2030 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
2031 SYMBOL_CLASS (sym
) = LOC_STATIC
;
2032 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
2033 #ifdef STATIC_TRANSFORM_NAME
2034 if (IS_STATIC_TRANSFORM_NAME (SYMBOL_NAME (sym
)))
2036 struct minimal_symbol
*msym
;
2037 msym
= lookup_minimal_symbol (SYMBOL_NAME (sym
), NULL
, objfile
);
2040 SYMBOL_NAME (sym
) = STATIC_TRANSFORM_NAME (SYMBOL_NAME (sym
));
2041 SYMBOL_VALUE_ADDRESS (sym
) = SYMBOL_VALUE_ADDRESS (msym
);
2045 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2047 add_symbol_to_list (sym
, &global_symbols
);
2049 add_symbol_to_list (sym
, &local_symbols
);
2053 /* Reference parameter */
2054 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
2055 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
2056 SYMBOL_VALUE (sym
) = valu
;
2057 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2058 add_symbol_to_list (sym
, &local_symbols
);
2062 /* Reference parameter which is in a register. */
2063 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
2064 SYMBOL_CLASS (sym
) = LOC_REGPARM_ADDR
;
2065 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (valu
);
2066 if (SYMBOL_VALUE (sym
) >= NUM_REGS
)
2068 complain (®_value_complaint
, SYMBOL_VALUE (sym
), NUM_REGS
,
2069 SYMBOL_SOURCE_NAME (sym
));
2070 SYMBOL_VALUE (sym
) = SP_REGNUM
; /* Known safe, though useless */
2072 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2073 add_symbol_to_list (sym
, &local_symbols
);
2077 /* This is used by Sun FORTRAN for "function result value".
2078 Sun claims ("dbx and dbxtool interfaces", 2nd ed)
2079 that Pascal uses it too, but when I tried it Pascal used
2080 "x:3" (local symbol) instead. */
2081 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
2082 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
2083 SYMBOL_VALUE (sym
) = valu
;
2084 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2085 add_symbol_to_list (sym
, &local_symbols
);
2088 /* New code added to support cfront stabs strings.
2089 Note: case 'P' already handled above */
2091 /* Cfront type continuation coming up!
2092 Find the original definition and add to it.
2093 We'll have to do this for the typedef too,
2094 since we cloned the symbol to define a type in read_type.
2095 Stabs info examples:
2097 foo__1CFv :ZtF (first def foo__1CFv:F(0,3);(0,24))
2098 C:ZsC;;__ct__1CFv func1__1CFv func2__1CFv ... ;;;
2099 where C is the name of the class.
2100 Unfortunately, we can't lookup the original symbol yet 'cuz
2101 we haven't finished reading all the symbols.
2102 Instead, we save it for processing later */
2103 process_later (sym
, p
, resolve_cfront_continuation
);
2104 SYMBOL_TYPE (sym
) = error_type (&p
, objfile
); /* FIXME! change later */
2105 SYMBOL_CLASS (sym
) = LOC_CONST
;
2106 SYMBOL_VALUE (sym
) = 0;
2107 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2108 /* Don't add to list - we'll delete it later when
2109 we add the continuation to the real sym */
2111 /* End of new code added to support cfront stabs strings */
2114 SYMBOL_TYPE (sym
) = error_type (&p
, objfile
);
2115 SYMBOL_CLASS (sym
) = LOC_CONST
;
2116 SYMBOL_VALUE (sym
) = 0;
2117 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2118 add_symbol_to_list (sym
, &file_symbols
);
2122 /* When passing structures to a function, some systems sometimes pass
2123 the address in a register, not the structure itself. */
2125 if (REG_STRUCT_HAS_ADDR (processing_gcc_compilation
, SYMBOL_TYPE (sym
))
2126 && (SYMBOL_CLASS (sym
) == LOC_REGPARM
|| SYMBOL_CLASS (sym
) == LOC_ARG
))
2128 struct type
*symbol_type
= check_typedef (SYMBOL_TYPE (sym
));
2130 if ((TYPE_CODE (symbol_type
) == TYPE_CODE_STRUCT
)
2131 || (TYPE_CODE (symbol_type
) == TYPE_CODE_UNION
)
2132 || (TYPE_CODE (symbol_type
) == TYPE_CODE_BITSTRING
)
2133 || (TYPE_CODE (symbol_type
) == TYPE_CODE_SET
))
2135 /* If REG_STRUCT_HAS_ADDR yields non-zero we have to convert
2136 LOC_REGPARM to LOC_REGPARM_ADDR for structures and unions. */
2137 if (SYMBOL_CLASS (sym
) == LOC_REGPARM
)
2138 SYMBOL_CLASS (sym
) = LOC_REGPARM_ADDR
;
2139 /* Likewise for converting LOC_ARG to LOC_REF_ARG (for the 7th
2140 and subsequent arguments on the sparc, for example). */
2141 else if (SYMBOL_CLASS (sym
) == LOC_ARG
)
2142 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
2146 /* Is there more to parse? For example LRS/alias information? */
2147 while (*p
&& *p
== ';')
2150 if (*p
&& *p
== 'l')
2152 /* GNU extensions for live range splitting may be appended to
2153 the end of the stab string. eg. "l(#1,#2);l(#3,#5)" */
2155 /* Resolve the live range and add it to SYM's live range list. */
2156 if (!resolve_live_range (objfile
, sym
, p
))
2159 /* Find end of live range info. */
2160 p
= strchr (p
, ')');
2161 if (!*p
|| *p
!= ')')
2163 complain (&lrs_general_complaint
, "live range format not recognized");
2172 /* Add the live range found in P to the symbol SYM in objfile OBJFILE. Returns
2173 non-zero on success, zero otherwise. */
2176 resolve_live_range (objfile
, sym
, p
)
2177 struct objfile
*objfile
;
2182 CORE_ADDR start
, end
;
2184 /* Sanity check the beginning of the stabs string. */
2185 if (!*p
|| *p
!= 'l')
2187 complain (&lrs_general_complaint
, "live range string 1");
2192 if (!*p
|| *p
!= '(')
2194 complain (&lrs_general_complaint
, "live range string 2");
2199 /* Get starting value of range and advance P past the reference id.
2201 ?!? In theory, the process_reference should never fail, but we should
2202 catch that case just in case the compiler scrogged the stabs. */
2203 refnum
= process_reference (&p
);
2204 start
= ref_search_value (refnum
);
2207 complain (&lrs_general_complaint
, "Live range symbol not found 1");
2211 if (!*p
|| *p
!= ',')
2213 complain (&lrs_general_complaint
, "live range string 3");
2218 /* Get ending value of range and advance P past the reference id.
2220 ?!? In theory, the process_reference should never fail, but we should
2221 catch that case just in case the compiler scrogged the stabs. */
2222 refnum
= process_reference (&p
);
2223 end
= ref_search_value (refnum
);
2226 complain (&lrs_general_complaint
, "Live range symbol not found 2");
2230 if (!*p
|| *p
!= ')')
2232 complain (&lrs_general_complaint
, "live range string 4");
2236 /* Now that we know the bounds of the range, add it to the
2238 add_live_range (objfile
, sym
, start
, end
);
2243 /* Add a new live range defined by START and END to the symbol SYM
2244 in objfile OBJFILE. */
2247 add_live_range (objfile
, sym
, start
, end
)
2248 struct objfile
*objfile
;
2250 CORE_ADDR start
, end
;
2252 struct range_list
*r
, *rs
;
2256 complain (&lrs_general_complaint
, "end of live range follows start");
2260 /* Alloc new live range structure. */
2261 r
= (struct range_list
*)
2262 obstack_alloc (&objfile
->type_obstack
,
2263 sizeof (struct range_list
));
2268 /* Append this range to the symbol's range list. */
2269 if (!SYMBOL_RANGES (sym
))
2270 SYMBOL_RANGES (sym
) = r
;
2273 /* Get the last range for the symbol. */
2274 for (rs
= SYMBOL_RANGES (sym
); rs
->next
; rs
= rs
->next
)
2281 /* Skip rest of this symbol and return an error type.
2283 General notes on error recovery: error_type always skips to the
2284 end of the symbol (modulo cretinous dbx symbol name continuation).
2285 Thus code like this:
2287 if (*(*pp)++ != ';')
2288 return error_type (pp, objfile);
2290 is wrong because if *pp starts out pointing at '\0' (typically as the
2291 result of an earlier error), it will be incremented to point to the
2292 start of the next symbol, which might produce strange results, at least
2293 if you run off the end of the string table. Instead use
2296 return error_type (pp, objfile);
2302 foo = error_type (pp, objfile);
2306 And in case it isn't obvious, the point of all this hair is so the compiler
2307 can define new types and new syntaxes, and old versions of the
2308 debugger will be able to read the new symbol tables. */
2310 static struct type
*
2311 error_type (pp
, objfile
)
2313 struct objfile
*objfile
;
2315 complain (&error_type_complaint
);
2318 /* Skip to end of symbol. */
2319 while (**pp
!= '\0')
2324 /* Check for and handle cretinous dbx symbol name continuation! */
2325 if ((*pp
)[-1] == '\\' || (*pp
)[-1] == '?')
2327 *pp
= next_symbol_text (objfile
);
2334 return (builtin_type_error
);
2338 /* Read type information or a type definition; return the type. Even
2339 though this routine accepts either type information or a type
2340 definition, the distinction is relevant--some parts of stabsread.c
2341 assume that type information starts with a digit, '-', or '(' in
2342 deciding whether to call read_type. */
2345 read_type (pp
, objfile
)
2347 struct objfile
*objfile
;
2349 register struct type
*type
= 0;
2352 char type_descriptor
;
2354 /* Size in bits of type if specified by a type attribute, or -1 if
2355 there is no size attribute. */
2358 /* Used to distinguish string and bitstring from char-array and set. */
2361 /* Read type number if present. The type number may be omitted.
2362 for instance in a two-dimensional array declared with type
2363 "ar1;1;10;ar1;1;10;4". */
2364 if ((**pp
>= '0' && **pp
<= '9')
2368 if (read_type_number (pp
, typenums
) != 0)
2369 return error_type (pp
, objfile
);
2371 /* Type is not being defined here. Either it already exists,
2372 or this is a forward reference to it. dbx_alloc_type handles
2375 return dbx_alloc_type (typenums
, objfile
);
2377 /* Type is being defined here. */
2379 Also skip the type descriptor - we get it below with (*pp)[-1]. */
2384 /* 'typenums=' not present, type is anonymous. Read and return
2385 the definition, but don't put it in the type vector. */
2386 typenums
[0] = typenums
[1] = -1;
2391 type_descriptor
= (*pp
)[-1];
2392 switch (type_descriptor
)
2396 enum type_code code
;
2398 /* Used to index through file_symbols. */
2399 struct pending
*ppt
;
2402 /* Name including "struct", etc. */
2406 char *from
, *to
, *p
, *q1
, *q2
;
2408 /* Set the type code according to the following letter. */
2412 code
= TYPE_CODE_STRUCT
;
2415 code
= TYPE_CODE_UNION
;
2418 code
= TYPE_CODE_ENUM
;
2422 /* Complain and keep going, so compilers can invent new
2423 cross-reference types. */
2424 static struct complaint msg
=
2425 {"Unrecognized cross-reference type `%c'", 0, 0};
2426 complain (&msg
, (*pp
)[0]);
2427 code
= TYPE_CODE_STRUCT
;
2432 q1
= strchr (*pp
, '<');
2433 p
= strchr (*pp
, ':');
2435 return error_type (pp
, objfile
);
2436 if (q1
&& p
> q1
&& p
[1] == ':')
2438 int nesting_level
= 0;
2439 for (q2
= q1
; *q2
; q2
++)
2443 else if (*q2
== '>')
2445 else if (*q2
== ':' && nesting_level
== 0)
2450 return error_type (pp
, objfile
);
2453 (char *)obstack_alloc (&objfile
->type_obstack
, p
- *pp
+ 1);
2455 /* Copy the name. */
2461 /* Set the pointer ahead of the name which we just read, and
2466 /* Now check to see whether the type has already been
2467 declared. This was written for arrays of cross-referenced
2468 types before we had TYPE_CODE_TARGET_STUBBED, so I'm pretty
2469 sure it is not necessary anymore. But it might be a good
2470 idea, to save a little memory. */
2472 for (ppt
= file_symbols
; ppt
; ppt
= ppt
->next
)
2473 for (i
= 0; i
< ppt
->nsyms
; i
++)
2475 struct symbol
*sym
= ppt
->symbol
[i
];
2477 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
2478 && SYMBOL_NAMESPACE (sym
) == STRUCT_NAMESPACE
2479 && (TYPE_CODE (SYMBOL_TYPE (sym
)) == code
)
2480 && STREQ (SYMBOL_NAME (sym
), type_name
))
2482 obstack_free (&objfile
-> type_obstack
, type_name
);
2483 type
= SYMBOL_TYPE (sym
);
2488 /* Didn't find the type to which this refers, so we must
2489 be dealing with a forward reference. Allocate a type
2490 structure for it, and keep track of it so we can
2491 fill in the rest of the fields when we get the full
2493 type
= dbx_alloc_type (typenums
, objfile
);
2494 TYPE_CODE (type
) = code
;
2495 TYPE_TAG_NAME (type
) = type_name
;
2496 INIT_CPLUS_SPECIFIC(type
);
2497 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
2499 add_undefined_type (type
);
2503 case '-': /* RS/6000 built-in type */
2517 /* We deal with something like t(1,2)=(3,4)=... which
2518 the Lucid compiler and recent gcc versions (post 2.7.3) use. */
2520 /* Allocate and enter the typedef type first.
2521 This handles recursive types. */
2522 type
= dbx_alloc_type (typenums
, objfile
);
2523 TYPE_CODE (type
) = TYPE_CODE_TYPEDEF
;
2524 { struct type
*xtype
= read_type (pp
, objfile
);
2527 /* It's being defined as itself. That means it is "void". */
2528 TYPE_CODE (type
) = TYPE_CODE_VOID
;
2529 TYPE_LENGTH (type
) = 1;
2531 else if (type_size
>= 0 || is_string
)
2534 TYPE_NAME (type
) = NULL
;
2535 TYPE_TAG_NAME (type
) = NULL
;
2539 TYPE_FLAGS (type
) |= TYPE_FLAG_TARGET_STUB
;
2540 TYPE_TARGET_TYPE (type
) = xtype
;
2545 /* In the following types, we must be sure to overwrite any existing
2546 type that the typenums refer to, rather than allocating a new one
2547 and making the typenums point to the new one. This is because there
2548 may already be pointers to the existing type (if it had been
2549 forward-referenced), and we must change it to a pointer, function,
2550 reference, or whatever, *in-place*. */
2553 type1
= read_type (pp
, objfile
);
2554 type
= make_pointer_type (type1
, dbx_lookup_type (typenums
));
2557 case '&': /* Reference to another type */
2558 type1
= read_type (pp
, objfile
);
2559 type
= make_reference_type (type1
, dbx_lookup_type (typenums
));
2562 case 'f': /* Function returning another type */
2563 if (os9k_stabs
&& **pp
== '(')
2565 /* Function prototype; parse it.
2566 We must conditionalize this on os9k_stabs because otherwise
2567 it could be confused with a Sun-style (1,3) typenumber
2573 t
= read_type (pp
, objfile
);
2574 if (**pp
== ',') ++*pp
;
2577 type1
= read_type (pp
, objfile
);
2578 type
= make_function_type (type1
, dbx_lookup_type (typenums
));
2581 case 'k': /* Const qualifier on some type (Sun) */
2582 case 'c': /* Const qualifier on some type (OS9000) */
2583 /* Because 'c' means other things to AIX and 'k' is perfectly good,
2584 only accept 'c' in the os9k_stabs case. */
2585 if (type_descriptor
== 'c' && !os9k_stabs
)
2586 return error_type (pp
, objfile
);
2587 type
= read_type (pp
, objfile
);
2588 /* FIXME! For now, we ignore const and volatile qualifiers. */
2591 case 'B': /* Volatile qual on some type (Sun) */
2592 case 'i': /* Volatile qual on some type (OS9000) */
2593 /* Because 'i' means other things to AIX and 'B' is perfectly good,
2594 only accept 'i' in the os9k_stabs case. */
2595 if (type_descriptor
== 'i' && !os9k_stabs
)
2596 return error_type (pp
, objfile
);
2597 type
= read_type (pp
, objfile
);
2598 /* FIXME! For now, we ignore const and volatile qualifiers. */
2602 if (isdigit (**pp
) || **pp
== '(' || **pp
== '-')
2603 { /* Member (class & variable) type */
2604 /* FIXME -- we should be doing smash_to_XXX types here. */
2606 struct type
*domain
= read_type (pp
, objfile
);
2607 struct type
*memtype
;
2610 /* Invalid member type data format. */
2611 return error_type (pp
, objfile
);
2614 memtype
= read_type (pp
, objfile
);
2615 type
= dbx_alloc_type (typenums
, objfile
);
2616 smash_to_member_type (type
, domain
, memtype
);
2618 else /* type attribute */
2621 /* Skip to the semicolon. */
2622 while (**pp
!= ';' && **pp
!= '\0')
2625 return error_type (pp
, objfile
);
2627 ++*pp
; /* Skip the semicolon. */
2632 type_size
= atoi (attr
+ 1);
2642 /* Ignore unrecognized type attributes, so future compilers
2643 can invent new ones. */
2651 case '#': /* Method (class & fn) type */
2652 if ((*pp
)[0] == '#')
2654 /* We'll get the parameter types from the name. */
2655 struct type
*return_type
;
2658 return_type
= read_type (pp
, objfile
);
2659 if (*(*pp
)++ != ';')
2660 complain (&invalid_member_complaint
, symnum
);
2661 type
= allocate_stub_method (return_type
);
2662 if (typenums
[0] != -1)
2663 *dbx_lookup_type (typenums
) = type
;
2667 struct type
*domain
= read_type (pp
, objfile
);
2668 struct type
*return_type
;
2672 /* Invalid member type data format. */
2673 return error_type (pp
, objfile
);
2677 return_type
= read_type (pp
, objfile
);
2678 args
= read_args (pp
, ';', objfile
);
2679 type
= dbx_alloc_type (typenums
, objfile
);
2680 smash_to_method_type (type
, domain
, return_type
, args
);
2684 case 'r': /* Range type */
2685 type
= read_range_type (pp
, typenums
, objfile
);
2686 if (typenums
[0] != -1)
2687 *dbx_lookup_type (typenums
) = type
;
2692 /* Const and volatile qualified type. */
2693 type
= read_type (pp
, objfile
);
2696 /* Sun ACC builtin int type */
2697 type
= read_sun_builtin_type (pp
, typenums
, objfile
);
2698 if (typenums
[0] != -1)
2699 *dbx_lookup_type (typenums
) = type
;
2703 case 'R': /* Sun ACC builtin float type */
2704 type
= read_sun_floating_type (pp
, typenums
, objfile
);
2705 if (typenums
[0] != -1)
2706 *dbx_lookup_type (typenums
) = type
;
2709 case 'e': /* Enumeration type */
2710 type
= dbx_alloc_type (typenums
, objfile
);
2711 type
= read_enum_type (pp
, type
, objfile
);
2712 if (typenums
[0] != -1)
2713 *dbx_lookup_type (typenums
) = type
;
2716 case 's': /* Struct type */
2717 case 'u': /* Union type */
2718 type
= dbx_alloc_type (typenums
, objfile
);
2719 switch (type_descriptor
)
2722 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
2725 TYPE_CODE (type
) = TYPE_CODE_UNION
;
2728 type
= read_struct_type (pp
, type
, objfile
);
2731 case 'a': /* Array type */
2733 return error_type (pp
, objfile
);
2736 type
= dbx_alloc_type (typenums
, objfile
);
2737 type
= read_array_type (pp
, type
, objfile
);
2739 TYPE_CODE (type
) = TYPE_CODE_STRING
;
2743 type1
= read_type (pp
, objfile
);
2744 type
= create_set_type ((struct type
*) NULL
, type1
);
2746 TYPE_CODE (type
) = TYPE_CODE_BITSTRING
;
2747 if (typenums
[0] != -1)
2748 *dbx_lookup_type (typenums
) = type
;
2752 --*pp
; /* Go back to the symbol in error */
2753 /* Particularly important if it was \0! */
2754 return error_type (pp
, objfile
);
2759 warning ("GDB internal error, type is NULL in stabsread.c\n");
2760 return error_type (pp
, objfile
);
2763 /* Size specified in a type attribute overrides any other size. */
2764 if (type_size
!= -1)
2765 TYPE_LENGTH (type
) = (type_size
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
2770 /* RS/6000 xlc/dbx combination uses a set of builtin types, starting from -1.
2771 Return the proper type node for a given builtin type number. */
2773 static struct type
*
2774 rs6000_builtin_type (typenum
)
2777 /* We recognize types numbered from -NUMBER_RECOGNIZED to -1. */
2778 #define NUMBER_RECOGNIZED 34
2779 /* This includes an empty slot for type number -0. */
2780 static struct type
*negative_types
[NUMBER_RECOGNIZED
+ 1];
2781 struct type
*rettype
= NULL
;
2783 if (typenum
>= 0 || typenum
< -NUMBER_RECOGNIZED
)
2785 complain (&rs6000_builtin_complaint
, typenum
);
2786 return builtin_type_error
;
2788 if (negative_types
[-typenum
] != NULL
)
2789 return negative_types
[-typenum
];
2791 #if TARGET_CHAR_BIT != 8
2792 #error This code wrong for TARGET_CHAR_BIT not 8
2793 /* These definitions all assume that TARGET_CHAR_BIT is 8. I think
2794 that if that ever becomes not true, the correct fix will be to
2795 make the size in the struct type to be in bits, not in units of
2802 /* The size of this and all the other types are fixed, defined
2803 by the debugging format. If there is a type called "int" which
2804 is other than 32 bits, then it should use a new negative type
2805 number (or avoid negative type numbers for that case).
2806 See stabs.texinfo. */
2807 rettype
= init_type (TYPE_CODE_INT
, 4, 0, "int", NULL
);
2810 rettype
= init_type (TYPE_CODE_INT
, 1, 0, "char", NULL
);
2813 rettype
= init_type (TYPE_CODE_INT
, 2, 0, "short", NULL
);
2816 rettype
= init_type (TYPE_CODE_INT
, 4, 0, "long", NULL
);
2819 rettype
= init_type (TYPE_CODE_INT
, 1, TYPE_FLAG_UNSIGNED
,
2820 "unsigned char", NULL
);
2823 rettype
= init_type (TYPE_CODE_INT
, 1, 0, "signed char", NULL
);
2826 rettype
= init_type (TYPE_CODE_INT
, 2, TYPE_FLAG_UNSIGNED
,
2827 "unsigned short", NULL
);
2830 rettype
= init_type (TYPE_CODE_INT
, 4, TYPE_FLAG_UNSIGNED
,
2831 "unsigned int", NULL
);
2834 rettype
= init_type (TYPE_CODE_INT
, 4, TYPE_FLAG_UNSIGNED
,
2837 rettype
= init_type (TYPE_CODE_INT
, 4, TYPE_FLAG_UNSIGNED
,
2838 "unsigned long", NULL
);
2841 rettype
= init_type (TYPE_CODE_VOID
, 1, 0, "void", NULL
);
2844 /* IEEE single precision (32 bit). */
2845 rettype
= init_type (TYPE_CODE_FLT
, 4, 0, "float", NULL
);
2848 /* IEEE double precision (64 bit). */
2849 rettype
= init_type (TYPE_CODE_FLT
, 8, 0, "double", NULL
);
2852 /* This is an IEEE double on the RS/6000, and different machines with
2853 different sizes for "long double" should use different negative
2854 type numbers. See stabs.texinfo. */
2855 rettype
= init_type (TYPE_CODE_FLT
, 8, 0, "long double", NULL
);
2858 rettype
= init_type (TYPE_CODE_INT
, 4, 0, "integer", NULL
);
2861 rettype
= init_type (TYPE_CODE_BOOL
, 4, TYPE_FLAG_UNSIGNED
,
2865 rettype
= init_type (TYPE_CODE_FLT
, 4, 0, "short real", NULL
);
2868 rettype
= init_type (TYPE_CODE_FLT
, 8, 0, "real", NULL
);
2871 rettype
= init_type (TYPE_CODE_ERROR
, 0, 0, "stringptr", NULL
);
2874 rettype
= init_type (TYPE_CODE_CHAR
, 1, TYPE_FLAG_UNSIGNED
,
2878 rettype
= init_type (TYPE_CODE_BOOL
, 1, TYPE_FLAG_UNSIGNED
,
2882 rettype
= init_type (TYPE_CODE_BOOL
, 2, TYPE_FLAG_UNSIGNED
,
2886 rettype
= init_type (TYPE_CODE_BOOL
, 4, TYPE_FLAG_UNSIGNED
,
2890 rettype
= init_type (TYPE_CODE_BOOL
, 4, TYPE_FLAG_UNSIGNED
,
2894 /* Complex type consisting of two IEEE single precision values. */
2895 rettype
= init_type (TYPE_CODE_COMPLEX
, 8, 0, "complex", NULL
);
2898 /* Complex type consisting of two IEEE double precision values. */
2899 rettype
= init_type (TYPE_CODE_COMPLEX
, 16, 0, "double complex", NULL
);
2902 rettype
= init_type (TYPE_CODE_INT
, 1, 0, "integer*1", NULL
);
2905 rettype
= init_type (TYPE_CODE_INT
, 2, 0, "integer*2", NULL
);
2908 rettype
= init_type (TYPE_CODE_INT
, 4, 0, "integer*4", NULL
);
2911 rettype
= init_type (TYPE_CODE_CHAR
, 2, 0, "wchar", NULL
);
2914 rettype
= init_type (TYPE_CODE_INT
, 8, 0, "long long", NULL
);
2917 rettype
= init_type (TYPE_CODE_INT
, 8, TYPE_FLAG_UNSIGNED
,
2918 "unsigned long long", NULL
);
2921 rettype
= init_type (TYPE_CODE_INT
, 8, TYPE_FLAG_UNSIGNED
,
2925 rettype
= init_type (TYPE_CODE_INT
, 8, 0, "integer*8", NULL
);
2928 negative_types
[-typenum
] = rettype
;
2932 /* This page contains subroutines of read_type. */
2934 /* Read member function stabs info for C++ classes. The form of each member
2937 NAME :: TYPENUM[=type definition] ARGS : PHYSNAME ;
2939 An example with two member functions is:
2941 afunc1::20=##15;:i;2A.;afunc2::20:i;2A.;
2943 For the case of overloaded operators, the format is op$::*.funcs, where
2944 $ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator
2945 name (such as `+=') and `.' marks the end of the operator name.
2947 Returns 1 for success, 0 for failure. */
2950 read_member_functions (fip
, pp
, type
, objfile
)
2951 struct field_info
*fip
;
2954 struct objfile
*objfile
;
2958 /* Total number of member functions defined in this class. If the class
2959 defines two `f' functions, and one `g' function, then this will have
2961 int total_length
= 0;
2965 struct next_fnfield
*next
;
2966 struct fn_field fn_field
;
2968 struct type
*look_ahead_type
;
2969 struct next_fnfieldlist
*new_fnlist
;
2970 struct next_fnfield
*new_sublist
;
2974 /* Process each list until we find something that is not a member function
2975 or find the end of the functions. */
2979 /* We should be positioned at the start of the function name.
2980 Scan forward to find the first ':' and if it is not the
2981 first of a "::" delimiter, then this is not a member function. */
2993 look_ahead_type
= NULL
;
2996 new_fnlist
= (struct next_fnfieldlist
*)
2997 xmalloc (sizeof (struct next_fnfieldlist
));
2998 make_cleanup (free
, new_fnlist
);
2999 memset (new_fnlist
, 0, sizeof (struct next_fnfieldlist
));
3001 if ((*pp
)[0] == 'o' && (*pp
)[1] == 'p' && is_cplus_marker ((*pp
)[2]))
3003 /* This is a completely wierd case. In order to stuff in the
3004 names that might contain colons (the usual name delimiter),
3005 Mike Tiemann defined a different name format which is
3006 signalled if the identifier is "op$". In that case, the
3007 format is "op$::XXXX." where XXXX is the name. This is
3008 used for names like "+" or "=". YUUUUUUUK! FIXME! */
3009 /* This lets the user type "break operator+".
3010 We could just put in "+" as the name, but that wouldn't
3012 static char opname
[32] = {'o', 'p', CPLUS_MARKER
};
3013 char *o
= opname
+ 3;
3015 /* Skip past '::'. */
3018 STABS_CONTINUE (pp
, objfile
);
3024 main_fn_name
= savestring (opname
, o
- opname
);
3030 main_fn_name
= savestring (*pp
, p
- *pp
);
3031 /* Skip past '::'. */
3034 new_fnlist
-> fn_fieldlist
.name
= main_fn_name
;
3039 (struct next_fnfield
*) xmalloc (sizeof (struct next_fnfield
));
3040 make_cleanup (free
, new_sublist
);
3041 memset (new_sublist
, 0, sizeof (struct next_fnfield
));
3043 /* Check for and handle cretinous dbx symbol name continuation! */
3044 if (look_ahead_type
== NULL
)
3047 STABS_CONTINUE (pp
, objfile
);
3049 new_sublist
-> fn_field
.type
= read_type (pp
, objfile
);
3052 /* Invalid symtab info for member function. */
3058 /* g++ version 1 kludge */
3059 new_sublist
-> fn_field
.type
= look_ahead_type
;
3060 look_ahead_type
= NULL
;
3070 /* If this is just a stub, then we don't have the real name here. */
3072 if (TYPE_FLAGS (new_sublist
-> fn_field
.type
) & TYPE_FLAG_STUB
)
3074 if (!TYPE_DOMAIN_TYPE (new_sublist
-> fn_field
.type
))
3075 TYPE_DOMAIN_TYPE (new_sublist
-> fn_field
.type
) = type
;
3076 new_sublist
-> fn_field
.is_stub
= 1;
3078 new_sublist
-> fn_field
.physname
= savestring (*pp
, p
- *pp
);
3081 /* Set this member function's visibility fields. */
3084 case VISIBILITY_PRIVATE
:
3085 new_sublist
-> fn_field
.is_private
= 1;
3087 case VISIBILITY_PROTECTED
:
3088 new_sublist
-> fn_field
.is_protected
= 1;
3092 STABS_CONTINUE (pp
, objfile
);
3095 case 'A': /* Normal functions. */
3096 new_sublist
-> fn_field
.is_const
= 0;
3097 new_sublist
-> fn_field
.is_volatile
= 0;
3100 case 'B': /* `const' member functions. */
3101 new_sublist
-> fn_field
.is_const
= 1;
3102 new_sublist
-> fn_field
.is_volatile
= 0;
3105 case 'C': /* `volatile' member function. */
3106 new_sublist
-> fn_field
.is_const
= 0;
3107 new_sublist
-> fn_field
.is_volatile
= 1;
3110 case 'D': /* `const volatile' member function. */
3111 new_sublist
-> fn_field
.is_const
= 1;
3112 new_sublist
-> fn_field
.is_volatile
= 1;
3115 case '*': /* File compiled with g++ version 1 -- no info */
3120 complain (&const_vol_complaint
, **pp
);
3129 /* virtual member function, followed by index.
3130 The sign bit is set to distinguish pointers-to-methods
3131 from virtual function indicies. Since the array is
3132 in words, the quantity must be shifted left by 1
3133 on 16 bit machine, and by 2 on 32 bit machine, forcing
3134 the sign bit out, and usable as a valid index into
3135 the array. Remove the sign bit here. */
3136 new_sublist
-> fn_field
.voffset
=
3137 (0x7fffffff & read_huge_number (pp
, ';', &nbits
)) + 2;
3141 STABS_CONTINUE (pp
, objfile
);
3142 if (**pp
== ';' || **pp
== '\0')
3144 /* Must be g++ version 1. */
3145 new_sublist
-> fn_field
.fcontext
= 0;
3149 /* Figure out from whence this virtual function came.
3150 It may belong to virtual function table of
3151 one of its baseclasses. */
3152 look_ahead_type
= read_type (pp
, objfile
);
3155 /* g++ version 1 overloaded methods. */
3159 new_sublist
-> fn_field
.fcontext
= look_ahead_type
;
3168 look_ahead_type
= NULL
;
3174 /* static member function. */
3175 new_sublist
-> fn_field
.voffset
= VOFFSET_STATIC
;
3176 if (strncmp (new_sublist
-> fn_field
.physname
,
3177 main_fn_name
, strlen (main_fn_name
)))
3179 new_sublist
-> fn_field
.is_stub
= 1;
3185 complain (&member_fn_complaint
, (*pp
)[-1]);
3186 /* Fall through into normal member function. */
3189 /* normal member function. */
3190 new_sublist
-> fn_field
.voffset
= 0;
3191 new_sublist
-> fn_field
.fcontext
= 0;
3195 new_sublist
-> next
= sublist
;
3196 sublist
= new_sublist
;
3198 STABS_CONTINUE (pp
, objfile
);
3200 while (**pp
!= ';' && **pp
!= '\0');
3204 new_fnlist
-> fn_fieldlist
.fn_fields
= (struct fn_field
*)
3205 obstack_alloc (&objfile
-> type_obstack
,
3206 sizeof (struct fn_field
) * length
);
3207 memset (new_fnlist
-> fn_fieldlist
.fn_fields
, 0,
3208 sizeof (struct fn_field
) * length
);
3209 for (i
= length
; (i
--, sublist
); sublist
= sublist
-> next
)
3211 new_fnlist
-> fn_fieldlist
.fn_fields
[i
] = sublist
-> fn_field
;
3214 new_fnlist
-> fn_fieldlist
.length
= length
;
3215 new_fnlist
-> next
= fip
-> fnlist
;
3216 fip
-> fnlist
= new_fnlist
;
3218 total_length
+= length
;
3219 STABS_CONTINUE (pp
, objfile
);
3224 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3225 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
3226 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * nfn_fields
);
3227 memset (TYPE_FN_FIELDLISTS (type
), 0,
3228 sizeof (struct fn_fieldlist
) * nfn_fields
);
3229 TYPE_NFN_FIELDS (type
) = nfn_fields
;
3230 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
3236 /* Special GNU C++ name.
3238 Returns 1 for success, 0 for failure. "failure" means that we can't
3239 keep parsing and it's time for error_type(). */
3242 read_cpp_abbrev (fip
, pp
, type
, objfile
)
3243 struct field_info
*fip
;
3246 struct objfile
*objfile
;
3251 struct type
*context
;
3261 /* At this point, *pp points to something like "22:23=*22...",
3262 where the type number before the ':' is the "context" and
3263 everything after is a regular type definition. Lookup the
3264 type, find it's name, and construct the field name. */
3266 context
= read_type (pp
, objfile
);
3270 case 'f': /* $vf -- a virtual function table pointer */
3271 fip
->list
->field
.name
=
3272 obconcat (&objfile
->type_obstack
, vptr_name
, "", "");
3275 case 'b': /* $vb -- a virtual bsomethingorother */
3276 name
= type_name_no_tag (context
);
3279 complain (&invalid_cpp_type_complaint
, symnum
);
3282 fip
->list
->field
.name
=
3283 obconcat (&objfile
->type_obstack
, vb_name
, name
, "");
3287 complain (&invalid_cpp_abbrev_complaint
, *pp
);
3288 fip
->list
->field
.name
=
3289 obconcat (&objfile
->type_obstack
,
3290 "INVALID_CPLUSPLUS_ABBREV", "", "");
3294 /* At this point, *pp points to the ':'. Skip it and read the
3300 complain (&invalid_cpp_abbrev_complaint
, *pp
);
3303 fip
->list
->field
.type
= read_type (pp
, objfile
);
3305 (*pp
)++; /* Skip the comma. */
3311 FIELD_BITPOS (fip
->list
->field
) = read_huge_number (pp
, ';', &nbits
);
3315 /* This field is unpacked. */
3316 FIELD_BITSIZE (fip
->list
->field
) = 0;
3317 fip
->list
->visibility
= VISIBILITY_PRIVATE
;
3321 complain (&invalid_cpp_abbrev_complaint
, *pp
);
3322 /* We have no idea what syntax an unrecognized abbrev would have, so
3323 better return 0. If we returned 1, we would need to at least advance
3324 *pp to avoid an infinite loop. */
3331 read_one_struct_field (fip
, pp
, p
, type
, objfile
)
3332 struct field_info
*fip
;
3336 struct objfile
*objfile
;
3338 /* The following is code to work around cfront generated stabs.
3339 The stabs contains full mangled name for each field.
3340 We try to demangle the name and extract the field name out of it.
3342 if (ARM_DEMANGLING
&& current_subfile
->language
== language_cplus
)
3348 dem
= cplus_demangle (*pp
, DMGL_ANSI
| DMGL_PARAMS
);
3351 dem_p
= strrchr (dem
, ':');
3352 if (dem_p
!= 0 && *(dem_p
-1)==':')
3354 FIELD_NAME (fip
->list
->field
) =
3355 obsavestring (dem_p
, strlen (dem_p
), &objfile
-> type_obstack
);
3359 FIELD_NAME (fip
->list
->field
) =
3360 obsavestring (*pp
, p
- *pp
, &objfile
-> type_obstack
);
3364 /* end of code for cfront work around */
3367 fip
-> list
-> field
.name
=
3368 obsavestring (*pp
, p
- *pp
, &objfile
-> type_obstack
);
3371 /* This means we have a visibility for a field coming. */
3375 fip
-> list
-> visibility
= *(*pp
)++;
3379 /* normal dbx-style format, no explicit visibility */
3380 fip
-> list
-> visibility
= VISIBILITY_PUBLIC
;
3383 fip
-> list
-> field
.type
= read_type (pp
, objfile
);
3388 /* Possible future hook for nested types. */
3391 fip
-> list
-> field
.bitpos
= (long)-2; /* nested type */
3400 /* Static class member. */
3401 SET_FIELD_PHYSNAME (fip
->list
->field
, savestring (*pp
, p
- *pp
));
3405 else if (**pp
!= ',')
3407 /* Bad structure-type format. */
3408 complain (&stabs_general_complaint
, "bad structure-type format");
3412 (*pp
)++; /* Skip the comma. */
3416 FIELD_BITPOS (fip
->list
->field
) = read_huge_number (pp
, ',', &nbits
);
3419 complain (&stabs_general_complaint
, "bad structure-type format");
3422 FIELD_BITSIZE (fip
->list
->field
) = read_huge_number (pp
, ';', &nbits
);
3425 complain (&stabs_general_complaint
, "bad structure-type format");
3430 if (FIELD_BITPOS (fip
->list
->field
) == 0
3431 && FIELD_BITSIZE (fip
->list
->field
) == 0)
3433 /* This can happen in two cases: (1) at least for gcc 2.4.5 or so,
3434 it is a field which has been optimized out. The correct stab for
3435 this case is to use VISIBILITY_IGNORE, but that is a recent
3436 invention. (2) It is a 0-size array. For example
3437 union { int num; char str[0]; } foo. Printing "<no value>" for
3438 str in "p foo" is OK, since foo.str (and thus foo.str[3])
3439 will continue to work, and a 0-size array as a whole doesn't
3440 have any contents to print.
3442 I suspect this probably could also happen with gcc -gstabs (not
3443 -gstabs+) for static fields, and perhaps other C++ extensions.
3444 Hopefully few people use -gstabs with gdb, since it is intended
3445 for dbx compatibility. */
3447 /* Ignore this field. */
3448 fip
-> list
-> visibility
= VISIBILITY_IGNORE
;
3452 /* Detect an unpacked field and mark it as such.
3453 dbx gives a bit size for all fields.
3454 Note that forward refs cannot be packed,
3455 and treat enums as if they had the width of ints. */
3457 struct type
*field_type
= check_typedef (FIELD_TYPE (fip
->list
->field
));
3459 if (TYPE_CODE (field_type
) != TYPE_CODE_INT
3460 && TYPE_CODE (field_type
) != TYPE_CODE_RANGE
3461 && TYPE_CODE (field_type
) != TYPE_CODE_BOOL
3462 && TYPE_CODE (field_type
) != TYPE_CODE_ENUM
)
3464 FIELD_BITSIZE (fip
->list
->field
) = 0;
3466 if ((FIELD_BITSIZE (fip
->list
->field
)
3467 == TARGET_CHAR_BIT
* TYPE_LENGTH (field_type
)
3468 || (TYPE_CODE (field_type
) == TYPE_CODE_ENUM
3469 && FIELD_BITSIZE (fip
->list
->field
) == TARGET_INT_BIT
)
3472 FIELD_BITPOS (fip
->list
->field
) % 8 == 0)
3474 FIELD_BITSIZE (fip
->list
->field
) = 0;
3480 /* Read struct or class data fields. They have the form:
3482 NAME : [VISIBILITY] TYPENUM , BITPOS , BITSIZE ;
3484 At the end, we see a semicolon instead of a field.
3486 In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
3489 The optional VISIBILITY is one of:
3491 '/0' (VISIBILITY_PRIVATE)
3492 '/1' (VISIBILITY_PROTECTED)
3493 '/2' (VISIBILITY_PUBLIC)
3494 '/9' (VISIBILITY_IGNORE)
3496 or nothing, for C style fields with public visibility.
3498 Returns 1 for success, 0 for failure. */
3501 read_struct_fields (fip
, pp
, type
, objfile
)
3502 struct field_info
*fip
;
3505 struct objfile
*objfile
;
3508 struct nextfield
*new;
3510 /* We better set p right now, in case there are no fields at all... */
3514 /* Read each data member type until we find the terminating ';' at the end of
3515 the data member list, or break for some other reason such as finding the
3516 start of the member function list. */
3520 if (os9k_stabs
&& **pp
== ',') break;
3521 STABS_CONTINUE (pp
, objfile
);
3522 /* Get space to record the next field's data. */
3523 new = (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
3524 make_cleanup (free
, new);
3525 memset (new, 0, sizeof (struct nextfield
));
3526 new -> next
= fip
-> list
;
3529 /* Get the field name. */
3532 /* If is starts with CPLUS_MARKER it is a special abbreviation,
3533 unless the CPLUS_MARKER is followed by an underscore, in
3534 which case it is just the name of an anonymous type, which we
3535 should handle like any other type name. */
3537 if (is_cplus_marker (p
[0]) && p
[1] != '_')
3539 if (!read_cpp_abbrev (fip
, pp
, type
, objfile
))
3544 /* Look for the ':' that separates the field name from the field
3545 values. Data members are delimited by a single ':', while member
3546 functions are delimited by a pair of ':'s. When we hit the member
3547 functions (if any), terminate scan loop and return. */
3549 while (*p
!= ':' && *p
!= '\0')
3556 /* Check to see if we have hit the member functions yet. */
3561 read_one_struct_field (fip
, pp
, p
, type
, objfile
);
3563 if (p
[0] == ':' && p
[1] == ':')
3565 /* chill the list of fields: the last entry (at the head) is a
3566 partially constructed entry which we now scrub. */
3567 fip
-> list
= fip
-> list
-> next
;
3572 /* The stabs for C++ derived classes contain baseclass information which
3573 is marked by a '!' character after the total size. This function is
3574 called when we encounter the baseclass marker, and slurps up all the
3575 baseclass information.
3577 Immediately following the '!' marker is the number of base classes that
3578 the class is derived from, followed by information for each base class.
3579 For each base class, there are two visibility specifiers, a bit offset
3580 to the base class information within the derived class, a reference to
3581 the type for the base class, and a terminating semicolon.
3583 A typical example, with two base classes, would be "!2,020,19;0264,21;".
3585 Baseclass information marker __________________|| | | | | | |
3586 Number of baseclasses __________________________| | | | | | |
3587 Visibility specifiers (2) ________________________| | | | | |
3588 Offset in bits from start of class _________________| | | | |
3589 Type number for base class ___________________________| | | |
3590 Visibility specifiers (2) _______________________________| | |
3591 Offset in bits from start of class ________________________| |
3592 Type number of base class ____________________________________|
3594 Return 1 for success, 0 for (error-type-inducing) failure. */
3597 read_baseclasses (fip
, pp
, type
, objfile
)
3598 struct field_info
*fip
;
3601 struct objfile
*objfile
;
3604 struct nextfield
*new;
3612 /* Skip the '!' baseclass information marker. */
3616 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3619 TYPE_N_BASECLASSES (type
) = read_huge_number (pp
, ',', &nbits
);
3625 /* Some stupid compilers have trouble with the following, so break
3626 it up into simpler expressions. */
3627 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*)
3628 TYPE_ALLOC (type
, B_BYTES (TYPE_N_BASECLASSES (type
)));
3631 int num_bytes
= B_BYTES (TYPE_N_BASECLASSES (type
));
3634 pointer
= (char *) TYPE_ALLOC (type
, num_bytes
);
3635 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*) pointer
;
3639 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), TYPE_N_BASECLASSES (type
));
3641 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
3643 new = (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
3644 make_cleanup (free
, new);
3645 memset (new, 0, sizeof (struct nextfield
));
3646 new -> next
= fip
-> list
;
3648 FIELD_BITSIZE (new->field
) = 0; /* this should be an unpacked field! */
3650 STABS_CONTINUE (pp
, objfile
);
3654 /* Nothing to do. */
3657 SET_TYPE_FIELD_VIRTUAL (type
, i
);
3660 /* Unknown character. Complain and treat it as non-virtual. */
3662 static struct complaint msg
= {
3663 "Unknown virtual character `%c' for baseclass", 0, 0};
3664 complain (&msg
, **pp
);
3669 new -> visibility
= *(*pp
)++;
3670 switch (new -> visibility
)
3672 case VISIBILITY_PRIVATE
:
3673 case VISIBILITY_PROTECTED
:
3674 case VISIBILITY_PUBLIC
:
3677 /* Bad visibility format. Complain and treat it as
3680 static struct complaint msg
= {
3681 "Unknown visibility `%c' for baseclass", 0, 0};
3682 complain (&msg
, new -> visibility
);
3683 new -> visibility
= VISIBILITY_PUBLIC
;
3690 /* The remaining value is the bit offset of the portion of the object
3691 corresponding to this baseclass. Always zero in the absence of
3692 multiple inheritance. */
3694 FIELD_BITPOS (new->field
) = read_huge_number (pp
, ',', &nbits
);
3699 /* The last piece of baseclass information is the type of the
3700 base class. Read it, and remember it's type name as this
3703 new -> field
.type
= read_type (pp
, objfile
);
3704 new -> field
.name
= type_name_no_tag (new -> field
.type
);
3706 /* skip trailing ';' and bump count of number of fields seen */
3715 /* The tail end of stabs for C++ classes that contain a virtual function
3716 pointer contains a tilde, a %, and a type number.
3717 The type number refers to the base class (possibly this class itself) which
3718 contains the vtable pointer for the current class.
3720 This function is called when we have parsed all the method declarations,
3721 so we can look for the vptr base class info. */
3724 read_tilde_fields (fip
, pp
, type
, objfile
)
3725 struct field_info
*fip
;
3728 struct objfile
*objfile
;
3732 STABS_CONTINUE (pp
, objfile
);
3734 /* If we are positioned at a ';', then skip it. */
3744 if (**pp
== '=' || **pp
== '+' || **pp
== '-')
3746 /* Obsolete flags that used to indicate the presence
3747 of constructors and/or destructors. */
3751 /* Read either a '%' or the final ';'. */
3752 if (*(*pp
)++ == '%')
3754 /* The next number is the type number of the base class
3755 (possibly our own class) which supplies the vtable for
3756 this class. Parse it out, and search that class to find
3757 its vtable pointer, and install those into TYPE_VPTR_BASETYPE
3758 and TYPE_VPTR_FIELDNO. */
3763 t
= read_type (pp
, objfile
);
3765 while (*p
!= '\0' && *p
!= ';')
3771 /* Premature end of symbol. */
3775 TYPE_VPTR_BASETYPE (type
) = t
;
3776 if (type
== t
) /* Our own class provides vtbl ptr */
3778 for (i
= TYPE_NFIELDS (t
) - 1;
3779 i
>= TYPE_N_BASECLASSES (t
);
3782 if (! strncmp (TYPE_FIELD_NAME (t
, i
), vptr_name
,
3783 sizeof (vptr_name
) - 1))
3785 TYPE_VPTR_FIELDNO (type
) = i
;
3789 /* Virtual function table field not found. */
3790 complain (&vtbl_notfound_complaint
, TYPE_NAME (type
));
3795 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
3806 attach_fn_fields_to_type (fip
, type
)
3807 struct field_info
*fip
;
3808 register struct type
*type
;
3812 for (n
= TYPE_NFN_FIELDS (type
);
3813 fip
-> fnlist
!= NULL
;
3814 fip
-> fnlist
= fip
-> fnlist
-> next
)
3816 --n
; /* Circumvent Sun3 compiler bug */
3817 TYPE_FN_FIELDLISTS (type
)[n
] = fip
-> fnlist
-> fn_fieldlist
;
3822 /* read cfront class static data.
3823 pp points to string starting with the list of static data
3824 eg: A:ZcA;1@Bpub v2@Bvirpri;__ct__1AFv func__1AFv *sfunc__1AFv ;as__1A ;;
3827 A:ZcA;;foopri__1AFv foopro__1AFv __ct__1AFv __ct__1AFRC1A foopub__1AFv ;;;
3832 read_cfront_static_fields (fip
, pp
, type
, objfile
)
3833 struct field_info
*fip
;
3836 struct objfile
*objfile
;
3838 struct nextfield
* new;
3841 struct symbol
* ref_static
=0;
3843 if (**pp
==';') /* no static data; return */
3849 /* Process each field in the list until we find the terminating ";" */
3851 /* eg: p = "as__1A ;;;" */
3852 STABS_CONTINUE (pp
, objfile
); /* handle \\ */
3853 while (**pp
!=';' && (sname
= get_substring (pp
, ' '), sname
))
3855 ref_static
= lookup_symbol (sname
, 0, VAR_NAMESPACE
, 0, 0); /*demangled_name*/
3858 static struct complaint msg
= {"\
3859 Unable to find symbol for static data field %s\n",
3861 complain (&msg
, sname
);
3864 stype
= SYMBOL_TYPE(ref_static
);
3866 /* allocate a new fip */
3867 new = (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
3868 make_cleanup (free
, new);
3869 memset (new, 0, sizeof (struct nextfield
));
3870 new -> next
= fip
-> list
;
3873 /* set visibility */
3874 /* FIXME! no way to tell visibility from stabs??? */
3875 new -> visibility
= VISIBILITY_PUBLIC
;
3877 /* set field info into fip */
3878 fip
-> list
-> field
.type
= stype
;
3880 /* set bitpos & bitsize */
3881 SET_FIELD_PHYSNAME (fip
->list
->field
, savestring (sname
, strlen (sname
)));
3883 /* set name field */
3884 /* The following is code to work around cfront generated stabs.
3885 The stabs contains full mangled name for each field.
3886 We try to demangle the name and extract the field name out of it.
3891 dem
= cplus_demangle (sname
, DMGL_ANSI
| DMGL_PARAMS
);
3894 dem_p
= strrchr (dem
, ':');
3895 if (dem_p
!= 0 && *(dem_p
-1)==':')
3897 fip
->list
->field
.name
=
3898 obsavestring (dem_p
, strlen (dem_p
), &objfile
-> type_obstack
);
3902 fip
->list
->field
.name
=
3903 obsavestring (sname
, strlen (sname
), &objfile
-> type_obstack
);
3905 } /* end of code for cfront work around */
3906 } /* loop again for next static field */
3910 /* Copy structure fields to fip so attach_fields_to_type will work.
3911 type has already been created with the initial instance data fields.
3912 Now we want to be able to add the other members to the class,
3913 so we want to add them back to the fip and reattach them again
3914 once we have collected all the class members. */
3917 copy_cfront_struct_fields (fip
, type
, objfile
)
3918 struct field_info
*fip
;
3920 struct objfile
*objfile
;
3922 int nfields
= TYPE_NFIELDS(type
);
3924 struct nextfield
* new;
3926 /* Copy the fields into the list of fips and reset the types
3927 to remove the old fields */
3929 for (i
=0; i
<nfields
; i
++)
3931 /* allocate a new fip */
3932 new = (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
3933 make_cleanup (free
, new);
3934 memset (new, 0, sizeof (struct nextfield
));
3935 new -> next
= fip
-> list
;
3938 /* copy field info into fip */
3939 new -> field
= TYPE_FIELD (type
, i
);
3940 /* set visibility */
3941 if (TYPE_FIELD_PROTECTED (type
, i
))
3942 new -> visibility
= VISIBILITY_PROTECTED
;
3943 else if (TYPE_FIELD_PRIVATE (type
, i
))
3944 new -> visibility
= VISIBILITY_PRIVATE
;
3946 new -> visibility
= VISIBILITY_PUBLIC
;
3948 /* Now delete the fields from the type since we will be
3949 allocing new space once we get the rest of the fields
3950 in attach_fields_to_type.
3951 The pointer TYPE_FIELDS(type) is left dangling but should
3952 be freed later by objstack_free */
3953 TYPE_FIELDS (type
)=0;
3954 TYPE_NFIELDS (type
) = 0;
3959 /* Create the vector of fields, and record how big it is.
3960 We need this info to record proper virtual function table information
3961 for this class's virtual functions. */
3964 attach_fields_to_type (fip
, type
, objfile
)
3965 struct field_info
*fip
;
3966 register struct type
*type
;
3967 struct objfile
*objfile
;
3969 register int nfields
= 0;
3970 register int non_public_fields
= 0;
3971 register struct nextfield
*scan
;
3973 /* Count up the number of fields that we have, as well as taking note of
3974 whether or not there are any non-public fields, which requires us to
3975 allocate and build the private_field_bits and protected_field_bits
3978 for (scan
= fip
-> list
; scan
!= NULL
; scan
= scan
-> next
)
3981 if (scan
-> visibility
!= VISIBILITY_PUBLIC
)
3983 non_public_fields
++;
3987 /* Now we know how many fields there are, and whether or not there are any
3988 non-public fields. Record the field count, allocate space for the
3989 array of fields, and create blank visibility bitfields if necessary. */
3991 TYPE_NFIELDS (type
) = nfields
;
3992 TYPE_FIELDS (type
) = (struct field
*)
3993 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
3994 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
3996 if (non_public_fields
)
3998 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
4000 TYPE_FIELD_PRIVATE_BITS (type
) =
4001 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
4002 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
4004 TYPE_FIELD_PROTECTED_BITS (type
) =
4005 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
4006 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
4008 TYPE_FIELD_IGNORE_BITS (type
) =
4009 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
4010 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
4013 /* Copy the saved-up fields into the field vector. Start from the head
4014 of the list, adding to the tail of the field array, so that they end
4015 up in the same order in the array in which they were added to the list. */
4017 while (nfields
-- > 0)
4019 TYPE_FIELD (type
, nfields
) = fip
-> list
-> field
;
4020 switch (fip
-> list
-> visibility
)
4022 case VISIBILITY_PRIVATE
:
4023 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
4026 case VISIBILITY_PROTECTED
:
4027 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
4030 case VISIBILITY_IGNORE
:
4031 SET_TYPE_FIELD_IGNORE (type
, nfields
);
4034 case VISIBILITY_PUBLIC
:
4038 /* Unknown visibility. Complain and treat it as public. */
4040 static struct complaint msg
= {
4041 "Unknown visibility `%c' for field", 0, 0};
4042 complain (&msg
, fip
-> list
-> visibility
);
4046 fip
-> list
= fip
-> list
-> next
;
4051 /* Read the description of a structure (or union type) and return an object
4052 describing the type.
4054 PP points to a character pointer that points to the next unconsumed token
4055 in the the stabs string. For example, given stabs "A:T4=s4a:1,0,32;;",
4056 *PP will point to "4a:1,0,32;;".
4058 TYPE points to an incomplete type that needs to be filled in.
4060 OBJFILE points to the current objfile from which the stabs information is
4061 being read. (Note that it is redundant in that TYPE also contains a pointer
4062 to this same objfile, so it might be a good idea to eliminate it. FIXME).
4065 static struct type
*
4066 read_struct_type (pp
, type
, objfile
)
4069 struct objfile
*objfile
;
4071 struct cleanup
*back_to
;
4072 struct field_info fi
;
4077 back_to
= make_cleanup (null_cleanup
, 0);
4079 INIT_CPLUS_SPECIFIC (type
);
4080 TYPE_FLAGS (type
) &= ~TYPE_FLAG_STUB
;
4082 /* First comes the total size in bytes. */
4086 TYPE_LENGTH (type
) = read_huge_number (pp
, 0, &nbits
);
4088 return error_type (pp
, objfile
);
4091 /* Now read the baseclasses, if any, read the regular C struct or C++
4092 class member fields, attach the fields to the type, read the C++
4093 member functions, attach them to the type, and then read any tilde
4094 field (baseclass specifier for the class holding the main vtable). */
4096 if (!read_baseclasses (&fi
, pp
, type
, objfile
)
4097 || !read_struct_fields (&fi
, pp
, type
, objfile
)
4098 || !attach_fields_to_type (&fi
, type
, objfile
)
4099 || !read_member_functions (&fi
, pp
, type
, objfile
)
4100 || !attach_fn_fields_to_type (&fi
, type
)
4101 || !read_tilde_fields (&fi
, pp
, type
, objfile
))
4103 type
= error_type (pp
, objfile
);
4106 do_cleanups (back_to
);
4110 /* Read a definition of an array type,
4111 and create and return a suitable type object.
4112 Also creates a range type which represents the bounds of that
4115 static struct type
*
4116 read_array_type (pp
, type
, objfile
)
4118 register struct type
*type
;
4119 struct objfile
*objfile
;
4121 struct type
*index_type
, *element_type
, *range_type
;
4126 /* Format of an array type:
4127 "ar<index type>;lower;upper;<array_contents_type>".
4128 OS9000: "arlower,upper;<array_contents_type>".
4130 Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
4131 for these, produce a type like float[][]. */
4134 index_type
= builtin_type_int
;
4137 index_type
= read_type (pp
, objfile
);
4139 /* Improper format of array type decl. */
4140 return error_type (pp
, objfile
);
4144 if (!(**pp
>= '0' && **pp
<= '9') && **pp
!= '-')
4149 lower
= read_huge_number (pp
, os9k_stabs
? ',' : ';', &nbits
);
4151 return error_type (pp
, objfile
);
4153 if (!(**pp
>= '0' && **pp
<= '9') && **pp
!= '-')
4158 upper
= read_huge_number (pp
, ';', &nbits
);
4160 return error_type (pp
, objfile
);
4162 element_type
= read_type (pp
, objfile
);
4171 create_range_type ((struct type
*) NULL
, index_type
, lower
, upper
);
4172 type
= create_array_type (type
, element_type
, range_type
);
4178 /* Read a definition of an enumeration type,
4179 and create and return a suitable type object.
4180 Also defines the symbols that represent the values of the type. */
4182 static struct type
*
4183 read_enum_type (pp
, type
, objfile
)
4185 register struct type
*type
;
4186 struct objfile
*objfile
;
4191 register struct symbol
*sym
;
4193 struct pending
**symlist
;
4194 struct pending
*osyms
, *syms
;
4197 int unsigned_enum
= 1;
4200 /* FIXME! The stabs produced by Sun CC merrily define things that ought
4201 to be file-scope, between N_FN entries, using N_LSYM. What's a mother
4202 to do? For now, force all enum values to file scope. */
4203 if (within_function
)
4204 symlist
= &local_symbols
;
4207 symlist
= &file_symbols
;
4209 o_nsyms
= osyms
? osyms
->nsyms
: 0;
4213 /* Size. Perhaps this does not have to be conditionalized on
4214 os9k_stabs (assuming the name of an enum constant can't start
4216 read_huge_number (pp
, 0, &nbits
);
4218 return error_type (pp
, objfile
);
4221 /* The aix4 compiler emits an extra field before the enum members;
4222 my guess is it's a type of some sort. Just ignore it. */
4225 /* Skip over the type. */
4229 /* Skip over the colon. */
4233 /* Read the value-names and their values.
4234 The input syntax is NAME:VALUE,NAME:VALUE, and so on.
4235 A semicolon or comma instead of a NAME means the end. */
4236 while (**pp
&& **pp
!= ';' && **pp
!= ',')
4238 STABS_CONTINUE (pp
, objfile
);
4240 while (*p
!= ':') p
++;
4241 name
= obsavestring (*pp
, p
- *pp
, &objfile
-> symbol_obstack
);
4243 n
= read_huge_number (pp
, ',', &nbits
);
4245 return error_type (pp
, objfile
);
4247 sym
= (struct symbol
*)
4248 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
4249 memset (sym
, 0, sizeof (struct symbol
));
4250 SYMBOL_NAME (sym
) = name
;
4251 SYMBOL_LANGUAGE (sym
) = current_subfile
-> language
;
4252 SYMBOL_CLASS (sym
) = LOC_CONST
;
4253 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
4254 SYMBOL_VALUE (sym
) = n
;
4257 add_symbol_to_list (sym
, symlist
);
4262 (*pp
)++; /* Skip the semicolon. */
4264 /* Now fill in the fields of the type-structure. */
4266 TYPE_LENGTH (type
) = TARGET_INT_BIT
/ HOST_CHAR_BIT
;
4267 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
4268 TYPE_FLAGS (type
) &= ~TYPE_FLAG_STUB
;
4270 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
4271 TYPE_NFIELDS (type
) = nsyms
;
4272 TYPE_FIELDS (type
) = (struct field
*)
4273 TYPE_ALLOC (type
, sizeof (struct field
) * nsyms
);
4274 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nsyms
);
4276 /* Find the symbols for the values and put them into the type.
4277 The symbols can be found in the symlist that we put them on
4278 to cause them to be defined. osyms contains the old value
4279 of that symlist; everything up to there was defined by us. */
4280 /* Note that we preserve the order of the enum constants, so
4281 that in something like "enum {FOO, LAST_THING=FOO}" we print
4282 FOO, not LAST_THING. */
4284 for (syms
= *symlist
, n
= nsyms
- 1; syms
; syms
= syms
->next
)
4286 int last
= syms
== osyms
? o_nsyms
: 0;
4287 int j
= syms
->nsyms
;
4288 for (; --j
>= last
; --n
)
4290 struct symbol
*xsym
= syms
->symbol
[j
];
4291 SYMBOL_TYPE (xsym
) = type
;
4292 TYPE_FIELD_NAME (type
, n
) = SYMBOL_NAME (xsym
);
4293 TYPE_FIELD_BITPOS (type
, n
) = SYMBOL_VALUE (xsym
);
4294 TYPE_FIELD_BITSIZE (type
, n
) = 0;
4303 /* Sun's ACC uses a somewhat saner method for specifying the builtin
4304 typedefs in every file (for int, long, etc):
4306 type = b <signed> <width> <format type>; <offset>; <nbits>
4308 optional format type = c or b for char or boolean.
4309 offset = offset from high order bit to start bit of type.
4310 width is # bytes in object of this type, nbits is # bits in type.
4312 The width/offset stuff appears to be for small objects stored in
4313 larger ones (e.g. `shorts' in `int' registers). We ignore it for now,
4316 static struct type
*
4317 read_sun_builtin_type (pp
, typenums
, objfile
)
4320 struct objfile
*objfile
;
4325 enum type_code code
= TYPE_CODE_INT
;
4336 return error_type (pp
, objfile
);
4340 /* For some odd reason, all forms of char put a c here. This is strange
4341 because no other type has this honor. We can safely ignore this because
4342 we actually determine 'char'acterness by the number of bits specified in
4344 Boolean forms, e.g Fortran logical*X, put a b here. */
4348 else if (**pp
== 'b')
4350 code
= TYPE_CODE_BOOL
;
4354 /* The first number appears to be the number of bytes occupied
4355 by this type, except that unsigned short is 4 instead of 2.
4356 Since this information is redundant with the third number,
4357 we will ignore it. */
4358 read_huge_number (pp
, ';', &nbits
);
4360 return error_type (pp
, objfile
);
4362 /* The second number is always 0, so ignore it too. */
4363 read_huge_number (pp
, ';', &nbits
);
4365 return error_type (pp
, objfile
);
4367 /* The third number is the number of bits for this type. */
4368 type_bits
= read_huge_number (pp
, 0, &nbits
);
4370 return error_type (pp
, objfile
);
4371 /* The type *should* end with a semicolon. If it are embedded
4372 in a larger type the semicolon may be the only way to know where
4373 the type ends. If this type is at the end of the stabstring we
4374 can deal with the omitted semicolon (but we don't have to like
4375 it). Don't bother to complain(), Sun's compiler omits the semicolon
4381 return init_type (TYPE_CODE_VOID
, 1,
4382 signed_type
? 0 : TYPE_FLAG_UNSIGNED
, (char *)NULL
,
4385 return init_type (code
,
4386 type_bits
/ TARGET_CHAR_BIT
,
4387 signed_type
? 0 : TYPE_FLAG_UNSIGNED
, (char *)NULL
,
4391 static struct type
*
4392 read_sun_floating_type (pp
, typenums
, objfile
)
4395 struct objfile
*objfile
;
4401 /* The first number has more details about the type, for example
4403 details
= read_huge_number (pp
, ';', &nbits
);
4405 return error_type (pp
, objfile
);
4407 /* The second number is the number of bytes occupied by this type */
4408 nbytes
= read_huge_number (pp
, ';', &nbits
);
4410 return error_type (pp
, objfile
);
4412 if (details
== NF_COMPLEX
|| details
== NF_COMPLEX16
4413 || details
== NF_COMPLEX32
)
4414 /* This is a type we can't handle, but we do know the size.
4415 We also will be able to give it a name. */
4416 return init_type (TYPE_CODE_COMPLEX
, nbytes
, 0, NULL
, objfile
);
4418 return init_type (TYPE_CODE_FLT
, nbytes
, 0, NULL
, objfile
);
4421 /* Read a number from the string pointed to by *PP.
4422 The value of *PP is advanced over the number.
4423 If END is nonzero, the character that ends the
4424 number must match END, or an error happens;
4425 and that character is skipped if it does match.
4426 If END is zero, *PP is left pointing to that character.
4428 If the number fits in a long, set *BITS to 0 and return the value.
4429 If not, set *BITS to be the number of bits in the number and return 0.
4431 If encounter garbage, set *BITS to -1 and return 0. */
4434 read_huge_number (pp
, end
, bits
)
4454 /* Leading zero means octal. GCC uses this to output values larger
4455 than an int (because that would be hard in decimal). */
4463 upper_limit
= ULONG_MAX
/ radix
;
4465 upper_limit
= LONG_MAX
/ radix
;
4467 while ((c
= *p
++) >= '0' && c
< ('0' + radix
))
4469 if (n
<= upper_limit
)
4472 n
+= c
- '0'; /* FIXME this overflows anyway */
4477 /* This depends on large values being output in octal, which is
4484 /* Ignore leading zeroes. */
4488 else if (c
== '2' || c
== '3')
4514 /* Large decimal constants are an error (because it is hard to
4515 count how many bits are in them). */
4521 /* -0x7f is the same as 0x80. So deal with it by adding one to
4522 the number of bits. */
4534 /* It's *BITS which has the interesting information. */
4538 static struct type
*
4539 read_range_type (pp
, typenums
, objfile
)
4542 struct objfile
*objfile
;
4544 char *orig_pp
= *pp
;
4549 struct type
*result_type
;
4550 struct type
*index_type
= NULL
;
4552 /* First comes a type we are a subrange of.
4553 In C it is usually 0, 1 or the type being defined. */
4554 if (read_type_number (pp
, rangenums
) != 0)
4555 return error_type (pp
, objfile
);
4556 self_subrange
= (rangenums
[0] == typenums
[0] &&
4557 rangenums
[1] == typenums
[1]);
4562 index_type
= read_type (pp
, objfile
);
4565 /* A semicolon should now follow; skip it. */
4569 /* The remaining two operands are usually lower and upper bounds
4570 of the range. But in some special cases they mean something else. */
4571 n2
= read_huge_number (pp
, ';', &n2bits
);
4572 n3
= read_huge_number (pp
, ';', &n3bits
);
4574 if (n2bits
== -1 || n3bits
== -1)
4575 return error_type (pp
, objfile
);
4578 goto handle_true_range
;
4580 /* If limits are huge, must be large integral type. */
4581 if (n2bits
!= 0 || n3bits
!= 0)
4583 char got_signed
= 0;
4584 char got_unsigned
= 0;
4585 /* Number of bits in the type. */
4588 /* Range from 0 to <large number> is an unsigned large integral type. */
4589 if ((n2bits
== 0 && n2
== 0) && n3bits
!= 0)
4594 /* Range from <large number> to <large number>-1 is a large signed
4595 integral type. Take care of the case where <large number> doesn't
4596 fit in a long but <large number>-1 does. */
4597 else if ((n2bits
!= 0 && n3bits
!= 0 && n2bits
== n3bits
+ 1)
4598 || (n2bits
!= 0 && n3bits
== 0
4599 && (n2bits
== sizeof (long) * HOST_CHAR_BIT
)
4606 if (got_signed
|| got_unsigned
)
4608 return init_type (TYPE_CODE_INT
, nbits
/ TARGET_CHAR_BIT
,
4609 got_unsigned
? TYPE_FLAG_UNSIGNED
: 0, NULL
,
4613 return error_type (pp
, objfile
);
4616 /* A type defined as a subrange of itself, with bounds both 0, is void. */
4617 if (self_subrange
&& n2
== 0 && n3
== 0)
4618 return init_type (TYPE_CODE_VOID
, 1, 0, NULL
, objfile
);
4620 /* If n3 is zero and n2 is positive, we want a floating type, and n2
4621 is the width in bytes.
4623 Fortran programs appear to use this for complex types also. To
4624 distinguish between floats and complex, g77 (and others?) seem
4625 to use self-subranges for the complexes, and subranges of int for
4628 Also note that for complexes, g77 sets n2 to the size of one of
4629 the member floats, not the whole complex beast. My guess is that
4630 this was to work well with pre-COMPLEX versions of gdb. */
4632 if (n3
== 0 && n2
> 0)
4636 return init_type (TYPE_CODE_COMPLEX
, 2 * n2
, 0, NULL
, objfile
);
4640 return init_type (TYPE_CODE_FLT
, n2
, 0, NULL
, objfile
);
4644 /* If the upper bound is -1, it must really be an unsigned int. */
4646 else if (n2
== 0 && n3
== -1)
4648 /* It is unsigned int or unsigned long. */
4649 /* GCC 2.3.3 uses this for long long too, but that is just a GDB 3.5
4650 compatibility hack. */
4651 return init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
4652 TYPE_FLAG_UNSIGNED
, NULL
, objfile
);
4655 /* Special case: char is defined (Who knows why) as a subrange of
4656 itself with range 0-127. */
4657 else if (self_subrange
&& n2
== 0 && n3
== 127)
4658 return init_type (TYPE_CODE_INT
, 1, 0, NULL
, objfile
);
4660 else if (current_symbol
&& SYMBOL_LANGUAGE (current_symbol
) == language_chill
4662 goto handle_true_range
;
4664 /* We used to do this only for subrange of self or subrange of int. */
4668 /* n3 actually gives the size. */
4669 return init_type (TYPE_CODE_INT
, - n3
, TYPE_FLAG_UNSIGNED
,
4672 return init_type (TYPE_CODE_INT
, 1, TYPE_FLAG_UNSIGNED
, NULL
, objfile
);
4674 return init_type (TYPE_CODE_INT
, 2, TYPE_FLAG_UNSIGNED
, NULL
, objfile
);
4676 /* -1 is used for the upper bound of (4 byte) "unsigned int" and
4677 "unsigned long", and we already checked for that,
4678 so don't need to test for it here. */
4680 /* I think this is for Convex "long long". Since I don't know whether
4681 Convex sets self_subrange, I also accept that particular size regardless
4682 of self_subrange. */
4683 else if (n3
== 0 && n2
< 0
4685 || n2
== - TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
))
4686 return init_type (TYPE_CODE_INT
, - n2
, 0, NULL
, objfile
);
4687 else if (n2
== -n3
-1)
4690 return init_type (TYPE_CODE_INT
, 1, 0, NULL
, objfile
);
4692 return init_type (TYPE_CODE_INT
, 2, 0, NULL
, objfile
);
4693 if (n3
== 0x7fffffff)
4694 return init_type (TYPE_CODE_INT
, 4, 0, NULL
, objfile
);
4697 /* We have a real range type on our hands. Allocate space and
4698 return a real pointer. */
4702 index_type
= builtin_type_int
;
4704 index_type
= *dbx_lookup_type (rangenums
);
4705 if (index_type
== NULL
)
4707 /* Does this actually ever happen? Is that why we are worrying
4708 about dealing with it rather than just calling error_type? */
4710 static struct type
*range_type_index
;
4712 complain (&range_type_base_complaint
, rangenums
[1]);
4713 if (range_type_index
== NULL
)
4715 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
4716 0, "range type index type", NULL
);
4717 index_type
= range_type_index
;
4720 result_type
= create_range_type ((struct type
*) NULL
, index_type
, n2
, n3
);
4721 return (result_type
);
4724 /* Read in an argument list. This is a list of types, separated by commas
4725 and terminated with END. Return the list of types read in, or (struct type
4726 **)-1 if there is an error. */
4728 static struct type
**
4729 read_args (pp
, end
, objfile
)
4732 struct objfile
*objfile
;
4734 /* FIXME! Remove this arbitrary limit! */
4735 struct type
*types
[1024], **rval
; /* allow for fns of 1023 parameters */
4741 /* Invalid argument list: no ','. */
4742 return (struct type
**)-1;
4744 STABS_CONTINUE (pp
, objfile
);
4745 types
[n
++] = read_type (pp
, objfile
);
4747 (*pp
)++; /* get past `end' (the ':' character) */
4751 rval
= (struct type
**) xmalloc (2 * sizeof (struct type
*));
4753 else if (TYPE_CODE (types
[n
-1]) != TYPE_CODE_VOID
)
4755 rval
= (struct type
**) xmalloc ((n
+ 1) * sizeof (struct type
*));
4756 memset (rval
+ n
, 0, sizeof (struct type
*));
4760 rval
= (struct type
**) xmalloc (n
* sizeof (struct type
*));
4762 memcpy (rval
, types
, n
* sizeof (struct type
*));
4766 /* Common block handling. */
4768 /* List of symbols declared since the last BCOMM. This list is a tail
4769 of local_symbols. When ECOMM is seen, the symbols on the list
4770 are noted so their proper addresses can be filled in later,
4771 using the common block base address gotten from the assembler
4774 static struct pending
*common_block
;
4775 static int common_block_i
;
4777 /* Name of the current common block. We get it from the BCOMM instead of the
4778 ECOMM to match IBM documentation (even though IBM puts the name both places
4779 like everyone else). */
4780 static char *common_block_name
;
4782 /* Process a N_BCOMM symbol. The storage for NAME is not guaranteed
4783 to remain after this function returns. */
4786 common_block_start (name
, objfile
)
4788 struct objfile
*objfile
;
4790 if (common_block_name
!= NULL
)
4792 static struct complaint msg
= {
4793 "Invalid symbol data: common block within common block",
4797 common_block
= local_symbols
;
4798 common_block_i
= local_symbols
? local_symbols
->nsyms
: 0;
4799 common_block_name
= obsavestring (name
, strlen (name
),
4800 &objfile
-> symbol_obstack
);
4803 /* Process a N_ECOMM symbol. */
4806 common_block_end (objfile
)
4807 struct objfile
*objfile
;
4809 /* Symbols declared since the BCOMM are to have the common block
4810 start address added in when we know it. common_block and
4811 common_block_i point to the first symbol after the BCOMM in
4812 the local_symbols list; copy the list and hang it off the
4813 symbol for the common block name for later fixup. */
4816 struct pending
*new = 0;
4817 struct pending
*next
;
4820 if (common_block_name
== NULL
)
4822 static struct complaint msg
= {"ECOMM symbol unmatched by BCOMM", 0, 0};
4827 sym
= (struct symbol
*)
4828 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
4829 memset (sym
, 0, sizeof (struct symbol
));
4830 /* Note: common_block_name already saved on symbol_obstack */
4831 SYMBOL_NAME (sym
) = common_block_name
;
4832 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
4834 /* Now we copy all the symbols which have been defined since the BCOMM. */
4836 /* Copy all the struct pendings before common_block. */
4837 for (next
= local_symbols
;
4838 next
!= NULL
&& next
!= common_block
;
4841 for (j
= 0; j
< next
->nsyms
; j
++)
4842 add_symbol_to_list (next
->symbol
[j
], &new);
4845 /* Copy however much of COMMON_BLOCK we need. If COMMON_BLOCK is
4846 NULL, it means copy all the local symbols (which we already did
4849 if (common_block
!= NULL
)
4850 for (j
= common_block_i
; j
< common_block
->nsyms
; j
++)
4851 add_symbol_to_list (common_block
->symbol
[j
], &new);
4853 SYMBOL_TYPE (sym
) = (struct type
*) new;
4855 /* Should we be putting local_symbols back to what it was?
4858 i
= hashname (SYMBOL_NAME (sym
));
4859 SYMBOL_VALUE_CHAIN (sym
) = global_sym_chain
[i
];
4860 global_sym_chain
[i
] = sym
;
4861 common_block_name
= NULL
;
4864 /* Add a common block's start address to the offset of each symbol
4865 declared to be in it (by being between a BCOMM/ECOMM pair that uses
4866 the common block name). */
4869 fix_common_block (sym
, valu
)
4873 struct pending
*next
= (struct pending
*) SYMBOL_TYPE (sym
);
4874 for ( ; next
; next
= next
->next
)
4877 for (j
= next
->nsyms
- 1; j
>= 0; j
--)
4878 SYMBOL_VALUE_ADDRESS (next
->symbol
[j
]) += valu
;
4884 /* What about types defined as forward references inside of a small lexical
4886 /* Add a type to the list of undefined types to be checked through
4887 once this file has been read in. */
4890 add_undefined_type (type
)
4893 if (undef_types_length
== undef_types_allocated
)
4895 undef_types_allocated
*= 2;
4896 undef_types
= (struct type
**)
4897 xrealloc ((char *) undef_types
,
4898 undef_types_allocated
* sizeof (struct type
*));
4900 undef_types
[undef_types_length
++] = type
;
4903 /* Go through each undefined type, see if it's still undefined, and fix it
4904 up if possible. We have two kinds of undefined types:
4906 TYPE_CODE_ARRAY: Array whose target type wasn't defined yet.
4907 Fix: update array length using the element bounds
4908 and the target type's length.
4909 TYPE_CODE_STRUCT, TYPE_CODE_UNION: Structure whose fields were not
4910 yet defined at the time a pointer to it was made.
4911 Fix: Do a full lookup on the struct/union tag. */
4913 cleanup_undefined_types ()
4917 for (type
= undef_types
; type
< undef_types
+ undef_types_length
; type
++)
4919 switch (TYPE_CODE (*type
))
4922 case TYPE_CODE_STRUCT
:
4923 case TYPE_CODE_UNION
:
4924 case TYPE_CODE_ENUM
:
4926 /* Check if it has been defined since. Need to do this here
4927 as well as in check_typedef to deal with the (legitimate in
4928 C though not C++) case of several types with the same name
4929 in different source files. */
4930 if (TYPE_FLAGS (*type
) & TYPE_FLAG_STUB
)
4932 struct pending
*ppt
;
4934 /* Name of the type, without "struct" or "union" */
4935 char *typename
= TYPE_TAG_NAME (*type
);
4937 if (typename
== NULL
)
4939 static struct complaint msg
= {"need a type name", 0, 0};
4943 for (ppt
= file_symbols
; ppt
; ppt
= ppt
->next
)
4945 for (i
= 0; i
< ppt
->nsyms
; i
++)
4947 struct symbol
*sym
= ppt
->symbol
[i
];
4949 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
4950 && SYMBOL_NAMESPACE (sym
) == STRUCT_NAMESPACE
4951 && (TYPE_CODE (SYMBOL_TYPE (sym
)) ==
4953 && STREQ (SYMBOL_NAME (sym
), typename
))
4955 memcpy (*type
, SYMBOL_TYPE (sym
),
4956 sizeof (struct type
));
4966 static struct complaint msg
= {"\
4967 GDB internal error. cleanup_undefined_types with bad type %d.", 0, 0};
4968 complain (&msg
, TYPE_CODE (*type
));
4974 undef_types_length
= 0;
4977 /* Scan through all of the global symbols defined in the object file,
4978 assigning values to the debugging symbols that need to be assigned
4979 to. Get these symbols from the minimal symbol table. */
4982 scan_file_globals (objfile
)
4983 struct objfile
*objfile
;
4986 struct minimal_symbol
*msymbol
;
4987 struct symbol
*sym
, *prev
, *rsym
;
4988 struct objfile
*resolve_objfile
;
4990 /* SVR4 based linkers copy referenced global symbols from shared
4991 libraries to the main executable.
4992 If we are scanning the symbols for a shared library, try to resolve
4993 them from the minimal symbols of the main executable first. */
4995 if (symfile_objfile
&& objfile
!= symfile_objfile
)
4996 resolve_objfile
= symfile_objfile
;
4998 resolve_objfile
= objfile
;
5002 /* Avoid expensive loop through all minimal symbols if there are
5003 no unresolved symbols. */
5004 for (hash
= 0; hash
< HASHSIZE
; hash
++)
5006 if (global_sym_chain
[hash
])
5009 if (hash
>= HASHSIZE
)
5012 for (msymbol
= resolve_objfile
-> msymbols
;
5013 msymbol
&& SYMBOL_NAME (msymbol
) != NULL
;
5018 /* Skip static symbols. */
5019 switch (MSYMBOL_TYPE (msymbol
))
5031 /* Get the hash index and check all the symbols
5032 under that hash index. */
5034 hash
= hashname (SYMBOL_NAME (msymbol
));
5036 for (sym
= global_sym_chain
[hash
]; sym
;)
5038 if (SYMBOL_NAME (msymbol
)[0] == SYMBOL_NAME (sym
)[0] &&
5039 STREQ(SYMBOL_NAME (msymbol
) + 1, SYMBOL_NAME (sym
) + 1))
5042 struct alias_list
*aliases
;
5044 /* Splice this symbol out of the hash chain and
5045 assign the value we have to it. */
5048 SYMBOL_VALUE_CHAIN (prev
) = SYMBOL_VALUE_CHAIN (sym
);
5052 global_sym_chain
[hash
] = SYMBOL_VALUE_CHAIN (sym
);
5055 /* Check to see whether we need to fix up a common block. */
5056 /* Note: this code might be executed several times for
5057 the same symbol if there are multiple references. */
5059 /* If symbol has aliases, do minimal symbol fixups for each.
5060 These live aliases/references weren't added to
5061 global_sym_chain hash but may also need to be fixed up. */
5062 /* FIXME: Maybe should have added aliases to the global chain, resolved symbol name, then treated aliases as normal
5063 symbols? Still, we wouldn't want to add_to_list. */
5064 /* Now do the same for each alias of this symbol */
5066 aliases
= SYMBOL_ALIASES (sym
);
5069 if (SYMBOL_CLASS (rsym
) == LOC_BLOCK
)
5071 fix_common_block (rsym
,
5072 SYMBOL_VALUE_ADDRESS (msymbol
));
5076 SYMBOL_VALUE_ADDRESS (rsym
)
5077 = SYMBOL_VALUE_ADDRESS (msymbol
);
5079 SYMBOL_SECTION (rsym
) = SYMBOL_SECTION (msymbol
);
5082 rsym
= aliases
->sym
;
5083 aliases
= aliases
->next
;
5092 sym
= SYMBOL_VALUE_CHAIN (prev
);
5096 sym
= global_sym_chain
[hash
];
5102 sym
= SYMBOL_VALUE_CHAIN (sym
);
5106 if (resolve_objfile
== objfile
)
5108 resolve_objfile
= objfile
;
5111 /* Change the storage class of any remaining unresolved globals to
5112 LOC_UNRESOLVED and remove them from the chain. */
5113 for (hash
= 0; hash
< HASHSIZE
; hash
++)
5115 sym
= global_sym_chain
[hash
];
5119 sym
= SYMBOL_VALUE_CHAIN (sym
);
5121 /* Change the symbol address from the misleading chain value
5123 SYMBOL_VALUE_ADDRESS (prev
) = 0;
5125 /* Complain about unresolved common block symbols. */
5126 if (SYMBOL_CLASS (prev
) == LOC_STATIC
)
5127 SYMBOL_CLASS (prev
) = LOC_UNRESOLVED
;
5129 complain (&unresolved_sym_chain_complaint
,
5130 objfile
-> name
, SYMBOL_NAME (prev
));
5133 memset (global_sym_chain
, 0, sizeof (global_sym_chain
));
5136 /* Initialize anything that needs initializing when starting to read
5137 a fresh piece of a symbol file, e.g. reading in the stuff corresponding
5145 /* Initialize anything that needs initializing when a completely new
5146 symbol file is specified (not just adding some symbols from another
5147 file, e.g. a shared library). */
5150 stabsread_new_init ()
5152 /* Empty the hash table of global syms looking for values. */
5153 memset (global_sym_chain
, 0, sizeof (global_sym_chain
));
5156 /* Initialize anything that needs initializing at the same time as
5157 start_symtab() is called. */
5161 global_stabs
= NULL
; /* AIX COFF */
5162 /* Leave FILENUM of 0 free for builtin types and this file's types. */
5163 n_this_object_header_files
= 1;
5164 type_vector_length
= 0;
5165 type_vector
= (struct type
**) 0;
5167 /* FIXME: If common_block_name is not already NULL, we should complain(). */
5168 common_block_name
= NULL
;
5173 /* Call after end_symtab() */
5179 free ((char *) type_vector
);
5182 type_vector_length
= 0;
5183 previous_stab_code
= 0;
5187 finish_global_stabs (objfile
)
5188 struct objfile
*objfile
;
5192 patch_block_stabs (global_symbols
, global_stabs
, objfile
);
5193 free ((PTR
) global_stabs
);
5194 global_stabs
= NULL
;
5198 /* Initializer for this module */
5201 _initialize_stabsread ()
5203 undef_types_allocated
= 20;
5204 undef_types_length
= 0;
5205 undef_types
= (struct type
**)
5206 xmalloc (undef_types_allocated
* sizeof (struct type
*));