Will Compiler optimize malloc/free or new/delete pair into alloca

Question

Is there any mature C/C++ compiler, capable of optimizing malloc/free (or new/delete) pairs info alloca? In other words, convert from heap-based memory to stack-based (ONLY for some limited cases).

This optimization may be allowed only for pair of malloc/free when both functions are in the same function (or even in the same block of {}), and free is called every time when malloc is called. Also, lets consider that pointer to malloced memory is not saved in some global variable.

So, will GCC/LLVM+clang/Intel Compiler convert such block of code:

{
   char *carray;
   carray = malloc(100);          // or malloc(N)
   // some string-like work with carray
   free(carray);
}

into

{
    char*carray;
    carray = alloca(100);  // or if(N<const1) carray=alloca(N);else carray=malloc(N)
    // the same work
    // nothing                       // or if(N>=const1) free(carray)
}

This conversion may be not very useful for every program, but I think, there may be some special compiler option.

PS (update1) We can limit our discussion only to cases when compiler Knows that malloc and free is from libc (stdlib)

Answer 1

There's an off-shoot of LLVM called poolalloc that does this optimization. It's being maintained as part of SAFECode, and isn't in the mainline LLVM distribution.

It's described in Chris Lattner's PhD thesis and in this PLDI paper. The code is here.

Answer 2

Technically, the compilers can optimize anything as long as they follow the As-If rule.
So, optimizing heap allocations to stack allocations would be possible but do to the compiler needs to be intelligent enough to probe the usage and determine that changing the allocation to stack won't affect the observable behavior of the program.

I am not aware of any compiler which does this.