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);
1148 /* Structure for storing pointers to reference definitions for fast lookup
1149 during "process_later". */
1150 #define MAX_REFS 100 /* FIXME! Change to use heap. */
1151 static struct ref_map_s
1156 } ref_map
[MAX_REFS
];
1158 /* Initialize our list of references.
1159 This should be called before any symbol table is read.
1160 FIXME: Will reference numbers be unique only to objects? If so, we may
1161 need to add something to disambiguate the refids. Or, it might be OK to
1162 leave as is, as long as we read and process an object's symbol table all
1164 static int ref_count
= 0; /* Ptr to free cell in linked list. */
1169 memset (ref_map
, 0, MAX_REFS
* sizeof (struct ref_map_s
));
1172 /* Create array of pointers mapping refids to symbols and stab strings.
1173 Add pointers to reference definition symbols and/or their values as we
1174 find them, using their reference numbers as our index.
1175 These will be used later when we resolve references. */
1177 ref_add (refnum
, sym
, stabs
, value
)
1185 if (refnum
>= ref_count
)
1186 ref_count
= refnum
+ 1;
1187 if (ref_count
> MAX_REFS
)
1188 error ("no more free slots in chain\n");
1189 ref_map
[refnum
].stabs
= stabs
;
1190 ref_map
[refnum
].sym
= sym
;
1191 ref_map
[refnum
].value
= value
;
1194 /* Return defined sym for the reference "refnum" */
1199 if (refnum
< 0 || refnum
> ref_count
)
1201 return ref_map
[refnum
].sym
;
1204 /* Return value for the reference "refnum" */
1206 ref_search_value (refnum
)
1209 if (refnum
< 0 || refnum
> ref_count
)
1211 return ref_map
[refnum
].value
;
1214 /* Parse reference id and advance string to the next character following
1216 Return the reference number. */
1219 process_reference (string
)
1225 if (**string
!= '#')
1228 /* Read number as reference id. */
1229 p
= *string
+ 1; /* Advance beyond '#' */
1230 while (*p
&& isdigit (*p
))
1232 refnum
= refnum
* 10 + *p
- '0';
1239 /* If string defines a reference, store away a pointer to the reference
1240 definition for fast lookup when we "process_later",
1241 and return the reference number. */
1243 symbol_reference_defined (string
)
1249 refnum
= process_reference (&p
);
1251 /* Defining symbols end in '=' */
1254 /* Symbol is being defined here. */
1261 /* Must be a reference. Either the symbol has already been defined,
1262 or this is a forward reference to it. */
1265 return 0; /* Not defined here */
1271 define_symbol (valu
, string
, desc
, type
, objfile
)
1276 struct objfile
*objfile
;
1278 register struct symbol
*sym
;
1279 char *p
= (char *) strchr (string
, ':');
1284 /* We would like to eliminate nameless symbols, but keep their types.
1285 E.g. stab entry ":t10=*2" should produce a type 10, which is a pointer
1286 to type 2, but, should not create a symbol to address that type. Since
1287 the symbol will be nameless, there is no way any user can refer to it. */
1291 /* Ignore syms with empty names. */
1295 /* Ignore old-style symbols from cc -go */
1302 p
= strchr (p
, ':');
1305 /* If a nameless stab entry, all we need is the type, not the symbol.
1306 e.g. ":t10=*2" or a nameless enum like " :T16=ered:0,green:1,blue:2,;" */
1307 nameless
= (p
== string
|| ((string
[0] == ' ') && (string
[1] == ':')));
1309 current_symbol
= sym
= (struct symbol
*)
1310 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
1311 memset (sym
, 0, sizeof (struct symbol
));
1313 switch (type
& N_TYPE
)
1316 SYMBOL_SECTION(sym
) = SECT_OFF_TEXT
;
1319 SYMBOL_SECTION(sym
) = SECT_OFF_DATA
;
1322 SYMBOL_SECTION(sym
) = SECT_OFF_BSS
;
1326 if (processing_gcc_compilation
)
1328 /* GCC 2.x puts the line number in desc. SunOS apparently puts in the
1329 number of bytes occupied by a type or object, which we ignore. */
1330 SYMBOL_LINE(sym
) = desc
;
1334 SYMBOL_LINE(sym
) = 0; /* unknown */
1337 if (is_cplus_marker (string
[0]))
1339 /* Special GNU C++ names. */
1343 SYMBOL_NAME (sym
) = obsavestring ("this", strlen ("this"),
1344 &objfile
-> symbol_obstack
);
1347 case 'v': /* $vtbl_ptr_type */
1348 /* Was: SYMBOL_NAME (sym) = "vptr"; */
1352 SYMBOL_NAME (sym
) = obsavestring ("eh_throw", strlen ("eh_throw"),
1353 &objfile
-> symbol_obstack
);
1357 /* This was an anonymous type that was never fixed up. */
1360 #ifdef STATIC_TRANSFORM_NAME
1362 /* SunPRO (3.0 at least) static variable encoding. */
1367 complain (&unrecognized_cplus_name_complaint
, string
);
1368 goto normal
; /* Do *something* with it */
1371 else if (string
[0] == '#')
1373 /* Special GNU C extension for referencing symbols. */
1377 /* Initialize symbol references and determine if this is
1378 a definition. If symbol reference is being defined, go
1379 ahead and add it. Otherwise, just return sym. */
1381 if (refnum
= symbol_reference_defined (&s
), refnum
)
1382 ref_add (refnum
, sym
, string
, SYMBOL_VALUE (sym
));
1384 process_later (sym
, string
, resolve_symbol_reference
);
1386 /* s is after refid... advance string there
1387 so that the symbol name will not include the refid. */
1391 SYMBOL_NAME (sym
) = (char *)
1392 obstack_alloc (&objfile
-> symbol_obstack
, nlen
);
1393 strncpy (SYMBOL_NAME (sym
), s
, nlen
);
1394 SYMBOL_NAME (sym
)[nlen
] = '\0';
1395 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
->symbol_obstack
);
1398 /* FIXME! Want SYMBOL_NAME (sym) = 0;
1399 Get error if leave name 0. So give it something. */
1402 SYMBOL_NAME (sym
) = (char *)
1403 obstack_alloc (&objfile
-> symbol_obstack
, nlen
);
1404 strncpy (SYMBOL_NAME (sym
), string
, nlen
);
1405 SYMBOL_NAME (sym
)[nlen
] = '\0';
1406 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
->symbol_obstack
);
1413 SYMBOL_LANGUAGE (sym
) = current_subfile
-> language
;
1414 SYMBOL_NAME (sym
) = (char *)
1415 obstack_alloc (&objfile
-> symbol_obstack
, ((p
- string
) + 1));
1416 /* Open-coded memcpy--saves function call time. */
1417 /* FIXME: Does it really? Try replacing with simple strcpy and
1418 try it on an executable with a large symbol table. */
1419 /* FIXME: considering that gcc can open code memcpy anyway, I
1420 doubt it. xoxorich. */
1422 register char *p1
= string
;
1423 register char *p2
= SYMBOL_NAME (sym
);
1431 /* If this symbol is from a C++ compilation, then attempt to cache the
1432 demangled form for future reference. This is a typical time versus
1433 space tradeoff, that was decided in favor of time because it sped up
1434 C++ symbol lookups by a factor of about 20. */
1436 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
->symbol_obstack
);
1440 /* Determine the type of name being defined. */
1442 /* Getting GDB to correctly skip the symbol on an undefined symbol
1443 descriptor and not ever dump core is a very dodgy proposition if
1444 we do things this way. I say the acorn RISC machine can just
1445 fix their compiler. */
1446 /* The Acorn RISC machine's compiler can put out locals that don't
1447 start with "234=" or "(3,4)=", so assume anything other than the
1448 deftypes we know how to handle is a local. */
1449 if (!strchr ("cfFGpPrStTvVXCR", *p
))
1451 if (isdigit (*p
) || *p
== '(' || *p
== '-')
1460 /* c is a special case, not followed by a type-number.
1461 SYMBOL:c=iVALUE for an integer constant symbol.
1462 SYMBOL:c=rVALUE for a floating constant symbol.
1463 SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
1464 e.g. "b:c=e6,0" for "const b = blob1"
1465 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
1468 SYMBOL_CLASS (sym
) = LOC_CONST
;
1469 SYMBOL_TYPE (sym
) = error_type (&p
, objfile
);
1470 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1471 add_symbol_to_list (sym
, &file_symbols
);
1479 double d
= atof (p
);
1482 /* FIXME-if-picky-about-floating-accuracy: Should be using
1483 target arithmetic to get the value. real.c in GCC
1484 probably has the necessary code. */
1486 /* FIXME: lookup_fundamental_type is a hack. We should be
1487 creating a type especially for the type of float constants.
1488 Problem is, what type should it be?
1490 Also, what should the name of this type be? Should we
1491 be using 'S' constants (see stabs.texinfo) instead? */
1493 SYMBOL_TYPE (sym
) = lookup_fundamental_type (objfile
,
1496 obstack_alloc (&objfile
-> symbol_obstack
,
1497 TYPE_LENGTH (SYMBOL_TYPE (sym
)));
1498 store_floating (dbl_valu
, TYPE_LENGTH (SYMBOL_TYPE (sym
)), d
);
1499 SYMBOL_VALUE_BYTES (sym
) = dbl_valu
;
1500 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
1505 /* Defining integer constants this way is kind of silly,
1506 since 'e' constants allows the compiler to give not
1507 only the value, but the type as well. C has at least
1508 int, long, unsigned int, and long long as constant
1509 types; other languages probably should have at least
1510 unsigned as well as signed constants. */
1512 /* We just need one int constant type for all objfiles.
1513 It doesn't depend on languages or anything (arguably its
1514 name should be a language-specific name for a type of
1515 that size, but I'm inclined to say that if the compiler
1516 wants a nice name for the type, it can use 'e'). */
1517 static struct type
*int_const_type
;
1519 /* Yes, this is as long as a *host* int. That is because we
1521 if (int_const_type
== NULL
)
1523 init_type (TYPE_CODE_INT
,
1524 sizeof (int) * HOST_CHAR_BIT
/ TARGET_CHAR_BIT
, 0,
1526 (struct objfile
*)NULL
);
1527 SYMBOL_TYPE (sym
) = int_const_type
;
1528 SYMBOL_VALUE (sym
) = atoi (p
);
1529 SYMBOL_CLASS (sym
) = LOC_CONST
;
1533 /* SYMBOL:c=eTYPE,INTVALUE for a constant symbol whose value
1534 can be represented as integral.
1535 e.g. "b:c=e6,0" for "const b = blob1"
1536 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
1538 SYMBOL_CLASS (sym
) = LOC_CONST
;
1539 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1543 SYMBOL_TYPE (sym
) = error_type (&p
, objfile
);
1548 /* If the value is too big to fit in an int (perhaps because
1549 it is unsigned), or something like that, we silently get
1550 a bogus value. The type and everything else about it is
1551 correct. Ideally, we should be using whatever we have
1552 available for parsing unsigned and long long values,
1554 SYMBOL_VALUE (sym
) = atoi (p
);
1559 SYMBOL_CLASS (sym
) = LOC_CONST
;
1560 SYMBOL_TYPE (sym
) = error_type (&p
, objfile
);
1563 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1564 add_symbol_to_list (sym
, &file_symbols
);
1568 /* The name of a caught exception. */
1569 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1570 SYMBOL_CLASS (sym
) = LOC_LABEL
;
1571 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1572 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
1573 add_symbol_to_list (sym
, &local_symbols
);
1577 /* A static function definition. */
1578 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1579 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1580 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1581 add_symbol_to_list (sym
, &file_symbols
);
1582 /* fall into process_function_types. */
1584 process_function_types
:
1585 /* Function result types are described as the result type in stabs.
1586 We need to convert this to the function-returning-type-X type
1587 in GDB. E.g. "int" is converted to "function returning int". */
1588 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_FUNC
)
1589 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
1590 /* fall into process_prototype_types */
1592 process_prototype_types
:
1593 /* Sun acc puts declared types of arguments here. We don't care
1594 about their actual types (FIXME -- we should remember the whole
1595 function prototype), but the list may define some new types
1596 that we have to remember, so we must scan it now. */
1599 read_type (&p
, objfile
);
1604 /* A global function definition. */
1605 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1606 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1607 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1608 add_symbol_to_list (sym
, &global_symbols
);
1609 goto process_function_types
;
1612 /* For a class G (global) symbol, it appears that the
1613 value is not correct. It is necessary to search for the
1614 corresponding linker definition to find the value.
1615 These definitions appear at the end of the namelist. */
1616 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1617 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1618 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1619 /* Don't add symbol references to global_sym_chain.
1620 Symbol references don't have valid names and wont't match up with
1621 minimal symbols when the global_sym_chain is relocated.
1622 We'll fixup symbol references when we fixup the defining symbol. */
1623 if (SYMBOL_NAME (sym
) && SYMBOL_NAME (sym
)[0] != '#')
1625 i
= hashname (SYMBOL_NAME (sym
));
1626 SYMBOL_VALUE_CHAIN (sym
) = global_sym_chain
[i
];
1627 global_sym_chain
[i
] = sym
;
1629 add_symbol_to_list (sym
, &global_symbols
);
1632 /* This case is faked by a conditional above,
1633 when there is no code letter in the dbx data.
1634 Dbx data never actually contains 'l'. */
1637 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1638 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
1639 SYMBOL_VALUE (sym
) = valu
;
1640 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1641 add_symbol_to_list (sym
, &local_symbols
);
1646 /* pF is a two-letter code that means a function parameter in Fortran.
1647 The type-number specifies the type of the return value.
1648 Translate it into a pointer-to-function type. */
1652 = lookup_pointer_type
1653 (lookup_function_type (read_type (&p
, objfile
)));
1656 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1658 /* Normally this is a parameter, a LOC_ARG. On the i960, it
1659 can also be a LOC_LOCAL_ARG depending on symbol type. */
1660 #ifndef DBX_PARM_SYMBOL_CLASS
1661 #define DBX_PARM_SYMBOL_CLASS(type) LOC_ARG
1664 SYMBOL_CLASS (sym
) = DBX_PARM_SYMBOL_CLASS (type
);
1665 SYMBOL_VALUE (sym
) = valu
;
1666 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1667 add_symbol_to_list (sym
, &local_symbols
);
1669 if (TARGET_BYTE_ORDER
!= BIG_ENDIAN
)
1671 /* On little-endian machines, this crud is never necessary,
1672 and, if the extra bytes contain garbage, is harmful. */
1676 /* If it's gcc-compiled, if it says `short', believe it. */
1677 if (processing_gcc_compilation
|| BELIEVE_PCC_PROMOTION
)
1680 #if !BELIEVE_PCC_PROMOTION
1682 /* This is the signed type which arguments get promoted to. */
1683 static struct type
*pcc_promotion_type
;
1684 /* This is the unsigned type which arguments get promoted to. */
1685 static struct type
*pcc_unsigned_promotion_type
;
1687 /* Call it "int" because this is mainly C lossage. */
1688 if (pcc_promotion_type
== NULL
)
1689 pcc_promotion_type
=
1690 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
1693 if (pcc_unsigned_promotion_type
== NULL
)
1694 pcc_unsigned_promotion_type
=
1695 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
1696 TYPE_FLAG_UNSIGNED
, "unsigned int", NULL
);
1698 #if defined(BELIEVE_PCC_PROMOTION_TYPE)
1699 /* This macro is defined on machines (e.g. sparc) where
1700 we should believe the type of a PCC 'short' argument,
1701 but shouldn't believe the address (the address is
1702 the address of the corresponding int).
1704 My guess is that this correction, as opposed to changing
1705 the parameter to an 'int' (as done below, for PCC
1706 on most machines), is the right thing to do
1707 on all machines, but I don't want to risk breaking
1708 something that already works. On most PCC machines,
1709 the sparc problem doesn't come up because the calling
1710 function has to zero the top bytes (not knowing whether
1711 the called function wants an int or a short), so there
1712 is little practical difference between an int and a short
1713 (except perhaps what happens when the GDB user types
1714 "print short_arg = 0x10000;").
1716 Hacked for SunOS 4.1 by gnu@cygnus.com. In 4.1, the compiler
1717 actually produces the correct address (we don't need to fix it
1718 up). I made this code adapt so that it will offset the symbol
1719 if it was pointing at an int-aligned location and not
1720 otherwise. This way you can use the same gdb for 4.0.x and
1723 If the parameter is shorter than an int, and is integral
1724 (e.g. char, short, or unsigned equivalent), and is claimed to
1725 be passed on an integer boundary, don't believe it! Offset the
1726 parameter's address to the tail-end of that integer. */
1728 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (pcc_promotion_type
)
1729 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
1730 && 0 == SYMBOL_VALUE (sym
) % TYPE_LENGTH (pcc_promotion_type
))
1732 SYMBOL_VALUE (sym
) += TYPE_LENGTH (pcc_promotion_type
)
1733 - TYPE_LENGTH (SYMBOL_TYPE (sym
));
1737 #else /* no BELIEVE_PCC_PROMOTION_TYPE. */
1739 /* If PCC says a parameter is a short or a char,
1740 it is really an int. */
1741 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (pcc_promotion_type
)
1742 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
)
1745 TYPE_UNSIGNED (SYMBOL_TYPE (sym
))
1746 ? pcc_unsigned_promotion_type
1747 : pcc_promotion_type
;
1751 #endif /* no BELIEVE_PCC_PROMOTION_TYPE. */
1753 #endif /* !BELIEVE_PCC_PROMOTION. */
1756 /* acc seems to use P to declare the prototypes of functions that
1757 are referenced by this file. gdb is not prepared to deal
1758 with this extra information. FIXME, it ought to. */
1761 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1762 goto process_prototype_types
;
1767 /* Parameter which is in a register. */
1768 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1769 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
1770 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (valu
);
1771 if (SYMBOL_VALUE (sym
) >= NUM_REGS
)
1773 complain (®_value_complaint
, SYMBOL_VALUE (sym
), NUM_REGS
,
1774 SYMBOL_SOURCE_NAME (sym
));
1775 SYMBOL_VALUE (sym
) = SP_REGNUM
; /* Known safe, though useless */
1777 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1778 add_symbol_to_list (sym
, &local_symbols
);
1782 /* Register variable (either global or local). */
1783 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1784 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
1785 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (valu
);
1786 if (SYMBOL_VALUE (sym
) >= NUM_REGS
)
1788 complain (®_value_complaint
, SYMBOL_VALUE (sym
), NUM_REGS
,
1789 SYMBOL_SOURCE_NAME (sym
));
1790 SYMBOL_VALUE (sym
) = SP_REGNUM
; /* Known safe, though useless */
1792 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1793 if (within_function
)
1795 /* Sun cc uses a pair of symbols, one 'p' and one 'r' with the same
1796 name to represent an argument passed in a register.
1797 GCC uses 'P' for the same case. So if we find such a symbol pair
1798 we combine it into one 'P' symbol. For Sun cc we need to do this
1799 regardless of REG_STRUCT_HAS_ADDR, because the compiler puts out
1800 the 'p' symbol even if it never saves the argument onto the stack.
1802 On most machines, we want to preserve both symbols, so that
1803 we can still get information about what is going on with the
1804 stack (VAX for computing args_printed, using stack slots instead
1805 of saved registers in backtraces, etc.).
1807 Note that this code illegally combines
1808 main(argc) struct foo argc; { register struct foo argc; }
1809 but this case is considered pathological and causes a warning
1810 from a decent compiler. */
1813 && local_symbols
->nsyms
> 0
1814 #ifndef USE_REGISTER_NOT_ARG
1815 && REG_STRUCT_HAS_ADDR (processing_gcc_compilation
,
1817 && (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
1818 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_UNION
1819 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_SET
1820 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_BITSTRING
)
1824 struct symbol
*prev_sym
;
1825 prev_sym
= local_symbols
->symbol
[local_symbols
->nsyms
- 1];
1826 if ((SYMBOL_CLASS (prev_sym
) == LOC_REF_ARG
1827 || SYMBOL_CLASS (prev_sym
) == LOC_ARG
)
1828 && STREQ (SYMBOL_NAME (prev_sym
), SYMBOL_NAME(sym
)))
1830 SYMBOL_CLASS (prev_sym
) = LOC_REGPARM
;
1831 /* Use the type from the LOC_REGISTER; that is the type
1832 that is actually in that register. */
1833 SYMBOL_TYPE (prev_sym
) = SYMBOL_TYPE (sym
);
1834 SYMBOL_VALUE (prev_sym
) = SYMBOL_VALUE (sym
);
1839 add_symbol_to_list (sym
, &local_symbols
);
1842 add_symbol_to_list (sym
, &file_symbols
);
1846 /* Static symbol at top level of file */
1847 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1848 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1849 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
1850 #ifdef STATIC_TRANSFORM_NAME
1851 if (SYMBOL_NAME (sym
)[0] == '$')
1853 struct minimal_symbol
*msym
;
1854 msym
= lookup_minimal_symbol (SYMBOL_NAME (sym
), NULL
, objfile
);
1857 SYMBOL_NAME (sym
) = STATIC_TRANSFORM_NAME (SYMBOL_NAME (sym
));
1858 SYMBOL_VALUE_ADDRESS (sym
) = SYMBOL_VALUE_ADDRESS (msym
);
1862 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1863 add_symbol_to_list (sym
, &file_symbols
);
1867 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1869 /* For a nameless type, we don't want a create a symbol, thus we
1870 did not use `sym'. Return without further processing. */
1871 if (nameless
) return NULL
;
1873 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1874 SYMBOL_VALUE (sym
) = valu
;
1875 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1876 /* C++ vagaries: we may have a type which is derived from
1877 a base type which did not have its name defined when the
1878 derived class was output. We fill in the derived class's
1879 base part member's name here in that case. */
1880 if (TYPE_NAME (SYMBOL_TYPE (sym
)) != NULL
)
1881 if ((TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
1882 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_UNION
)
1883 && TYPE_N_BASECLASSES (SYMBOL_TYPE (sym
)))
1886 for (j
= TYPE_N_BASECLASSES (SYMBOL_TYPE (sym
)) - 1; j
>= 0; j
--)
1887 if (TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym
), j
) == 0)
1888 TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym
), j
) =
1889 type_name_no_tag (TYPE_BASECLASS (SYMBOL_TYPE (sym
), j
));
1892 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == NULL
)
1894 /* gcc-2.6 or later (when using -fvtable-thunks)
1895 emits a unique named type for a vtable entry.
1896 Some gdb code depends on that specific name. */
1897 extern const char vtbl_ptr_name
[];
1899 if ((TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_PTR
1900 && strcmp (SYMBOL_NAME (sym
), vtbl_ptr_name
))
1901 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FUNC
)
1903 /* If we are giving a name to a type such as "pointer to
1904 foo" or "function returning foo", we better not set
1905 the TYPE_NAME. If the program contains "typedef char
1906 *caddr_t;", we don't want all variables of type char
1907 * to print as caddr_t. This is not just a
1908 consequence of GDB's type management; PCC and GCC (at
1909 least through version 2.4) both output variables of
1910 either type char * or caddr_t with the type number
1911 defined in the 't' symbol for caddr_t. If a future
1912 compiler cleans this up it GDB is not ready for it
1913 yet, but if it becomes ready we somehow need to
1914 disable this check (without breaking the PCC/GCC2.4
1919 Fortunately, this check seems not to be necessary
1920 for anything except pointers or functions. */
1923 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_NAME (sym
);
1926 add_symbol_to_list (sym
, &file_symbols
);
1930 /* Struct, union, or enum tag. For GNU C++, this can be be followed
1931 by 't' which means we are typedef'ing it as well. */
1932 synonym
= *p
== 't';
1936 /* The semantics of C++ state that "struct foo { ... }" also defines
1937 a typedef for "foo". Unfortunately, cfront never makes the typedef
1938 when translating C++ into C. We make the typedef here so that
1939 "ptype foo" works as expected for cfront translated code. */
1940 else if (current_subfile
->language
== language_cplus
)
1943 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1945 /* For a nameless type, we don't want a create a symbol, thus we
1946 did not use `sym'. Return without further processing. */
1947 if (nameless
) return NULL
;
1949 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1950 SYMBOL_VALUE (sym
) = valu
;
1951 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
1952 if (TYPE_TAG_NAME (SYMBOL_TYPE (sym
)) == 0)
1953 TYPE_TAG_NAME (SYMBOL_TYPE (sym
))
1954 = obconcat (&objfile
-> type_obstack
, "", "", SYMBOL_NAME (sym
));
1955 add_symbol_to_list (sym
, &file_symbols
);
1959 /* Clone the sym and then modify it. */
1960 register struct symbol
*typedef_sym
= (struct symbol
*)
1961 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
1962 *typedef_sym
= *sym
;
1963 SYMBOL_CLASS (typedef_sym
) = LOC_TYPEDEF
;
1964 SYMBOL_VALUE (typedef_sym
) = valu
;
1965 SYMBOL_NAMESPACE (typedef_sym
) = VAR_NAMESPACE
;
1966 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
1967 TYPE_NAME (SYMBOL_TYPE (sym
))
1968 = obconcat (&objfile
-> type_obstack
, "", "", SYMBOL_NAME (sym
));
1969 add_symbol_to_list (typedef_sym
, &file_symbols
);
1974 /* Static symbol of local scope */
1975 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1976 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1977 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
1978 #ifdef STATIC_TRANSFORM_NAME
1979 if (SYMBOL_NAME (sym
)[0] == '$')
1981 struct minimal_symbol
*msym
;
1982 msym
= lookup_minimal_symbol (SYMBOL_NAME (sym
), NULL
, objfile
);
1985 SYMBOL_NAME (sym
) = STATIC_TRANSFORM_NAME (SYMBOL_NAME (sym
));
1986 SYMBOL_VALUE_ADDRESS (sym
) = SYMBOL_VALUE_ADDRESS (msym
);
1990 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1992 add_symbol_to_list (sym
, &global_symbols
);
1994 add_symbol_to_list (sym
, &local_symbols
);
1998 /* Reference parameter */
1999 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
2000 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
2001 SYMBOL_VALUE (sym
) = valu
;
2002 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2003 add_symbol_to_list (sym
, &local_symbols
);
2007 /* Reference parameter which is in a register. */
2008 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
2009 SYMBOL_CLASS (sym
) = LOC_REGPARM_ADDR
;
2010 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (valu
);
2011 if (SYMBOL_VALUE (sym
) >= NUM_REGS
)
2013 complain (®_value_complaint
, SYMBOL_VALUE (sym
), NUM_REGS
,
2014 SYMBOL_SOURCE_NAME (sym
));
2015 SYMBOL_VALUE (sym
) = SP_REGNUM
; /* Known safe, though useless */
2017 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2018 add_symbol_to_list (sym
, &local_symbols
);
2022 /* This is used by Sun FORTRAN for "function result value".
2023 Sun claims ("dbx and dbxtool interfaces", 2nd ed)
2024 that Pascal uses it too, but when I tried it Pascal used
2025 "x:3" (local symbol) instead. */
2026 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
2027 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
2028 SYMBOL_VALUE (sym
) = valu
;
2029 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2030 add_symbol_to_list (sym
, &local_symbols
);
2033 /* New code added to support cfront stabs strings.
2034 Note: case 'P' already handled above */
2036 /* Cfront type continuation coming up!
2037 Find the original definition and add to it.
2038 We'll have to do this for the typedef too,
2039 since we cloned the symbol to define a type in read_type.
2040 Stabs info examples:
2042 foo__1CFv :ZtF (first def foo__1CFv:F(0,3);(0,24))
2043 C:ZsC;;__ct__1CFv func1__1CFv func2__1CFv ... ;;;
2044 where C is the name of the class.
2045 Unfortunately, we can't lookup the original symbol yet 'cuz
2046 we haven't finished reading all the symbols.
2047 Instead, we save it for processing later */
2048 process_later (sym
, p
, resolve_cfront_continuation
);
2049 SYMBOL_TYPE (sym
) = error_type (&p
, objfile
); /* FIXME! change later */
2050 SYMBOL_CLASS (sym
) = LOC_CONST
;
2051 SYMBOL_VALUE (sym
) = 0;
2052 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2053 /* Don't add to list - we'll delete it later when
2054 we add the continuation to the real sym */
2056 /* End of new code added to support cfront stabs strings */
2059 SYMBOL_TYPE (sym
) = error_type (&p
, objfile
);
2060 SYMBOL_CLASS (sym
) = LOC_CONST
;
2061 SYMBOL_VALUE (sym
) = 0;
2062 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2063 add_symbol_to_list (sym
, &file_symbols
);
2067 /* When passing structures to a function, some systems sometimes pass
2068 the address in a register, not the structure itself. */
2070 if (REG_STRUCT_HAS_ADDR (processing_gcc_compilation
, SYMBOL_TYPE (sym
))
2071 && (SYMBOL_CLASS (sym
) == LOC_REGPARM
|| SYMBOL_CLASS (sym
) == LOC_ARG
))
2073 struct type
*symbol_type
= check_typedef (SYMBOL_TYPE (sym
));
2075 if ((TYPE_CODE (symbol_type
) == TYPE_CODE_STRUCT
)
2076 || (TYPE_CODE (symbol_type
) == TYPE_CODE_UNION
)
2077 || (TYPE_CODE (symbol_type
) == TYPE_CODE_BITSTRING
)
2078 || (TYPE_CODE (symbol_type
) == TYPE_CODE_SET
))
2080 /* If REG_STRUCT_HAS_ADDR yields non-zero we have to convert
2081 LOC_REGPARM to LOC_REGPARM_ADDR for structures and unions. */
2082 if (SYMBOL_CLASS (sym
) == LOC_REGPARM
)
2083 SYMBOL_CLASS (sym
) = LOC_REGPARM_ADDR
;
2084 /* Likewise for converting LOC_ARG to LOC_REF_ARG (for the 7th
2085 and subsequent arguments on the sparc, for example). */
2086 else if (SYMBOL_CLASS (sym
) == LOC_ARG
)
2087 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
2091 /* Is there more to parse? eg. ";l(#1,#2);l(#3,#5)" */
2092 while (*p
&& (*p
== ';' || *p
== ','))
2095 if (*p
&& *p
== 'l')
2097 /* GNU extensions for live range splitting may be appended to
2098 the end of the stab string. eg. "l(#1,#2);l(#3,#5)" */
2100 /* Fix up ranges later. */
2101 process_later (sym
, p
, resolve_live_range
);
2103 /* Find end of live range info. */
2104 p
= strchr (p
, ')');
2105 if (!*p
|| *p
!= ')')
2106 error ("Internal error: live range format not recognized.\n");
2114 /* Add live range information to symbol. (eg. p is l(#1,#2)...) */
2116 resolve_live_range (objfile
, sym
, p
)
2117 struct objfile
* objfile
;
2123 CORE_ADDR start
, end
;
2125 if (!*p
|| *p
!= 'l')
2126 error ("Internal error: live range string.\n");
2129 if (!*p
|| *p
!= '(')
2130 error ("Internal error: live range string.\n");
2133 /* Get starting value of range symbol reference. eg. "#1,#2),l(#3,#5)"
2134 and advance p past the refid. */
2135 refnum
= process_reference (&p
);
2136 start
= ref_search_value (refnum
);
2138 error ("Internal error: live range symbol not found.\n");
2140 if (!*p
|| *p
!= ',')
2141 error ("Internal error: live range string.\n");
2144 /* Get ending value of range symbol reference. eg. "#2),l(#3,#5)" */
2145 refnum
= process_reference (&p
);
2146 end
= ref_search_value (refnum
);
2148 error ("Internal error: live range symbol not found.\n");
2150 add_live_range (objfile
, sym
, start
, end
);
2152 if (!*p
|| *p
!= ')')
2153 error ("Internal error: live range string.\n");
2159 add_live_range (objfile
, sym
, start
, end
)
2160 struct objfile
*objfile
;
2162 CORE_ADDR start
, end
;
2164 struct live_range
*r
, *rs
;
2167 error ("Internal error: end of live range follows start.\n");
2169 /* Alloc new live range structure. */
2170 r
= (struct live_range
*)
2171 obstack_alloc (&objfile
->type_obstack
,
2172 sizeof (struct live_range
));
2177 /* Append this range to the symbol's range list. */
2178 if (!SYMBOL_RANGE (sym
))
2180 SYMBOL_RANGE (sym
) = r
;
2184 /* Get the last range for the symbol. */
2185 for (rs
= SYMBOL_RANGE (sym
); rs
->next
; rs
= rs
->next
)
2191 /* Given addr, Search thu alias list to find the one active. */
2193 ref_search_val (sym
, addr
)
2197 struct live_range
*r
;
2201 if (!SYMBOL_RANGE (sym
))
2203 for (r
= SYMBOL_RANGE (sym
); r
; r
= r
->next
)
2205 if (r
->start
<= addr
2209 sym
= SYMBOL_ALIASES (sym
);
2215 /* Skip rest of this symbol and return an error type.
2217 General notes on error recovery: error_type always skips to the
2218 end of the symbol (modulo cretinous dbx symbol name continuation).
2219 Thus code like this:
2221 if (*(*pp)++ != ';')
2222 return error_type (pp, objfile);
2224 is wrong because if *pp starts out pointing at '\0' (typically as the
2225 result of an earlier error), it will be incremented to point to the
2226 start of the next symbol, which might produce strange results, at least
2227 if you run off the end of the string table. Instead use
2230 return error_type (pp, objfile);
2236 foo = error_type (pp, objfile);
2240 And in case it isn't obvious, the point of all this hair is so the compiler
2241 can define new types and new syntaxes, and old versions of the
2242 debugger will be able to read the new symbol tables. */
2244 static struct type
*
2245 error_type (pp
, objfile
)
2247 struct objfile
*objfile
;
2249 complain (&error_type_complaint
);
2252 /* Skip to end of symbol. */
2253 while (**pp
!= '\0')
2258 /* Check for and handle cretinous dbx symbol name continuation! */
2259 if ((*pp
)[-1] == '\\' || (*pp
)[-1] == '?')
2261 *pp
= next_symbol_text (objfile
);
2268 return (builtin_type_error
);
2272 /* Read type information or a type definition; return the type. Even
2273 though this routine accepts either type information or a type
2274 definition, the distinction is relevant--some parts of stabsread.c
2275 assume that type information starts with a digit, '-', or '(' in
2276 deciding whether to call read_type. */
2279 read_type (pp
, objfile
)
2281 struct objfile
*objfile
;
2283 register struct type
*type
= 0;
2286 char type_descriptor
;
2288 /* Size in bits of type if specified by a type attribute, or -1 if
2289 there is no size attribute. */
2292 /* Used to distinguish string and bitstring from char-array and set. */
2295 /* Read type number if present. The type number may be omitted.
2296 for instance in a two-dimensional array declared with type
2297 "ar1;1;10;ar1;1;10;4". */
2298 if ((**pp
>= '0' && **pp
<= '9')
2302 if (read_type_number (pp
, typenums
) != 0)
2303 return error_type (pp
, objfile
);
2305 /* Type is not being defined here. Either it already exists,
2306 or this is a forward reference to it. dbx_alloc_type handles
2309 return dbx_alloc_type (typenums
, objfile
);
2311 /* Type is being defined here. */
2313 Also skip the type descriptor - we get it below with (*pp)[-1]. */
2318 /* 'typenums=' not present, type is anonymous. Read and return
2319 the definition, but don't put it in the type vector. */
2320 typenums
[0] = typenums
[1] = -1;
2325 type_descriptor
= (*pp
)[-1];
2326 switch (type_descriptor
)
2330 enum type_code code
;
2332 /* Used to index through file_symbols. */
2333 struct pending
*ppt
;
2336 /* Name including "struct", etc. */
2340 char *from
, *to
, *p
, *q1
, *q2
;
2342 /* Set the type code according to the following letter. */
2346 code
= TYPE_CODE_STRUCT
;
2349 code
= TYPE_CODE_UNION
;
2352 code
= TYPE_CODE_ENUM
;
2356 /* Complain and keep going, so compilers can invent new
2357 cross-reference types. */
2358 static struct complaint msg
=
2359 {"Unrecognized cross-reference type `%c'", 0, 0};
2360 complain (&msg
, (*pp
)[0]);
2361 code
= TYPE_CODE_STRUCT
;
2366 q1
= strchr (*pp
, '<');
2367 p
= strchr (*pp
, ':');
2369 return error_type (pp
, objfile
);
2370 if (q1
&& p
> q1
&& p
[1] == ':')
2372 int nesting_level
= 0;
2373 for (q2
= q1
; *q2
; q2
++)
2377 else if (*q2
== '>')
2379 else if (*q2
== ':' && nesting_level
== 0)
2384 return error_type (pp
, objfile
);
2387 (char *)obstack_alloc (&objfile
->type_obstack
, p
- *pp
+ 1);
2389 /* Copy the name. */
2395 /* Set the pointer ahead of the name which we just read, and
2400 /* Now check to see whether the type has already been
2401 declared. This was written for arrays of cross-referenced
2402 types before we had TYPE_CODE_TARGET_STUBBED, so I'm pretty
2403 sure it is not necessary anymore. But it might be a good
2404 idea, to save a little memory. */
2406 for (ppt
= file_symbols
; ppt
; ppt
= ppt
->next
)
2407 for (i
= 0; i
< ppt
->nsyms
; i
++)
2409 struct symbol
*sym
= ppt
->symbol
[i
];
2411 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
2412 && SYMBOL_NAMESPACE (sym
) == STRUCT_NAMESPACE
2413 && (TYPE_CODE (SYMBOL_TYPE (sym
)) == code
)
2414 && STREQ (SYMBOL_NAME (sym
), type_name
))
2416 obstack_free (&objfile
-> type_obstack
, type_name
);
2417 type
= SYMBOL_TYPE (sym
);
2422 /* Didn't find the type to which this refers, so we must
2423 be dealing with a forward reference. Allocate a type
2424 structure for it, and keep track of it so we can
2425 fill in the rest of the fields when we get the full
2427 type
= dbx_alloc_type (typenums
, objfile
);
2428 TYPE_CODE (type
) = code
;
2429 TYPE_TAG_NAME (type
) = type_name
;
2430 INIT_CPLUS_SPECIFIC(type
);
2431 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
2433 add_undefined_type (type
);
2437 case '-': /* RS/6000 built-in type */
2451 /* We deal with something like t(1,2)=(3,4)=... which
2452 the Lucid compiler and recent gcc versions (post 2.7.3) use. */
2454 /* Allocate and enter the typedef type first.
2455 This handles recursive types. */
2456 type
= dbx_alloc_type (typenums
, objfile
);
2457 TYPE_CODE (type
) = TYPE_CODE_TYPEDEF
;
2458 { struct type
*xtype
= read_type (pp
, objfile
);
2461 /* It's being defined as itself. That means it is "void". */
2462 TYPE_CODE (type
) = TYPE_CODE_VOID
;
2463 TYPE_LENGTH (type
) = 1;
2465 else if (type_size
>= 0 || is_string
)
2468 TYPE_NAME (type
) = NULL
;
2469 TYPE_TAG_NAME (type
) = NULL
;
2473 TYPE_FLAGS (type
) |= TYPE_FLAG_TARGET_STUB
;
2474 TYPE_TARGET_TYPE (type
) = xtype
;
2479 /* In the following types, we must be sure to overwrite any existing
2480 type that the typenums refer to, rather than allocating a new one
2481 and making the typenums point to the new one. This is because there
2482 may already be pointers to the existing type (if it had been
2483 forward-referenced), and we must change it to a pointer, function,
2484 reference, or whatever, *in-place*. */
2487 type1
= read_type (pp
, objfile
);
2488 type
= make_pointer_type (type1
, dbx_lookup_type (typenums
));
2491 case '&': /* Reference to another type */
2492 type1
= read_type (pp
, objfile
);
2493 type
= make_reference_type (type1
, dbx_lookup_type (typenums
));
2496 case 'f': /* Function returning another type */
2497 if (os9k_stabs
&& **pp
== '(')
2499 /* Function prototype; parse it.
2500 We must conditionalize this on os9k_stabs because otherwise
2501 it could be confused with a Sun-style (1,3) typenumber
2507 t
= read_type (pp
, objfile
);
2508 if (**pp
== ',') ++*pp
;
2511 type1
= read_type (pp
, objfile
);
2512 type
= make_function_type (type1
, dbx_lookup_type (typenums
));
2515 case 'k': /* Const qualifier on some type (Sun) */
2516 case 'c': /* Const qualifier on some type (OS9000) */
2517 /* Because 'c' means other things to AIX and 'k' is perfectly good,
2518 only accept 'c' in the os9k_stabs case. */
2519 if (type_descriptor
== 'c' && !os9k_stabs
)
2520 return error_type (pp
, objfile
);
2521 type
= read_type (pp
, objfile
);
2522 /* FIXME! For now, we ignore const and volatile qualifiers. */
2525 case 'B': /* Volatile qual on some type (Sun) */
2526 case 'i': /* Volatile qual on some type (OS9000) */
2527 /* Because 'i' means other things to AIX and 'B' is perfectly good,
2528 only accept 'i' in the os9k_stabs case. */
2529 if (type_descriptor
== 'i' && !os9k_stabs
)
2530 return error_type (pp
, objfile
);
2531 type
= read_type (pp
, objfile
);
2532 /* FIXME! For now, we ignore const and volatile qualifiers. */
2536 if (isdigit (**pp
) || **pp
== '(' || **pp
== '-')
2537 { /* Member (class & variable) type */
2538 /* FIXME -- we should be doing smash_to_XXX types here. */
2540 struct type
*domain
= read_type (pp
, objfile
);
2541 struct type
*memtype
;
2544 /* Invalid member type data format. */
2545 return error_type (pp
, objfile
);
2548 memtype
= read_type (pp
, objfile
);
2549 type
= dbx_alloc_type (typenums
, objfile
);
2550 smash_to_member_type (type
, domain
, memtype
);
2552 else /* type attribute */
2555 /* Skip to the semicolon. */
2556 while (**pp
!= ';' && **pp
!= '\0')
2559 return error_type (pp
, objfile
);
2561 ++*pp
; /* Skip the semicolon. */
2566 type_size
= atoi (attr
+ 1);
2576 /* Ignore unrecognized type attributes, so future compilers
2577 can invent new ones. */
2585 case '#': /* Method (class & fn) type */
2586 if ((*pp
)[0] == '#')
2588 /* We'll get the parameter types from the name. */
2589 struct type
*return_type
;
2592 return_type
= read_type (pp
, objfile
);
2593 if (*(*pp
)++ != ';')
2594 complain (&invalid_member_complaint
, symnum
);
2595 type
= allocate_stub_method (return_type
);
2596 if (typenums
[0] != -1)
2597 *dbx_lookup_type (typenums
) = type
;
2601 struct type
*domain
= read_type (pp
, objfile
);
2602 struct type
*return_type
;
2606 /* Invalid member type data format. */
2607 return error_type (pp
, objfile
);
2611 return_type
= read_type (pp
, objfile
);
2612 args
= read_args (pp
, ';', objfile
);
2613 type
= dbx_alloc_type (typenums
, objfile
);
2614 smash_to_method_type (type
, domain
, return_type
, args
);
2618 case 'r': /* Range type */
2619 type
= read_range_type (pp
, typenums
, objfile
);
2620 if (typenums
[0] != -1)
2621 *dbx_lookup_type (typenums
) = type
;
2626 /* Const and volatile qualified type. */
2627 type
= read_type (pp
, objfile
);
2630 /* Sun ACC builtin int type */
2631 type
= read_sun_builtin_type (pp
, typenums
, objfile
);
2632 if (typenums
[0] != -1)
2633 *dbx_lookup_type (typenums
) = type
;
2637 case 'R': /* Sun ACC builtin float type */
2638 type
= read_sun_floating_type (pp
, typenums
, objfile
);
2639 if (typenums
[0] != -1)
2640 *dbx_lookup_type (typenums
) = type
;
2643 case 'e': /* Enumeration type */
2644 type
= dbx_alloc_type (typenums
, objfile
);
2645 type
= read_enum_type (pp
, type
, objfile
);
2646 if (typenums
[0] != -1)
2647 *dbx_lookup_type (typenums
) = type
;
2650 case 's': /* Struct type */
2651 case 'u': /* Union type */
2652 type
= dbx_alloc_type (typenums
, objfile
);
2653 switch (type_descriptor
)
2656 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
2659 TYPE_CODE (type
) = TYPE_CODE_UNION
;
2662 type
= read_struct_type (pp
, type
, objfile
);
2665 case 'a': /* Array type */
2667 return error_type (pp
, objfile
);
2670 type
= dbx_alloc_type (typenums
, objfile
);
2671 type
= read_array_type (pp
, type
, objfile
);
2673 TYPE_CODE (type
) = TYPE_CODE_STRING
;
2677 type1
= read_type (pp
, objfile
);
2678 type
= create_set_type ((struct type
*) NULL
, type1
);
2680 TYPE_CODE (type
) = TYPE_CODE_BITSTRING
;
2681 if (typenums
[0] != -1)
2682 *dbx_lookup_type (typenums
) = type
;
2686 --*pp
; /* Go back to the symbol in error */
2687 /* Particularly important if it was \0! */
2688 return error_type (pp
, objfile
);
2693 warning ("GDB internal error, type is NULL in stabsread.c\n");
2694 return error_type (pp
, objfile
);
2697 /* Size specified in a type attribute overrides any other size. */
2698 if (type_size
!= -1)
2699 TYPE_LENGTH (type
) = (type_size
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
2704 /* RS/6000 xlc/dbx combination uses a set of builtin types, starting from -1.
2705 Return the proper type node for a given builtin type number. */
2707 static struct type
*
2708 rs6000_builtin_type (typenum
)
2711 /* We recognize types numbered from -NUMBER_RECOGNIZED to -1. */
2712 #define NUMBER_RECOGNIZED 34
2713 /* This includes an empty slot for type number -0. */
2714 static struct type
*negative_types
[NUMBER_RECOGNIZED
+ 1];
2715 struct type
*rettype
= NULL
;
2717 if (typenum
>= 0 || typenum
< -NUMBER_RECOGNIZED
)
2719 complain (&rs6000_builtin_complaint
, typenum
);
2720 return builtin_type_error
;
2722 if (negative_types
[-typenum
] != NULL
)
2723 return negative_types
[-typenum
];
2725 #if TARGET_CHAR_BIT != 8
2726 #error This code wrong for TARGET_CHAR_BIT not 8
2727 /* These definitions all assume that TARGET_CHAR_BIT is 8. I think
2728 that if that ever becomes not true, the correct fix will be to
2729 make the size in the struct type to be in bits, not in units of
2736 /* The size of this and all the other types are fixed, defined
2737 by the debugging format. If there is a type called "int" which
2738 is other than 32 bits, then it should use a new negative type
2739 number (or avoid negative type numbers for that case).
2740 See stabs.texinfo. */
2741 rettype
= init_type (TYPE_CODE_INT
, 4, 0, "int", NULL
);
2744 rettype
= init_type (TYPE_CODE_INT
, 1, 0, "char", NULL
);
2747 rettype
= init_type (TYPE_CODE_INT
, 2, 0, "short", NULL
);
2750 rettype
= init_type (TYPE_CODE_INT
, 4, 0, "long", NULL
);
2753 rettype
= init_type (TYPE_CODE_INT
, 1, TYPE_FLAG_UNSIGNED
,
2754 "unsigned char", NULL
);
2757 rettype
= init_type (TYPE_CODE_INT
, 1, 0, "signed char", NULL
);
2760 rettype
= init_type (TYPE_CODE_INT
, 2, TYPE_FLAG_UNSIGNED
,
2761 "unsigned short", NULL
);
2764 rettype
= init_type (TYPE_CODE_INT
, 4, TYPE_FLAG_UNSIGNED
,
2765 "unsigned int", NULL
);
2768 rettype
= init_type (TYPE_CODE_INT
, 4, TYPE_FLAG_UNSIGNED
,
2771 rettype
= init_type (TYPE_CODE_INT
, 4, TYPE_FLAG_UNSIGNED
,
2772 "unsigned long", NULL
);
2775 rettype
= init_type (TYPE_CODE_VOID
, 1, 0, "void", NULL
);
2778 /* IEEE single precision (32 bit). */
2779 rettype
= init_type (TYPE_CODE_FLT
, 4, 0, "float", NULL
);
2782 /* IEEE double precision (64 bit). */
2783 rettype
= init_type (TYPE_CODE_FLT
, 8, 0, "double", NULL
);
2786 /* This is an IEEE double on the RS/6000, and different machines with
2787 different sizes for "long double" should use different negative
2788 type numbers. See stabs.texinfo. */
2789 rettype
= init_type (TYPE_CODE_FLT
, 8, 0, "long double", NULL
);
2792 rettype
= init_type (TYPE_CODE_INT
, 4, 0, "integer", NULL
);
2795 rettype
= init_type (TYPE_CODE_BOOL
, 4, TYPE_FLAG_UNSIGNED
,
2799 rettype
= init_type (TYPE_CODE_FLT
, 4, 0, "short real", NULL
);
2802 rettype
= init_type (TYPE_CODE_FLT
, 8, 0, "real", NULL
);
2805 rettype
= init_type (TYPE_CODE_ERROR
, 0, 0, "stringptr", NULL
);
2808 rettype
= init_type (TYPE_CODE_CHAR
, 1, TYPE_FLAG_UNSIGNED
,
2812 rettype
= init_type (TYPE_CODE_BOOL
, 1, TYPE_FLAG_UNSIGNED
,
2816 rettype
= init_type (TYPE_CODE_BOOL
, 2, TYPE_FLAG_UNSIGNED
,
2820 rettype
= init_type (TYPE_CODE_BOOL
, 4, TYPE_FLAG_UNSIGNED
,
2824 rettype
= init_type (TYPE_CODE_BOOL
, 4, TYPE_FLAG_UNSIGNED
,
2828 /* Complex type consisting of two IEEE single precision values. */
2829 rettype
= init_type (TYPE_CODE_ERROR
, 8, 0, "complex", NULL
);
2832 /* Complex type consisting of two IEEE double precision values. */
2833 rettype
= init_type (TYPE_CODE_ERROR
, 16, 0, "double complex", NULL
);
2836 rettype
= init_type (TYPE_CODE_INT
, 1, 0, "integer*1", NULL
);
2839 rettype
= init_type (TYPE_CODE_INT
, 2, 0, "integer*2", NULL
);
2842 rettype
= init_type (TYPE_CODE_INT
, 4, 0, "integer*4", NULL
);
2845 rettype
= init_type (TYPE_CODE_CHAR
, 2, 0, "wchar", NULL
);
2848 rettype
= init_type (TYPE_CODE_INT
, 8, 0, "long long", NULL
);
2851 rettype
= init_type (TYPE_CODE_INT
, 8, TYPE_FLAG_UNSIGNED
,
2852 "unsigned long long", NULL
);
2855 rettype
= init_type (TYPE_CODE_INT
, 8, TYPE_FLAG_UNSIGNED
,
2859 rettype
= init_type (TYPE_CODE_INT
, 8, 0, "integer*8", NULL
);
2862 negative_types
[-typenum
] = rettype
;
2866 /* This page contains subroutines of read_type. */
2868 /* Read member function stabs info for C++ classes. The form of each member
2871 NAME :: TYPENUM[=type definition] ARGS : PHYSNAME ;
2873 An example with two member functions is:
2875 afunc1::20=##15;:i;2A.;afunc2::20:i;2A.;
2877 For the case of overloaded operators, the format is op$::*.funcs, where
2878 $ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator
2879 name (such as `+=') and `.' marks the end of the operator name.
2881 Returns 1 for success, 0 for failure. */
2884 read_member_functions (fip
, pp
, type
, objfile
)
2885 struct field_info
*fip
;
2888 struct objfile
*objfile
;
2892 /* Total number of member functions defined in this class. If the class
2893 defines two `f' functions, and one `g' function, then this will have
2895 int total_length
= 0;
2899 struct next_fnfield
*next
;
2900 struct fn_field fn_field
;
2902 struct type
*look_ahead_type
;
2903 struct next_fnfieldlist
*new_fnlist
;
2904 struct next_fnfield
*new_sublist
;
2908 /* Process each list until we find something that is not a member function
2909 or find the end of the functions. */
2913 /* We should be positioned at the start of the function name.
2914 Scan forward to find the first ':' and if it is not the
2915 first of a "::" delimiter, then this is not a member function. */
2927 look_ahead_type
= NULL
;
2930 new_fnlist
= (struct next_fnfieldlist
*)
2931 xmalloc (sizeof (struct next_fnfieldlist
));
2932 make_cleanup (free
, new_fnlist
);
2933 memset (new_fnlist
, 0, sizeof (struct next_fnfieldlist
));
2935 if ((*pp
)[0] == 'o' && (*pp
)[1] == 'p' && is_cplus_marker ((*pp
)[2]))
2937 /* This is a completely wierd case. In order to stuff in the
2938 names that might contain colons (the usual name delimiter),
2939 Mike Tiemann defined a different name format which is
2940 signalled if the identifier is "op$". In that case, the
2941 format is "op$::XXXX." where XXXX is the name. This is
2942 used for names like "+" or "=". YUUUUUUUK! FIXME! */
2943 /* This lets the user type "break operator+".
2944 We could just put in "+" as the name, but that wouldn't
2946 static char opname
[32] = {'o', 'p', CPLUS_MARKER
};
2947 char *o
= opname
+ 3;
2949 /* Skip past '::'. */
2952 STABS_CONTINUE (pp
, objfile
);
2958 main_fn_name
= savestring (opname
, o
- opname
);
2964 main_fn_name
= savestring (*pp
, p
- *pp
);
2965 /* Skip past '::'. */
2968 new_fnlist
-> fn_fieldlist
.name
= main_fn_name
;
2973 (struct next_fnfield
*) xmalloc (sizeof (struct next_fnfield
));
2974 make_cleanup (free
, new_sublist
);
2975 memset (new_sublist
, 0, sizeof (struct next_fnfield
));
2977 /* Check for and handle cretinous dbx symbol name continuation! */
2978 if (look_ahead_type
== NULL
)
2981 STABS_CONTINUE (pp
, objfile
);
2983 new_sublist
-> fn_field
.type
= read_type (pp
, objfile
);
2986 /* Invalid symtab info for member function. */
2992 /* g++ version 1 kludge */
2993 new_sublist
-> fn_field
.type
= look_ahead_type
;
2994 look_ahead_type
= NULL
;
3004 /* If this is just a stub, then we don't have the real name here. */
3006 if (TYPE_FLAGS (new_sublist
-> fn_field
.type
) & TYPE_FLAG_STUB
)
3008 if (!TYPE_DOMAIN_TYPE (new_sublist
-> fn_field
.type
))
3009 TYPE_DOMAIN_TYPE (new_sublist
-> fn_field
.type
) = type
;
3010 new_sublist
-> fn_field
.is_stub
= 1;
3012 new_sublist
-> fn_field
.physname
= savestring (*pp
, p
- *pp
);
3015 /* Set this member function's visibility fields. */
3018 case VISIBILITY_PRIVATE
:
3019 new_sublist
-> fn_field
.is_private
= 1;
3021 case VISIBILITY_PROTECTED
:
3022 new_sublist
-> fn_field
.is_protected
= 1;
3026 STABS_CONTINUE (pp
, objfile
);
3029 case 'A': /* Normal functions. */
3030 new_sublist
-> fn_field
.is_const
= 0;
3031 new_sublist
-> fn_field
.is_volatile
= 0;
3034 case 'B': /* `const' member functions. */
3035 new_sublist
-> fn_field
.is_const
= 1;
3036 new_sublist
-> fn_field
.is_volatile
= 0;
3039 case 'C': /* `volatile' member function. */
3040 new_sublist
-> fn_field
.is_const
= 0;
3041 new_sublist
-> fn_field
.is_volatile
= 1;
3044 case 'D': /* `const volatile' member function. */
3045 new_sublist
-> fn_field
.is_const
= 1;
3046 new_sublist
-> fn_field
.is_volatile
= 1;
3049 case '*': /* File compiled with g++ version 1 -- no info */
3054 complain (&const_vol_complaint
, **pp
);
3063 /* virtual member function, followed by index.
3064 The sign bit is set to distinguish pointers-to-methods
3065 from virtual function indicies. Since the array is
3066 in words, the quantity must be shifted left by 1
3067 on 16 bit machine, and by 2 on 32 bit machine, forcing
3068 the sign bit out, and usable as a valid index into
3069 the array. Remove the sign bit here. */
3070 new_sublist
-> fn_field
.voffset
=
3071 (0x7fffffff & read_huge_number (pp
, ';', &nbits
)) + 2;
3075 STABS_CONTINUE (pp
, objfile
);
3076 if (**pp
== ';' || **pp
== '\0')
3078 /* Must be g++ version 1. */
3079 new_sublist
-> fn_field
.fcontext
= 0;
3083 /* Figure out from whence this virtual function came.
3084 It may belong to virtual function table of
3085 one of its baseclasses. */
3086 look_ahead_type
= read_type (pp
, objfile
);
3089 /* g++ version 1 overloaded methods. */
3093 new_sublist
-> fn_field
.fcontext
= look_ahead_type
;
3102 look_ahead_type
= NULL
;
3108 /* static member function. */
3109 new_sublist
-> fn_field
.voffset
= VOFFSET_STATIC
;
3110 if (strncmp (new_sublist
-> fn_field
.physname
,
3111 main_fn_name
, strlen (main_fn_name
)))
3113 new_sublist
-> fn_field
.is_stub
= 1;
3119 complain (&member_fn_complaint
, (*pp
)[-1]);
3120 /* Fall through into normal member function. */
3123 /* normal member function. */
3124 new_sublist
-> fn_field
.voffset
= 0;
3125 new_sublist
-> fn_field
.fcontext
= 0;
3129 new_sublist
-> next
= sublist
;
3130 sublist
= new_sublist
;
3132 STABS_CONTINUE (pp
, objfile
);
3134 while (**pp
!= ';' && **pp
!= '\0');
3138 new_fnlist
-> fn_fieldlist
.fn_fields
= (struct fn_field
*)
3139 obstack_alloc (&objfile
-> type_obstack
,
3140 sizeof (struct fn_field
) * length
);
3141 memset (new_fnlist
-> fn_fieldlist
.fn_fields
, 0,
3142 sizeof (struct fn_field
) * length
);
3143 for (i
= length
; (i
--, sublist
); sublist
= sublist
-> next
)
3145 new_fnlist
-> fn_fieldlist
.fn_fields
[i
] = sublist
-> fn_field
;
3148 new_fnlist
-> fn_fieldlist
.length
= length
;
3149 new_fnlist
-> next
= fip
-> fnlist
;
3150 fip
-> fnlist
= new_fnlist
;
3152 total_length
+= length
;
3153 STABS_CONTINUE (pp
, objfile
);
3158 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3159 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
3160 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * nfn_fields
);
3161 memset (TYPE_FN_FIELDLISTS (type
), 0,
3162 sizeof (struct fn_fieldlist
) * nfn_fields
);
3163 TYPE_NFN_FIELDS (type
) = nfn_fields
;
3164 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
3170 /* Special GNU C++ name.
3172 Returns 1 for success, 0 for failure. "failure" means that we can't
3173 keep parsing and it's time for error_type(). */
3176 read_cpp_abbrev (fip
, pp
, type
, objfile
)
3177 struct field_info
*fip
;
3180 struct objfile
*objfile
;
3185 struct type
*context
;
3195 /* At this point, *pp points to something like "22:23=*22...",
3196 where the type number before the ':' is the "context" and
3197 everything after is a regular type definition. Lookup the
3198 type, find it's name, and construct the field name. */
3200 context
= read_type (pp
, objfile
);
3204 case 'f': /* $vf -- a virtual function table pointer */
3205 fip
->list
->field
.name
=
3206 obconcat (&objfile
->type_obstack
, vptr_name
, "", "");
3209 case 'b': /* $vb -- a virtual bsomethingorother */
3210 name
= type_name_no_tag (context
);
3213 complain (&invalid_cpp_type_complaint
, symnum
);
3216 fip
->list
->field
.name
=
3217 obconcat (&objfile
->type_obstack
, vb_name
, name
, "");
3221 complain (&invalid_cpp_abbrev_complaint
, *pp
);
3222 fip
->list
->field
.name
=
3223 obconcat (&objfile
->type_obstack
,
3224 "INVALID_CPLUSPLUS_ABBREV", "", "");
3228 /* At this point, *pp points to the ':'. Skip it and read the
3234 complain (&invalid_cpp_abbrev_complaint
, *pp
);
3237 fip
->list
->field
.type
= read_type (pp
, objfile
);
3239 (*pp
)++; /* Skip the comma. */
3245 FIELD_BITPOS (fip
->list
->field
) = read_huge_number (pp
, ';', &nbits
);
3249 /* This field is unpacked. */
3250 FIELD_BITSIZE (fip
->list
->field
) = 0;
3251 fip
->list
->visibility
= VISIBILITY_PRIVATE
;
3255 complain (&invalid_cpp_abbrev_complaint
, *pp
);
3256 /* We have no idea what syntax an unrecognized abbrev would have, so
3257 better return 0. If we returned 1, we would need to at least advance
3258 *pp to avoid an infinite loop. */
3265 read_one_struct_field (fip
, pp
, p
, type
, objfile
)
3266 struct field_info
*fip
;
3270 struct objfile
*objfile
;
3272 /* The following is code to work around cfront generated stabs.
3273 The stabs contains full mangled name for each field.
3274 We try to demangle the name and extract the field name out of it.
3276 if (ARM_DEMANGLING
&& current_subfile
->language
== language_cplus
)
3282 dem
= cplus_demangle (*pp
, DMGL_ANSI
| DMGL_PARAMS
);
3285 dem_p
= strrchr (dem
, ':');
3286 if (dem_p
!= 0 && *(dem_p
-1)==':')
3288 FIELD_NAME (fip
->list
->field
) =
3289 obsavestring (dem_p
, strlen (dem_p
), &objfile
-> type_obstack
);
3293 FIELD_NAME (fip
->list
->field
) =
3294 obsavestring (*pp
, p
- *pp
, &objfile
-> type_obstack
);
3298 /* end of code for cfront work around */
3301 fip
-> list
-> field
.name
=
3302 obsavestring (*pp
, p
- *pp
, &objfile
-> type_obstack
);
3305 /* This means we have a visibility for a field coming. */
3309 fip
-> list
-> visibility
= *(*pp
)++;
3313 /* normal dbx-style format, no explicit visibility */
3314 fip
-> list
-> visibility
= VISIBILITY_PUBLIC
;
3317 fip
-> list
-> field
.type
= read_type (pp
, objfile
);
3322 /* Possible future hook for nested types. */
3325 fip
-> list
-> field
.bitpos
= (long)-2; /* nested type */
3334 /* Static class member. */
3335 SET_FIELD_PHYSNAME (fip
->list
->field
, savestring (*pp
, p
- *pp
));
3339 else if (**pp
!= ',')
3341 /* Bad structure-type format. */
3342 complain (&stabs_general_complaint
, "bad structure-type format");
3346 (*pp
)++; /* Skip the comma. */
3350 FIELD_BITPOS (fip
->list
->field
) = read_huge_number (pp
, ',', &nbits
);
3353 complain (&stabs_general_complaint
, "bad structure-type format");
3356 FIELD_BITSIZE (fip
->list
->field
) = read_huge_number (pp
, ';', &nbits
);
3359 complain (&stabs_general_complaint
, "bad structure-type format");
3364 if (FIELD_BITPOS (fip
->list
->field
) == 0
3365 && FIELD_BITSIZE (fip
->list
->field
) == 0)
3367 /* This can happen in two cases: (1) at least for gcc 2.4.5 or so,
3368 it is a field which has been optimized out. The correct stab for
3369 this case is to use VISIBILITY_IGNORE, but that is a recent
3370 invention. (2) It is a 0-size array. For example
3371 union { int num; char str[0]; } foo. Printing "<no value>" for
3372 str in "p foo" is OK, since foo.str (and thus foo.str[3])
3373 will continue to work, and a 0-size array as a whole doesn't
3374 have any contents to print.
3376 I suspect this probably could also happen with gcc -gstabs (not
3377 -gstabs+) for static fields, and perhaps other C++ extensions.
3378 Hopefully few people use -gstabs with gdb, since it is intended
3379 for dbx compatibility. */
3381 /* Ignore this field. */
3382 fip
-> list
-> visibility
= VISIBILITY_IGNORE
;
3386 /* Detect an unpacked field and mark it as such.
3387 dbx gives a bit size for all fields.
3388 Note that forward refs cannot be packed,
3389 and treat enums as if they had the width of ints. */
3391 if (TYPE_CODE (FIELD_TYPE (fip
->list
->field
)) != TYPE_CODE_INT
3392 && TYPE_CODE (FIELD_TYPE (fip
->list
->field
)) != TYPE_CODE_BOOL
3393 && TYPE_CODE (FIELD_TYPE (fip
->list
->field
)) != TYPE_CODE_ENUM
)
3395 FIELD_BITSIZE (fip
->list
->field
) = 0;
3397 if ((FIELD_BITSIZE (fip
->list
->field
)
3398 == TARGET_CHAR_BIT
* TYPE_LENGTH (FIELD_TYPE (fip
->list
->field
))
3399 || (TYPE_CODE (FIELD_TYPE (fip
->list
->field
)) == TYPE_CODE_ENUM
3400 && FIELD_BITSIZE (fip
->list
->field
) == TARGET_INT_BIT
)
3403 FIELD_BITPOS (fip
->list
->field
) % 8 == 0)
3405 FIELD_BITSIZE (fip
->list
->field
) = 0;
3411 /* Read struct or class data fields. They have the form:
3413 NAME : [VISIBILITY] TYPENUM , BITPOS , BITSIZE ;
3415 At the end, we see a semicolon instead of a field.
3417 In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
3420 The optional VISIBILITY is one of:
3422 '/0' (VISIBILITY_PRIVATE)
3423 '/1' (VISIBILITY_PROTECTED)
3424 '/2' (VISIBILITY_PUBLIC)
3425 '/9' (VISIBILITY_IGNORE)
3427 or nothing, for C style fields with public visibility.
3429 Returns 1 for success, 0 for failure. */
3432 read_struct_fields (fip
, pp
, type
, objfile
)
3433 struct field_info
*fip
;
3436 struct objfile
*objfile
;
3439 struct nextfield
*new;
3441 /* We better set p right now, in case there are no fields at all... */
3445 /* Read each data member type until we find the terminating ';' at the end of
3446 the data member list, or break for some other reason such as finding the
3447 start of the member function list. */
3451 if (os9k_stabs
&& **pp
== ',') break;
3452 STABS_CONTINUE (pp
, objfile
);
3453 /* Get space to record the next field's data. */
3454 new = (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
3455 make_cleanup (free
, new);
3456 memset (new, 0, sizeof (struct nextfield
));
3457 new -> next
= fip
-> list
;
3460 /* Get the field name. */
3463 /* If is starts with CPLUS_MARKER it is a special abbreviation,
3464 unless the CPLUS_MARKER is followed by an underscore, in
3465 which case it is just the name of an anonymous type, which we
3466 should handle like any other type name. */
3468 if (is_cplus_marker (p
[0]) && p
[1] != '_')
3470 if (!read_cpp_abbrev (fip
, pp
, type
, objfile
))
3475 /* Look for the ':' that separates the field name from the field
3476 values. Data members are delimited by a single ':', while member
3477 functions are delimited by a pair of ':'s. When we hit the member
3478 functions (if any), terminate scan loop and return. */
3480 while (*p
!= ':' && *p
!= '\0')
3487 /* Check to see if we have hit the member functions yet. */
3492 read_one_struct_field (fip
, pp
, p
, type
, objfile
);
3494 if (p
[0] == ':' && p
[1] == ':')
3496 /* chill the list of fields: the last entry (at the head) is a
3497 partially constructed entry which we now scrub. */
3498 fip
-> list
= fip
-> list
-> next
;
3503 /* The stabs for C++ derived classes contain baseclass information which
3504 is marked by a '!' character after the total size. This function is
3505 called when we encounter the baseclass marker, and slurps up all the
3506 baseclass information.
3508 Immediately following the '!' marker is the number of base classes that
3509 the class is derived from, followed by information for each base class.
3510 For each base class, there are two visibility specifiers, a bit offset
3511 to the base class information within the derived class, a reference to
3512 the type for the base class, and a terminating semicolon.
3514 A typical example, with two base classes, would be "!2,020,19;0264,21;".
3516 Baseclass information marker __________________|| | | | | | |
3517 Number of baseclasses __________________________| | | | | | |
3518 Visibility specifiers (2) ________________________| | | | | |
3519 Offset in bits from start of class _________________| | | | |
3520 Type number for base class ___________________________| | | |
3521 Visibility specifiers (2) _______________________________| | |
3522 Offset in bits from start of class ________________________| |
3523 Type number of base class ____________________________________|
3525 Return 1 for success, 0 for (error-type-inducing) failure. */
3528 read_baseclasses (fip
, pp
, type
, objfile
)
3529 struct field_info
*fip
;
3532 struct objfile
*objfile
;
3535 struct nextfield
*new;
3543 /* Skip the '!' baseclass information marker. */
3547 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3550 TYPE_N_BASECLASSES (type
) = read_huge_number (pp
, ',', &nbits
);
3556 /* Some stupid compilers have trouble with the following, so break
3557 it up into simpler expressions. */
3558 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*)
3559 TYPE_ALLOC (type
, B_BYTES (TYPE_N_BASECLASSES (type
)));
3562 int num_bytes
= B_BYTES (TYPE_N_BASECLASSES (type
));
3565 pointer
= (char *) TYPE_ALLOC (type
, num_bytes
);
3566 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*) pointer
;
3570 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), TYPE_N_BASECLASSES (type
));
3572 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
3574 new = (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
3575 make_cleanup (free
, new);
3576 memset (new, 0, sizeof (struct nextfield
));
3577 new -> next
= fip
-> list
;
3579 FIELD_BITSIZE (new->field
) = 0; /* this should be an unpacked field! */
3581 STABS_CONTINUE (pp
, objfile
);
3585 /* Nothing to do. */
3588 SET_TYPE_FIELD_VIRTUAL (type
, i
);
3591 /* Unknown character. Complain and treat it as non-virtual. */
3593 static struct complaint msg
= {
3594 "Unknown virtual character `%c' for baseclass", 0, 0};
3595 complain (&msg
, **pp
);
3600 new -> visibility
= *(*pp
)++;
3601 switch (new -> visibility
)
3603 case VISIBILITY_PRIVATE
:
3604 case VISIBILITY_PROTECTED
:
3605 case VISIBILITY_PUBLIC
:
3608 /* Bad visibility format. Complain and treat it as
3611 static struct complaint msg
= {
3612 "Unknown visibility `%c' for baseclass", 0, 0};
3613 complain (&msg
, new -> visibility
);
3614 new -> visibility
= VISIBILITY_PUBLIC
;
3621 /* The remaining value is the bit offset of the portion of the object
3622 corresponding to this baseclass. Always zero in the absence of
3623 multiple inheritance. */
3625 FIELD_BITPOS (new->field
) = read_huge_number (pp
, ',', &nbits
);
3630 /* The last piece of baseclass information is the type of the
3631 base class. Read it, and remember it's type name as this
3634 new -> field
.type
= read_type (pp
, objfile
);
3635 new -> field
.name
= type_name_no_tag (new -> field
.type
);
3637 /* skip trailing ';' and bump count of number of fields seen */
3646 /* The tail end of stabs for C++ classes that contain a virtual function
3647 pointer contains a tilde, a %, and a type number.
3648 The type number refers to the base class (possibly this class itself) which
3649 contains the vtable pointer for the current class.
3651 This function is called when we have parsed all the method declarations,
3652 so we can look for the vptr base class info. */
3655 read_tilde_fields (fip
, pp
, type
, objfile
)
3656 struct field_info
*fip
;
3659 struct objfile
*objfile
;
3663 STABS_CONTINUE (pp
, objfile
);
3665 /* If we are positioned at a ';', then skip it. */
3675 if (**pp
== '=' || **pp
== '+' || **pp
== '-')
3677 /* Obsolete flags that used to indicate the presence
3678 of constructors and/or destructors. */
3682 /* Read either a '%' or the final ';'. */
3683 if (*(*pp
)++ == '%')
3685 /* The next number is the type number of the base class
3686 (possibly our own class) which supplies the vtable for
3687 this class. Parse it out, and search that class to find
3688 its vtable pointer, and install those into TYPE_VPTR_BASETYPE
3689 and TYPE_VPTR_FIELDNO. */
3694 t
= read_type (pp
, objfile
);
3696 while (*p
!= '\0' && *p
!= ';')
3702 /* Premature end of symbol. */
3706 TYPE_VPTR_BASETYPE (type
) = t
;
3707 if (type
== t
) /* Our own class provides vtbl ptr */
3709 for (i
= TYPE_NFIELDS (t
) - 1;
3710 i
>= TYPE_N_BASECLASSES (t
);
3713 if (! strncmp (TYPE_FIELD_NAME (t
, i
), vptr_name
,
3714 sizeof (vptr_name
) - 1))
3716 TYPE_VPTR_FIELDNO (type
) = i
;
3720 /* Virtual function table field not found. */
3721 complain (&vtbl_notfound_complaint
, TYPE_NAME (type
));
3726 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
3737 attach_fn_fields_to_type (fip
, type
)
3738 struct field_info
*fip
;
3739 register struct type
*type
;
3743 for (n
= TYPE_NFN_FIELDS (type
);
3744 fip
-> fnlist
!= NULL
;
3745 fip
-> fnlist
= fip
-> fnlist
-> next
)
3747 --n
; /* Circumvent Sun3 compiler bug */
3748 TYPE_FN_FIELDLISTS (type
)[n
] = fip
-> fnlist
-> fn_fieldlist
;
3753 /* read cfront class static data.
3754 pp points to string starting with the list of static data
3755 eg: A:ZcA;1@Bpub v2@Bvirpri;__ct__1AFv func__1AFv *sfunc__1AFv ;as__1A ;;
3758 A:ZcA;;foopri__1AFv foopro__1AFv __ct__1AFv __ct__1AFRC1A foopub__1AFv ;;;
3763 read_cfront_static_fields (fip
, pp
, type
, objfile
)
3764 struct field_info
*fip
;
3767 struct objfile
*objfile
;
3769 struct nextfield
* new;
3772 struct symbol
* ref_static
=0;
3774 if (**pp
==';') /* no static data; return */
3780 /* Process each field in the list until we find the terminating ";" */
3782 /* eg: p = "as__1A ;;;" */
3783 STABS_CONTINUE (pp
, objfile
); /* handle \\ */
3784 while (**pp
!=';' && (sname
= get_substring (pp
, ' '), sname
))
3786 ref_static
= lookup_symbol (sname
, 0, VAR_NAMESPACE
, 0, 0); /*demangled_name*/
3789 static struct complaint msg
= {"\
3790 Unable to find symbol for static data field %s\n",
3792 complain (&msg
, sname
);
3795 stype
= SYMBOL_TYPE(ref_static
);
3797 /* allocate a new fip */
3798 new = (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
3799 make_cleanup (free
, new);
3800 memset (new, 0, sizeof (struct nextfield
));
3801 new -> next
= fip
-> list
;
3804 /* set visibility */
3805 /* FIXME! no way to tell visibility from stabs??? */
3806 new -> visibility
= VISIBILITY_PUBLIC
;
3808 /* set field info into fip */
3809 fip
-> list
-> field
.type
= stype
;
3811 /* set bitpos & bitsize */
3812 SET_FIELD_PHYSNAME (fip
->list
->field
, savestring (sname
, strlen (sname
)));
3814 /* set name field */
3815 /* The following is code to work around cfront generated stabs.
3816 The stabs contains full mangled name for each field.
3817 We try to demangle the name and extract the field name out of it.
3822 dem
= cplus_demangle (sname
, DMGL_ANSI
| DMGL_PARAMS
);
3825 dem_p
= strrchr (dem
, ':');
3826 if (dem_p
!= 0 && *(dem_p
-1)==':')
3828 fip
->list
->field
.name
=
3829 obsavestring (dem_p
, strlen (dem_p
), &objfile
-> type_obstack
);
3833 fip
->list
->field
.name
=
3834 obsavestring (sname
, strlen (sname
), &objfile
-> type_obstack
);
3836 } /* end of code for cfront work around */
3837 } /* loop again for next static field */
3841 /* Copy structure fields to fip so attach_fields_to_type will work.
3842 type has already been created with the initial instance data fields.
3843 Now we want to be able to add the other members to the class,
3844 so we want to add them back to the fip and reattach them again
3845 once we have collected all the class members. */
3848 copy_cfront_struct_fields (fip
, type
, objfile
)
3849 struct field_info
*fip
;
3851 struct objfile
*objfile
;
3853 int nfields
= TYPE_NFIELDS(type
);
3855 struct nextfield
* new;
3857 /* Copy the fields into the list of fips and reset the types
3858 to remove the old fields */
3860 for (i
=0; i
<nfields
; i
++)
3862 /* allocate a new fip */
3863 new = (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
3864 make_cleanup (free
, new);
3865 memset (new, 0, sizeof (struct nextfield
));
3866 new -> next
= fip
-> list
;
3869 /* copy field info into fip */
3870 new -> field
= TYPE_FIELD (type
, i
);
3871 /* set visibility */
3872 if (TYPE_FIELD_PROTECTED (type
, i
))
3873 new -> visibility
= VISIBILITY_PROTECTED
;
3874 else if (TYPE_FIELD_PRIVATE (type
, i
))
3875 new -> visibility
= VISIBILITY_PRIVATE
;
3877 new -> visibility
= VISIBILITY_PUBLIC
;
3879 /* Now delete the fields from the type since we will be
3880 allocing new space once we get the rest of the fields
3881 in attach_fields_to_type.
3882 The pointer TYPE_FIELDS(type) is left dangling but should
3883 be freed later by objstack_free */
3884 TYPE_FIELDS (type
)=0;
3885 TYPE_NFIELDS (type
) = 0;
3890 /* Create the vector of fields, and record how big it is.
3891 We need this info to record proper virtual function table information
3892 for this class's virtual functions. */
3895 attach_fields_to_type (fip
, type
, objfile
)
3896 struct field_info
*fip
;
3897 register struct type
*type
;
3898 struct objfile
*objfile
;
3900 register int nfields
= 0;
3901 register int non_public_fields
= 0;
3902 register struct nextfield
*scan
;
3904 /* Count up the number of fields that we have, as well as taking note of
3905 whether or not there are any non-public fields, which requires us to
3906 allocate and build the private_field_bits and protected_field_bits
3909 for (scan
= fip
-> list
; scan
!= NULL
; scan
= scan
-> next
)
3912 if (scan
-> visibility
!= VISIBILITY_PUBLIC
)
3914 non_public_fields
++;
3918 /* Now we know how many fields there are, and whether or not there are any
3919 non-public fields. Record the field count, allocate space for the
3920 array of fields, and create blank visibility bitfields if necessary. */
3922 TYPE_NFIELDS (type
) = nfields
;
3923 TYPE_FIELDS (type
) = (struct field
*)
3924 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
3925 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
3927 if (non_public_fields
)
3929 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3931 TYPE_FIELD_PRIVATE_BITS (type
) =
3932 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3933 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
3935 TYPE_FIELD_PROTECTED_BITS (type
) =
3936 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3937 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
3939 TYPE_FIELD_IGNORE_BITS (type
) =
3940 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3941 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
3944 /* Copy the saved-up fields into the field vector. Start from the head
3945 of the list, adding to the tail of the field array, so that they end
3946 up in the same order in the array in which they were added to the list. */
3948 while (nfields
-- > 0)
3950 TYPE_FIELD (type
, nfields
) = fip
-> list
-> field
;
3951 switch (fip
-> list
-> visibility
)
3953 case VISIBILITY_PRIVATE
:
3954 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
3957 case VISIBILITY_PROTECTED
:
3958 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
3961 case VISIBILITY_IGNORE
:
3962 SET_TYPE_FIELD_IGNORE (type
, nfields
);
3965 case VISIBILITY_PUBLIC
:
3969 /* Unknown visibility. Complain and treat it as public. */
3971 static struct complaint msg
= {
3972 "Unknown visibility `%c' for field", 0, 0};
3973 complain (&msg
, fip
-> list
-> visibility
);
3977 fip
-> list
= fip
-> list
-> next
;
3982 /* Read the description of a structure (or union type) and return an object
3983 describing the type.
3985 PP points to a character pointer that points to the next unconsumed token
3986 in the the stabs string. For example, given stabs "A:T4=s4a:1,0,32;;",
3987 *PP will point to "4a:1,0,32;;".
3989 TYPE points to an incomplete type that needs to be filled in.
3991 OBJFILE points to the current objfile from which the stabs information is
3992 being read. (Note that it is redundant in that TYPE also contains a pointer
3993 to this same objfile, so it might be a good idea to eliminate it. FIXME).
3996 static struct type
*
3997 read_struct_type (pp
, type
, objfile
)
4000 struct objfile
*objfile
;
4002 struct cleanup
*back_to
;
4003 struct field_info fi
;
4008 back_to
= make_cleanup (null_cleanup
, 0);
4010 INIT_CPLUS_SPECIFIC (type
);
4011 TYPE_FLAGS (type
) &= ~TYPE_FLAG_STUB
;
4013 /* First comes the total size in bytes. */
4017 TYPE_LENGTH (type
) = read_huge_number (pp
, 0, &nbits
);
4019 return error_type (pp
, objfile
);
4022 /* Now read the baseclasses, if any, read the regular C struct or C++
4023 class member fields, attach the fields to the type, read the C++
4024 member functions, attach them to the type, and then read any tilde
4025 field (baseclass specifier for the class holding the main vtable). */
4027 if (!read_baseclasses (&fi
, pp
, type
, objfile
)
4028 || !read_struct_fields (&fi
, pp
, type
, objfile
)
4029 || !attach_fields_to_type (&fi
, type
, objfile
)
4030 || !read_member_functions (&fi
, pp
, type
, objfile
)
4031 || !attach_fn_fields_to_type (&fi
, type
)
4032 || !read_tilde_fields (&fi
, pp
, type
, objfile
))
4034 type
= error_type (pp
, objfile
);
4037 do_cleanups (back_to
);
4041 /* Read a definition of an array type,
4042 and create and return a suitable type object.
4043 Also creates a range type which represents the bounds of that
4046 static struct type
*
4047 read_array_type (pp
, type
, objfile
)
4049 register struct type
*type
;
4050 struct objfile
*objfile
;
4052 struct type
*index_type
, *element_type
, *range_type
;
4057 /* Format of an array type:
4058 "ar<index type>;lower;upper;<array_contents_type>".
4059 OS9000: "arlower,upper;<array_contents_type>".
4061 Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
4062 for these, produce a type like float[][]. */
4065 index_type
= builtin_type_int
;
4068 index_type
= read_type (pp
, objfile
);
4070 /* Improper format of array type decl. */
4071 return error_type (pp
, objfile
);
4075 if (!(**pp
>= '0' && **pp
<= '9') && **pp
!= '-')
4080 lower
= read_huge_number (pp
, os9k_stabs
? ',' : ';', &nbits
);
4082 return error_type (pp
, objfile
);
4084 if (!(**pp
>= '0' && **pp
<= '9') && **pp
!= '-')
4089 upper
= read_huge_number (pp
, ';', &nbits
);
4091 return error_type (pp
, objfile
);
4093 element_type
= read_type (pp
, objfile
);
4102 create_range_type ((struct type
*) NULL
, index_type
, lower
, upper
);
4103 type
= create_array_type (type
, element_type
, range_type
);
4109 /* Read a definition of an enumeration type,
4110 and create and return a suitable type object.
4111 Also defines the symbols that represent the values of the type. */
4113 static struct type
*
4114 read_enum_type (pp
, type
, objfile
)
4116 register struct type
*type
;
4117 struct objfile
*objfile
;
4122 register struct symbol
*sym
;
4124 struct pending
**symlist
;
4125 struct pending
*osyms
, *syms
;
4128 int unsigned_enum
= 1;
4131 /* FIXME! The stabs produced by Sun CC merrily define things that ought
4132 to be file-scope, between N_FN entries, using N_LSYM. What's a mother
4133 to do? For now, force all enum values to file scope. */
4134 if (within_function
)
4135 symlist
= &local_symbols
;
4138 symlist
= &file_symbols
;
4140 o_nsyms
= osyms
? osyms
->nsyms
: 0;
4144 /* Size. Perhaps this does not have to be conditionalized on
4145 os9k_stabs (assuming the name of an enum constant can't start
4147 read_huge_number (pp
, 0, &nbits
);
4149 return error_type (pp
, objfile
);
4152 /* The aix4 compiler emits an extra field before the enum members;
4153 my guess is it's a type of some sort. Just ignore it. */
4156 /* Skip over the type. */
4160 /* Skip over the colon. */
4164 /* Read the value-names and their values.
4165 The input syntax is NAME:VALUE,NAME:VALUE, and so on.
4166 A semicolon or comma instead of a NAME means the end. */
4167 while (**pp
&& **pp
!= ';' && **pp
!= ',')
4169 STABS_CONTINUE (pp
, objfile
);
4171 while (*p
!= ':') p
++;
4172 name
= obsavestring (*pp
, p
- *pp
, &objfile
-> symbol_obstack
);
4174 n
= read_huge_number (pp
, ',', &nbits
);
4176 return error_type (pp
, objfile
);
4178 sym
= (struct symbol
*)
4179 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
4180 memset (sym
, 0, sizeof (struct symbol
));
4181 SYMBOL_NAME (sym
) = name
;
4182 SYMBOL_LANGUAGE (sym
) = current_subfile
-> language
;
4183 SYMBOL_CLASS (sym
) = LOC_CONST
;
4184 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
4185 SYMBOL_VALUE (sym
) = n
;
4188 add_symbol_to_list (sym
, symlist
);
4193 (*pp
)++; /* Skip the semicolon. */
4195 /* Now fill in the fields of the type-structure. */
4197 TYPE_LENGTH (type
) = TARGET_INT_BIT
/ HOST_CHAR_BIT
;
4198 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
4199 TYPE_FLAGS (type
) &= ~TYPE_FLAG_STUB
;
4201 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
4202 TYPE_NFIELDS (type
) = nsyms
;
4203 TYPE_FIELDS (type
) = (struct field
*)
4204 TYPE_ALLOC (type
, sizeof (struct field
) * nsyms
);
4205 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nsyms
);
4207 /* Find the symbols for the values and put them into the type.
4208 The symbols can be found in the symlist that we put them on
4209 to cause them to be defined. osyms contains the old value
4210 of that symlist; everything up to there was defined by us. */
4211 /* Note that we preserve the order of the enum constants, so
4212 that in something like "enum {FOO, LAST_THING=FOO}" we print
4213 FOO, not LAST_THING. */
4215 for (syms
= *symlist
, n
= nsyms
- 1; syms
; syms
= syms
->next
)
4217 int last
= syms
== osyms
? o_nsyms
: 0;
4218 int j
= syms
->nsyms
;
4219 for (; --j
>= last
; --n
)
4221 struct symbol
*xsym
= syms
->symbol
[j
];
4222 SYMBOL_TYPE (xsym
) = type
;
4223 TYPE_FIELD_NAME (type
, n
) = SYMBOL_NAME (xsym
);
4224 TYPE_FIELD_BITPOS (type
, n
) = SYMBOL_VALUE (xsym
);
4225 TYPE_FIELD_BITSIZE (type
, n
) = 0;
4234 /* Sun's ACC uses a somewhat saner method for specifying the builtin
4235 typedefs in every file (for int, long, etc):
4237 type = b <signed> <width>; <offset>; <nbits>
4238 signed = u or s. Possible c in addition to u or s (for char?).
4239 offset = offset from high order bit to start bit of type.
4240 width is # bytes in object of this type, nbits is # bits in type.
4242 The width/offset stuff appears to be for small objects stored in
4243 larger ones (e.g. `shorts' in `int' registers). We ignore it for now,
4246 static struct type
*
4247 read_sun_builtin_type (pp
, typenums
, objfile
)
4250 struct objfile
*objfile
;
4265 return error_type (pp
, objfile
);
4269 /* For some odd reason, all forms of char put a c here. This is strange
4270 because no other type has this honor. We can safely ignore this because
4271 we actually determine 'char'acterness by the number of bits specified in
4277 /* The first number appears to be the number of bytes occupied
4278 by this type, except that unsigned short is 4 instead of 2.
4279 Since this information is redundant with the third number,
4280 we will ignore it. */
4281 read_huge_number (pp
, ';', &nbits
);
4283 return error_type (pp
, objfile
);
4285 /* The second number is always 0, so ignore it too. */
4286 read_huge_number (pp
, ';', &nbits
);
4288 return error_type (pp
, objfile
);
4290 /* The third number is the number of bits for this type. */
4291 type_bits
= read_huge_number (pp
, 0, &nbits
);
4293 return error_type (pp
, objfile
);
4294 /* The type *should* end with a semicolon. If it are embedded
4295 in a larger type the semicolon may be the only way to know where
4296 the type ends. If this type is at the end of the stabstring we
4297 can deal with the omitted semicolon (but we don't have to like
4298 it). Don't bother to complain(), Sun's compiler omits the semicolon
4304 return init_type (TYPE_CODE_VOID
, 1,
4305 signed_type
? 0 : TYPE_FLAG_UNSIGNED
, (char *)NULL
,
4308 return init_type (TYPE_CODE_INT
,
4309 type_bits
/ TARGET_CHAR_BIT
,
4310 signed_type
? 0 : TYPE_FLAG_UNSIGNED
, (char *)NULL
,
4314 static struct type
*
4315 read_sun_floating_type (pp
, typenums
, objfile
)
4318 struct objfile
*objfile
;
4324 /* The first number has more details about the type, for example
4326 details
= read_huge_number (pp
, ';', &nbits
);
4328 return error_type (pp
, objfile
);
4330 /* The second number is the number of bytes occupied by this type */
4331 nbytes
= read_huge_number (pp
, ';', &nbits
);
4333 return error_type (pp
, objfile
);
4335 if (details
== NF_COMPLEX
|| details
== NF_COMPLEX16
4336 || details
== NF_COMPLEX32
)
4337 /* This is a type we can't handle, but we do know the size.
4338 We also will be able to give it a name. */
4339 return init_type (TYPE_CODE_ERROR
, nbytes
, 0, NULL
, objfile
);
4341 return init_type (TYPE_CODE_FLT
, nbytes
, 0, NULL
, objfile
);
4344 /* Read a number from the string pointed to by *PP.
4345 The value of *PP is advanced over the number.
4346 If END is nonzero, the character that ends the
4347 number must match END, or an error happens;
4348 and that character is skipped if it does match.
4349 If END is zero, *PP is left pointing to that character.
4351 If the number fits in a long, set *BITS to 0 and return the value.
4352 If not, set *BITS to be the number of bits in the number and return 0.
4354 If encounter garbage, set *BITS to -1 and return 0. */
4357 read_huge_number (pp
, end
, bits
)
4377 /* Leading zero means octal. GCC uses this to output values larger
4378 than an int (because that would be hard in decimal). */
4386 upper_limit
= ULONG_MAX
/ radix
;
4388 upper_limit
= LONG_MAX
/ radix
;
4390 while ((c
= *p
++) >= '0' && c
< ('0' + radix
))
4392 if (n
<= upper_limit
)
4395 n
+= c
- '0'; /* FIXME this overflows anyway */
4400 /* This depends on large values being output in octal, which is
4407 /* Ignore leading zeroes. */
4411 else if (c
== '2' || c
== '3')
4437 /* Large decimal constants are an error (because it is hard to
4438 count how many bits are in them). */
4444 /* -0x7f is the same as 0x80. So deal with it by adding one to
4445 the number of bits. */
4457 /* It's *BITS which has the interesting information. */
4461 static struct type
*
4462 read_range_type (pp
, typenums
, objfile
)
4465 struct objfile
*objfile
;
4467 char *orig_pp
= *pp
;
4472 struct type
*result_type
;
4473 struct type
*index_type
= NULL
;
4475 /* First comes a type we are a subrange of.
4476 In C it is usually 0, 1 or the type being defined. */
4477 if (read_type_number (pp
, rangenums
) != 0)
4478 return error_type (pp
, objfile
);
4479 self_subrange
= (rangenums
[0] == typenums
[0] &&
4480 rangenums
[1] == typenums
[1]);
4485 index_type
= read_type (pp
, objfile
);
4488 /* A semicolon should now follow; skip it. */
4492 /* The remaining two operands are usually lower and upper bounds
4493 of the range. But in some special cases they mean something else. */
4494 n2
= read_huge_number (pp
, ';', &n2bits
);
4495 n3
= read_huge_number (pp
, ';', &n3bits
);
4497 if (n2bits
== -1 || n3bits
== -1)
4498 return error_type (pp
, objfile
);
4501 goto handle_true_range
;
4503 /* If limits are huge, must be large integral type. */
4504 if (n2bits
!= 0 || n3bits
!= 0)
4506 char got_signed
= 0;
4507 char got_unsigned
= 0;
4508 /* Number of bits in the type. */
4511 /* Range from 0 to <large number> is an unsigned large integral type. */
4512 if ((n2bits
== 0 && n2
== 0) && n3bits
!= 0)
4517 /* Range from <large number> to <large number>-1 is a large signed
4518 integral type. Take care of the case where <large number> doesn't
4519 fit in a long but <large number>-1 does. */
4520 else if ((n2bits
!= 0 && n3bits
!= 0 && n2bits
== n3bits
+ 1)
4521 || (n2bits
!= 0 && n3bits
== 0
4522 && (n2bits
== sizeof (long) * HOST_CHAR_BIT
)
4529 if (got_signed
|| got_unsigned
)
4531 return init_type (TYPE_CODE_INT
, nbits
/ TARGET_CHAR_BIT
,
4532 got_unsigned
? TYPE_FLAG_UNSIGNED
: 0, NULL
,
4536 return error_type (pp
, objfile
);
4539 /* A type defined as a subrange of itself, with bounds both 0, is void. */
4540 if (self_subrange
&& n2
== 0 && n3
== 0)
4541 return init_type (TYPE_CODE_VOID
, 1, 0, NULL
, objfile
);
4543 /* If n3 is zero and n2 is positive, we want a floating type,
4544 and n2 is the width in bytes.
4546 Fortran programs appear to use this for complex types also,
4547 and they give no way to distinguish between double and single-complex!
4549 GDB does not have complex types.
4551 Just return the complex as a float of that size. It won't work right
4552 for the complex values, but at least it makes the file loadable. */
4554 if (n3
== 0 && n2
> 0)
4556 return init_type (TYPE_CODE_FLT
, n2
, 0, NULL
, objfile
);
4559 /* If the upper bound is -1, it must really be an unsigned int. */
4561 else if (n2
== 0 && n3
== -1)
4563 /* It is unsigned int or unsigned long. */
4564 /* GCC 2.3.3 uses this for long long too, but that is just a GDB 3.5
4565 compatibility hack. */
4566 return init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
4567 TYPE_FLAG_UNSIGNED
, NULL
, objfile
);
4570 /* Special case: char is defined (Who knows why) as a subrange of
4571 itself with range 0-127. */
4572 else if (self_subrange
&& n2
== 0 && n3
== 127)
4573 return init_type (TYPE_CODE_INT
, 1, 0, NULL
, objfile
);
4575 else if (current_symbol
&& SYMBOL_LANGUAGE (current_symbol
) == language_chill
4577 goto handle_true_range
;
4579 /* We used to do this only for subrange of self or subrange of int. */
4583 /* n3 actually gives the size. */
4584 return init_type (TYPE_CODE_INT
, - n3
, TYPE_FLAG_UNSIGNED
,
4587 return init_type (TYPE_CODE_INT
, 1, TYPE_FLAG_UNSIGNED
, NULL
, objfile
);
4589 return init_type (TYPE_CODE_INT
, 2, TYPE_FLAG_UNSIGNED
, NULL
, objfile
);
4591 /* -1 is used for the upper bound of (4 byte) "unsigned int" and
4592 "unsigned long", and we already checked for that,
4593 so don't need to test for it here. */
4595 /* I think this is for Convex "long long". Since I don't know whether
4596 Convex sets self_subrange, I also accept that particular size regardless
4597 of self_subrange. */
4598 else if (n3
== 0 && n2
< 0
4600 || n2
== - TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
))
4601 return init_type (TYPE_CODE_INT
, - n2
, 0, NULL
, objfile
);
4602 else if (n2
== -n3
-1)
4605 return init_type (TYPE_CODE_INT
, 1, 0, NULL
, objfile
);
4607 return init_type (TYPE_CODE_INT
, 2, 0, NULL
, objfile
);
4608 if (n3
== 0x7fffffff)
4609 return init_type (TYPE_CODE_INT
, 4, 0, NULL
, objfile
);
4612 /* We have a real range type on our hands. Allocate space and
4613 return a real pointer. */
4617 index_type
= builtin_type_int
;
4619 index_type
= *dbx_lookup_type (rangenums
);
4620 if (index_type
== NULL
)
4622 /* Does this actually ever happen? Is that why we are worrying
4623 about dealing with it rather than just calling error_type? */
4625 static struct type
*range_type_index
;
4627 complain (&range_type_base_complaint
, rangenums
[1]);
4628 if (range_type_index
== NULL
)
4630 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
4631 0, "range type index type", NULL
);
4632 index_type
= range_type_index
;
4635 result_type
= create_range_type ((struct type
*) NULL
, index_type
, n2
, n3
);
4636 return (result_type
);
4639 /* Read in an argument list. This is a list of types, separated by commas
4640 and terminated with END. Return the list of types read in, or (struct type
4641 **)-1 if there is an error. */
4643 static struct type
**
4644 read_args (pp
, end
, objfile
)
4647 struct objfile
*objfile
;
4649 /* FIXME! Remove this arbitrary limit! */
4650 struct type
*types
[1024], **rval
; /* allow for fns of 1023 parameters */
4656 /* Invalid argument list: no ','. */
4657 return (struct type
**)-1;
4659 STABS_CONTINUE (pp
, objfile
);
4660 types
[n
++] = read_type (pp
, objfile
);
4662 (*pp
)++; /* get past `end' (the ':' character) */
4666 rval
= (struct type
**) xmalloc (2 * sizeof (struct type
*));
4668 else if (TYPE_CODE (types
[n
-1]) != TYPE_CODE_VOID
)
4670 rval
= (struct type
**) xmalloc ((n
+ 1) * sizeof (struct type
*));
4671 memset (rval
+ n
, 0, sizeof (struct type
*));
4675 rval
= (struct type
**) xmalloc (n
* sizeof (struct type
*));
4677 memcpy (rval
, types
, n
* sizeof (struct type
*));
4681 /* Common block handling. */
4683 /* List of symbols declared since the last BCOMM. This list is a tail
4684 of local_symbols. When ECOMM is seen, the symbols on the list
4685 are noted so their proper addresses can be filled in later,
4686 using the common block base address gotten from the assembler
4689 static struct pending
*common_block
;
4690 static int common_block_i
;
4692 /* Name of the current common block. We get it from the BCOMM instead of the
4693 ECOMM to match IBM documentation (even though IBM puts the name both places
4694 like everyone else). */
4695 static char *common_block_name
;
4697 /* Process a N_BCOMM symbol. The storage for NAME is not guaranteed
4698 to remain after this function returns. */
4701 common_block_start (name
, objfile
)
4703 struct objfile
*objfile
;
4705 if (common_block_name
!= NULL
)
4707 static struct complaint msg
= {
4708 "Invalid symbol data: common block within common block",
4712 common_block
= local_symbols
;
4713 common_block_i
= local_symbols
? local_symbols
->nsyms
: 0;
4714 common_block_name
= obsavestring (name
, strlen (name
),
4715 &objfile
-> symbol_obstack
);
4718 /* Process a N_ECOMM symbol. */
4721 common_block_end (objfile
)
4722 struct objfile
*objfile
;
4724 /* Symbols declared since the BCOMM are to have the common block
4725 start address added in when we know it. common_block and
4726 common_block_i point to the first symbol after the BCOMM in
4727 the local_symbols list; copy the list and hang it off the
4728 symbol for the common block name for later fixup. */
4731 struct pending
*new = 0;
4732 struct pending
*next
;
4735 if (common_block_name
== NULL
)
4737 static struct complaint msg
= {"ECOMM symbol unmatched by BCOMM", 0, 0};
4742 sym
= (struct symbol
*)
4743 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
4744 memset (sym
, 0, sizeof (struct symbol
));
4745 /* Note: common_block_name already saved on symbol_obstack */
4746 SYMBOL_NAME (sym
) = common_block_name
;
4747 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
4749 /* Now we copy all the symbols which have been defined since the BCOMM. */
4751 /* Copy all the struct pendings before common_block. */
4752 for (next
= local_symbols
;
4753 next
!= NULL
&& next
!= common_block
;
4756 for (j
= 0; j
< next
->nsyms
; j
++)
4757 add_symbol_to_list (next
->symbol
[j
], &new);
4760 /* Copy however much of COMMON_BLOCK we need. If COMMON_BLOCK is
4761 NULL, it means copy all the local symbols (which we already did
4764 if (common_block
!= NULL
)
4765 for (j
= common_block_i
; j
< common_block
->nsyms
; j
++)
4766 add_symbol_to_list (common_block
->symbol
[j
], &new);
4768 SYMBOL_TYPE (sym
) = (struct type
*) new;
4770 /* Should we be putting local_symbols back to what it was?
4773 i
= hashname (SYMBOL_NAME (sym
));
4774 SYMBOL_VALUE_CHAIN (sym
) = global_sym_chain
[i
];
4775 global_sym_chain
[i
] = sym
;
4776 common_block_name
= NULL
;
4779 /* Add a common block's start address to the offset of each symbol
4780 declared to be in it (by being between a BCOMM/ECOMM pair that uses
4781 the common block name). */
4784 fix_common_block (sym
, valu
)
4788 struct pending
*next
= (struct pending
*) SYMBOL_TYPE (sym
);
4789 for ( ; next
; next
= next
->next
)
4792 for (j
= next
->nsyms
- 1; j
>= 0; j
--)
4793 SYMBOL_VALUE_ADDRESS (next
->symbol
[j
]) += valu
;
4799 /* What about types defined as forward references inside of a small lexical
4801 /* Add a type to the list of undefined types to be checked through
4802 once this file has been read in. */
4805 add_undefined_type (type
)
4808 if (undef_types_length
== undef_types_allocated
)
4810 undef_types_allocated
*= 2;
4811 undef_types
= (struct type
**)
4812 xrealloc ((char *) undef_types
,
4813 undef_types_allocated
* sizeof (struct type
*));
4815 undef_types
[undef_types_length
++] = type
;
4818 /* Go through each undefined type, see if it's still undefined, and fix it
4819 up if possible. We have two kinds of undefined types:
4821 TYPE_CODE_ARRAY: Array whose target type wasn't defined yet.
4822 Fix: update array length using the element bounds
4823 and the target type's length.
4824 TYPE_CODE_STRUCT, TYPE_CODE_UNION: Structure whose fields were not
4825 yet defined at the time a pointer to it was made.
4826 Fix: Do a full lookup on the struct/union tag. */
4828 cleanup_undefined_types ()
4832 for (type
= undef_types
; type
< undef_types
+ undef_types_length
; type
++)
4834 switch (TYPE_CODE (*type
))
4837 case TYPE_CODE_STRUCT
:
4838 case TYPE_CODE_UNION
:
4839 case TYPE_CODE_ENUM
:
4841 /* Check if it has been defined since. Need to do this here
4842 as well as in check_typedef to deal with the (legitimate in
4843 C though not C++) case of several types with the same name
4844 in different source files. */
4845 if (TYPE_FLAGS (*type
) & TYPE_FLAG_STUB
)
4847 struct pending
*ppt
;
4849 /* Name of the type, without "struct" or "union" */
4850 char *typename
= TYPE_TAG_NAME (*type
);
4852 if (typename
== NULL
)
4854 static struct complaint msg
= {"need a type name", 0, 0};
4858 for (ppt
= file_symbols
; ppt
; ppt
= ppt
->next
)
4860 for (i
= 0; i
< ppt
->nsyms
; i
++)
4862 struct symbol
*sym
= ppt
->symbol
[i
];
4864 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
4865 && SYMBOL_NAMESPACE (sym
) == STRUCT_NAMESPACE
4866 && (TYPE_CODE (SYMBOL_TYPE (sym
)) ==
4868 && STREQ (SYMBOL_NAME (sym
), typename
))
4870 memcpy (*type
, SYMBOL_TYPE (sym
),
4871 sizeof (struct type
));
4881 static struct complaint msg
= {"\
4882 GDB internal error. cleanup_undefined_types with bad type %d.", 0, 0};
4883 complain (&msg
, TYPE_CODE (*type
));
4889 undef_types_length
= 0;
4892 /* Scan through all of the global symbols defined in the object file,
4893 assigning values to the debugging symbols that need to be assigned
4894 to. Get these symbols from the minimal symbol table. */
4897 scan_file_globals (objfile
)
4898 struct objfile
*objfile
;
4901 struct minimal_symbol
*msymbol
;
4902 struct symbol
*sym
, *prev
, *rsym
;
4903 struct objfile
*resolve_objfile
;
4905 /* SVR4 based linkers copy referenced global symbols from shared
4906 libraries to the main executable.
4907 If we are scanning the symbols for a shared library, try to resolve
4908 them from the minimal symbols of the main executable first. */
4910 if (symfile_objfile
&& objfile
!= symfile_objfile
)
4911 resolve_objfile
= symfile_objfile
;
4913 resolve_objfile
= objfile
;
4917 /* Avoid expensive loop through all minimal symbols if there are
4918 no unresolved symbols. */
4919 for (hash
= 0; hash
< HASHSIZE
; hash
++)
4921 if (global_sym_chain
[hash
])
4924 if (hash
>= HASHSIZE
)
4927 for (msymbol
= resolve_objfile
-> msymbols
;
4928 msymbol
&& SYMBOL_NAME (msymbol
) != NULL
;
4933 /* Skip static symbols. */
4934 switch (MSYMBOL_TYPE (msymbol
))
4946 /* Get the hash index and check all the symbols
4947 under that hash index. */
4949 hash
= hashname (SYMBOL_NAME (msymbol
));
4951 for (sym
= global_sym_chain
[hash
]; sym
;)
4953 if (SYMBOL_NAME (msymbol
)[0] == SYMBOL_NAME (sym
)[0] &&
4954 STREQ(SYMBOL_NAME (msymbol
) + 1, SYMBOL_NAME (sym
) + 1))
4956 /* Splice this symbol out of the hash chain and
4957 assign the value we have to it. */
4960 SYMBOL_VALUE_CHAIN (prev
) = SYMBOL_VALUE_CHAIN (sym
);
4964 global_sym_chain
[hash
] = SYMBOL_VALUE_CHAIN (sym
);
4967 /* Check to see whether we need to fix up a common block. */
4968 /* Note: this code might be executed several times for
4969 the same symbol if there are multiple references. */
4971 /* If symbol has aliases, do minimal symbol fixups for each.
4972 These live aliases/references weren't added to
4973 global_sym_chain hash but may also need to be fixed up. */
4974 /* FIXME: Maybe should have added aliases to the global chain, resolved symbol name, then treated aliases as normal
4975 symbols? Still, we wouldn't want to add_to_list. */
4976 /* Now do the same for each alias of this symbol */
4977 for (rsym
= sym
; rsym
; rsym
= SYMBOL_ALIASES (rsym
))
4979 if (SYMBOL_CLASS (rsym
) == LOC_BLOCK
)
4981 fix_common_block (rsym
, SYMBOL_VALUE_ADDRESS (msymbol
));
4985 SYMBOL_VALUE_ADDRESS (rsym
)
4986 = SYMBOL_VALUE_ADDRESS (msymbol
);
4988 SYMBOL_SECTION (rsym
) = SYMBOL_SECTION (msymbol
);
4993 sym
= SYMBOL_VALUE_CHAIN (prev
);
4997 sym
= global_sym_chain
[hash
];
5003 sym
= SYMBOL_VALUE_CHAIN (sym
);
5007 if (resolve_objfile
== objfile
)
5009 resolve_objfile
= objfile
;
5012 /* Change the storage class of any remaining unresolved globals to
5013 LOC_UNRESOLVED and remove them from the chain. */
5014 for (hash
= 0; hash
< HASHSIZE
; hash
++)
5016 sym
= global_sym_chain
[hash
];
5020 sym
= SYMBOL_VALUE_CHAIN (sym
);
5022 /* Change the symbol address from the misleading chain value
5024 SYMBOL_VALUE_ADDRESS (prev
) = 0;
5026 /* Complain about unresolved common block symbols. */
5027 if (SYMBOL_CLASS (prev
) == LOC_STATIC
)
5028 SYMBOL_CLASS (prev
) = LOC_UNRESOLVED
;
5030 complain (&unresolved_sym_chain_complaint
,
5031 objfile
-> name
, SYMBOL_NAME (prev
));
5034 memset (global_sym_chain
, 0, sizeof (global_sym_chain
));
5037 /* Initialize anything that needs initializing when starting to read
5038 a fresh piece of a symbol file, e.g. reading in the stuff corresponding
5046 /* Initialize anything that needs initializing when a completely new
5047 symbol file is specified (not just adding some symbols from another
5048 file, e.g. a shared library). */
5051 stabsread_new_init ()
5053 /* Empty the hash table of global syms looking for values. */
5054 memset (global_sym_chain
, 0, sizeof (global_sym_chain
));
5057 /* Initialize anything that needs initializing at the same time as
5058 start_symtab() is called. */
5062 global_stabs
= NULL
; /* AIX COFF */
5063 /* Leave FILENUM of 0 free for builtin types and this file's types. */
5064 n_this_object_header_files
= 1;
5065 type_vector_length
= 0;
5066 type_vector
= (struct type
**) 0;
5068 /* FIXME: If common_block_name is not already NULL, we should complain(). */
5069 common_block_name
= NULL
;
5074 /* Call after end_symtab() */
5080 free ((char *) type_vector
);
5083 type_vector_length
= 0;
5084 previous_stab_code
= 0;
5088 finish_global_stabs (objfile
)
5089 struct objfile
*objfile
;
5093 patch_block_stabs (global_symbols
, global_stabs
, objfile
);
5094 free ((PTR
) global_stabs
);
5095 global_stabs
= NULL
;
5099 /* Initializer for this module */
5102 _initialize_stabsread ()
5104 undef_types_allocated
= 20;
5105 undef_types_length
= 0;
5106 undef_types
= (struct type
**)
5107 xmalloc (undef_types_allocated
* sizeof (struct type
*));