Initial revision

From-SVN: r11151

gcc/cp/rtti.c

+/* RunTime Type Identification
+   Copyright (C) 1995, 1996 Free Software Foundation, Inc.
+
+This file is part of GNU CC.
+
+GNU CC is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU CC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU CC; see the file COPYING.  If not, write to
+the Free Software Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.  */
+
+
+#include "config.h"
+#include "tree.h"
+#include "cp-tree.h"
+#include "flags.h"
+#include "output.h"
+
+#undef NULL
+#define NULL 0
+
+extern tree define_function ();
+extern tree build_t_desc_overload ();
+extern struct obstack *permanent_obstack;
+
+/* in c-common.c */
+extern tree combine_strings PROTO((tree));
+
+/* Given the expression EXP of type `class *', return the head
+   of the object pointed to by EXP.  */
+tree
+build_headof (exp)
+     tree exp;
+{
+  tree type = TREE_TYPE (exp);
+  tree vptr, offset;
+
+  if (TREE_CODE (type) != POINTER_TYPE)
+    {
+      error ("`headof' applied to non-pointer type");
+      return error_mark_node;
+    }
+  type = TREE_TYPE (type);
+
+  if (!TYPE_VIRTUAL_P (type) || CLASSTYPE_VFIELD (type) == NULL_TREE)
+    return exp;
+
+  vptr = fold (size_binop (PLUS_EXPR, 
+	   size_binop (FLOOR_DIV_EXPR, 
+  	     DECL_FIELD_BITPOS (CLASSTYPE_VFIELD (type)),
+	     size_int (BITS_PER_UNIT)),
+ 	   exp)); 
+  vptr = build1 (INDIRECT_REF, build_pointer_type (vtable_entry_type), vptr);
+
+  if (flag_vtable_thunks)
+    offset = build_array_ref (vptr, integer_zero_node);
+  else
+    offset = build_component_ref (build_array_ref (vptr, integer_zero_node),
+				  delta_identifier,
+				  NULL_TREE, 0);
+
+  type = build_type_variant (ptr_type_node, TREE_READONLY (exp),
+			     TREE_THIS_VOLATILE (exp));
+  return build (PLUS_EXPR, type, exp,
+		convert (ptrdiff_type_node, offset));
+}
+
+/* Return the type_info node associated with the expression EXP.  If EXP is
+   a reference to a polymorphic class, return the dynamic type; otherwise
+   return the static type of the expression.  */
+tree
+build_typeid (exp)
+     tree exp;
+{
+  tree type;
+
+  if (!flag_rtti)
+    cp_error ("cannot take typeid of object when -frtti is not specified");
+
+  if (exp == error_mark_node)
+    return error_mark_node;
+
+  type = TREE_TYPE (exp);
+
+  /* Strip top-level cv-qualifiers.  */
+  type = TYPE_MAIN_VARIANT (type);
+
+  /* if b is an instance of B, typeid(b) == typeid(B).  Do this before
+     reference trickiness.  */
+  if (TREE_CODE (exp) == VAR_DECL && TREE_CODE (type) == RECORD_TYPE)
+    return get_typeid (type);
+
+  /* peel back references, so they match. */
+  if (TREE_CODE (type) == REFERENCE_TYPE)
+    type = TREE_TYPE (type);
+
+  /* Peel off cv qualifiers. */
+  type = TYPE_MAIN_VARIANT (type);
+
+  /* Apply trivial conversion T -> T& for dereferenced ptrs.  */
+  if (TREE_CODE (type) == RECORD_TYPE)
+    type = build_reference_type (type);
+
+  /* If exp is a reference to polymorphic type, get the real type_info.  */
+  if (TREE_CODE (type) == REFERENCE_TYPE && TYPE_VIRTUAL_P (TREE_TYPE (type)))
+    {
+      /* build reference to type_info from vtable.  */
+      tree t;
+
+      if (flag_vtable_thunks)
+	t = build_vfn_ref ((tree *) NULL_TREE, exp, integer_one_node);
+      else
+	t = build_vfn_ref ((tree *) NULL_TREE, exp, integer_zero_node);
+
+      TREE_TYPE (t) = build_pointer_type (__class_desc_type_node);
+      t = build_indirect_ref (t, NULL);
+      return t;
+    }
+
+  /* otherwise return the type_info for the static type of the expr.  */
+  return get_typeid (type);
+}
+
+/* Return the type_info object for TYPE, creating it if necessary.  */
+tree
+get_typeid (type)
+     tree type;
+{
+  tree t, td;
+
+  if (type == error_mark_node)
+    return error_mark_node;
+  
+  /* Is it useful (and/or correct) to have different typeids for `T &'
+     and `T'?  */
+  if (TREE_CODE (type) == REFERENCE_TYPE)
+    type = TREE_TYPE (type);
+
+  td = build_t_desc (type, 1);
+  if (td == error_mark_node)
+    return error_mark_node;
+
+  t = TREE_OPERAND (td, 0);
+  return t;
+}
+
+/* Get a bad_cast node for the program to throw...
+
+   See libstdc++::exception{,.cc} for __bad_cast_object */
+tree
+get_bad_cast_node ()
+{
+  static tree t;
+  if (t == NULL_TREE
+      && (t = lookup_name (get_identifier ("__bad_cast_object"), 0))
+         == NULL_TREE)
+    {
+      error ("you must #include <typeinfo>");
+      return error_mark_node;
+    }
+  return t;
+}
+
+/* Execute a dynamic cast, as described in section 5.2.6 of the 9/93 working
+   paper.  */
+tree
+build_dynamic_cast (type, expr)
+     tree type, expr;
+{
+  enum tree_code tc = TREE_CODE (type);
+  tree exprtype = TREE_TYPE (expr);
+  enum tree_code ec = TREE_CODE (exprtype);
+  tree retval;
+
+  if (type == error_mark_node || expr == error_mark_node)
+    return error_mark_node;
+  
+  switch (tc)
+    {
+    case POINTER_TYPE:
+      if (ec == REFERENCE_TYPE)
+	{
+	  expr = convert_from_reference (expr);
+	  exprtype = TREE_TYPE (expr);
+	  ec = TREE_CODE (exprtype);
+	}
+      if (ec != POINTER_TYPE)
+	goto fail;
+      if (TREE_CODE (TREE_TYPE (exprtype)) != RECORD_TYPE)
+	goto fail;
+      if (TYPE_SIZE (TREE_TYPE (exprtype)) == 0)
+	goto fail;
+      if (TREE_READONLY (TREE_TYPE (exprtype)) &&
+	  ! TYPE_READONLY (TREE_TYPE (type)))
+	goto fail;
+      if (TYPE_MAIN_VARIANT (TREE_TYPE (type)) == void_type_node)
+	break;
+      /* else fall through */
+    case REFERENCE_TYPE:
+      if (TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE
+	  && TYPE_SIZE (TREE_TYPE (type)) != NULL_TREE)
+	break;
+      /* else fall through */
+    default:
+      goto fail;
+    }
+
+  /* Apply trivial conversion T -> T& for dereferenced ptrs.  */
+  if (ec == RECORD_TYPE)
+    {
+      exprtype = build_type_variant (exprtype, TREE_READONLY (expr),
+				     TREE_THIS_VOLATILE (expr));
+      exprtype = build_reference_type (exprtype);
+      expr = convert_to_reference (exprtype, expr, CONV_IMPLICIT,
+				   LOOKUP_NORMAL, NULL_TREE);
+      ec = REFERENCE_TYPE;
+    }
+
+  if (tc == REFERENCE_TYPE)
+    {
+      if (ec != REFERENCE_TYPE)
+	goto fail;
+      if (TREE_CODE (TREE_TYPE (exprtype)) != RECORD_TYPE)
+	goto fail;
+      if (TYPE_SIZE (TREE_TYPE (exprtype)) == 0)
+	goto fail;
+      if (TREE_READONLY (TREE_TYPE (exprtype)) &&
+	  ! TYPE_READONLY (TREE_TYPE (type)))
+	goto fail;
+    }
+
+  /* If *type is an unambiguous accessible base class of *exprtype,
+     convert statically.  */
+  {
+    int distance;
+    tree path;
+
+    distance = get_base_distance (TREE_TYPE (type), TREE_TYPE (exprtype), 1,
+				  &path);
+    if (distance >= 0)
+      return build_vbase_path (PLUS_EXPR, type, expr, path, 0);
+  }
+
+  /* Otherwise *exprtype must be a polymorphic class (have a vtbl).  */
+  if (TYPE_VIRTUAL_P (TREE_TYPE (exprtype)))
+    {
+      /* if TYPE is `void *', return pointer to complete object.  */
+      if (tc == POINTER_TYPE
+	  && TYPE_MAIN_VARIANT (TREE_TYPE (type)) == void_type_node)
+	{
+	  /* if b is an object, dynamic_cast<void *>(&b) == (void *)&b.  */
+	  if (TREE_CODE (expr) == ADDR_EXPR
+	      && TREE_CODE (TREE_OPERAND (expr, 0)) == VAR_DECL
+	      && TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == RECORD_TYPE)
+	    return build1 (NOP_EXPR, type, expr);
+
+	  return build_headof (expr);
+	}
+      else
+	{
+	  tree retval;
+          tree result, td1, td2, elems, tmp1, expr1;
+
+ 	  /* If we got here, we can't convert statically.  Therefore,
+	     dynamic_cast<D&>(b) (b an object) cannot succeed.  */
+	  if (ec == REFERENCE_TYPE)
+	    {
+	      if (TREE_CODE (expr) == VAR_DECL
+		  && TREE_CODE (TREE_TYPE (expr)) == RECORD_TYPE)
+		{
+		  cp_warning ("dynamic_cast of `%#D' to `%#T' can never succeed",
+			      expr, type);
+		  return build_throw (get_bad_cast_node ());
+		}
+	    }
+	  /* Ditto for dynamic_cast<D*>(&b).  */
+	  else if (TREE_CODE (expr) == ADDR_EXPR)
+	    {
+	      tree op = TREE_OPERAND (expr, 0);
+	      if (TREE_CODE (op) == VAR_DECL
+		  && TREE_CODE (TREE_TYPE (op)) == RECORD_TYPE)
+		{
+		  cp_warning ("dynamic_cast of `%#D' to `%#T' can never succeed",
+			      expr, type);
+		  retval = build_int_2 (0, 0); 
+		  TREE_TYPE (retval) = type; 
+		  return retval;
+		}
+	    }
+
+	  expr1 = expr;
+	  if (tc == REFERENCE_TYPE)
+	    expr1 = build_unary_op (ADDR_EXPR, expr1, 0);
+
+	  /* Build run-time conversion.  */
+	  expr1 = build_headof (expr1);
+
+	  if (ec == POINTER_TYPE)
+	    td1 = build_typeid (build_indirect_ref (expr, NULL_PTR));
+	  else
+	    td1 = build_typeid (expr);
+	  
+	  if (tc == POINTER_TYPE)
+	    td2 = get_typeid (TREE_TYPE (type));
+	  else
+	    td2 = get_typeid (TYPE_MAIN_VARIANT (TREE_TYPE (type)));
+
+          elems = tree_cons (NULL_TREE, td2,
+            tree_cons (NULL_TREE, build_int_2 (1, 0),
+	      tree_cons (NULL_TREE, expr1, NULL_TREE)));
+          result = build_method_call (td1,
+            get_identifier ("__rtti_match"), elems, NULL_TREE, LOOKUP_NORMAL);
+
+	  if (tc == REFERENCE_TYPE)
+	    {
+	      expr1 = build_throw (get_bad_cast_node ());
+	      expr1 = build_compound_expr (tree_cons (NULL_TREE, expr1,
+						      build_tree_list (NULL_TREE, convert (type, integer_zero_node))));
+	      TREE_TYPE (expr1) = type;
+	      result = save_expr (result);
+	      return build (COND_EXPR, type, result, result, expr1);
+	    }
+
+	  /* Now back to the type we want from a void*. */
+	  result = convert (type, result);
+          return result;
+	}
+    }
+
+ fail:
+  cp_error ("cannot dynamic_cast `%E' (of type `%#T') to type `%#T'",
+	    expr, exprtype, type);
+  return error_mark_node;
+}
+
+/* Build and initialize various sorts of descriptors.  Every descriptor
+   node has a name associated with it (the name created by mangling).
+   For this reason, we use the identifier as our access to the __*_desc
+   nodes, instead of sticking them directly in the types.  Otherwise we
+   would burden all built-in types (and pointer types) with slots that
+   we don't necessarily want to use.
+
+   For each descriptor we build, we build a variable that contains
+   the descriptor's information.  When we need this info at runtime,
+   all we need is access to these variables.
+
+   Note: these constructors always return the address of the descriptor
+   info, since that is simplest for their mutual interaction.  */
+
+static tree
+build_generic_desc (tdecl, type, elems)
+     tree tdecl;
+     tree type;
+     tree elems;
+{
+  tree init = elems;
+  int toplev = global_bindings_p ();
+
+  TREE_CONSTANT (init) = 1;
+  TREE_STATIC (init) = 1;
+  TREE_READONLY (init) = 1;
+
+  TREE_TYPE (tdecl) = type;
+  DECL_INITIAL (tdecl) = init;
+  TREE_STATIC (tdecl) = 1;
+  DECL_SIZE (tdecl) = NULL_TREE;
+  layout_decl (tdecl, 0);
+  if (! toplev)
+    push_to_top_level ();
+  cp_finish_decl (tdecl, init, NULL_TREE, 0, 0);
+  if (! toplev)
+    pop_from_top_level ();
+
+  if (! TREE_USED (tdecl))
+    {
+      assemble_external (tdecl);
+      TREE_USED (tdecl) = 1;
+    }
+
+  return IDENTIFIER_AS_DESC (DECL_NAME (tdecl));
+}
+
+/* Build an initializer for a __bltn_desc node.  */
+static tree
+build_bltn_desc (tdecl, type)
+     tree tdecl;
+     tree type;
+{
+  tree elems, t;
+
+  if (type == boolean_type_node)
+    t = lookup_field (__bltn_desc_type_node, get_identifier("_RTTI_BI_BOOL"),
+		      0, 0);
+  else if (type == char_type_node)
+    t = lookup_field (__bltn_desc_type_node, get_identifier("_RTTI_BI_CHAR"),
+		      0, 0);
+  else if (type == short_integer_type_node)
+    t = lookup_field (__bltn_desc_type_node, get_identifier("_RTTI_BI_SHORT"),
+		      0, 0);
+  else if (type == integer_type_node)
+    t = lookup_field (__bltn_desc_type_node, get_identifier("_RTTI_BI_INT"),
+		      0, 0);
+  else if (type == long_integer_type_node)
+    t = lookup_field (__bltn_desc_type_node, get_identifier("_RTTI_BI_LONG"),
+		      0, 0);
+  else if (type == long_long_integer_type_node)
+    t = lookup_field (__bltn_desc_type_node, 
+		      get_identifier("_RTTI_BI_LONGLONG"), 0, 0);
+  else if (type == float_type_node)
+    t = lookup_field (__bltn_desc_type_node, get_identifier("_RTTI_BI_FLOAT"),
+		      0, 0);
+  else if (type == double_type_node)
+    t = lookup_field (__bltn_desc_type_node, 
+		      get_identifier("_RTTI_BI_DOUBLE"), 0, 0);
+  else if (type == long_double_type_node)
+    t = lookup_field (__bltn_desc_type_node, 
+		      get_identifier("_RTTI_BI_LDOUBLE"), 0, 0);
+  else if (type == unsigned_char_type_node)
+    t = lookup_field (__bltn_desc_type_node, get_identifier("_RTTI_BI_UCHAR"),
+		      0, 0);
+  else if (type == short_unsigned_type_node)
+    t = lookup_field (__bltn_desc_type_node, get_identifier("_RTTI_BI_USHORT"),
+		      0, 0);
+  else if (type == unsigned_type_node)
+    t = lookup_field (__bltn_desc_type_node, get_identifier("_RTTI_BI_UINT"),
+		      0, 0);
+  else if (type == long_unsigned_type_node)
+    t = lookup_field (__bltn_desc_type_node, get_identifier("_RTTI_BI_ULONG"),
+		      0, 0);
+  else if (type == long_long_unsigned_type_node)
+    t = lookup_field (__bltn_desc_type_node, 
+		      get_identifier("_RTTI_BI_ULONGLONG"), 0, 0);
+  else if (type == signed_char_type_node)
+    t = lookup_field (__bltn_desc_type_node, get_identifier("_RTTI_BI_SCHAR"),
+		      0, 0);
+  else if (type == wchar_type_node)
+    t = lookup_field (__bltn_desc_type_node, get_identifier("_RTTI_BI_WCHAR"),
+		      0, 0);
+  else if (type == void_type_node)
+    t = lookup_field (__bltn_desc_type_node, get_identifier("_RTTI_BI_VOID"),
+		      0, 0);
+  else
+    {
+      cp_compiler_error ("type `%T' not handled as a built-in type");
+    }
+
+  elems = tree_cons (NULL_TREE, t, NULL_TREE);
+  return build_generic_desc (tdecl, __bltn_desc_type_node, elems);
+}
+
+/* Build an initializer for a __user_desc node.  */
+static tree
+build_user_desc (tdecl)
+     tree tdecl;
+{
+  tree elems, name_string, t;
+  tree tname = DECL_NAME (tdecl);
+
+  name_string = combine_strings (build_string 
+    (IDENTIFIER_LENGTH (tname)+1, IDENTIFIER_POINTER (tname)));
+  elems = name_string;
+  return build_generic_desc (tdecl, __user_desc_type_node, elems);
+}
+
+/* Build an initializer for a __class_type_info node. */
+static tree
+build_class_desc (tdecl, type)
+     tree tdecl;
+     tree type;
+{
+  tree tname = DECL_NAME (tdecl);
+  tree name_string;
+
+  int i = CLASSTYPE_N_BASECLASSES (type);
+  int n_base = i;
+  int base_cnt = 0;
+  tree binfos = TYPE_BINFO_BASETYPES (type);
+  tree vb = CLASSTYPE_VBASECLASSES (type);
+  tree base, elems, access, offset, isvir;
+  tree base_list, off_list, acc_list, isvir_list;
+  tree t;
+  static tree acc_pub = NULL_TREE;
+  static tree acc_pro = NULL_TREE;
+  static tree acc_pri = NULL_TREE;
+
+  if (acc_pub == NULL_TREE) 
+    {
+      acc_pub = lookup_field (__class_desc_type_node, 
+                                get_identifier("_RTTI_ACCESS_PUBLIC"), 0, 0);
+      acc_pro = lookup_field (__class_desc_type_node,
+                                get_identifier("_RTTI_ACCESS_PROTECTED"), 0, 0);
+      acc_pri = lookup_field (__class_desc_type_node,
+                                get_identifier("_RTTI_ACCESS_PRIVATE"), 0, 0);
+    }
+
+  base_list = build_tree_list (NULL_TREE, integer_zero_node);
+  off_list = build_tree_list (NULL_TREE, integer_zero_node);
+  acc_list = build_tree_list (NULL_TREE, integer_zero_node);
+  isvir_list = build_tree_list (NULL_TREE, integer_zero_node);
+  while (--i >= 0)
+    {
+      tree binfo = TREE_VEC_ELT (binfos, i);
+
+      base = build_t_desc (BINFO_TYPE (binfo), 1);
+      if (TREE_VIA_VIRTUAL (binfo))
+	{
+	  tree t = BINFO_TYPE (binfo);
+	  char *name;
+	  tree field;
+	  int off;
+
+	  name = (char *) alloca (TYPE_NAME_LENGTH (t)+sizeof (VBASE_NAME)+1);
+	  sprintf (name, VBASE_NAME_FORMAT, TYPE_NAME_STRING (t));
+	  field = lookup_field (type, get_identifier (name), 0, 0);
+	  offset = size_binop (FLOOR_DIV_EXPR, 
+		DECL_FIELD_BITPOS (field), size_int (BITS_PER_UNIT));
+	}
+      else
+	offset = BINFO_OFFSET (binfo);
+
+      if (TREE_VIA_PUBLIC (binfo))
+        access = acc_pub;
+      else if (TREE_VIA_PROTECTED (binfo))
+	access = acc_pro;
+      else
+	access = acc_pri;
+      if (TREE_VIA_VIRTUAL (binfo))
+	isvir = build_int_2 (1, 0);
+      else
+	isvir = build_int_2 (0, 0);
+
+      base_list = tree_cons (NULL_TREE, base, base_list);
+      isvir_list = tree_cons (NULL_TREE, isvir, isvir_list);
+      acc_list = tree_cons (NULL_TREE, access, acc_list);
+      off_list = tree_cons (NULL_TREE, offset, off_list);
+      base_cnt++;
+    }
+#if 0
+  i = n_base;
+  while (vb)
+    {
+      tree b;
+      access = acc_pub;
+      while (--i >= 0)
+	{
+	  b = TREE_VEC_ELT (binfos, i);
+	  if (BINFO_TYPE (vb) == BINFO_TYPE (b) && TREE_VIA_VIRTUAL (b))
+	    {
+	      if (TREE_VIA_PUBLIC (b))
+		access = acc_pub;
+	      else if (TREE_VIA_PROTECTED (b))
+		access = acc_pro;
+	      else
+		access = acc_pri;
+	      break;
+	    }
+	}
+      base = build_t_desc (BINFO_TYPE (vb), 1);
+      offset = BINFO_OFFSET (vb);
+      isvir = build_int_2 (1, 0);
+
+      base_list = tree_cons (NULL_TREE, base, base_list);
+      isvir_list = tree_cons (NULL_TREE, isvir, isvir_list);
+      acc_list = tree_cons (NULL_TREE, access, acc_list);
+      off_list = tree_cons (NULL_TREE, offset, off_list);
+
+      base_cnt++;
+      vb = TREE_CHAIN (vb);
+    }
+#endif
+  base_list = finish_table (NULL_TREE, build_pointer_type (__t_desc_type_node), 
+			    base_list, 0);
+  off_list = finish_table (NULL_TREE, integer_type_node, 
+			    off_list, 0);
+  isvir_list = finish_table (NULL_TREE, integer_type_node, 
+			    isvir_list, 0);
+  acc_list = finish_table (NULL_TREE, __access_mode_type_node, 
+			    acc_list, 0);
+
+
+  name_string = combine_strings (build_string (IDENTIFIER_LENGTH (tname)+1, IDENTIFIER_POINTER (tname)));
+
+  elems = tree_cons (NULL_TREE, name_string,
+	    tree_cons (NULL_TREE, default_conversion (base_list),
+	      tree_cons (NULL_TREE, default_conversion (off_list),
+		tree_cons (NULL_TREE, default_conversion (isvir_list),
+		  tree_cons (NULL_TREE, default_conversion (acc_list),
+	      	    tree_cons (NULL_TREE, build_int_2 (base_cnt, 0), NULL_TREE))))));
+
+  return build_generic_desc (tdecl, __class_desc_type_node, elems);
+}
+
+/* Build an initializer for a __pointer_type_info node.  */
+static tree
+build_ptr_desc (tdecl, type)
+     tree tdecl;
+     tree type;
+{
+  tree t, elems;
+
+  t = TREE_TYPE (type);
+  t = build_t_desc (t, 1);
+  t = build_indirect_ref (t, NULL);
+  elems = tree_cons (NULL_TREE, t, NULL_TREE);
+  return build_generic_desc (tdecl, __ptr_desc_type_node,  elems);
+}
+
+/* Build an initializer for a __attr_type_info node.  */
+static tree
+build_attr_desc (tdecl, type)
+     tree tdecl;
+     tree type;
+{
+  tree elems, t, attrval;
+
+  if (TYPE_READONLY (type))
+    {
+      if (TYPE_VOLATILE (type))
+	attrval = lookup_field (__attr_desc_type_node, 
+				get_identifier("_RTTI_ATTR_CONSTVOL"), 0, 0);
+      else
+	attrval = lookup_field (__attr_desc_type_node, 
+				get_identifier("_RTTI_ATTR_CONST"), 0, 0);
+    }
+  else
+    {
+      if (TYPE_VOLATILE (type))
+	attrval = lookup_field (__attr_desc_type_node, 
+				get_identifier("_RTTI_ATTR_VOLATILE"), 0, 0);
+    }
+  t = build_t_desc (TYPE_MAIN_VARIANT (type), 1);
+  t = build_indirect_ref (t , NULL);
+  elems = tree_cons (NULL_TREE, attrval, tree_cons (NULL_TREE, t, NULL_TREE));
+  return build_generic_desc (tdecl, __attr_desc_type_node,  elems);
+}
+
+/* Build an initializer for a __func_type_info node.  */
+static tree
+build_func_desc (tdecl)
+     tree tdecl;
+{
+  tree elems, name_string;
+  tree tname = DECL_NAME (tdecl);
+
+  name_string = combine_strings (build_string 
+    (IDENTIFIER_LENGTH (tname)+1, IDENTIFIER_POINTER (tname)));
+  elems = name_string; 
+  return build_generic_desc (tdecl, __func_desc_type_node,  elems);
+}
+
+/* Build an initializer for a __ptmf_type_info node.  */
+static tree
+build_ptmf_desc (tdecl, type)
+     tree tdecl;
+     tree type;
+{ 
+  tree elems, name_string;
+  tree tname = DECL_NAME (tdecl);
+
+  name_string = combine_strings (build_string 
+    (IDENTIFIER_LENGTH (tname)+1, IDENTIFIER_POINTER (tname)));
+  elems = name_string; 
+  return build_generic_desc (tdecl, __ptmf_desc_type_node,  elems);
+}
+
+/* Build an initializer for a __ptmd_type_info node.  */
+static tree
+build_ptmd_desc (tdecl, type)
+     tree tdecl;
+     tree type;
+{
+  tree tc, t, elems;
+  tc = build_t_desc (TYPE_OFFSET_BASETYPE (type), 1);
+  tc = build_indirect_ref (tc , NULL);
+  t = build_t_desc (TREE_TYPE (type), 1);
+  t = build_indirect_ref (t , NULL);
+  elems = tree_cons (NULL_TREE, tc,
+	    tree_cons (NULL_TREE, t, NULL_TREE));
+  return build_generic_desc (tdecl, __ptmd_desc_type_node,  elems);
+}
+
+struct uninst_st {
+  tree type;
+  struct uninst_st *next;
+};
+typedef struct uninst_st uninst_node;
+static uninst_node * uninst_desc = (uninst_node *)NULL;
+
+static void
+add_uninstantiated_desc (type)
+     tree type;
+{
+  uninst_node *t;
+
+  t = (uninst_node *) xmalloc (sizeof (struct uninst_st));
+  t->type = type;
+  t->next = uninst_desc;
+  uninst_desc = t;
+}
+
+/* We may choose to link the emitting of certain high use TDs for certain
+   objects, we do that here.  Return the type to link against if such a
+   link exists, otherwise just return TYPE.  */
+
+tree
+get_def_to_follow (type)
+     tree type;
+{
+#if 0
+  /* For now we don't lay out T&, T* TDs with the main TD for the object.  */
+  /* Let T* and T& be written only when T is written (if T is an aggr).
+     We do this for const, but not for volatile, since volatile
+     is rare and const is not.  */
+  if (!TYPE_VOLATILE (taggr)
+      && (TREE_CODE (taggr) == POINTER_TYPE
+	  || TREE_CODE (taggr) == REFERENCE_TYPE)
+      && IS_AGGR_TYPE (TREE_TYPE (taggr)))
+    taggr = TREE_TYPE (taggr);
+#endif
+  return type;
+}
+
+/* build a general type_info node. */
+tree
+build_t_desc (type, definition)
+     tree type;
+     int definition;
+{
+  tree tdecl;
+  tree tname, name_string;
+  tree elems;
+  tree t, tt, taggr;
+
+  if (__ptmd_desc_type_node == NULL_TREE)
+    {
+      init_type_desc();
+      if (__ptmd_desc_type_node)
+	{
+          for ( ; uninst_desc; uninst_desc = uninst_desc->next )
+	    build_t_desc (uninst_desc->type, 1);
+	}
+    }
+  if (__t_desc_type_node == NULL_TREE)
+    {
+      static int warned = 0;
+      if (! warned)
+	{
+	  cp_error ("failed to build type descriptor node of '%T', maybe <typeinfo> not included", type);
+	}
+      warned = 1;
+      return error_mark_node;
+    }
+  if (__ptmd_desc_type_node == NULL_TREE)
+    {
+      add_uninstantiated_desc (type);
+      definition = 0;
+    }
+
+  push_obstacks (&permanent_obstack, &permanent_obstack);
+  tname = build_t_desc_overload (type);
+
+  if (!IDENTIFIER_AS_DESC (tname))
+    {
+      tdecl = build_decl (VAR_DECL, tname, __t_desc_type_node);
+      DECL_EXTERNAL (tdecl) = 1;
+      TREE_PUBLIC (tdecl) = 1;
+      tdecl = pushdecl_top_level (tdecl);
+      SET_IDENTIFIER_AS_DESC (tname, build_unary_op (ADDR_EXPR, tdecl, 0));
+      if (!definition)
+	cp_finish_decl (tdecl, NULL_TREE, NULL_TREE, 0, 0);
+    }
+  else
+    tdecl = TREE_OPERAND (IDENTIFIER_AS_DESC (tname), 0);
+
+  /* If it's not a definition, don't do anything more.  */
+  if (!definition)
+    return IDENTIFIER_AS_DESC (tname);
+
+  /* If it has already been written, don't to anything more.  */
+  /* Should this be on tdecl? */
+  if (TREE_ASM_WRITTEN (IDENTIFIER_AS_DESC (tname)))
+    return IDENTIFIER_AS_DESC (tname);
+
+  /* If we previously defined it, return the defined result.  */
+  if (DECL_INITIAL (tdecl))
+    return IDENTIFIER_AS_DESC (tname);
+    
+  taggr = get_def_to_follow (type);
+
+  /* If we know that we don't need to write out this type's
+     vtable, then don't write out it's type_info.  Somebody
+     else will take care of that.  */
+  if (IS_AGGR_TYPE (taggr) && CLASSTYPE_VFIELD (taggr))
+    {
+      /* Let's play follow the vtable. */
+      TREE_PUBLIC (tdecl) = CLASSTYPE_INTERFACE_KNOWN (taggr);
+      DECL_EXTERNAL (tdecl) = CLASSTYPE_INTERFACE_ONLY (taggr);
+    }
+  else
+    {
+      DECL_EXTERNAL (tdecl) = 0;
+      TREE_PUBLIC (tdecl) = (definition > 1);
+    }
+
+  if (DECL_EXTERNAL (tdecl))
+    return IDENTIFIER_AS_DESC (tname);
+
+  /* Show that we are defining the t_desc for this type.  */
+  DECL_INITIAL (tdecl) = error_mark_node;
+  t = DECL_CONTEXT (tdecl);
+  if ( t && TREE_CODE_CLASS (TREE_CODE (t)) == 't') 
+    pushclass (t, 2);
+
+  if (TYPE_VOLATILE (type) || TYPE_READONLY (type))
+    t = build_attr_desc (tdecl, type);
+  else if (TREE_CODE (type) == ARRAY_TYPE)
+    t = build_ptr_desc (tdecl, type);
+  else if (TREE_CODE (type) == POINTER_TYPE)
+    {
+      if (TREE_CODE (TREE_TYPE (type)) == OFFSET_TYPE)
+	{
+	  type = TREE_TYPE (type);
+	  t = build_ptmd_desc (tdecl, type);
+	}
+      else
+	{
+	  t = build_ptr_desc (tdecl, type);
+	}
+    }
+  else if (TYPE_BUILT_IN (type))
+    t = build_bltn_desc (tdecl, type);
+  else if (IS_AGGR_TYPE (type))
+    {
+      if (TYPE_PTRMEMFUNC_P (type))
+	{
+	  t = build_ptmf_desc (tdecl, type);
+	}
+      else
+	{
+	  t = build_class_desc (tdecl, type);
+	}
+    }
+  else if (TREE_CODE (type) == FUNCTION_TYPE)
+    t = build_func_desc (tdecl);
+  else 
+    t = build_user_desc (tdecl);
+
+  pop_obstacks ();
+  return t;
+}
+
+#if 0
+/* This is the old dossier type descriptor generation code, it's much
+   more extended than rtti. It's reserved for later use. */
+/* Build an initializer for a __t_desc node.  So that we can take advantage
+   of recursion, we accept NULL for TYPE.
+   DEFINITION is greater than zero iff we must define the type descriptor
+   (as opposed to merely referencing it).  1 means treat according to
+   #pragma interface/#pragma implementation rules.  2 means define as
+   global and public, no matter what.  */
+tree
+build_t_desc (type, definition)
+     tree type;
+     int definition;
+{
+  tree tdecl;
+  tree tname, name_string;
+  tree elems, fields;
+  tree parents, vbases, offsets, ivars, methods, target_type;
+  int method_count = 0, field_count = 0;
+
+  if (type == NULL_TREE)
+    return NULL_TREE;
+
+  tname = build_t_desc_overload (type);
+  if (IDENTIFIER_AS_DESC (tname)
+      && (!definition || TREE_ASM_WRITTEN (IDENTIFIER_AS_DESC (tname))))
+    return IDENTIFIER_AS_DESC (tname);
+
+  tdecl = lookup_name (tname, 0);
+  if (tdecl == NULL_TREE)
+    {
+      tdecl = build_decl (VAR_DECL, tname, __t_desc_type_node);
+      DECL_EXTERNAL (tdecl) = 1;
+      TREE_PUBLIC (tdecl) = 1;
+      tdecl = pushdecl_top_level (tdecl);
+    }
+  /* If we previously defined it, return the defined result.  */
+  else if (definition && DECL_INITIAL (tdecl))
+    return IDENTIFIER_AS_DESC (tname);
+
+  if (definition)
+    {
+      tree taggr = type;
+      /* Let T* and T& be written only when T is written (if T is an aggr).
+         We do this for const, but not for volatile, since volatile
+	 is rare and const is not.  */
+      if (!TYPE_VOLATILE (taggr)
+	  && (TREE_CODE (taggr) == POINTER_TYPE
+	      || TREE_CODE (taggr) == REFERENCE_TYPE)
+	  && IS_AGGR_TYPE (TREE_TYPE (taggr)))
+	taggr = TREE_TYPE (taggr);
+
+      /* If we know that we don't need to write out this type's
+	 vtable, then don't write out it's dossier.  Somebody
+	 else will take care of that.  */
+      if (IS_AGGR_TYPE (taggr) && CLASSTYPE_VFIELD (taggr))
+	{
+	  if (CLASSTYPE_VTABLE_NEEDS_WRITING (taggr))
+	    {
+	      TREE_PUBLIC (tdecl) = ! CLASSTYPE_INTERFACE_ONLY (taggr)
+		&& CLASSTYPE_INTERFACE_KNOWN (taggr);
+	      DECL_EXTERNAL (tdecl) = 0;
+	    }
+	  else
+	    {
+	      if (write_virtuals != 0)
+		TREE_PUBLIC (tdecl) = 1;
+	    }
+	}
+      else
+	{
+	  DECL_EXTERNAL (tdecl) = 0;
+	  TREE_PUBLIC (tdecl) = (definition > 1);
+	}
+    }
+  SET_IDENTIFIER_AS_DESC (tname, build_unary_op (ADDR_EXPR, tdecl, 0));
+
+  if (!definition || DECL_EXTERNAL (tdecl))
+    {
+      /* That's it!  */
+      cp_finish_decl (tdecl, NULL_TREE, NULL_TREE, 0, 0);
+      return IDENTIFIER_AS_DESC (tname);
+    }
+
+  /* Show that we are defining the t_desc for this type.  */
+  DECL_INITIAL (tdecl) = error_mark_node;
+
+  parents = build_tree_list (NULL_TREE, integer_zero_node);
+  vbases = build_tree_list (NULL_TREE, integer_zero_node);
+  offsets = build_tree_list (NULL_TREE, integer_zero_node);
+  methods = NULL_TREE;
+  ivars = NULL_TREE;
+
+  if (TYPE_LANG_SPECIFIC (type))
+    {
+      int i = CLASSTYPE_N_BASECLASSES (type);
+      tree method_vec = CLASSTYPE_METHOD_VEC (type);
+      tree *meth, *end;
+      tree binfos = TYPE_BINFO_BASETYPES (type);
+      tree vb = CLASSTYPE_VBASECLASSES (type);
+
+      while (--i >= 0)
+	parents = tree_cons (NULL_TREE, build_t_desc (BINFO_TYPE (TREE_VEC_ELT (binfos, i)), 0), parents);
+
+      while (vb)
+	{
+	  vbases = tree_cons (NULL_TREE, build_t_desc (BINFO_TYPE (vb), 0), vbases);
+	  offsets = tree_cons (NULL_TREE, BINFO_OFFSET (vb), offsets);
+	  vb = TREE_CHAIN (vb);
+	}
+
+      if (method_vec)
+	for (meth = TREE_VEC_END (method_vec),
+	     end = &TREE_VEC_ELT (method_vec, 0); meth-- != end; )
+	  if (*meth)
+	    {
+	      methods = tree_cons (NULL_TREE, build_m_desc (*meth), methods);
+	      method_count++;
+	    }
+    }
+
+  if (IS_AGGR_TYPE (type))
+    {
+      for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
+	if (TREE_CODE (fields) == FIELD_DECL
+	    || TREE_CODE (fields) == VAR_DECL)
+	  {
+	    ivars = tree_cons (NULL_TREE, build_i_desc (fields), ivars);
+	    field_count++;
+	  }
+      ivars = nreverse (ivars);
+    }
+
+  parents = finish_table (NULL_TREE, build_pointer_type (__t_desc_type_node), parents, 0);
+  vbases = finish_table (NULL_TREE, build_pointer_type (__t_desc_type_node), vbases, 0);
+  offsets = finish_table (NULL_TREE, integer_type_node, offsets, 0);
+  if (methods == NULL_TREE)
+    methods = null_pointer_node;
+  else
+    methods = build_unary_op (ADDR_EXPR,
+			      finish_table (NULL_TREE, __m_desc_type_node, methods, 0),
+			      0);
+  if (ivars == NULL_TREE)
+    ivars = null_pointer_node;
+  else
+    ivars = build_unary_op (ADDR_EXPR,
+			    finish_table (NULL_TREE, __i_desc_type_node, ivars, 0),
+			    0);
+  if (TREE_TYPE (type))
+    target_type = build_t_desc (TREE_TYPE (type), definition);
+  else
+    target_type = integer_zero_node;
+
+  name_string = combine_strings (build_string (IDENTIFIER_LENGTH (tname)+1, IDENTIFIER_POINTER (tname)));
+
+  elems = tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, name_string, 0),
+	   tree_cons (NULL_TREE,
+		      TYPE_SIZE(type)? size_in_bytes(type) : integer_zero_node,
+	     /* really should use bitfield initialization here.  */
+	     tree_cons (NULL_TREE, integer_zero_node,
+	      tree_cons (NULL_TREE, target_type,
+	       tree_cons (NULL_TREE, build_int_2 (field_count, 2),
+		tree_cons (NULL_TREE, build_int_2 (method_count, 2),
+		 tree_cons (NULL_TREE, ivars,
+		  tree_cons (NULL_TREE, methods,
+		   tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, parents, 0),
+		    tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, vbases, 0),
+		     build_tree_list (NULL_TREE, build_unary_op (ADDR_EXPR, offsets, 0))))))))))));
+  return build_generic_desc (tdecl, elems);
+}
+
+/* Build an initializer for a __i_desc node.  */
+tree
+build_i_desc (decl)
+     tree decl;
+{
+  tree elems, name_string;
+  tree taggr;
+
+  name_string = DECL_NAME (decl);
+  name_string = combine_strings (build_string (IDENTIFIER_LENGTH (name_string)+1, IDENTIFIER_POINTER (name_string)));
+
+  /* Now decide whether this ivar should cause it's type to get
+     def'd or ref'd in this file.  If the type we are looking at
+     has a proxy definition, we look at the proxy (i.e., a
+     `foo *' is equivalent to a `foo').  */
+  taggr = TREE_TYPE (decl);
+
+  if ((TREE_CODE (taggr) == POINTER_TYPE
+       || TREE_CODE (taggr) == REFERENCE_TYPE)
+      && TYPE_VOLATILE (taggr) == 0)
+    taggr = TREE_TYPE (taggr);
+
+  elems = tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, name_string, 0),
+	     tree_cons (NULL_TREE, DECL_FIELD_BITPOS (decl),
+		build_tree_list (NULL_TREE, build_t_desc (TREE_TYPE (decl),
+							  ! IS_AGGR_TYPE (taggr)))));
+  taggr = build (CONSTRUCTOR, __i_desc_type_node, NULL_TREE, elems);
+  TREE_CONSTANT (taggr) = 1;
+  TREE_STATIC (taggr) = 1;
+  TREE_READONLY (taggr) = 1;
+  return taggr;
+}
+
+/* Build an initializer for a __m_desc node.  */
+tree
+build_m_desc (decl)
+     tree decl;
+{
+  tree taggr, elems, name_string;
+  tree parm_count, req_count, vindex, vcontext;
+  tree parms;
+  int p_count, r_count;
+  tree parm_types = NULL_TREE;
+
+  for (parms = TYPE_ARG_TYPES (TREE_TYPE (decl)), p_count = 0, r_count = 0;
+       parms != NULL_TREE; parms = TREE_CHAIN (parms), p_count++)
+    {
+      taggr = TREE_VALUE (parms);
+      if ((TREE_CODE (taggr) == POINTER_TYPE
+	   || TREE_CODE (taggr) == REFERENCE_TYPE)
+	  && TYPE_VOLATILE (taggr) == 0)
+	taggr = TREE_TYPE (taggr);
+
+      parm_types = tree_cons (NULL_TREE, build_t_desc (TREE_VALUE (parms),
+						       ! IS_AGGR_TYPE (taggr)),
+			      parm_types);
+      if (TREE_PURPOSE (parms) == NULL_TREE)
+	r_count++;
+    }
+
+  parm_types = finish_table (NULL_TREE, build_pointer_type (__t_desc_type_node),
+			     nreverse (parm_types), 0);
+  parm_count = build_int_2 (p_count, 0);
+  req_count = build_int_2 (r_count, 0);
+
+  if (DECL_VINDEX (decl))
+    vindex = DECL_VINDEX (decl);
+  else
+    vindex = integer_zero_node;
+  if (DECL_CONTEXT (decl)
+      && TREE_CODE_CLASS (TREE_CODE (DECL_CONTEXT (decl))) == 't')
+    vcontext = build_t_desc (DECL_CONTEXT (decl), 0);
+  else
+    vcontext = integer_zero_node;
+  name_string = DECL_NAME (decl);
+  if (name_string == NULL)
+      name_string = DECL_ASSEMBLER_NAME (decl);
+  name_string = combine_strings (build_string (IDENTIFIER_LENGTH (name_string)+1, IDENTIFIER_POINTER (name_string)));
+
+  /* Now decide whether the return type of this mvar
+     should cause it's type to get def'd or ref'd in this file.
+     If the type we are looking at has a proxy definition,
+     we look at the proxy (i.e., a `foo *' is equivalent to a `foo').  */
+  taggr = TREE_TYPE (TREE_TYPE (decl));
+
+  if ((TREE_CODE (taggr) == POINTER_TYPE
+       || TREE_CODE (taggr) == REFERENCE_TYPE)
+      && TYPE_VOLATILE (taggr) == 0)
+    taggr = TREE_TYPE (taggr);
+
+  elems = tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, name_string, 0),
+	     tree_cons (NULL_TREE, vindex,
+		tree_cons (NULL_TREE, vcontext,
+		   tree_cons (NULL_TREE, build_t_desc (TREE_TYPE (TREE_TYPE (decl)),
+						       ! IS_AGGR_TYPE (taggr)),
+		      tree_cons (NULL_TREE, build_c_cast (build_pointer_type (default_function_type), build_unary_op (ADDR_EXPR, decl, 0), 0),
+			 tree_cons (NULL_TREE, parm_count,
+			    tree_cons (NULL_TREE, req_count,
+			       build_tree_list (NULL_TREE, build_unary_op (ADDR_EXPR, parm_types, 0)))))))));
+
+  taggr = build (CONSTRUCTOR, __m_desc_type_node, NULL_TREE, elems);
+  TREE_CONSTANT (taggr) = 1;
+  TREE_STATIC (taggr) = 1;
+  TREE_READONLY (taggr) = 1;
+  return taggr;
+}
+#endif /* dossier */