How can I catch programmer error with malloc?

Question

I'm trying to find a way to catch a programmer error in the argument for malloc in an automated code tester.

For example:

struct Pepe* p = malloc(sizeof(struct Pepe*));

This, of course, compiles without any problems. The thing is that struct Pepe has another struct of the same size inside it, therefore no problem appears during execution (nor with free).

The correct code should be:

struct Pepe* p = malloc(sizeof(struct Pepe));

Can we get a warning or something to catch this problem?

I tried -Wall and -Wextra but there was no warning.

valgrind will catch the subsequent write outside of allocated memory (if the structure happens to be larger than a pointer), among other subtle problems such as memory leaks — ikegami
– ikegami, Commented Feb 19, 2020 at 15:08
@leandrom You can use the following declaration struct Pepe* p = malloc(sizeof(*p)); to prevent the error. — Vlad from Moscow
– Vlad from Moscow, Commented Feb 19, 2020 at 15:08
A common ideom is to use struct foo *x = malloc (sizeof *x);; This will not warn you, but avoids the error altogether. — Ctx
– Ctx, Commented Feb 19, 2020 at 15:08
@ikegami struct happens to be EXACTLY same size as the pointer, no valgrind errors And yes, I know how to correctly declare, it's for doing automatic tests of code WITHOUT reading them ;) — leandrom
– leandrom, Commented Feb 19, 2020 at 15:10
I'd look at a static analysis package such as PC-lint . See gimpel.com/checks.html — Richard Chambers
– Richard Chambers, Commented Feb 19, 2020 at 15:50

Ctx · Accepted Answer · 2020-02-19 15:35:58Z

4

You can use the clang static analyzer for that. Consider the following (buggy) code:

#include <stdlib.h>

struct foo {
    int a,b;
};

int main (void) {
    struct foo *bar = malloc(sizeof(struct foo *));

    free(bar);
}

Now you can invoke the clang static analyzer:

$ scan-build clang src.c

and get the following warning:

src.c:10:20: warning: Result of 'malloc' is converted to a pointer of type 'struct foo', which is incompatible with sizeof operand type 'struct foo *'
        struct foo *bar = malloc(sizeof(struct foo *));
        ~~~~~~~~~~~~      ^~~~~~ ~~~~~~~~~~~~~~~~~~~~
1 warning generated.
scan-build: 1 bug found.

The clang static analyzer is bundled with many linux distributions in the package clang-tools. The homepage can be found here

answered Feb 19, 2020 at 15:35

Ctx

18.6k24 gold badges38 silver badges56 bronze badges

Sign up to request clarification or add additional context in comments.

1 Comment

S.S. Anne Over a year ago

This is good. I hadn't even thought about scan-build (although it seems to invoke GCC instead of Clang).

S.S. Anne · Accepted Answer · 2020-02-19 15:28:43Z

2

You can't really resolve the warning this way if you're naming the types.

An easier solution would be to use the variable to find its size. This also alleviates any possible issues with the type of the variable changing:

struct Pepe *p = malloc(sizeof(*p));

Now if I make p an int *...

int *p = malloc(sizeof(*p));

it still works!

If you want to do it at execution time, you can build your code with the -fsanitize=address flag (assuming GCC or Clang) or you can use the Valgrind tool.

edited Feb 19, 2020 at 15:28

answered Feb 19, 2020 at 15:13

S.S. Anne

15.7k8 gold badges42 silver badges82 bronze badges

4 Comments

leandrom Over a year ago

Thanks for the answer, btw you changed pretty much my post.... I tried to make clear that the idea is to TEST automatically other's people code without reading it (as i know how to use malloc correctly). So it looks like a typo but in reality they are making the mistake there. You see? So not really looking for a workaround but a way to catch it "compiling/execution" time if possible :)

S.S. Anne Over a year ago

@leandrom I made another edit that says "programmer error", but even so there's no way to do it without changing style or a memory checker like Valgrind or -fsanitize=address.

chux Over a year ago

Aside: () not required after operator sizeof of an object. Could simplify to p = malloc(sizeof *p);

S.S. Anne Over a year ago

@chux-ReinstateMonica No. I like sizeof().

klutt · Accepted Answer · 2020-02-19 15:15:00Z

1

Don't know of any warning or so, but you can use a macro to get around the problem

#define ALLOC(p, n)  ((p) = malloc((n) * sizeof *(p)))

Use it like this:

struct Pepe *p;
ALLOC(p, 1);

edited Feb 19, 2020 at 15:15

answered Feb 19, 2020 at 15:12

klutt

31.7k19 gold badges65 silver badges114 bronze badges

1 Comment

S.S. Anne Over a year ago

A macro!? Are you sure about this? What about maintainability?

Serge · Accepted Answer · 2020-02-19 15:43:01Z

The issue is that both statements are very much correct with 'c' and there is no way of catching it in the language. The malloc is just a function which the program calls in order to allocate some amount of memory. Compiler does not know anything about it, does not check and does not care. The only way around it is to use a good programming style, as mentioned in other replies of use a different programming language with build in memory management, e.g. java, c#, ...

However, there is a bunch of free and commercial static and dynamic linting tools (e.g., purify, cppcheck, clang static analyzer, ...) available for 'c' and 'c++'. Maybe you need to investigate them and use as a part of the build methodology. They should be able to catch those issues. And, as it was mentioned, valgrind is a free dynamic checker.

Collectives™ on Stack Overflow

How can I catch programmer error with malloc?

4 Answers 4

1 Comment

4 Comments

1 Comment

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

1 Comment

4 Comments

1 Comment

Comments

Your Answer

Sign up or log in

Post as a guest

Related