* call.c (build_method_call): Remove bogus code for two-argument

	delete.
	* init.c (build_new_1): Expand on comment, and remove dead code.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@27547 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 53e5f61..4336252 100644 (file)
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,5 +1,9 @@
 1999-06-16  Mark Mitchell  <mark@codesourcery.com>
 
+       * call.c (build_method_call): Remove bogus code for two-argument
+       delete.
+       * init.c (build_new_1): Expand on comment, and remove dead code.
+
        * init.c (expand_cleanup_for_base): New function, split out
        from ...
        (emit_base_init): Here.

diff --git a/gcc/cp/call.c b/gcc/cp/call.c
index 66d98c5..cdfba04 100644 (file)
--- a/gcc/cp/call.c
+++ b/gcc/cp/call.c
@@ -474,29 +474,6 @@ build_method_call (instance, name, parms, basetype_path, flags)
       return build_min_nt (METHOD_CALL_EXPR, name, instance, parms, NULL_TREE);
     }
 
-  /* This is the logic that magically deletes the second argument to
-     operator delete, if it is not needed.  */
-  if (name == ansi_opname[(int) DELETE_EXPR] && list_length (parms)==2)
-    {
-      tree save_last = TREE_CHAIN (parms);
-
-      /* get rid of unneeded argument */
-      TREE_CHAIN (parms) = NULL_TREE;
-      if (build_method_call (instance, name, parms, basetype_path,
-                            (LOOKUP_SPECULATIVELY|flags) & ~LOOKUP_COMPLAIN))
-       {
-         /* If it finds a match, return it.  */
-         return build_method_call (instance, name, parms, basetype_path, flags);
-       }
-      /* If it doesn't work, two argument delete must work */
-      TREE_CHAIN (parms) = save_last;
-    }
-  /* We already know whether it's needed or not for vec delete.  */
-  else if (name == ansi_opname[(int) VEC_DELETE_EXPR]
-          && TYPE_LANG_SPECIFIC (TREE_TYPE (instance))
-          && ! TYPE_VEC_DELETE_TAKES_SIZE (TREE_TYPE (instance)))
-    TREE_CHAIN (parms) = NULL_TREE;
-
   if (TREE_CODE (name) == BIT_NOT_EXPR)
     {
       if (parms)

diff --git a/gcc/cp/init.c b/gcc/cp/init.c
index 852bb0b..019b5f9 100644 (file)
--- a/gcc/cp/init.c
+++ b/gcc/cp/init.c
@@ -2191,21 +2191,21 @@ build_new_1 (exp)
       signature_error (NULL_TREE, true_type);
       return error_mark_node;
     }
+  
+  /* When we allocate an array, and the corresponding deallocation
+     function takes a second argument of type size_t, and that's the
+     "usual deallocation function", we allocate some extra space at
+     the beginning of the array to store the size of the array.
 
-#if 1
-  /* Get a little extra space to store a couple of things before the new'ed
-     array, if this isn't the default placement new.  */
+     Well, that's what we should do.  For backwards compatibility, we
+     have to do this whenever there's a two-argument array-delete
+     operator. 
 
+     FIXME: For -fnew-abi, we don't have to maintain backwards
+     compatibility and we should fix this.  */
   use_cookie = (has_array && TYPE_VEC_NEW_USES_COOKIE (true_type)
                && ! (placement && ! TREE_CHAIN (placement)
                      && TREE_TYPE (TREE_VALUE (placement)) == ptr_type_node));
-#else
-  /* Get a little extra space to store a couple of things before the new'ed
-     array, if this is either non-placement new or new (nothrow).  */
-  
-  use_cookie = (has_array && TYPE_VEC_NEW_USES_COOKIE (true_type)
-               && (! placement || nothrow));
-#endif
 
   if (use_cookie)
     {

diff --git a/gcc/testsuite/g++.old-deja/g++.other/delete6.C b/gcc/testsuite/g++.old-deja/g++.other/delete6.C
new file mode 100644 (file)
index 0000000..f1777a6
--- /dev/null
+++ b/gcc/testsuite/g++.old-deja/g++.other/delete6.C
@@ -0,0 +1,27 @@
+// Origin: Alexander Schiemann (aschiem@count.math.uni-sb.de)
+
+int i;
+
+struct B{};
+
+struct A{
+
+  static void* operator new(unsigned int)
+  {return &i;}
+
+  inline static void operator delete(void*p); 
+
+  static void operator delete(void*, const B&){} 
+
+};
+
+
+inline void A::operator delete(void*p)
+{A::operator delete(p,B());}
+
+
+int main()
+{A *ap=new A;
+delete ap;}
+
+