cp-tree.def (NON_DEPENDENT_EXPR): Add operand.

	* cp-tree.def (NON_DEPENDENT_EXPR): Add operand.
	* decl2.c (build_offset_ref_call_from_tree): Use
	build_non_dependent_expr.
	* error.c (dump_expr) <NON_DEPENDENT_EXPR case>: Dump the operand.
	* pt.c (build_non_dependent_expr): Set operand.

From-SVN: r70478

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index bee756c8f5d95d846e7473d9c716d3a713572d0a..e6c0bfb7566957ff8cecf097c5a4d9bc7ed1d503 100644 (file)
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,11 @@
+2003-08-15  Nathan Sidwell  <nathan@codesourcery.com>
+
+       * cp-tree.def (NON_DEPENDENT_EXPR): Add operand.
+       * decl2.c (build_offset_ref_call_from_tree): Use
+       build_non_dependent_expr.
+       * error.c (dump_expr) <NON_DEPENDENT_EXPR case>: Dump the operand.
+       * pt.c (build_non_dependent_expr): Set operand.
+       
 2003-08-14  Jan Hubicka  <jh@suse.cz>
 
        * decl2.c (mark_member_pointers): Rename to...
@@ -5,9 +13,9 @@
        (lower_function): Update call.
        * except.c (eh_type_info): Break out from ...
        (build_eh_type): ... here; tinfo is already used.
-        (finish_eh_spec_block): Mark tinfos as used.
-        * semantics.c (finish_handler_params): Mark tinfo as used.
-       * cp-tree.h(eh_type_info): Declare.
+       (finish_eh_spec_block): Mark tinfos as used.
+       * semantics.c (finish_handler_params): Mark tinfo as used.
+       * cp-tree.h (eh_type_info): Declare.
 
 2003-08-15  Nathan Sidwell  <nathan@codesourcery.com>
 

diff --git a/gcc/cp/cp-tree.def b/gcc/cp/cp-tree.def
index a5fa243a167249b809968ad0980d9db1292a98f2..36b7aaa85e83905ac6d36536e7966b89fc33551e 100644 (file)
--- a/gcc/cp/cp-tree.def
+++ b/gcc/cp/cp-tree.def
@@ -240,8 +240,9 @@ DEFTREECODE (PSEUDO_DTOR_EXPR, "pseudo_dtor_expr", 'e', 3)
    modify the original expression, which would change the mangling of
    that expression if it appeared in a template argument list.  In
    that situation, we create a NON_DEPENDENT_EXPR to take the place of
-   the original expression.  */
-DEFTREECODE (NON_DEPENDENT_EXPR, "non_dependent_expr", 'e', 0)
+   the original expression.  The expression is the only operand -- it
+   is only needed for diagnostics.   */
+DEFTREECODE (NON_DEPENDENT_EXPR, "non_dependent_expr", 'e', 1)
 
 /* CTOR_INITIALIZER is a placeholder in template code for a call to
    setup_vtbl_pointer (and appears in all functions, not just ctors).  */

diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c
index eb32f49378d6a7277c343414b5bc1a77fe361985..ace4313f337bb4637d96a9a96ee4c47161532393 100644 (file)
--- a/gcc/cp/decl2.c
+++ b/gcc/cp/decl2.c
@@ -2981,27 +2981,25 @@ finish_file ()
   input_location = locus;
 }
 
-/* FN is an OFFSET_REF indicating the function to call in parse-tree
-   form; it has not yet been semantically analyzed.  ARGS are the
-   arguments to the function.  They have already been semantically
-   analzyed.  */
+/* FN is an OFFSET_REF, DOTSTAR_EXPR or MEMBER_REF indicating the
+   function to call in parse-tree form; it has not yet been
+   semantically analyzed.  ARGS are the arguments to the function.
+   They have already been semantically analyzed.  */
 
 tree
 build_offset_ref_call_from_tree (tree fn, tree args)
 {
-  tree object_addr;
   tree orig_fn;
   tree orig_args;
   tree expr;
+  tree object;
 
   orig_fn = fn;
   orig_args = args;
+  object = TREE_OPERAND (fn, 0);
 
   if (processing_template_decl)
     {
-      tree object;
-      tree object_type;
-
       my_friendly_assert (TREE_CODE (fn) == DOTSTAR_EXPR
                          || TREE_CODE (fn) == MEMBER_REF,
                          20030708);
@@ -3013,10 +3011,9 @@ build_offset_ref_call_from_tree (tree fn, tree args)
         parameter.  That must be done before the FN is transformed
         because we depend on the form of FN.  */
       args = build_non_dependent_args (args);
-      object_type = TREE_TYPE (TREE_OPERAND (fn, 0));
       if (TREE_CODE (fn) == DOTSTAR_EXPR)
-       object_type = build_pointer_type (non_reference (object_type));
-      object = build (NON_DEPENDENT_EXPR, object_type);
+       object = build_unary_op (ADDR_EXPR, object, 0);
+      object = build_non_dependent_expr (object);
       args = tree_cons (NULL_TREE, object, args);
       /* Now that the arguments are done, transform FN.  */
       fn = build_non_dependent_expr (fn);
@@ -3030,7 +3027,7 @@ build_offset_ref_call_from_tree (tree fn, tree args)
        void B::g() { (this->*p)(); }  */
   if (TREE_CODE (fn) == OFFSET_REF)
     {
-      object_addr = build_unary_op (ADDR_EXPR, TREE_OPERAND (fn, 0), 0);
+      tree object_addr = build_unary_op (ADDR_EXPR, object, 0);
       fn = TREE_OPERAND (fn, 1);
       fn = get_member_function_from_ptrfunc (&object_addr, fn);
       args = tree_cons (NULL_TREE, object_addr, args);

diff --git a/gcc/cp/error.c b/gcc/cp/error.c
index 380a5263a0b4747bfa405545127f0b4b1c743b6e..9aeb555c615033fe0df690bc3277a8725b3270af 100644 (file)
--- a/gcc/cp/error.c
+++ b/gcc/cp/error.c
@@ -1876,9 +1876,7 @@ dump_expr (tree t, int flags)
       break;
 
     case NON_DEPENDENT_EXPR:
-      pp_string (cxx_pp, "<expression of type ");
-      dump_type (TREE_TYPE (t), flags);
-      pp_greater (cxx_pp);
+      dump_expr (TREE_OPERAND (t, 0), flags);
       break;
 
       /*  This list is incomplete, but should suffice for now.

diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index 722c18e2a34a69b5fbc5fa410c05709e00d27ae7..d97463bc3907100360371ac97720285a7b2b3621 100644 (file)
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -11793,7 +11793,7 @@ build_non_dependent_expr (tree expr)
      the expression so that mangling (say) "f<g>" inside the body of
      "f" works out correctly.  Therefore, the REFERENCE_TYPE is
      stripped here.  */
-  return build (NON_DEPENDENT_EXPR, non_reference (TREE_TYPE (expr)));
+  return build1 (NON_DEPENDENT_EXPR, non_reference (TREE_TYPE (expr)), expr);
 }
 
 /* ARGS is a TREE_LIST of expressions as arguments to a function call.