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 resolve_symbol_reference
PARAMS ((struct objfile
*, struct symbol
*, char *));
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/aliases to point to the original
1047 symbol definition. */
1050 resolve_symbol_reference (objfile
, sym
, p
)
1051 struct objfile
*objfile
;
1056 struct symbol
*ref_sym
=0;
1057 struct alias_list
*alias
;
1059 /* If this is not a symbol reference return now. */
1063 /* Use "#<num>" as the name; we'll fix the name later.
1064 We stored the original symbol name as "#<id>=<name>"
1065 so we can now search for "#<id>" to resolving the reference.
1066 We'll fix the names later by removing the "#<id>" or "#<id>=" */
1068 /*---------------------------------------------------------*/
1069 /* Get the reference id number, and
1070 advance p past the names so we can parse the rest.
1071 eg: id=2 for p : "2=", "2=z:r(0,1)" "2:r(0,1);l(#5,#6),l(#7,#4)" */
1072 /*---------------------------------------------------------*/
1074 /* This gets reference name from string. sym may not have a name. */
1076 /* Get the reference number associated with the reference id in the
1077 gdb stab string. From that reference number, get the main/primary
1078 symbol for this alias. */
1079 refnum
= process_reference (&p
);
1080 ref_sym
= ref_search (refnum
);
1082 error ("error: symbol for reference not found.\n");
1085 /* Parse the stab of the referencing symbol
1086 now that we have the referenced symbol.
1087 Add it as a new symbol and a link back to the referenced symbol.
1088 eg: p : "=", "=z:r(0,1)" ":r(0,1);l(#5,#6),l(#7,#4)" */
1091 /* If the stab symbol table and string contain:
1092 RSYM 0 5 00000000 868 #15=z:r(0,1)
1093 LBRAC 0 0 00000000 899 #5=
1094 SLINE 0 16 00000003 923 #6=
1095 Then the same symbols can be later referenced by:
1096 RSYM 0 5 00000000 927 #15:r(0,1);l(#5,#6)
1097 This is used in live range splitting to:
1098 1) specify that a symbol (#15) is actually just a new storage
1099 class for a symbol (#15=z) which was previously defined.
1100 2) specify that the beginning and ending ranges for a symbol
1101 (#15) are the values of the beginning (#5) and ending (#6)
1104 /* Read number as reference id.
1105 eg: p : "=", "=z:r(0,1)" ":r(0,1);l(#5,#6),l(#7,#4)" */
1106 /* FIXME! Might I want to use SYMBOL_CLASS (sym) = LOC_OPTIMIZED_OUT;
1107 in case of "l(0,0)"? */
1109 /*--------------------------------------------------*/
1110 /* Add this symbol to the reference list. */
1111 /*--------------------------------------------------*/
1113 alias
= (struct alias_list
*) obstack_alloc (&objfile
->type_obstack
,
1114 sizeof (struct alias_list
));
1116 error ("Unable to allocate alias list memory");
1121 if (!SYMBOL_ALIASES (ref_sym
))
1123 SYMBOL_ALIASES (ref_sym
) = alias
;
1127 struct alias_list
*temp
;
1129 /* Get to the end of the list. */
1130 for (temp
= SYMBOL_ALIASES (ref_sym
);
1137 /* Want to fix up name so that other functions (eg. valops)
1138 will correctly print the name.
1139 Don't add_symbol_to_list so that lookup_symbol won't find it.
1140 nope... needed for fixups. */
1141 SYMBOL_NAME (sym
) = SYMBOL_NAME (ref_sym
);
1147 #define MAX_CHUNK_REFS 100
1148 #define REF_CHUNK_SIZE \
1149 MAX_CHUNK_REFS * sizeof (struct ref_map_s)
1150 #define REF_MAP_SIZE(ref_chunk) \
1151 ref_chunk * REF_CHUNK_SIZE
1153 /* Structure for storing pointers to reference definitions for fast lookup
1154 during "process_later". */
1155 static struct ref_map_s
1162 /* Ptr to free cell in chunk's linked list. */
1163 static int ref_count
= 0;
1165 /* Number of chunks malloced. */
1166 static int ref_chunk
= 0;
1168 /* Initialize our list of references.
1169 This should be called before any symbol table is read. */
1178 /* Create array of pointers mapping refids to symbols and stab strings.
1179 Add pointers to reference definition symbols and/or their values as we
1180 find them, using their reference numbers as our index.
1181 These will be used later when we resolve references. */
1183 ref_add (refnum
, sym
, stabs
, value
)
1191 if (refnum
>= ref_count
)
1192 ref_count
= refnum
+ 1;
1193 if (ref_count
> ref_chunk
* MAX_CHUNK_REFS
)
1195 int new_slots
= ref_count
- ref_chunk
* MAX_CHUNK_REFS
;
1196 int new_chunks
= new_slots
/ MAX_CHUNK_REFS
+ 1;
1197 ref_map
= xrealloc (ref_map
, REF_MAP_SIZE(ref_chunk
+ new_chunks
));
1199 error ("no more free slots in chain\n");
1200 memset (ref_map
+ REF_MAP_SIZE(ref_chunk
), 0, new_chunks
* REF_CHUNK_SIZE
);
1201 ref_chunk
+= new_chunks
;
1203 ref_map
[refnum
].stabs
= stabs
;
1204 ref_map
[refnum
].sym
= sym
;
1205 ref_map
[refnum
].value
= value
;
1208 /* Return defined sym for the reference REFNUM. */
1213 if (refnum
< 0 || refnum
> ref_count
)
1215 return ref_map
[refnum
].sym
;
1218 /* Return value for the reference REFNUM. */
1221 ref_search_value (refnum
)
1224 if (refnum
< 0 || refnum
> ref_count
)
1226 return ref_map
[refnum
].value
;
1229 /* Parse a reference id in STRING and return the resulting
1230 reference number. Move STRING beyond the reference id. */
1233 process_reference (string
)
1239 if (**string
!= '#')
1242 /* Advance beyond the initial '#'. */
1245 /* Read number as reference id. */
1246 while (*p
&& isdigit (*p
))
1248 refnum
= refnum
* 10 + *p
- '0';
1255 /* If STRING defines a reference, store away a pointer to the reference
1256 definition for later use. Return the reference number. */
1259 symbol_reference_defined (string
)
1265 refnum
= process_reference (&p
);
1267 /* Defining symbols end in '=' */
1270 /* Symbol is being defined here. */
1276 /* Must be a reference. Either the symbol has already been defined,
1277 or this is a forward reference to it. */
1285 define_symbol (valu
, string
, desc
, type
, objfile
)
1290 struct objfile
*objfile
;
1292 register struct symbol
*sym
;
1293 char *p
= (char *) strchr (string
, ':');
1298 /* We would like to eliminate nameless symbols, but keep their types.
1299 E.g. stab entry ":t10=*2" should produce a type 10, which is a pointer
1300 to type 2, but, should not create a symbol to address that type. Since
1301 the symbol will be nameless, there is no way any user can refer to it. */
1305 /* Ignore syms with empty names. */
1309 /* Ignore old-style symbols from cc -go */
1316 p
= strchr (p
, ':');
1319 /* If a nameless stab entry, all we need is the type, not the symbol.
1320 e.g. ":t10=*2" or a nameless enum like " :T16=ered:0,green:1,blue:2,;" */
1321 nameless
= (p
== string
|| ((string
[0] == ' ') && (string
[1] == ':')));
1323 current_symbol
= sym
= (struct symbol
*)
1324 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
1325 memset (sym
, 0, sizeof (struct symbol
));
1327 switch (type
& N_TYPE
)
1330 SYMBOL_SECTION(sym
) = SECT_OFF_TEXT
;
1333 SYMBOL_SECTION(sym
) = SECT_OFF_DATA
;
1336 SYMBOL_SECTION(sym
) = SECT_OFF_BSS
;
1340 if (processing_gcc_compilation
)
1342 /* GCC 2.x puts the line number in desc. SunOS apparently puts in the
1343 number of bytes occupied by a type or object, which we ignore. */
1344 SYMBOL_LINE(sym
) = desc
;
1348 SYMBOL_LINE(sym
) = 0; /* unknown */
1351 if (is_cplus_marker (string
[0]))
1353 /* Special GNU C++ names. */
1357 SYMBOL_NAME (sym
) = obsavestring ("this", strlen ("this"),
1358 &objfile
-> symbol_obstack
);
1361 case 'v': /* $vtbl_ptr_type */
1362 /* Was: SYMBOL_NAME (sym) = "vptr"; */
1366 SYMBOL_NAME (sym
) = obsavestring ("eh_throw", strlen ("eh_throw"),
1367 &objfile
-> symbol_obstack
);
1371 /* This was an anonymous type that was never fixed up. */
1374 #ifdef STATIC_TRANSFORM_NAME
1376 /* SunPRO (3.0 at least) static variable encoding. */
1381 complain (&unrecognized_cplus_name_complaint
, string
);
1382 goto normal
; /* Do *something* with it */
1385 else if (string
[0] == '#')
1387 /* Special GNU C extension for referencing symbols. */
1391 /* If STRING defines a new reference id, then add it to the
1392 reference map. Else it must be referring to a previously
1393 defined symbol, so add it to the alias list of the previously
1396 refnum
= symbol_reference_defined (&s
);
1398 ref_add (refnum
, sym
, string
, SYMBOL_VALUE (sym
));
1400 resolve_symbol_reference (objfile
, sym
, string
);
1402 /* S..P contains the name of the symbol. We need to store
1403 the correct name into SYMBOL_NAME. */
1409 SYMBOL_NAME (sym
) = (char *)
1410 obstack_alloc (&objfile
-> symbol_obstack
, nlen
);
1411 strncpy (SYMBOL_NAME (sym
), s
, nlen
);
1412 SYMBOL_NAME (sym
)[nlen
] = '\0';
1413 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
->symbol_obstack
);
1416 /* FIXME! Want SYMBOL_NAME (sym) = 0;
1417 Get error if leave name 0. So give it something. */
1420 SYMBOL_NAME (sym
) = (char *)
1421 obstack_alloc (&objfile
-> symbol_obstack
, nlen
);
1422 strncpy (SYMBOL_NAME (sym
), string
, nlen
);
1423 SYMBOL_NAME (sym
)[nlen
] = '\0';
1424 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
->symbol_obstack
);
1427 /* Advance STRING beyond the reference id. */
1433 SYMBOL_LANGUAGE (sym
) = current_subfile
-> language
;
1434 SYMBOL_NAME (sym
) = (char *)
1435 obstack_alloc (&objfile
-> symbol_obstack
, ((p
- string
) + 1));
1436 /* Open-coded memcpy--saves function call time. */
1437 /* FIXME: Does it really? Try replacing with simple strcpy and
1438 try it on an executable with a large symbol table. */
1439 /* FIXME: considering that gcc can open code memcpy anyway, I
1440 doubt it. xoxorich. */
1442 register char *p1
= string
;
1443 register char *p2
= SYMBOL_NAME (sym
);
1451 /* If this symbol is from a C++ compilation, then attempt to cache the
1452 demangled form for future reference. This is a typical time versus
1453 space tradeoff, that was decided in favor of time because it sped up
1454 C++ symbol lookups by a factor of about 20. */
1456 SYMBOL_INIT_DEMANGLED_NAME (sym
, &objfile
->symbol_obstack
);
1460 /* Determine the type of name being defined. */
1462 /* Getting GDB to correctly skip the symbol on an undefined symbol
1463 descriptor and not ever dump core is a very dodgy proposition if
1464 we do things this way. I say the acorn RISC machine can just
1465 fix their compiler. */
1466 /* The Acorn RISC machine's compiler can put out locals that don't
1467 start with "234=" or "(3,4)=", so assume anything other than the
1468 deftypes we know how to handle is a local. */
1469 if (!strchr ("cfFGpPrStTvVXCR", *p
))
1471 if (isdigit (*p
) || *p
== '(' || *p
== '-')
1480 /* c is a special case, not followed by a type-number.
1481 SYMBOL:c=iVALUE for an integer constant symbol.
1482 SYMBOL:c=rVALUE for a floating constant symbol.
1483 SYMBOL:c=eTYPE,INTVALUE for an enum constant symbol.
1484 e.g. "b:c=e6,0" for "const b = blob1"
1485 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
1488 SYMBOL_CLASS (sym
) = LOC_CONST
;
1489 SYMBOL_TYPE (sym
) = error_type (&p
, objfile
);
1490 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1491 add_symbol_to_list (sym
, &file_symbols
);
1499 double d
= atof (p
);
1502 /* FIXME-if-picky-about-floating-accuracy: Should be using
1503 target arithmetic to get the value. real.c in GCC
1504 probably has the necessary code. */
1506 /* FIXME: lookup_fundamental_type is a hack. We should be
1507 creating a type especially for the type of float constants.
1508 Problem is, what type should it be?
1510 Also, what should the name of this type be? Should we
1511 be using 'S' constants (see stabs.texinfo) instead? */
1513 SYMBOL_TYPE (sym
) = lookup_fundamental_type (objfile
,
1516 obstack_alloc (&objfile
-> symbol_obstack
,
1517 TYPE_LENGTH (SYMBOL_TYPE (sym
)));
1518 store_floating (dbl_valu
, TYPE_LENGTH (SYMBOL_TYPE (sym
)), d
);
1519 SYMBOL_VALUE_BYTES (sym
) = dbl_valu
;
1520 SYMBOL_CLASS (sym
) = LOC_CONST_BYTES
;
1525 /* Defining integer constants this way is kind of silly,
1526 since 'e' constants allows the compiler to give not
1527 only the value, but the type as well. C has at least
1528 int, long, unsigned int, and long long as constant
1529 types; other languages probably should have at least
1530 unsigned as well as signed constants. */
1532 /* We just need one int constant type for all objfiles.
1533 It doesn't depend on languages or anything (arguably its
1534 name should be a language-specific name for a type of
1535 that size, but I'm inclined to say that if the compiler
1536 wants a nice name for the type, it can use 'e'). */
1537 static struct type
*int_const_type
;
1539 /* Yes, this is as long as a *host* int. That is because we
1541 if (int_const_type
== NULL
)
1543 init_type (TYPE_CODE_INT
,
1544 sizeof (int) * HOST_CHAR_BIT
/ TARGET_CHAR_BIT
, 0,
1546 (struct objfile
*)NULL
);
1547 SYMBOL_TYPE (sym
) = int_const_type
;
1548 SYMBOL_VALUE (sym
) = atoi (p
);
1549 SYMBOL_CLASS (sym
) = LOC_CONST
;
1553 /* SYMBOL:c=eTYPE,INTVALUE for a constant symbol whose value
1554 can be represented as integral.
1555 e.g. "b:c=e6,0" for "const b = blob1"
1556 (where type 6 is defined by "blobs:t6=eblob1:0,blob2:1,;"). */
1558 SYMBOL_CLASS (sym
) = LOC_CONST
;
1559 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1563 SYMBOL_TYPE (sym
) = error_type (&p
, objfile
);
1568 /* If the value is too big to fit in an int (perhaps because
1569 it is unsigned), or something like that, we silently get
1570 a bogus value. The type and everything else about it is
1571 correct. Ideally, we should be using whatever we have
1572 available for parsing unsigned and long long values,
1574 SYMBOL_VALUE (sym
) = atoi (p
);
1579 SYMBOL_CLASS (sym
) = LOC_CONST
;
1580 SYMBOL_TYPE (sym
) = error_type (&p
, objfile
);
1583 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1584 add_symbol_to_list (sym
, &file_symbols
);
1588 /* The name of a caught exception. */
1589 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1590 SYMBOL_CLASS (sym
) = LOC_LABEL
;
1591 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1592 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
1593 add_symbol_to_list (sym
, &local_symbols
);
1597 /* A static function definition. */
1598 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1599 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1600 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1601 add_symbol_to_list (sym
, &file_symbols
);
1602 /* fall into process_function_types. */
1604 process_function_types
:
1605 /* Function result types are described as the result type in stabs.
1606 We need to convert this to the function-returning-type-X type
1607 in GDB. E.g. "int" is converted to "function returning int". */
1608 if (TYPE_CODE (SYMBOL_TYPE (sym
)) != TYPE_CODE_FUNC
)
1609 SYMBOL_TYPE (sym
) = lookup_function_type (SYMBOL_TYPE (sym
));
1610 /* fall into process_prototype_types */
1612 process_prototype_types
:
1613 /* Sun acc puts declared types of arguments here. We don't care
1614 about their actual types (FIXME -- we should remember the whole
1615 function prototype), but the list may define some new types
1616 that we have to remember, so we must scan it now. */
1619 read_type (&p
, objfile
);
1624 /* A global function definition. */
1625 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1626 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
1627 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1628 add_symbol_to_list (sym
, &global_symbols
);
1629 goto process_function_types
;
1632 /* For a class G (global) symbol, it appears that the
1633 value is not correct. It is necessary to search for the
1634 corresponding linker definition to find the value.
1635 These definitions appear at the end of the namelist. */
1636 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1637 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1638 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1639 /* Don't add symbol references to global_sym_chain.
1640 Symbol references don't have valid names and wont't match up with
1641 minimal symbols when the global_sym_chain is relocated.
1642 We'll fixup symbol references when we fixup the defining symbol. */
1643 if (SYMBOL_NAME (sym
) && SYMBOL_NAME (sym
)[0] != '#')
1645 i
= hashname (SYMBOL_NAME (sym
));
1646 SYMBOL_VALUE_CHAIN (sym
) = global_sym_chain
[i
];
1647 global_sym_chain
[i
] = sym
;
1649 add_symbol_to_list (sym
, &global_symbols
);
1652 /* This case is faked by a conditional above,
1653 when there is no code letter in the dbx data.
1654 Dbx data never actually contains 'l'. */
1657 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1658 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
1659 SYMBOL_VALUE (sym
) = valu
;
1660 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1661 add_symbol_to_list (sym
, &local_symbols
);
1666 /* pF is a two-letter code that means a function parameter in Fortran.
1667 The type-number specifies the type of the return value.
1668 Translate it into a pointer-to-function type. */
1672 = lookup_pointer_type
1673 (lookup_function_type (read_type (&p
, objfile
)));
1676 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1678 /* Normally this is a parameter, a LOC_ARG. On the i960, it
1679 can also be a LOC_LOCAL_ARG depending on symbol type. */
1680 #ifndef DBX_PARM_SYMBOL_CLASS
1681 #define DBX_PARM_SYMBOL_CLASS(type) LOC_ARG
1684 SYMBOL_CLASS (sym
) = DBX_PARM_SYMBOL_CLASS (type
);
1685 SYMBOL_VALUE (sym
) = valu
;
1686 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1687 add_symbol_to_list (sym
, &local_symbols
);
1689 if (TARGET_BYTE_ORDER
!= BIG_ENDIAN
)
1691 /* On little-endian machines, this crud is never necessary,
1692 and, if the extra bytes contain garbage, is harmful. */
1696 /* If it's gcc-compiled, if it says `short', believe it. */
1697 if (processing_gcc_compilation
|| BELIEVE_PCC_PROMOTION
)
1700 #if !BELIEVE_PCC_PROMOTION
1702 /* This is the signed type which arguments get promoted to. */
1703 static struct type
*pcc_promotion_type
;
1704 /* This is the unsigned type which arguments get promoted to. */
1705 static struct type
*pcc_unsigned_promotion_type
;
1707 /* Call it "int" because this is mainly C lossage. */
1708 if (pcc_promotion_type
== NULL
)
1709 pcc_promotion_type
=
1710 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
1713 if (pcc_unsigned_promotion_type
== NULL
)
1714 pcc_unsigned_promotion_type
=
1715 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
1716 TYPE_FLAG_UNSIGNED
, "unsigned int", NULL
);
1718 #if defined(BELIEVE_PCC_PROMOTION_TYPE)
1719 /* This macro is defined on machines (e.g. sparc) where
1720 we should believe the type of a PCC 'short' argument,
1721 but shouldn't believe the address (the address is
1722 the address of the corresponding int).
1724 My guess is that this correction, as opposed to changing
1725 the parameter to an 'int' (as done below, for PCC
1726 on most machines), is the right thing to do
1727 on all machines, but I don't want to risk breaking
1728 something that already works. On most PCC machines,
1729 the sparc problem doesn't come up because the calling
1730 function has to zero the top bytes (not knowing whether
1731 the called function wants an int or a short), so there
1732 is little practical difference between an int and a short
1733 (except perhaps what happens when the GDB user types
1734 "print short_arg = 0x10000;").
1736 Hacked for SunOS 4.1 by gnu@cygnus.com. In 4.1, the compiler
1737 actually produces the correct address (we don't need to fix it
1738 up). I made this code adapt so that it will offset the symbol
1739 if it was pointing at an int-aligned location and not
1740 otherwise. This way you can use the same gdb for 4.0.x and
1743 If the parameter is shorter than an int, and is integral
1744 (e.g. char, short, or unsigned equivalent), and is claimed to
1745 be passed on an integer boundary, don't believe it! Offset the
1746 parameter's address to the tail-end of that integer. */
1748 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (pcc_promotion_type
)
1749 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
1750 && 0 == SYMBOL_VALUE (sym
) % TYPE_LENGTH (pcc_promotion_type
))
1752 SYMBOL_VALUE (sym
) += TYPE_LENGTH (pcc_promotion_type
)
1753 - TYPE_LENGTH (SYMBOL_TYPE (sym
));
1757 #else /* no BELIEVE_PCC_PROMOTION_TYPE. */
1759 /* If PCC says a parameter is a short or a char,
1760 it is really an int. */
1761 if (TYPE_LENGTH (SYMBOL_TYPE (sym
)) < TYPE_LENGTH (pcc_promotion_type
)
1762 && TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_INT
)
1765 TYPE_UNSIGNED (SYMBOL_TYPE (sym
))
1766 ? pcc_unsigned_promotion_type
1767 : pcc_promotion_type
;
1771 #endif /* no BELIEVE_PCC_PROMOTION_TYPE. */
1773 #endif /* !BELIEVE_PCC_PROMOTION. */
1776 /* acc seems to use P to declare the prototypes of functions that
1777 are referenced by this file. gdb is not prepared to deal
1778 with this extra information. FIXME, it ought to. */
1781 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1782 goto process_prototype_types
;
1787 /* Parameter which is in a register. */
1788 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1789 SYMBOL_CLASS (sym
) = LOC_REGPARM
;
1790 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (valu
);
1791 if (SYMBOL_VALUE (sym
) >= NUM_REGS
)
1793 complain (®_value_complaint
, SYMBOL_VALUE (sym
), NUM_REGS
,
1794 SYMBOL_SOURCE_NAME (sym
));
1795 SYMBOL_VALUE (sym
) = SP_REGNUM
; /* Known safe, though useless */
1797 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1798 add_symbol_to_list (sym
, &local_symbols
);
1802 /* Register variable (either global or local). */
1803 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1804 SYMBOL_CLASS (sym
) = LOC_REGISTER
;
1805 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (valu
);
1806 if (SYMBOL_VALUE (sym
) >= NUM_REGS
)
1808 complain (®_value_complaint
, SYMBOL_VALUE (sym
), NUM_REGS
,
1809 SYMBOL_SOURCE_NAME (sym
));
1810 SYMBOL_VALUE (sym
) = SP_REGNUM
; /* Known safe, though useless */
1812 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1813 if (within_function
)
1815 /* Sun cc uses a pair of symbols, one 'p' and one 'r' with the same
1816 name to represent an argument passed in a register.
1817 GCC uses 'P' for the same case. So if we find such a symbol pair
1818 we combine it into one 'P' symbol. For Sun cc we need to do this
1819 regardless of REG_STRUCT_HAS_ADDR, because the compiler puts out
1820 the 'p' symbol even if it never saves the argument onto the stack.
1822 On most machines, we want to preserve both symbols, so that
1823 we can still get information about what is going on with the
1824 stack (VAX for computing args_printed, using stack slots instead
1825 of saved registers in backtraces, etc.).
1827 Note that this code illegally combines
1828 main(argc) struct foo argc; { register struct foo argc; }
1829 but this case is considered pathological and causes a warning
1830 from a decent compiler. */
1833 && local_symbols
->nsyms
> 0
1834 #ifndef USE_REGISTER_NOT_ARG
1835 && REG_STRUCT_HAS_ADDR (processing_gcc_compilation
,
1837 && (TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
1838 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_UNION
1839 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_SET
1840 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_BITSTRING
)
1844 struct symbol
*prev_sym
;
1845 prev_sym
= local_symbols
->symbol
[local_symbols
->nsyms
- 1];
1846 if ((SYMBOL_CLASS (prev_sym
) == LOC_REF_ARG
1847 || SYMBOL_CLASS (prev_sym
) == LOC_ARG
)
1848 && STREQ (SYMBOL_NAME (prev_sym
), SYMBOL_NAME(sym
)))
1850 SYMBOL_CLASS (prev_sym
) = LOC_REGPARM
;
1851 /* Use the type from the LOC_REGISTER; that is the type
1852 that is actually in that register. */
1853 SYMBOL_TYPE (prev_sym
) = SYMBOL_TYPE (sym
);
1854 SYMBOL_VALUE (prev_sym
) = SYMBOL_VALUE (sym
);
1859 add_symbol_to_list (sym
, &local_symbols
);
1862 add_symbol_to_list (sym
, &file_symbols
);
1866 /* Static symbol at top level of file */
1867 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1868 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1869 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
1870 #ifdef STATIC_TRANSFORM_NAME
1871 if (SYMBOL_NAME (sym
)[0] == '$')
1873 struct minimal_symbol
*msym
;
1874 msym
= lookup_minimal_symbol (SYMBOL_NAME (sym
), NULL
, objfile
);
1877 SYMBOL_NAME (sym
) = STATIC_TRANSFORM_NAME (SYMBOL_NAME (sym
));
1878 SYMBOL_VALUE_ADDRESS (sym
) = SYMBOL_VALUE_ADDRESS (msym
);
1882 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1883 add_symbol_to_list (sym
, &file_symbols
);
1887 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1889 /* For a nameless type, we don't want a create a symbol, thus we
1890 did not use `sym'. Return without further processing. */
1891 if (nameless
) return NULL
;
1893 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1894 SYMBOL_VALUE (sym
) = valu
;
1895 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
1896 /* C++ vagaries: we may have a type which is derived from
1897 a base type which did not have its name defined when the
1898 derived class was output. We fill in the derived class's
1899 base part member's name here in that case. */
1900 if (TYPE_NAME (SYMBOL_TYPE (sym
)) != NULL
)
1901 if ((TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_STRUCT
1902 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_UNION
)
1903 && TYPE_N_BASECLASSES (SYMBOL_TYPE (sym
)))
1906 for (j
= TYPE_N_BASECLASSES (SYMBOL_TYPE (sym
)) - 1; j
>= 0; j
--)
1907 if (TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym
), j
) == 0)
1908 TYPE_BASECLASS_NAME (SYMBOL_TYPE (sym
), j
) =
1909 type_name_no_tag (TYPE_BASECLASS (SYMBOL_TYPE (sym
), j
));
1912 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == NULL
)
1914 /* gcc-2.6 or later (when using -fvtable-thunks)
1915 emits a unique named type for a vtable entry.
1916 Some gdb code depends on that specific name. */
1917 extern const char vtbl_ptr_name
[];
1919 if ((TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_PTR
1920 && strcmp (SYMBOL_NAME (sym
), vtbl_ptr_name
))
1921 || TYPE_CODE (SYMBOL_TYPE (sym
)) == TYPE_CODE_FUNC
)
1923 /* If we are giving a name to a type such as "pointer to
1924 foo" or "function returning foo", we better not set
1925 the TYPE_NAME. If the program contains "typedef char
1926 *caddr_t;", we don't want all variables of type char
1927 * to print as caddr_t. This is not just a
1928 consequence of GDB's type management; PCC and GCC (at
1929 least through version 2.4) both output variables of
1930 either type char * or caddr_t with the type number
1931 defined in the 't' symbol for caddr_t. If a future
1932 compiler cleans this up it GDB is not ready for it
1933 yet, but if it becomes ready we somehow need to
1934 disable this check (without breaking the PCC/GCC2.4
1939 Fortunately, this check seems not to be necessary
1940 for anything except pointers or functions. */
1943 TYPE_NAME (SYMBOL_TYPE (sym
)) = SYMBOL_NAME (sym
);
1946 add_symbol_to_list (sym
, &file_symbols
);
1950 /* Struct, union, or enum tag. For GNU C++, this can be be followed
1951 by 't' which means we are typedef'ing it as well. */
1952 synonym
= *p
== 't';
1956 /* The semantics of C++ state that "struct foo { ... }" also defines
1957 a typedef for "foo". Unfortunately, cfront never makes the typedef
1958 when translating C++ into C. We make the typedef here so that
1959 "ptype foo" works as expected for cfront translated code. */
1960 else if (current_subfile
->language
== language_cplus
)
1963 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1965 /* For a nameless type, we don't want a create a symbol, thus we
1966 did not use `sym'. Return without further processing. */
1967 if (nameless
) return NULL
;
1969 SYMBOL_CLASS (sym
) = LOC_TYPEDEF
;
1970 SYMBOL_VALUE (sym
) = valu
;
1971 SYMBOL_NAMESPACE (sym
) = STRUCT_NAMESPACE
;
1972 if (TYPE_TAG_NAME (SYMBOL_TYPE (sym
)) == 0)
1973 TYPE_TAG_NAME (SYMBOL_TYPE (sym
))
1974 = obconcat (&objfile
-> type_obstack
, "", "", SYMBOL_NAME (sym
));
1975 add_symbol_to_list (sym
, &file_symbols
);
1979 /* Clone the sym and then modify it. */
1980 register struct symbol
*typedef_sym
= (struct symbol
*)
1981 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
1982 *typedef_sym
= *sym
;
1983 SYMBOL_CLASS (typedef_sym
) = LOC_TYPEDEF
;
1984 SYMBOL_VALUE (typedef_sym
) = valu
;
1985 SYMBOL_NAMESPACE (typedef_sym
) = VAR_NAMESPACE
;
1986 if (TYPE_NAME (SYMBOL_TYPE (sym
)) == 0)
1987 TYPE_NAME (SYMBOL_TYPE (sym
))
1988 = obconcat (&objfile
-> type_obstack
, "", "", SYMBOL_NAME (sym
));
1989 add_symbol_to_list (typedef_sym
, &file_symbols
);
1994 /* Static symbol of local scope */
1995 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
1996 SYMBOL_CLASS (sym
) = LOC_STATIC
;
1997 SYMBOL_VALUE_ADDRESS (sym
) = valu
;
1998 #ifdef STATIC_TRANSFORM_NAME
1999 if (SYMBOL_NAME (sym
)[0] == '$')
2001 struct minimal_symbol
*msym
;
2002 msym
= lookup_minimal_symbol (SYMBOL_NAME (sym
), NULL
, objfile
);
2005 SYMBOL_NAME (sym
) = STATIC_TRANSFORM_NAME (SYMBOL_NAME (sym
));
2006 SYMBOL_VALUE_ADDRESS (sym
) = SYMBOL_VALUE_ADDRESS (msym
);
2010 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2012 add_symbol_to_list (sym
, &global_symbols
);
2014 add_symbol_to_list (sym
, &local_symbols
);
2018 /* Reference parameter */
2019 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
2020 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
2021 SYMBOL_VALUE (sym
) = valu
;
2022 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2023 add_symbol_to_list (sym
, &local_symbols
);
2027 /* Reference parameter which is in a register. */
2028 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
2029 SYMBOL_CLASS (sym
) = LOC_REGPARM_ADDR
;
2030 SYMBOL_VALUE (sym
) = STAB_REG_TO_REGNUM (valu
);
2031 if (SYMBOL_VALUE (sym
) >= NUM_REGS
)
2033 complain (®_value_complaint
, SYMBOL_VALUE (sym
), NUM_REGS
,
2034 SYMBOL_SOURCE_NAME (sym
));
2035 SYMBOL_VALUE (sym
) = SP_REGNUM
; /* Known safe, though useless */
2037 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2038 add_symbol_to_list (sym
, &local_symbols
);
2042 /* This is used by Sun FORTRAN for "function result value".
2043 Sun claims ("dbx and dbxtool interfaces", 2nd ed)
2044 that Pascal uses it too, but when I tried it Pascal used
2045 "x:3" (local symbol) instead. */
2046 SYMBOL_TYPE (sym
) = read_type (&p
, objfile
);
2047 SYMBOL_CLASS (sym
) = LOC_LOCAL
;
2048 SYMBOL_VALUE (sym
) = valu
;
2049 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2050 add_symbol_to_list (sym
, &local_symbols
);
2053 /* New code added to support cfront stabs strings.
2054 Note: case 'P' already handled above */
2056 /* Cfront type continuation coming up!
2057 Find the original definition and add to it.
2058 We'll have to do this for the typedef too,
2059 since we cloned the symbol to define a type in read_type.
2060 Stabs info examples:
2062 foo__1CFv :ZtF (first def foo__1CFv:F(0,3);(0,24))
2063 C:ZsC;;__ct__1CFv func1__1CFv func2__1CFv ... ;;;
2064 where C is the name of the class.
2065 Unfortunately, we can't lookup the original symbol yet 'cuz
2066 we haven't finished reading all the symbols.
2067 Instead, we save it for processing later */
2068 process_later (sym
, p
, resolve_cfront_continuation
);
2069 SYMBOL_TYPE (sym
) = error_type (&p
, objfile
); /* FIXME! change later */
2070 SYMBOL_CLASS (sym
) = LOC_CONST
;
2071 SYMBOL_VALUE (sym
) = 0;
2072 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2073 /* Don't add to list - we'll delete it later when
2074 we add the continuation to the real sym */
2076 /* End of new code added to support cfront stabs strings */
2079 SYMBOL_TYPE (sym
) = error_type (&p
, objfile
);
2080 SYMBOL_CLASS (sym
) = LOC_CONST
;
2081 SYMBOL_VALUE (sym
) = 0;
2082 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
2083 add_symbol_to_list (sym
, &file_symbols
);
2087 /* When passing structures to a function, some systems sometimes pass
2088 the address in a register, not the structure itself. */
2090 if (REG_STRUCT_HAS_ADDR (processing_gcc_compilation
, SYMBOL_TYPE (sym
))
2091 && (SYMBOL_CLASS (sym
) == LOC_REGPARM
|| SYMBOL_CLASS (sym
) == LOC_ARG
))
2093 struct type
*symbol_type
= check_typedef (SYMBOL_TYPE (sym
));
2095 if ((TYPE_CODE (symbol_type
) == TYPE_CODE_STRUCT
)
2096 || (TYPE_CODE (symbol_type
) == TYPE_CODE_UNION
)
2097 || (TYPE_CODE (symbol_type
) == TYPE_CODE_BITSTRING
)
2098 || (TYPE_CODE (symbol_type
) == TYPE_CODE_SET
))
2100 /* If REG_STRUCT_HAS_ADDR yields non-zero we have to convert
2101 LOC_REGPARM to LOC_REGPARM_ADDR for structures and unions. */
2102 if (SYMBOL_CLASS (sym
) == LOC_REGPARM
)
2103 SYMBOL_CLASS (sym
) = LOC_REGPARM_ADDR
;
2104 /* Likewise for converting LOC_ARG to LOC_REF_ARG (for the 7th
2105 and subsequent arguments on the sparc, for example). */
2106 else if (SYMBOL_CLASS (sym
) == LOC_ARG
)
2107 SYMBOL_CLASS (sym
) = LOC_REF_ARG
;
2111 /* Is there more to parse? For example LRS/alias information? */
2112 while (*p
&& (*p
== ';' || *p
== ','))
2115 if (*p
&& *p
== 'l')
2117 /* GNU extensions for live range splitting may be appended to
2118 the end of the stab string. eg. "l(#1,#2);l(#3,#5)" */
2120 /* Resolve the live range and add it to SYM's live range list. */
2121 resolve_live_range (objfile
, sym
, p
);
2123 /* Find end of live range info. */
2124 p
= strchr (p
, ')');
2125 if (!*p
|| *p
!= ')')
2126 error ("Internal error: live range format not recognized.\n");
2133 /* Add the live range found in P to the symbol SYM in objfile OBJFILE. */
2136 resolve_live_range (objfile
, sym
, p
)
2137 struct objfile
* objfile
;
2142 CORE_ADDR start
, end
;
2144 /* Sanity check the beginning of the stabs string. */
2145 if (!*p
|| *p
!= 'l')
2146 error ("Internal error: live range string.\n");
2149 if (!*p
|| *p
!= '(')
2150 error ("Internal error: live range string.\n");
2153 /* Get starting value of range and advance P past the reference id.
2155 ?!? In theory, the process_reference should never fail, but we should
2156 catch that case just in case the compiler scrogged the stabs. */
2157 refnum
= process_reference (&p
);
2158 start
= ref_search_value (refnum
);
2160 error ("Internal error: live range symbol not found.\n");
2162 if (!*p
|| *p
!= ',')
2163 error ("Internal error: live range string.\n");
2166 /* Get ending value of range and advance P past the reference id.
2168 ?!? In theory, the process_reference should never fail, but we should
2169 catch that case just in case the compiler scrogged the stabs. */
2170 refnum
= process_reference (&p
);
2171 end
= ref_search_value (refnum
);
2173 error ("Internal error: live range symbol not found.\n");
2175 if (!*p
|| *p
!= ')')
2176 error ("Internal error: live range string.\n");
2178 /* Now that we know the bounds of the range, add it to the
2180 add_live_range (objfile
, sym
, start
, end
);
2183 /* Add a new live range defined by START and END to the symbol SYM
2184 in objfile OBJFILE. */
2187 add_live_range (objfile
, sym
, start
, end
)
2188 struct objfile
*objfile
;
2190 CORE_ADDR start
, end
;
2192 struct range_list
*r
, *rs
;
2195 error ("Internal error: end of live range follows start.\n");
2197 /* Alloc new live range structure. */
2198 r
= (struct range_list
*)
2199 obstack_alloc (&objfile
->type_obstack
,
2200 sizeof (struct range_list
));
2205 /* Append this range to the symbol's range list. */
2206 if (!SYMBOL_RANGES (sym
))
2208 SYMBOL_RANGES (sym
) = r
;
2212 /* Get the last range for the symbol. */
2213 for (rs
= SYMBOL_RANGES (sym
); rs
->next
; rs
= rs
->next
)
2220 /* Skip rest of this symbol and return an error type.
2222 General notes on error recovery: error_type always skips to the
2223 end of the symbol (modulo cretinous dbx symbol name continuation).
2224 Thus code like this:
2226 if (*(*pp)++ != ';')
2227 return error_type (pp, objfile);
2229 is wrong because if *pp starts out pointing at '\0' (typically as the
2230 result of an earlier error), it will be incremented to point to the
2231 start of the next symbol, which might produce strange results, at least
2232 if you run off the end of the string table. Instead use
2235 return error_type (pp, objfile);
2241 foo = error_type (pp, objfile);
2245 And in case it isn't obvious, the point of all this hair is so the compiler
2246 can define new types and new syntaxes, and old versions of the
2247 debugger will be able to read the new symbol tables. */
2249 static struct type
*
2250 error_type (pp
, objfile
)
2252 struct objfile
*objfile
;
2254 complain (&error_type_complaint
);
2257 /* Skip to end of symbol. */
2258 while (**pp
!= '\0')
2263 /* Check for and handle cretinous dbx symbol name continuation! */
2264 if ((*pp
)[-1] == '\\' || (*pp
)[-1] == '?')
2266 *pp
= next_symbol_text (objfile
);
2273 return (builtin_type_error
);
2277 /* Read type information or a type definition; return the type. Even
2278 though this routine accepts either type information or a type
2279 definition, the distinction is relevant--some parts of stabsread.c
2280 assume that type information starts with a digit, '-', or '(' in
2281 deciding whether to call read_type. */
2284 read_type (pp
, objfile
)
2286 struct objfile
*objfile
;
2288 register struct type
*type
= 0;
2291 char type_descriptor
;
2293 /* Size in bits of type if specified by a type attribute, or -1 if
2294 there is no size attribute. */
2297 /* Used to distinguish string and bitstring from char-array and set. */
2300 /* Read type number if present. The type number may be omitted.
2301 for instance in a two-dimensional array declared with type
2302 "ar1;1;10;ar1;1;10;4". */
2303 if ((**pp
>= '0' && **pp
<= '9')
2307 if (read_type_number (pp
, typenums
) != 0)
2308 return error_type (pp
, objfile
);
2310 /* Type is not being defined here. Either it already exists,
2311 or this is a forward reference to it. dbx_alloc_type handles
2314 return dbx_alloc_type (typenums
, objfile
);
2316 /* Type is being defined here. */
2318 Also skip the type descriptor - we get it below with (*pp)[-1]. */
2323 /* 'typenums=' not present, type is anonymous. Read and return
2324 the definition, but don't put it in the type vector. */
2325 typenums
[0] = typenums
[1] = -1;
2330 type_descriptor
= (*pp
)[-1];
2331 switch (type_descriptor
)
2335 enum type_code code
;
2337 /* Used to index through file_symbols. */
2338 struct pending
*ppt
;
2341 /* Name including "struct", etc. */
2345 char *from
, *to
, *p
, *q1
, *q2
;
2347 /* Set the type code according to the following letter. */
2351 code
= TYPE_CODE_STRUCT
;
2354 code
= TYPE_CODE_UNION
;
2357 code
= TYPE_CODE_ENUM
;
2361 /* Complain and keep going, so compilers can invent new
2362 cross-reference types. */
2363 static struct complaint msg
=
2364 {"Unrecognized cross-reference type `%c'", 0, 0};
2365 complain (&msg
, (*pp
)[0]);
2366 code
= TYPE_CODE_STRUCT
;
2371 q1
= strchr (*pp
, '<');
2372 p
= strchr (*pp
, ':');
2374 return error_type (pp
, objfile
);
2375 if (q1
&& p
> q1
&& p
[1] == ':')
2377 int nesting_level
= 0;
2378 for (q2
= q1
; *q2
; q2
++)
2382 else if (*q2
== '>')
2384 else if (*q2
== ':' && nesting_level
== 0)
2389 return error_type (pp
, objfile
);
2392 (char *)obstack_alloc (&objfile
->type_obstack
, p
- *pp
+ 1);
2394 /* Copy the name. */
2400 /* Set the pointer ahead of the name which we just read, and
2405 /* Now check to see whether the type has already been
2406 declared. This was written for arrays of cross-referenced
2407 types before we had TYPE_CODE_TARGET_STUBBED, so I'm pretty
2408 sure it is not necessary anymore. But it might be a good
2409 idea, to save a little memory. */
2411 for (ppt
= file_symbols
; ppt
; ppt
= ppt
->next
)
2412 for (i
= 0; i
< ppt
->nsyms
; i
++)
2414 struct symbol
*sym
= ppt
->symbol
[i
];
2416 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
2417 && SYMBOL_NAMESPACE (sym
) == STRUCT_NAMESPACE
2418 && (TYPE_CODE (SYMBOL_TYPE (sym
)) == code
)
2419 && STREQ (SYMBOL_NAME (sym
), type_name
))
2421 obstack_free (&objfile
-> type_obstack
, type_name
);
2422 type
= SYMBOL_TYPE (sym
);
2427 /* Didn't find the type to which this refers, so we must
2428 be dealing with a forward reference. Allocate a type
2429 structure for it, and keep track of it so we can
2430 fill in the rest of the fields when we get the full
2432 type
= dbx_alloc_type (typenums
, objfile
);
2433 TYPE_CODE (type
) = code
;
2434 TYPE_TAG_NAME (type
) = type_name
;
2435 INIT_CPLUS_SPECIFIC(type
);
2436 TYPE_FLAGS (type
) |= TYPE_FLAG_STUB
;
2438 add_undefined_type (type
);
2442 case '-': /* RS/6000 built-in type */
2456 /* We deal with something like t(1,2)=(3,4)=... which
2457 the Lucid compiler and recent gcc versions (post 2.7.3) use. */
2459 /* Allocate and enter the typedef type first.
2460 This handles recursive types. */
2461 type
= dbx_alloc_type (typenums
, objfile
);
2462 TYPE_CODE (type
) = TYPE_CODE_TYPEDEF
;
2463 { struct type
*xtype
= read_type (pp
, objfile
);
2466 /* It's being defined as itself. That means it is "void". */
2467 TYPE_CODE (type
) = TYPE_CODE_VOID
;
2468 TYPE_LENGTH (type
) = 1;
2470 else if (type_size
>= 0 || is_string
)
2473 TYPE_NAME (type
) = NULL
;
2474 TYPE_TAG_NAME (type
) = NULL
;
2478 TYPE_FLAGS (type
) |= TYPE_FLAG_TARGET_STUB
;
2479 TYPE_TARGET_TYPE (type
) = xtype
;
2484 /* In the following types, we must be sure to overwrite any existing
2485 type that the typenums refer to, rather than allocating a new one
2486 and making the typenums point to the new one. This is because there
2487 may already be pointers to the existing type (if it had been
2488 forward-referenced), and we must change it to a pointer, function,
2489 reference, or whatever, *in-place*. */
2492 type1
= read_type (pp
, objfile
);
2493 type
= make_pointer_type (type1
, dbx_lookup_type (typenums
));
2496 case '&': /* Reference to another type */
2497 type1
= read_type (pp
, objfile
);
2498 type
= make_reference_type (type1
, dbx_lookup_type (typenums
));
2501 case 'f': /* Function returning another type */
2502 if (os9k_stabs
&& **pp
== '(')
2504 /* Function prototype; parse it.
2505 We must conditionalize this on os9k_stabs because otherwise
2506 it could be confused with a Sun-style (1,3) typenumber
2512 t
= read_type (pp
, objfile
);
2513 if (**pp
== ',') ++*pp
;
2516 type1
= read_type (pp
, objfile
);
2517 type
= make_function_type (type1
, dbx_lookup_type (typenums
));
2520 case 'k': /* Const qualifier on some type (Sun) */
2521 case 'c': /* Const qualifier on some type (OS9000) */
2522 /* Because 'c' means other things to AIX and 'k' is perfectly good,
2523 only accept 'c' in the os9k_stabs case. */
2524 if (type_descriptor
== 'c' && !os9k_stabs
)
2525 return error_type (pp
, objfile
);
2526 type
= read_type (pp
, objfile
);
2527 /* FIXME! For now, we ignore const and volatile qualifiers. */
2530 case 'B': /* Volatile qual on some type (Sun) */
2531 case 'i': /* Volatile qual on some type (OS9000) */
2532 /* Because 'i' means other things to AIX and 'B' is perfectly good,
2533 only accept 'i' in the os9k_stabs case. */
2534 if (type_descriptor
== 'i' && !os9k_stabs
)
2535 return error_type (pp
, objfile
);
2536 type
= read_type (pp
, objfile
);
2537 /* FIXME! For now, we ignore const and volatile qualifiers. */
2541 if (isdigit (**pp
) || **pp
== '(' || **pp
== '-')
2542 { /* Member (class & variable) type */
2543 /* FIXME -- we should be doing smash_to_XXX types here. */
2545 struct type
*domain
= read_type (pp
, objfile
);
2546 struct type
*memtype
;
2549 /* Invalid member type data format. */
2550 return error_type (pp
, objfile
);
2553 memtype
= read_type (pp
, objfile
);
2554 type
= dbx_alloc_type (typenums
, objfile
);
2555 smash_to_member_type (type
, domain
, memtype
);
2557 else /* type attribute */
2560 /* Skip to the semicolon. */
2561 while (**pp
!= ';' && **pp
!= '\0')
2564 return error_type (pp
, objfile
);
2566 ++*pp
; /* Skip the semicolon. */
2571 type_size
= atoi (attr
+ 1);
2581 /* Ignore unrecognized type attributes, so future compilers
2582 can invent new ones. */
2590 case '#': /* Method (class & fn) type */
2591 if ((*pp
)[0] == '#')
2593 /* We'll get the parameter types from the name. */
2594 struct type
*return_type
;
2597 return_type
= read_type (pp
, objfile
);
2598 if (*(*pp
)++ != ';')
2599 complain (&invalid_member_complaint
, symnum
);
2600 type
= allocate_stub_method (return_type
);
2601 if (typenums
[0] != -1)
2602 *dbx_lookup_type (typenums
) = type
;
2606 struct type
*domain
= read_type (pp
, objfile
);
2607 struct type
*return_type
;
2611 /* Invalid member type data format. */
2612 return error_type (pp
, objfile
);
2616 return_type
= read_type (pp
, objfile
);
2617 args
= read_args (pp
, ';', objfile
);
2618 type
= dbx_alloc_type (typenums
, objfile
);
2619 smash_to_method_type (type
, domain
, return_type
, args
);
2623 case 'r': /* Range type */
2624 type
= read_range_type (pp
, typenums
, objfile
);
2625 if (typenums
[0] != -1)
2626 *dbx_lookup_type (typenums
) = type
;
2631 /* Const and volatile qualified type. */
2632 type
= read_type (pp
, objfile
);
2635 /* Sun ACC builtin int type */
2636 type
= read_sun_builtin_type (pp
, typenums
, objfile
);
2637 if (typenums
[0] != -1)
2638 *dbx_lookup_type (typenums
) = type
;
2642 case 'R': /* Sun ACC builtin float type */
2643 type
= read_sun_floating_type (pp
, typenums
, objfile
);
2644 if (typenums
[0] != -1)
2645 *dbx_lookup_type (typenums
) = type
;
2648 case 'e': /* Enumeration type */
2649 type
= dbx_alloc_type (typenums
, objfile
);
2650 type
= read_enum_type (pp
, type
, objfile
);
2651 if (typenums
[0] != -1)
2652 *dbx_lookup_type (typenums
) = type
;
2655 case 's': /* Struct type */
2656 case 'u': /* Union type */
2657 type
= dbx_alloc_type (typenums
, objfile
);
2658 switch (type_descriptor
)
2661 TYPE_CODE (type
) = TYPE_CODE_STRUCT
;
2664 TYPE_CODE (type
) = TYPE_CODE_UNION
;
2667 type
= read_struct_type (pp
, type
, objfile
);
2670 case 'a': /* Array type */
2672 return error_type (pp
, objfile
);
2675 type
= dbx_alloc_type (typenums
, objfile
);
2676 type
= read_array_type (pp
, type
, objfile
);
2678 TYPE_CODE (type
) = TYPE_CODE_STRING
;
2682 type1
= read_type (pp
, objfile
);
2683 type
= create_set_type ((struct type
*) NULL
, type1
);
2685 TYPE_CODE (type
) = TYPE_CODE_BITSTRING
;
2686 if (typenums
[0] != -1)
2687 *dbx_lookup_type (typenums
) = type
;
2691 --*pp
; /* Go back to the symbol in error */
2692 /* Particularly important if it was \0! */
2693 return error_type (pp
, objfile
);
2698 warning ("GDB internal error, type is NULL in stabsread.c\n");
2699 return error_type (pp
, objfile
);
2702 /* Size specified in a type attribute overrides any other size. */
2703 if (type_size
!= -1)
2704 TYPE_LENGTH (type
) = (type_size
+ TARGET_CHAR_BIT
- 1) / TARGET_CHAR_BIT
;
2709 /* RS/6000 xlc/dbx combination uses a set of builtin types, starting from -1.
2710 Return the proper type node for a given builtin type number. */
2712 static struct type
*
2713 rs6000_builtin_type (typenum
)
2716 /* We recognize types numbered from -NUMBER_RECOGNIZED to -1. */
2717 #define NUMBER_RECOGNIZED 34
2718 /* This includes an empty slot for type number -0. */
2719 static struct type
*negative_types
[NUMBER_RECOGNIZED
+ 1];
2720 struct type
*rettype
= NULL
;
2722 if (typenum
>= 0 || typenum
< -NUMBER_RECOGNIZED
)
2724 complain (&rs6000_builtin_complaint
, typenum
);
2725 return builtin_type_error
;
2727 if (negative_types
[-typenum
] != NULL
)
2728 return negative_types
[-typenum
];
2730 #if TARGET_CHAR_BIT != 8
2731 #error This code wrong for TARGET_CHAR_BIT not 8
2732 /* These definitions all assume that TARGET_CHAR_BIT is 8. I think
2733 that if that ever becomes not true, the correct fix will be to
2734 make the size in the struct type to be in bits, not in units of
2741 /* The size of this and all the other types are fixed, defined
2742 by the debugging format. If there is a type called "int" which
2743 is other than 32 bits, then it should use a new negative type
2744 number (or avoid negative type numbers for that case).
2745 See stabs.texinfo. */
2746 rettype
= init_type (TYPE_CODE_INT
, 4, 0, "int", NULL
);
2749 rettype
= init_type (TYPE_CODE_INT
, 1, 0, "char", NULL
);
2752 rettype
= init_type (TYPE_CODE_INT
, 2, 0, "short", NULL
);
2755 rettype
= init_type (TYPE_CODE_INT
, 4, 0, "long", NULL
);
2758 rettype
= init_type (TYPE_CODE_INT
, 1, TYPE_FLAG_UNSIGNED
,
2759 "unsigned char", NULL
);
2762 rettype
= init_type (TYPE_CODE_INT
, 1, 0, "signed char", NULL
);
2765 rettype
= init_type (TYPE_CODE_INT
, 2, TYPE_FLAG_UNSIGNED
,
2766 "unsigned short", NULL
);
2769 rettype
= init_type (TYPE_CODE_INT
, 4, TYPE_FLAG_UNSIGNED
,
2770 "unsigned int", NULL
);
2773 rettype
= init_type (TYPE_CODE_INT
, 4, TYPE_FLAG_UNSIGNED
,
2776 rettype
= init_type (TYPE_CODE_INT
, 4, TYPE_FLAG_UNSIGNED
,
2777 "unsigned long", NULL
);
2780 rettype
= init_type (TYPE_CODE_VOID
, 1, 0, "void", NULL
);
2783 /* IEEE single precision (32 bit). */
2784 rettype
= init_type (TYPE_CODE_FLT
, 4, 0, "float", NULL
);
2787 /* IEEE double precision (64 bit). */
2788 rettype
= init_type (TYPE_CODE_FLT
, 8, 0, "double", NULL
);
2791 /* This is an IEEE double on the RS/6000, and different machines with
2792 different sizes for "long double" should use different negative
2793 type numbers. See stabs.texinfo. */
2794 rettype
= init_type (TYPE_CODE_FLT
, 8, 0, "long double", NULL
);
2797 rettype
= init_type (TYPE_CODE_INT
, 4, 0, "integer", NULL
);
2800 rettype
= init_type (TYPE_CODE_BOOL
, 4, TYPE_FLAG_UNSIGNED
,
2804 rettype
= init_type (TYPE_CODE_FLT
, 4, 0, "short real", NULL
);
2807 rettype
= init_type (TYPE_CODE_FLT
, 8, 0, "real", NULL
);
2810 rettype
= init_type (TYPE_CODE_ERROR
, 0, 0, "stringptr", NULL
);
2813 rettype
= init_type (TYPE_CODE_CHAR
, 1, TYPE_FLAG_UNSIGNED
,
2817 rettype
= init_type (TYPE_CODE_BOOL
, 1, TYPE_FLAG_UNSIGNED
,
2821 rettype
= init_type (TYPE_CODE_BOOL
, 2, TYPE_FLAG_UNSIGNED
,
2825 rettype
= init_type (TYPE_CODE_BOOL
, 4, TYPE_FLAG_UNSIGNED
,
2829 rettype
= init_type (TYPE_CODE_BOOL
, 4, TYPE_FLAG_UNSIGNED
,
2833 /* Complex type consisting of two IEEE single precision values. */
2834 rettype
= init_type (TYPE_CODE_ERROR
, 8, 0, "complex", NULL
);
2837 /* Complex type consisting of two IEEE double precision values. */
2838 rettype
= init_type (TYPE_CODE_ERROR
, 16, 0, "double complex", NULL
);
2841 rettype
= init_type (TYPE_CODE_INT
, 1, 0, "integer*1", NULL
);
2844 rettype
= init_type (TYPE_CODE_INT
, 2, 0, "integer*2", NULL
);
2847 rettype
= init_type (TYPE_CODE_INT
, 4, 0, "integer*4", NULL
);
2850 rettype
= init_type (TYPE_CODE_CHAR
, 2, 0, "wchar", NULL
);
2853 rettype
= init_type (TYPE_CODE_INT
, 8, 0, "long long", NULL
);
2856 rettype
= init_type (TYPE_CODE_INT
, 8, TYPE_FLAG_UNSIGNED
,
2857 "unsigned long long", NULL
);
2860 rettype
= init_type (TYPE_CODE_INT
, 8, TYPE_FLAG_UNSIGNED
,
2864 rettype
= init_type (TYPE_CODE_INT
, 8, 0, "integer*8", NULL
);
2867 negative_types
[-typenum
] = rettype
;
2871 /* This page contains subroutines of read_type. */
2873 /* Read member function stabs info for C++ classes. The form of each member
2876 NAME :: TYPENUM[=type definition] ARGS : PHYSNAME ;
2878 An example with two member functions is:
2880 afunc1::20=##15;:i;2A.;afunc2::20:i;2A.;
2882 For the case of overloaded operators, the format is op$::*.funcs, where
2883 $ is the CPLUS_MARKER (usually '$'), `*' holds the place for an operator
2884 name (such as `+=') and `.' marks the end of the operator name.
2886 Returns 1 for success, 0 for failure. */
2889 read_member_functions (fip
, pp
, type
, objfile
)
2890 struct field_info
*fip
;
2893 struct objfile
*objfile
;
2897 /* Total number of member functions defined in this class. If the class
2898 defines two `f' functions, and one `g' function, then this will have
2900 int total_length
= 0;
2904 struct next_fnfield
*next
;
2905 struct fn_field fn_field
;
2907 struct type
*look_ahead_type
;
2908 struct next_fnfieldlist
*new_fnlist
;
2909 struct next_fnfield
*new_sublist
;
2913 /* Process each list until we find something that is not a member function
2914 or find the end of the functions. */
2918 /* We should be positioned at the start of the function name.
2919 Scan forward to find the first ':' and if it is not the
2920 first of a "::" delimiter, then this is not a member function. */
2932 look_ahead_type
= NULL
;
2935 new_fnlist
= (struct next_fnfieldlist
*)
2936 xmalloc (sizeof (struct next_fnfieldlist
));
2937 make_cleanup (free
, new_fnlist
);
2938 memset (new_fnlist
, 0, sizeof (struct next_fnfieldlist
));
2940 if ((*pp
)[0] == 'o' && (*pp
)[1] == 'p' && is_cplus_marker ((*pp
)[2]))
2942 /* This is a completely wierd case. In order to stuff in the
2943 names that might contain colons (the usual name delimiter),
2944 Mike Tiemann defined a different name format which is
2945 signalled if the identifier is "op$". In that case, the
2946 format is "op$::XXXX." where XXXX is the name. This is
2947 used for names like "+" or "=". YUUUUUUUK! FIXME! */
2948 /* This lets the user type "break operator+".
2949 We could just put in "+" as the name, but that wouldn't
2951 static char opname
[32] = {'o', 'p', CPLUS_MARKER
};
2952 char *o
= opname
+ 3;
2954 /* Skip past '::'. */
2957 STABS_CONTINUE (pp
, objfile
);
2963 main_fn_name
= savestring (opname
, o
- opname
);
2969 main_fn_name
= savestring (*pp
, p
- *pp
);
2970 /* Skip past '::'. */
2973 new_fnlist
-> fn_fieldlist
.name
= main_fn_name
;
2978 (struct next_fnfield
*) xmalloc (sizeof (struct next_fnfield
));
2979 make_cleanup (free
, new_sublist
);
2980 memset (new_sublist
, 0, sizeof (struct next_fnfield
));
2982 /* Check for and handle cretinous dbx symbol name continuation! */
2983 if (look_ahead_type
== NULL
)
2986 STABS_CONTINUE (pp
, objfile
);
2988 new_sublist
-> fn_field
.type
= read_type (pp
, objfile
);
2991 /* Invalid symtab info for member function. */
2997 /* g++ version 1 kludge */
2998 new_sublist
-> fn_field
.type
= look_ahead_type
;
2999 look_ahead_type
= NULL
;
3009 /* If this is just a stub, then we don't have the real name here. */
3011 if (TYPE_FLAGS (new_sublist
-> fn_field
.type
) & TYPE_FLAG_STUB
)
3013 if (!TYPE_DOMAIN_TYPE (new_sublist
-> fn_field
.type
))
3014 TYPE_DOMAIN_TYPE (new_sublist
-> fn_field
.type
) = type
;
3015 new_sublist
-> fn_field
.is_stub
= 1;
3017 new_sublist
-> fn_field
.physname
= savestring (*pp
, p
- *pp
);
3020 /* Set this member function's visibility fields. */
3023 case VISIBILITY_PRIVATE
:
3024 new_sublist
-> fn_field
.is_private
= 1;
3026 case VISIBILITY_PROTECTED
:
3027 new_sublist
-> fn_field
.is_protected
= 1;
3031 STABS_CONTINUE (pp
, objfile
);
3034 case 'A': /* Normal functions. */
3035 new_sublist
-> fn_field
.is_const
= 0;
3036 new_sublist
-> fn_field
.is_volatile
= 0;
3039 case 'B': /* `const' member functions. */
3040 new_sublist
-> fn_field
.is_const
= 1;
3041 new_sublist
-> fn_field
.is_volatile
= 0;
3044 case 'C': /* `volatile' member function. */
3045 new_sublist
-> fn_field
.is_const
= 0;
3046 new_sublist
-> fn_field
.is_volatile
= 1;
3049 case 'D': /* `const volatile' member function. */
3050 new_sublist
-> fn_field
.is_const
= 1;
3051 new_sublist
-> fn_field
.is_volatile
= 1;
3054 case '*': /* File compiled with g++ version 1 -- no info */
3059 complain (&const_vol_complaint
, **pp
);
3068 /* virtual member function, followed by index.
3069 The sign bit is set to distinguish pointers-to-methods
3070 from virtual function indicies. Since the array is
3071 in words, the quantity must be shifted left by 1
3072 on 16 bit machine, and by 2 on 32 bit machine, forcing
3073 the sign bit out, and usable as a valid index into
3074 the array. Remove the sign bit here. */
3075 new_sublist
-> fn_field
.voffset
=
3076 (0x7fffffff & read_huge_number (pp
, ';', &nbits
)) + 2;
3080 STABS_CONTINUE (pp
, objfile
);
3081 if (**pp
== ';' || **pp
== '\0')
3083 /* Must be g++ version 1. */
3084 new_sublist
-> fn_field
.fcontext
= 0;
3088 /* Figure out from whence this virtual function came.
3089 It may belong to virtual function table of
3090 one of its baseclasses. */
3091 look_ahead_type
= read_type (pp
, objfile
);
3094 /* g++ version 1 overloaded methods. */
3098 new_sublist
-> fn_field
.fcontext
= look_ahead_type
;
3107 look_ahead_type
= NULL
;
3113 /* static member function. */
3114 new_sublist
-> fn_field
.voffset
= VOFFSET_STATIC
;
3115 if (strncmp (new_sublist
-> fn_field
.physname
,
3116 main_fn_name
, strlen (main_fn_name
)))
3118 new_sublist
-> fn_field
.is_stub
= 1;
3124 complain (&member_fn_complaint
, (*pp
)[-1]);
3125 /* Fall through into normal member function. */
3128 /* normal member function. */
3129 new_sublist
-> fn_field
.voffset
= 0;
3130 new_sublist
-> fn_field
.fcontext
= 0;
3134 new_sublist
-> next
= sublist
;
3135 sublist
= new_sublist
;
3137 STABS_CONTINUE (pp
, objfile
);
3139 while (**pp
!= ';' && **pp
!= '\0');
3143 new_fnlist
-> fn_fieldlist
.fn_fields
= (struct fn_field
*)
3144 obstack_alloc (&objfile
-> type_obstack
,
3145 sizeof (struct fn_field
) * length
);
3146 memset (new_fnlist
-> fn_fieldlist
.fn_fields
, 0,
3147 sizeof (struct fn_field
) * length
);
3148 for (i
= length
; (i
--, sublist
); sublist
= sublist
-> next
)
3150 new_fnlist
-> fn_fieldlist
.fn_fields
[i
] = sublist
-> fn_field
;
3153 new_fnlist
-> fn_fieldlist
.length
= length
;
3154 new_fnlist
-> next
= fip
-> fnlist
;
3155 fip
-> fnlist
= new_fnlist
;
3157 total_length
+= length
;
3158 STABS_CONTINUE (pp
, objfile
);
3163 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3164 TYPE_FN_FIELDLISTS (type
) = (struct fn_fieldlist
*)
3165 TYPE_ALLOC (type
, sizeof (struct fn_fieldlist
) * nfn_fields
);
3166 memset (TYPE_FN_FIELDLISTS (type
), 0,
3167 sizeof (struct fn_fieldlist
) * nfn_fields
);
3168 TYPE_NFN_FIELDS (type
) = nfn_fields
;
3169 TYPE_NFN_FIELDS_TOTAL (type
) = total_length
;
3175 /* Special GNU C++ name.
3177 Returns 1 for success, 0 for failure. "failure" means that we can't
3178 keep parsing and it's time for error_type(). */
3181 read_cpp_abbrev (fip
, pp
, type
, objfile
)
3182 struct field_info
*fip
;
3185 struct objfile
*objfile
;
3190 struct type
*context
;
3200 /* At this point, *pp points to something like "22:23=*22...",
3201 where the type number before the ':' is the "context" and
3202 everything after is a regular type definition. Lookup the
3203 type, find it's name, and construct the field name. */
3205 context
= read_type (pp
, objfile
);
3209 case 'f': /* $vf -- a virtual function table pointer */
3210 fip
->list
->field
.name
=
3211 obconcat (&objfile
->type_obstack
, vptr_name
, "", "");
3214 case 'b': /* $vb -- a virtual bsomethingorother */
3215 name
= type_name_no_tag (context
);
3218 complain (&invalid_cpp_type_complaint
, symnum
);
3221 fip
->list
->field
.name
=
3222 obconcat (&objfile
->type_obstack
, vb_name
, name
, "");
3226 complain (&invalid_cpp_abbrev_complaint
, *pp
);
3227 fip
->list
->field
.name
=
3228 obconcat (&objfile
->type_obstack
,
3229 "INVALID_CPLUSPLUS_ABBREV", "", "");
3233 /* At this point, *pp points to the ':'. Skip it and read the
3239 complain (&invalid_cpp_abbrev_complaint
, *pp
);
3242 fip
->list
->field
.type
= read_type (pp
, objfile
);
3244 (*pp
)++; /* Skip the comma. */
3250 FIELD_BITPOS (fip
->list
->field
) = read_huge_number (pp
, ';', &nbits
);
3254 /* This field is unpacked. */
3255 FIELD_BITSIZE (fip
->list
->field
) = 0;
3256 fip
->list
->visibility
= VISIBILITY_PRIVATE
;
3260 complain (&invalid_cpp_abbrev_complaint
, *pp
);
3261 /* We have no idea what syntax an unrecognized abbrev would have, so
3262 better return 0. If we returned 1, we would need to at least advance
3263 *pp to avoid an infinite loop. */
3270 read_one_struct_field (fip
, pp
, p
, type
, objfile
)
3271 struct field_info
*fip
;
3275 struct objfile
*objfile
;
3277 /* The following is code to work around cfront generated stabs.
3278 The stabs contains full mangled name for each field.
3279 We try to demangle the name and extract the field name out of it.
3281 if (ARM_DEMANGLING
&& current_subfile
->language
== language_cplus
)
3287 dem
= cplus_demangle (*pp
, DMGL_ANSI
| DMGL_PARAMS
);
3290 dem_p
= strrchr (dem
, ':');
3291 if (dem_p
!= 0 && *(dem_p
-1)==':')
3293 FIELD_NAME (fip
->list
->field
) =
3294 obsavestring (dem_p
, strlen (dem_p
), &objfile
-> type_obstack
);
3298 FIELD_NAME (fip
->list
->field
) =
3299 obsavestring (*pp
, p
- *pp
, &objfile
-> type_obstack
);
3303 /* end of code for cfront work around */
3306 fip
-> list
-> field
.name
=
3307 obsavestring (*pp
, p
- *pp
, &objfile
-> type_obstack
);
3310 /* This means we have a visibility for a field coming. */
3314 fip
-> list
-> visibility
= *(*pp
)++;
3318 /* normal dbx-style format, no explicit visibility */
3319 fip
-> list
-> visibility
= VISIBILITY_PUBLIC
;
3322 fip
-> list
-> field
.type
= read_type (pp
, objfile
);
3327 /* Possible future hook for nested types. */
3330 fip
-> list
-> field
.bitpos
= (long)-2; /* nested type */
3339 /* Static class member. */
3340 SET_FIELD_PHYSNAME (fip
->list
->field
, savestring (*pp
, p
- *pp
));
3344 else if (**pp
!= ',')
3346 /* Bad structure-type format. */
3347 complain (&stabs_general_complaint
, "bad structure-type format");
3351 (*pp
)++; /* Skip the comma. */
3355 FIELD_BITPOS (fip
->list
->field
) = read_huge_number (pp
, ',', &nbits
);
3358 complain (&stabs_general_complaint
, "bad structure-type format");
3361 FIELD_BITSIZE (fip
->list
->field
) = read_huge_number (pp
, ';', &nbits
);
3364 complain (&stabs_general_complaint
, "bad structure-type format");
3369 if (FIELD_BITPOS (fip
->list
->field
) == 0
3370 && FIELD_BITSIZE (fip
->list
->field
) == 0)
3372 /* This can happen in two cases: (1) at least for gcc 2.4.5 or so,
3373 it is a field which has been optimized out. The correct stab for
3374 this case is to use VISIBILITY_IGNORE, but that is a recent
3375 invention. (2) It is a 0-size array. For example
3376 union { int num; char str[0]; } foo. Printing "<no value>" for
3377 str in "p foo" is OK, since foo.str (and thus foo.str[3])
3378 will continue to work, and a 0-size array as a whole doesn't
3379 have any contents to print.
3381 I suspect this probably could also happen with gcc -gstabs (not
3382 -gstabs+) for static fields, and perhaps other C++ extensions.
3383 Hopefully few people use -gstabs with gdb, since it is intended
3384 for dbx compatibility. */
3386 /* Ignore this field. */
3387 fip
-> list
-> visibility
= VISIBILITY_IGNORE
;
3391 /* Detect an unpacked field and mark it as such.
3392 dbx gives a bit size for all fields.
3393 Note that forward refs cannot be packed,
3394 and treat enums as if they had the width of ints. */
3396 if (TYPE_CODE (FIELD_TYPE (fip
->list
->field
)) != TYPE_CODE_INT
3397 && TYPE_CODE (FIELD_TYPE (fip
->list
->field
)) != TYPE_CODE_BOOL
3398 && TYPE_CODE (FIELD_TYPE (fip
->list
->field
)) != TYPE_CODE_ENUM
)
3400 FIELD_BITSIZE (fip
->list
->field
) = 0;
3402 if ((FIELD_BITSIZE (fip
->list
->field
)
3403 == TARGET_CHAR_BIT
* TYPE_LENGTH (FIELD_TYPE (fip
->list
->field
))
3404 || (TYPE_CODE (FIELD_TYPE (fip
->list
->field
)) == TYPE_CODE_ENUM
3405 && FIELD_BITSIZE (fip
->list
->field
) == TARGET_INT_BIT
)
3408 FIELD_BITPOS (fip
->list
->field
) % 8 == 0)
3410 FIELD_BITSIZE (fip
->list
->field
) = 0;
3416 /* Read struct or class data fields. They have the form:
3418 NAME : [VISIBILITY] TYPENUM , BITPOS , BITSIZE ;
3420 At the end, we see a semicolon instead of a field.
3422 In C++, this may wind up being NAME:?TYPENUM:PHYSNAME; for
3425 The optional VISIBILITY is one of:
3427 '/0' (VISIBILITY_PRIVATE)
3428 '/1' (VISIBILITY_PROTECTED)
3429 '/2' (VISIBILITY_PUBLIC)
3430 '/9' (VISIBILITY_IGNORE)
3432 or nothing, for C style fields with public visibility.
3434 Returns 1 for success, 0 for failure. */
3437 read_struct_fields (fip
, pp
, type
, objfile
)
3438 struct field_info
*fip
;
3441 struct objfile
*objfile
;
3444 struct nextfield
*new;
3446 /* We better set p right now, in case there are no fields at all... */
3450 /* Read each data member type until we find the terminating ';' at the end of
3451 the data member list, or break for some other reason such as finding the
3452 start of the member function list. */
3456 if (os9k_stabs
&& **pp
== ',') break;
3457 STABS_CONTINUE (pp
, objfile
);
3458 /* Get space to record the next field's data. */
3459 new = (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
3460 make_cleanup (free
, new);
3461 memset (new, 0, sizeof (struct nextfield
));
3462 new -> next
= fip
-> list
;
3465 /* Get the field name. */
3468 /* If is starts with CPLUS_MARKER it is a special abbreviation,
3469 unless the CPLUS_MARKER is followed by an underscore, in
3470 which case it is just the name of an anonymous type, which we
3471 should handle like any other type name. */
3473 if (is_cplus_marker (p
[0]) && p
[1] != '_')
3475 if (!read_cpp_abbrev (fip
, pp
, type
, objfile
))
3480 /* Look for the ':' that separates the field name from the field
3481 values. Data members are delimited by a single ':', while member
3482 functions are delimited by a pair of ':'s. When we hit the member
3483 functions (if any), terminate scan loop and return. */
3485 while (*p
!= ':' && *p
!= '\0')
3492 /* Check to see if we have hit the member functions yet. */
3497 read_one_struct_field (fip
, pp
, p
, type
, objfile
);
3499 if (p
[0] == ':' && p
[1] == ':')
3501 /* chill the list of fields: the last entry (at the head) is a
3502 partially constructed entry which we now scrub. */
3503 fip
-> list
= fip
-> list
-> next
;
3508 /* The stabs for C++ derived classes contain baseclass information which
3509 is marked by a '!' character after the total size. This function is
3510 called when we encounter the baseclass marker, and slurps up all the
3511 baseclass information.
3513 Immediately following the '!' marker is the number of base classes that
3514 the class is derived from, followed by information for each base class.
3515 For each base class, there are two visibility specifiers, a bit offset
3516 to the base class information within the derived class, a reference to
3517 the type for the base class, and a terminating semicolon.
3519 A typical example, with two base classes, would be "!2,020,19;0264,21;".
3521 Baseclass information marker __________________|| | | | | | |
3522 Number of baseclasses __________________________| | | | | | |
3523 Visibility specifiers (2) ________________________| | | | | |
3524 Offset in bits from start of class _________________| | | | |
3525 Type number for base class ___________________________| | | |
3526 Visibility specifiers (2) _______________________________| | |
3527 Offset in bits from start of class ________________________| |
3528 Type number of base class ____________________________________|
3530 Return 1 for success, 0 for (error-type-inducing) failure. */
3533 read_baseclasses (fip
, pp
, type
, objfile
)
3534 struct field_info
*fip
;
3537 struct objfile
*objfile
;
3540 struct nextfield
*new;
3548 /* Skip the '!' baseclass information marker. */
3552 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3555 TYPE_N_BASECLASSES (type
) = read_huge_number (pp
, ',', &nbits
);
3561 /* Some stupid compilers have trouble with the following, so break
3562 it up into simpler expressions. */
3563 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*)
3564 TYPE_ALLOC (type
, B_BYTES (TYPE_N_BASECLASSES (type
)));
3567 int num_bytes
= B_BYTES (TYPE_N_BASECLASSES (type
));
3570 pointer
= (char *) TYPE_ALLOC (type
, num_bytes
);
3571 TYPE_FIELD_VIRTUAL_BITS (type
) = (B_TYPE
*) pointer
;
3575 B_CLRALL (TYPE_FIELD_VIRTUAL_BITS (type
), TYPE_N_BASECLASSES (type
));
3577 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
3579 new = (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
3580 make_cleanup (free
, new);
3581 memset (new, 0, sizeof (struct nextfield
));
3582 new -> next
= fip
-> list
;
3584 FIELD_BITSIZE (new->field
) = 0; /* this should be an unpacked field! */
3586 STABS_CONTINUE (pp
, objfile
);
3590 /* Nothing to do. */
3593 SET_TYPE_FIELD_VIRTUAL (type
, i
);
3596 /* Unknown character. Complain and treat it as non-virtual. */
3598 static struct complaint msg
= {
3599 "Unknown virtual character `%c' for baseclass", 0, 0};
3600 complain (&msg
, **pp
);
3605 new -> visibility
= *(*pp
)++;
3606 switch (new -> visibility
)
3608 case VISIBILITY_PRIVATE
:
3609 case VISIBILITY_PROTECTED
:
3610 case VISIBILITY_PUBLIC
:
3613 /* Bad visibility format. Complain and treat it as
3616 static struct complaint msg
= {
3617 "Unknown visibility `%c' for baseclass", 0, 0};
3618 complain (&msg
, new -> visibility
);
3619 new -> visibility
= VISIBILITY_PUBLIC
;
3626 /* The remaining value is the bit offset of the portion of the object
3627 corresponding to this baseclass. Always zero in the absence of
3628 multiple inheritance. */
3630 FIELD_BITPOS (new->field
) = read_huge_number (pp
, ',', &nbits
);
3635 /* The last piece of baseclass information is the type of the
3636 base class. Read it, and remember it's type name as this
3639 new -> field
.type
= read_type (pp
, objfile
);
3640 new -> field
.name
= type_name_no_tag (new -> field
.type
);
3642 /* skip trailing ';' and bump count of number of fields seen */
3651 /* The tail end of stabs for C++ classes that contain a virtual function
3652 pointer contains a tilde, a %, and a type number.
3653 The type number refers to the base class (possibly this class itself) which
3654 contains the vtable pointer for the current class.
3656 This function is called when we have parsed all the method declarations,
3657 so we can look for the vptr base class info. */
3660 read_tilde_fields (fip
, pp
, type
, objfile
)
3661 struct field_info
*fip
;
3664 struct objfile
*objfile
;
3668 STABS_CONTINUE (pp
, objfile
);
3670 /* If we are positioned at a ';', then skip it. */
3680 if (**pp
== '=' || **pp
== '+' || **pp
== '-')
3682 /* Obsolete flags that used to indicate the presence
3683 of constructors and/or destructors. */
3687 /* Read either a '%' or the final ';'. */
3688 if (*(*pp
)++ == '%')
3690 /* The next number is the type number of the base class
3691 (possibly our own class) which supplies the vtable for
3692 this class. Parse it out, and search that class to find
3693 its vtable pointer, and install those into TYPE_VPTR_BASETYPE
3694 and TYPE_VPTR_FIELDNO. */
3699 t
= read_type (pp
, objfile
);
3701 while (*p
!= '\0' && *p
!= ';')
3707 /* Premature end of symbol. */
3711 TYPE_VPTR_BASETYPE (type
) = t
;
3712 if (type
== t
) /* Our own class provides vtbl ptr */
3714 for (i
= TYPE_NFIELDS (t
) - 1;
3715 i
>= TYPE_N_BASECLASSES (t
);
3718 if (! strncmp (TYPE_FIELD_NAME (t
, i
), vptr_name
,
3719 sizeof (vptr_name
) - 1))
3721 TYPE_VPTR_FIELDNO (type
) = i
;
3725 /* Virtual function table field not found. */
3726 complain (&vtbl_notfound_complaint
, TYPE_NAME (type
));
3731 TYPE_VPTR_FIELDNO (type
) = TYPE_VPTR_FIELDNO (t
);
3742 attach_fn_fields_to_type (fip
, type
)
3743 struct field_info
*fip
;
3744 register struct type
*type
;
3748 for (n
= TYPE_NFN_FIELDS (type
);
3749 fip
-> fnlist
!= NULL
;
3750 fip
-> fnlist
= fip
-> fnlist
-> next
)
3752 --n
; /* Circumvent Sun3 compiler bug */
3753 TYPE_FN_FIELDLISTS (type
)[n
] = fip
-> fnlist
-> fn_fieldlist
;
3758 /* read cfront class static data.
3759 pp points to string starting with the list of static data
3760 eg: A:ZcA;1@Bpub v2@Bvirpri;__ct__1AFv func__1AFv *sfunc__1AFv ;as__1A ;;
3763 A:ZcA;;foopri__1AFv foopro__1AFv __ct__1AFv __ct__1AFRC1A foopub__1AFv ;;;
3768 read_cfront_static_fields (fip
, pp
, type
, objfile
)
3769 struct field_info
*fip
;
3772 struct objfile
*objfile
;
3774 struct nextfield
* new;
3777 struct symbol
* ref_static
=0;
3779 if (**pp
==';') /* no static data; return */
3785 /* Process each field in the list until we find the terminating ";" */
3787 /* eg: p = "as__1A ;;;" */
3788 STABS_CONTINUE (pp
, objfile
); /* handle \\ */
3789 while (**pp
!=';' && (sname
= get_substring (pp
, ' '), sname
))
3791 ref_static
= lookup_symbol (sname
, 0, VAR_NAMESPACE
, 0, 0); /*demangled_name*/
3794 static struct complaint msg
= {"\
3795 Unable to find symbol for static data field %s\n",
3797 complain (&msg
, sname
);
3800 stype
= SYMBOL_TYPE(ref_static
);
3802 /* allocate a new fip */
3803 new = (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
3804 make_cleanup (free
, new);
3805 memset (new, 0, sizeof (struct nextfield
));
3806 new -> next
= fip
-> list
;
3809 /* set visibility */
3810 /* FIXME! no way to tell visibility from stabs??? */
3811 new -> visibility
= VISIBILITY_PUBLIC
;
3813 /* set field info into fip */
3814 fip
-> list
-> field
.type
= stype
;
3816 /* set bitpos & bitsize */
3817 SET_FIELD_PHYSNAME (fip
->list
->field
, savestring (sname
, strlen (sname
)));
3819 /* set name field */
3820 /* The following is code to work around cfront generated stabs.
3821 The stabs contains full mangled name for each field.
3822 We try to demangle the name and extract the field name out of it.
3827 dem
= cplus_demangle (sname
, DMGL_ANSI
| DMGL_PARAMS
);
3830 dem_p
= strrchr (dem
, ':');
3831 if (dem_p
!= 0 && *(dem_p
-1)==':')
3833 fip
->list
->field
.name
=
3834 obsavestring (dem_p
, strlen (dem_p
), &objfile
-> type_obstack
);
3838 fip
->list
->field
.name
=
3839 obsavestring (sname
, strlen (sname
), &objfile
-> type_obstack
);
3841 } /* end of code for cfront work around */
3842 } /* loop again for next static field */
3846 /* Copy structure fields to fip so attach_fields_to_type will work.
3847 type has already been created with the initial instance data fields.
3848 Now we want to be able to add the other members to the class,
3849 so we want to add them back to the fip and reattach them again
3850 once we have collected all the class members. */
3853 copy_cfront_struct_fields (fip
, type
, objfile
)
3854 struct field_info
*fip
;
3856 struct objfile
*objfile
;
3858 int nfields
= TYPE_NFIELDS(type
);
3860 struct nextfield
* new;
3862 /* Copy the fields into the list of fips and reset the types
3863 to remove the old fields */
3865 for (i
=0; i
<nfields
; i
++)
3867 /* allocate a new fip */
3868 new = (struct nextfield
*) xmalloc (sizeof (struct nextfield
));
3869 make_cleanup (free
, new);
3870 memset (new, 0, sizeof (struct nextfield
));
3871 new -> next
= fip
-> list
;
3874 /* copy field info into fip */
3875 new -> field
= TYPE_FIELD (type
, i
);
3876 /* set visibility */
3877 if (TYPE_FIELD_PROTECTED (type
, i
))
3878 new -> visibility
= VISIBILITY_PROTECTED
;
3879 else if (TYPE_FIELD_PRIVATE (type
, i
))
3880 new -> visibility
= VISIBILITY_PRIVATE
;
3882 new -> visibility
= VISIBILITY_PUBLIC
;
3884 /* Now delete the fields from the type since we will be
3885 allocing new space once we get the rest of the fields
3886 in attach_fields_to_type.
3887 The pointer TYPE_FIELDS(type) is left dangling but should
3888 be freed later by objstack_free */
3889 TYPE_FIELDS (type
)=0;
3890 TYPE_NFIELDS (type
) = 0;
3895 /* Create the vector of fields, and record how big it is.
3896 We need this info to record proper virtual function table information
3897 for this class's virtual functions. */
3900 attach_fields_to_type (fip
, type
, objfile
)
3901 struct field_info
*fip
;
3902 register struct type
*type
;
3903 struct objfile
*objfile
;
3905 register int nfields
= 0;
3906 register int non_public_fields
= 0;
3907 register struct nextfield
*scan
;
3909 /* Count up the number of fields that we have, as well as taking note of
3910 whether or not there are any non-public fields, which requires us to
3911 allocate and build the private_field_bits and protected_field_bits
3914 for (scan
= fip
-> list
; scan
!= NULL
; scan
= scan
-> next
)
3917 if (scan
-> visibility
!= VISIBILITY_PUBLIC
)
3919 non_public_fields
++;
3923 /* Now we know how many fields there are, and whether or not there are any
3924 non-public fields. Record the field count, allocate space for the
3925 array of fields, and create blank visibility bitfields if necessary. */
3927 TYPE_NFIELDS (type
) = nfields
;
3928 TYPE_FIELDS (type
) = (struct field
*)
3929 TYPE_ALLOC (type
, sizeof (struct field
) * nfields
);
3930 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nfields
);
3932 if (non_public_fields
)
3934 ALLOCATE_CPLUS_STRUCT_TYPE (type
);
3936 TYPE_FIELD_PRIVATE_BITS (type
) =
3937 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3938 B_CLRALL (TYPE_FIELD_PRIVATE_BITS (type
), nfields
);
3940 TYPE_FIELD_PROTECTED_BITS (type
) =
3941 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3942 B_CLRALL (TYPE_FIELD_PROTECTED_BITS (type
), nfields
);
3944 TYPE_FIELD_IGNORE_BITS (type
) =
3945 (B_TYPE
*) TYPE_ALLOC (type
, B_BYTES (nfields
));
3946 B_CLRALL (TYPE_FIELD_IGNORE_BITS (type
), nfields
);
3949 /* Copy the saved-up fields into the field vector. Start from the head
3950 of the list, adding to the tail of the field array, so that they end
3951 up in the same order in the array in which they were added to the list. */
3953 while (nfields
-- > 0)
3955 TYPE_FIELD (type
, nfields
) = fip
-> list
-> field
;
3956 switch (fip
-> list
-> visibility
)
3958 case VISIBILITY_PRIVATE
:
3959 SET_TYPE_FIELD_PRIVATE (type
, nfields
);
3962 case VISIBILITY_PROTECTED
:
3963 SET_TYPE_FIELD_PROTECTED (type
, nfields
);
3966 case VISIBILITY_IGNORE
:
3967 SET_TYPE_FIELD_IGNORE (type
, nfields
);
3970 case VISIBILITY_PUBLIC
:
3974 /* Unknown visibility. Complain and treat it as public. */
3976 static struct complaint msg
= {
3977 "Unknown visibility `%c' for field", 0, 0};
3978 complain (&msg
, fip
-> list
-> visibility
);
3982 fip
-> list
= fip
-> list
-> next
;
3987 /* Read the description of a structure (or union type) and return an object
3988 describing the type.
3990 PP points to a character pointer that points to the next unconsumed token
3991 in the the stabs string. For example, given stabs "A:T4=s4a:1,0,32;;",
3992 *PP will point to "4a:1,0,32;;".
3994 TYPE points to an incomplete type that needs to be filled in.
3996 OBJFILE points to the current objfile from which the stabs information is
3997 being read. (Note that it is redundant in that TYPE also contains a pointer
3998 to this same objfile, so it might be a good idea to eliminate it. FIXME).
4001 static struct type
*
4002 read_struct_type (pp
, type
, objfile
)
4005 struct objfile
*objfile
;
4007 struct cleanup
*back_to
;
4008 struct field_info fi
;
4013 back_to
= make_cleanup (null_cleanup
, 0);
4015 INIT_CPLUS_SPECIFIC (type
);
4016 TYPE_FLAGS (type
) &= ~TYPE_FLAG_STUB
;
4018 /* First comes the total size in bytes. */
4022 TYPE_LENGTH (type
) = read_huge_number (pp
, 0, &nbits
);
4024 return error_type (pp
, objfile
);
4027 /* Now read the baseclasses, if any, read the regular C struct or C++
4028 class member fields, attach the fields to the type, read the C++
4029 member functions, attach them to the type, and then read any tilde
4030 field (baseclass specifier for the class holding the main vtable). */
4032 if (!read_baseclasses (&fi
, pp
, type
, objfile
)
4033 || !read_struct_fields (&fi
, pp
, type
, objfile
)
4034 || !attach_fields_to_type (&fi
, type
, objfile
)
4035 || !read_member_functions (&fi
, pp
, type
, objfile
)
4036 || !attach_fn_fields_to_type (&fi
, type
)
4037 || !read_tilde_fields (&fi
, pp
, type
, objfile
))
4039 type
= error_type (pp
, objfile
);
4042 do_cleanups (back_to
);
4046 /* Read a definition of an array type,
4047 and create and return a suitable type object.
4048 Also creates a range type which represents the bounds of that
4051 static struct type
*
4052 read_array_type (pp
, type
, objfile
)
4054 register struct type
*type
;
4055 struct objfile
*objfile
;
4057 struct type
*index_type
, *element_type
, *range_type
;
4062 /* Format of an array type:
4063 "ar<index type>;lower;upper;<array_contents_type>".
4064 OS9000: "arlower,upper;<array_contents_type>".
4066 Fortran adjustable arrays use Adigits or Tdigits for lower or upper;
4067 for these, produce a type like float[][]. */
4070 index_type
= builtin_type_int
;
4073 index_type
= read_type (pp
, objfile
);
4075 /* Improper format of array type decl. */
4076 return error_type (pp
, objfile
);
4080 if (!(**pp
>= '0' && **pp
<= '9') && **pp
!= '-')
4085 lower
= read_huge_number (pp
, os9k_stabs
? ',' : ';', &nbits
);
4087 return error_type (pp
, objfile
);
4089 if (!(**pp
>= '0' && **pp
<= '9') && **pp
!= '-')
4094 upper
= read_huge_number (pp
, ';', &nbits
);
4096 return error_type (pp
, objfile
);
4098 element_type
= read_type (pp
, objfile
);
4107 create_range_type ((struct type
*) NULL
, index_type
, lower
, upper
);
4108 type
= create_array_type (type
, element_type
, range_type
);
4114 /* Read a definition of an enumeration type,
4115 and create and return a suitable type object.
4116 Also defines the symbols that represent the values of the type. */
4118 static struct type
*
4119 read_enum_type (pp
, type
, objfile
)
4121 register struct type
*type
;
4122 struct objfile
*objfile
;
4127 register struct symbol
*sym
;
4129 struct pending
**symlist
;
4130 struct pending
*osyms
, *syms
;
4133 int unsigned_enum
= 1;
4136 /* FIXME! The stabs produced by Sun CC merrily define things that ought
4137 to be file-scope, between N_FN entries, using N_LSYM. What's a mother
4138 to do? For now, force all enum values to file scope. */
4139 if (within_function
)
4140 symlist
= &local_symbols
;
4143 symlist
= &file_symbols
;
4145 o_nsyms
= osyms
? osyms
->nsyms
: 0;
4149 /* Size. Perhaps this does not have to be conditionalized on
4150 os9k_stabs (assuming the name of an enum constant can't start
4152 read_huge_number (pp
, 0, &nbits
);
4154 return error_type (pp
, objfile
);
4157 /* The aix4 compiler emits an extra field before the enum members;
4158 my guess is it's a type of some sort. Just ignore it. */
4161 /* Skip over the type. */
4165 /* Skip over the colon. */
4169 /* Read the value-names and their values.
4170 The input syntax is NAME:VALUE,NAME:VALUE, and so on.
4171 A semicolon or comma instead of a NAME means the end. */
4172 while (**pp
&& **pp
!= ';' && **pp
!= ',')
4174 STABS_CONTINUE (pp
, objfile
);
4176 while (*p
!= ':') p
++;
4177 name
= obsavestring (*pp
, p
- *pp
, &objfile
-> symbol_obstack
);
4179 n
= read_huge_number (pp
, ',', &nbits
);
4181 return error_type (pp
, objfile
);
4183 sym
= (struct symbol
*)
4184 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
4185 memset (sym
, 0, sizeof (struct symbol
));
4186 SYMBOL_NAME (sym
) = name
;
4187 SYMBOL_LANGUAGE (sym
) = current_subfile
-> language
;
4188 SYMBOL_CLASS (sym
) = LOC_CONST
;
4189 SYMBOL_NAMESPACE (sym
) = VAR_NAMESPACE
;
4190 SYMBOL_VALUE (sym
) = n
;
4193 add_symbol_to_list (sym
, symlist
);
4198 (*pp
)++; /* Skip the semicolon. */
4200 /* Now fill in the fields of the type-structure. */
4202 TYPE_LENGTH (type
) = TARGET_INT_BIT
/ HOST_CHAR_BIT
;
4203 TYPE_CODE (type
) = TYPE_CODE_ENUM
;
4204 TYPE_FLAGS (type
) &= ~TYPE_FLAG_STUB
;
4206 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
4207 TYPE_NFIELDS (type
) = nsyms
;
4208 TYPE_FIELDS (type
) = (struct field
*)
4209 TYPE_ALLOC (type
, sizeof (struct field
) * nsyms
);
4210 memset (TYPE_FIELDS (type
), 0, sizeof (struct field
) * nsyms
);
4212 /* Find the symbols for the values and put them into the type.
4213 The symbols can be found in the symlist that we put them on
4214 to cause them to be defined. osyms contains the old value
4215 of that symlist; everything up to there was defined by us. */
4216 /* Note that we preserve the order of the enum constants, so
4217 that in something like "enum {FOO, LAST_THING=FOO}" we print
4218 FOO, not LAST_THING. */
4220 for (syms
= *symlist
, n
= nsyms
- 1; syms
; syms
= syms
->next
)
4222 int last
= syms
== osyms
? o_nsyms
: 0;
4223 int j
= syms
->nsyms
;
4224 for (; --j
>= last
; --n
)
4226 struct symbol
*xsym
= syms
->symbol
[j
];
4227 SYMBOL_TYPE (xsym
) = type
;
4228 TYPE_FIELD_NAME (type
, n
) = SYMBOL_NAME (xsym
);
4229 TYPE_FIELD_BITPOS (type
, n
) = SYMBOL_VALUE (xsym
);
4230 TYPE_FIELD_BITSIZE (type
, n
) = 0;
4239 /* Sun's ACC uses a somewhat saner method for specifying the builtin
4240 typedefs in every file (for int, long, etc):
4242 type = b <signed> <width>; <offset>; <nbits>
4243 signed = u or s. Possible c in addition to u or s (for char?).
4244 offset = offset from high order bit to start bit of type.
4245 width is # bytes in object of this type, nbits is # bits in type.
4247 The width/offset stuff appears to be for small objects stored in
4248 larger ones (e.g. `shorts' in `int' registers). We ignore it for now,
4251 static struct type
*
4252 read_sun_builtin_type (pp
, typenums
, objfile
)
4255 struct objfile
*objfile
;
4270 return error_type (pp
, objfile
);
4274 /* For some odd reason, all forms of char put a c here. This is strange
4275 because no other type has this honor. We can safely ignore this because
4276 we actually determine 'char'acterness by the number of bits specified in
4282 /* The first number appears to be the number of bytes occupied
4283 by this type, except that unsigned short is 4 instead of 2.
4284 Since this information is redundant with the third number,
4285 we will ignore it. */
4286 read_huge_number (pp
, ';', &nbits
);
4288 return error_type (pp
, objfile
);
4290 /* The second number is always 0, so ignore it too. */
4291 read_huge_number (pp
, ';', &nbits
);
4293 return error_type (pp
, objfile
);
4295 /* The third number is the number of bits for this type. */
4296 type_bits
= read_huge_number (pp
, 0, &nbits
);
4298 return error_type (pp
, objfile
);
4299 /* The type *should* end with a semicolon. If it are embedded
4300 in a larger type the semicolon may be the only way to know where
4301 the type ends. If this type is at the end of the stabstring we
4302 can deal with the omitted semicolon (but we don't have to like
4303 it). Don't bother to complain(), Sun's compiler omits the semicolon
4309 return init_type (TYPE_CODE_VOID
, 1,
4310 signed_type
? 0 : TYPE_FLAG_UNSIGNED
, (char *)NULL
,
4313 return init_type (TYPE_CODE_INT
,
4314 type_bits
/ TARGET_CHAR_BIT
,
4315 signed_type
? 0 : TYPE_FLAG_UNSIGNED
, (char *)NULL
,
4319 static struct type
*
4320 read_sun_floating_type (pp
, typenums
, objfile
)
4323 struct objfile
*objfile
;
4329 /* The first number has more details about the type, for example
4331 details
= read_huge_number (pp
, ';', &nbits
);
4333 return error_type (pp
, objfile
);
4335 /* The second number is the number of bytes occupied by this type */
4336 nbytes
= read_huge_number (pp
, ';', &nbits
);
4338 return error_type (pp
, objfile
);
4340 if (details
== NF_COMPLEX
|| details
== NF_COMPLEX16
4341 || details
== NF_COMPLEX32
)
4342 /* This is a type we can't handle, but we do know the size.
4343 We also will be able to give it a name. */
4344 return init_type (TYPE_CODE_ERROR
, nbytes
, 0, NULL
, objfile
);
4346 return init_type (TYPE_CODE_FLT
, nbytes
, 0, NULL
, objfile
);
4349 /* Read a number from the string pointed to by *PP.
4350 The value of *PP is advanced over the number.
4351 If END is nonzero, the character that ends the
4352 number must match END, or an error happens;
4353 and that character is skipped if it does match.
4354 If END is zero, *PP is left pointing to that character.
4356 If the number fits in a long, set *BITS to 0 and return the value.
4357 If not, set *BITS to be the number of bits in the number and return 0.
4359 If encounter garbage, set *BITS to -1 and return 0. */
4362 read_huge_number (pp
, end
, bits
)
4382 /* Leading zero means octal. GCC uses this to output values larger
4383 than an int (because that would be hard in decimal). */
4391 upper_limit
= ULONG_MAX
/ radix
;
4393 upper_limit
= LONG_MAX
/ radix
;
4395 while ((c
= *p
++) >= '0' && c
< ('0' + radix
))
4397 if (n
<= upper_limit
)
4400 n
+= c
- '0'; /* FIXME this overflows anyway */
4405 /* This depends on large values being output in octal, which is
4412 /* Ignore leading zeroes. */
4416 else if (c
== '2' || c
== '3')
4442 /* Large decimal constants are an error (because it is hard to
4443 count how many bits are in them). */
4449 /* -0x7f is the same as 0x80. So deal with it by adding one to
4450 the number of bits. */
4462 /* It's *BITS which has the interesting information. */
4466 static struct type
*
4467 read_range_type (pp
, typenums
, objfile
)
4470 struct objfile
*objfile
;
4472 char *orig_pp
= *pp
;
4477 struct type
*result_type
;
4478 struct type
*index_type
= NULL
;
4480 /* First comes a type we are a subrange of.
4481 In C it is usually 0, 1 or the type being defined. */
4482 if (read_type_number (pp
, rangenums
) != 0)
4483 return error_type (pp
, objfile
);
4484 self_subrange
= (rangenums
[0] == typenums
[0] &&
4485 rangenums
[1] == typenums
[1]);
4490 index_type
= read_type (pp
, objfile
);
4493 /* A semicolon should now follow; skip it. */
4497 /* The remaining two operands are usually lower and upper bounds
4498 of the range. But in some special cases they mean something else. */
4499 n2
= read_huge_number (pp
, ';', &n2bits
);
4500 n3
= read_huge_number (pp
, ';', &n3bits
);
4502 if (n2bits
== -1 || n3bits
== -1)
4503 return error_type (pp
, objfile
);
4506 goto handle_true_range
;
4508 /* If limits are huge, must be large integral type. */
4509 if (n2bits
!= 0 || n3bits
!= 0)
4511 char got_signed
= 0;
4512 char got_unsigned
= 0;
4513 /* Number of bits in the type. */
4516 /* Range from 0 to <large number> is an unsigned large integral type. */
4517 if ((n2bits
== 0 && n2
== 0) && n3bits
!= 0)
4522 /* Range from <large number> to <large number>-1 is a large signed
4523 integral type. Take care of the case where <large number> doesn't
4524 fit in a long but <large number>-1 does. */
4525 else if ((n2bits
!= 0 && n3bits
!= 0 && n2bits
== n3bits
+ 1)
4526 || (n2bits
!= 0 && n3bits
== 0
4527 && (n2bits
== sizeof (long) * HOST_CHAR_BIT
)
4534 if (got_signed
|| got_unsigned
)
4536 return init_type (TYPE_CODE_INT
, nbits
/ TARGET_CHAR_BIT
,
4537 got_unsigned
? TYPE_FLAG_UNSIGNED
: 0, NULL
,
4541 return error_type (pp
, objfile
);
4544 /* A type defined as a subrange of itself, with bounds both 0, is void. */
4545 if (self_subrange
&& n2
== 0 && n3
== 0)
4546 return init_type (TYPE_CODE_VOID
, 1, 0, NULL
, objfile
);
4548 /* If n3 is zero and n2 is positive, we want a floating type,
4549 and n2 is the width in bytes.
4551 Fortran programs appear to use this for complex types also,
4552 and they give no way to distinguish between double and single-complex!
4554 GDB does not have complex types.
4556 Just return the complex as a float of that size. It won't work right
4557 for the complex values, but at least it makes the file loadable. */
4559 if (n3
== 0 && n2
> 0)
4561 return init_type (TYPE_CODE_FLT
, n2
, 0, NULL
, objfile
);
4564 /* If the upper bound is -1, it must really be an unsigned int. */
4566 else if (n2
== 0 && n3
== -1)
4568 /* It is unsigned int or unsigned long. */
4569 /* GCC 2.3.3 uses this for long long too, but that is just a GDB 3.5
4570 compatibility hack. */
4571 return init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
4572 TYPE_FLAG_UNSIGNED
, NULL
, objfile
);
4575 /* Special case: char is defined (Who knows why) as a subrange of
4576 itself with range 0-127. */
4577 else if (self_subrange
&& n2
== 0 && n3
== 127)
4578 return init_type (TYPE_CODE_INT
, 1, 0, NULL
, objfile
);
4580 else if (current_symbol
&& SYMBOL_LANGUAGE (current_symbol
) == language_chill
4582 goto handle_true_range
;
4584 /* We used to do this only for subrange of self or subrange of int. */
4588 /* n3 actually gives the size. */
4589 return init_type (TYPE_CODE_INT
, - n3
, TYPE_FLAG_UNSIGNED
,
4592 return init_type (TYPE_CODE_INT
, 1, TYPE_FLAG_UNSIGNED
, NULL
, objfile
);
4594 return init_type (TYPE_CODE_INT
, 2, TYPE_FLAG_UNSIGNED
, NULL
, objfile
);
4596 /* -1 is used for the upper bound of (4 byte) "unsigned int" and
4597 "unsigned long", and we already checked for that,
4598 so don't need to test for it here. */
4600 /* I think this is for Convex "long long". Since I don't know whether
4601 Convex sets self_subrange, I also accept that particular size regardless
4602 of self_subrange. */
4603 else if (n3
== 0 && n2
< 0
4605 || n2
== - TARGET_LONG_LONG_BIT
/ TARGET_CHAR_BIT
))
4606 return init_type (TYPE_CODE_INT
, - n2
, 0, NULL
, objfile
);
4607 else if (n2
== -n3
-1)
4610 return init_type (TYPE_CODE_INT
, 1, 0, NULL
, objfile
);
4612 return init_type (TYPE_CODE_INT
, 2, 0, NULL
, objfile
);
4613 if (n3
== 0x7fffffff)
4614 return init_type (TYPE_CODE_INT
, 4, 0, NULL
, objfile
);
4617 /* We have a real range type on our hands. Allocate space and
4618 return a real pointer. */
4622 index_type
= builtin_type_int
;
4624 index_type
= *dbx_lookup_type (rangenums
);
4625 if (index_type
== NULL
)
4627 /* Does this actually ever happen? Is that why we are worrying
4628 about dealing with it rather than just calling error_type? */
4630 static struct type
*range_type_index
;
4632 complain (&range_type_base_complaint
, rangenums
[1]);
4633 if (range_type_index
== NULL
)
4635 init_type (TYPE_CODE_INT
, TARGET_INT_BIT
/ TARGET_CHAR_BIT
,
4636 0, "range type index type", NULL
);
4637 index_type
= range_type_index
;
4640 result_type
= create_range_type ((struct type
*) NULL
, index_type
, n2
, n3
);
4641 return (result_type
);
4644 /* Read in an argument list. This is a list of types, separated by commas
4645 and terminated with END. Return the list of types read in, or (struct type
4646 **)-1 if there is an error. */
4648 static struct type
**
4649 read_args (pp
, end
, objfile
)
4652 struct objfile
*objfile
;
4654 /* FIXME! Remove this arbitrary limit! */
4655 struct type
*types
[1024], **rval
; /* allow for fns of 1023 parameters */
4661 /* Invalid argument list: no ','. */
4662 return (struct type
**)-1;
4664 STABS_CONTINUE (pp
, objfile
);
4665 types
[n
++] = read_type (pp
, objfile
);
4667 (*pp
)++; /* get past `end' (the ':' character) */
4671 rval
= (struct type
**) xmalloc (2 * sizeof (struct type
*));
4673 else if (TYPE_CODE (types
[n
-1]) != TYPE_CODE_VOID
)
4675 rval
= (struct type
**) xmalloc ((n
+ 1) * sizeof (struct type
*));
4676 memset (rval
+ n
, 0, sizeof (struct type
*));
4680 rval
= (struct type
**) xmalloc (n
* sizeof (struct type
*));
4682 memcpy (rval
, types
, n
* sizeof (struct type
*));
4686 /* Common block handling. */
4688 /* List of symbols declared since the last BCOMM. This list is a tail
4689 of local_symbols. When ECOMM is seen, the symbols on the list
4690 are noted so their proper addresses can be filled in later,
4691 using the common block base address gotten from the assembler
4694 static struct pending
*common_block
;
4695 static int common_block_i
;
4697 /* Name of the current common block. We get it from the BCOMM instead of the
4698 ECOMM to match IBM documentation (even though IBM puts the name both places
4699 like everyone else). */
4700 static char *common_block_name
;
4702 /* Process a N_BCOMM symbol. The storage for NAME is not guaranteed
4703 to remain after this function returns. */
4706 common_block_start (name
, objfile
)
4708 struct objfile
*objfile
;
4710 if (common_block_name
!= NULL
)
4712 static struct complaint msg
= {
4713 "Invalid symbol data: common block within common block",
4717 common_block
= local_symbols
;
4718 common_block_i
= local_symbols
? local_symbols
->nsyms
: 0;
4719 common_block_name
= obsavestring (name
, strlen (name
),
4720 &objfile
-> symbol_obstack
);
4723 /* Process a N_ECOMM symbol. */
4726 common_block_end (objfile
)
4727 struct objfile
*objfile
;
4729 /* Symbols declared since the BCOMM are to have the common block
4730 start address added in when we know it. common_block and
4731 common_block_i point to the first symbol after the BCOMM in
4732 the local_symbols list; copy the list and hang it off the
4733 symbol for the common block name for later fixup. */
4736 struct pending
*new = 0;
4737 struct pending
*next
;
4740 if (common_block_name
== NULL
)
4742 static struct complaint msg
= {"ECOMM symbol unmatched by BCOMM", 0, 0};
4747 sym
= (struct symbol
*)
4748 obstack_alloc (&objfile
-> symbol_obstack
, sizeof (struct symbol
));
4749 memset (sym
, 0, sizeof (struct symbol
));
4750 /* Note: common_block_name already saved on symbol_obstack */
4751 SYMBOL_NAME (sym
) = common_block_name
;
4752 SYMBOL_CLASS (sym
) = LOC_BLOCK
;
4754 /* Now we copy all the symbols which have been defined since the BCOMM. */
4756 /* Copy all the struct pendings before common_block. */
4757 for (next
= local_symbols
;
4758 next
!= NULL
&& next
!= common_block
;
4761 for (j
= 0; j
< next
->nsyms
; j
++)
4762 add_symbol_to_list (next
->symbol
[j
], &new);
4765 /* Copy however much of COMMON_BLOCK we need. If COMMON_BLOCK is
4766 NULL, it means copy all the local symbols (which we already did
4769 if (common_block
!= NULL
)
4770 for (j
= common_block_i
; j
< common_block
->nsyms
; j
++)
4771 add_symbol_to_list (common_block
->symbol
[j
], &new);
4773 SYMBOL_TYPE (sym
) = (struct type
*) new;
4775 /* Should we be putting local_symbols back to what it was?
4778 i
= hashname (SYMBOL_NAME (sym
));
4779 SYMBOL_VALUE_CHAIN (sym
) = global_sym_chain
[i
];
4780 global_sym_chain
[i
] = sym
;
4781 common_block_name
= NULL
;
4784 /* Add a common block's start address to the offset of each symbol
4785 declared to be in it (by being between a BCOMM/ECOMM pair that uses
4786 the common block name). */
4789 fix_common_block (sym
, valu
)
4793 struct pending
*next
= (struct pending
*) SYMBOL_TYPE (sym
);
4794 for ( ; next
; next
= next
->next
)
4797 for (j
= next
->nsyms
- 1; j
>= 0; j
--)
4798 SYMBOL_VALUE_ADDRESS (next
->symbol
[j
]) += valu
;
4804 /* What about types defined as forward references inside of a small lexical
4806 /* Add a type to the list of undefined types to be checked through
4807 once this file has been read in. */
4810 add_undefined_type (type
)
4813 if (undef_types_length
== undef_types_allocated
)
4815 undef_types_allocated
*= 2;
4816 undef_types
= (struct type
**)
4817 xrealloc ((char *) undef_types
,
4818 undef_types_allocated
* sizeof (struct type
*));
4820 undef_types
[undef_types_length
++] = type
;
4823 /* Go through each undefined type, see if it's still undefined, and fix it
4824 up if possible. We have two kinds of undefined types:
4826 TYPE_CODE_ARRAY: Array whose target type wasn't defined yet.
4827 Fix: update array length using the element bounds
4828 and the target type's length.
4829 TYPE_CODE_STRUCT, TYPE_CODE_UNION: Structure whose fields were not
4830 yet defined at the time a pointer to it was made.
4831 Fix: Do a full lookup on the struct/union tag. */
4833 cleanup_undefined_types ()
4837 for (type
= undef_types
; type
< undef_types
+ undef_types_length
; type
++)
4839 switch (TYPE_CODE (*type
))
4842 case TYPE_CODE_STRUCT
:
4843 case TYPE_CODE_UNION
:
4844 case TYPE_CODE_ENUM
:
4846 /* Check if it has been defined since. Need to do this here
4847 as well as in check_typedef to deal with the (legitimate in
4848 C though not C++) case of several types with the same name
4849 in different source files. */
4850 if (TYPE_FLAGS (*type
) & TYPE_FLAG_STUB
)
4852 struct pending
*ppt
;
4854 /* Name of the type, without "struct" or "union" */
4855 char *typename
= TYPE_TAG_NAME (*type
);
4857 if (typename
== NULL
)
4859 static struct complaint msg
= {"need a type name", 0, 0};
4863 for (ppt
= file_symbols
; ppt
; ppt
= ppt
->next
)
4865 for (i
= 0; i
< ppt
->nsyms
; i
++)
4867 struct symbol
*sym
= ppt
->symbol
[i
];
4869 if (SYMBOL_CLASS (sym
) == LOC_TYPEDEF
4870 && SYMBOL_NAMESPACE (sym
) == STRUCT_NAMESPACE
4871 && (TYPE_CODE (SYMBOL_TYPE (sym
)) ==
4873 && STREQ (SYMBOL_NAME (sym
), typename
))
4875 memcpy (*type
, SYMBOL_TYPE (sym
),
4876 sizeof (struct type
));
4886 static struct complaint msg
= {"\
4887 GDB internal error. cleanup_undefined_types with bad type %d.", 0, 0};
4888 complain (&msg
, TYPE_CODE (*type
));
4894 undef_types_length
= 0;
4897 /* Scan through all of the global symbols defined in the object file,
4898 assigning values to the debugging symbols that need to be assigned
4899 to. Get these symbols from the minimal symbol table. */
4902 scan_file_globals (objfile
)
4903 struct objfile
*objfile
;
4906 struct minimal_symbol
*msymbol
;
4907 struct symbol
*sym
, *prev
, *rsym
;
4908 struct objfile
*resolve_objfile
;
4910 /* SVR4 based linkers copy referenced global symbols from shared
4911 libraries to the main executable.
4912 If we are scanning the symbols for a shared library, try to resolve
4913 them from the minimal symbols of the main executable first. */
4915 if (symfile_objfile
&& objfile
!= symfile_objfile
)
4916 resolve_objfile
= symfile_objfile
;
4918 resolve_objfile
= objfile
;
4922 /* Avoid expensive loop through all minimal symbols if there are
4923 no unresolved symbols. */
4924 for (hash
= 0; hash
< HASHSIZE
; hash
++)
4926 if (global_sym_chain
[hash
])
4929 if (hash
>= HASHSIZE
)
4932 for (msymbol
= resolve_objfile
-> msymbols
;
4933 msymbol
&& SYMBOL_NAME (msymbol
) != NULL
;
4938 /* Skip static symbols. */
4939 switch (MSYMBOL_TYPE (msymbol
))
4951 /* Get the hash index and check all the symbols
4952 under that hash index. */
4954 hash
= hashname (SYMBOL_NAME (msymbol
));
4956 for (sym
= global_sym_chain
[hash
]; sym
;)
4958 if (SYMBOL_NAME (msymbol
)[0] == SYMBOL_NAME (sym
)[0] &&
4959 STREQ(SYMBOL_NAME (msymbol
) + 1, SYMBOL_NAME (sym
) + 1))
4962 struct alias_list
*aliases
;
4964 /* Splice this symbol out of the hash chain and
4965 assign the value we have to it. */
4968 SYMBOL_VALUE_CHAIN (prev
) = SYMBOL_VALUE_CHAIN (sym
);
4972 global_sym_chain
[hash
] = SYMBOL_VALUE_CHAIN (sym
);
4975 /* Check to see whether we need to fix up a common block. */
4976 /* Note: this code might be executed several times for
4977 the same symbol if there are multiple references. */
4979 /* If symbol has aliases, do minimal symbol fixups for each.
4980 These live aliases/references weren't added to
4981 global_sym_chain hash but may also need to be fixed up. */
4982 /* FIXME: Maybe should have added aliases to the global chain, resolved symbol name, then treated aliases as normal
4983 symbols? Still, we wouldn't want to add_to_list. */
4984 /* Now do the same for each alias of this symbol */
4986 aliases
= SYMBOL_ALIASES (sym
);
4989 if (SYMBOL_CLASS (rsym
) == LOC_BLOCK
)
4991 fix_common_block (rsym
,
4992 SYMBOL_VALUE_ADDRESS (msymbol
));
4996 SYMBOL_VALUE_ADDRESS (rsym
)
4997 = SYMBOL_VALUE_ADDRESS (msymbol
);
4999 SYMBOL_SECTION (rsym
) = SYMBOL_SECTION (msymbol
);
5002 rsym
= aliases
->sym
;
5003 aliases
= aliases
->next
;
5012 sym
= SYMBOL_VALUE_CHAIN (prev
);
5016 sym
= global_sym_chain
[hash
];
5022 sym
= SYMBOL_VALUE_CHAIN (sym
);
5026 if (resolve_objfile
== objfile
)
5028 resolve_objfile
= objfile
;
5031 /* Change the storage class of any remaining unresolved globals to
5032 LOC_UNRESOLVED and remove them from the chain. */
5033 for (hash
= 0; hash
< HASHSIZE
; hash
++)
5035 sym
= global_sym_chain
[hash
];
5039 sym
= SYMBOL_VALUE_CHAIN (sym
);
5041 /* Change the symbol address from the misleading chain value
5043 SYMBOL_VALUE_ADDRESS (prev
) = 0;
5045 /* Complain about unresolved common block symbols. */
5046 if (SYMBOL_CLASS (prev
) == LOC_STATIC
)
5047 SYMBOL_CLASS (prev
) = LOC_UNRESOLVED
;
5049 complain (&unresolved_sym_chain_complaint
,
5050 objfile
-> name
, SYMBOL_NAME (prev
));
5053 memset (global_sym_chain
, 0, sizeof (global_sym_chain
));
5056 /* Initialize anything that needs initializing when starting to read
5057 a fresh piece of a symbol file, e.g. reading in the stuff corresponding
5065 /* Initialize anything that needs initializing when a completely new
5066 symbol file is specified (not just adding some symbols from another
5067 file, e.g. a shared library). */
5070 stabsread_new_init ()
5072 /* Empty the hash table of global syms looking for values. */
5073 memset (global_sym_chain
, 0, sizeof (global_sym_chain
));
5076 /* Initialize anything that needs initializing at the same time as
5077 start_symtab() is called. */
5081 global_stabs
= NULL
; /* AIX COFF */
5082 /* Leave FILENUM of 0 free for builtin types and this file's types. */
5083 n_this_object_header_files
= 1;
5084 type_vector_length
= 0;
5085 type_vector
= (struct type
**) 0;
5087 /* FIXME: If common_block_name is not already NULL, we should complain(). */
5088 common_block_name
= NULL
;
5093 /* Call after end_symtab() */
5099 free ((char *) type_vector
);
5102 type_vector_length
= 0;
5103 previous_stab_code
= 0;
5107 finish_global_stabs (objfile
)
5108 struct objfile
*objfile
;
5112 patch_block_stabs (global_symbols
, global_stabs
, objfile
);
5113 free ((PTR
) global_stabs
);
5114 global_stabs
= NULL
;
5118 /* Initializer for this module */
5121 _initialize_stabsread ()
5123 undef_types_allocated
= 20;
5124 undef_types_length
= 0;
5125 undef_types
= (struct type
**)
5126 xmalloc (undef_types_allocated
* sizeof (struct type
*));