Oodles of changes. The most important is adding support for stabs

[binutils.git] / gdb / symtab.h

diff --git a/gdb/symtab.h b/gdb/symtab.h
index 801bc5f12fb763c8892d83a5acc7ab45dacb56bb..bd7e050ac456eeb07ea1f52f6bf4447d02b44254 100644 (file)
--- a/gdb/symtab.h
+++ b/gdb/symtab.h
@@ -103,7 +103,7 @@ enum type_code
 
   /* Modula-2 */
   TYPE_CODE_CHAR,              /* *real* character type */
-  TYPE_CODE_BOOL,              /* Builtin Modula-2 BOOLEAN */
+  TYPE_CODE_BOOL               /* Builtin Modula-2 BOOLEAN */
 };
 
 /* This appears in a type's flags word for an unsigned integer type.  */
@@ -195,9 +195,11 @@ struct type
   int vptr_fieldno;
 
   /* Slot to point to additional language-specific fields of this type.  */
-  union
+  union type_specific
     {
+      /* ARG_TYPES is for TYPE_CODE_METHOD and TYPE_CODE_FUNC.  */
       struct type **arg_types;
+      /* CPLUS_STUFF is for TYPE_CODE_STRUCT.  */
       struct cplus_struct_type *cplus_stuff;
     } type_specific;
 };
@@ -244,20 +246,32 @@ struct cplus_struct_type
          struct type *fcontext;
          unsigned int is_const : 1;
          unsigned int is_volatile : 1;
+         unsigned int is_private : 1;
+         unsigned int is_protected : 1;
+         unsigned int is_stub : 1;
+         unsigned int dummy : 3;
+
          /* Index into that baseclass's virtual function table,
             minus 2; else if static: VOFFSET_STATIC; else: 0.  */
-         unsigned voffset : 30;
+         unsigned voffset : 24;
 #        define VOFFSET_STATIC 1
        } *fn_fields;
 
-      B_TYPE *private_fn_field_bits;
-      B_TYPE *protected_fn_field_bits;
-
     } *fn_fieldlists;
 
   unsigned char via_protected;
   unsigned char via_public;
 };
+/* The default value of TYPE_CPLUS_SPECIFIC(T) points to the
+   this shared static structure. */
+
+extern struct cplus_struct_type cplus_struct_default;
+
+extern void allocate_cplus_struct_type ();
+#define ALLOCATE_CPLUS_STRUCT_TYPE(type) allocate_cplus_struct_type (type)
+#define HAVE_CPLUS_STRUCT(type) \
+  (TYPE_CPLUS_SPECIFIC(type) != &cplus_struct_default)
+
 \f
 /* All of the name-scope contours of the program
    are represented by `struct block' objects.
@@ -358,7 +372,7 @@ struct block
 
 enum namespace
 {
-  UNDEF_NAMESPACE, VAR_NAMESPACE, STRUCT_NAMESPACE, LABEL_NAMESPACE,
+  UNDEF_NAMESPACE, VAR_NAMESPACE, STRUCT_NAMESPACE, LABEL_NAMESPACE
 };
 
 /* An address-class says where to find the value of a symbol.  */
@@ -381,7 +395,7 @@ enum address_class
                           `struct block'.  Function names have this class. */
   LOC_CONST_BYTES,     /* Value is a constant byte-sequence pointed to by
                           SYMBOL_VALUE_ADDRESS, in target byte order.  */
-  LOC_LOCAL_ARG,       /* Value is arg at spec'd offset in stack frame.
+  LOC_LOCAL_ARG                /* Value is arg at spec'd offset in stack frame.
                           Differs from LOC_LOCAL in that symbol is an
                           argument; differs from LOC_ARG in that we find it
                           in the frame (FRAME_LOCALS_ADDRESS), not in the
@@ -674,6 +688,7 @@ int current_source_line;
 #define TYPE_FN_FIELDS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->fn_fields
 #define TYPE_NFN_FIELDS(thistype) TYPE_CPLUS_SPECIFIC(thistype)->nfn_fields
 #define TYPE_NFN_FIELDS_TOTAL(thistype) TYPE_CPLUS_SPECIFIC(thistype)->nfn_fields_total
+#define        TYPE_TYPE_SPECIFIC(thistype) (thistype)->type_specific
 #define TYPE_ARG_TYPES(thistype) (thistype)->type_specific.arg_types
 #define TYPE_CPLUS_SPECIFIC(thistype) (thistype)->type_specific.cplus_stuff
 #define TYPE_BASECLASS(thistype,index) (thistype)->fields[index].type
@@ -705,9 +720,11 @@ int current_source_line;
 #define SET_TYPE_FIELD_VIRTUAL(thistype, n) \
   B_SET (TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (n))
 #define TYPE_FIELD_PRIVATE(thistype, n) \
-  B_TST(TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits, (n))
+  (TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits == NULL ? 0 \
+    : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->private_field_bits, (n)))
 #define TYPE_FIELD_PROTECTED(thistype, n) \
-B_TST(TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits, (n))
+  (TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits == NULL ? 0 \
+    : B_TST(TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits, (n)))
 #define TYPE_FIELD_VIRTUAL(thistype, n) \
        B_TST(TYPE_CPLUS_SPECIFIC(thistype)->virtual_field_bits, (n))
 
@@ -729,13 +746,9 @@ B_TST(TYPE_CPLUS_SPECIFIC(thistype)->protected_field_bits, (n))
 #define TYPE_FN_FIELD_STATIC_P(thisfn, n) ((thisfn)[n].voffset == VOFFSET_STATIC)
 #define TYPE_FN_FIELD_VOFFSET(thisfn, n) ((thisfn)[n].voffset-2)
 #define TYPE_FN_FIELD_FCONTEXT(thisfn, n) ((thisfn)[n].fcontext)
-
-#define TYPE_FN_PRIVATE_BITS(thisfn) (thisfn).private_fn_field_bits
-#define TYPE_FN_PROTECTED_BITS(thisfn) (thisfn).protected_fn_field_bits
-#define SET_TYPE_FN_PRIVATE(thisfn, n) B_SET ((thisfn).private_fn_field_bits, n)
-#define SET_TYPE_FN_PROTECTED(thisfn, n) B_SET ((thisfn).protected_fn_field_bits, n)
-#define TYPE_FN_PRIVATE(thisfn, n) B_TST ((thisfn).private_fn_field_bits, n)
-#define TYPE_FN_PROTECTED(thisfn, n) B_TST ((thisfn).protected_fn_field_bits, n)
+#define TYPE_FN_FIELD_STUB(thisfn, n) ((thisfn)[n].is_stub)
+#define TYPE_FN_FIELD_PRIVATE(thisfn, n) ((thisfn)[n].is_private)
+#define TYPE_FN_FIELD_PROTECTED(thisfn, n) ((thisfn)[n].is_protected)
 
 /* The virtual function table is now an array of structures
    which have the form { int16 offset, delta; void *pfn; }.