This is the mail archive of the mailing list for the GCC project.

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: avoiding recursive calls of calloc due to optimization

On Mon, Sep 21, 2015 at 10:20 AM, Daniel Gutson
<> wrote:
> This is derived from
> Currently, gcc provides an optimization that transforms a call to
> malloc and a call to memset into a call to calloc.
> This is fine except when it takes place within the calloc() function
> implementation itself, causing a recursive call.
> Two alternatives have been proposed: -fno-malloc-builtin and disable
> optimizations in calloc().
> I think the former is suboptimal since it affects all the code just
> because of the implementation of one function (calloc()),
> whereas the latter is suboptimal too since it disables the
> optimizations in the whole function (calloc too).
> I think of two alternatives: either make -fno-calloc-builtin to
> disable the optimization, or make the optimization aware of the
> function context where it is operating and prevent it to do the
> transformation if the function is calloc().
> Please help me to find the best alternative so we can implent it.

Did you try the optimize attribute?

Also you can try the following:

size_t ns = size*elements;
If (ns / elements != size)
  return NULL;
void *ptr = malloc (ns);
asm ("":"+r"(ptr));
memset (ptr, 0, ns);

Notice I put in a check for overflow in there.

Andrew Pinski

> Thanks,
>    Daniel.

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]