1 /* Support routines for decoding "stabs" debugging information format.
2 Copyright 1986, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 1997
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 ref_init
PARAMS ((void));
192 get_substring
PARAMS ((char ** p
, int c
));
194 static const char vptr_name
[] = { '_','v','p','t','r',CPLUS_MARKER
,'\0' };
195 static const char vb_name
[] = { '_','v','b',CPLUS_MARKER
,'\0' };
197 /* Define this as 1 if a pcc declaration of a char or short argument
198 gives the correct address. Otherwise assume pcc gives the
199 address of the corresponding int, which is not the same on a
200 big-endian machine. */
202 #ifndef BELIEVE_PCC_PROMOTION
203 #define BELIEVE_PCC_PROMOTION 0
206 struct complaint invalid_cpp_abbrev_complaint
=
207 {"invalid C++ abbreviation `%s'", 0, 0};
209 struct complaint invalid_cpp_type_complaint
=
210 {"C++ abbreviated type name unknown at symtab pos %d", 0, 0};
212 struct complaint member_fn_complaint
=
213 {"member function type missing, got '%c'", 0, 0};
215 struct complaint const_vol_complaint
=
216 {"const/volatile indicator missing, got '%c'", 0, 0};
218 struct complaint error_type_complaint
=
219 {"debug info mismatch between compiler and debugger", 0, 0};
221 struct complaint invalid_member_complaint
=
222 {"invalid (minimal) member type data format at symtab pos %d.", 0, 0};
224 struct complaint range_type_base_complaint
=
225 {"base type %d of range type is not defined", 0, 0};
227 struct complaint reg_value_complaint
=
228 {"register number %d too large (max %d) in symbol %s", 0, 0};
230 struct complaint vtbl_notfound_complaint
=
231 {"virtual function table pointer not found when defining class `%s'", 0, 0};
233 struct complaint unrecognized_cplus_name_complaint
=
234 {"Unknown C++ symbol name `%s'", 0, 0};
236 struct complaint rs6000_builtin_complaint
=
237 {"Unknown builtin type %d", 0, 0};
239 struct complaint unresolved_sym_chain_complaint
=
240 {"%s: common block `%s' from global_sym_chain unresolved", 0, 0};
242 struct complaint stabs_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 to point to the original
1048 The main need for this function is to add information for supporting
1049 live range splitting.
1050 eg: p : "#7=", "#2=z:r(0,1)" "#2:r(0,1);l(#5,#6),l(#7,#4)" */
1052 resolve_symbol_reference (objfile
, sym
, p
)
1053 struct objfile
* objfile
;
1054 struct symbol
* sym
;
1058 struct symbol
* ref_sym
=0;
1059 struct cleanup
*back_to
;
1061 back_to
= make_cleanup (null_cleanup
, 0);
1063 if (*p
!= '#') /* symbol ref id */
1066 /* Use "#<num>" as the name; we'll fix the name later.
1067 We stored the original symbol name as "#<id>=<name>"
1068 so we can now search for "#<id>" to resolving the reference.
1069 We'll fix the names later by removing the "#<id>" or "#<id>=" */
1071 /*---------------------------------------------------------*/
1072 /* Get the reference id number, and
1073 advance p past the names so we can parse the rest.
1074 eg: id=2 for p : "2=", "2=z:r(0,1)" "2:r(0,1);l(#5,#6),l(#7,#4)" */
1075 /*---------------------------------------------------------*/
1077 /* This gets reference name from string. sym may not have a name. */
1078 refnum
= process_reference (&p
);
1079 ref_sym
= ref_search (refnum
);
1081 error ("error: symbol for reference not found.\n");
1083 /* Parse the stab of the referencing symbol
1084 now that we have the referenced symbol.
1085 Add it as a new symbol and a link back to the referenced symbol.
1086 eg: p : "=", "=z:r(0,1)" ":r(0,1);l(#5,#6),l(#7,#4)" */
1089 /* If the stab symbol table and string contain:
1090 RSYM 0 5 00000000 868 #15=z:r(0,1)
1091 LBRAC 0 0 00000000 899 #5=
1092 SLINE 0 16 00000003 923 #6=
1093 Then the same symbols can be later referenced by:
1094 RSYM 0 5 00000000 927 #15:r(0,1);l(#5,#6)
1095 This is used in live range splitting to:
1096 1) specify that a symbol (#15) is actually just a new storage
1097 class for a symbol (#15=z) which was previously defined.
1098 2) specify that the beginning and ending ranges for a symbol
1099 (#15) are the values of the beginning (#5) and ending (#6)
1102 /* Read number as reference id.
1103 eg: p : "=", "=z:r(0,1)" ":r(0,1);l(#5,#6),l(#7,#4)" */
1104 /* FIXME! Might I want to use SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
1105 in case of "l(0,0)"? */
1107 /*--------------------------------------------------*/
1108 /* Add this symbol to the reference list. */
1109 /*--------------------------------------------------*/
1110 SYMBOL_ALIASES (sym
) = SYMBOL_ALIASES (ref_sym
);
1111 SYMBOL_ALIASES (ref_sym
) = sym
;
1113 /* Want to fix up name so that other functions (eg. valops)
1114 will correctly print the name.
1115 Don't add_symbol_to_list so that lookup_symbol won't find it.
1116 nope... needed for fixups. */
1117 SYMBOL_NAME (sym
) = SYMBOL_NAME (ref_sym
);
1121 do_cleanups (back_to
);
1125 /* Get range symbol reference. eg. "#2),l(#3,#5)"
1126 postpone resolve_reference until after we're done reading symbols. */
1128 resolve_reference (p
)
1132 struct symbol
*sym
= 0;
1136 if (!s
|| *s
!= '#')
1138 p
= strchr (s
, ')');
1142 strncpy (sym_refid
, s
, len
);
1143 sym_refid
[len
] = '\0';
1144 sym
= lookup_symbol (sym_refid
, 0, VAR_NAMESPACE
, 0, 0);
1149 #define MAX_CHUNK_REFS 100
1150 #define REF_CHUNK_SIZE \
1151 MAX_CHUNK_REFS * sizeof (struct ref_map_s)
1152 #define REF_MAP_SIZE(ref_chunk) \
1153 ref_chunk * REF_CHUNK_SIZE
1155 /* Structure for storing pointers to reference definitions for fast lookup
1156 during "process_later". */
1157 static struct ref_map_s
1164 /* Ptr to free cell in chunk's linked list. */
1165 static int ref_count
= 0;
1167 /* Number of chunks malloced. */
1168 static int ref_chunk
= 0;
1170 /* Initialize our list of references.
1171 This should be called before any symbol table is read.
1172 FIXME: Will reference numbers be unique only to objects? If so, we may
1173 need to add something to disambiguate the refids. Or, it might be OK to
1174 leave as is, as long as we read and process an object's symbol table all
1184 /* Create array of pointers mapping refids to symbols and stab strings.
1185 Add pointers to reference definition symbols and/or their values as we
1186 find them, using their reference numbers as our index.
1187 These will be used later when we resolve references. */
1189 ref_add (refnum
, sym
, stabs
, value
)
1197 if (refnum
>= ref_count
)
1198 ref_count
= refnum
+ 1;
1199 if (ref_count
> ref_chunk
* MAX_CHUNK_REFS
)
1201 int new_slots
= ref_count
- ref_chunk
* MAX_CHUNK_REFS
;
1202 int new_chunks
= new_slots
/ MAX_CHUNK_REFS
+ 1;
1203 ref_map
= realloc (ref_map
, REF_MAP_SIZE(ref_chunk
+ new_chunks
));
1205 error ("no more free slots in chain\n");
1206 memset (ref_map
+ REF_MAP_SIZE(ref_chunk
), 0, new_chunks
* REF_CHUNK_SIZE
);
1207 ref_chunk
+= new_chunks
;
1209 ref_map
[refnum
].stabs
= stabs
;
1210 ref_map
[refnum
].sym
= sym
;
1211 ref_map
[refnum
].value
= value
;
1214 /* Return defined sym for the reference "refnum" */
1219 if (refnum
< 0 || refnum
> ref_count
)
1221 return ref_map
[refnum
].sym
;
1224 /* Return value for the reference "refnum" */
1226 ref_search_value (refnum
)
1229 if (refnum
< 0 || refnum
> ref_count
)
1231 return ref_map
[refnum
].value
;
1234 /* Parse reference id and advance string to the next character following
1236 Return the reference number. */
1239 process_reference (string
)
1245 if (**string
!= '#')
1248 /* Read number as reference id. */
1249 p
= *string
+ 1; /* Advance beyond '#' */
1250 while (*p
&& isdigit (*p
))
1252 refnum
= refnum
* 10 + *p
- '0';
1259 /* If string defines a reference, store away a pointer to the reference
1260 definition for fast lookup when we "process_later",
1261 and return the reference number. */
1263 symbol_reference_defined (string
)
1269 refnum
= process_reference (&p
);
1271 /* Defining symbols end in '=' */
1274 /* Symbol is being defined here. */
1281 /* Must be a reference. Either the symbol has already been defined,
1282 or this is a forward reference to it. */
1285 return 0; /* Not defined here */
1291 define_symbol (valu
, string
, desc
, type
, objfile
)
1296 struct objfile
*objfile
;
1298 register struct symbol
*sym
;
1299 char *p
= (char *) strchr (string
, ':');
1304 /* We would like to eliminate nameless symbols, but keep their types.
1305 E.g. stab entry ":t10=*2" should produce a type 10, which is a pointer
1306 to type 2, but, should not create a symbol to address that type. Since
1307 the symbol will be nameless, there is no way any user can refer to it. */
1311 /* Ignore syms with empty names. */
1315 /* Ignore old-style symbols from cc -go */
1322 p
= strchr (p
, ':');
1325 /* If a nameless stab entry, all we need is the type, not the symbol.
1326 e.g. ":t10=*2" or a nameless enum like " :T16=ered:0,green:1,blue:2,;" */
1327 nameless
= (p
== string
|| ((string
[0] == ' ') && (string
[1] == ':')));
1329 current_symbol
= sym
= (struct symbol
*)
1330 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
1331 memset (sym
, 0, sizeof (struct symbol
));
1333 switch (type
& N_TYPE
)
1336 SYMBOL_SECTION(sym
) = SECT_OFF_TEXT
;
1339 SYMBOL_SECTION(sym
) = SECT_OFF_DATA
;
1342 SYMBOL_SECTION(sym
) = SECT_OFF_BSS
;
1346 if (processing_gcc_compilation
)
1348 /* GCC 2.x puts the line number in desc. SunOS apparently puts in the
1349 number of bytes occupied by a type or object, which we ignore. */
1350 SYMBOL_LINE(sym
) = desc
;
1354 SYMBOL_LINE(sym
) = 0; /* unknown */
1357 if (is_cplus_marker (string
[0]))
1359 /* Special GNU C++ names. */
1363 SYMBOL_NAME (sym
) = obsavestring ("this", strlen ("this"),
1364 &objfile
-> symbol_obstack
);
1367 case 'v': /* $vtbl_ptr_type */
1368 /* Was: SYMBOL_NAME (sym) = "vptr"; */
1372 SYMBOL_NAME (sym
) = obsavestring ("eh_throw", strlen ("eh_throw"),
1373 &objfile
-> symbol_obstack
);
1377 /* This was an anonymous type that was never fixed up. */
1380 #ifdef STATIC_TRANSFORM_NAME
1382 /* SunPRO (3.0 at least) static variable encoding. */
1387 complain (&unrecognized_cplus_name_complaint
, string
);
1388 goto normal
; /* Do *something* with it */
1391 else if (string
[0] == '#')
1393 /* Special GNU C extension for referencing symbols. */
1397 /* Initialize symbol references and determine if this is
1398 a definition. If symbol reference is being defined, go
1399 ahead and add it. Otherwise, just return sym. */
1401 if (refnum
= symbol_reference_defined (&s
), refnum
)
1402 ref_add (refnum
, sym
, string
, SYMBOL_VALUE (sym
));
1404 process_later (sym
, string
, resolve_symbol_reference
);
1406 /* s is after refid... advance string there
1407 so that the symbol name will not include the refid. */
1411 SYMBOL_NAME (sym
) = (char *)
1412 obstack_alloc (&objfile
-> symbol_obstack
, nlen
);
1413 strncpy (SYMBOL_NAME (sym
), s
, nlen
);
1414 SYMBOL_NAME (sym
)[nlen
] = '\0';
1415 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
->symbol_obstack
);
1418 /* FIXME! Want SYMBOL_NAME (sym) = 0;
1419 Get error if leave name 0. So give it something. */
1422 SYMBOL_NAME (sym
) = (char *)
1423 obstack_alloc (&objfile
-> symbol_obstack
, nlen
);
1424 strncpy (SYMBOL_NAME (sym
), string
, nlen
);
1425 SYMBOL_NAME (sym
)[nlen
] = '\0';
1426 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
->symbol_obstack
);
1433 SYMBOL_LANGUAGE (sym
) = current_subfile
-> language
;
1434 SYMBOL_NAME (sym
) = (char *)
1435 obstack_alloc (&objfile
-> symbol_obstack
, ((p
- string
) + 1));
1436 /* Open-coded memcpy--saves function call time. */
1437 /* FIXME: Does it really? Try replacing with simple strcpy and
1438 try it on an executable with a large symbol table. */
1439 /* FIXME: considering that gcc can open code memcpy anyway, I
1440 doubt it. xoxorich. */
1442 register char *p1
= string
;
1443 register char *p2
= SYMBOL_NAME (sym
);
1451 /* If this symbol is from a C++ compilation, then attempt to cache the
1452 demangled form for future reference. This is a typical time versus
1453 space tradeoff, that was decided in favor of time because it sped up
1454 C++ symbol lookups by a factor of about 20. */
1456 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
->symbol_obstack
);
1460 /* Determine the type of name being defined. */
1462 /* Getting GDB to correctly skip the symbol on an undefined symbol
1463 descriptor and not ever dump core is a very dodgy proposition if
1464 we do things this way. I say the acorn RISC machine can just
1465 fix their compiler. */
1466 /* The Acorn RISC machine's compiler can put out locals that don't
1467 start with "234=" or "(3,4)=", so assume anything other than the
1468 deftypes we know how to handle is a local. */
1469 if (!strchr ("cfFGpPrStTvVXCR", *p
))
1471 if (isdigit (*p
) || *p
== '(' || *p
== '-')
1480 /* c is a special case, not followed by a type-number.
1481 SYMBOL:c=iVALUE for an integer constant symbol.
1482 SYMBOL:c=rVALUE for a floating constant symbol.
1483 SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
1484 e.g. "b:c=e6,0" for "const b = blob1"
1485 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
1488 SYMBOL_CLASS (sym
) = LOC_CONST
;
1489 SYMBOL_TYPE (sym
) = error_type (&p
, objfile
);
1490 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1491 add_symbol_to_list (sym
, &file_symbols
);
1499 double d
= atof (p
);
1502 /* FIXME-if-picky-about-floating-accuracy: Should be using
1503 target arithmetic to get the value. real.c in GCC
1504 probably has the necessary code. */
1506 /* FIXME: lookup_fundamental_type is a hack. We should be
1507 creating a type especially for the type of float constants.
1508 Problem is, what type should it be?
1510 Also, what should the name of this type be? Should we
1511 be using 'S' constants (see stabs.texinfo) instead? */
1513 SYMBOL_TYPE (sym
) = lookup_fundamental_type (objfile
,
1516 obstack_alloc (&objfile
-> symbol_obstack
,
1517 TYPE_LENGTH (SYMBOL_TYPE (sym
)));
1518 store_floating (dbl_valu
, TYPE_LENGTH (SYMBOL_TYPE (sym
)), d
);
1519 SYMBOL_VALUE_BYTES (sym
) = dbl_valu
;
1520 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
1525 /* Defining integer constants this way is kind of silly,
1526 since 'e' constants allows the compiler to give not
1527 only the value, but the type as well. C has at least
1528 int, long, unsigned int, and long long as constant
1529 types; other languages probably should have at least
1530 unsigned as well as signed constants. */
1532 /* We just need one int constant type for all objfiles.
1533 It doesn't depend on languages or anything (arguably its
1534 name should be a language-specific name for a type of
1535 that size, but I'm inclined to say that if the compiler
1536 wants a nice name for the type, it can use 'e'). */
1537 static struct type
*int_const_type
;
1539 /* Yes, this is as long as a *host* int. That is because we
1541 if (int_const_type
== NULL
)
1543 init_type (TYPE_CODE_INT
,
1544 sizeof (int) * HOST_CHAR_BIT
/ TARGET_CHAR_BIT
, 0,
1546 (struct objfile
*)NULL
);
1547 SYMBOL_TYPE (sym
) = int_const_type
;
1548 SYMBOL_VALUE (sym
) = atoi (p
);
1549 SYMBOL_CLASS (sym
) = LOC_CONST
;
1553 /* SYMBOL:c=eTYPE,INTVALUE for a constant symbol whose value
1554 can be represented as integral.
1555 e.g. "b:c=e6,0" for "const b = blob1"
1556 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
1558 SYMBOL_CLASS (sym
) = LOC_CONST
;
1559 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1563 SYMBOL_TYPE (sym
) = error_type (&p
, objfile
);
1568 /* If the value is too big to fit in an int (perhaps because
1569 it is unsigned), or something like that, we silently get
1570 a bogus value. The type and everything else about it is
1571 correct. Ideally, we should be using whatever we have
1572 available for parsing unsigned and long long values,
1574 SYMBOL_VALUE (sym
) = atoi (p
);
1579 SYMBOL_CLASS (sym
) = LOC_CONST
;
1580 SYMBOL_TYPE (sym
) = error_type (&p
, objfile
);
1583 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1584 add_symbol_to_list (sym
, &file_symbols
);
1588 /* The name of a caught exception. */
1589 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1590 SYMBOL_CLASS (sym
) = LOC_LABEL
;
1591 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1592 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
1593 add_symbol_to_list (sym
, &local_symbols
);
1597 /* A static function definition. */
1598 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1599 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1600 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1601 add_symbol_to_list (sym
, &file_symbols
);
1602 /* fall into process_function_types. */
1604 process_function_types
:
1605 /* Function result types are described as the result type in stabs.
1606 We need to convert this to the function-returning-type-X type
1607 in GDB. E.g. "int" is converted to "function returning int". */
1608 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_FUNC
)
1609 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
1610 /* fall into process_prototype_types */
1612 process_prototype_types
:
1613 /* Sun acc puts declared types of arguments here. We don't care
1614 about their actual types (FIXME -- we should remember the whole
1615 function prototype), but the list may define some new types
1616 that we have to remember, so we must scan it now. */
1619 read_type (&p
, objfile
);
1624 /* A global function definition. */
1625 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1626 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1627 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1628 add_symbol_to_list (sym
, &global_symbols
);
1629 goto process_function_types
;
1632 /* For a class G (global) symbol, it appears that the
1633 value is not correct. It is necessary to search for the
1634 corresponding linker definition to find the value.
1635 These definitions appear at the end of the namelist. */
1636 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1637 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1638 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1639 /* Don't add symbol references to global_sym_chain.
1640 Symbol references don't have valid names and wont't match up with
1641 minimal symbols when the global_sym_chain is relocated.
1642 We'll fixup symbol references when we fixup the defining symbol. */
1643 if (SYMBOL_NAME (sym
) && SYMBOL_NAME (sym
)[0] != '#')
1645 i
= hashname (SYMBOL_NAME (sym
));
1646 SYMBOL_VALUE_CHAIN (sym
) = global_sym_chain
[i
];
1647 global_sym_chain
[i
] = sym
;
1649 add_symbol_to_list (sym
, &global_symbols
);
1652 /* This case is faked by a conditional above,
1653 when there is no code letter in the dbx data.
1654 Dbx data never actually contains 'l'. */
1657 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1658 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
1659 SYMBOL_VALUE (sym
) = valu
;
1660 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1661 add_symbol_to_list (sym
, &local_symbols
);
1666 /* pF is a two-letter code that means a function parameter in Fortran.
1667 The type-number specifies the type of the return value.
1668 Translate it into a pointer-to-function type. */
1672 = lookup_pointer_type
1673 (lookup_function_type (read_type (&p
, objfile
)));
1676 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1678 /* Normally this is a parameter, a LOC_ARG. On the i960, it
1679 can also be a LOC_LOCAL_ARG depending on symbol type. */
1680 #ifndef DBX_PARM_SYMBOL_CLASS
1681 #define DBX_PARM_SYMBOL_CLASS(type) LOC_ARG
1684 SYMBOL_CLASS (sym
) = DBX_PARM_SYMBOL_CLASS (type
);
1685 SYMBOL_VALUE (sym
) = valu
;
1686 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1687 add_symbol_to_list (sym
, &local_symbols
);
1689 if (TARGET_BYTE_ORDER
!= BIG_ENDIAN
)
1691 /* On little-endian machines, this crud is never necessary,
1692 and, if the extra bytes contain garbage, is harmful. */
1696 /* If it's gcc-compiled, if it says `short', believe it. */
1697 if (processing_gcc_compilation
|| BELIEVE_PCC_PROMOTION
)
1700 #if !BELIEVE_PCC_PROMOTION
1702 /* This is the signed type which arguments get promoted to. */
1703 static struct type
*pcc_promotion_type
;
1704 /* This is the unsigned type which arguments get promoted to. */
1705 static struct type
*pcc_unsigned_promotion_type
;
1707 /* Call it "int" because this is mainly C lossage. */
1708 if (pcc_promotion_type
== NULL
)
1709 pcc_promotion_type
=
1710 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
1713 if (pcc_unsigned_promotion_type
== NULL
)
1714 pcc_unsigned_promotion_type
=
1715 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
1716 TYPE_FLAG_UNSIGNED
, "unsigned int", NULL
);
1718 #if defined(BELIEVE_PCC_PROMOTION_TYPE)
1719 /* This macro is defined on machines (e.g. sparc) where
1720 we should believe the type of a PCC 'short' argument,
1721 but shouldn't believe the address (the address is
1722 the address of the corresponding int).
1724 My guess is that this correction, as opposed to changing
1725 the parameter to an 'int' (as done below, for PCC
1726 on most machines), is the right thing to do
1727 on all machines, but I don't want to risk breaking
1728 something that already works. On most PCC machines,
1729 the sparc problem doesn't come up because the calling
1730 function has to zero the top bytes (not knowing whether
1731 the called function wants an int or a short), so there
1732 is little practical difference between an int and a short
1733 (except perhaps what happens when the GDB user types
1734 "print short_arg = 0x10000;").
1736 Hacked for SunOS 4.1 by gnu@cygnus.com. In 4.1, the compiler
1737 actually produces the correct address (we don't need to fix it
1738 up). I made this code adapt so that it will offset the symbol
1739 if it was pointing at an int-aligned location and not
1740 otherwise. This way you can use the same gdb for 4.0.x and
1743 If the parameter is shorter than an int, and is integral
1744 (e.g. char, short, or unsigned equivalent), and is claimed to
1745 be passed on an integer boundary, don't believe it! Offset the
1746 parameter's address to the tail-end of that integer. */
1748 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (pcc_promotion_type
)
1749 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
1750 && 0 == SYMBOL_VALUE (sym
) % TYPE_LENGTH (pcc_promotion_type
))
1752 SYMBOL_VALUE (sym
) += TYPE_LENGTH (pcc_promotion_type
)
1753 - TYPE_LENGTH (SYMBOL_TYPE (sym
));
1757 #else /* no BELIEVE_PCC_PROMOTION_TYPE. */
1759 /* If PCC says a parameter is a short or a char,
1760 it is really an int. */
1761 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (pcc_promotion_type
)
1762 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
)
1765 TYPE_UNSIGNED (SYMBOL_TYPE (sym
))
1766 ? pcc_unsigned_promotion_type
1767 : pcc_promotion_type
;
1771 #endif /* no BELIEVE_PCC_PROMOTION_TYPE. */
1773 #endif /* !BELIEVE_PCC_PROMOTION. */
1776 /* acc seems to use P to declare the prototypes of functions that
1777 are referenced by this file. gdb is not prepared to deal
1778 with this extra information. FIXME, it ought to. */
1781 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1782 goto process_prototype_types
;
1787 /* Parameter which is in a register. */
1788 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1789 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
1790 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (valu
);
1791 if (SYMBOL_VALUE (sym
) >= NUM_REGS
)
1793 complain (®_value_complaint
, SYMBOL_VALUE (sym
), NUM_REGS
,
1794 SYMBOL_SOURCE_NAME (sym
));
1795 SYMBOL_VALUE (sym
) = SP_REGNUM
; /* Known safe, though useless */
1797 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1798 add_symbol_to_list (sym
, &local_symbols
);
1802 /* Register variable (either global or local). */
1803 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1804 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
1805 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (valu
);
1806 if (SYMBOL_VALUE (sym
) >= NUM_REGS
)
1808 complain (®_value_complaint
, SYMBOL_VALUE (sym
), NUM_REGS
,
1809 SYMBOL_SOURCE_NAME (sym
));
1810 SYMBOL_VALUE (sym
) = SP_REGNUM
; /* Known safe, though useless */
1812 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1813 if (within_function
)
1815 /* Sun cc uses a pair of symbols, one 'p' and one 'r' with the same
1816 name to represent an argument passed in a register.
1817 GCC uses 'P' for the same case. So if we find such a symbol pair
1818 we combine it into one 'P' symbol. For Sun cc we need to do this
1819 regardless of REG_STRUCT_HAS_ADDR, because the compiler puts out
1820 the 'p' symbol even if it never saves the argument onto the stack.
1822 On most machines, we want to preserve both symbols, so that
1823 we can still get information about what is going on with the
1824 stack (VAX for computing args_printed, using stack slots instead
1825 of saved registers in backtraces, etc.).
1827 Note that this code illegally combines
1828 main(argc) struct foo argc; { register struct foo argc; }
1829 but this case is considered pathological and causes a warning
1830 from a decent compiler. */
1833 && local_symbols
->nsyms
> 0
1834 #ifndef USE_REGISTER_NOT_ARG
1835 && REG_STRUCT_HAS_ADDR (processing_gcc_compilation
,
1837 && (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
1838 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_UNION
1839 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_SET
1840 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_BITSTRING
)
1844 struct symbol
*prev_sym
;
1845 prev_sym
= local_symbols
->symbol
[local_symbols
->nsyms
- 1];
1846 if ((SYMBOL_CLASS (prev_sym
) == LOC_REF_ARG
1847 || SYMBOL_CLASS (prev_sym
) == LOC_ARG
)
1848 && STREQ (SYMBOL_NAME (prev_sym
), SYMBOL_NAME(sym
)))
1850 SYMBOL_CLASS (prev_sym
) = LOC_REGPARM
;
1851 /* Use the type from the LOC_REGISTER; that is the type
1852 that is actually in that register. */
1853 SYMBOL_TYPE (prev_sym
) = SYMBOL_TYPE (sym
);
1854 SYMBOL_VALUE (prev_sym
) = SYMBOL_VALUE (sym
);
1859 add_symbol_to_list (sym
, &local_symbols
);
1862 add_symbol_to_list (sym
, &file_symbols
);
1866 /* Static symbol at top level of file */
1867 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1868 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1869 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
1870 #ifdef STATIC_TRANSFORM_NAME
1871 if (SYMBOL_NAME (sym
)[0] == '$')
1873 struct minimal_symbol
*msym
;
1874 msym
= lookup_minimal_symbol (SYMBOL_NAME (sym
), NULL
, objfile
);
1877 SYMBOL_NAME (sym
) = STATIC_TRANSFORM_NAME (SYMBOL_NAME (sym
));
1878 SYMBOL_VALUE_ADDRESS (sym
) = SYMBOL_VALUE_ADDRESS (msym
);
1882 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1883 add_symbol_to_list (sym
, &file_symbols
);
1887 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1889 /* For a nameless type, we don't want a create a symbol, thus we
1890 did not use `sym'. Return without further processing. */
1891 if (nameless
) return NULL
;
1893 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1894 SYMBOL_VALUE (sym
) = valu
;
1895 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1896 /* C++ vagaries: we may have a type which is derived from
1897 a base type which did not have its name defined when the
1898 derived class was output. We fill in the derived class's
1899 base part member's name here in that case. */
1900 if (TYPE_NAME (SYMBOL_TYPE (sym
)) != NULL
)
1901 if ((TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
1902 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_UNION
)
1903 && TYPE_N_BASECLASSES (SYMBOL_TYPE (sym
)))
1906 for (j
= TYPE_N_BASECLASSES (SYMBOL_TYPE (sym
)) - 1; j
>= 0; j
--)
1907 if (TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym
), j
) == 0)
1908 TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym
), j
) =
1909 type_name_no_tag (TYPE_BASECLASS (SYMBOL_TYPE (sym
), j
));
1912 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == NULL
)
1914 /* gcc-2.6 or later (when using -fvtable-thunks)
1915 emits a unique named type for a vtable entry.
1916 Some gdb code depends on that specific name. */
1917 extern const char vtbl_ptr_name
[];
1919 if ((TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_PTR
1920 && strcmp (SYMBOL_NAME (sym
), vtbl_ptr_name
))
1921 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FUNC
)
1923 /* If we are giving a name to a type such as "pointer to
1924 foo" or "function returning foo", we better not set
1925 the TYPE_NAME. If the program contains "typedef char
1926 *caddr_t;", we don't want all variables of type char
1927 * to print as caddr_t. This is not just a
1928 consequence of GDB's type management; PCC and GCC (at
1929 least through version 2.4) both output variables of
1930 either type char * or caddr_t with the type number
1931 defined in the 't' symbol for caddr_t. If a future
1932 compiler cleans this up it GDB is not ready for it
1933 yet, but if it becomes ready we somehow need to
1934 disable this check (without breaking the PCC/GCC2.4
1939 Fortunately, this check seems not to be necessary
1940 for anything except pointers or functions. */
1943 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_NAME (sym
);
1946 add_symbol_to_list (sym
, &file_symbols
);
1950 /* Struct, union, or enum tag. For GNU C++, this can be be followed
1951 by 't' which means we are typedef'ing it as well. */
1952 synonym
= *p
== 't';
1956 /* The semantics of C++ state that "struct foo { ... }" also defines
1957 a typedef for "foo". Unfortunately, cfront never makes the typedef
1958 when translating C++ into C. We make the typedef here so that
1959 "ptype foo" works as expected for cfront translated code. */
1960 else if (current_subfile
->language
== language_cplus
)
1963 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1965 /* For a nameless type, we don't want a create a symbol, thus we
1966 did not use `sym'. Return without further processing. */
1967 if (nameless
) return NULL
;
1969 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1970 SYMBOL_VALUE (sym
) = valu
;
1971 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
1972 if (TYPE_TAG_NAME (SYMBOL_TYPE (sym
)) == 0)
1973 TYPE_TAG_NAME (SYMBOL_TYPE (sym
))
1974 = obconcat (&objfile
-> type_obstack
, "", "", SYMBOL_NAME (sym
));
1975 add_symbol_to_list (sym
, &file_symbols
);
1979 /* Clone the sym and then modify it. */
1980 register struct symbol
*typedef_sym
= (struct symbol
*)
1981 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
1982 *typedef_sym
= *sym
;
1983 SYMBOL_CLASS (typedef_sym
) = LOC_TYPEDEF
;
1984 SYMBOL_VALUE (typedef_sym
) = valu
;
1985 SYMBOL_NAMESPACE (typedef_sym
) = VAR_NAMESPACE
;
1986 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
1987 TYPE_NAME (SYMBOL_TYPE (sym
))
1988 = obconcat (&objfile
-> type_obstack
, "", "", SYMBOL_NAME (sym
));
1989 add_symbol_to_list (typedef_sym
, &file_symbols
);
1994 /* Static symbol of local scope */
1995 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1996 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1997 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
1998 #ifdef STATIC_TRANSFORM_NAME
1999 if (SYMBOL_NAME (sym
)[0] == '$')
2001 struct minimal_symbol
*msym
;
2002 msym
= lookup_minimal_symbol (SYMBOL_NAME (sym
), NULL
, objfile
);
2005 SYMBOL_NAME (sym
) = STATIC_TRANSFORM_NAME (SYMBOL_NAME (sym
));
2006 SYMBOL_VALUE_ADDRESS (sym
) = SYMBOL_VALUE_ADDRESS (msym
);
2010 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2012 add_symbol_to_list (sym
, &global_symbols
);
2014 add_symbol_to_list (sym
, &local_symbols
);
2018 /* Reference parameter */
2019 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
2020 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
2021 SYMBOL_VALUE (sym
) = valu
;
2022 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2023 add_symbol_to_list (sym
, &local_symbols
);
2027 /* Reference parameter which is in a register. */
2028 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
2029 SYMBOL_CLASS (sym
) = LOC_REGPARM_ADDR
;
2030 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (valu
);
2031 if (SYMBOL_VALUE (sym
) >= NUM_REGS
)
2033 complain (®_value_complaint
, SYMBOL_VALUE (sym
), NUM_REGS
,
2034 SYMBOL_SOURCE_NAME (sym
));
2035 SYMBOL_VALUE (sym
) = SP_REGNUM
; /* Known safe, though useless */
2037 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2038 add_symbol_to_list (sym
, &local_symbols
);
2042 /* This is used by Sun FORTRAN for "function result value".
2043 Sun claims ("dbx and dbxtool interfaces", 2nd ed)
2044 that Pascal uses it too, but when I tried it Pascal used
2045 "x:3" (local symbol) instead. */
2046 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
2047 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
2048 SYMBOL_VALUE (sym
) = valu
;
2049 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2050 add_symbol_to_list (sym
, &local_symbols
);
2053 /* New code added to support cfront stabs strings.
2054 Note: case 'P' already handled above */
2056 /* Cfront type continuation coming up!
2057 Find the original definition and add to it.
2058 We'll have to do this for the typedef too,
2059 since we cloned the symbol to define a type in read_type.
2060 Stabs info examples:
2062 foo__1CFv :ZtF (first def foo__1CFv:F(0,3);(0,24))
2063 C:ZsC;;__ct__1CFv func1__1CFv func2__1CFv ... ;;;
2064 where C is the name of the class.
2065 Unfortunately, we can't lookup the original symbol yet 'cuz
2066 we haven't finished reading all the symbols.
2067 Instead, we save it for processing later */
2068 process_later (sym
, p
, resolve_cfront_continuation
);
2069 SYMBOL_TYPE (sym
) = error_type (&p
, objfile
); /* FIXME! change later */
2070 SYMBOL_CLASS (sym
) = LOC_CONST
;
2071 SYMBOL_VALUE (sym
) = 0;
2072 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2073 /* Don't add to list - we'll delete it later when
2074 we add the continuation to the real sym */
2076 /* End of new code added to support cfront stabs strings */
2079 SYMBOL_TYPE (sym
) = error_type (&p
, objfile
);
2080 SYMBOL_CLASS (sym
) = LOC_CONST
;
2081 SYMBOL_VALUE (sym
) = 0;
2082 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2083 add_symbol_to_list (sym
, &file_symbols
);
2087 /* When passing structures to a function, some systems sometimes pass
2088 the address in a register, not the structure itself. */
2090 if (REG_STRUCT_HAS_ADDR (processing_gcc_compilation
, SYMBOL_TYPE (sym
))
2091 && (SYMBOL_CLASS (sym
) == LOC_REGPARM
|| SYMBOL_CLASS (sym
) == LOC_ARG
))
2093 struct type
*symbol_type
= check_typedef (SYMBOL_TYPE (sym
));
2095 if ((TYPE_CODE (symbol_type
) == TYPE_CODE_STRUCT
)
2096 || (TYPE_CODE (symbol_type
) == TYPE_CODE_UNION
)
2097 || (TYPE_CODE (symbol_type
) == TYPE_CODE_BITSTRING
)
2098 || (TYPE_CODE (symbol_type
) == TYPE_CODE_SET
))
2100 /* If REG_STRUCT_HAS_ADDR yields non-zero we have to convert
2101 LOC_REGPARM to LOC_REGPARM_ADDR for structures and unions. */
2102 if (SYMBOL_CLASS (sym
) == LOC_REGPARM
)
2103 SYMBOL_CLASS (sym
) = LOC_REGPARM_ADDR
;
2104 /* Likewise for converting LOC_ARG to LOC_REF_ARG (for the 7th
2105 and subsequent arguments on the sparc, for example). */
2106 else if (SYMBOL_CLASS (sym
) == LOC_ARG
)
2107 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
2111 /* Is there more to parse? eg. ";l(#1,#2);l(#3,#5)" */
2112 while (*p
&& (*p
== ';' || *p
== ','))
2115 if (*p
&& *p
== 'l')
2117 /* GNU extensions for live range splitting may be appended to
2118 the end of the stab string. eg. "l(#1,#2);l(#3,#5)" */
2120 /* Fix up ranges later. */
2121 process_later (sym
, p
, resolve_live_range
);
2123 /* Find end of live range info. */
2124 p
= strchr (p
, ')');
2125 if (!*p
|| *p
!= ')')
2126 error ("Internal error: live range format not recognized.\n");
2134 /* Add live range information to symbol. (eg. p is l(#1,#2)...) */
2136 resolve_live_range (objfile
, sym
, p
)
2137 struct objfile
* objfile
;
2143 CORE_ADDR start
, end
;
2145 if (!*p
|| *p
!= 'l')
2146 error ("Internal error: live range string.\n");
2149 if (!*p
|| *p
!= '(')
2150 error ("Internal error: live range string.\n");
2153 /* Get starting value of range symbol reference. eg. "#1,#2),l(#3,#5)"
2154 and advance p past the refid. */
2155 refnum
= process_reference (&p
);
2156 start
= ref_search_value (refnum
);
2158 error ("Internal error: live range symbol not found.\n");
2160 if (!*p
|| *p
!= ',')
2161 error ("Internal error: live range string.\n");
2164 /* Get ending value of range symbol reference. eg. "#2),l(#3,#5)" */
2165 refnum
= process_reference (&p
);
2166 end
= ref_search_value (refnum
);
2168 error ("Internal error: live range symbol not found.\n");
2170 add_live_range (objfile
, sym
, start
, end
);
2172 if (!*p
|| *p
!= ')')
2173 error ("Internal error: live range string.\n");
2179 add_live_range (objfile
, sym
, start
, end
)
2180 struct objfile
*objfile
;
2182 CORE_ADDR start
, end
;
2184 struct live_range
*r
, *rs
;
2187 error ("Internal error: end of live range follows start.\n");
2189 /* Alloc new live range structure. */
2190 r
= (struct live_range
*)
2191 obstack_alloc (&objfile
->type_obstack
,
2192 sizeof (struct live_range
));
2197 /* Append this range to the symbol's range list. */
2198 if (!SYMBOL_RANGE (sym
))
2200 SYMBOL_RANGE (sym
) = r
;
2204 /* Get the last range for the symbol. */
2205 for (rs
= SYMBOL_RANGE (sym
); rs
->next
; rs
= rs
->next
)
2211 /* Given addr, Search thu alias list to find the one active. */
2213 ref_search_val (sym
, addr
)
2217 struct live_range
*r
;
2221 if (!SYMBOL_RANGE (sym
))
2223 for (r
= SYMBOL_RANGE (sym
); r
; r
= r
->next
)
2225 if (r
->start
<= addr
2229 sym
= SYMBOL_ALIASES (sym
);
2235 /* Skip rest of this symbol and return an error type.
2237 General notes on error recovery: error_type always skips to the
2238 end of the symbol (modulo cretinous dbx symbol name continuation).
2239 Thus code like this:
2241 if (*(*pp)++ != ';')
2242 return error_type (pp, objfile);
2244 is wrong because if *pp starts out pointing at '\0' (typically as the
2245 result of an earlier error), it will be incremented to point to the
2246 start of the next symbol, which might produce strange results, at least
2247 if you run off the end of the string table. Instead use
2250 return error_type (pp, objfile);
2256 foo = error_type (pp, objfile);
2260 And in case it isn't obvious, the point of all this hair is so the compiler
2261 can define new types and new syntaxes, and old versions of the
2262 debugger will be able to read the new symbol tables. */
2264 static struct type
*
2265 error_type (pp
, objfile
)
2267 struct objfile
*objfile
;
2269 complain (&error_type_complaint
);
2272 /* Skip to end of symbol. */
2273 while (**pp
!= '\0')
2278 /* Check for and handle cretinous dbx symbol name continuation! */
2279 if ((*pp
)[-1] == '\\' || (*pp
)[-1] == '?')
2281 *pp
= next_symbol_text (objfile
);
2288 return (builtin_type_error
);
2292 /* Read type information or a type definition; return the type. Even
2293 though this routine accepts either type information or a type
2294 definition, the distinction is relevant--some parts of stabsread.c
2295 assume that type information starts with a digit, '-', or '(' in
2296 deciding whether to call read_type. */
2299 read_type (pp
, objfile
)
2301 struct objfile
*objfile
;
2303 register struct type
*type
= 0;
2306 char type_descriptor
;
2308 /* Size in bits of type if specified by a type attribute, or -1 if
2309 there is no size attribute. */
2312 /* Used to distinguish string and bitstring from char-array and set. */
2315 /* Read type number if present. The type number may be omitted.
2316 for instance in a two-dimensional array declared with type
2317 "ar1;1;10;ar1;1;10;4". */
2318 if ((**pp
>= '0' && **pp
<= '9')
2322 if (read_type_number (pp
, typenums
) != 0)
2323 return error_type (pp
, objfile
);
2325 /* Type is not being defined here. Either it already exists,
2326 or this is a forward reference to it. dbx_alloc_type handles
2329 return dbx_alloc_type (typenums
, objfile
);
2331 /* Type is being defined here. */
2333 Also skip the type descriptor - we get it below with (*pp)[-1]. */
2338 /* 'typenums=' not present, type is anonymous. Read and return
2339 the definition, but don't put it in the type vector. */
2340 typenums
[0] = typenums
[1] = -1;
2345 type_descriptor
= (*pp
)[-1];
2346 switch (type_descriptor
)
2350 enum type_code code
;
2352 /* Used to index through file_symbols. */
2353 struct pending
*ppt
;
2356 /* Name including "struct", etc. */
2360 char *from
, *to
, *p
, *q1
, *q2
;
2362 /* Set the type code according to the following letter. */
2366 code
= TYPE_CODE_STRUCT
;
2369 code
= TYPE_CODE_UNION
;
2372 code
= TYPE_CODE_ENUM
;
2376 /* Complain and keep going, so compilers can invent new
2377 cross-reference types. */
2378 static struct complaint msg
=
2379 {"Unrecognized cross-reference type `%c'", 0, 0};
2380 complain (&msg
, (*pp
)[0]);
2381 code
= TYPE_CODE_STRUCT
;
2386 q1
= strchr (*pp
, '<');
2387 p
= strchr (*pp
, ':');
2389 return error_type (pp
, objfile
);
2390 if (q1
&& p
> q1
&& p
[1] == ':')
2392 int nesting_level
= 0;
2393 for (q2
= q1
; *q2
; q2
++)
2397 else if (*q2
== '>')
2399 else if (*q2
== ':' && nesting_level
== 0)
2404 return error_type (pp
, objfile
);
2407 (char *)obstack_alloc (&objfile
->type_obstack
, p
- *pp
+ 1);
2409 /* Copy the name. */
2415 /* Set the pointer ahead of the name which we just read, and
2420 /* Now check to see whether the type has already been
2421 declared. This was written for arrays of cross-referenced
2422 types before we had TYPE_CODE_TARGET_STUBBED, so I'm pretty
2423 sure it is not necessary anymore. But it might be a good
2424 idea, to save a little memory. */
2426 for (ppt
= file_symbols
; ppt
; ppt
= ppt
->next
)
2427 for (i
= 0; i
< ppt
->nsyms
; i
++)
2429 struct symbol
*sym
= ppt
->symbol
[i
];
2431 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
2432 && SYMBOL_NAMESPACE (sym
) == STRUCT_NAMESPACE
2433 && (TYPE_CODE (SYMBOL_TYPE (sym
)) == code
)
2434 && STREQ (SYMBOL_NAME (sym
), type_name
))
2436 obstack_free (&objfile
-> type_obstack
, type_name
);
2437 type
= SYMBOL_TYPE (sym
);
2442 /* Didn't find the type to which this refers, so we must
2443 be dealing with a forward reference. Allocate a type
2444 structure for it, and keep track of it so we can
2445 fill in the rest of the fields when we get the full
2447 type
= dbx_alloc_type (typenums
, objfile
);
2448 TYPE_CODE (type
) = code
;
2449 TYPE_TAG_NAME (type
) = type_name
;
2450 INIT_CPLUS_SPECIFIC(type
);
2451 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
2453 add_undefined_type (type
);
2457 case '-': /* RS/6000 built-in type */
2471 /* We deal with something like t(1,2)=(3,4)=... which
2472 the Lucid compiler and recent gcc versions (post 2.7.3) use. */
2474 /* Allocate and enter the typedef type first.
2475 This handles recursive types. */
2476 type
= dbx_alloc_type (typenums
, objfile
);
2477 TYPE_CODE (type
) = TYPE_CODE_TYPEDEF
;
2478 { struct type
*xtype
= read_type (pp
, objfile
);
2481 /* It's being defined as itself. That means it is "void". */
2482 TYPE_CODE (type
) = TYPE_CODE_VOID
;
2483 TYPE_LENGTH (type
) = 1;
2485 else if (type_size
>= 0 || is_string
)
2488 TYPE_NAME (type
) = NULL
;
2489 TYPE_TAG_NAME (type
) = NULL
;
2493 TYPE_FLAGS (type
) |= TYPE_FLAG_TARGET_STUB
;
2494 TYPE_TARGET_TYPE (type
) = xtype
;
2499 /* In the following types, we must be sure to overwrite any existing
2500 type that the typenums refer to, rather than allocating a new one
2501 and making the typenums point to the new one. This is because there
2502 may already be pointers to the existing type (if it had been
2503 forward-referenced), and we must change it to a pointer, function,
2504 reference, or whatever, *in-place*. */
2507 type1
= read_type (pp
, objfile
);
2508 type
= make_pointer_type (type1
, dbx_lookup_type (typenums
));
2511 case '&': /* Reference to another type */
2512 type1
= read_type (pp
, objfile
);
2513 type
= make_reference_type (type1
, dbx_lookup_type (typenums
));
2516 case 'f': /* Function returning another type */
2517 if (os9k_stabs
&& **pp
== '(')
2519 /* Function prototype; parse it.
2520 We must conditionalize this on os9k_stabs because otherwise
2521 it could be confused with a Sun-style (1,3) typenumber
2527 t
= read_type (pp
, objfile
);
2528 if (**pp
== ',') ++*pp
;
2531 type1
= read_type (pp
, objfile
);
2532 type
= make_function_type (type1
, dbx_lookup_type (typenums
));
2535 case 'k': /* Const qualifier on some type (Sun) */
2536 case 'c': /* Const qualifier on some type (OS9000) */
2537 /* Because 'c' means other things to AIX and 'k' is perfectly good,
2538 only accept 'c' in the os9k_stabs case. */
2539 if (type_descriptor
== 'c' && !os9k_stabs
)
2540 return error_type (pp
, objfile
);
2541 type
= read_type (pp
, objfile
);
2542 /* FIXME! For now, we ignore const and volatile qualifiers. */
2545 case 'B': /* Volatile qual on some type (Sun) */
2546 case 'i': /* Volatile qual on some type (OS9000) */
2547 /* Because 'i' means other things to AIX and 'B' is perfectly good,
2548 only accept 'i' in the os9k_stabs case. */
2549 if (type_descriptor
== 'i' && !os9k_stabs
)
2550 return error_type (pp
, objfile
);
2551 type
= read_type (pp
, objfile
);
2552 /* FIXME! For now, we ignore const and volatile qualifiers. */
2556 if (isdigit (**pp
) || **pp
== '(' || **pp
== '-')
2557 { /* Member (class & variable) type */
2558 /* FIXME -- we should be doing smash_to_XXX types here. */
2560 struct type
*domain
= read_type (pp
, objfile
);
2561 struct type
*memtype
;
2564 /* Invalid member type data format. */
2565 return error_type (pp
, objfile
);
2568 memtype
= read_type (pp
, objfile
);
2569 type
= dbx_alloc_type (typenums
, objfile
);
2570 smash_to_member_type (type
, domain
, memtype
);
2572 else /* type attribute */
2575 /* Skip to the semicolon. */
2576 while (**pp
!= ';' && **pp
!= '\0')
2579 return error_type (pp
, objfile
);
2581 ++*pp
; /* Skip the semicolon. */
2586 type_size
= atoi (attr
+ 1);
2596 /* Ignore unrecognized type attributes, so future compilers
2597 can invent new ones. */
2605 case '#': /* Method (class & fn) type */
2606 if ((*pp
)[0] == '#')
2608 /* We'll get the parameter types from the name. */
2609 struct type
*return_type
;
2612 return_type
= read_type (pp
, objfile
);
2613 if (*(*pp
)++ != ';')
2614 complain (&invalid_member_complaint
, symnum
);
2615 type
= allocate_stub_method (return_type
);
2616 if (typenums
[0] != -1)
2617 *dbx_lookup_type (typenums
) = type
;
2621 struct type
*domain
= read_type (pp
, objfile
);
2622 struct type
*return_type
;
2626 /* Invalid member type data format. */
2627 return error_type (pp
, objfile
);
2631 return_type
= read_type (pp
, objfile
);
2632 args
= read_args (pp
, ';', objfile
);
2633 type
= dbx_alloc_type (typenums
, objfile
);
2634 smash_to_method_type (type
, domain
, return_type
, args
);
2638 case 'r': /* Range type */
2639 type
= read_range_type (pp
, typenums
, objfile
);
2640 if (typenums
[0] != -1)
2641 *dbx_lookup_type (typenums
) = type
;
2646 /* Const and volatile qualified type. */
2647 type
= read_type (pp
, objfile
);
2650 /* Sun ACC builtin int type */
2651 type
= read_sun_builtin_type (pp
, typenums
, objfile
);
2652 if (typenums
[0] != -1)
2653 *dbx_lookup_type (typenums
) = type
;
2657 case 'R': /* Sun ACC builtin float type */
2658 type
= read_sun_floating_type (pp
, typenums
, objfile
);
2659 if (typenums
[0] != -1)
2660 *dbx_lookup_type (typenums
) = type
;
2663 case 'e': /* Enumeration type */
2664 type
= dbx_alloc_type (typenums
, objfile
);
2665 type
= read_enum_type (pp
, type
, objfile
);
2666 if (typenums
[0] != -1)
2667 *dbx_lookup_type (typenums
) = type
;
2670 case 's': /* Struct type */
2671 case 'u': /* Union type */
2672 type
= dbx_alloc_type (typenums
, objfile
);
2673 switch (type_descriptor
)
2676 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
2679 TYPE_CODE (type
) = TYPE_CODE_UNION
;
2682 type
= read_struct_type (pp
, type
, objfile
);
2685 case 'a': /* Array type */
2687 return error_type (pp
, objfile
);
2690 type
= dbx_alloc_type (typenums
, objfile
);
2691 type
= read_array_type (pp
, type
, objfile
);
2693 TYPE_CODE (type
) = TYPE_CODE_STRING
;
2697 type1
= read_type (pp
, objfile
);
2698 type
= create_set_type ((struct type
*) NULL
, type1
);
2700 TYPE_CODE (type
) = TYPE_CODE_BITSTRING
;
2701 if (typenums
[0] != -1)
2702 *dbx_lookup_type (typenums
) = type
;
2706 --*pp
; /* Go back to the symbol in error */
2707 /* Particularly important if it was \0! */
2708 return error_type (pp
, objfile
);
2713 warning ("GDB internal error, type is NULL in stabsread.c\n");
2714 return error_type (pp
, objfile
);
2717 /* Size specified in a type attribute overrides any other size. */
2718 if (type_size
!= -1)
2719 TYPE_LENGTH (type
) = (type_size
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
2724 /* RS/6000 xlc/dbx combination uses a set of builtin types, starting from -1.
2725 Return the proper type node for a given builtin type number. */
2727 static struct type
*
2728 rs6000_builtin_type (typenum
)
2731 /* We recognize types numbered from -NUMBER_RECOGNIZED to -1. */
2732 #define NUMBER_RECOGNIZED 34
2733 /* This includes an empty slot for type number -0. */
2734 static struct type
*negative_types
[NUMBER_RECOGNIZED
+ 1];
2735 struct type
*rettype
= NULL
;
2737 if (typenum
>= 0 || typenum
< -NUMBER_RECOGNIZED
)
2739 complain (&rs6000_builtin_complaint
, typenum
);
2740 return builtin_type_error
;
2742 if (negative_types
[-typenum
] != NULL
)
2743 return negative_types
[-typenum
];
2745 #if TARGET_CHAR_BIT != 8
2746 #error This code wrong for TARGET_CHAR_BIT not 8
2747 /* These definitions all assume that TARGET_CHAR_BIT is 8. I think
2748 that if that ever becomes not true, the correct fix will be to
2749 make the size in the struct type to be in bits, not in units of
2756 /* The size of this and all the other types are fixed, defined
2757 by the debugging format. If there is a type called "int" which
2758 is other than 32 bits, then it should use a new negative type
2759 number (or avoid negative type numbers for that case).
2760 See stabs.texinfo. */
2761 rettype
= init_type (TYPE_CODE_INT
, 4, 0, "int", NULL
);
2764 rettype
= init_type (TYPE_CODE_INT
, 1, 0, "char", NULL
);
2767 rettype
= init_type (TYPE_CODE_INT
, 2, 0, "short", NULL
);
2770 rettype
= init_type (TYPE_CODE_INT
, 4, 0, "long", NULL
);
2773 rettype
= init_type (TYPE_CODE_INT
, 1, TYPE_FLAG_UNSIGNED
,
2774 "unsigned char", NULL
);
2777 rettype
= init_type (TYPE_CODE_INT
, 1, 0, "signed char", NULL
);
2780 rettype
= init_type (TYPE_CODE_INT
, 2, TYPE_FLAG_UNSIGNED
,
2781 "unsigned short", NULL
);
2784 rettype
= init_type (TYPE_CODE_INT
, 4, TYPE_FLAG_UNSIGNED
,
2785 "unsigned int", NULL
);
2788 rettype
= init_type (TYPE_CODE_INT
, 4, TYPE_FLAG_UNSIGNED
,
2791 rettype
= init_type (TYPE_CODE_INT
, 4, TYPE_FLAG_UNSIGNED
,
2792 "unsigned long", NULL
);
2795 rettype
= init_type (TYPE_CODE_VOID
, 1, 0, "void", NULL
);
2798 /* IEEE single precision (32 bit). */
2799 rettype
= init_type (TYPE_CODE_FLT
, 4, 0, "float", NULL
);
2802 /* IEEE double precision (64 bit). */
2803 rettype
= init_type (TYPE_CODE_FLT
, 8, 0, "double", NULL
);
2806 /* This is an IEEE double on the RS/6000, and different machines with
2807 different sizes for "long double" should use different negative
2808 type numbers. See stabs.texinfo. */
2809 rettype
= init_type (TYPE_CODE_FLT
, 8, 0, "long double", NULL
);
2812 rettype
= init_type (TYPE_CODE_INT
, 4, 0, "integer", NULL
);
2815 rettype
= init_type (TYPE_CODE_BOOL
, 4, TYPE_FLAG_UNSIGNED
,
2819 rettype
= init_type (TYPE_CODE_FLT
, 4, 0, "short real", NULL
);
2822 rettype
= init_type (TYPE_CODE_FLT
, 8, 0, "real", NULL
);
2825 rettype
= init_type (TYPE_CODE_ERROR
, 0, 0, "stringptr", NULL
);
2828 rettype
= init_type (TYPE_CODE_CHAR
, 1, TYPE_FLAG_UNSIGNED
,
2832 rettype
= init_type (TYPE_CODE_BOOL
, 1, TYPE_FLAG_UNSIGNED
,
2836 rettype
= init_type (TYPE_CODE_BOOL
, 2, TYPE_FLAG_UNSIGNED
,
2840 rettype
= init_type (TYPE_CODE_BOOL
, 4, TYPE_FLAG_UNSIGNED
,
2844 rettype
= init_type (TYPE_CODE_BOOL
, 4, TYPE_FLAG_UNSIGNED
,
2848 /* Complex type consisting of two IEEE single precision values. */
2849 rettype
= init_type (TYPE_CODE_ERROR
, 8, 0, "complex", NULL
);
2852 /* Complex type consisting of two IEEE double precision values. */
2853 rettype
= init_type (TYPE_CODE_ERROR
, 16, 0, "double complex", NULL
);
2856 rettype
= init_type (TYPE_CODE_INT
, 1, 0, "integer*1", NULL
);
2859 rettype
= init_type (TYPE_CODE_INT
, 2, 0, "integer*2", NULL
);
2862 rettype
= init_type (TYPE_CODE_INT
, 4, 0, "integer*4", NULL
);
2865 rettype
= init_type (TYPE_CODE_CHAR
, 2, 0, "wchar", NULL
);
2868 rettype
= init_type (TYPE_CODE_INT
, 8, 0, "long long", NULL
);
2871 rettype
= init_type (TYPE_CODE_INT
, 8, TYPE_FLAG_UNSIGNED
,
2872 "unsigned long long", NULL
);
2875 rettype
= init_type (TYPE_CODE_INT
, 8, TYPE_FLAG_UNSIGNED
,
2879 rettype
= init_type (TYPE_CODE_INT
, 8, 0, "integer*8", NULL
);
2882 negative_types
[-typenum
] = rettype
;
2886 /* This page contains subroutines of read_type. */
2888 /* Read member function stabs info for C++ classes. The form of each member
2891 NAME :: TYPENUM[=type definition] ARGS : PHYSNAME ;
2893 An example with two member functions is:
2895 afunc1::20=##15;:i;2A.;afunc2::20:i;2A.;
2897 For the case of overloaded operators, the format is op$::*.funcs, where
2898 $ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator
2899 name (such as `+=') and `.' marks the end of the operator name.
2901 Returns 1 for success, 0 for failure. */
2904 read_member_functions (fip
, pp
, type
, objfile
)
2905 struct field_info
*fip
;
2908 struct objfile
*objfile
;
2912 /* Total number of member functions defined in this class. If the class
2913 defines two `f' functions, and one `g' function, then this will have
2915 int total_length
= 0;
2919 struct next_fnfield
*next
;
2920 struct fn_field fn_field
;
2922 struct type
*look_ahead_type
;
2923 struct next_fnfieldlist
*new_fnlist
;
2924 struct next_fnfield
*new_sublist
;
2928 /* Process each list until we find something that is not a member function
2929 or find the end of the functions. */
2933 /* We should be positioned at the start of the function name.
2934 Scan forward to find the first ':' and if it is not the
2935 first of a "::" delimiter, then this is not a member function. */
2947 look_ahead_type
= NULL
;
2950 new_fnlist
= (struct next_fnfieldlist
*)
2951 xmalloc (sizeof (struct next_fnfieldlist
));
2952 make_cleanup (free
, new_fnlist
);
2953 memset (new_fnlist
, 0, sizeof (struct next_fnfieldlist
));
2955 if ((*pp
)[0] == 'o' && (*pp
)[1] == 'p' && is_cplus_marker ((*pp
)[2]))
2957 /* This is a completely wierd case. In order to stuff in the
2958 names that might contain colons (the usual name delimiter),
2959 Mike Tiemann defined a different name format which is
2960 signalled if the identifier is "op$". In that case, the
2961 format is "op$::XXXX." where XXXX is the name. This is
2962 used for names like "+" or "=". YUUUUUUUK! FIXME! */
2963 /* This lets the user type "break operator+".
2964 We could just put in "+" as the name, but that wouldn't
2966 static char opname
[32] = {'o', 'p', CPLUS_MARKER
};
2967 char *o
= opname
+ 3;
2969 /* Skip past '::'. */
2972 STABS_CONTINUE (pp
, objfile
);
2978 main_fn_name
= savestring (opname
, o
- opname
);
2984 main_fn_name
= savestring (*pp
, p
- *pp
);
2985 /* Skip past '::'. */
2988 new_fnlist
-> fn_fieldlist
.name
= main_fn_name
;
2993 (struct next_fnfield
*) xmalloc (sizeof (struct next_fnfield
));
2994 make_cleanup (free
, new_sublist
);
2995 memset (new_sublist
, 0, sizeof (struct next_fnfield
));
2997 /* Check for and handle cretinous dbx symbol name continuation! */
2998 if (look_ahead_type
== NULL
)
3001 STABS_CONTINUE (pp
, objfile
);
3003 new_sublist
-> fn_field
.type
= read_type (pp
, objfile
);
3006 /* Invalid symtab info for member function. */
3012 /* g++ version 1 kludge */
3013 new_sublist
-> fn_field
.type
= look_ahead_type
;
3014 look_ahead_type
= NULL
;
3024 /* If this is just a stub, then we don't have the real name here. */
3026 if (TYPE_FLAGS (new_sublist
-> fn_field
.type
) & TYPE_FLAG_STUB
)
3028 if (!TYPE_DOMAIN_TYPE (new_sublist
-> fn_field
.type
))
3029 TYPE_DOMAIN_TYPE (new_sublist
-> fn_field
.type
) = type
;
3030 new_sublist
-> fn_field
.is_stub
= 1;
3032 new_sublist
-> fn_field
.physname
= savestring (*pp
, p
- *pp
);
3035 /* Set this member function's visibility fields. */
3038 case VISIBILITY_PRIVATE
:
3039 new_sublist
-> fn_field
.is_private
= 1;
3041 case VISIBILITY_PROTECTED
:
3042 new_sublist
-> fn_field
.is_protected
= 1;
3046 STABS_CONTINUE (pp
, objfile
);
3049 case 'A': /* Normal functions. */
3050 new_sublist
-> fn_field
.is_const
= 0;
3051 new_sublist
-> fn_field
.is_volatile
= 0;
3054 case 'B': /* `const' member functions. */
3055 new_sublist
-> fn_field
.is_const
= 1;
3056 new_sublist
-> fn_field
.is_volatile
= 0;
3059 case 'C': /* `volatile' member function. */
3060 new_sublist
-> fn_field
.is_const
= 0;
3061 new_sublist
-> fn_field
.is_volatile
= 1;
3064 case 'D': /* `const volatile' member function. */
3065 new_sublist
-> fn_field
.is_const
= 1;
3066 new_sublist
-> fn_field
.is_volatile
= 1;
3069 case '*': /* File compiled with g++ version 1 -- no info */
3074 complain (&const_vol_complaint
, **pp
);
3083 /* virtual member function, followed by index.
3084 The sign bit is set to distinguish pointers-to-methods
3085 from virtual function indicies. Since the array is
3086 in words, the quantity must be shifted left by 1
3087 on 16 bit machine, and by 2 on 32 bit machine, forcing
3088 the sign bit out, and usable as a valid index into
3089 the array. Remove the sign bit here. */
3090 new_sublist
-> fn_field
.voffset
=
3091 (0x7fffffff & read_huge_number (pp
, ';', &nbits
)) + 2;
3095 STABS_CONTINUE (pp
, objfile
);
3096 if (**pp
== ';' || **pp
== '\0')
3098 /* Must be g++ version 1. */
3099 new_sublist
-> fn_field
.fcontext
= 0;
3103 /* Figure out from whence this virtual function came.
3104 It may belong to virtual function table of
3105 one of its baseclasses. */
3106 look_ahead_type
= read_type (pp
, objfile
);
3109 /* g++ version 1 overloaded methods. */
3113 new_sublist
-> fn_field
.fcontext
= look_ahead_type
;
3122 look_ahead_type
= NULL
;
3128 /* static member function. */
3129 new_sublist
-> fn_field
.voffset
= VOFFSET_STATIC
;
3130 if (strncmp (new_sublist
-> fn_field
.physname
,
3131 main_fn_name
, strlen (main_fn_name
)))
3133 new_sublist
-> fn_field
.is_stub
= 1;
3139 complain (&member_fn_complaint
, (*pp
)[-1]);
3140 /* Fall through into normal member function. */
3143 /* normal member function. */
3144 new_sublist
-> fn_field
.voffset
= 0;
3145 new_sublist
-> fn_field
.fcontext
= 0;
3149 new_sublist
-> next
= sublist
;
3150 sublist
= new_sublist
;
3152 STABS_CONTINUE (pp
, objfile
);
3154 while (**pp
!= ';' && **pp
!= '\0');
3158 new_fnlist
-> fn_fieldlist
.fn_fields
= (struct fn_field
*)
3159 obstack_alloc (&objfile
-> type_obstack
,
3160 sizeof (struct fn_field
) * length
);
3161 memset (new_fnlist
-> fn_fieldlist
.fn_fields
, 0,
3162 sizeof (struct fn_field
) * length
);
3163 for (i
= length
; (i
--, sublist
); sublist
= sublist
-> next
)
3165 new_fnlist
-> fn_fieldlist
.fn_fields
[i
] = sublist
-> fn_field
;
3168 new_fnlist
-> fn_fieldlist
.length
= length
;
3169 new_fnlist
-> next
= fip
-> fnlist
;
3170 fip
-> fnlist
= new_fnlist
;
3172 total_length
+= length
;
3173 STABS_CONTINUE (pp
, objfile
);
3178 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3179 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
3180 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * nfn_fields
);
3181 memset (TYPE_FN_FIELDLISTS (type
), 0,
3182 sizeof (struct fn_fieldlist
) * nfn_fields
);
3183 TYPE_NFN_FIELDS (type
) = nfn_fields
;
3184 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
3190 /* Special GNU C++ name.
3192 Returns 1 for success, 0 for failure. "failure" means that we can't
3193 keep parsing and it's time for error_type(). */
3196 read_cpp_abbrev (fip
, pp
, type
, objfile
)
3197 struct field_info
*fip
;
3200 struct objfile
*objfile
;
3205 struct type
*context
;
3215 /* At this point, *pp points to something like "22:23=*22...",
3216 where the type number before the ':' is the "context" and
3217 everything after is a regular type definition. Lookup the
3218 type, find it's name, and construct the field name. */
3220 context
= read_type (pp
, objfile
);
3224 case 'f': /* $vf -- a virtual function table pointer */
3225 fip
->list
->field
.name
=
3226 obconcat (&objfile
->type_obstack
, vptr_name
, "", "");
3229 case 'b': /* $vb -- a virtual bsomethingorother */
3230 name
= type_name_no_tag (context
);
3233 complain (&invalid_cpp_type_complaint
, symnum
);
3236 fip
->list
->field
.name
=
3237 obconcat (&objfile
->type_obstack
, vb_name
, name
, "");
3241 complain (&invalid_cpp_abbrev_complaint
, *pp
);
3242 fip
->list
->field
.name
=
3243 obconcat (&objfile
->type_obstack
,
3244 "INVALID_CPLUSPLUS_ABBREV", "", "");
3248 /* At this point, *pp points to the ':'. Skip it and read the
3254 complain (&invalid_cpp_abbrev_complaint
, *pp
);
3257 fip
->list
->field
.type
= read_type (pp
, objfile
);
3259 (*pp
)++; /* Skip the comma. */
3265 FIELD_BITPOS (fip
->list
->field
) = read_huge_number (pp
, ';', &nbits
);
3269 /* This field is unpacked. */
3270 FIELD_BITSIZE (fip
->list
->field
) = 0;
3271 fip
->list
->visibility
= VISIBILITY_PRIVATE
;
3275 complain (&invalid_cpp_abbrev_complaint
, *pp
);
3276 /* We have no idea what syntax an unrecognized abbrev would have, so
3277 better return 0. If we returned 1, we would need to at least advance
3278 *pp to avoid an infinite loop. */
3285 read_one_struct_field (fip
, pp
, p
, type
, objfile
)
3286 struct field_info
*fip
;
3290 struct objfile
*objfile
;
3292 /* The following is code to work around cfront generated stabs.
3293 The stabs contains full mangled name for each field.
3294 We try to demangle the name and extract the field name out of it.
3296 if (ARM_DEMANGLING
&& current_subfile
->language
== language_cplus
)
3302 dem
= cplus_demangle (*pp
, DMGL_ANSI
| DMGL_PARAMS
);
3305 dem_p
= strrchr (dem
, ':');
3306 if (dem_p
!= 0 && *(dem_p
-1)==':')
3308 FIELD_NAME (fip
->list
->field
) =
3309 obsavestring (dem_p
, strlen (dem_p
), &objfile
-> type_obstack
);
3313 FIELD_NAME (fip
->list
->field
) =
3314 obsavestring (*pp
, p
- *pp
, &objfile
-> type_obstack
);
3318 /* end of code for cfront work around */
3321 fip
-> list
-> field
.name
=
3322 obsavestring (*pp
, p
- *pp
, &objfile
-> type_obstack
);
3325 /* This means we have a visibility for a field coming. */
3329 fip
-> list
-> visibility
= *(*pp
)++;
3333 /* normal dbx-style format, no explicit visibility */
3334 fip
-> list
-> visibility
= VISIBILITY_PUBLIC
;
3337 fip
-> list
-> field
.type
= read_type (pp
, objfile
);
3342 /* Possible future hook for nested types. */
3345 fip
-> list
-> field
.bitpos
= (long)-2; /* nested type */
3354 /* Static class member. */
3355 SET_FIELD_PHYSNAME (fip
->list
->field
, savestring (*pp
, p
- *pp
));
3359 else if (**pp
!= ',')
3361 /* Bad structure-type format. */
3362 complain (&stabs_general_complaint
, "bad structure-type format");
3366 (*pp
)++; /* Skip the comma. */
3370 FIELD_BITPOS (fip
->list
->field
) = read_huge_number (pp
, ',', &nbits
);
3373 complain (&stabs_general_complaint
, "bad structure-type format");
3376 FIELD_BITSIZE (fip
->list
->field
) = read_huge_number (pp
, ';', &nbits
);
3379 complain (&stabs_general_complaint
, "bad structure-type format");
3384 if (FIELD_BITPOS (fip
->list
->field
) == 0
3385 && FIELD_BITSIZE (fip
->list
->field
) == 0)
3387 /* This can happen in two cases: (1) at least for gcc 2.4.5 or so,
3388 it is a field which has been optimized out. The correct stab for
3389 this case is to use VISIBILITY_IGNORE, but that is a recent
3390 invention. (2) It is a 0-size array. For example
3391 union { int num; char str[0]; } foo. Printing "<no value>" for
3392 str in "p foo" is OK, since foo.str (and thus foo.str[3])
3393 will continue to work, and a 0-size array as a whole doesn't
3394 have any contents to print.
3396 I suspect this probably could also happen with gcc -gstabs (not
3397 -gstabs+) for static fields, and perhaps other C++ extensions.
3398 Hopefully few people use -gstabs with gdb, since it is intended
3399 for dbx compatibility. */
3401 /* Ignore this field. */
3402 fip
-> list
-> visibility
= VISIBILITY_IGNORE
;
3406 /* Detect an unpacked field and mark it as such.
3407 dbx gives a bit size for all fields.
3408 Note that forward refs cannot be packed,
3409 and treat enums as if they had the width of ints. */
3411 if (TYPE_CODE (FIELD_TYPE (fip
->list
->field
)) != TYPE_CODE_INT
3412 && TYPE_CODE (FIELD_TYPE (fip
->list
->field
)) != TYPE_CODE_BOOL
3413 && TYPE_CODE (FIELD_TYPE (fip
->list
->field
)) != TYPE_CODE_ENUM
)
3415 FIELD_BITSIZE (fip
->list
->field
) = 0;
3417 if ((FIELD_BITSIZE (fip
->list
->field
)
3418 == TARGET_CHAR_BIT
* TYPE_LENGTH (FIELD_TYPE (fip
->list
->field
))
3419 || (TYPE_CODE (FIELD_TYPE (fip
->list
->field
)) == TYPE_CODE_ENUM
3420 && FIELD_BITSIZE (fip
->list
->field
) == TARGET_INT_BIT
)
3423 FIELD_BITPOS (fip
->list
->field
) % 8 == 0)
3425 FIELD_BITSIZE (fip
->list
->field
) = 0;
3431 /* Read struct or class data fields. They have the form:
3433 NAME : [VISIBILITY] TYPENUM , BITPOS , BITSIZE ;
3435 At the end, we see a semicolon instead of a field.
3437 In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
3440 The optional VISIBILITY is one of:
3442 '/0' (VISIBILITY_PRIVATE)
3443 '/1' (VISIBILITY_PROTECTED)
3444 '/2' (VISIBILITY_PUBLIC)
3445 '/9' (VISIBILITY_IGNORE)
3447 or nothing, for C style fields with public visibility.
3449 Returns 1 for success, 0 for failure. */
3452 read_struct_fields (fip
, pp
, type
, objfile
)
3453 struct field_info
*fip
;
3456 struct objfile
*objfile
;
3459 struct nextfield
*new;
3461 /* We better set p right now, in case there are no fields at all... */
3465 /* Read each data member type until we find the terminating ';' at the end of
3466 the data member list, or break for some other reason such as finding the
3467 start of the member function list. */
3471 if (os9k_stabs
&& **pp
== ',') break;
3472 STABS_CONTINUE (pp
, objfile
);
3473 /* Get space to record the next field's data. */
3474 new = (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
3475 make_cleanup (free
, new);
3476 memset (new, 0, sizeof (struct nextfield
));
3477 new -> next
= fip
-> list
;
3480 /* Get the field name. */
3483 /* If is starts with CPLUS_MARKER it is a special abbreviation,
3484 unless the CPLUS_MARKER is followed by an underscore, in
3485 which case it is just the name of an anonymous type, which we
3486 should handle like any other type name. */
3488 if (is_cplus_marker (p
[0]) && p
[1] != '_')
3490 if (!read_cpp_abbrev (fip
, pp
, type
, objfile
))
3495 /* Look for the ':' that separates the field name from the field
3496 values. Data members are delimited by a single ':', while member
3497 functions are delimited by a pair of ':'s. When we hit the member
3498 functions (if any), terminate scan loop and return. */
3500 while (*p
!= ':' && *p
!= '\0')
3507 /* Check to see if we have hit the member functions yet. */
3512 read_one_struct_field (fip
, pp
, p
, type
, objfile
);
3514 if (p
[0] == ':' && p
[1] == ':')
3516 /* chill the list of fields: the last entry (at the head) is a
3517 partially constructed entry which we now scrub. */
3518 fip
-> list
= fip
-> list
-> next
;
3523 /* The stabs for C++ derived classes contain baseclass information which
3524 is marked by a '!' character after the total size. This function is
3525 called when we encounter the baseclass marker, and slurps up all the
3526 baseclass information.
3528 Immediately following the '!' marker is the number of base classes that
3529 the class is derived from, followed by information for each base class.
3530 For each base class, there are two visibility specifiers, a bit offset
3531 to the base class information within the derived class, a reference to
3532 the type for the base class, and a terminating semicolon.
3534 A typical example, with two base classes, would be "!2,020,19;0264,21;".
3536 Baseclass information marker __________________|| | | | | | |
3537 Number of baseclasses __________________________| | | | | | |
3538 Visibility specifiers (2) ________________________| | | | | |
3539 Offset in bits from start of class _________________| | | | |
3540 Type number for base class ___________________________| | | |
3541 Visibility specifiers (2) _______________________________| | |
3542 Offset in bits from start of class ________________________| |
3543 Type number of base class ____________________________________|
3545 Return 1 for success, 0 for (error-type-inducing) failure. */
3548 read_baseclasses (fip
, pp
, type
, objfile
)
3549 struct field_info
*fip
;
3552 struct objfile
*objfile
;
3555 struct nextfield
*new;
3563 /* Skip the '!' baseclass information marker. */
3567 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3570 TYPE_N_BASECLASSES (type
) = read_huge_number (pp
, ',', &nbits
);
3576 /* Some stupid compilers have trouble with the following, so break
3577 it up into simpler expressions. */
3578 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*)
3579 TYPE_ALLOC (type
, B_BYTES (TYPE_N_BASECLASSES (type
)));
3582 int num_bytes
= B_BYTES (TYPE_N_BASECLASSES (type
));
3585 pointer
= (char *) TYPE_ALLOC (type
, num_bytes
);
3586 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*) pointer
;
3590 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), TYPE_N_BASECLASSES (type
));
3592 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
3594 new = (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
3595 make_cleanup (free
, new);
3596 memset (new, 0, sizeof (struct nextfield
));
3597 new -> next
= fip
-> list
;
3599 FIELD_BITSIZE (new->field
) = 0; /* this should be an unpacked field! */
3601 STABS_CONTINUE (pp
, objfile
);
3605 /* Nothing to do. */
3608 SET_TYPE_FIELD_VIRTUAL (type
, i
);
3611 /* Unknown character. Complain and treat it as non-virtual. */
3613 static struct complaint msg
= {
3614 "Unknown virtual character `%c' for baseclass", 0, 0};
3615 complain (&msg
, **pp
);
3620 new -> visibility
= *(*pp
)++;
3621 switch (new -> visibility
)
3623 case VISIBILITY_PRIVATE
:
3624 case VISIBILITY_PROTECTED
:
3625 case VISIBILITY_PUBLIC
:
3628 /* Bad visibility format. Complain and treat it as
3631 static struct complaint msg
= {
3632 "Unknown visibility `%c' for baseclass", 0, 0};
3633 complain (&msg
, new -> visibility
);
3634 new -> visibility
= VISIBILITY_PUBLIC
;
3641 /* The remaining value is the bit offset of the portion of the object
3642 corresponding to this baseclass. Always zero in the absence of
3643 multiple inheritance. */
3645 FIELD_BITPOS (new->field
) = read_huge_number (pp
, ',', &nbits
);
3650 /* The last piece of baseclass information is the type of the
3651 base class. Read it, and remember it's type name as this
3654 new -> field
.type
= read_type (pp
, objfile
);
3655 new -> field
.name
= type_name_no_tag (new -> field
.type
);
3657 /* skip trailing ';' and bump count of number of fields seen */
3666 /* The tail end of stabs for C++ classes that contain a virtual function
3667 pointer contains a tilde, a %, and a type number.
3668 The type number refers to the base class (possibly this class itself) which
3669 contains the vtable pointer for the current class.
3671 This function is called when we have parsed all the method declarations,
3672 so we can look for the vptr base class info. */
3675 read_tilde_fields (fip
, pp
, type
, objfile
)
3676 struct field_info
*fip
;
3679 struct objfile
*objfile
;
3683 STABS_CONTINUE (pp
, objfile
);
3685 /* If we are positioned at a ';', then skip it. */
3695 if (**pp
== '=' || **pp
== '+' || **pp
== '-')
3697 /* Obsolete flags that used to indicate the presence
3698 of constructors and/or destructors. */
3702 /* Read either a '%' or the final ';'. */
3703 if (*(*pp
)++ == '%')
3705 /* The next number is the type number of the base class
3706 (possibly our own class) which supplies the vtable for
3707 this class. Parse it out, and search that class to find
3708 its vtable pointer, and install those into TYPE_VPTR_BASETYPE
3709 and TYPE_VPTR_FIELDNO. */
3714 t
= read_type (pp
, objfile
);
3716 while (*p
!= '\0' && *p
!= ';')
3722 /* Premature end of symbol. */
3726 TYPE_VPTR_BASETYPE (type
) = t
;
3727 if (type
== t
) /* Our own class provides vtbl ptr */
3729 for (i
= TYPE_NFIELDS (t
) - 1;
3730 i
>= TYPE_N_BASECLASSES (t
);
3733 if (! strncmp (TYPE_FIELD_NAME (t
, i
), vptr_name
,
3734 sizeof (vptr_name
) - 1))
3736 TYPE_VPTR_FIELDNO (type
) = i
;
3740 /* Virtual function table field not found. */
3741 complain (&vtbl_notfound_complaint
, TYPE_NAME (type
));
3746 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
3757 attach_fn_fields_to_type (fip
, type
)
3758 struct field_info
*fip
;
3759 register struct type
*type
;
3763 for (n
= TYPE_NFN_FIELDS (type
);
3764 fip
-> fnlist
!= NULL
;
3765 fip
-> fnlist
= fip
-> fnlist
-> next
)
3767 --n
; /* Circumvent Sun3 compiler bug */
3768 TYPE_FN_FIELDLISTS (type
)[n
] = fip
-> fnlist
-> fn_fieldlist
;
3773 /* read cfront class static data.
3774 pp points to string starting with the list of static data
3775 eg: A:ZcA;1@Bpub v2@Bvirpri;__ct__1AFv func__1AFv *sfunc__1AFv ;as__1A ;;
3778 A:ZcA;;foopri__1AFv foopro__1AFv __ct__1AFv __ct__1AFRC1A foopub__1AFv ;;;
3783 read_cfront_static_fields (fip
, pp
, type
, objfile
)
3784 struct field_info
*fip
;
3787 struct objfile
*objfile
;
3789 struct nextfield
* new;
3792 struct symbol
* ref_static
=0;
3794 if (**pp
==';') /* no static data; return */
3800 /* Process each field in the list until we find the terminating ";" */
3802 /* eg: p = "as__1A ;;;" */
3803 STABS_CONTINUE (pp
, objfile
); /* handle \\ */
3804 while (**pp
!=';' && (sname
= get_substring (pp
, ' '), sname
))
3806 ref_static
= lookup_symbol (sname
, 0, VAR_NAMESPACE
, 0, 0); /*demangled_name*/
3809 static struct complaint msg
= {"\
3810 Unable to find symbol for static data field %s\n",
3812 complain (&msg
, sname
);
3815 stype
= SYMBOL_TYPE(ref_static
);
3817 /* allocate a new fip */
3818 new = (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
3819 make_cleanup (free
, new);
3820 memset (new, 0, sizeof (struct nextfield
));
3821 new -> next
= fip
-> list
;
3824 /* set visibility */
3825 /* FIXME! no way to tell visibility from stabs??? */
3826 new -> visibility
= VISIBILITY_PUBLIC
;
3828 /* set field info into fip */
3829 fip
-> list
-> field
.type
= stype
;
3831 /* set bitpos & bitsize */
3832 SET_FIELD_PHYSNAME (fip
->list
->field
, savestring (sname
, strlen (sname
)));
3834 /* set name field */
3835 /* The following is code to work around cfront generated stabs.
3836 The stabs contains full mangled name for each field.
3837 We try to demangle the name and extract the field name out of it.
3842 dem
= cplus_demangle (sname
, DMGL_ANSI
| DMGL_PARAMS
);
3845 dem_p
= strrchr (dem
, ':');
3846 if (dem_p
!= 0 && *(dem_p
-1)==':')
3848 fip
->list
->field
.name
=
3849 obsavestring (dem_p
, strlen (dem_p
), &objfile
-> type_obstack
);
3853 fip
->list
->field
.name
=
3854 obsavestring (sname
, strlen (sname
), &objfile
-> type_obstack
);
3856 } /* end of code for cfront work around */
3857 } /* loop again for next static field */
3861 /* Copy structure fields to fip so attach_fields_to_type will work.
3862 type has already been created with the initial instance data fields.
3863 Now we want to be able to add the other members to the class,
3864 so we want to add them back to the fip and reattach them again
3865 once we have collected all the class members. */
3868 copy_cfront_struct_fields (fip
, type
, objfile
)
3869 struct field_info
*fip
;
3871 struct objfile
*objfile
;
3873 int nfields
= TYPE_NFIELDS(type
);
3875 struct nextfield
* new;
3877 /* Copy the fields into the list of fips and reset the types
3878 to remove the old fields */
3880 for (i
=0; i
<nfields
; i
++)
3882 /* allocate a new fip */
3883 new = (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
3884 make_cleanup (free
, new);
3885 memset (new, 0, sizeof (struct nextfield
));
3886 new -> next
= fip
-> list
;
3889 /* copy field info into fip */
3890 new -> field
= TYPE_FIELD (type
, i
);
3891 /* set visibility */
3892 if (TYPE_FIELD_PROTECTED (type
, i
))
3893 new -> visibility
= VISIBILITY_PROTECTED
;
3894 else if (TYPE_FIELD_PRIVATE (type
, i
))
3895 new -> visibility
= VISIBILITY_PRIVATE
;
3897 new -> visibility
= VISIBILITY_PUBLIC
;
3899 /* Now delete the fields from the type since we will be
3900 allocing new space once we get the rest of the fields
3901 in attach_fields_to_type.
3902 The pointer TYPE_FIELDS(type) is left dangling but should
3903 be freed later by objstack_free */
3904 TYPE_FIELDS (type
)=0;
3905 TYPE_NFIELDS (type
) = 0;
3910 /* Create the vector of fields, and record how big it is.
3911 We need this info to record proper virtual function table information
3912 for this class's virtual functions. */
3915 attach_fields_to_type (fip
, type
, objfile
)
3916 struct field_info
*fip
;
3917 register struct type
*type
;
3918 struct objfile
*objfile
;
3920 register int nfields
= 0;
3921 register int non_public_fields
= 0;
3922 register struct nextfield
*scan
;
3924 /* Count up the number of fields that we have, as well as taking note of
3925 whether or not there are any non-public fields, which requires us to
3926 allocate and build the private_field_bits and protected_field_bits
3929 for (scan
= fip
-> list
; scan
!= NULL
; scan
= scan
-> next
)
3932 if (scan
-> visibility
!= VISIBILITY_PUBLIC
)
3934 non_public_fields
++;
3938 /* Now we know how many fields there are, and whether or not there are any
3939 non-public fields. Record the field count, allocate space for the
3940 array of fields, and create blank visibility bitfields if necessary. */
3942 TYPE_NFIELDS (type
) = nfields
;
3943 TYPE_FIELDS (type
) = (struct field
*)
3944 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
3945 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
3947 if (non_public_fields
)
3949 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3951 TYPE_FIELD_PRIVATE_BITS (type
) =
3952 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3953 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
3955 TYPE_FIELD_PROTECTED_BITS (type
) =
3956 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3957 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
3959 TYPE_FIELD_IGNORE_BITS (type
) =
3960 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3961 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
3964 /* Copy the saved-up fields into the field vector. Start from the head
3965 of the list, adding to the tail of the field array, so that they end
3966 up in the same order in the array in which they were added to the list. */
3968 while (nfields
-- > 0)
3970 TYPE_FIELD (type
, nfields
) = fip
-> list
-> field
;
3971 switch (fip
-> list
-> visibility
)
3973 case VISIBILITY_PRIVATE
:
3974 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
3977 case VISIBILITY_PROTECTED
:
3978 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
3981 case VISIBILITY_IGNORE
:
3982 SET_TYPE_FIELD_IGNORE (type
, nfields
);
3985 case VISIBILITY_PUBLIC
:
3989 /* Unknown visibility. Complain and treat it as public. */
3991 static struct complaint msg
= {
3992 "Unknown visibility `%c' for field", 0, 0};
3993 complain (&msg
, fip
-> list
-> visibility
);
3997 fip
-> list
= fip
-> list
-> next
;
4002 /* Read the description of a structure (or union type) and return an object
4003 describing the type.
4005 PP points to a character pointer that points to the next unconsumed token
4006 in the the stabs string. For example, given stabs "A:T4=s4a:1,0,32;;",
4007 *PP will point to "4a:1,0,32;;".
4009 TYPE points to an incomplete type that needs to be filled in.
4011 OBJFILE points to the current objfile from which the stabs information is
4012 being read. (Note that it is redundant in that TYPE also contains a pointer
4013 to this same objfile, so it might be a good idea to eliminate it. FIXME).
4016 static struct type
*
4017 read_struct_type (pp
, type
, objfile
)
4020 struct objfile
*objfile
;
4022 struct cleanup
*back_to
;
4023 struct field_info fi
;
4028 back_to
= make_cleanup (null_cleanup
, 0);
4030 INIT_CPLUS_SPECIFIC (type
);
4031 TYPE_FLAGS (type
) &= ~TYPE_FLAG_STUB
;
4033 /* First comes the total size in bytes. */
4037 TYPE_LENGTH (type
) = read_huge_number (pp
, 0, &nbits
);
4039 return error_type (pp
, objfile
);
4042 /* Now read the baseclasses, if any, read the regular C struct or C++
4043 class member fields, attach the fields to the type, read the C++
4044 member functions, attach them to the type, and then read any tilde
4045 field (baseclass specifier for the class holding the main vtable). */
4047 if (!read_baseclasses (&fi
, pp
, type
, objfile
)
4048 || !read_struct_fields (&fi
, pp
, type
, objfile
)
4049 || !attach_fields_to_type (&fi
, type
, objfile
)
4050 || !read_member_functions (&fi
, pp
, type
, objfile
)
4051 || !attach_fn_fields_to_type (&fi
, type
)
4052 || !read_tilde_fields (&fi
, pp
, type
, objfile
))
4054 type
= error_type (pp
, objfile
);
4057 do_cleanups (back_to
);
4061 /* Read a definition of an array type,
4062 and create and return a suitable type object.
4063 Also creates a range type which represents the bounds of that
4066 static struct type
*
4067 read_array_type (pp
, type
, objfile
)
4069 register struct type
*type
;
4070 struct objfile
*objfile
;
4072 struct type
*index_type
, *element_type
, *range_type
;
4077 /* Format of an array type:
4078 "ar<index type>;lower;upper;<array_contents_type>".
4079 OS9000: "arlower,upper;<array_contents_type>".
4081 Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
4082 for these, produce a type like float[][]. */
4085 index_type
= builtin_type_int
;
4088 index_type
= read_type (pp
, objfile
);
4090 /* Improper format of array type decl. */
4091 return error_type (pp
, objfile
);
4095 if (!(**pp
>= '0' && **pp
<= '9') && **pp
!= '-')
4100 lower
= read_huge_number (pp
, os9k_stabs
? ',' : ';', &nbits
);
4102 return error_type (pp
, objfile
);
4104 if (!(**pp
>= '0' && **pp
<= '9') && **pp
!= '-')
4109 upper
= read_huge_number (pp
, ';', &nbits
);
4111 return error_type (pp
, objfile
);
4113 element_type
= read_type (pp
, objfile
);
4122 create_range_type ((struct type
*) NULL
, index_type
, lower
, upper
);
4123 type
= create_array_type (type
, element_type
, range_type
);
4129 /* Read a definition of an enumeration type,
4130 and create and return a suitable type object.
4131 Also defines the symbols that represent the values of the type. */
4133 static struct type
*
4134 read_enum_type (pp
, type
, objfile
)
4136 register struct type
*type
;
4137 struct objfile
*objfile
;
4142 register struct symbol
*sym
;
4144 struct pending
**symlist
;
4145 struct pending
*osyms
, *syms
;
4148 int unsigned_enum
= 1;
4151 /* FIXME! The stabs produced by Sun CC merrily define things that ought
4152 to be file-scope, between N_FN entries, using N_LSYM. What's a mother
4153 to do? For now, force all enum values to file scope. */
4154 if (within_function
)
4155 symlist
= &local_symbols
;
4158 symlist
= &file_symbols
;
4160 o_nsyms
= osyms
? osyms
->nsyms
: 0;
4164 /* Size. Perhaps this does not have to be conditionalized on
4165 os9k_stabs (assuming the name of an enum constant can't start
4167 read_huge_number (pp
, 0, &nbits
);
4169 return error_type (pp
, objfile
);
4172 /* The aix4 compiler emits an extra field before the enum members;
4173 my guess is it's a type of some sort. Just ignore it. */
4176 /* Skip over the type. */
4180 /* Skip over the colon. */
4184 /* Read the value-names and their values.
4185 The input syntax is NAME:VALUE,NAME:VALUE, and so on.
4186 A semicolon or comma instead of a NAME means the end. */
4187 while (**pp
&& **pp
!= ';' && **pp
!= ',')
4189 STABS_CONTINUE (pp
, objfile
);
4191 while (*p
!= ':') p
++;
4192 name
= obsavestring (*pp
, p
- *pp
, &objfile
-> symbol_obstack
);
4194 n
= read_huge_number (pp
, ',', &nbits
);
4196 return error_type (pp
, objfile
);
4198 sym
= (struct symbol
*)
4199 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
4200 memset (sym
, 0, sizeof (struct symbol
));
4201 SYMBOL_NAME (sym
) = name
;
4202 SYMBOL_LANGUAGE (sym
) = current_subfile
-> language
;
4203 SYMBOL_CLASS (sym
) = LOC_CONST
;
4204 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
4205 SYMBOL_VALUE (sym
) = n
;
4208 add_symbol_to_list (sym
, symlist
);
4213 (*pp
)++; /* Skip the semicolon. */
4215 /* Now fill in the fields of the type-structure. */
4217 TYPE_LENGTH (type
) = TARGET_INT_BIT
/ HOST_CHAR_BIT
;
4218 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
4219 TYPE_FLAGS (type
) &= ~TYPE_FLAG_STUB
;
4221 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
4222 TYPE_NFIELDS (type
) = nsyms
;
4223 TYPE_FIELDS (type
) = (struct field
*)
4224 TYPE_ALLOC (type
, sizeof (struct field
) * nsyms
);
4225 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nsyms
);
4227 /* Find the symbols for the values and put them into the type.
4228 The symbols can be found in the symlist that we put them on
4229 to cause them to be defined. osyms contains the old value
4230 of that symlist; everything up to there was defined by us. */
4231 /* Note that we preserve the order of the enum constants, so
4232 that in something like "enum {FOO, LAST_THING=FOO}" we print
4233 FOO, not LAST_THING. */
4235 for (syms
= *symlist
, n
= nsyms
- 1; syms
; syms
= syms
->next
)
4237 int last
= syms
== osyms
? o_nsyms
: 0;
4238 int j
= syms
->nsyms
;
4239 for (; --j
>= last
; --n
)
4241 struct symbol
*xsym
= syms
->symbol
[j
];
4242 SYMBOL_TYPE (xsym
) = type
;
4243 TYPE_FIELD_NAME (type
, n
) = SYMBOL_NAME (xsym
);
4244 TYPE_FIELD_BITPOS (type
, n
) = SYMBOL_VALUE (xsym
);
4245 TYPE_FIELD_BITSIZE (type
, n
) = 0;
4254 /* Sun's ACC uses a somewhat saner method for specifying the builtin
4255 typedefs in every file (for int, long, etc):
4257 type = b <signed> <width>; <offset>; <nbits>
4258 signed = u or s. Possible c in addition to u or s (for char?).
4259 offset = offset from high order bit to start bit of type.
4260 width is # bytes in object of this type, nbits is # bits in type.
4262 The width/offset stuff appears to be for small objects stored in
4263 larger ones (e.g. `shorts' in `int' registers). We ignore it for now,
4266 static struct type
*
4267 read_sun_builtin_type (pp
, typenums
, objfile
)
4270 struct objfile
*objfile
;
4285 return error_type (pp
, objfile
);
4289 /* For some odd reason, all forms of char put a c here. This is strange
4290 because no other type has this honor. We can safely ignore this because
4291 we actually determine 'char'acterness by the number of bits specified in
4297 /* The first number appears to be the number of bytes occupied
4298 by this type, except that unsigned short is 4 instead of 2.
4299 Since this information is redundant with the third number,
4300 we will ignore it. */
4301 read_huge_number (pp
, ';', &nbits
);
4303 return error_type (pp
, objfile
);
4305 /* The second number is always 0, so ignore it too. */
4306 read_huge_number (pp
, ';', &nbits
);
4308 return error_type (pp
, objfile
);
4310 /* The third number is the number of bits for this type. */
4311 type_bits
= read_huge_number (pp
, 0, &nbits
);
4313 return error_type (pp
, objfile
);
4314 /* The type *should* end with a semicolon. If it are embedded
4315 in a larger type the semicolon may be the only way to know where
4316 the type ends. If this type is at the end of the stabstring we
4317 can deal with the omitted semicolon (but we don't have to like
4318 it). Don't bother to complain(), Sun's compiler omits the semicolon
4324 return init_type (TYPE_CODE_VOID
, 1,
4325 signed_type
? 0 : TYPE_FLAG_UNSIGNED
, (char *)NULL
,
4328 return init_type (TYPE_CODE_INT
,
4329 type_bits
/ TARGET_CHAR_BIT
,
4330 signed_type
? 0 : TYPE_FLAG_UNSIGNED
, (char *)NULL
,
4334 static struct type
*
4335 read_sun_floating_type (pp
, typenums
, objfile
)
4338 struct objfile
*objfile
;
4344 /* The first number has more details about the type, for example
4346 details
= read_huge_number (pp
, ';', &nbits
);
4348 return error_type (pp
, objfile
);
4350 /* The second number is the number of bytes occupied by this type */
4351 nbytes
= read_huge_number (pp
, ';', &nbits
);
4353 return error_type (pp
, objfile
);
4355 if (details
== NF_COMPLEX
|| details
== NF_COMPLEX16
4356 || details
== NF_COMPLEX32
)
4357 /* This is a type we can't handle, but we do know the size.
4358 We also will be able to give it a name. */
4359 return init_type (TYPE_CODE_ERROR
, nbytes
, 0, NULL
, objfile
);
4361 return init_type (TYPE_CODE_FLT
, nbytes
, 0, NULL
, objfile
);
4364 /* Read a number from the string pointed to by *PP.
4365 The value of *PP is advanced over the number.
4366 If END is nonzero, the character that ends the
4367 number must match END, or an error happens;
4368 and that character is skipped if it does match.
4369 If END is zero, *PP is left pointing to that character.
4371 If the number fits in a long, set *BITS to 0 and return the value.
4372 If not, set *BITS to be the number of bits in the number and return 0.
4374 If encounter garbage, set *BITS to -1 and return 0. */
4377 read_huge_number (pp
, end
, bits
)
4397 /* Leading zero means octal. GCC uses this to output values larger
4398 than an int (because that would be hard in decimal). */
4406 upper_limit
= ULONG_MAX
/ radix
;
4408 upper_limit
= LONG_MAX
/ radix
;
4410 while ((c
= *p
++) >= '0' && c
< ('0' + radix
))
4412 if (n
<= upper_limit
)
4415 n
+= c
- '0'; /* FIXME this overflows anyway */
4420 /* This depends on large values being output in octal, which is
4427 /* Ignore leading zeroes. */
4431 else if (c
== '2' || c
== '3')
4457 /* Large decimal constants are an error (because it is hard to
4458 count how many bits are in them). */
4464 /* -0x7f is the same as 0x80. So deal with it by adding one to
4465 the number of bits. */
4477 /* It's *BITS which has the interesting information. */
4481 static struct type
*
4482 read_range_type (pp
, typenums
, objfile
)
4485 struct objfile
*objfile
;
4487 char *orig_pp
= *pp
;
4492 struct type
*result_type
;
4493 struct type
*index_type
= NULL
;
4495 /* First comes a type we are a subrange of.
4496 In C it is usually 0, 1 or the type being defined. */
4497 if (read_type_number (pp
, rangenums
) != 0)
4498 return error_type (pp
, objfile
);
4499 self_subrange
= (rangenums
[0] == typenums
[0] &&
4500 rangenums
[1] == typenums
[1]);
4505 index_type
= read_type (pp
, objfile
);
4508 /* A semicolon should now follow; skip it. */
4512 /* The remaining two operands are usually lower and upper bounds
4513 of the range. But in some special cases they mean something else. */
4514 n2
= read_huge_number (pp
, ';', &n2bits
);
4515 n3
= read_huge_number (pp
, ';', &n3bits
);
4517 if (n2bits
== -1 || n3bits
== -1)
4518 return error_type (pp
, objfile
);
4521 goto handle_true_range
;
4523 /* If limits are huge, must be large integral type. */
4524 if (n2bits
!= 0 || n3bits
!= 0)
4526 char got_signed
= 0;
4527 char got_unsigned
= 0;
4528 /* Number of bits in the type. */
4531 /* Range from 0 to <large number> is an unsigned large integral type. */
4532 if ((n2bits
== 0 && n2
== 0) && n3bits
!= 0)
4537 /* Range from <large number> to <large number>-1 is a large signed
4538 integral type. Take care of the case where <large number> doesn't
4539 fit in a long but <large number>-1 does. */
4540 else if ((n2bits
!= 0 && n3bits
!= 0 && n2bits
== n3bits
+ 1)
4541 || (n2bits
!= 0 && n3bits
== 0
4542 && (n2bits
== sizeof (long) * HOST_CHAR_BIT
)
4549 if (got_signed
|| got_unsigned
)
4551 return init_type (TYPE_CODE_INT
, nbits
/ TARGET_CHAR_BIT
,
4552 got_unsigned
? TYPE_FLAG_UNSIGNED
: 0, NULL
,
4556 return error_type (pp
, objfile
);
4559 /* A type defined as a subrange of itself, with bounds both 0, is void. */
4560 if (self_subrange
&& n2
== 0 && n3
== 0)
4561 return init_type (TYPE_CODE_VOID
, 1, 0, NULL
, objfile
);
4563 /* If n3 is zero and n2 is positive, we want a floating type,
4564 and n2 is the width in bytes.
4566 Fortran programs appear to use this for complex types also,
4567 and they give no way to distinguish between double and single-complex!
4569 GDB does not have complex types.
4571 Just return the complex as a float of that size. It won't work right
4572 for the complex values, but at least it makes the file loadable. */
4574 if (n3
== 0 && n2
> 0)
4576 return init_type (TYPE_CODE_FLT
, n2
, 0, NULL
, objfile
);
4579 /* If the upper bound is -1, it must really be an unsigned int. */
4581 else if (n2
== 0 && n3
== -1)
4583 /* It is unsigned int or unsigned long. */
4584 /* GCC 2.3.3 uses this for long long too, but that is just a GDB 3.5
4585 compatibility hack. */
4586 return init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
4587 TYPE_FLAG_UNSIGNED
, NULL
, objfile
);
4590 /* Special case: char is defined (Who knows why) as a subrange of
4591 itself with range 0-127. */
4592 else if (self_subrange
&& n2
== 0 && n3
== 127)
4593 return init_type (TYPE_CODE_INT
, 1, 0, NULL
, objfile
);
4595 else if (current_symbol
&& SYMBOL_LANGUAGE (current_symbol
) == language_chill
4597 goto handle_true_range
;
4599 /* We used to do this only for subrange of self or subrange of int. */
4603 /* n3 actually gives the size. */
4604 return init_type (TYPE_CODE_INT
, - n3
, TYPE_FLAG_UNSIGNED
,
4607 return init_type (TYPE_CODE_INT
, 1, TYPE_FLAG_UNSIGNED
, NULL
, objfile
);
4609 return init_type (TYPE_CODE_INT
, 2, TYPE_FLAG_UNSIGNED
, NULL
, objfile
);
4611 /* -1 is used for the upper bound of (4 byte) "unsigned int" and
4612 "unsigned long", and we already checked for that,
4613 so don't need to test for it here. */
4615 /* I think this is for Convex "long long". Since I don't know whether
4616 Convex sets self_subrange, I also accept that particular size regardless
4617 of self_subrange. */
4618 else if (n3
== 0 && n2
< 0
4620 || n2
== - TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
))
4621 return init_type (TYPE_CODE_INT
, - n2
, 0, NULL
, objfile
);
4622 else if (n2
== -n3
-1)
4625 return init_type (TYPE_CODE_INT
, 1, 0, NULL
, objfile
);
4627 return init_type (TYPE_CODE_INT
, 2, 0, NULL
, objfile
);
4628 if (n3
== 0x7fffffff)
4629 return init_type (TYPE_CODE_INT
, 4, 0, NULL
, objfile
);
4632 /* We have a real range type on our hands. Allocate space and
4633 return a real pointer. */
4637 index_type
= builtin_type_int
;
4639 index_type
= *dbx_lookup_type (rangenums
);
4640 if (index_type
== NULL
)
4642 /* Does this actually ever happen? Is that why we are worrying
4643 about dealing with it rather than just calling error_type? */
4645 static struct type
*range_type_index
;
4647 complain (&range_type_base_complaint
, rangenums
[1]);
4648 if (range_type_index
== NULL
)
4650 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
4651 0, "range type index type", NULL
);
4652 index_type
= range_type_index
;
4655 result_type
= create_range_type ((struct type
*) NULL
, index_type
, n2
, n3
);
4656 return (result_type
);
4659 /* Read in an argument list. This is a list of types, separated by commas
4660 and terminated with END. Return the list of types read in, or (struct type
4661 **)-1 if there is an error. */
4663 static struct type
**
4664 read_args (pp
, end
, objfile
)
4667 struct objfile
*objfile
;
4669 /* FIXME! Remove this arbitrary limit! */
4670 struct type
*types
[1024], **rval
; /* allow for fns of 1023 parameters */
4676 /* Invalid argument list: no ','. */
4677 return (struct type
**)-1;
4679 STABS_CONTINUE (pp
, objfile
);
4680 types
[n
++] = read_type (pp
, objfile
);
4682 (*pp
)++; /* get past `end' (the ':' character) */
4686 rval
= (struct type
**) xmalloc (2 * sizeof (struct type
*));
4688 else if (TYPE_CODE (types
[n
-1]) != TYPE_CODE_VOID
)
4690 rval
= (struct type
**) xmalloc ((n
+ 1) * sizeof (struct type
*));
4691 memset (rval
+ n
, 0, sizeof (struct type
*));
4695 rval
= (struct type
**) xmalloc (n
* sizeof (struct type
*));
4697 memcpy (rval
, types
, n
* sizeof (struct type
*));
4701 /* Common block handling. */
4703 /* List of symbols declared since the last BCOMM. This list is a tail
4704 of local_symbols. When ECOMM is seen, the symbols on the list
4705 are noted so their proper addresses can be filled in later,
4706 using the common block base address gotten from the assembler
4709 static struct pending
*common_block
;
4710 static int common_block_i
;
4712 /* Name of the current common block. We get it from the BCOMM instead of the
4713 ECOMM to match IBM documentation (even though IBM puts the name both places
4714 like everyone else). */
4715 static char *common_block_name
;
4717 /* Process a N_BCOMM symbol. The storage for NAME is not guaranteed
4718 to remain after this function returns. */
4721 common_block_start (name
, objfile
)
4723 struct objfile
*objfile
;
4725 if (common_block_name
!= NULL
)
4727 static struct complaint msg
= {
4728 "Invalid symbol data: common block within common block",
4732 common_block
= local_symbols
;
4733 common_block_i
= local_symbols
? local_symbols
->nsyms
: 0;
4734 common_block_name
= obsavestring (name
, strlen (name
),
4735 &objfile
-> symbol_obstack
);
4738 /* Process a N_ECOMM symbol. */
4741 common_block_end (objfile
)
4742 struct objfile
*objfile
;
4744 /* Symbols declared since the BCOMM are to have the common block
4745 start address added in when we know it. common_block and
4746 common_block_i point to the first symbol after the BCOMM in
4747 the local_symbols list; copy the list and hang it off the
4748 symbol for the common block name for later fixup. */
4751 struct pending
*new = 0;
4752 struct pending
*next
;
4755 if (common_block_name
== NULL
)
4757 static struct complaint msg
= {"ECOMM symbol unmatched by BCOMM", 0, 0};
4762 sym
= (struct symbol
*)
4763 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
4764 memset (sym
, 0, sizeof (struct symbol
));
4765 /* Note: common_block_name already saved on symbol_obstack */
4766 SYMBOL_NAME (sym
) = common_block_name
;
4767 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
4769 /* Now we copy all the symbols which have been defined since the BCOMM. */
4771 /* Copy all the struct pendings before common_block. */
4772 for (next
= local_symbols
;
4773 next
!= NULL
&& next
!= common_block
;
4776 for (j
= 0; j
< next
->nsyms
; j
++)
4777 add_symbol_to_list (next
->symbol
[j
], &new);
4780 /* Copy however much of COMMON_BLOCK we need. If COMMON_BLOCK is
4781 NULL, it means copy all the local symbols (which we already did
4784 if (common_block
!= NULL
)
4785 for (j
= common_block_i
; j
< common_block
->nsyms
; j
++)
4786 add_symbol_to_list (common_block
->symbol
[j
], &new);
4788 SYMBOL_TYPE (sym
) = (struct type
*) new;
4790 /* Should we be putting local_symbols back to what it was?
4793 i
= hashname (SYMBOL_NAME (sym
));
4794 SYMBOL_VALUE_CHAIN (sym
) = global_sym_chain
[i
];
4795 global_sym_chain
[i
] = sym
;
4796 common_block_name
= NULL
;
4799 /* Add a common block's start address to the offset of each symbol
4800 declared to be in it (by being between a BCOMM/ECOMM pair that uses
4801 the common block name). */
4804 fix_common_block (sym
, valu
)
4808 struct pending
*next
= (struct pending
*) SYMBOL_TYPE (sym
);
4809 for ( ; next
; next
= next
->next
)
4812 for (j
= next
->nsyms
- 1; j
>= 0; j
--)
4813 SYMBOL_VALUE_ADDRESS (next
->symbol
[j
]) += valu
;
4819 /* What about types defined as forward references inside of a small lexical
4821 /* Add a type to the list of undefined types to be checked through
4822 once this file has been read in. */
4825 add_undefined_type (type
)
4828 if (undef_types_length
== undef_types_allocated
)
4830 undef_types_allocated
*= 2;
4831 undef_types
= (struct type
**)
4832 xrealloc ((char *) undef_types
,
4833 undef_types_allocated
* sizeof (struct type
*));
4835 undef_types
[undef_types_length
++] = type
;
4838 /* Go through each undefined type, see if it's still undefined, and fix it
4839 up if possible. We have two kinds of undefined types:
4841 TYPE_CODE_ARRAY: Array whose target type wasn't defined yet.
4842 Fix: update array length using the element bounds
4843 and the target type's length.
4844 TYPE_CODE_STRUCT, TYPE_CODE_UNION: Structure whose fields were not
4845 yet defined at the time a pointer to it was made.
4846 Fix: Do a full lookup on the struct/union tag. */
4848 cleanup_undefined_types ()
4852 for (type
= undef_types
; type
< undef_types
+ undef_types_length
; type
++)
4854 switch (TYPE_CODE (*type
))
4857 case TYPE_CODE_STRUCT
:
4858 case TYPE_CODE_UNION
:
4859 case TYPE_CODE_ENUM
:
4861 /* Check if it has been defined since. Need to do this here
4862 as well as in check_typedef to deal with the (legitimate in
4863 C though not C++) case of several types with the same name
4864 in different source files. */
4865 if (TYPE_FLAGS (*type
) & TYPE_FLAG_STUB
)
4867 struct pending
*ppt
;
4869 /* Name of the type, without "struct" or "union" */
4870 char *typename
= TYPE_TAG_NAME (*type
);
4872 if (typename
== NULL
)
4874 static struct complaint msg
= {"need a type name", 0, 0};
4878 for (ppt
= file_symbols
; ppt
; ppt
= ppt
->next
)
4880 for (i
= 0; i
< ppt
->nsyms
; i
++)
4882 struct symbol
*sym
= ppt
->symbol
[i
];
4884 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
4885 && SYMBOL_NAMESPACE (sym
) == STRUCT_NAMESPACE
4886 && (TYPE_CODE (SYMBOL_TYPE (sym
)) ==
4888 && STREQ (SYMBOL_NAME (sym
), typename
))
4890 memcpy (*type
, SYMBOL_TYPE (sym
),
4891 sizeof (struct type
));
4901 static struct complaint msg
= {"\
4902 GDB internal error. cleanup_undefined_types with bad type %d.", 0, 0};
4903 complain (&msg
, TYPE_CODE (*type
));
4909 undef_types_length
= 0;
4912 /* Scan through all of the global symbols defined in the object file,
4913 assigning values to the debugging symbols that need to be assigned
4914 to. Get these symbols from the minimal symbol table. */
4917 scan_file_globals (objfile
)
4918 struct objfile
*objfile
;
4921 struct minimal_symbol
*msymbol
;
4922 struct symbol
*sym
, *prev
, *rsym
;
4923 struct objfile
*resolve_objfile
;
4925 /* SVR4 based linkers copy referenced global symbols from shared
4926 libraries to the main executable.
4927 If we are scanning the symbols for a shared library, try to resolve
4928 them from the minimal symbols of the main executable first. */
4930 if (symfile_objfile
&& objfile
!= symfile_objfile
)
4931 resolve_objfile
= symfile_objfile
;
4933 resolve_objfile
= objfile
;
4937 /* Avoid expensive loop through all minimal symbols if there are
4938 no unresolved symbols. */
4939 for (hash
= 0; hash
< HASHSIZE
; hash
++)
4941 if (global_sym_chain
[hash
])
4944 if (hash
>= HASHSIZE
)
4947 for (msymbol
= resolve_objfile
-> msymbols
;
4948 msymbol
&& SYMBOL_NAME (msymbol
) != NULL
;
4953 /* Skip static symbols. */
4954 switch (MSYMBOL_TYPE (msymbol
))
4966 /* Get the hash index and check all the symbols
4967 under that hash index. */
4969 hash
= hashname (SYMBOL_NAME (msymbol
));
4971 for (sym
= global_sym_chain
[hash
]; sym
;)
4973 if (SYMBOL_NAME (msymbol
)[0] == SYMBOL_NAME (sym
)[0] &&
4974 STREQ(SYMBOL_NAME (msymbol
) + 1, SYMBOL_NAME (sym
) + 1))
4976 /* Splice this symbol out of the hash chain and
4977 assign the value we have to it. */
4980 SYMBOL_VALUE_CHAIN (prev
) = SYMBOL_VALUE_CHAIN (sym
);
4984 global_sym_chain
[hash
] = SYMBOL_VALUE_CHAIN (sym
);
4987 /* Check to see whether we need to fix up a common block. */
4988 /* Note: this code might be executed several times for
4989 the same symbol if there are multiple references. */
4991 /* If symbol has aliases, do minimal symbol fixups for each.
4992 These live aliases/references weren't added to
4993 global_sym_chain hash but may also need to be fixed up. */
4994 /* FIXME: Maybe should have added aliases to the global chain, resolved symbol name, then treated aliases as normal
4995 symbols? Still, we wouldn't want to add_to_list. */
4996 /* Now do the same for each alias of this symbol */
4997 for (rsym
= sym
; rsym
; rsym
= SYMBOL_ALIASES (rsym
))
4999 if (SYMBOL_CLASS (rsym
) == LOC_BLOCK
)
5001 fix_common_block (rsym
, SYMBOL_VALUE_ADDRESS (msymbol
));
5005 SYMBOL_VALUE_ADDRESS (rsym
)
5006 = SYMBOL_VALUE_ADDRESS (msymbol
);
5008 SYMBOL_SECTION (rsym
) = SYMBOL_SECTION (msymbol
);
5013 sym
= SYMBOL_VALUE_CHAIN (prev
);
5017 sym
= global_sym_chain
[hash
];
5023 sym
= SYMBOL_VALUE_CHAIN (sym
);
5027 if (resolve_objfile
== objfile
)
5029 resolve_objfile
= objfile
;
5032 /* Change the storage class of any remaining unresolved globals to
5033 LOC_UNRESOLVED and remove them from the chain. */
5034 for (hash
= 0; hash
< HASHSIZE
; hash
++)
5036 sym
= global_sym_chain
[hash
];
5040 sym
= SYMBOL_VALUE_CHAIN (sym
);
5042 /* Change the symbol address from the misleading chain value
5044 SYMBOL_VALUE_ADDRESS (prev
) = 0;
5046 /* Complain about unresolved common block symbols. */
5047 if (SYMBOL_CLASS (prev
) == LOC_STATIC
)
5048 SYMBOL_CLASS (prev
) = LOC_UNRESOLVED
;
5050 complain (&unresolved_sym_chain_complaint
,
5051 objfile
-> name
, SYMBOL_NAME (prev
));
5054 memset (global_sym_chain
, 0, sizeof (global_sym_chain
));
5057 /* Initialize anything that needs initializing when starting to read
5058 a fresh piece of a symbol file, e.g. reading in the stuff corresponding
5066 /* Initialize anything that needs initializing when a completely new
5067 symbol file is specified (not just adding some symbols from another
5068 file, e.g. a shared library). */
5071 stabsread_new_init ()
5073 /* Empty the hash table of global syms looking for values. */
5074 memset (global_sym_chain
, 0, sizeof (global_sym_chain
));
5077 /* Initialize anything that needs initializing at the same time as
5078 start_symtab() is called. */
5082 global_stabs
= NULL
; /* AIX COFF */
5083 /* Leave FILENUM of 0 free for builtin types and this file's types. */
5084 n_this_object_header_files
= 1;
5085 type_vector_length
= 0;
5086 type_vector
= (struct type
**) 0;
5088 /* FIXME: If common_block_name is not already NULL, we should complain(). */
5089 common_block_name
= NULL
;
5094 /* Call after end_symtab() */
5100 free ((char *) type_vector
);
5103 type_vector_length
= 0;
5104 previous_stab_code
= 0;
5108 finish_global_stabs (objfile
)
5109 struct objfile
*objfile
;
5113 patch_block_stabs (global_symbols
, global_stabs
, objfile
);
5114 free ((PTR
) global_stabs
);
5115 global_stabs
= NULL
;
5119 /* Initializer for this module */
5122 _initialize_stabsread ()
5124 undef_types_allocated
= 20;
5125 undef_types_length
= 0;
5126 undef_types
= (struct type
**)
5127 xmalloc (undef_types_allocated
* sizeof (struct type
*));