There's an unpleasant case in conditional operator we are getting
wrong.
int *p;
const void *v;
int n;
n ? p : (const void *)0
According to C standard, the type of that expression is const void *. Note
that
n ? p : (void *)0
is an entirely different story - it's int *.
What's going on here is pretty simple: there are two degenerate cases of
conditional operator: pointer vs. null pointer constant and pointer vs.
possibly qualified pointer to void. Look at these cases:
n ? p : NULL => should be the same type as p
n ? p : v => clearly const void * - pointer to void with union of
qualifiers; in this case we obviously lose any information about the type
of object being pointed to.
The tricky part comes from definition of what null pointer constant _is_.
C allows two variants - integer constant expression with value 0 (we accept
it, but warn about bad taste) and the same cast to void * (we also accept
that, of course).
Note that this is specific type - pointer to void. Without any qualifiers.
We are guaranteed that we can convert it to any pointer type and get
a pointer distinct from address of any object. So (const void *)0 is the same
thing as (const void *)(void *)0 and it is the null pointer to const void.
*HOWEVER*, it is not a null pointer constant. The standard is clear here and
frankly, it's reasonable. If you cast to anything other than void *, then
you presumably mean it and want the conversion rules as for any pointer
of that type. Think of something like
#ifdef FOO
const void *f(int n);
#else
#define f(n) ((const void *)NULL)
#endif
You don't want to have types suddenly change under you depending on FOO.
sparse is more liberal than standard C in what it accepts as null pointer
constant. It almost never matters; however, in case of conditional operator
we end up with a different type for an expression both sparse and any
C compiler will accept as valid.
I'm fixing other fun stuff in that area (e.g. we ought to take a union of
qualifiers, ought _not_ to mix different structs or unions, etc.), so
unless there are serious objections I'd rather go with standard behaviour
in that case. What will change:
int n;
int *p;
n ? p : (const void *)NULL int * => const void *
n ? p : (const void *)0 ditto
n ? p : (char *)0 int * => a warning on mixing int * with
char *
n ? p : (char *)NULL ditto
n ? p : (void *)NULL int * => void *
n ? p : (void *)0 unchanged
n ? p : NULL unchanged
Objections?
-
To unsubscribe from this list: send the line "unsubscribe linux-sparse" in
the body of a message to [EMAIL PROTECTED]
More majordomo info at http://vger.kernel.org/majordomo-info.html
