What sense do these clobbered variable warnings make?

Question

I have a function like this:

#include <setjmp.h>
jmp_buf buf;
void func2(int g);
extern int some_global;
void func(int x)
{
    if (setjmp(buf))
        return;
    if (some_global)
        x += 5;
    func2(x);
}

GCC (gcc (Debian 4.4.5-8) 4.4.5) gives a warning:

test.c: In function ‘func’:
test.c:5: warning: argument ‘x’ might be clobbered by ‘longjmp’ or ‘vfork’ [-Wclobbered]

Why???? I mean, obviously I don't care if x is clobbered or not, because it can't possibly be used after setjmp returns. Even the compiler should be aware of something so blindingly obvious, given that it has some kind of special knowledge of setjmp.

My main interest is finding bugs in a code base that I inherited, so, "use this coding style instead" is not advice I am looking for. However, there are a number of bizarre twists here. For example, if x is a local variable instead of a parameter, then GCC does not complain. Also, GCC will not complain without the if (some_global) line. Nice. Something is messing up GCC's flow analysis, or maybe GCC knows something I don't.

So,

• Is there an easy way to suppress this warning for this function, just the same way you can cast unused parameters to (void)?

• Or do I just suppress the warning project-wide?

• Or am I missing something?

Update: Let me share with you a slightly different version that does not generate a warning:

#include <setjmp.h>
jmp_buf buf;
void func2(int g);
extern int some_global;
void func(int y)
{
    int x = y;
    if (setjmp(buf))
        return;
    if (some_global)
        x += 5;
    func2(x);
}

Answer 1

After scraping the net a bit, and re-reading the GCC docs, I came across this:

Function Attributes:

returns_twice

The returns_twice attribute tells the compiler that a function may return more than one time. The compiler will ensure that all registers are dead before calling such a function and will emit a warning about the variables that may be clobbered after the second return from the function. Examples of such functions are setjmp and vfork. The longjmp-like counterpart of such function, if any, might need to be marked with the noreturn attribute.

So it appears that GCC does not have any "special knowledge" of setjmp, it just insinuates that it does. All it knows is that setjmp returns twice, not that it always returns 0 the first time and nonzero afterwards. Gosh, that would have been nice.

Answer 2

From man longjmp:

The values of automatic variables are unspecified after a call to longjmp() if they meet all the following criteria:

   ·  they are local to the function that made the corresponding setjmp(3)
      call;

   ·  their  values  are  changed  between  the  calls  to  setjmp(3)  and
      longjmp(); and

   ·  they are not declared as volatile.

As it happens, your x variable in the first example meets the criteria:

• It is local to the function, as function parameters are just like local automatic variables.
• Its value may be changed just after setjmp if some_global is true.
• It is not volatile.

So its value may be unspecified (clobbered).

About why the second version does not emit the warning... no idea.