init.c (resolve_offset_ref): Handle default-initialization.

	* init.c (resolve_offset_ref): Handle default-initialization.
	* except.c (build_throw): Handle throwing NULL.
	* typeck.c (build_x_function_call): Use resolve_offset_ref.
	* search.c (compute_access): Only strip an anonymous union
	for a FIELD_DECL.
	* call.c (add_builtin_candidates): Tweak.
	* cvt.c (build_expr_type_conversion): Restore code for conversion
	from class types.
	* decl2.c (delete_sanity): Use it.  Clean up.
	* typeck.c (comp_ptr_ttypes_real): Fix cv-qual comparisons.
        * typeck.c (c_expand_return): Don't warn about void expressions on
        return statements in functions returning void.

From-SVN: r20399

9 files changed, 305 insertions, 221 deletions

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 8fa60f4..c84e3e2 100644
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,27 @@
+1998-06-10  Jason Merrill  <jason@yorick.cygnus.com>
+
+	* init.c (resolve_offset_ref): Handle default-initialization.
+
+	* except.c (build_throw): Handle throwing NULL.
+
+	* typeck.c (build_x_function_call): Use resolve_offset_ref.
+
+	* search.c (compute_access): Only strip an anonymous union
+	for a FIELD_DECL.
+
+	* call.c (add_builtin_candidates): Tweak.
+
+	* cvt.c (build_expr_type_conversion): Restore code for conversion
+	from class types.
+	* decl2.c (delete_sanity): Use it.  Clean up.
+
+	* typeck.c (comp_ptr_ttypes_real): Fix cv-qual comparisons.
+
+1998-06-10  Branko Cibej  <branko.cibej@hermes.si>
+
+        * typeck.c (c_expand_return): Don't warn about void expressions on
+        return statements in functions returning void.
+
 1998-06-09  Mark Mitchell  <mark@markmitchell.com>
 
 	* pt.c (fn_type_unification): Revise documentation.  Tidy.
diff --git a/gcc/cp/call.c b/gcc/cp/call.c
index cf0a21a..7a74213 100644
--- a/gcc/cp/call.c
+++ b/gcc/cp/call.c
@@ -1807,6 +1807,11 @@ add_builtin_candidates (candidates, code, code2, fnname, args, flags)
 	{
 	  tree convs = lookup_conversions (argtypes[i]);
 
+	  if (i == 0 && code == MODIFY_EXPR && code2 == NOP_EXPR)
+	    return candidates;
+
+	  convs = lookup_conversions (argtypes[i]);
+
 	  if (code == COND_EXPR)
 	    {
 	      if (real_lvalue_p (args[i]))
@@ -1816,9 +1821,8 @@ add_builtin_candidates (candidates, code, code2, fnname, args, flags)
 	      types[i] = scratch_tree_cons
 		(NULL_TREE, TYPE_MAIN_VARIANT (argtypes[i]), types[i]);
 	    }
-		
-	  else if (! convs || (i == 0 && code == MODIFY_EXPR
-			       && code2 == NOP_EXPR))
+
+	  else if (! convs)
 	    return candidates;
 
 	  for (; convs; convs = TREE_CHAIN (convs))
diff --git a/gcc/cp/cvt.c b/gcc/cp/cvt.c
index abf8475..5c4c0b0 100644
--- a/gcc/cp/cvt.c
+++ b/gcc/cp/cvt.c
@@ -941,36 +941,99 @@ 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);
 
-  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;
+  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);
+      case FUNCTION_TYPE:
+      case ARRAY_TYPE:
+	return (desires & WANT_POINTER) ? default_conversion (expr)
+     	                                : NULL_TREE;
+      default:
+	return NULL_TREE;
+      }
+
+  /* The code for conversions from class type is currently only used for
+     delete expressions.  Other expressions are handled by build_new_op.  */
+
+  if (! TYPE_HAS_CONVERSION (basetype))
+    return NULL_TREE;
+
+  for (conv = lookup_conversions (basetype); conv; conv = TREE_CHAIN (conv))
+    {
+      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;
+	}
+    }
 
-    default:
-      break;
+  if (winner)
+    {
+      tree type = TREE_TYPE (TREE_TYPE (winner));
+      if (TREE_CODE (type) == REFERENCE_TYPE)
+	type = TREE_TYPE (type);
+      return build_user_type_conversion (type, expr, LOOKUP_NORMAL);
     }
 
   return NULL_TREE;
diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c
index 25488c2..b498599 100644
--- a/gcc/cp/decl2.c
+++ b/gcc/cp/decl2.c
@@ -1236,9 +1236,7 @@ delete_sanity (exp, size, doing_vec, use_global_delete)
      tree exp, size;
      int doing_vec, use_global_delete;
 {
-  tree t;
-  tree type;
-  enum tree_code code;
+  tree t, type;
   /* For a regular vector delete (aka, no size argument) we will pass
      this down as a NULL_TREE into build_vec_delete.  */
   tree maxindex = NULL_TREE;
@@ -1254,65 +1252,45 @@ delete_sanity (exp, size, doing_vec, use_global_delete)
       return t;
     }
 
-  t = exp;
-  if (TREE_CODE (t) == OFFSET_REF)
-    t = resolve_offset_ref (t);
-  t = stabilize_reference (convert_from_reference (t));
-  type = TREE_TYPE (t);
-  code = TREE_CODE (type);
+  if (TREE_CODE (exp) == OFFSET_REF)
+    exp = resolve_offset_ref (exp);
+  exp = convert_from_reference (exp);
+  t = stabilize_reference (exp);
+  t = build_expr_type_conversion (WANT_POINTER, t, 1);
 
-  switch (doing_vec)
+  if (t == NULL_TREE || t == error_mark_node)
     {
-    case 2:
-      maxindex = build_binary_op (MINUS_EXPR, size, integer_one_node, 1);
-      pedwarn ("anachronistic use of array size in vector delete");
-      /* Fall through.  */
-    case 1:
-      break;
-    default:
-      if (code != POINTER_TYPE)
-	{
-	  cp_error ("type `%#T' argument given to `delete', expected pointer",
-		    type);
-	  return error_mark_node;
-	}
-
-      /* Deleting a pointer with the value zero is valid and has no effect.  */
-      if (integer_zerop (t))
-	return build1 (NOP_EXPR, void_type_node, t);
+      cp_error ("type `%#T' argument given to `delete', expected pointer",
+		TREE_TYPE (exp));
+      return error_mark_node;
     }
 
-  if (code == POINTER_TYPE)
+  if (doing_vec == 2)
     {
-#if 0
-      /* As of Valley Forge, you can delete a pointer to const.  */
-      if (TREE_READONLY (TREE_TYPE (type)))
-	{
-	  error ("`const *' cannot be deleted");
-	  return error_mark_node;
-	}
-#endif
-      /* You can't delete functions.  */
-      if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
-	{
-	  error ("cannot delete a function");
-	  return error_mark_node;
-	}
+      maxindex = build_binary_op (MINUS_EXPR, size, integer_one_node, 1);
+      pedwarn ("anachronistic use of array size in vector delete");
     }
 
-#if 0
-  /* If the type has no destructor, then we should build a regular
-     delete, instead of a vector delete.  Otherwise, we would end
-     up passing a bogus offset into __builtin_delete, which is
-     not expecting it.  */ 
-  if (doing_vec
-      && TREE_CODE (type) == POINTER_TYPE
-      && !TYPE_HAS_DESTRUCTOR (TREE_TYPE (type)))
+  type = TREE_TYPE (t);
+
+  /* As of Valley Forge, you can delete a pointer to const.  */
+
+  /* You can't delete functions.  */
+  if (TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
     {
-      doing_vec = 0;
-      use_global_delete = 1;
+      error ("cannot delete a function");
+      return error_mark_node;
     }
-#endif
+
+  /* An array can't have been allocated by new, so complain.  */
+  if (TREE_CODE (t) == ADDR_EXPR
+      && TREE_CODE (TREE_OPERAND (t, 0)) == VAR_DECL
+      && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == ARRAY_TYPE)
+    cp_warning ("deleting array `%#D'", TREE_OPERAND (t, 0));
+
+  /* Deleting a pointer with the value zero is valid and has no effect.  */
+  if (integer_zerop (t))
+    return build1 (NOP_EXPR, void_type_node, t);
 
   if (doing_vec)
     return build_vec_delete (t, maxindex, integer_one_node,
diff --git a/gcc/cp/except.c b/gcc/cp/except.c
index d5859f8..dba0f09 100644
--- a/gcc/cp/except.c
+++ b/gcc/cp/except.c
@@ -1077,13 +1077,21 @@ tree
 build_throw (e)
      tree e;
 {
-  if (e != error_mark_node)
+  if (e == error_mark_node)
+    return e;
+
+  if (processing_template_decl)
+    return build_min (THROW_EXPR, void_type_node, e);
+
+  if (! flag_ansi && e == null_node)
     {
-      if (processing_template_decl)
-	return build_min (THROW_EXPR, void_type_node, e);
-      e = build1 (THROW_EXPR, void_type_node, e);
-      TREE_SIDE_EFFECTS (e) = 1;
-      TREE_USED (e) = 1;
+      cp_warning ("throwing NULL");
+      e = integer_zero_node;
     }
+
+  e = build1 (THROW_EXPR, void_type_node, e);
+  TREE_SIDE_EFFECTS (e) = 1;
+  TREE_USED (e) = 1;
+
   return e;
 }
diff --git a/gcc/cp/init.c b/gcc/cp/init.c
index c9de483..828729c 100644
--- a/gcc/cp/init.c
+++ b/gcc/cp/init.c
@@ -197,9 +197,11 @@ perform_member_init (member, name, init, explicit)
 	{
 	  if (explicit)
 	    {
-	      cp_error ("incomplete initializer for member `%D' of class `%T' which has no constructor",
-			member, current_class_type);
-	      init = error_mark_node;
+	      /* default-initialization.  */
+	      if (AGGREGATE_TYPE_P (type))
+		init = build (CONSTRUCTOR, type, NULL_TREE, NULL_TREE);
+	      else
+		init = integer_zero_node;
 	    }
 	  /* member traversal: note it leaves init NULL */
 	  else if (TREE_CODE (TREE_TYPE (member)) == REFERENCE_TYPE)
@@ -222,7 +224,8 @@ perform_member_init (member, name, init, explicit)
 	 current_member_init_list.  */
       if (init || explicit)
 	{
-	  decl = build_component_ref (current_class_ref, name, NULL_TREE, explicit);
+	  decl = build_component_ref (current_class_ref, name, NULL_TREE,
+				      explicit);
 	  expand_expr_stmt (build_modify_expr (decl, INIT_EXPR, init));
 	}
     }
@@ -238,7 +241,8 @@ perform_member_init (member, name, init, explicit)
       push_obstacks_nochange ();
       resume_temporary_allocation ();
 
-      expr = build_component_ref (current_class_ref, name, NULL_TREE, explicit);
+      expr = build_component_ref (current_class_ref, name, NULL_TREE,
+				  explicit);
       expr = build_delete (type, expr, integer_zero_node,
 			   LOOKUP_NONVIRTUAL|LOOKUP_DESTRUCTOR, 0);
 
diff --git a/gcc/cp/parse.c b/gcc/cp/parse.c
index 481a1ff..3f5f4f2 100644
--- a/gcc/cp/parse.c
+++ b/gcc/cp/parse.c
@@ -697,18 +697,18 @@ static const short yyrline[] = { 0,
   3174,  3176,  3178,  3180,  3183,  3184,  3186,  3189,  3190,  3193,
   3193,  3196,  3196,  3199,  3199,  3201,  3203,  3205,  3207,  3213,
   3219,  3222,  3225,  3231,  3233,  3235,  3239,  3241,  3244,  3251,
-  3257,  3266,  3270,  3272,  3275,  3277,  3280,  3284,  3286,  3289,
-  3291,  3294,  3311,  3317,  3325,  3327,  3329,  3333,  3336,  3337,
-  3345,  3349,  3353,  3356,  3357,  3363,  3366,  3369,  3371,  3375,
-  3380,  3383,  3393,  3398,  3399,  3406,  3409,  3412,  3414,  3417,
-  3419,  3429,  3443,  3447,  3450,  3452,  3456,  3460,  3463,  3466,
-  3468,  3472,  3474,  3481,  3488,  3491,  3494,  3498,  3502,  3508,
-  3512,  3517,  3519,  3522,  3527,  3533,  3544,  3547,  3549,  3553,
-  3558,  3560,  3567,  3570,  3572,  3574,  3580,  3585,  3588,  3590,
-  3592,  3594,  3596,  3598,  3600,  3602,  3604,  3606,  3608,  3610,
-  3612,  3614,  3616,  3618,  3620,  3622,  3624,  3626,  3628,  3630,
-  3632,  3634,  3636,  3638,  3640,  3642,  3644,  3646,  3648,  3650,
-  3653,  3655
+  3257,  3265,  3269,  3271,  3274,  3276,  3279,  3283,  3285,  3288,
+  3290,  3293,  3310,  3316,  3324,  3326,  3328,  3332,  3335,  3336,
+  3344,  3348,  3352,  3355,  3356,  3362,  3365,  3368,  3370,  3374,
+  3379,  3382,  3392,  3397,  3398,  3405,  3408,  3411,  3413,  3416,
+  3418,  3428,  3442,  3446,  3449,  3451,  3455,  3459,  3462,  3465,
+  3467,  3471,  3473,  3480,  3487,  3490,  3493,  3497,  3501,  3507,
+  3511,  3516,  3518,  3521,  3526,  3532,  3543,  3546,  3548,  3552,
+  3557,  3559,  3566,  3569,  3571,  3573,  3579,  3584,  3587,  3589,
+  3591,  3593,  3595,  3597,  3599,  3601,  3603,  3605,  3607,  3609,
+  3611,  3613,  3615,  3617,  3619,  3621,  3623,  3625,  3627,  3629,
+  3631,  3633,  3635,  3637,  3639,  3641,  3643,  3645,  3647,  3649,
+  3652,  3654
 };
 #endif
 
@@ -7185,7 +7185,7 @@ case 730:
 #line 3252 "parse.y"
 { 
                   expand_start_all_catch (); 
-                  expand_start_catch (NULL);
+                  start_catch_handler (NULL);
                 ;
     break;}
 case 731:
@@ -7194,46 +7194,45 @@ case 731:
 		  int nested = (hack_decl_function_context
 				(current_function_decl) != NULL_TREE);
 		  expand_end_all_catch ();
-                  expand_end_catch ();
 		  finish_function (lineno, (int)yyvsp[-3].itype, nested);
 		;
     break;}
 case 732:
-#line 3268 "parse.y"
+#line 3267 "parse.y"
 { yyval.ttype = begin_try_block (); ;
     break;}
 case 733:
-#line 3270 "parse.y"
+#line 3269 "parse.y"
 { finish_try_block (yyvsp[-1].ttype); ;
     break;}
 case 734:
-#line 3272 "parse.y"
+#line 3271 "parse.y"
 { finish_handler_sequence (yyvsp[-3].ttype); ;
     break;}
 case 737:
-#line 3282 "parse.y"
+#line 3281 "parse.y"
 { yyval.ttype = begin_handler(); ;
     break;}
 case 738:
-#line 3284 "parse.y"
+#line 3283 "parse.y"
 { finish_handler_parms (yyvsp[-1].ttype); ;
     break;}
 case 739:
-#line 3286 "parse.y"
+#line 3285 "parse.y"
 { finish_handler (yyvsp[-3].ttype); ;
     break;}
 case 742:
-#line 3296 "parse.y"
+#line 3295 "parse.y"
 { expand_start_catch_block (NULL_TREE, NULL_TREE); ;
     break;}
 case 743:
-#line 3312 "parse.y"
+#line 3311 "parse.y"
 { check_for_new_type ("inside exception declarations", yyvsp[-1].ftype);
 		  expand_start_catch_block (TREE_PURPOSE (yyvsp[-1].ftype.t),
 					    TREE_VALUE (yyvsp[-1].ftype.t)); ;
     break;}
 case 744:
-#line 3319 "parse.y"
+#line 3318 "parse.y"
 { tree label;
 		do_label:
 		  label = define_label (input_filename, lineno, yyvsp[-1].ttype);
@@ -7242,98 +7241,98 @@ case 744:
 		;
     break;}
 case 745:
-#line 3326 "parse.y"
+#line 3325 "parse.y"
 { goto do_label; ;
     break;}
 case 746:
-#line 3328 "parse.y"
+#line 3327 "parse.y"
 { goto do_label; ;
     break;}
 case 747:
-#line 3330 "parse.y"
+#line 3329 "parse.y"
 { goto do_label; ;
     break;}
 case 748:
-#line 3335 "parse.y"
+#line 3334 "parse.y"
 { if (yyvsp[-1].ttype) cplus_expand_expr_stmt (yyvsp[-1].ttype); ;
     break;}
 case 750:
-#line 3338 "parse.y"
+#line 3337 "parse.y"
 { if (pedantic)
 		    pedwarn ("ANSI C++ forbids compound statements inside for initializations");
 		;
     break;}
 case 751:
-#line 3347 "parse.y"
+#line 3346 "parse.y"
 { emit_line_note (input_filename, lineno);
 		  yyval.ttype = NULL_TREE; ;
     break;}
 case 752:
-#line 3350 "parse.y"
+#line 3349 "parse.y"
 { emit_line_note (input_filename, lineno); ;
     break;}
 case 753:
-#line 3355 "parse.y"
+#line 3354 "parse.y"
 { yyval.ttype = NULL_TREE; ;
     break;}
 case 755:
-#line 3358 "parse.y"
+#line 3357 "parse.y"
 { yyval.ttype = NULL_TREE; ;
     break;}
 case 756:
-#line 3365 "parse.y"
+#line 3364 "parse.y"
 { yyval.ttype = NULL_TREE; ;
     break;}
 case 759:
-#line 3372 "parse.y"
+#line 3371 "parse.y"
 { yyval.ttype = chainon (yyval.ttype, yyvsp[0].ttype); ;
     break;}
 case 760:
-#line 3377 "parse.y"
+#line 3376 "parse.y"
 { yyval.ttype = build_tree_list (yyval.ttype, yyvsp[-1].ttype); ;
     break;}
 case 761:
-#line 3382 "parse.y"
+#line 3381 "parse.y"
 { yyval.ttype = tree_cons (NULL_TREE, yyval.ttype, NULL_TREE); ;
     break;}
 case 762:
-#line 3384 "parse.y"
+#line 3383 "parse.y"
 { yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, yyval.ttype); ;
     break;}
 case 763:
-#line 3395 "parse.y"
+#line 3394 "parse.y"
 {
 		  yyval.ttype = empty_parms();
 		;
     break;}
 case 765:
-#line 3400 "parse.y"
+#line 3399 "parse.y"
 { yyval.ttype = finish_parmlist (build_tree_list (NULL_TREE, yyvsp[0].ftype.t), 0);
 		  check_for_new_type ("inside parameter list", yyvsp[0].ftype); ;
     break;}
 case 766:
-#line 3408 "parse.y"
+#line 3407 "parse.y"
 { yyval.ttype = finish_parmlist (yyval.ttype, 0); ;
     break;}
 case 767:
-#line 3410 "parse.y"
+#line 3409 "parse.y"
 { yyval.ttype = finish_parmlist (yyvsp[-1].ttype, 1); ;
     break;}
 case 768:
-#line 3413 "parse.y"
+#line 3412 "parse.y"
 { yyval.ttype = finish_parmlist (yyvsp[-1].ttype, 1); ;
     break;}
 case 769:
-#line 3415 "parse.y"
+#line 3414 "parse.y"
 { yyval.ttype = finish_parmlist (build_tree_list (NULL_TREE,
 							 yyvsp[-1].ftype.t), 1); ;
     break;}
 case 770:
-#line 3418 "parse.y"
+#line 3417 "parse.y"
 { yyval.ttype = finish_parmlist (NULL_TREE, 1); ;
     break;}
 case 771:
-#line 3420 "parse.y"
+#line 3419 "parse.y"
 {
 		  /* This helps us recover from really nasty
 		     parse errors, for example, a missing right
@@ -7345,7 +7344,7 @@ case 771:
 		;
     break;}
 case 772:
-#line 3430 "parse.y"
+#line 3429 "parse.y"
 {
 		  /* This helps us recover from really nasty
 		     parse errors, for example, a missing right
@@ -7358,98 +7357,98 @@ case 772:
 		;
     break;}
 case 773:
-#line 3445 "parse.y"
+#line 3444 "parse.y"
 { maybe_snarf_defarg (); ;
     break;}
 case 774:
-#line 3447 "parse.y"
+#line 3446 "parse.y"
 { yyval.ttype = yyvsp[0].ttype; ;
     break;}
 case 777:
-#line 3458 "parse.y"
+#line 3457 "parse.y"
 { check_for_new_type ("in a parameter list", yyvsp[0].ftype);
 		  yyval.ttype = build_tree_list (NULL_TREE, yyvsp[0].ftype.t); ;
     break;}
 case 778:
-#line 3461 "parse.y"
+#line 3460 "parse.y"
 { check_for_new_type ("in a parameter list", yyvsp[-1].ftype);
 		  yyval.ttype = build_tree_list (yyvsp[0].ttype, yyvsp[-1].ftype.t); ;
     break;}
 case 779:
-#line 3464 "parse.y"
+#line 3463 "parse.y"
 { check_for_new_type ("in a parameter list", yyvsp[0].ftype);
 		  yyval.ttype = chainon (yyval.ttype, yyvsp[0].ftype.t); ;
     break;}
 case 780:
-#line 3467 "parse.y"
+#line 3466 "parse.y"
 { yyval.ttype = chainon (yyval.ttype, build_tree_list (NULL_TREE, yyvsp[0].ttype)); ;
     break;}
 case 781:
-#line 3469 "parse.y"
+#line 3468 "parse.y"
 { yyval.ttype = chainon (yyval.ttype, build_tree_list (yyvsp[0].ttype, yyvsp[-2].ttype)); ;
     break;}
 case 783:
-#line 3475 "parse.y"
+#line 3474 "parse.y"
 { check_for_new_type ("in a parameter list", yyvsp[-1].ftype);
 		  yyval.ttype = build_tree_list (NULL_TREE, yyvsp[-1].ftype.t); ;
     break;}
 case 784:
-#line 3485 "parse.y"
+#line 3484 "parse.y"
 { tree specs = strip_attrs (yyvsp[-1].ftype.t);
 		  yyval.ftype.new_type_flag = yyvsp[-1].ftype.new_type_flag;
 		  yyval.ftype.t = build_tree_list (specs, yyvsp[0].ttype); ;
     break;}
 case 785:
-#line 3489 "parse.y"
+#line 3488 "parse.y"
 { yyval.ftype.t = build_tree_list (yyvsp[-1].ftype.t, yyvsp[0].ttype); 
 		  yyval.ftype.new_type_flag = yyvsp[-1].ftype.new_type_flag; ;
     break;}
 case 786:
-#line 3492 "parse.y"
+#line 3491 "parse.y"
 { yyval.ftype.t = build_tree_list (get_decl_list (yyvsp[-1].ftype.t), yyvsp[0].ttype); 
 		  yyval.ftype.new_type_flag = yyvsp[-1].ftype.new_type_flag; ;
     break;}
 case 787:
-#line 3495 "parse.y"
+#line 3494 "parse.y"
 { tree specs = strip_attrs (yyvsp[-1].ftype.t);
 		  yyval.ftype.t = build_tree_list (specs, yyvsp[0].ttype);
 		  yyval.ftype.new_type_flag = yyvsp[-1].ftype.new_type_flag; ;
     break;}
 case 788:
-#line 3499 "parse.y"
+#line 3498 "parse.y"
 { tree specs = strip_attrs (yyvsp[0].ftype.t);
 		  yyval.ftype.t = build_tree_list (specs, NULL_TREE); 
 		  yyval.ftype.new_type_flag = yyvsp[0].ftype.new_type_flag; ;
     break;}
 case 789:
-#line 3503 "parse.y"
+#line 3502 "parse.y"
 { tree specs = strip_attrs (yyvsp[-1].ttype);
 		  yyval.ftype.t = build_tree_list (specs, yyvsp[0].ttype); 
 		  yyval.ftype.new_type_flag = 0; ;
     break;}
 case 790:
-#line 3510 "parse.y"
+#line 3509 "parse.y"
 { yyval.ftype.t = build_tree_list (NULL_TREE, yyvsp[0].ftype.t);
 		  yyval.ftype.new_type_flag = yyvsp[0].ftype.new_type_flag;  ;
     break;}
 case 791:
-#line 3513 "parse.y"
+#line 3512 "parse.y"
 { yyval.ftype.t = build_tree_list (yyvsp[0].ttype, yyvsp[-1].ftype.t);
 		  yyval.ftype.new_type_flag = yyvsp[-1].ftype.new_type_flag;  ;
     break;}
 case 794:
-#line 3524 "parse.y"
+#line 3523 "parse.y"
 { see_typename (); ;
     break;}
 case 795:
-#line 3529 "parse.y"
+#line 3528 "parse.y"
 {
 		  error ("type specifier omitted for parameter");
 		  yyval.ttype = build_tree_list (integer_type_node, NULL_TREE);
 		;
     break;}
 case 796:
-#line 3534 "parse.y"
+#line 3533 "parse.y"
 {
 		  error ("type specifier omitted for parameter");
 		  if (TREE_CODE (yyval.ttype) == SCOPE_REF
@@ -7460,188 +7459,188 @@ case 796:
 		;
     break;}
 case 797:
-#line 3546 "parse.y"
+#line 3545 "parse.y"
 { yyval.ttype = NULL_TREE; ;
     break;}
 case 798:
-#line 3548 "parse.y"
+#line 3547 "parse.y"
 { yyval.ttype = yyvsp[-1].ttype; ;
     break;}
 case 799:
-#line 3550 "parse.y"
+#line 3549 "parse.y"
 { yyval.ttype = build_decl_list (NULL_TREE, NULL_TREE); ;
     break;}
 case 800:
-#line 3555 "parse.y"
+#line 3554 "parse.y"
 { yyval.ttype = build_decl_list (NULL_TREE, groktypename(yyvsp[0].ftype.t)); ;
     break;}
 case 802:
-#line 3561 "parse.y"
+#line 3560 "parse.y"
 {
 		  TREE_CHAIN (yyvsp[0].ttype) = yyval.ttype;
 		  yyval.ttype = yyvsp[0].ttype;
 		;
     break;}
 case 803:
-#line 3569 "parse.y"
+#line 3568 "parse.y"
 { yyval.ttype = NULL_TREE; ;
     break;}
 case 804:
-#line 3571 "parse.y"
+#line 3570 "parse.y"
 { yyval.ttype = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ;
     break;}
 case 805:
-#line 3573 "parse.y"
+#line 3572 "parse.y"
 { yyval.ttype = make_reference_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ;
     break;}
 case 806:
-#line 3575 "parse.y"
+#line 3574 "parse.y"
 { tree arg = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype);
 		  yyval.ttype = build_parse_node (SCOPE_REF, yyvsp[-2].ttype, arg);
 		;
     break;}
 case 807:
-#line 3582 "parse.y"
+#line 3581 "parse.y"
 { got_scope = NULL_TREE; ;
     break;}
 case 808:
-#line 3587 "parse.y"
+#line 3586 "parse.y"
 { yyval.ttype = ansi_opname[MULT_EXPR]; ;
     break;}
 case 809:
-#line 3589 "parse.y"
+#line 3588 "parse.y"
 { yyval.ttype = ansi_opname[TRUNC_DIV_EXPR]; ;
     break;}
 case 810:
-#line 3591 "parse.y"
+#line 3590 "parse.y"
 { yyval.ttype = ansi_opname[TRUNC_MOD_EXPR]; ;
     break;}
 case 811:
-#line 3593 "parse.y"
+#line 3592 "parse.y"
 { yyval.ttype = ansi_opname[PLUS_EXPR]; ;
     break;}
 case 812:
-#line 3595 "parse.y"
+#line 3594 "parse.y"
 { yyval.ttype = ansi_opname[MINUS_EXPR]; ;
     break;}
 case 813:
-#line 3597 "parse.y"
+#line 3596 "parse.y"
 { yyval.ttype = ansi_opname[BIT_AND_EXPR]; ;
     break;}
 case 814:
-#line 3599 "parse.y"
+#line 3598 "parse.y"
 { yyval.ttype = ansi_opname[BIT_IOR_EXPR]; ;
     break;}
 case 815:
-#line 3601 "parse.y"
+#line 3600 "parse.y"
 { yyval.ttype = ansi_opname[BIT_XOR_EXPR]; ;
     break;}
 case 816:
-#line 3603 "parse.y"
+#line 3602 "parse.y"
 { yyval.ttype = ansi_opname[BIT_NOT_EXPR]; ;
     break;}
 case 817:
-#line 3605 "parse.y"
+#line 3604 "parse.y"
 { yyval.ttype = ansi_opname[COMPOUND_EXPR]; ;
     break;}
 case 818:
-#line 3607 "parse.y"
+#line 3606 "parse.y"
 { yyval.ttype = ansi_opname[yyvsp[0].code]; ;
     break;}
 case 819:
-#line 3609 "parse.y"
+#line 3608 "parse.y"
 { yyval.ttype = ansi_opname[LT_EXPR]; ;
     break;}
 case 820:
-#line 3611 "parse.y"
+#line 3610 "parse.y"
 { yyval.ttype = ansi_opname[GT_EXPR]; ;
     break;}
 case 821:
-#line 3613 "parse.y"
+#line 3612 "parse.y"
 { yyval.ttype = ansi_opname[yyvsp[0].code]; ;
     break;}
 case 822:
-#line 3615 "parse.y"
+#line 3614 "parse.y"
 { yyval.ttype = ansi_assopname[yyvsp[0].code]; ;
     break;}
 case 823:
-#line 3617 "parse.y"
+#line 3616 "parse.y"
 { yyval.ttype = ansi_opname [MODIFY_EXPR]; ;
     break;}
 case 824:
-#line 3619 "parse.y"
+#line 3618 "parse.y"
 { yyval.ttype = ansi_opname[yyvsp[0].code]; ;
     break;}
 case 825:
-#line 3621 "parse.y"
+#line 3620 "parse.y"
 { yyval.ttype = ansi_opname[yyvsp[0].code]; ;
     break;}
 case 826:
-#line 3623 "parse.y"
+#line 3622 "parse.y"
 { yyval.ttype = ansi_opname[POSTINCREMENT_EXPR]; ;
     break;}
 case 827:
-#line 3625 "parse.y"
+#line 3624 "parse.y"
 { yyval.ttype = ansi_opname[PREDECREMENT_EXPR]; ;
     break;}
 case 828:
-#line 3627 "parse.y"
+#line 3626 "parse.y"
 { yyval.ttype = ansi_opname[TRUTH_ANDIF_EXPR]; ;
     break;}
 case 829:
-#line 3629 "parse.y"
+#line 3628 "parse.y"
 { yyval.ttype = ansi_opname[TRUTH_ORIF_EXPR]; ;
     break;}
 case 830:
-#line 3631 "parse.y"
+#line 3630 "parse.y"
 { yyval.ttype = ansi_opname[TRUTH_NOT_EXPR]; ;
     break;}
 case 831:
-#line 3633 "parse.y"
+#line 3632 "parse.y"
 { yyval.ttype = ansi_opname[COND_EXPR]; ;
     break;}
 case 832:
-#line 3635 "parse.y"
+#line 3634 "parse.y"
 { yyval.ttype = ansi_opname[yyvsp[0].code]; ;
     break;}
 case 833:
-#line 3637 "parse.y"
+#line 3636 "parse.y"
 { yyval.ttype = ansi_opname[COMPONENT_REF]; ;
     break;}
 case 834:
-#line 3639 "parse.y"
+#line 3638 "parse.y"
 { yyval.ttype = ansi_opname[MEMBER_REF]; ;
     break;}
 case 835:
-#line 3641 "parse.y"
+#line 3640 "parse.y"
 { yyval.ttype = ansi_opname[CALL_EXPR]; ;
     break;}
 case 836:
-#line 3643 "parse.y"
+#line 3642 "parse.y"
 { yyval.ttype = ansi_opname[ARRAY_REF]; ;
     break;}
 case 837:
-#line 3645 "parse.y"
+#line 3644 "parse.y"
 { yyval.ttype = ansi_opname[NEW_EXPR]; ;
     break;}
 case 838:
-#line 3647 "parse.y"
+#line 3646 "parse.y"
 { yyval.ttype = ansi_opname[DELETE_EXPR]; ;
     break;}
 case 839:
-#line 3649 "parse.y"
+#line 3648 "parse.y"
 { yyval.ttype = ansi_opname[VEC_NEW_EXPR]; ;
     break;}
 case 840:
-#line 3651 "parse.y"
+#line 3650 "parse.y"
 { yyval.ttype = ansi_opname[VEC_DELETE_EXPR]; ;
     break;}
 case 841:
-#line 3654 "parse.y"
+#line 3653 "parse.y"
 { yyval.ttype = grokoptypename (yyvsp[-1].ftype.t, yyvsp[0].ttype); ;
     break;}
 case 842:
-#line 3656 "parse.y"
+#line 3655 "parse.y"
 { yyval.ttype = ansi_opname[ERROR_MARK]; ;
     break;}
 }
@@ -7842,7 +7841,7 @@ yyerrhandle:
   yystate = yyn;
   goto yynewstate;
 }
-#line 3659 "parse.y"
+#line 3658 "parse.y"
 
 
 #ifdef SPEW_DEBUG
diff --git a/gcc/cp/search.c b/gcc/cp/search.c
index e92e8d8..4bece8b 100644
--- a/gcc/cp/search.c
+++ b/gcc/cp/search.c
@@ -961,15 +961,14 @@ compute_access (basetype_path, field)
     return access_public_node;
 
   previous_scope = current_scope ();
-  
-  context = DECL_CLASS_CONTEXT (field);
-  if (context == NULL_TREE)
-    context = DECL_CONTEXT (field);
+
+  context = DECL_REAL_CONTEXT (field);
 
   /* Fields coming from nested anonymous unions have their DECL_CLASS_CONTEXT
      slot set to the union type rather than the record type containing
      the anonymous union.  */
-  if (context && ANON_UNION_TYPE_P (context))
+  if (context && ANON_UNION_TYPE_P (context)
+      && TREE_CODE (field) == FIELD_DECL)
     context = TYPE_CONTEXT (context);
 
   /* Virtual function tables are never private.  But we should know that
diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c
index f394f40..8156398 100644
--- a/gcc/cp/typeck.c
+++ b/gcc/cp/typeck.c
@@ -2564,8 +2564,19 @@ build_x_function_call (function, params, decl)
 	decl = current_class_ref;
 
       decl_addr = build_unary_op (ADDR_EXPR, decl, 0);
-      function = get_member_function_from_ptrfunc (&decl_addr,
-						   TREE_OPERAND (function, 1));
+
+      /* Sigh.  OFFSET_REFs are being used for too many things.
+	 They're being used both for -> and ->*, and we want to resolve
+	 the -> cases here, but leave the ->*.  We could use
+	 resolve_offset_ref for those, too, but it would call
+         get_member_function_from_ptrfunc and decl_addr wouldn't get
+         updated properly.  Nasty.  */
+      if (TREE_CODE (TREE_OPERAND (function, 1)) == FIELD_DECL)
+	function = resolve_offset_ref (function);
+      else
+	function = TREE_OPERAND (function, 1);
+
+      function = get_member_function_from_ptrfunc (&decl_addr, function);
       params = expr_tree_cons (NULL_TREE, decl_addr, params);
       return build_function_call (function, params);
     }
@@ -7271,8 +7282,7 @@ c_expand_return (retval)
   if (valtype == NULL_TREE || TREE_CODE (valtype) == VOID_TYPE)
     {
       current_function_returns_null = 1;
-      if ((pedantic && ! DECL_ARTIFICIAL (current_function_decl))
-	  || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
+      if (TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE)
 	pedwarn ("`return' with a value, in function returning void");
       expand_return (retval);
       return;
@@ -7477,22 +7487,17 @@ comp_ptr_ttypes_real (to, from, constp)
 	 so the usual checks are not appropriate.  */
       if (TREE_CODE (to) != FUNCTION_TYPE && TREE_CODE (to) != METHOD_TYPE)
 	{
-	  switch (comp_cv_qualification (from, to))
-	    {
-	    case 1:
-	      /* FROM is more cv-qualified than TO.  */
-	      return 0;
+	  if (TYPE_READONLY (from) > TYPE_READONLY (to)
+	      || TYPE_VOLATILE (from) > TYPE_VOLATILE (to))
+	    return 0;
 
-	    case -1:
-	      /* TO is more cv-qualified than FROM.  */
+	  if (TYPE_READONLY (to) > TYPE_READONLY (from)
+	      || TYPE_VOLATILE (to) > TYPE_VOLATILE (from))
+	    {
 	      if (constp == 0)
 		return 0;
-	      else 
+	      else
 		++to_more_cv_qualified;
-	      break;
-
-	    default:
-	      break;
 	    }
 
 	  if (constp > 0)