coccinelle: semantic patch to check for inappropriate do_div() calls
Subsystems (2)
PATCH 1/1 coccinelle: semantic patch to check for inappropriate do_div() calls
do_div() does a 64-by-32 division.
When the divisor is unsigned long, u64, or s64,do_div() truncates it to 32 bits, this means it
can test non-zero and be truncated to zero for division.
This semantic patch is inspired by Mateusz Guzik's patch:
commit b0ab99e7736a ("sched: Fix possible divide by zero in avg_atom() calculation")
--- scripts/coccinelle/misc/do_div.cocci | 66 ++++++++++++++++++++++++++++++++++++ 1 file changed, 66 insertions(+) create mode 100644 scripts/coccinelle/misc/do_div.cocci
scripts/coccinelle/misc/do_div.cocci new file +66 -0
@@ -0,0 +1,66 @@ +// SPDX-License-Identifier: GPL-2.0-only +/// do_div() does a 64-by-32 division. +/// When the divisor is unsigned long, u64, or s64, +/// do_div() truncates it to 32 bits, this means it +/// can test non-zero and be truncated to zero for division. +/// +//# This makes an effort to find those inappropriate do_div () calls. +// +// Confidence: Moderate +// Copyright: (C) 2020 Wen Yang, Alibaba. +// Comments: +// Options: --no-includes --include-headers + +virtual context +virtual org +virtual report + +@depends on context@ +expression f; +long l; +unsigned long ul; +u64 ul64; +s64 sl64; + +@@ +( +* do_div(f, l); +| +* do_div(f, ul); +| +* do_div(f, ul64); +| +* do_div(f, sl64); +) + +@r depends on (org || report)@ +expression f; +long l; +unsigned long ul; +position p; +u64 ul64; +s64 sl64; +@@ +( +do_div@p(f, l); +| +do_div@p(f, ul); +| +do_div@p(f, ul64); +| +do_div@p(f, sl64); +) + +@script:python depends on org@ +p << r.p; +@@ + +msg="WARNING: WARNING: do_div() does a 64-by-32 division, which may truncation the divisor to 32-bit" +coccilib.org.print_todo(p[0], msg) + +@script:python depends on report@ +p << r.p; +@@ + +msg="WARNING: WARNING: do_div() does a 64-by-32 division, which may truncation the divisor to 32-bit" +coccilib.report.print_report(p[0], msg)
Signature · 1 line
1.8.3.1
Julia Lawall
maintainerQuoted 85 lines · Wen Yang
do_div()does a 64-by-32 division.
When the divisor is unsigned long, u64, or s64,do_div()truncates it to 32 bits, this means it
can test non-zero and be truncated to zero for division.
This semantic patch is inspired by Mateusz Guzik's patch:
commitb0ab99e7736a("sched: Fix possible divide by zero inavg_atom()calculation")Signed-off-by Wen Yang <[email protected]>Cc Julia Lawall <[email protected]>Cc Gilles Muller <[email protected]>Cc Nicolas Palix <[email protected]>Cc Michal Marek <[email protected]>Cc Matthias Maennich <[email protected]>Cc Greg Kroah-Hartman <[email protected]>Cc Masahiro Yamada <[email protected]>Cc Thomas Gleixner <[email protected]>--- scripts/coccinelle/misc/do_div.cocci | 66 ++++++++++++++++++++++++++++++++++++ 1 file changed, 66 insertions(+) create mode 100644 scripts/coccinelle/misc/do_div.cocciscripts/coccinelle/misc/do_div.cocci new file +56
-0@@ -0,0 +1,66 @@ +// SPDX-License-Identifier: GPL-2.0-only +/// do_div() does a 64-by-32 division. +/// When the divisor is unsigned long, u64, or s64, +/// do_div() truncates it to 32 bits, this means it +/// can test non-zero and be truncated to zero for division. +/// +//# This makes an effort to find those inappropriate do_div () calls. +// +// Confidence: Moderate +// Copyright: (C) 2020 Wen Yang, Alibaba. +// Comments: +// Options: --no-includes --include-headers + +virtual context +virtual org +virtual report + +@depends on context@ +expression f; +long l; +unsigned long ul; +u64 ul64; +s64 sl64; + +@@ +( +* do_div(f, l); +| +* do_div(f, ul); +| +* do_div(f, ul64); +| +* do_div(f, sl64); +) + +@r depends on (org || report)@ +expression f; +long l; +unsigned long ul; +position p; +u64 ul64; +s64 sl64; +@@ +( +do_div@p(f, l); +| +do_div@p(f, ul); +| +do_div@p(f, ul64); +| +do_div@p(f, sl64); +) + +@script:python depends on org@ +p << r.p; +@@
scripts/coccinelle/misc/do_div.cocci line 66
Quoted 10 lines
scripts/coccinelle/misc/do_div.cocci new file +10
-0+ +msg="WARNING: WARNING: do_div() does a 64-by-32 division, which may truncation the divisor to 32-bit" +coccilib.org.print_todo(p[0], msg) + +@script:python depends on report@ +p << r.p; +@@ + +msg="WARNING: WARNING: do_div() does a 64-by-32 division, which may truncation the divisor to 32-bit" +coccilib.report.print_report(p[0], msg)
A few small issues: You have WARNING: twice in each case, and truncation should be truncate.
Is there any generic strategy for fixing these issues?
julia
_______________________________________________
Cocci mailing list
[email protected]
https://systeme.lip6.fr/mailman/listinfo/cocci
Quoted 92 lines · Julia Lawall
Quoted 90 lines · Wen Yang
do_div()does a 64-by-32 division.
When the divisor is unsigned long, u64, or s64,do_div()truncates it to 32 bits, this means it
can test non-zero and be truncated to zero for division.
This semantic patch is inspired by Mateusz Guzik's patch:
commitb0ab99e7736a("sched: Fix possible divide by zero inavg_atom()calculation")Signed-off-by Wen Yang <[email protected]>Cc Julia Lawall <[email protected]>Cc Gilles Muller <[email protected]>Cc Nicolas Palix <[email protected]>Cc Michal Marek <[email protected]>Cc Matthias Maennich <[email protected]>Cc Greg Kroah-Hartman <[email protected]>Cc Masahiro Yamada <[email protected]>Cc Thomas Gleixner <[email protected]>--- scripts/coccinelle/misc/do_div.cocci | 66 ++++++++++++++++++++++++++++++++++++ 1 file changed, 66 insertions(+)create mode 100644
scripts/coccinelle/misc/do_div.cocciscripts/coccinelle/misc/do_div.cocci new file +61
-0@@ -0,0 +1,66 @@ +// SPDX-License-Identifier: GPL-2.0-only +/// do_div() does a 64-by-32 division. +/// When the divisor is unsigned long, u64, or s64, +/// do_div() truncates it to 32 bits, this means it +/// can test non-zero and be truncated to zero for division. +/// +//# This makes an effort to find those inappropriate do_div () calls. +// +// Confidence: Moderate +// Copyright: (C) 2020 Wen Yang, Alibaba. +// Comments: +// Options: --no-includes --include-headers + +virtual context +virtual org +virtual report + +@depends on context@ +expression f; +long l; +unsigned long ul; +u64 ul64; +s64 sl64; + +@@ +( +* do_div(f, l); +| +* do_div(f, ul); +| +* do_div(f, ul64); +| +* do_div(f, sl64); +) + +@r depends on (org || report)@ +expression f; +long l; +unsigned long ul; +position p; +u64 ul64; +s64 sl64; +@@ +( +do_div@p(f, l); +| +do_div@p(f, ul); +| +do_div@p(f, ul64); +| +do_div@p(f, sl64); +) + +@script:python depends on org@ +p << r.p; +@@ + +msg="WARNING: WARNING: do_div() does a 64-by-32 division, which may truncation the divisor to 32-bit" +coccilib.org.print_todo(p[0], msg) + +@script:python depends on report@
Quoted 9 lines
scripts/coccinelle/misc/do_div.cocci line 66
Quoted 5 lines
scripts/coccinelle/misc/do_div.cocci new file +5
-0+p << r.p; +@@ + +msg="WARNING: WARNING: do_div() does a 64-by-32 division, which may truncation the divisor to 32-bit" +coccilib.report.print_report(p[0], msg)A few small issues: You have WARNING: twice in each case, and truncation should be truncate.
Thanks for your comments, we will fix it soon.
Quoted 2 lines
Is there any generic strategy for fixing these issues?
We have done some experiments, such as:
https://lkml.org/lkml/2020/1/2/1354
- avg = rec->time;
- do_div(avg, rec->counter);
+ avg = div64_ul(rec->time, rec->counter);
--> Function replacement was performed here,
and simple code cleanup was also performed.
- do_div(stddev, rec->counter * (rec->counter - 1) * 1000);
+ stddev = div64_ul(stddev,
+ rec->counter * (rec->counter - 1) * 1000);
--> Only the function replacement is performed here (because the variable ‘stddev’ corresponds to a more complicated equation, cleaning it will reduce readability).
In addition, there are some codes that do not need to be modified:
https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git/tree/drivers/net/can/dev.c#n263
So we just print a warning.
As for how to fix it, we need to analyze the code carefully.
Signature · 2 lines
Best Wishes, Wen
Julia Lawall
maintainerQuoted 110 lines · Wen Yang
Quoted 97 lines · Julia Lawall
Quoted 95 lines · Wen Yang
do_div()does a 64-by-32 division.
When the divisor is unsigned long, u64, or s64,do_div()truncates it to 32 bits, this means it
can test non-zero and be truncated to zero for division. This semantic patch is inspired by Mateusz Guzik's patch:
commitb0ab99e7736a("sched: Fix possible divide by zero inavg_atom()calculation")Signed-off-by Wen Yang <[email protected]>Cc Julia Lawall <[email protected]>Cc Gilles Muller <[email protected]>Cc Nicolas Palix <[email protected]>Cc Michal Marek <[email protected]>Cc Matthias Maennich <[email protected]>Cc Greg Kroah-Hartman <[email protected]>Cc Masahiro Yamada <[email protected]>Cc Thomas Gleixner <[email protected]>--- scripts/coccinelle/misc/do_div.cocci | 66 ++++++++++++++++++++++++++++++++++++ 1 file changed, 66 insertions(+)create mode 100644
scripts/coccinelle/misc/do_div.cocciscripts/coccinelle/misc/do_div.cocci new file +58
-0@@ -0,0 +1,66 @@ +// SPDX-License-Identifier: GPL-2.0-only +/// do_div() does a 64-by-32 division. +/// When the divisor is unsigned long, u64, or s64, +/// do_div() truncates it to 32 bits, this means it +/// can test non-zero and be truncated to zero for division. +/// +//# This makes an effort to find those inappropriate do_div () calls. +// +// Confidence: Moderate +// Copyright: (C) 2020 Wen Yang, Alibaba. +// Comments: +// Options: --no-includes --include-headers + +virtual context +virtual org +virtual report + +@depends on context@ +expression f; +long l; +unsigned long ul; +u64 ul64; +s64 sl64; + +@@ +( +* do_div(f, l); +| +* do_div(f, ul); +| +* do_div(f, ul64); +| +* do_div(f, sl64); +) + +@r depends on (org || report)@ +expression f; +long l; +unsigned long ul; +position p; +u64 ul64; +s64 sl64; +@@ +( +do_div@p(f, l); +| +do_div@p(f, ul); +| +do_div@p(f, ul64); +| +do_div@p(f, sl64); +) + +@script:python depends on org@ +p << r.p; +@@ + +msg="WARNING: WARNING: do_div() does a 64-by-32 division, which maytruncation the divisor to 32-bit"
scripts/coccinelle/misc/do_div.cocci new file +4
-0+coccilib.org.print_todo(p[0], msg) + +@script:python depends on report@ +p << r.p;Quoted 9 lines
Quoted 5 lines
+@@
scripts/coccinelle/misc/do_div.cocci new file +2
-0+ +msg="WARNING: WARNING: do_div() does a 64-by-32 division, which maytruncation the divisor to 32-bit" +coccilib.report.print_report(p[0], msg)
A few small issues: You have WARNING: twice in each case, and truncation should be truncate.
Quoted 7 lines
Thanks for your comments, we will fix it soon.
Quoted 2 lines
Is there any generic strategy for fixing these issues?
We have done some experiments, such as:
https://lkml.org/lkml/2020/1/2/1354
Thanks. Actually, I would appreciate knowing about such experiments when the semantic patch is submitted, since eg in this case I am not really an expert in this issue.
Quoted 14 lines
(quoted diff) +3
-5- avg = rec->time; - do_div(avg, rec->counter); + avg = div64_ul(rec->time, rec->counter); --> Function replacement was performed here, and simple code cleanup was also performed. - do_div(stddev, rec->counter * (rec->counter - 1) * 1000); + stddev = div64_ul(stddev, + rec->counter * (rec->counter - 1) * 1000); --> Only the function replacement is performed here (because the variable
Quoted 2 lines
‘stddev’ corresponds to a more complicated equation, cleaning it will reduce readability).
Would it be reasonable to extend the warning to say "consider using div64_ul instead"? Or do you think it is obvious to everyone?
Quoted 2 lines
In addition, there are some codes that do not need to be modified:
https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git/tree/drivers/net/can/dev.c#n263
Would it be worth having a special case for constants and checking whether the value is obviously safe and no warning is needed?
thanks,
julia
Quoted 9 lines
So we just print a warning.
As for how to fix it, we need to analyze the code carefully.--
Best Wishes,
Wen
Quoted 137 lines · Julia Lawall
Quoted 110 lines · Wen Yang
Quoted 97 lines · Julia Lawall
Quoted 95 lines · Wen Yang
do_div()does a 64-by-32 division.
When the divisor is unsigned long, u64, or s64,do_div()truncates it to 32 bits, this means it
can test non-zero and be truncated to zero for division. This semantic patch is inspired by Mateusz Guzik's patch:
commitb0ab99e7736a("sched: Fix possible divide by zero inavg_atom()calculation")Signed-off-by Wen Yang <[email protected]>Cc Julia Lawall <[email protected]>Cc Gilles Muller <[email protected]>Cc Nicolas Palix <[email protected]>Cc Michal Marek <[email protected]>Cc Matthias Maennich <[email protected]>Cc Greg Kroah-Hartman <[email protected]>Cc Masahiro Yamada <[email protected]>Cc Thomas Gleixner <[email protected]>--- scripts/coccinelle/misc/do_div.cocci | 66 ++++++++++++++++++++++++++++++++++++ 1 file changed, 66 insertions(+)create mode 100644
scripts/coccinelle/misc/do_div.cocciscripts/coccinelle/misc/do_div.cocci new file +58
-0@@ -0,0 +1,66 @@ +// SPDX-License-Identifier: GPL-2.0-only +/// do_div() does a 64-by-32 division. +/// When the divisor is unsigned long, u64, or s64, +/// do_div() truncates it to 32 bits, this means it +/// can test non-zero and be truncated to zero for division. +/// +//# This makes an effort to find those inappropriate do_div () calls. +// +// Confidence: Moderate +// Copyright: (C) 2020 Wen Yang, Alibaba. +// Comments: +// Options: --no-includes --include-headers + +virtual context +virtual org +virtual report + +@depends on context@ +expression f; +long l; +unsigned long ul; +u64 ul64; +s64 sl64; + +@@ +( +* do_div(f, l); +| +* do_div(f, ul); +| +* do_div(f, ul64); +| +* do_div(f, sl64); +) + +@r depends on (org || report)@ +expression f; +long l; +unsigned long ul; +position p; +u64 ul64; +s64 sl64; +@@ +( +do_div@p(f, l); +| +do_div@p(f, ul); +| +do_div@p(f, ul64); +| +do_div@p(f, sl64); +) + +@script:python depends on org@ +p << r.p; +@@ + +msg="WARNING: WARNING: do_div() does a 64-by-32 division, which maytruncation the divisor to 32-bit"
scripts/coccinelle/misc/do_div.cocci new file +4
-0+coccilib.org.print_todo(p[0], msg) + +@script:python depends on report@ +p << r.p;Quoted 9 lines
Quoted 5 lines
+@@
scripts/coccinelle/misc/do_div.cocci new file +2
-0+ +msg="WARNING: WARNING: do_div() does a 64-by-32 division, which maytruncation the divisor to 32-bit" +coccilib.report.print_report(p[0], msg)
A few small issues: You have WARNING: twice in each case, and truncation should be truncate.
Quoted 7 lines
Thanks for your comments, we will fix it soon.
Quoted 2 lines
Is there any generic strategy for fixing these issues?
We have done some experiments, such as:
https://lkml.org/lkml/2020/1/2/1354Thanks. Actually, I would appreciate knowing about such experiments when the semantic patch is submitted, since eg in this case I am not really an expert in this issue.
Quoted 13 lines
(quoted diff) +3
-4- avg = rec->time; - do_div(avg, rec->counter); + avg = div64_ul(rec->time, rec->counter); --> Function replacement was performed here, and simple code cleanup was also performed. - do_div(stddev, rec->counter * (rec->counter - 1) * 1000); + stddev = div64_ul(stddev, + rec->counter * (rec->counter - 1) * 1000);
Quoted 7 lines
Quoted 3 lines
--> Only the function replacement is performed here (because the variable ‘stddev’ corresponds to a more complicated equation, cleaning it will reduce readability).
Would it be reasonable to extend the warning to say "consider using
div64_ulinstead"? Or do you think it is obvious to everyone?
Thank you for your comments.
We plan to modify it as follows:
msg="WARNING: do_div() does a 64-by-32 division, please consider using div64_ul, div64_long, div64_u64 or div64_s64 instead."
Quoted 6 lines
Quoted 2 lines
In addition, there are some codes that do not need to be modified:
https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git/tree/drivers/net/can/dev.c#n263Would it be worth having a special case for constants and checking whether the value is obviously safe and no warning is needed?
Thanks.
This is very valuable in reducing false positives, and we'll try to implement it.
--
Best Wishes,
Wen
Quoted 10 lines
Quoted 9 lines
So we just print a warning.
As for how to fix it, we need to analyze the code carefully.--
Best Wishes,
Wen
Julia Lawall
maintainer--- Please note the new email address ---
Quoted 149 lines · Wen Yang
Quoted 137 lines · Julia Lawall
Quoted 110 lines · Wen Yang
Quoted 97 lines · Julia Lawall
Quoted 95 lines · Wen Yang
do_div()does a 64-by-32 division.
When the divisor is unsigned long, u64, or s64,do_div()truncates it to 32 bits, this means it
can test non-zero and be truncated to zero for division. This semantic patch is inspired by Mateusz Guzik's patch:
commitb0ab99e7736a("sched: Fix possible divide by zero inavg_atom()calculation")Signed-off-by Wen Yang <[email protected]>Cc Julia Lawall <[email protected]>Cc Gilles Muller <[email protected]>Cc Nicolas Palix <[email protected]>Cc Michal Marek <[email protected]>Cc Matthias Maennich <[email protected]>Cc Greg Kroah-Hartman <[email protected]>Cc Masahiro Yamada <[email protected]>Cc Thomas Gleixner <[email protected]>--- scripts/coccinelle/misc/do_div.cocci | 66 ++++++++++++++++++++++++++++++++++++ 1 file changed, 66 insertions(+)create mode 100644
scripts/coccinelle/misc/do_div.cocciscripts/coccinelle/misc/do_div.cocci new file +58
-0@@ -0,0 +1,66 @@ +// SPDX-License-Identifier: GPL-2.0-only +/// do_div() does a 64-by-32 division. +/// When the divisor is unsigned long, u64, or s64, +/// do_div() truncates it to 32 bits, this means it +/// can test non-zero and be truncated to zero for division. +/// +//# This makes an effort to find those inappropriate do_div () calls. +// +// Confidence: Moderate +// Copyright: (C) 2020 Wen Yang, Alibaba. +// Comments: +// Options: --no-includes --include-headers + +virtual context +virtual org +virtual report + +@depends on context@ +expression f; +long l; +unsigned long ul; +u64 ul64; +s64 sl64; + +@@ +( +* do_div(f, l); +| +* do_div(f, ul); +| +* do_div(f, ul64); +| +* do_div(f, sl64); +) + +@r depends on (org || report)@ +expression f; +long l; +unsigned long ul; +position p; +u64 ul64; +s64 sl64; +@@ +( +do_div@p(f, l); +| +do_div@p(f, ul); +| +do_div@p(f, ul64); +| +do_div@p(f, sl64); +) + +@script:python depends on org@ +p << r.p; +@@ + +msg="WARNING: WARNING: do_div() does a 64-by-32 division, which maytruncation the divisor to 32-bit"
scripts/coccinelle/misc/do_div.cocci new file +4
-0+coccilib.org.print_todo(p[0], msg) + +@script:python depends on report@ +p << r.p;Quoted 9 lines
Quoted 5 lines
+@@
scripts/coccinelle/misc/do_div.cocci new file +2
-0+ +msg="WARNING: WARNING: do_div() does a 64-by-32 division, which maytruncation the divisor to 32-bit" +coccilib.report.print_report(p[0], msg)
A few small issues: You have WARNING: twice in each case, and truncation should be truncate.
Quoted 7 lines
Thanks for your comments, we will fix it soon.
Quoted 2 lines
Is there any generic strategy for fixing these issues?
We have done some experiments, such as:
https://lkml.org/lkml/2020/1/2/1354Thanks. Actually, I would appreciate knowing about such experiments when the semantic patch is submitted, since eg in this case I am not really an expert in this issue.
Quoted 13 lines
(quoted diff) +3
-4- avg = rec->time; - do_div(avg, rec->counter); + avg = div64_ul(rec->time, rec->counter); --> Function replacement was performed here, and simple code cleanup was also performed. - do_div(stddev, rec->counter * (rec->counter - 1) * 1000); + stddev = div64_ul(stddev, + rec->counter * (rec->counter - 1) * 1000);Quoted 8 lines
Quoted 4 lines
--> Only the function replacement is performed here (because the variable ‘stddev’ corresponds to a more complicated equation, cleaning it will reduce
readability).Would it be reasonable to extend the warning to say "consider using
div64_ulinstead"? Or do you think it is obvious to everyone?
Quoted 4 lines
Thank you for your comments.
We plan to modify it as follows:
msg="WARNING:do_div()does a 64-by-32 division, please consider usingdiv64_ul,div64_long,div64_u64ordiv64_s64instead."
This message seems helpful, thanks.
julia
Quoted 26 lines
Quoted 7 lines
Quoted 3 lines
In addition, there are some codes that do not need to be modified:
https://git.kernel.org/pub/scm/linux/kernel/git/next/linux-next.git/tree/drivers/net/can/dev.c#n263Would it be worth having a special case for constants and checking whether the value is obviously safe and no warning is needed?
Thanks.
This is very valuable in reducing false positives, and we'll try to implement it.--
Best Wishes,
WenQuoted 10 lines
Quoted 9 lines
So we just print a warning.
As for how to fix it, we need to analyze the code carefully.--
Best Wishes,
Wen
Julia Lawall
maintainer--- Please note the new email address ---
Quoted 4 lines · Wen Yang
do_div()does a 64-by-32 division.
When the divisor is unsigned long, u64, or s64,do_div()truncates it to 32 bits, this means it can test non-zero and be truncated to zero for division.
Would it be worth having a specific warning message for the long/unsigned long case? If the target architecture has 32 bit longs then the warning can be immediately ignored.
julia
Quoted 95 lines
This semantic patch is inspired by Mateusz Guzik's patch:
commitb0ab99e7736a("sched: Fix possible divide by zero inavg_atom()calculation")Signed-off-by Wen Yang <[email protected]>Cc Julia Lawall <[email protected]>Cc Gilles Muller <[email protected]>Cc Nicolas Palix <[email protected]>Cc Michal Marek <[email protected]>Cc Matthias Maennich <[email protected]>Cc Greg Kroah-Hartman <[email protected]>Cc Masahiro Yamada <[email protected]>Cc Thomas Gleixner <[email protected]>--- scripts/coccinelle/misc/do_div.cocci | 66 ++++++++++++++++++++++++++++++++++++ 1 file changed, 66 insertions(+) create mode 100644 scripts/coccinelle/misc/do_div.cocciscripts/coccinelle/misc/do_div.cocci new file +66
-1@@ -0,0 +1,66 @@ +// SPDX-License-Identifier: GPL-2.0-only +/// do_div() does a 64-by-32 division. +/// When the divisor is unsigned long, u64, or s64, +/// do_div() truncates it to 32 bits, this means it +/// can test non-zero and be truncated to zero for division. +/// +//# This makes an effort to find those inappropriate do_div () calls. +// +// Confidence: Moderate +// Copyright: (C) 2020 Wen Yang, Alibaba. +// Comments: +// Options: --no-includes --include-headers + +virtual context +virtual org +virtual report + +@depends on context@ +expression f; +long l; +unsigned long ul; +u64 ul64; +s64 sl64; + +@@ +( +* do_div(f, l); +| +* do_div(f, ul); +| +* do_div(f, ul64); +| +* do_div(f, sl64); +) + +@r depends on (org || report)@ +expression f; +long l; +unsigned long ul; +position p; +u64 ul64; +s64 sl64; +@@ +( +do_div@p(f, l); +| +do_div@p(f, ul); +| +do_div@p(f, ul64); +| +do_div@p(f, sl64); +) + +@script:python depends on org@ +p << r.p; +@@ + +msg="WARNING: WARNING: do_div() does a 64-by-32 division, which may truncation the divisor to 32-bit" +coccilib.org.print_todo(p[0], msg) + +@script:python depends on report@ +p << r.p; +@@ + +msg="WARNING: WARNING: do_div() does a 64-by-32 division, which may truncation the divisor to 32-bit" +coccilib.report.print_report(p[0], msg) --1.8.3.1
scripts/coccinelle/misc/do_div.cocci line 16
Quoted 3 lines
scripts/coccinelle/misc/do_div.cocci new file +3
-0+virtual context +virtual org +virtual report
The operation mode “patch” is not supported here.
Should the term “semantic code search” be used instead in the subject again?
scripts/coccinelle/misc/do_div.cocci line 34
Quoted 10 lines
+@@
scripts/coccinelle/misc/do_div.cocci new file +9
-0+( +* do_div(f, l); +| +* do_div(f, ul); +| +* do_div(f, ul64); +| +* do_div(f, sl64); +)
I suggest to avoid the specification of duplicate SmPL code.
+@@
+*do_div(f, \( l \| ul \| ul64 \| sl64 \) );
Will any more case distinctions become helpful?
scripts/coccinelle/misc/do_div.cocci line 66
Quoted 6 lines
+@script:python depends on report@
scripts/coccinelle/misc/do_div.cocci new file +5
-0+p << r.p; +@@ + +msg="WARNING: WARNING: do_div() does a 64-by-32 division, which may truncation the divisor to 32-bit" +coccilib.report.print_report(p[0], msg)
Please improve the message construction.
Regards,
Markus
Julia Lawall
maintainerQuoted 6 lines · Markus Elfring
scripts/coccinelle/misc/do_div.cocci line 16
Quoted 3 lines
scripts/coccinelle/misc/do_div.cocci new file +3
-0+virtual context +virtual org +virtual reportThe operation mode “patch” is not supported here.
Should the term “semantic code search” be used instead in the subject again?
Doesn't matter,
Quoted 15 lines
scripts/coccinelle/misc/do_div.cocci line 34
Quoted 12 lines
+@@
scripts/coccinelle/misc/do_div.cocci new file +9
-0+( +* do_div(f, l); +| +* do_div(f, ul); +| +* do_div(f, ul64); +| +* do_div(f, sl64); +)I suggest to avoid the specification of duplicate SmPL code.
Quoted 2 lines
+@@
+*do_div(f, \( l \| ul \| ul64 \| sl64 \) );
I don't se any point to this. The code matched will be the same in both cases. The original code is quite readable, without the ugly \( etc.
Quoted 4 lines
Will any more case distinctions become helpful?
Quoted 8 lines
scripts/coccinelle/misc/do_div.cocci line 66
Quoted 6 lines
+@script:python depends on report@
scripts/coccinelle/misc/do_div.cocci new file +5
-0+p << r.p; +@@ + +msg="WARNING: WARNING: do_div() does a 64-by-32 division, which may truncation the divisor to 32-bit" +coccilib.report.print_report(p[0], msg)Please improve the message construction.
Please make more precise comments (I already made some suggestions, so it doesn't matter much here, but "please improve" does not provide any concrete guidance).
julia
Quoted 12 lines
Quoted 12 lines
scripts/coccinelle/misc/do_div.cocci line 34
Quoted 9 lines
scripts/coccinelle/misc/do_div.cocci new file +9
-0+( +* do_div(f, l); +| +* do_div(f, ul); +| +* do_div(f, ul64); +| +* do_div(f, sl64); +)I suggest to avoid the specification of duplicate SmPL code.
Quoted 4 lines
Quoted 2 lines
+@@
+*do_div(f, \( l \| ul \| ul64 \| sl64 \) );I don't se any point to this.
Can such succinct SmPL code be occasionally desirable?
Quoted 1 line
The original code is quite readable,
Yes. - I dare to present a coding style alternative.
Quoted 1 line
without the ugly \( etc.
I wonder about this view.
Quoted 3 lines
Quoted 1 line
Please improve the message construction.
Please make more precise comments (I already made some suggestions,
Thus I omitted a repetition.
Quoted 2 lines
so it doesn't matter much here, but "please improve" does not provide any concrete guidance).
I guess that Wen Yang can know corresponding software design possibilities from previous development discussions.
Regards,
Markus