Re: libstdc++/9747: allocator<T>::deallocate(*, int ) does not call ::operator delete(size_t).

Re: libstdc++/9747: allocator<T>::deallocate(*, int ) does not call ::operator delete(size_t).

[paolo]

Synopsis: allocator<T>::deallocate(*, int ) does not call ::operator delete(size_t).

Responsible-Changed-From-To: unassigned->paolo
Responsible-Changed-By: paolo
Responsible-Changed-When: Tue Feb 18 20:21:16 2003
Responsible-Changed-Why:
    Triaged.
State-Changed-From-To: open->closed
State-Changed-By: paolo
State-Changed-When: Tue Feb 18 20:21:16 2003
State-Changed-Why:
    This is well known and intended for performance sake.
    Look at include/bits/stl_alloc.h in your src distribution:
    a new/delete allocator is available via __new_alloc and, if
    you like, you can choose it at build time by simply changing
    the __alloc typedef.
    Thanks, Paolo.

http://gcc.gnu.org/cgi-bin/gnatsweb.pl?cmd=view%20audit-trail&database=gcc&pr=9747

Re: libstdc++/9747: allocator<T>::deallocate(*, int ) does not call ::operator delete(size_t).

[axiong]

The following reply was made to PR libstdc++/9747; it has been noted by GNATS.

From: axiong@ca.ibm.com
To: gcc-gnats@gcc.gnu.org, nobody@gcc.gnu.org
Cc:  
Subject: Re: libstdc++/9747: allocator<T>::deallocate(*, int ) does not call ::operator
 delete(size_t).
Date: Tue, 18 Feb 2003 14:39:32 -0500

 => The C++ code as attached:
 /*********  hello.C ***********************************************/
 #include <memory>
 #include <stdlib.h>
 
 struct S {};
 bool global = false;
 
 template class std::allocator<S>; // explicit instantiation
 
 void operator delete(void *p) throw()
 {
         global = true;
         free(p);
 }
 
 int main(void)
 {
 
         std::allocator<S> a;
 
         S* p = a.allocate(1);
 
         a.deallocate(p,1);
 
         if (!global) return 1;
 
         return 0;
 }
 /****** End ************************************************/
 

libstdc++/9747: allocator<T>::deallocate(*, int ) does not call ::operator delete(size_t).

[axiong]

>Number:         9747
>Category:       libstdc++
>Synopsis:       allocator<T>::deallocate(*, int ) does not call ::operator delete(size_t).
>Confidential:   no
>Severity:       serious
>Priority:       medium
>Responsible:    unassigned
>State:          open
>Class:          sw-bug
>Submitter-Id:   net
>Arrival-Date:   Tue Feb 18 19:36:00 UTC 2003
>Closed-Date:
>Last-Modified:
>Originator:     Guan-Zhu (Andrew) Xiong
>Release:        gcc version 3.2
>Organization:
>Environment:
Linux Version 2.4.19
SuSE SLES 8 (ppc) - Kernel 2.4.19-ul1-ppc64-SMP (16).
>Description:
=> allocator<T>::deallocate(*, int) does not call 
   ::operator delete(size_t).

=> REF:   ISO/IEC 14882:1998, 20.4.1.1 allocator members

=> WHAT:  allocator<T>::deallocate(*, int) shall call 
          ::operator delete(size_t). 20.4.1.1;10a (2)

=> The following C++ code shows that the ::operator 
   delete(size_t) is not called.
   -> Expected Return Code from "main": 0
   -> Actual Run Return Code from "main": 1
>How-To-Repeat:
1) Compile the given code "hello.C"
   -> g++ -o hello hello.C
2) Run it
   -> hello
3) get the return code from "main()"
   - echo Return Code: $?
Then you will get: Return Code: 1. However, the expected
output sould be: Return Code: 0
>Fix:

>Release-Note:
>Audit-Trail:
>Unformatted:
----gnatsweb-attachment----
Content-Type: text/plain; name="hello.C"
Content-Disposition: inline; filename="hello.C"

#include <memory>
#include <stdlib.h>

struct S {};
bool global = false;

template class std::allocator<S>; // explicit instantiation

void operator delete(void *p) throw()
{
	global = true;
	free(p);
}

int main(void)
{

	std::allocator<S> a;

	S* p = a.allocate(1);

	a.deallocate(p,1);

	if (!global) return 1;

	return 0;
}