forums.ps2dev.org

[Raphael]

Hi there, I noticed some bad behaviour of the free() function with pointers that were already freed before, and using the 'safe' way of "if (!ptr) free(ptr);" doesn't work either. This will at most cases crash the program.
After looking at the sources, I noticed that the pointer given to free won't be set to NULL after being freed, so that pretty much explains the problem.

So my request is to fix that up. Here's the patch

[ryoko_no_usagi]

This is not bad behaviour of free(), it's your responsibility to keep track of your pointers. Look at how free() is declared; it can't do what you ask. You had better set all pointers to your free()'d memory to NULL yourself.

[Raphael]

Then why would "free(ptr); if (!ptr) free(ptr);" work (not crash) on any C/C++ compiler for PC? Because libc on PC sets the freed pointer to NULL after correctly doing so.
This also fits the logic, because the calling function else cannot tell if the free failed or not since there's no return value.
So my request stays.



EDIT: Sorry, i completely read over that one sentence

[raf]

[TyRaNiD]

Double freeing is a common bug in C code, it all depends on how clever the heap routines are as to whether it is likely to crash your system or not, and setting the pointer to NULL and getting free to check it might work in a specific case but it then assumes your app code knows what it is doing. Alot of systems will work okay with double freeing because the heap allocator will realise that that pointer is bogus and not do anything with it.

The real issue with free as it stands is it directly correlates the real address with the instance of that allocated memory block, therefore if you malloc then free then malloc again you could wind up with an aliased pointer somewhere which is very bad indeed, better to have a handle based system where the instance is separate from the actual location of the data. Incidently this is exactly what the psp kernel does for its memory allocations, just we then alloc a big block for our heap and use a malloc routine to partition it up. Oh well :)

[groepaz]

also

[ryoko_no_usagi]

[groepaz]

ehrm no, you didnt get what i said at all, which is: NULL is _NOT_ 0. NULL is _only_ guaranteed to be an invalid pointer, which might be binary 0x12345678 or 0xdeadbabe or whatever the implementation uses. it just happens to be 0 in many (most) implementations. this is why the NULL symbol exists in the first place.
_________________
http://www.hitmen-console.org
http://hitmen.c02.at/files/yapspd/

[PeterM]

In C++, NULL is zero (because Stroustrup says so).

I think "if (!ptr)" is a bit nicer to type, and possibly has clearer semantics ("is this a valid pointer?") than explicitly comparing to NULL.

[ryoko_no_usagi]

[BlackDiamond]

Setting the pointer to NULL inside free() would have no effects anyway. Unless you decide to change is it from "void free(void*)" to "void free(void**)" and free your pointer by calling "free(&ptr)".

[groepaz]

[PeterM]

The difference between NULL in C and C++ is quite interesting (if you're dorky like me...)

In C, NULL is defined as (void*) 0, in standard-conforming compilers, and conversions from void* to X* are implicit (which can lead to all kinds of problems) so you can do X* p = malloc(sizeof(X)) etc.

In C++, NULL is defined simply as 0, and conversions from 0 to any pointer type are valid. You would have to cast from void* to X* using a static_cast.

Pete

[Jim]

In C, any constant expression which evaluates to 0 is equivalent to NULL. It doesn't have to be (void *)0 it can be 0 or 0L or 5-5. In C++ it must be an integer.

6.3.2.3 of C99
An integer constant expression with the value 0, or such an expression cast to type void *, is called a null pointer constant.

4.10 of C++ standard
A null pointer constant is an integral constant expression rvalue of integer type that evaluates to zero.

Jim
_________________
http://www.dbfinteractive.com