cvt.c, [...]: Clean up more old overloading code, old RTTI code, and some formatting quirks.

	* cvt.c, decl.c, decl2.c, init.c, rtti.c, typeck.c, typeck2.c,
	cp-tree.h: Clean up more old overloading code, old RTTI code, and
	some formatting quirks.

From-SVN: r18391

8 files changed, 172 insertions, 984 deletions

diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 95bc071..93a2527 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -2084,7 +2084,6 @@ extern tree convert				PROTO((tree, tree));
 extern tree convert_force			PROTO((tree, tree, int));
 extern tree build_type_conversion		PROTO((enum tree_code, tree, tree, int));
 extern tree build_expr_type_conversion		PROTO((int, tree, int));
-extern int build_default_binary_type_conversion	PROTO((enum tree_code, tree *, tree *));
 extern tree type_promotes_to			PROTO((tree));
 extern tree perform_qualification_conversions   PROTO((tree, tree));
 
diff --git a/gcc/cp/cvt.c b/gcc/cp/cvt.c
index 05cd667..6cd6229 100644
--- a/gcc/cp/cvt.c
+++ b/gcc/cp/cvt.c
@@ -38,8 +38,6 @@ Boston, MA 02111-1307, USA.  */
 
 extern tree static_aggregates;
 
-static tree build_thunk PROTO((tree, tree));
-static tree convert_fn_ptr PROTO((tree, tree));
 static tree cp_convert_to_pointer PROTO((tree, tree));
 static tree convert_to_pointer_force PROTO((tree, tree));
 static tree build_up_reference PROTO((tree, tree, int, int));
@@ -68,60 +66,6 @@ static tree build_type_conversion_1 PROTO((tree, tree, tree, tree,
 
 /* Subroutines of `convert'.  */
 
-/* Build a thunk.  What it is, is an entry point that when called will
-   adjust the this pointer (the first argument) by offset, and then
-   goto the real address of the function given by REAL_ADDR that we
-   would like called.  What we return is the address of the thunk.  */
-
-static tree
-build_thunk (offset, real_addr)
-     tree offset, real_addr;
-{
-  if (TREE_CODE (real_addr) != ADDR_EXPR
-      || TREE_CODE (TREE_OPERAND (real_addr, 0)) != FUNCTION_DECL)
-    {
-      sorry ("MI pointer to member conversion too complex");
-      return error_mark_node;
-    }
-  sorry ("MI pointer to member conversion too complex");
-  return error_mark_node;
-}
-
-/* Convert a `pointer to member' (POINTER_TYPE to METHOD_TYPE) into
-   another `pointer to method'.  This may involved the creation of
-   a thunk to handle the this offset calculation.  */
-
-static tree
-convert_fn_ptr (type, expr)
-     tree type, expr;
-{
-#if 0				/* We don't use thunks for pmfs.  */
-  if (flag_vtable_thunks)
-    {
-      tree intype = TREE_TYPE (expr);
-      tree binfo = get_binfo (TYPE_METHOD_BASETYPE (TREE_TYPE (intype)),
-			      TYPE_METHOD_BASETYPE (TREE_TYPE (type)), 1);
-      if (binfo == error_mark_node)
-	{
-	  error ("  in pointer to member conversion");
-	  return error_mark_node;
-	}
-      if (binfo == NULL_TREE)
-	{
-	  /* ARM 4.8 restriction.  */
-	  error ("invalid pointer to member conversion");
-	  return error_mark_node;
-	}
-
-      if (BINFO_OFFSET_ZEROP (binfo))
-	return build1 (NOP_EXPR, type, expr);
-      return build1 (NOP_EXPR, type, build_thunk (BINFO_OFFSET (binfo), expr));
-    }
-  else
-#endif
-    return build_ptrmemfunc (type, expr, 1);
-}
-
 /* if converting pointer to pointer
      if dealing with classes, check for derived->base or vice versa
      else if dealing with method pointers, delegate
@@ -239,9 +183,11 @@ cp_convert_to_pointer (type, expr)
 		  tree path;
 
 		  if (code == PLUS_EXPR)
-		    get_base_distance (TREE_TYPE (type), TREE_TYPE (intype), 0, &path);
+		    get_base_distance (TREE_TYPE (type), TREE_TYPE (intype),
+				       0, &path);
 		  else
-		    get_base_distance (TREE_TYPE (intype), TREE_TYPE (type), 0, &path);
+		    get_base_distance (TREE_TYPE (intype), TREE_TYPE (type),
+				       0, &path);
 		  return build_vbase_path (code, type, expr, path, 0);
 		}
 	    }
@@ -249,7 +195,7 @@ cp_convert_to_pointer (type, expr)
       if (TREE_CODE (TREE_TYPE (intype)) == METHOD_TYPE
 	  && TREE_CODE (type) == POINTER_TYPE
 	  && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE)
-	return convert_fn_ptr (type, expr);
+	return build_ptrmemfunc (type, expr, 1);
 
       if (TREE_CODE (TREE_TYPE (type)) == OFFSET_TYPE
 	  && TREE_CODE (TREE_TYPE (intype)) == OFFSET_TYPE)
@@ -548,7 +494,8 @@ convert_to_reference (reftype, expr, convtype, flags, decl)
 	  
       rval = build_unary_op (ADDR_EXPR, expr, 0);
       if (rval != error_mark_node)
-	rval = convert_force (build_pointer_type (TREE_TYPE (reftype)), rval, 0);
+	rval = convert_force (build_pointer_type (TREE_TYPE (reftype)),
+			      rval, 0);
       if (rval != error_mark_node)
 	rval = build1 (NOP_EXPR, reftype, rval);
     }
@@ -1033,230 +980,39 @@ build_expr_type_conversion (desires, expr, complain)
      int complain;
 {
   tree basetype = TREE_TYPE (expr);
-  tree conv;
-  tree winner = NULL_TREE;
 
   if (TREE_CODE (basetype) == OFFSET_TYPE)
     expr = resolve_offset_ref (expr);
   expr = convert_from_reference (expr);
   basetype = TREE_TYPE (expr);
 
-  if (! IS_AGGR_TYPE (basetype))
-    switch (TREE_CODE (basetype))
-      {
-      case INTEGER_TYPE:
-	if ((desires & WANT_NULL) && TREE_CODE (expr) == INTEGER_CST
-	    && integer_zerop (expr))
-	  return expr;
-	/* else fall through...  */
-
-      case BOOLEAN_TYPE:
-	return (desires & WANT_INT) ? expr : NULL_TREE;
-      case ENUMERAL_TYPE:
-	return (desires & WANT_ENUM) ? expr : NULL_TREE;
-      case REAL_TYPE:
-	return (desires & WANT_FLOAT) ? expr : NULL_TREE;
-      case POINTER_TYPE:
-	return (desires & WANT_POINTER) ? expr : NULL_TREE;
-	
-      case FUNCTION_TYPE:
-      case ARRAY_TYPE:
-	return (desires & WANT_POINTER) ? default_conversion (expr)
-     	                                : NULL_TREE;
-      default:
-	return NULL_TREE;
-      }
-
-  if (! TYPE_HAS_CONVERSION (basetype))
-    return NULL_TREE;
-
-  for (conv = lookup_conversions (basetype); conv; conv = TREE_CHAIN (conv))
+  switch (TREE_CODE (basetype))
     {
-      int win = 0;
-      tree candidate;
-      tree cand = TREE_VALUE (conv);
-
-      if (winner && winner == cand)
-	continue;
-
-      candidate = TREE_TYPE (TREE_TYPE (cand));
-      if (TREE_CODE (candidate) == REFERENCE_TYPE)
-	candidate = TREE_TYPE (candidate);
-
-      switch (TREE_CODE (candidate))
-	{
-	case BOOLEAN_TYPE:
-	case INTEGER_TYPE:
-	  win = (desires & WANT_INT); break;
-	case ENUMERAL_TYPE:
-	  win = (desires & WANT_ENUM); break;
-	case REAL_TYPE:
-	  win = (desires & WANT_FLOAT); break;
-	case POINTER_TYPE:
-	  win = (desires & WANT_POINTER); break;
-
-	default:
-	  break;
-	}
-
-      if (win)
-	{
-	  if (winner)
-	    {
-	      if (complain)
-		{
-		  cp_error ("ambiguous default type conversion from `%T'",
-			    basetype);
-		  cp_error ("  candidate conversions include `%D' and `%D'",
-			    winner, cand);
-		}
-	      return error_mark_node;
-	    }
-	  else
-	    winner = cand;
-	}
-    }
-
-  if (winner)
-    {
-      tree type = TREE_TYPE (TREE_TYPE (winner));
-      if (TREE_CODE (type) == REFERENCE_TYPE)
-	type = TREE_TYPE (type);
-      return build_type_conversion_1 (type, basetype, expr,
-				      DECL_NAME (winner), 1);
-    }
-
-  return NULL_TREE;
-}
-
-/* Must convert two aggregate types to non-aggregate type.
-   Attempts to find a non-ambiguous, "best" type conversion.
-
-   Return 1 on success, 0 on failure.
-
-   @@ What are the real semantics of this supposed to be??? */
-
-int
-build_default_binary_type_conversion (code, arg1, arg2)
-     enum tree_code code;
-     tree *arg1, *arg2;
-{
-  switch (code)
-    {
-    case MULT_EXPR:
-    case TRUNC_DIV_EXPR:
-    case CEIL_DIV_EXPR:
-    case FLOOR_DIV_EXPR:
-    case ROUND_DIV_EXPR:
-    case EXACT_DIV_EXPR:
-      *arg1 = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, *arg1, 0);
-      *arg2 = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, *arg2, 0);
-      break;
-
-    case TRUNC_MOD_EXPR:
-    case FLOOR_MOD_EXPR:
-    case LSHIFT_EXPR:
-    case RSHIFT_EXPR:
-    case BIT_AND_EXPR:
-    case BIT_XOR_EXPR:
-    case BIT_IOR_EXPR:
-      *arg1 = build_expr_type_conversion (WANT_INT | WANT_ENUM, *arg1, 0);
-      *arg2 = build_expr_type_conversion (WANT_INT | WANT_ENUM, *arg2, 0);
-      break;
-
-    case PLUS_EXPR:
-      {
-	tree a1, a2, p1, p2;
-	int wins;
-
-	a1 = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, *arg1, 0);
-	a2 = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, *arg2, 0);
-	p1 = build_expr_type_conversion (WANT_POINTER, *arg1, 0);
-	p2 = build_expr_type_conversion (WANT_POINTER, *arg2, 0);
-
-	wins = (a1 && a2) + (a1 && p2) + (p1 && a2);
-
-	if (wins > 1)
-	  error ("ambiguous default type conversion for `operator +'");
-
-	if (a1 && a2)
-	  *arg1 = a1, *arg2 = a2;
-	else if (a1 && p2)
-	  *arg1 = a1, *arg2 = p2;
-	else
-	  *arg1 = p1, *arg2 = a2;
-	break;
-      }
-
-    case MINUS_EXPR:
-      {
-	tree a1, a2, p1, p2;
-	int wins;
-
-	a1 = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, *arg1, 0);
-	a2 = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, *arg2, 0);
-	p1 = build_expr_type_conversion (WANT_POINTER, *arg1, 0);
-	p2 = build_expr_type_conversion (WANT_POINTER, *arg2, 0);
-
-	wins = (a1 && a2) + (p1 && p2) + (p1 && a2);
-
-	if (wins > 1)
-	  error ("ambiguous default type conversion for `operator -'");
-
-	if (a1 && a2)
-	  *arg1 = a1, *arg2 = a2;
-	else if (p1 && p2)
-	  *arg1 = p1, *arg2 = p2;
-	else
-	  *arg1 = p1, *arg2 = a2;
-	break;
-      }
-
-    case GT_EXPR:
-    case LT_EXPR:
-    case GE_EXPR:
-    case LE_EXPR:
-    case EQ_EXPR:
-    case NE_EXPR:
-      {
-	tree a1, a2, p1, p2;
-	int wins;
-
-	a1 = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, *arg1, 0);
-	a2 = build_expr_type_conversion (WANT_ARITH | WANT_ENUM, *arg2, 0);
-	p1 = build_expr_type_conversion (WANT_POINTER | WANT_NULL, *arg1, 0);
-	p2 = build_expr_type_conversion (WANT_POINTER | WANT_NULL, *arg2, 0);
-
-	wins = (a1 && a2) + (p1 && p2);
-
-	if (wins > 1)
-	  cp_error ("ambiguous default type conversion for `%O'", code);
-
-	if (a1 && a2)
-	  *arg1 = a1, *arg2 = a2;
-	else
-	  *arg1 = p1, *arg2 = p2;
-	break;
-      }
-
-    case TRUTH_ANDIF_EXPR:
-    case TRUTH_ORIF_EXPR:
-      *arg1 = cp_convert (boolean_type_node, *arg1);
-      *arg2 = cp_convert (boolean_type_node, *arg2);
-      break;
+    case INTEGER_TYPE:
+      if ((desires & WANT_NULL) && TREE_CODE (expr) == INTEGER_CST
+	  && integer_zerop (expr))
+	return expr;
+      /* else fall through...  */
+
+    case BOOLEAN_TYPE:
+      return (desires & WANT_INT) ? expr : NULL_TREE;
+    case ENUMERAL_TYPE:
+      return (desires & WANT_ENUM) ? expr : NULL_TREE;
+    case REAL_TYPE:
+      return (desires & WANT_FLOAT) ? expr : NULL_TREE;
+    case POINTER_TYPE:
+      return (desires & WANT_POINTER) ? expr : NULL_TREE;
+	
+    case FUNCTION_TYPE:
+    case ARRAY_TYPE:
+      return ((desires & WANT_POINTER) ? default_conversion (expr)
+	      : NULL_TREE);
 
     default:
-      *arg1 = NULL_TREE;
-      *arg2 = NULL_TREE;
+      break;
     }
 
-  if (*arg1 == error_mark_node || *arg2 == error_mark_node)
-    cp_error ("ambiguous default type conversion for `%O'", code);
-
-  if (*arg1 && *arg2)
-    return 1;
-
-  return 0;
+  return NULL_TREE;
 }
 
 /* Implements integral promotion (4.1) and float->double promotion.  */
diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
index 334db91..fdf704c 100644
--- a/gcc/cp/decl.c
+++ b/gcc/cp/decl.c
@@ -5648,122 +5648,6 @@ init_decl_processing ()
 			 void_type_node);
   pushdecl (std_node);
 
-#if 0
-  if (flag_rtti)
-    {
-      /* Must build __t_desc type.  Currently, type descriptors look like this:
-
-	 struct __t_desc
-	 {
-           const char *name;
-	   int size;
-	   int bits;
-	   struct __t_desc *points_to;
-	   int ivars_count, meths_count;
-	   struct __i_desc *ivars[];
-	   struct __m_desc *meths[];
-	   struct __t_desc *parents[];
-	   struct __t_desc *vbases[];
-	   int offsets[];
-	 };
-
-	 ...as per Linton's paper.  */
-
-      __t_desc_type_node = make_lang_type (RECORD_TYPE);
-      __i_desc_type_node = make_lang_type (RECORD_TYPE);
-      __m_desc_type_node = make_lang_type (RECORD_TYPE);
-      __t_desc_array_type
-	= build_array_type (build_pointer_type (__t_desc_type_node),
-			    NULL_TREE);
-      __i_desc_array_type
-	= build_array_type (build_pointer_type (__i_desc_type_node),
-			    NULL_TREE);
-      __m_desc_array_type
-	= build_array_type (build_pointer_type (__m_desc_type_node),
-			    NULL_TREE);
-
-      fields[0] = build_lang_field_decl (FIELD_DECL, get_identifier ("name"),
-					 string_type_node);
-      fields[1] = build_lang_field_decl (FIELD_DECL, get_identifier ("size"),
-					 unsigned_type_node);
-      fields[2] = build_lang_field_decl (FIELD_DECL, get_identifier ("bits"),
-					 unsigned_type_node);
-      fields[3] = build_lang_field_decl (FIELD_DECL,
-					 get_identifier ("points_to"),
-					 build_pointer_type (__t_desc_type_node));
-      fields[4] = build_lang_field_decl (FIELD_DECL,
-					 get_identifier ("ivars_count"),
-					 integer_type_node);
-      fields[5] = build_lang_field_decl (FIELD_DECL,
-					 get_identifier ("meths_count"),
-					 integer_type_node);
-      fields[6] = build_lang_field_decl (FIELD_DECL, get_identifier ("ivars"),
-					 build_pointer_type (__i_desc_array_type));
-      fields[7] = build_lang_field_decl (FIELD_DECL, get_identifier ("meths"),
-					 build_pointer_type (__m_desc_array_type));
-      fields[8] = build_lang_field_decl (FIELD_DECL, get_identifier ("parents"),
-					 build_pointer_type (__t_desc_array_type));
-      fields[9] = build_lang_field_decl (FIELD_DECL, get_identifier ("vbases"),
-					 build_pointer_type (__t_desc_array_type));
-      fields[10] = build_lang_field_decl (FIELD_DECL, get_identifier ("offsets"),
-					 build_pointer_type (integer_type_node));
-      finish_builtin_type (__t_desc_type_node, "__t_desc", fields, 10, integer_type_node);
-
-      /* ivar descriptors look like this:
-
-	 struct __i_desc
-	 {
-	   const char *name;
-	   int offset;
-	   struct __t_desc *type;
-	 };
-      */
-
-      fields[0] = build_lang_field_decl (FIELD_DECL, get_identifier ("name"),
-					 string_type_node);
-      fields[1] = build_lang_field_decl (FIELD_DECL, get_identifier ("offset"),
-					 integer_type_node);
-      fields[2] = build_lang_field_decl (FIELD_DECL, get_identifier ("type"),
-					 build_pointer_type (__t_desc_type_node));
-      finish_builtin_type (__i_desc_type_node, "__i_desc", fields, 2,
-			   integer_type_node);
-
-      /* method descriptors look like this:
-
-	 struct __m_desc
-	 {
-	   const char *name;
-	   int vindex;
-	   struct __t_desc *vcontext;
-	   struct __t_desc *return_type;
-	   void (*address)();
-	   short parm_count;
-	   short required_parms;
-	   struct __t_desc *parm_types[];
-	 };
-      */
-
-      fields[0] = build_lang_field_decl (FIELD_DECL, get_identifier ("name"),
-					 string_type_node);
-      fields[1] = build_lang_field_decl (FIELD_DECL, get_identifier ("vindex"),
-					 integer_type_node);
-      fields[2] = build_lang_field_decl (FIELD_DECL, get_identifier ("vcontext"),
-					 build_pointer_type (__t_desc_type_node));
-      fields[3] = build_lang_field_decl (FIELD_DECL, get_identifier ("return_type"),
-					 build_pointer_type (__t_desc_type_node));
-      fields[4] = build_lang_field_decl (FIELD_DECL, get_identifier ("address"),
-					 build_pointer_type (default_function_type));
-      fields[5] = build_lang_field_decl (FIELD_DECL, get_identifier ("parm_count"),
-					 short_integer_type_node);
-      fields[6] = build_lang_field_decl (FIELD_DECL, get_identifier ("required_parms"),
-					 short_integer_type_node);
-      fields[7] = build_lang_field_decl (FIELD_DECL, get_identifier ("parm_types"),
-					 build_pointer_type (build_array_type (build_pointer_type (__t_desc_type_node), NULL_TREE)));
-      finish_builtin_type (__m_desc_type_node, "__m_desc", fields, 7,
-			   integer_type_node);
-    }
-#endif /*flag_rtti*/
-
   /* Now, C++.  */
   current_lang_name = lang_name_cplusplus;
 
@@ -5811,76 +5695,6 @@ init_decl_processing ()
   using_eh_for_cleanups ();
 }
 
-/* initialize type descriptor type node of various rtti type.  */
-
-int
-init_type_desc()
-{
-  tree tdecl;
-
-  tdecl = lookup_name (get_identifier ("type_info"), 0);
-  if (tdecl == NULL_TREE)
-    return 0;
-  __t_desc_type_node = TREE_TYPE (tdecl);
-#if 0
-  __tp_desc_type_node = build_pointer_type (__t_desc_type_node);
-#endif
-
-#if 0
-  tdecl = lookup_name (get_identifier ("__baselist_type_info"), 0);
-  if (tdecl == NULL_TREE)
-    return 0;
-  __baselist_desc_type_node = TREE_TYPE (tdecl);
-#endif
-
-  tdecl = lookup_name (get_identifier ("__builtin_type_info"), 0);
-  if (tdecl == NULL_TREE)
-    return 0;
-  __bltn_desc_type_node = TREE_TYPE (tdecl);
-
-  tdecl = lookup_name (get_identifier ("__user_type_info"), 0);
-  if (tdecl == NULL_TREE)
-    return 0;
-  __user_desc_type_node = TREE_TYPE (tdecl);
-
-  tdecl = lookup_name (get_identifier ("__class_type_info"), 0);
-  if (tdecl == NULL_TREE)
-    return 0;
-  __class_desc_type_node = TREE_TYPE (tdecl);
-
-  tdecl = lookup_field (__class_desc_type_node, 
-	get_identifier ("access_mode"), 0, 0);
-  if (tdecl == NULL_TREE)
-    return 0;
-  __access_mode_type_node = TREE_TYPE (tdecl);
-
-  tdecl = lookup_name (get_identifier ("__attr_type_info"), 0);
-  if (tdecl == NULL_TREE)
-    return 0;
-  __attr_desc_type_node = TREE_TYPE (tdecl);
-
-  tdecl = lookup_name (get_identifier ("__pointer_type_info"), 0);
-  if (tdecl == NULL_TREE)
-    return 0;
-  __ptr_desc_type_node = TREE_TYPE (tdecl);
-
-  tdecl = lookup_name (get_identifier ("__func_type_info"), 0);
-  if (tdecl == NULL_TREE)
-    return 0;
-  __func_desc_type_node = TREE_TYPE (tdecl);
-
-  tdecl = lookup_name (get_identifier ("__ptmf_type_info"), 0);
-  if (tdecl == NULL_TREE)
-    return 0;
-  __ptmf_desc_type_node = TREE_TYPE (tdecl);
-
-  tdecl = lookup_name (get_identifier ("__ptmd_type_info"), 0);
-  if (tdecl == NULL_TREE)
-    return 0;
-  __ptmd_desc_type_node = TREE_TYPE (tdecl);
-
-  return 1;
-}
 /* Make a definition for a builtin function named NAME and whose data type
    is TYPE.  TYPE should be a function type with argument types.
    FUNCTION_CODE tells later passes how to compile calls to this function.
diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c
index 2468342..e337b18 100644
--- a/gcc/cp/decl2.c
+++ b/gcc/cp/decl2.c
@@ -781,26 +781,6 @@ grok_method_quals (ctype, function, quals)
   return ctype;
 }
 
-#if 0				/* Not used.  */
-/* This routine replaces cryptic DECL_NAMEs with readable DECL_NAMEs.
-   It leaves DECL_ASSEMBLER_NAMEs with the correct value.  */
-/* This does not yet work with user defined conversion operators
-   It should.  */
-
-static void
-substitute_nice_name (decl)
-     tree decl;
-{
-  if (DECL_NAME (decl) && TREE_CODE (DECL_NAME (decl)) == IDENTIFIER_NODE)
-    {
-      char *n = decl_as_string (DECL_NAME (decl), 1);
-      if (n[strlen (n) - 1] == ' ')
-	n[strlen (n) - 1] = 0;
-      DECL_NAME (decl) = get_identifier (n);
-    }
-}
-#endif
-
 /* Warn when -fexternal-templates is used and #pragma
    interface/implementation is not used all the times it should be,
    inform the user.  */
@@ -1051,7 +1031,8 @@ grokclassfn (ctype, cname, function, flags, quals)
       if (IDENTIFIER_TYPE_VALUE (cname))
 	dbuf = build_overload_name (IDENTIFIER_TYPE_VALUE (cname), 1, 1);
       else if (IDENTIFIER_LOCAL_VALUE (cname))
-	dbuf = build_overload_name (TREE_TYPE (IDENTIFIER_LOCAL_VALUE (cname)), 1, 1);
+	dbuf = build_overload_name (TREE_TYPE (IDENTIFIER_LOCAL_VALUE (cname)),
+				    1, 1);
       else
       /* Using ctype fixes the `X::Y::~Y()' crash.  The cname has no type when
 	 it's defined out of the class definition, since poplevel_class wipes
@@ -1108,14 +1089,6 @@ grokclassfn (ctype, cname, function, flags, quals)
       DECL_ASSEMBLER_NAME (function)
 	= build_decl_overload (fn_name, these_arg_types,
 			       1 + DECL_CONSTRUCTOR_P (function));
-
-#if 0
-      /* This code is going into the compiler, but currently, it makes
-	 libg++/src/Integer.cc not compile.  The problem is that the nice name
-	 winds up going into the symbol table, and conversion operations look
-	 for the manged name.  */
-      substitute_nice_name (function);
-#endif
     }
 
   DECL_ARGUMENTS (function) = last_function_parms;
@@ -1199,8 +1172,7 @@ grok_array_decl (array_expr, index_exp)
     type = TREE_TYPE (type);
 
   /* If they have an `operator[]', use that.  */
-  if (TYPE_LANG_SPECIFIC (type)
-      && TYPE_OVERLOADS_ARRAY_REF (complete_type (type)))
+  if (IS_AGGR_TYPE (type) || IS_AGGR_TYPE (TREE_TYPE (index_exp)))
     return build_opfncall (ARRAY_REF, LOOKUP_NORMAL,
 			   array_expr, index_exp, NULL_TREE);
 
@@ -1596,7 +1568,8 @@ grokfield (declarator, declspecs, init, asmspec_tree, attrlist)
   if (DECL_NAME (value) != NULL_TREE
       && IDENTIFIER_POINTER (DECL_NAME (value))[0] == '_'
       && ! strcmp (IDENTIFIER_POINTER (DECL_NAME (value)), "_vptr"))
-    cp_error ("member `%D' conflicts with virtual function table field name", value);
+    cp_error ("member `%D' conflicts with virtual function table field name",
+	      value);
 
   /* Stash away type declarations.  */
   if (TREE_CODE (value) == TYPE_DECL)
@@ -1953,33 +1926,6 @@ grok_function_init (decl, init)
 	    TYPE_HAS_ABSTRACT_ASSIGN_REF (current_class_type) = 1;
 	}
     }
-  else if (TREE_CODE (init) == OFFSET_REF
-	   && TREE_OPERAND (init, 0) == NULL_TREE
-	   && TREE_CODE (TREE_TYPE (init)) == METHOD_TYPE)
-    {
-      tree basetype = DECL_CLASS_CONTEXT (init);
-      tree basefn = TREE_OPERAND (init, 1);
-      if (TREE_CODE (basefn) != FUNCTION_DECL)
-	cp_error ("non-method initializer invalid for method `%D'", decl);
-      else if (! BINFO_OFFSET_ZEROP (TYPE_BINFO (DECL_CLASS_CONTEXT (basefn))))
-	sorry ("base member function from other than first base class");
-      else
-	{
-	  tree binfo = get_binfo (basetype, TYPE_METHOD_BASETYPE (type), 1);
-	  if (binfo == error_mark_node)
-	    ;
-	  else if (binfo == 0)
-	    error_not_base_type (TYPE_METHOD_BASETYPE (TREE_TYPE (init)),
-				 TYPE_METHOD_BASETYPE (type));
-	  else
-	    {
-	      /* Mark this function as being defined,
-		 and give it new rtl.  */
-	      DECL_INITIAL (decl) = error_mark_node;
-	      DECL_RTL (decl) = DECL_RTL (basefn);
-	    }
-	}
-    }
   else
     cp_error ("invalid initializer for virtual method `%D'", decl);
 }
@@ -2264,82 +2210,6 @@ finish_anon_union (anon_union_decl)
   expand_anon_union_decl (anon_union_decl, NULL_TREE, elems);
 }
 
-/* Finish and output a table which is generated by the compiler.
-   NAME is the name to give the table.
-   TYPE is the type of the table entry.
-   INIT is all the elements in the table.
-   PUBLICP is non-zero if this table should be given external access.  */
-
-tree
-finish_table (name, type, init, publicp)
-     tree name, type, init;
-     int publicp;
-{
-  tree itype, atype, decl;
-  static tree empty_table;
-  int is_empty = 0;
-  tree asmspec;
-
-  itype = build_index_type (size_int (list_length (init) - 1));
-  atype = build_cplus_array_type (type, itype);
-  layout_type (atype);
-
-  if (TREE_VALUE (init) == integer_zero_node
-      && TREE_CHAIN (init) == NULL_TREE)
-    {
-#if 0
-      if (empty_table == NULL_TREE)
-#endif
-	{
-	  empty_table = get_temp_name (atype, 1);
-	  init = build (CONSTRUCTOR, atype, NULL_TREE, init);
-	  TREE_CONSTANT (init) = 1;
-	  TREE_STATIC (init) = 1;
-	  DECL_INITIAL (empty_table) = init;
-	  asmspec = build_string (IDENTIFIER_LENGTH (DECL_NAME (empty_table)),
-				  IDENTIFIER_POINTER (DECL_NAME (empty_table)));
-	  cp_finish_decl (empty_table, NULL_TREE, asmspec, 0, 0);
-	}
-      is_empty = 1;
-    }
-
-  if (name == NULL_TREE)
-    {
-      if (is_empty)
-	return empty_table;
-      decl = get_temp_name (atype, 1);
-    }
-  else
-    {
-      decl = build_decl (VAR_DECL, name, atype);
-      decl = pushdecl (decl);
-      TREE_STATIC (decl) = 1;
-    }
-
-  if (is_empty == 0)
-    {
-      TREE_PUBLIC (decl) = publicp;
-      init = build (CONSTRUCTOR, atype, NULL_TREE, init);
-      TREE_CONSTANT (init) = 1;
-      TREE_STATIC (init) = 1;
-      DECL_INITIAL (decl) = init;
-      asmspec = build_string (IDENTIFIER_LENGTH (DECL_NAME (decl)),
-			      IDENTIFIER_POINTER (DECL_NAME (decl)));
-    }
-  else
-    {
-      /* This will cause DECL to point to EMPTY_TABLE in rtl-land.  */
-      DECL_EXTERNAL (decl) = 1;
-      TREE_STATIC (decl) = 0;
-      init = 0;
-      asmspec = build_string (IDENTIFIER_LENGTH (DECL_NAME (empty_table)),
-			      IDENTIFIER_POINTER (DECL_NAME (empty_table)));
-    }
-
-  cp_finish_decl (decl, NULL_TREE, asmspec, 0, 0);
-  return decl;
-}
-
 /* Finish processing a builtin type TYPE.  It's name is NAME,
    its fields are in the array FIELDS.  LEN is the number of elements
    in FIELDS minus one, or put another way, it is the maximum subscript
diff --git a/gcc/cp/init.c b/gcc/cp/init.c
index a420092..1785142 100644
--- a/gcc/cp/init.c
+++ b/gcc/cp/init.c
@@ -1589,9 +1589,9 @@ build_member_call (type, name, parmlist)
 	  cp_error ("invalid use of member `%D'", t);
 	  return error_mark_node;
 	}
-      if (TYPE_LANG_SPECIFIC (TREE_TYPE (decl))
-	  && TYPE_OVERLOADS_CALL_EXPR (TREE_TYPE (decl)))
-	return build_opfncall (CALL_EXPR, LOOKUP_NORMAL, decl, parmlist, NULL_TREE);
+      if (TYPE_LANG_SPECIFIC (TREE_TYPE (decl)))
+	return build_opfncall (CALL_EXPR, LOOKUP_NORMAL, decl,
+			       parmlist, NULL_TREE);
       return build_function_call (decl, parmlist);
     }
   else
diff --git a/gcc/cp/rtti.c b/gcc/cp/rtti.c
index b4e7959..d01077c 100644
--- a/gcc/cp/rtti.c
+++ b/gcc/cp/rtti.c
@@ -1108,285 +1108,3 @@ synthesize_tinfo_fn (fndecl)
   c_expand_return (tmp);
   finish_function (lineno, 0, 0);
 }
-
-#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_expr_list (NULL_TREE, integer_zero_node);
-  vbases = build_expr_list (NULL_TREE, integer_zero_node);
-  offsets = build_expr_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)),
-			 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 */
diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c
index 7820f6e..137c735 100644
--- a/gcc/cp/typeck.c
+++ b/gcc/cp/typeck.c
@@ -570,10 +570,13 @@ common_type (t1, t2)
 	  /* If this was a member function type, get back to the
 	     original type of type member function (i.e., without
 	     the class instance variable up front.  */
-	  t1 = build_function_type (TREE_TYPE (t1), TREE_CHAIN (TYPE_ARG_TYPES (t1)));
-	  t2 = build_function_type (TREE_TYPE (t2), TREE_CHAIN (TYPE_ARG_TYPES (t2)));
+	  t1 = build_function_type (TREE_TYPE (t1),
+				    TREE_CHAIN (TYPE_ARG_TYPES (t1)));
+	  t2 = build_function_type (TREE_TYPE (t2),
+				    TREE_CHAIN (TYPE_ARG_TYPES (t2)));
 	  t3 = common_type (t1, t2);
-	  t3 = build_cplus_method_type (basetype, TREE_TYPE (t3), TYPE_ARG_TYPES (t3));
+	  t3 = build_cplus_method_type (basetype, TREE_TYPE (t3),
+					TYPE_ARG_TYPES (t3));
 	  t1 = build_exception_variant (t3, raises);
 	}
       else
@@ -958,7 +961,8 @@ comp_target_types (ttl, ttr, nptrs)
   else if (TREE_CODE (ttr) == FUNCTION_TYPE || TREE_CODE (ttr) == METHOD_TYPE)
     {
       if (comp_target_types (TREE_TYPE (ttl), TREE_TYPE (ttr), -1))
-	switch (comp_target_parms (TYPE_ARG_TYPES (ttl), TYPE_ARG_TYPES (ttr), 1))
+	switch (comp_target_parms (TYPE_ARG_TYPES (ttl),
+				   TYPE_ARG_TYPES (ttr), 1))
 	  {
 	  case 0:
 	    return 0;
@@ -978,9 +982,11 @@ comp_target_types (ttl, ttr, nptrs)
       /* Contravariance: we can assign a pointer to base member to a pointer
 	 to derived member.  Note difference from simple pointer case, where
 	 we can pass a pointer to derived to a pointer to base.  */
-      if (comptypes (TYPE_OFFSET_BASETYPE (ttr), TYPE_OFFSET_BASETYPE (ttl), 0))
+      if (comptypes (TYPE_OFFSET_BASETYPE (ttr),
+		     TYPE_OFFSET_BASETYPE (ttl), 0))
 	return comp_target_types (TREE_TYPE (ttl), TREE_TYPE (ttr), nptrs);
-      else if (comptypes (TYPE_OFFSET_BASETYPE (ttl), TYPE_OFFSET_BASETYPE (ttr), 0)
+      else if (comptypes (TYPE_OFFSET_BASETYPE (ttl),
+			  TYPE_OFFSET_BASETYPE (ttr), 0)
 	       && comp_target_types (TREE_TYPE (ttl), TREE_TYPE (ttr), nptrs))
 	return -1;
     }
@@ -1150,7 +1156,8 @@ comp_target_parms (parms1, parms2, strict)
 	continue;
 
       if ((TREE_CODE (p1) == POINTER_TYPE && TREE_CODE (p2) == POINTER_TYPE)
-	  || (TREE_CODE (p1) == REFERENCE_TYPE && TREE_CODE (p2) == REFERENCE_TYPE))
+	  || (TREE_CODE (p1) == REFERENCE_TYPE
+	      && TREE_CODE (p2) == REFERENCE_TYPE))
 	{
 	  if (strict <= 0
 	      && (TYPE_MAIN_VARIANT (TREE_TYPE (p1))
@@ -1571,7 +1578,8 @@ decay_conversion (exp)
 	  if (TREE_CODE (TREE_TYPE (inner)) == REFERENCE_TYPE)
 	    {
 	      inner = build1 (CONVERT_EXPR,
-			      build_pointer_type (TREE_TYPE (TREE_TYPE (inner))),
+			      build_pointer_type (TREE_TYPE
+						  (TREE_TYPE (inner))),
 			      inner);
 	      TREE_CONSTANT (inner) = TREE_CONSTANT (TREE_OPERAND (inner, 0));
 	    }
@@ -1604,8 +1612,8 @@ decay_conversion (exp)
       if (TYPE_READONLY (type) || TYPE_VOLATILE (type)
 	  || constp || volatilep)
 	restype = cp_build_type_variant (restype,
-					TYPE_READONLY (type) || constp,
-					TYPE_VOLATILE (type) || volatilep);
+					 TYPE_READONLY (type) || constp,
+					 TYPE_VOLATILE (type) || volatilep);
       ptrtype = build_pointer_type (restype);
 
       if (TREE_CODE (exp) == VAR_DECL)
@@ -1932,10 +1940,12 @@ build_component_ref (datum, component, basetype_path, protect)
 			  tree addr = build_unary_op (ADDR_EXPR, datum, 0);
 			  tree fntype = TREE_TYPE (fndecl);
 
-			  addr = convert_pointer_to (DECL_CONTEXT (fndecl), addr);
+			  addr = convert_pointer_to (DECL_CONTEXT (fndecl),
+						     addr);
 			  datum = build_indirect_ref (addr, NULL_PTR);
 			  my_friendly_assert (datum != error_mark_node, 310);
-			  fndecl = build_vfn_ref (&addr, datum, DECL_VINDEX (fndecl));
+			  fndecl = build_vfn_ref (&addr, datum,
+						  DECL_VINDEX (fndecl));
 			  /* The type of fndecl is a function type,
 			     not a pointer-to-function type, since
 			     build_vfn_ref returns not the correct
@@ -1945,7 +1955,8 @@ build_component_ref (datum, component, basetype_path, protect)
 			}
 		      else
 			mark_used (fndecl);
-		      return build (OFFSET_REF, TREE_TYPE (fndecl), datum, fndecl);
+		      return build (OFFSET_REF, TREE_TYPE (fndecl),
+				    datum, fndecl);
 		    }
 		  if (access == access_protected_node)
 		    cp_error ("member function `%D' is protected", fndecl);
@@ -2079,7 +2090,8 @@ build_x_indirect_ref (ptr, errorstring)
   if (processing_template_decl)
     return build_min_nt (INDIRECT_REF, ptr);
 
-  rval = build_opfncall (INDIRECT_REF, LOOKUP_NORMAL, ptr, NULL_TREE, NULL_TREE);
+  rval = build_opfncall (INDIRECT_REF, LOOKUP_NORMAL, ptr, NULL_TREE,
+			 NULL_TREE);
   if (rval)
     return rval;
   return build_indirect_ref (ptr, errorstring);
@@ -2102,17 +2114,6 @@ build_indirect_ref (ptr, errorstring)
   if (ptr == current_class_ptr)
     return current_class_ref;
 
-  if (IS_AGGR_TYPE (type))
-    {
-      ptr = build_expr_type_conversion (WANT_POINTER, pointer, 1);
-
-      if (ptr)
-	{
-	  pointer = ptr;
-	  type = TREE_TYPE (pointer);
-	}
-    }
-
   if (TREE_CODE (type) == POINTER_TYPE || TREE_CODE (type) == REFERENCE_TYPE)
     {
       if (TREE_CODE (pointer) == ADDR_EXPR
@@ -2135,7 +2136,8 @@ build_indirect_ref (ptr, errorstring)
 	     to assign to.  Also, &* is supposed to be a no-op.  */
 	  TREE_READONLY (ref) = TYPE_READONLY (t);
 	  TREE_SIDE_EFFECTS (ref)
-	    = TYPE_VOLATILE (t) || TREE_SIDE_EFFECTS (pointer) || flag_volatile;
+	    = (TYPE_VOLATILE (t) || TREE_SIDE_EFFECTS (pointer)
+	       || flag_volatile);
 	  TREE_THIS_VOLATILE (ref) = TYPE_VOLATILE (t);
 	  return ref;
 	}
@@ -2214,7 +2216,8 @@ build_array_ref (array, idx)
 	 Likewise an array of elements of variable size.  */
       if (TREE_CODE (idx) != INTEGER_CST
 	  || (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array))) != 0
-	      && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) != INTEGER_CST))
+	      && (TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array))))
+		  != INTEGER_CST)))
 	{
 	  if (mark_addressable (array) == 0)
 	    return error_mark_node;
@@ -2292,7 +2295,8 @@ build_array_ref (array, idx)
 	return error_mark_node;
       }
 
-    return build_indirect_ref (build_binary_op_nodefault (PLUS_EXPR, ar, ind, PLUS_EXPR),
+    return build_indirect_ref (build_binary_op_nodefault (PLUS_EXPR, ar,
+							  ind, PLUS_EXPR),
 			       "array indexing");
   }
 }
@@ -2357,12 +2361,14 @@ build_x_function_call (function, params, decl)
       function = TREE_VALUE (function);
       my_friendly_assert (TREE_CODE (function) == FUNCTION_DECL, 999);
       function = DECL_NAME (function);
-      return build_method_call (decl, function, params, TYPE_BINFO (type), LOOKUP_NORMAL);
+      return build_method_call (decl, function, params,
+				TYPE_BINFO (type), LOOKUP_NORMAL);
     }
     
   is_method = ((TREE_CODE (function) == TREE_LIST
 		&& current_class_type != NULL_TREE
-		&& IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (function)) == function)
+		&& (IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (function))
+		    == function))
 	       || TREE_CODE (function) == IDENTIFIER_NODE
 	       || TREE_CODE (type) == METHOD_TYPE
 	       || TYPE_PTRMEMFUNC_P (type));
@@ -2395,7 +2401,8 @@ build_x_function_call (function, params, decl)
 	}
       else if (TREE_CODE (function) == TREE_LIST)
 	{
-	  my_friendly_assert (TREE_CODE (TREE_VALUE (function)) == FUNCTION_DECL, 312);
+	  my_friendly_assert (TREE_CODE (TREE_VALUE (function))
+			      == FUNCTION_DECL, 312);
 	  basetype = DECL_CLASS_CONTEXT (TREE_VALUE (function));
 	  function = TREE_PURPOSE (function);
 	}
@@ -2416,7 +2423,8 @@ build_x_function_call (function, params, decl)
 	  if (TREE_CODE (TREE_TYPE (function)) != POINTER_TYPE
 	      && ! TYPE_PTRMEMFUNC_P (TREE_TYPE (function))
 	      && TREE_CODE (function) != OFFSET_REF)
-	    function = build (OFFSET_REF, TREE_TYPE (type), NULL_TREE, function);
+	    function = build (OFFSET_REF, TREE_TYPE (type), NULL_TREE,
+			      function);
 	  goto do_x_function;
 	}
 
@@ -2519,7 +2527,8 @@ build_x_function_call (function, params, decl)
 	 passed in as an argument.  */
       else if (TYPE_PTRMEMFUNC_P (fntype))
 	{
-	  tree rec = TYPE_METHOD_BASETYPE (TREE_TYPE (TYPE_PTRMEMFUNC_FN_TYPE (fntype)));
+	  tree rec = TYPE_METHOD_BASETYPE (TREE_TYPE
+					   (TYPE_PTRMEMFUNC_FN_TYPE (fntype)));
 	  ctypeptr = build_pointer_type (rec);
 	}
       /* Unexpected node type?  */
@@ -2587,7 +2596,8 @@ get_member_function_from_ptrfunc (instance_ptrptr, function)
 					     NULL_TREE, 0)));
       e1 = build_binary_op (GT_EXPR, idx, integer_zero_node, 1);
       delta = cp_convert (ptrdiff_type_node,
-			  build_component_ref (function, delta_identifier, NULL_TREE, 0));
+			  build_component_ref (function, delta_identifier,
+					       NULL_TREE, 0));
       delta2 = DELTA2_FROM_PTRMEMFUNC (function);
 
       /* Convert down to the right base, before using the instance.  */
@@ -2610,9 +2620,13 @@ get_member_function_from_ptrfunc (instance_ptrptr, function)
 	{
 	  aref = save_expr (aref);
 
-	  delta = build_binary_op (PLUS_EXPR,
-				   build_conditional_expr (e1, build_component_ref (aref, delta_identifier, NULL_TREE, 0), integer_zero_node),
-				   delta, 1);
+	  delta = build_binary_op
+	    (PLUS_EXPR,
+	     build_conditional_expr (e1, build_component_ref (aref,
+							      delta_identifier,
+							      NULL_TREE, 0),
+				     integer_zero_node),
+	     delta, 1);
 	}
 
       *instance_ptrptr = build (PLUS_EXPR, TREE_TYPE (instance_ptr),
@@ -2666,7 +2680,8 @@ build_function_call_real (function, params, require_complete, flags)
 
       GNU_xref_call (current_function_decl,
 		     IDENTIFIER_POINTER (name ? name
-					 : TYPE_IDENTIFIER (DECL_CLASS_CONTEXT (function))));
+					 : TYPE_IDENTIFIER (DECL_CLASS_CONTEXT
+							    (function))));
       mark_used (function);
       fndecl = function;
 
@@ -2936,7 +2951,8 @@ convert_arguments (return_loc, typelist, values, fndecl, flags)
 #ifdef PROMOTE_PROTOTYPES
 	      if ((TREE_CODE (type) == INTEGER_TYPE
 		   || TREE_CODE (type) == ENUMERAL_TYPE)
-		  && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
+		  && (TYPE_PRECISION (type)
+		      < TYPE_PRECISION (integer_type_node)))
 		parmval = default_conversion (parmval);
 #endif
 	    }
@@ -2955,7 +2971,9 @@ convert_arguments (return_loc, typelist, values, fndecl, flags)
 	      && (TYPE_PRECISION (TREE_TYPE (val))
 		  < TYPE_PRECISION (double_type_node)))
 	    /* Convert `float' to `double'.  */
-	    result = expr_tree_cons (NULL_TREE, cp_convert (double_type_node, val), result);
+	    result = expr_tree_cons (NULL_TREE,
+				     cp_convert (double_type_node, val),
+				     result);
 	  else if (TYPE_LANG_SPECIFIC (TREE_TYPE (val))
 		   && ! TYPE_HAS_TRIVIAL_INIT_REF (TREE_TYPE (val)))
 	    {
@@ -2965,7 +2983,8 @@ convert_arguments (return_loc, typelist, values, fndecl, flags)
 	    }
 	  else
 	    /* Convert `short' and `char' to full-size `int'.  */
-	    result = expr_tree_cons (NULL_TREE, default_conversion (val), result);
+	    result = expr_tree_cons (NULL_TREE, default_conversion (val),
+				     result);
 	}
 
       if (typetail)
@@ -2988,8 +3007,10 @@ convert_arguments (return_loc, typelist, values, fndecl, flags)
 	      else if (TREE_CODE (val) == CONSTRUCTOR)
 		{
 		  parmval = digest_init (type, val, (tree *)0);
-		  parmval = convert_for_initialization (return_loc, type, parmval, flags,
-							"default constructor", fndecl, i);
+		  parmval = convert_for_initialization (return_loc, type,
+							parmval, flags,
+							"default constructor",
+							fndecl, i);
 		}
 	      else
 		{
@@ -2997,12 +3018,15 @@ convert_arguments (return_loc, typelist, values, fndecl, flags)
 		  if (TREE_HAS_CONSTRUCTOR (val))
 		    val = copy_node (val);
 
-		  parmval = convert_for_initialization (return_loc, type, val, flags,
-							"default argument", fndecl, i);
+		  parmval = convert_for_initialization (return_loc, type,
+							val, flags,
+							"default argument",
+							fndecl, i);
 #ifdef PROMOTE_PROTOTYPES
 		  if ((TREE_CODE (type) == INTEGER_TYPE
 		       || TREE_CODE (type) == ENUMERAL_TYPE)
-		      && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)))
+		      && (TYPE_PRECISION (type)
+			  < TYPE_PRECISION (integer_type_node)))
 		    parmval = default_conversion (parmval);
 #endif
 		}
@@ -3087,15 +3111,7 @@ build_binary_op (code, arg1, arg2, convert_p)
 	}
 
       if (IS_AGGR_TYPE (type0) || IS_AGGR_TYPE (type1))
-	{
-	  /* Try to convert this to something reasonable.  */
-	  if (! build_default_binary_type_conversion(code, &args[0], &args[1]))
-	    {
-	      cp_error ("no match for `%O(%#T, %#T)'", code,
-			TREE_TYPE (arg1), TREE_TYPE (arg2));
-	      return error_mark_node;
-	    }
-	}
+	my_friendly_abort (754867);
     }
   return build_binary_op_nodefault (code, args[0], args[1], code);
 }
@@ -3279,7 +3295,8 @@ build_binary_op_nodefault (code, orig_op0, orig_op1, error_code)
 	 in the short type, making the entire operation go away.  */
       if (TREE_CODE (op0) == INTEGER_CST
 	  && TREE_CODE (op1) == NOP_EXPR
-	  && TYPE_PRECISION (type1) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1, 0)))
+	  && (TYPE_PRECISION (type1)
+	      > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1, 0))))
 	  && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op1, 0))))
 	{
 	  final_type = result_type;
@@ -3288,7 +3305,8 @@ build_binary_op_nodefault (code, orig_op0, orig_op1, error_code)
 	}
       if (TREE_CODE (op1) == INTEGER_CST
 	  && TREE_CODE (op0) == NOP_EXPR
-	  && TYPE_PRECISION (type0) > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0)))
+	  && (TYPE_PRECISION (type0)
+	      > TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0))))
 	  && TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op0, 0))))
 	{
 	  final_type = result_type;
@@ -3478,18 +3496,23 @@ build_binary_op_nodefault (code, orig_op0, orig_op1, error_code)
 	   && ((op1.index != -1 && op0.delta2 == op1.delta2)
 	       || op0.pfn == op1.pfn)) */
 
-	  tree index0 = build_component_ref (op0, index_identifier, NULL_TREE, 0);
-	  tree index1 = save_expr (build_component_ref (op1, index_identifier, NULL_TREE, 0));
+	  tree index0 = build_component_ref (op0, index_identifier,
+					     NULL_TREE, 0);
+	  tree index1 = save_expr (build_component_ref (op1, index_identifier,
+							NULL_TREE, 0));
 	  tree pfn0 = PFN_FROM_PTRMEMFUNC (op0);
 	  tree pfn1 = PFN_FROM_PTRMEMFUNC (op1);
 	  tree delta20 = DELTA2_FROM_PTRMEMFUNC (op0);
 	  tree delta21 = DELTA2_FROM_PTRMEMFUNC (op1);
 	  tree e1, e2, e3;
 	  tree integer_neg_one_node
-	    = build_binary_op (MINUS_EXPR, integer_zero_node, integer_one_node, 1);
+	    = build_binary_op (MINUS_EXPR, integer_zero_node,
+			       integer_one_node, 1);
 	  e1 = build_binary_op (EQ_EXPR, index0, index1, 1);
 	  e2 = build_binary_op (NE_EXPR, index1, integer_neg_one_node, 1);
-	  e2 = build_binary_op (TRUTH_ANDIF_EXPR, e2, build_binary_op (EQ_EXPR, delta20, delta21, 1), 1);
+	  e2 = build_binary_op (TRUTH_ANDIF_EXPR, e2,
+				build_binary_op (EQ_EXPR, delta20, delta21, 1),
+				1);
 	  e3 = build_binary_op (EQ_EXPR, pfn0, pfn1, 1);
 	  e2 = build_binary_op (TRUTH_ORIF_EXPR, e2, e3, 1);
 	  e2 = build_binary_op (TRUTH_ANDIF_EXPR, e1, e2, 1);
@@ -3500,7 +3523,8 @@ build_binary_op_nodefault (code, orig_op0, orig_op1, error_code)
       else if (TYPE_PTRMEMFUNC_P (type0)
 	       && TYPE_PTRMEMFUNC_FN_TYPE (type0) == type1)
 	{
-	  tree index0 = build_component_ref (op0, index_identifier, NULL_TREE, 0);
+	  tree index0 = build_component_ref (op0, index_identifier,
+					     NULL_TREE, 0);
 	  tree index1;
 	  tree pfn0 = PFN_FROM_PTRMEMFUNC (op0);
 	  tree delta20 = DELTA2_FROM_PTRMEMFUNC (op0);
@@ -3511,26 +3535,32 @@ build_binary_op_nodefault (code, orig_op0, orig_op1, error_code)
 	  if (TREE_CODE (TREE_OPERAND (op1, 0)) == FUNCTION_DECL
 	      && DECL_VINDEX (TREE_OPERAND (op1, 0)))
 	    {
-	      /* Map everything down one to make room for the null pointer to member.  */
+	      /* Map everything down one to make room for
+		 the null pointer to member.  */
 	      index1 = size_binop (PLUS_EXPR,
 				   DECL_VINDEX (TREE_OPERAND (op1, 0)),
 				   integer_one_node);
 	      op1 = integer_zero_node;
-	      delta21 = CLASSTYPE_VFIELD (TYPE_METHOD_BASETYPE (TREE_TYPE (type1)));
+	      delta21 = CLASSTYPE_VFIELD (TYPE_METHOD_BASETYPE
+					  (TREE_TYPE (type1)));
 	      delta21 = DECL_FIELD_BITPOS (delta21);
-	      delta21 = size_binop (FLOOR_DIV_EXPR, delta21, size_int (BITS_PER_UNIT));
+	      delta21 = size_binop (FLOOR_DIV_EXPR, delta21,
+				    size_int (BITS_PER_UNIT));
 	      delta21 = convert (sizetype, delta21);
 	    }
 	  else
 	    index1 = integer_neg_one_node;
 	  {
-	    tree nop1 = build1 (NOP_EXPR, TYPE_PTRMEMFUNC_FN_TYPE (type0), op1);
+	    tree nop1 = build1 (NOP_EXPR, TYPE_PTRMEMFUNC_FN_TYPE (type0),
+				op1);
 	    TREE_CONSTANT (nop1) = TREE_CONSTANT (op1);
 	    op1 = nop1;
 	  }
 	  e1 = build_binary_op (EQ_EXPR, index0, index1, 1);
 	  e2 = build_binary_op (NE_EXPR, index1, integer_neg_one_node, 1);
-	  e2 = build_binary_op (TRUTH_ANDIF_EXPR, e2, build_binary_op (EQ_EXPR, delta20, delta21, 1), 1);
+	  e2 = build_binary_op (TRUTH_ANDIF_EXPR, e2,
+				build_binary_op (EQ_EXPR, delta20, delta21, 1),
+				1);
 	  e3 = build_binary_op (EQ_EXPR, pfn0, op1, 1);
 	  e2 = build_binary_op (TRUTH_ORIF_EXPR, e2, e3, 1);
 	  e2 = build_binary_op (TRUTH_ANDIF_EXPR, e1, e2, 1);
@@ -3665,7 +3695,8 @@ build_binary_op_nodefault (code, orig_op0, orig_op1, error_code)
 	      && (unsigned0 || !uns))
 	    result_type
 	      = signed_or_unsigned_type (unsigned0,
-					 common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
+					 common_type (TREE_TYPE (arg0),
+						      TREE_TYPE (arg1)));
 	  else if (TREE_CODE (arg0) == INTEGER_CST
 		   && (unsigned1 || !uns)
 		   && (TYPE_PRECISION (TREE_TYPE (arg1))
@@ -3790,9 +3821,11 @@ build_binary_op_nodefault (code, orig_op0, orig_op1, error_code)
 	     not use the most significant bit of result_type.  */
 	  else if ((resultcode == EQ_EXPR || resultcode == NE_EXPR)
 		   && ((op0_signed && TREE_CODE (orig_op1) == INTEGER_CST
-			&& int_fits_type_p (orig_op1, signed_type (result_type))
+			&& int_fits_type_p (orig_op1,
+					    signed_type (result_type))
 			|| (op1_signed && TREE_CODE (orig_op0) == INTEGER_CST
-			    && int_fits_type_p (orig_op0, signed_type (result_type))))))
+			    && int_fits_type_p (orig_op0,
+						signed_type (result_type))))))
 	    /* OK */;
 	  else
 	    warning ("comparison between signed and unsigned");
@@ -3970,7 +4003,9 @@ pointer_int_sum (resultcode, ptrop, intop)
 
   intop = cp_convert (result_type,
 		      build_binary_op (MULT_EXPR, intop,
-				       cp_convert (TREE_TYPE (intop), size_exp), 1));
+				       cp_convert (TREE_TYPE (intop),
+						   size_exp),
+				       1));
 
   /* Create the sum or difference.  */
 
@@ -4009,8 +4044,8 @@ pointer_diff (op0, op1, ptrtype)
   /* First do the subtraction as integers;
      then drop through to build the divide operator.  */
 
-  op0 = build_binary_op (MINUS_EXPR,
-			 cp_convert (restype, op0), cp_convert (restype, op1), 1);
+  op0 = build_binary_op (MINUS_EXPR, cp_convert (restype, op0),
+			 cp_convert (restype, op1), 1);
 
   /* This generates an error if op1 is a pointer to an incomplete type.  */
   if (TYPE_SIZE (TREE_TYPE (TREE_TYPE (op1))) == 0)
@@ -4565,8 +4600,9 @@ build_unary_op (code, xarg, noconvert)
 	tree addr;
 
 	if (TREE_CODE (arg) == COMPONENT_REF)
-	  addr = build_component_addr (arg, argtype,
-				       "attempt to take address of bit-field structure member `%s'");
+	  addr = build_component_addr
+	    (arg, argtype,
+	     "attempt to take address of bit-field structure member `%s'");
 	else
 	  addr = build1 (code, argtype, arg);
 
@@ -4689,7 +4725,8 @@ unary_complex_lvalue (code, arg)
 
       t = TREE_OPERAND (arg, 1);
 
-      if (TREE_CODE (t) == FUNCTION_DECL) /* Check all this code for right semantics.  */
+      /* Check all this code for right semantics.  */	
+      if (TREE_CODE (t) == FUNCTION_DECL)
 	return build_unary_op (ADDR_EXPR, t, 0);
       if (TREE_CODE (t) == VAR_DECL)
 	return build_unary_op (ADDR_EXPR, t, 0);
@@ -4700,7 +4737,8 @@ unary_complex_lvalue (code, arg)
 
 	  if (TREE_OPERAND (arg, 0)
 	      && (TREE_CODE (TREE_OPERAND (arg, 0)) != NOP_EXPR
-		  || TREE_OPERAND (TREE_OPERAND (arg, 0), 0) != error_mark_node))
+		  || (TREE_OPERAND (TREE_OPERAND (arg, 0), 0)
+		      != error_mark_node)))
 	    if (TREE_CODE (t) != FIELD_DECL)
 	      {
 		/* Don't know if this should return address to just
@@ -4723,7 +4761,8 @@ unary_complex_lvalue (code, arg)
 			       convert (sizetype,
 					size_binop (EASY_DIV_EXPR,
 						    DECL_FIELD_BITPOS (t),
-						    size_int (BITS_PER_UNIT))));
+						    size_int (BITS_PER_UNIT))
+					));
 
 	  /* We offset all pointer to data members by 1 so that we can
 	     distinguish between a null pointer to data member and the first
@@ -4808,7 +4847,8 @@ mark_addressable (exp)
 
 	    TREE_ASM_WRITTEN (x) = 0;
 	    DECL_RTL (x) = 0;
-	    rest_of_decl_compilation (x, 0, IDENTIFIER_LOCAL_VALUE (x) == 0, 0);
+	    rest_of_decl_compilation (x, 0, IDENTIFIER_LOCAL_VALUE (x) == 0,
+				      0);
 	    TREE_ADDRESSABLE (x) = 1;
 
 	    pop_obstacks ();
@@ -4977,7 +5017,8 @@ build_conditional_expr (ifexp, op1, op2)
     {
       if (code2 == ENUMERAL_TYPE)
 	{
-	  cp_error ("enumeral mismatch in conditional expression: `%T' vs `%T'", type1, type2);
+	  cp_error ("enumeral mismatch in conditional expression: `%T' vs `%T'",
+		    type1, type2);
 	  return error_mark_node;
 	}
       else if (extra_warnings && ! IS_AGGR_TYPE_CODE (code2)
@@ -5066,7 +5107,8 @@ build_conditional_expr (ifexp, op1, op2)
 	result_type = type2;
       else if (IS_AGGR_TYPE (TREE_TYPE (type1))
 	       && IS_AGGR_TYPE (TREE_TYPE (type2))
-	       && (result_type = common_base_type (TREE_TYPE (type1), TREE_TYPE (type2))))
+	       && (result_type = common_base_type (TREE_TYPE (type1),
+						   TREE_TYPE (type2))))
 	{
 	  if (result_type == error_mark_node)
 	    {
@@ -5108,7 +5150,8 @@ build_conditional_expr (ifexp, op1, op2)
 	 an aggregate value, try converting to a scalar type.  */
       if (code1 == RECORD_TYPE && code2 == RECORD_TYPE)
 	{
-	  cp_error ("aggregate mismatch in conditional expression: `%T' vs `%T'", type1, type2);
+	  cp_error ("aggregate mismatch in conditional expression: `%T' vs `%T'",
+		    type1, type2);
 	  return error_mark_node;
 	}
       /* Warning: this code assumes that conversion between cv-variants of
@@ -5205,7 +5248,8 @@ build_x_compound_expr (list)
   result = build_opfncall (COMPOUND_EXPR, LOOKUP_NORMAL,
 			   TREE_VALUE (list), TREE_VALUE (rest), NULL_TREE);
   if (result)
-    return build_x_compound_expr (expr_tree_cons (NULL_TREE, result, TREE_CHAIN (rest)));
+    return build_x_compound_expr (expr_tree_cons (NULL_TREE, result,
+						  TREE_CHAIN (rest)));
 
   if (! TREE_SIDE_EFFECTS (TREE_VALUE (list)))
     {
@@ -5222,8 +5266,10 @@ build_x_compound_expr (list)
     warn_if_unused_value (TREE_VALUE(list));
 #endif
 
-  return build_compound_expr (expr_tree_cons (NULL_TREE, TREE_VALUE (list),
-					 build_expr_list (NULL_TREE, build_x_compound_expr (rest))));
+  return build_compound_expr
+    (expr_tree_cons (NULL_TREE, TREE_VALUE (list),
+		     build_expr_list (NULL_TREE,
+				      build_x_compound_expr (rest))));
 }
 
 /* Given a list of expressions, return a compound expression
@@ -5878,23 +5924,7 @@ build_modify_expr (lhs, modifycode, rhs)
     }
   else if (PROMOTES_TO_AGGR_TYPE (lhstype, REFERENCE_TYPE))
     {
-      /* This case must convert to some sort of lvalue that
-	 can participate in an op= operation.  */
-      tree lhs_tmp = lhs;
-      tree rhs_tmp = rhs;
-      if (build_default_binary_type_conversion (modifycode, &lhs_tmp, &rhs_tmp))
-	{
-	  lhs = stabilize_reference (lhs_tmp);
-	  /* Forget it was ever anything else.  */
-	  olhstype = lhstype = TREE_TYPE (lhs);
-	  newrhs = build_binary_op (modifycode, lhs, rhs_tmp, 1);
-	}
-      else
-	{
-	  cp_error ("no match for `%Q(%#T, %#T)'", modifycode,
-		    TREE_TYPE (lhs), TREE_TYPE (rhs));
-	  return error_mark_node;
-	}
+      my_friendly_abort (978652);
     }
   else
     {
diff --git a/gcc/cp/typeck2.c b/gcc/cp/typeck2.c
index 21f90cb..f462e79 100644
--- a/gcc/cp/typeck2.c
+++ b/gcc/cp/typeck2.c
@@ -1295,9 +1295,10 @@ build_x_arrow (datum)
       type = TREE_TYPE (rval);
     }
 
-  if (IS_AGGR_TYPE (type) && TYPE_OVERLOADS_ARROW (complete_type (type)))
+  if (IS_AGGR_TYPE (type))
     {
-      while ((rval = build_opfncall (COMPONENT_REF, LOOKUP_NORMAL, rval, NULL_TREE, NULL_TREE)))
+      while ((rval = build_opfncall (COMPONENT_REF, LOOKUP_NORMAL, rval,
+				     NULL_TREE, NULL_TREE)))
 	{
 	  if (rval == error_mark_node)
 	    return error_mark_node;