spatch for trivial pointer comparison style?
I added a checkpatch entry for this.
Maybe some cocci test like this would be useful?
@@
type t;
t *p;
@@
- p == NULL
+ !p
@@
type t;
t *p;
@@
- p != NULL
+ p
@@
type t;
t *p;
@@
- NULL == p
+ !p
@@
type t;
t *p;
@@
- NULL != p
+ p
Quoted 28 lines · Joe Perches
I added a checkpatch entry for this.
Maybe some cocci test like this would be useful?@@
type t;
t *p;
@@(quoted diff) +1
-1- p == NULL + !p@@
type t;
t *p;
@@(quoted diff) +1
-1- p != NULL + p@@
type t;
t *p;
@@(quoted diff) +1
-1- NULL == p + !p@@
type t;
t *p;
@@
Review
Quoted 2 lines
(quoted diff) +1
-1- NULL != p + p
This was discussed many years ago. I don't think that the change is desirable in all cases. There are functions like kmalloc where NULL means failure and !p seems like the reasonable choice. But there maybe other cases where NULL is somehow a meaningful value.
Here is a link to the part of the discussion:
https://lkml.org/lkml/2007/7/27/103
julia
Quoted 38 lines · Julia Lawall
Quoted 28 lines · Joe Perches
I added a checkpatch entry for this.
Maybe some cocci test like this would be useful?@@
type t;
t *p;
@@(quoted diff) +1
-1- p == NULL + !p@@
type t;
t *p;
@@(quoted diff) +1
-1- p != NULL + p@@
type t;
t *p;
@@(quoted diff) +1
-1- NULL == p + !p@@
type t;
t *p;
@@Review
Quoted 2 lines
(quoted diff) +1
-1- NULL != p + pThis was discussed many years ago. I don't think that the change is desirable in all cases. There are functions like kmalloc where NULL means failure and !p seems like the reasonable choice. But there maybe other cases where NULL is somehow a meaningful value.
Quoted 3 lines
Here is a link to the part of the discussion:
Yes, I agree with some of the things Al Viro said
there, but isn't 'type t; t *p;' a subset of
"expression *e"?
Quoted 39 lines · Joe Perches
Quoted 38 lines · Julia Lawall
Quoted 28 lines · Joe Perches
I added a checkpatch entry for this.
Maybe some cocci test like this would be useful?@@
type t;
t *p;
@@(quoted diff) +1
-1- p == NULL + !p@@
type t;
t *p;
@@(quoted diff) +1
-1- p != NULL + p@@
type t;
t *p;
@@(quoted diff) +1
-1- NULL == p + !p@@
type t;
t *p;
@@Review
Quoted 2 lines
(quoted diff) +1
-1- NULL != p + pThis was discussed many years ago. I don't think that the change is desirable in all cases. There are functions like kmalloc where NULL means failure and !p seems like the reasonable choice. But there maybe other cases where NULL is somehow a meaningful value.
Quoted 7 lines
Quoted 3 lines
Here is a link to the part of the discussion:
Yes, I agree with some of the things Al Viro said
there, but isn't 'type t; t *p;' a subset of
"expression *e"?
No. How would you expect it to be different. type t means that the type is known. expression *e means that there is a * in the type. But there is no way to know that there is a * in the type without knowing the full type.
Maybe something like
e = f(...);
...
if (e == NULL) S1 else S2
would be acceptable? But I was thinking that for some functions NULL might be considered to be a meaningful result, rather than a sign of failure.
The following semantic patch gives almost 3000 results:
@disable is_null@
expression e;
statement S1,S2;
@@
e = \(kmalloc\|kzalloc\|kcalloc\|devm_kmalloc\|devm_kzalloc\)(...); ... when != e
if (<+...
- e == NULL
+ !e
...+>) S1 else S2
julia
Quoted 1 line · Julia Lawall
On Thu, 13 Nov 2014, Joe Perches wrote:
[]
Quoted 5 lines
Quoted 3 lines
Yes, I agree with some of the things Al Viro said
there, but isn't 'type t; t *p;' a subset of
"expression *e"?No. How would you expect it to be different.
[]
Quoted 2 lines
type t means that the type
is known. expression *e means that there is a * in the type.
I had thought "expression *" could be r-value and
"type t; t *p;" could be l-value.
But then I don't find (or maybe don't parse too well) the coccinelle documentation that specifies these type relationships.
cheers, Joe
Quoted 10 lines · Joe Perches
Quoted 1 line · Julia Lawall
On Thu, 13 Nov 2014, Joe Perches wrote:
[]
Quoted 5 lines
Quoted 3 lines
Yes, I agree with some of the things Al Viro said
there, but isn't 'type t; t *p;' a subset of
"expression *e"?No. How would you expect it to be different.
[]
No. [] and * are treated completely differently.
Quoted 5 lines
Quoted 2 lines
type t means that the type
is known. expression *e means that there is a * in the type.I had thought "expression *" could be r-value and
"type t; t *p;" could be l-value.
No, you made that one up :) As we considered that it would be common to want to specify the type of an expression, we thought it would be tiresome to have to put eg expression int x. So you can just say int x.
The downside is that people write
identifer x;
and then don't understand the error message, because any misspelled metavariable kind is considered to be a type name.
julia
Quoted 8 lines
But then I don't find (or maybe don't parse too well) the coccinelle documentation that specifies these type relationships.
cheers, Joe
Quoted 4 lines
I don't think that the change is desirable in all cases. There are functions like kmalloc where NULL means failure and !p seems like the reasonable choice. But there maybe other cases where NULL is somehow a meaningful value.
How do you think about to adjust checks for null pointers not only in Linux source files but also in other applications? Are there any more software design challenges to consider with the definition of the preprocessor symbol "NULL"?
Regards,
Markus
Quoted 9 lines · SF Markus Elfring
Quoted 4 lines
I don't think that the change is desirable in all cases. There are functions like kmalloc where NULL means failure and !p seems like the reasonable choice. But there maybe other cases where NULL is somehow a meaningful value.
How do you think about to adjust checks for null pointers not only in Linux source files but also in other applications? Are there any more software design challenges to consider with the definition of the preprocessor symbol "NULL"?
Other applications may have other preferences.
julia