X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fgnu-v2-abi.c;h=fb31c44529f8580c69eba9061a913315d625e3aa;hb=45a15d6f78100ca3ba6fbd652951912be4814833;hp=3b7715230f0e06e67e14bc2f6a0ae05797fa78f6;hpb=1aa20aa88f25187a6947acc8d8ccaeb97daaa4d0;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/gnu-v2-abi.c b/gdb/gnu-v2-abi.c
index 3b7715230f..fb31c44529 100644
--- a/gdb/gnu-v2-abi.c
+++ b/gdb/gnu-v2-abi.c
@@ -34,6 +34,8 @@
 struct cp_abi_ops gnu_v2_abi_ops;
 
 static int vb_match (struct type *, int, struct type *);
+int gnuv2_baseclass_offset (struct type *type, int index, char *valaddr,
+			    CORE_ADDR address);
 
 static enum dtor_kinds
 gnuv2_is_destructor_name (const char *name)
@@ -82,11 +84,11 @@ gnuv2_is_operator_name (const char *name)
    J is an index into F which provides the desired virtual function.
 
    TYPE is the type in which F is located.  */
-static value_ptr
-gnuv2_virtual_fn_field (value_ptr * arg1p, struct fn_field * f, int j,
+static struct value *
+gnuv2_virtual_fn_field (struct value **arg1p, struct fn_field * f, int j,
 			struct type * type, int offset)
 {
-  value_ptr arg1 = *arg1p;
+  struct value *arg1 = *arg1p;
   struct type *type1 = check_typedef (VALUE_TYPE (arg1));
 
 
@@ -95,8 +97,10 @@ gnuv2_virtual_fn_field (value_ptr * arg1p, struct fn_field * f, int j,
      with a strange type, so cast it to type `pointer to long' (which
      should serve just fine as a function type).  Then, index into
      the table, and convert final value to appropriate function type.  */
-  value_ptr entry, vfn, vtbl;
-  value_ptr vi = value_from_longest (builtin_type_int,
+  struct value *entry;
+  struct value *vfn;
+  struct value *vtbl;
+  struct value *vi = value_from_longest (builtin_type_int,
 				     (LONGEST) TYPE_FN_FIELD_VOFFSET (f, j));
   struct type *fcontext = TYPE_FN_FIELD_FCONTEXT (f, j);
   struct type *context;
@@ -110,7 +114,7 @@ gnuv2_virtual_fn_field (value_ptr * arg1p, struct fn_field * f, int j,
   /* Now context is a pointer to the basetype containing the vtbl.  */
   if (TYPE_TARGET_TYPE (context) != type1)
     {
-      value_ptr tmp = value_cast (context, value_addr (arg1));
+      struct value *tmp = value_cast (context, value_addr (arg1));
       arg1 = value_ind (tmp);
       type1 = check_typedef (VALUE_TYPE (arg1));
     }
@@ -179,13 +183,12 @@ gnuv2_virtual_fn_field (value_ptr * arg1p, struct fn_field * f, int j,
 
 
 struct type *
-gnuv2_value_rtti_type (value_ptr v, int *full, int *top, int *using_enc)
+gnuv2_value_rtti_type (struct value *v, int *full, int *top, int *using_enc)
 {
   struct type *known_type;
   struct type *rtti_type;
   CORE_ADDR coreptr;
-  value_ptr vp;
-  int using_enclosing = 0;
+  struct value *vp;
   long top_offset = 0;
   char rtti_type_name[256];
   CORE_ADDR vtbl;
@@ -240,25 +243,7 @@ gnuv2_value_rtti_type (value_ptr v, int *full, int *top, int *using_enc)
   if (VALUE_ADDRESS (value_field (v, TYPE_VPTR_FIELDNO (known_type))) == 0)
     return NULL;
 
-  /*
-    If we are enclosed by something that isn't us, adjust the
-    address properly and set using_enclosing.
-  */
-  if (VALUE_ENCLOSING_TYPE(v) != VALUE_TYPE(v))
-    {
-      value_ptr tempval;
-      int bitpos = TYPE_BASECLASS_BITPOS (known_type,
-                                          TYPE_VPTR_FIELDNO (known_type));
-      tempval=value_field (v, TYPE_VPTR_FIELDNO(known_type));
-      VALUE_ADDRESS(tempval) += bitpos / 8;
-      vtbl=value_as_address (tempval);
-      using_enclosing=1;
-    }
-  else
-    {
-      vtbl=value_as_address(value_field(v,TYPE_VPTR_FIELDNO(known_type)));
-      using_enclosing=0;
-    }
+  vtbl=value_as_address(value_field(v,TYPE_VPTR_FIELDNO(known_type)));
 
   /* Try to find a symbol that is the vtable */
   minsym=lookup_minimal_symbol_by_pc(vtbl);
@@ -300,12 +285,104 @@ gnuv2_value_rtti_type (value_ptr v, int *full, int *top, int *using_enc)
       if (full)
         *full=1;
     }
-  if (using_enc)
-    *using_enc=using_enclosing;
 
   return rtti_type;
 }
 
+/* Return true if the INDEXth field of TYPE is a virtual baseclass
+   pointer which is for the base class whose type is BASECLASS.  */
+
+static int
+vb_match (struct type *type, int index, struct type *basetype)
+{
+  struct type *fieldtype;
+  char *name = TYPE_FIELD_NAME (type, index);
+  char *field_class_name = NULL;
+
+  if (*name != '_')
+    return 0;
+  /* gcc 2.4 uses _vb$.  */
+  if (name[1] == 'v' && name[2] == 'b' && is_cplus_marker (name[3]))
+    field_class_name = name + 4;
+  /* gcc 2.5 will use __vb_.  */
+  if (name[1] == '_' && name[2] == 'v' && name[3] == 'b' && name[4] == '_')
+    field_class_name = name + 5;
+
+  if (field_class_name == NULL)
+    /* This field is not a virtual base class pointer.  */
+    return 0;
+
+  /* It's a virtual baseclass pointer, now we just need to find out whether
+     it is for this baseclass.  */
+  fieldtype = TYPE_FIELD_TYPE (type, index);
+  if (fieldtype == NULL
+      || TYPE_CODE (fieldtype) != TYPE_CODE_PTR)
+    /* "Can't happen".  */
+    return 0;
+
+  /* What we check for is that either the types are equal (needed for
+     nameless types) or have the same name.  This is ugly, and a more
+     elegant solution should be devised (which would probably just push
+     the ugliness into symbol reading unless we change the stabs format).  */
+  if (TYPE_TARGET_TYPE (fieldtype) == basetype)
+    return 1;
+
+  if (TYPE_NAME (basetype) != NULL
+      && TYPE_NAME (TYPE_TARGET_TYPE (fieldtype)) != NULL
+      && STREQ (TYPE_NAME (basetype),
+		TYPE_NAME (TYPE_TARGET_TYPE (fieldtype))))
+    return 1;
+  return 0;
+}
+
+/* Compute the offset of the baseclass which is
+   the INDEXth baseclass of class TYPE,
+   for value at VALADDR (in host) at ADDRESS (in target).
+   The result is the offset of the baseclass value relative
+   to (the address of)(ARG) + OFFSET.
+
+   -1 is returned on error. */
+
+int
+gnuv2_baseclass_offset (struct type *type, int index, char *valaddr,
+		  CORE_ADDR address)
+{
+  struct type *basetype = TYPE_BASECLASS (type, index);
+
+  if (BASETYPE_VIA_VIRTUAL (type, index))
+    {
+      /* Must hunt for the pointer to this virtual baseclass.  */
+      register int i, len = TYPE_NFIELDS (type);
+      register int n_baseclasses = TYPE_N_BASECLASSES (type);
+
+      /* First look for the virtual baseclass pointer
+         in the fields.  */
+      for (i = n_baseclasses; i < len; i++)
+	{
+	  if (vb_match (type, i, basetype))
+	    {
+	      CORE_ADDR addr
+	      = unpack_pointer (TYPE_FIELD_TYPE (type, i),
+				valaddr + (TYPE_FIELD_BITPOS (type, i) / 8));
+
+	      return addr - (LONGEST) address;
+	    }
+	}
+      /* Not in the fields, so try looking through the baseclasses.  */
+      for (i = index + 1; i < n_baseclasses; i++)
+	{
+	  int boffset =
+	  baseclass_offset (type, i, valaddr, address);
+	  if (boffset)
+	    return boffset;
+	}
+      /* Not found.  */
+      return -1;
+    }
+
+  /* Baseclass is easily computed.  */
+  return TYPE_BASECLASS_BITPOS (type, index) / 8;
+}
 
 static void
 init_gnuv2_ops (void)
@@ -319,6 +396,7 @@ init_gnuv2_ops (void)
   gnu_v2_abi_ops.is_operator_name = gnuv2_is_operator_name;
   gnu_v2_abi_ops.virtual_fn_field = gnuv2_virtual_fn_field;
   gnu_v2_abi_ops.rtti_type = gnuv2_value_rtti_type;
+  gnu_v2_abi_ops.baseclass_offset = gnuv2_baseclass_offset;
 }
 
 void