[Bug c++/12238] New: placement delete not called on incomplete object construction if in try-block!

["noways at aliceposta dot it" <gcc-bugzilla at gcc dot gnu dot org>]

PLEASE REPLY TO gcc-bugzilla@gcc.gnu.org ONLY, *NOT* gcc-bugs@gcc.gnu.org.

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=12238

           Summary: placement delete not called on incomplete object
                    construction if in try-block!
           Product: gcc
           Version: 3.2.3
            Status: UNCONFIRMED
          Severity: critical
          Priority: P1
         Component: c++
        AssignedTo: unassigned at gcc dot gnu dot org
        ReportedBy: noways at aliceposta dot it
                CC: gcc-bugs at gcc dot gnu dot org

i'm using g++ mingw compiler under win 2000 server and i found that placement 
new is supported but the relative placement delete isn't called in case of 
incomplete construction of objects(exception in ctor), any way a non placement 
delete is called, i think this a difference from the c++ spec.

i've also found that in the same situation enclosed in try-catch block:

classtag* po;
try
{
  po = new classtag(); //if exception in ctor():
                       //step1: call to "delete po;"
                       //step2: jump to catch block
  delete po;
}
catch(int ignore)
{}

the step1 isn't performed!

thx in advice :) , sorry for the english! :|

Michele

/*****************************************************************************/


ORIGINAL TEST SOURCE:

#include <stdio.h>
#include <stdlib.h>

class allocator
{
	int memb;
} globalallocator;

void* operator new(size_t s)
{
	printf("::operator new(size_t s)\n");
	return malloc(s);
}
void* operator new(size_t s,allocator a)
{
	printf("::operator new(size_t s,allocator a)\n");
	return malloc(s);
}
void* operator new[](size_t s)
{
	printf("::operator new[](size_t s)\n");
	return malloc(s);
}
void* operator new[](size_t s,allocator a)
{
	printf("::operator new[](size_t s,allocator a)\n");
	return malloc(s);
}

void operator delete(void* p,size_t s)
{
	printf("::operator delete(void* p,size_t s)\n");
	free(p);
}
void operator delete(void* p,size_t s,allocator a)
{
	printf("::operator delete(void* p,size_t s,allocator a)\n");
	free(p);
}
void operator delete[](void* p,size_t s)
{
	printf("::operator delete[](void* p,size_t s)\n");
	free(p);
}
void operator delete[](void* p,size_t s,allocator a)
{
	printf("::operator delete[](void* p,size_t s,allocator a)\n");
	free(p);
}

class test3
{
	public:

	void* operator new(size_t s)
	{
		printf("test3::operator new(size_t s)\n");
		return malloc(s);
	}
	void* operator new(size_t s,allocator a)
	{
		printf("test3::operator new(size_t s,allocator a)\n");
		return malloc(s);
	}
	void* operator new[](size_t s)
	{
		printf("test3::operator new[](size_t s)\n");
		return malloc(s);
	}
	void* operator new[](size_t s,allocator a)
	{
		printf("test3::operator new[](size_t s,allocator a)\n");
		return malloc(s);
	}

	void operator delete(void* p,size_t s)
	{
		printf("test3::operator delete(void* p,size_t s)\n");
		free(p);
	}
	void operator delete(void* p,size_t s,allocator a)
	{
		printf("test3::operator delete(void* p,size_t s,allocator a)
\n");
		free(p);
	}
	void operator delete[](void* p,size_t s)
	{
		printf("test3::operator delete[](void* p,size_t s)\n");
		free(p);
	}
	void operator delete[](void* p,size_t s,allocator a)
	{
		printf("test3::operator delete[](void* p,size_t s,allocator a)
\n");
		free(p);
	}
};

class testderiv : public test3
{
	public:
	testderiv()
	{
		printf("testderiv::ctor()\n");
	}
	testderiv(int p)
	{
		if(p)
		{
			printf("testderiv::ctor(%d) EXCEPTION\n",p);
			throw 1;
		}
		else
		{
			printf("testderiv::ctor(%d)\n",p);
		}
	}
	~testderiv()
	{
		printf("testderiv::dtor()\n");
	}
};

class testderivarray : public test3
{
	public:
	testderivarray()
	{
		printf("testderivarray::ctor() EXCEPTION\n");
		throw 1;
	}

	~testderivarray()
	{
		printf("testderivarray::dtor()\n");
	}
};

int main()
{
	testderiv* po;
	testderivarray* poa;
	try
	{
		po = new testderiv(1);
		delete po;
	}
	catch(int ignore)
	{}

	printf("\n");

	po = new testderiv(0);
	delete po;

	printf("\n");

	try
	{
		po = new(globalallocator) testderiv(1);
		delete po;
	}
	catch(int ignore)
	{}

	printf("\n");

	po = new(globalallocator) testderiv(0);
	delete po;

	printf("\n");

	try
	{
		po = new testderiv[3];
		delete[] po;
	}
	catch(int ignore)
	{}

	printf("\n");

	try
	{
		po = new(globalallocator) testderiv[3];
		delete[] po;
	}
	catch(int ignore)
	{}

	printf("\n");

	try
	{
		poa = new testderivarray[3];
		delete[] poa;
	}
	catch(int ignore)
	{}

	printf("\n");

	try
	{
		poa = new(globalallocator) testderivarray[3];
		delete[] poa;
	}
	catch(int ignore)
	{}

	return 0;
}


/* EXPECTED STANDARD C++ OUTPUT:

test3::operator new(size_t s)
testderiv::ctor(1) EXCEPTION
test3::operator delete(void* p,size_t s)

test3::operator new(size_t s)
testderiv::ctor(0)
testderiv::dtor()
test3::operator delete(void* p,size_t s)

test3::operator new(size_t s,allocator a)
testderiv::ctor(1) EXCEPTION
test3::operator delete(void* p,size_t s,allocator a)

test3::operator new(size_t s,allocator a)
testderiv::ctor(0)
testderiv::dtor()
test3::operator delete(void* p,size_t s)

test3::operator new[](size_t s)
testderiv::ctor()
testderiv::ctor()
testderiv::ctor()
testderiv::dtor()
testderiv::dtor()
testderiv::dtor()
test3::operator delete[](void* p,size_t s)

test3::operator new[](size_t s,allocator a)
testderiv::ctor()
testderiv::ctor()
testderiv::ctor()
testderiv::dtor()
testderiv::dtor()
testderiv::dtor()
test3::operator delete[](void* p,size_t s)

test3::operator new[](size_t s)
testderivarray::ctor() EXCEPTION
test3::operator delete[](void* p,size_t s)

test3::operator new[](size_t s,allocator a)
testderivarray::ctor() EXCEPTION
test3::operator delete[](void* p,size_t s,allocator a)

*/