[cocci] "not supported"

[cocci] "not supported"

[Jason A. Donenfeld]

Hi,

I'm trying to generically replace constructions that look like this:

@@
expression E;
type T;
identifier I;
@@
  {
-   T I;
-   do {
-     I = get_random_u32();
-   } while (I > E);
-   return I;
+   return get_random_u32_below(E + 1);
  }

But trying to run it results in "not supported". Any idea what's up?

Also, it'd be nice if there was a way for Coccinelle to figure out
variants of that, such as I >= E in a succinct way, and maybe other
different loop constructions that amount to the same thing.

Is there any way to express what I'm after?

Thanks,
Jason

Re: [cocci] "not supported"

[Julia Lawall]

On Wed, 19 Oct 2022, Jason A. Donenfeld wrote:

> Hi,
>
> I'm trying to generically replace constructions that look like this:
>
> @@
> expression E;
> type T;
> identifier I;
> @@
>   {
> -   T I;
> -   do {
> -     I = get_random_u32();
> -   } while (I > E);
> -   return I;
> +   return get_random_u32_below(E + 1);
>   }
>
> But trying to run it results in "not supported". Any idea what's up?

Maybe you have an old version of Coccinelle?  For a long time do while was
not supported.  But it's supported now, and your rule seemed to work fine
for me.

>
> Also, it'd be nice if there was a way for Coccinelle to figure out
> variants of that, such as I >= E in a succinct way, and maybe other
> different loop constructions that amount to the same thing.
>
> Is there any way to express what I'm after?

The only way Coccinelle figures out variants is with its isomorphisms, and
allowing I > E to match I >= E seems strange as a general rule.  There are
the following isomoprhisms:

Expression
@ gtr_lss @
expression X, Y;
@@
X < Y <=> Y > X

Expression
@ gtr_lss_eq @
expression X, Y;
@@
X <= Y <=> Y >= X

You may want to at least consider putting a ... when != I just under
the T I.

You may want to write a rule like:

do { ...
*  I = get_random_u32();
  ...
} while (...);

To see what the possible options are.

julia

Re: [cocci] "not supported"

[Jason A. Donenfeld]

Hi Julia,

On Thu, Oct 20, 2022 at 1:11 AM Julia Lawall <julia.lawall@inria.fr> wrote:
> Maybe you have an old version of Coccinelle?  For a long time do while was
> not supported.  But it's supported now, and your rule seemed to work fine
> for me.

Bingo, that worked. Thanks. Might consider cutting a new release soon
so that that's available on OPAM. I built it myself for the latest.

I just sent these in:
https://lore.kernel.org/lkml/20221022014403.3881893-5-Jason@zx2c4.com/

I wound up just having a bunch of different instances, rather than
trying to teach Coccinelle about strange equivalences.

There's another one in that series that's kind of interesting:

https://lore.kernel.org/lkml/20221022014403.3881893-6-Jason@zx2c4.com/

This one has a very simple rule:

@@
expression H;
expression L;
@@
- (get_random_u32_below(H) + L)
+ get_random_u32_between(L, H + L)

This worked as expected, but I had to do a lot of hand simplification.
For example, a lot of code had a pattern of:

get_random_u32_below(H - L + 1) + L

which then got converted into

get_random_u32_between(L, H - L + 1 + L)

which I then had to clean up manually into

get_random_u32_between(L, H + 1)

It's not like that's all that hard to do. But it would be cool if
Cocinnelle had some sort of algebraic simplification possibility.

Jason

Re: [cocci] "not supported"

[Julia Lawall]

On Fri, 21 Oct 2022, Jason A. Donenfeld wrote:

> Hi Julia,
>
> On Thu, Oct 20, 2022 at 1:11 AM Julia Lawall <julia.lawall@inria.fr> wrote:
> > Maybe you have an old version of Coccinelle?  For a long time do while was
> > not supported.  But it's supported now, and your rule seemed to work fine
> > for me.
>
> Bingo, that worked. Thanks. Might consider cutting a new release soon
> so that that's available on OPAM. I built it myself for the latest.

Yes, I'll try to do that soon.

>
> I just sent these in:
> https://lore.kernel.org/lkml/20221022014403.3881893-5-Jason@zx2c4.com/
>
> I wound up just having a bunch of different instances, rather than
> trying to teach Coccinelle about strange equivalences.
>
> There's another one in that series that's kind of interesting:
>
> https://lore.kernel.org/lkml/20221022014403.3881893-6-Jason@zx2c4.com/
>
> This one has a very simple rule:
>
> @@
> expression H;
> expression L;
> @@
> - (get_random_u32_below(H) + L)
> + get_random_u32_between(L, H + L)
>
> This worked as expected, but I had to do a lot of hand simplification.
> For example, a lot of code had a pattern of:
>
> get_random_u32_below(H - L + 1) + L
>
> which then got converted into
>
> get_random_u32_between(L, H - L + 1 + L)
>
> which I then had to clean up manually into
>
> get_random_u32_between(L, H + 1)
>
> It's not like that's all that hard to do. But it would be cool if
> Cocinnelle had some sort of algebraic simplification possibility.

Maybe it's a bit special case for Coccinelle.  If there were many
recurring cases you could make extra rules.

julia

Re: [cocci] Replacing special do { … } while loops by selected function calls

[Markus Elfring]

> I just sent these in:
> https://lore.kernel.org/lkml/20221022014403.3881893-5-Jason@zx2c4.com/

I suggest to reconsider the usage of SmPL ellipses in more detail
according to your SmPL code demonstration in the description for the change
suggestion “[PATCH v1 4/5] treewide: use get_random_u32_{above,below}()
instead of manual loop”.

Regards,
Markus

Re: [cocci] Checking the replacement “get_random_u32_above(0)”

[Markus Elfring]

> I just sent these in:
> https://lore.kernel.org/lkml/20221022014403.3881893-5-Jason@zx2c4.com/

I find the following code details also suspicious from two SmPL rules.

…
-   } while (!I);
+   I = get_random_u32_above(0);
…
-   } while (I == 0);
+   I = get_random_u32_above(0);
…


* Should such case distinctions be reconsidered?

* Can different function parameters become relevant here?


Regards,
Markus

Re: [cocci] algebraic simplification possibilities with SmPL

[Markus Elfring]

> There's another one in that series that's kind of interesting:
>
> https://lore.kernel.org/lkml/20221022014403.3881893-6-Jason@zx2c4.com/
>
> This one has a very simple rule:
>
> @@
> expression H;
> expression L;
> @@
> - (get_random_u32_below(H) + L)
> + get_random_u32_between(L, H + L)
>
> This worked as expected, but I had to do a lot of hand simplification.
> For example, a lot of code had a pattern of:
>
> get_random_u32_below(H - L + 1) + L
>
> which then got converted into
>
> get_random_u32_between(L, H - L + 1 + L)
>
> which I then had to clean up manually into
>
> get_random_u32_between(L, H + 1)
>
> It's not like that's all that hard to do. But it would be cool if
> Cocinnelle had some sort of algebraic simplification possibility.

I imagine also that it will occasionally be nicer if further optimisation
rules would belong to the standard functionality of the Coccinelle software.
But I guess that you can achieve desirable transformations also by using
additional rules for the semantic patch language.

How do you think about a change approach like the following?

@cleanup@
identifier H, L;
@@
 get_random_u32_between(L,
                        H
-                         - L
                          + 1
-                         + L
                       )


Regards,
Markus

Re: [cocci] Replacing special do { … } while loops by selected function calls

[Jason A. Donenfeld]

On Sat, Oct 22, 2022 at 09:45:43PM +0200, Markus Elfring wrote:
> > I just sent these in:
> > https://lore.kernel.org/lkml/20221022014403.3881893-5-Jason@zx2c4.com/
> 
> I suggest to reconsider the usage of SmPL ellipses in more detail
> according to your SmPL code demonstration in the description for the change
> suggestion “[PATCH v1 4/5] treewide: use get_random_u32_{above,below}()
> instead of manual loop”.

I'll do `... when != I`.

Re: [cocci] Checking the replacement “get_random_u32_above(0)”

[Jason A. Donenfeld]

On Sun, Oct 23, 2022 at 01:18:32PM +0200, Markus Elfring wrote:
> > I just sent these in:
> > https://lore.kernel.org/lkml/20221022014403.3881893-5-Jason@zx2c4.com/
> 
> I find the following code details also suspicious from two SmPL rules.
> 
> …
> -   } while (!I);
> +   I = get_random_u32_above(0);
> …
> -   } while (I == 0);
> +   I = get_random_u32_above(0);
> …
> 
> 
> * Should such case distinctions be reconsidered?
> 
> * Can different function parameters become relevant here?

* Can you be more specific?

I have no idea what you're getting at.

Jason

Re: [cocci] algebraic simplification possibilities with SmPL

[Jason A. Donenfeld]

On Sun, Oct 23, 2022 at 03:55:23PM +0200, Markus Elfring wrote:
> > There's another one in that series that's kind of interesting:
> >
> > https://lore.kernel.org/lkml/20221022014403.3881893-6-Jason@zx2c4.com/
> >
> > This one has a very simple rule:
> >
> > @@
> > expression H;
> > expression L;
> > @@
> > - (get_random_u32_below(H) + L)
> > + get_random_u32_between(L, H + L)
> >
> > This worked as expected, but I had to do a lot of hand simplification.
> > For example, a lot of code had a pattern of:
> >
> > get_random_u32_below(H - L + 1) + L
> >
> > which then got converted into
> >
> > get_random_u32_between(L, H - L + 1 + L)
> >
> > which I then had to clean up manually into
> >
> > get_random_u32_between(L, H + 1)
> >
> > It's not like that's all that hard to do. But it would be cool if
> > Cocinnelle had some sort of algebraic simplification possibility.
> 
> I imagine also that it will occasionally be nicer if further optimisation
> rules would belong to the standard functionality of the Coccinelle software.
> But I guess that you can achieve desirable transformations also by using
> additional rules for the semantic patch language.
> 
> How do you think about a change approach like the following?
> 
> @cleanup@
> identifier H, L;
> @@
>  get_random_u32_between(L,
>                         H
> -                         - L
>                           + 1
> -                         + L
>                        )
> 

I can do something like that. These seem to work:

@@
expression H;
expression L;
@@
- (get_random_u32_below(H) + L)
+ get_random_u32_between(L, H + L)

@@
expression H;
expression L;
expression E;
@@
  get_random_u32_between(L,
  H
- + E
- - E
  )

@@
expression H;
expression L;
expression E;
@@
  get_random_u32_between(L,
  H
- - E
- + E
  )

@@
expression H;
expression L;
expression E;
expression F;
@@
  get_random_u32_between(L,
  H
- - E
  + F
- + E
  )

@@
expression H;
expression L;
expression E;
expression F;
@@
  get_random_u32_between(L,
  H
- + E
  + F
- - E
  )


Kind of annoying that Coccinelle doesn't do commutativity itself, but
that's fine.

Jason

Re: [cocci] algebraic simplification possibilities with SmPL

[Julia Lawall]

On Sun, 23 Oct 2022, Jason A. Donenfeld wrote:

> On Sun, Oct 23, 2022 at 03:55:23PM +0200, Markus Elfring wrote:
> > > There's another one in that series that's kind of interesting:
> > >
> > > https://lore.kernel.org/lkml/20221022014403.3881893-6-Jason@zx2c4.com/
> > >
> > > This one has a very simple rule:
> > >
> > > @@
> > > expression H;
> > > expression L;
> > > @@
> > > - (get_random_u32_below(H) + L)
> > > + get_random_u32_between(L, H + L)
> > >
> > > This worked as expected, but I had to do a lot of hand simplification.
> > > For example, a lot of code had a pattern of:
> > >
> > > get_random_u32_below(H - L + 1) + L
> > >
> > > which then got converted into
> > >
> > > get_random_u32_between(L, H - L + 1 + L)
> > >
> > > which I then had to clean up manually into
> > >
> > > get_random_u32_between(L, H + 1)
> > >
> > > It's not like that's all that hard to do. But it would be cool if
> > > Cocinnelle had some sort of algebraic simplification possibility.
> >
> > I imagine also that it will occasionally be nicer if further optimisation
> > rules would belong to the standard functionality of the Coccinelle software.
> > But I guess that you can achieve desirable transformations also by using
> > additional rules for the semantic patch language.
> >
> > How do you think about a change approach like the following?
> >
> > @cleanup@
> > identifier H, L;
> > @@
> >  get_random_u32_between(L,
> >                         H
> > -                         - L
> >                           + 1
> > -                         + L
> >                        )
> >
>
> I can do something like that. These seem to work:
>
> @@
> expression H;
> expression L;
> @@
> - (get_random_u32_below(H) + L)
> + get_random_u32_between(L, H + L)
>
> @@
> expression H;
> expression L;
> expression E;
> @@
>   get_random_u32_between(L,
>   H
> - + E
> - - E
>   )
>
> @@
> expression H;
> expression L;
> expression E;
> @@
>   get_random_u32_between(L,
>   H
> - - E
> - + E
>   )
>
> @@
> expression H;
> expression L;
> expression E;
> expression F;
> @@
>   get_random_u32_between(L,
>   H
> - - E
>   + F
> - + E
>   )
>
> @@
> expression H;
> expression L;
> expression E;
> expression F;
> @@
>   get_random_u32_between(L,
>   H
> - + E
>   + F
> - - E
>   )
>
>
> Kind of annoying that Coccinelle doesn't do commutativity itself, but
> that's fine.

The parse tree is probably not what you would hope it to be.  It's
probably, eg:

(a + b) + c

so it's not straightforward to exchange b and c, without considering lots
of special cases.

julia

Re: [cocci] algebraic simplification possibilities with SmPL

[Jason A. Donenfeld]

On Sun, Oct 23, 2022 at 09:45:42PM +0200, Julia Lawall wrote:
> 
> 
> On Sun, 23 Oct 2022, Jason A. Donenfeld wrote:
> 
> > On Sun, Oct 23, 2022 at 03:55:23PM +0200, Markus Elfring wrote:
> > > > There's another one in that series that's kind of interesting:
> > > >
> > > > https://lore.kernel.org/lkml/20221022014403.3881893-6-Jason@zx2c4.com/
> > > >
> > > > This one has a very simple rule:
> > > >
> > > > @@
> > > > expression H;
> > > > expression L;
> > > > @@
> > > > - (get_random_u32_below(H) + L)
> > > > + get_random_u32_between(L, H + L)
> > > >
> > > > This worked as expected, but I had to do a lot of hand simplification.
> > > > For example, a lot of code had a pattern of:
> > > >
> > > > get_random_u32_below(H - L + 1) + L
> > > >
> > > > which then got converted into
> > > >
> > > > get_random_u32_between(L, H - L + 1 + L)
> > > >
> > > > which I then had to clean up manually into
> > > >
> > > > get_random_u32_between(L, H + 1)
> > > >
> > > > It's not like that's all that hard to do. But it would be cool if
> > > > Cocinnelle had some sort of algebraic simplification possibility.
> > >
> > > I imagine also that it will occasionally be nicer if further optimisation
> > > rules would belong to the standard functionality of the Coccinelle software.
> > > But I guess that you can achieve desirable transformations also by using
> > > additional rules for the semantic patch language.
> > >
> > > How do you think about a change approach like the following?
> > >
> > > @cleanup@
> > > identifier H, L;
> > > @@
> > >  get_random_u32_between(L,
> > >                         H
> > > -                         - L
> > >                           + 1
> > > -                         + L
> > >                        )
> > >
> >
> > I can do something like that. These seem to work:
> >
> > @@
> > expression H;
> > expression L;
> > @@
> > - (get_random_u32_below(H) + L)
> > + get_random_u32_between(L, H + L)
> >
> > @@
> > expression H;
> > expression L;
> > expression E;
> > @@
> >   get_random_u32_between(L,
> >   H
> > - + E
> > - - E
> >   )
> >
> > @@
> > expression H;
> > expression L;
> > expression E;
> > @@
> >   get_random_u32_between(L,
> >   H
> > - - E
> > - + E
> >   )
> >
> > @@
> > expression H;
> > expression L;
> > expression E;
> > expression F;
> > @@
> >   get_random_u32_between(L,
> >   H
> > - - E
> >   + F
> > - + E
> >   )
> >
> > @@
> > expression H;
> > expression L;
> > expression E;
> > expression F;
> > @@
> >   get_random_u32_between(L,
> >   H
> > - + E
> >   + F
> > - - E
> >   )
> >
> >
> > Kind of annoying that Coccinelle doesn't do commutativity itself, but
> > that's fine.
> 
> The parse tree is probably not what you would hope it to be.  It's
> probably, eg:
> 
> (a + b) + c
> 
> so it's not straightforward to exchange b and c, without considering lots
> of special cases.

The general solution might be a pass that removes parens when they don't
influence the order of operations?

Jason

Re: [cocci] algebraic simplification possibilities with SmPL

[Julia Lawall]

On Sun, 23 Oct 2022, Jason A. Donenfeld wrote:

> On Sun, Oct 23, 2022 at 09:45:42PM +0200, Julia Lawall wrote:
> >
> >
> > On Sun, 23 Oct 2022, Jason A. Donenfeld wrote:
> >
> > > On Sun, Oct 23, 2022 at 03:55:23PM +0200, Markus Elfring wrote:
> > > > > There's another one in that series that's kind of interesting:
> > > > >
> > > > > https://lore.kernel.org/lkml/20221022014403.3881893-6-Jason@zx2c4.com/
> > > > >
> > > > > This one has a very simple rule:
> > > > >
> > > > > @@
> > > > > expression H;
> > > > > expression L;
> > > > > @@
> > > > > - (get_random_u32_below(H) + L)
> > > > > + get_random_u32_between(L, H + L)
> > > > >
> > > > > This worked as expected, but I had to do a lot of hand simplification.
> > > > > For example, a lot of code had a pattern of:
> > > > >
> > > > > get_random_u32_below(H - L + 1) + L
> > > > >
> > > > > which then got converted into
> > > > >
> > > > > get_random_u32_between(L, H - L + 1 + L)
> > > > >
> > > > > which I then had to clean up manually into
> > > > >
> > > > > get_random_u32_between(L, H + 1)
> > > > >
> > > > > It's not like that's all that hard to do. But it would be cool if
> > > > > Cocinnelle had some sort of algebraic simplification possibility.
> > > >
> > > > I imagine also that it will occasionally be nicer if further optimisation
> > > > rules would belong to the standard functionality of the Coccinelle software.
> > > > But I guess that you can achieve desirable transformations also by using
> > > > additional rules for the semantic patch language.
> > > >
> > > > How do you think about a change approach like the following?
> > > >
> > > > @cleanup@
> > > > identifier H, L;
> > > > @@
> > > >  get_random_u32_between(L,
> > > >                         H
> > > > -                         - L
> > > >                           + 1
> > > > -                         + L
> > > >                        )
> > > >
> > >
> > > I can do something like that. These seem to work:
> > >
> > > @@
> > > expression H;
> > > expression L;
> > > @@
> > > - (get_random_u32_below(H) + L)
> > > + get_random_u32_between(L, H + L)
> > >
> > > @@
> > > expression H;
> > > expression L;
> > > expression E;
> > > @@
> > >   get_random_u32_between(L,
> > >   H
> > > - + E
> > > - - E
> > >   )
> > >
> > > @@
> > > expression H;
> > > expression L;
> > > expression E;
> > > @@
> > >   get_random_u32_between(L,
> > >   H
> > > - - E
> > > - + E
> > >   )
> > >
> > > @@
> > > expression H;
> > > expression L;
> > > expression E;
> > > expression F;
> > > @@
> > >   get_random_u32_between(L,
> > >   H
> > > - - E
> > >   + F
> > > - + E
> > >   )
> > >
> > > @@
> > > expression H;
> > > expression L;
> > > expression E;
> > > expression F;
> > > @@
> > >   get_random_u32_between(L,
> > >   H
> > > - + E
> > >   + F
> > > - - E
> > >   )
> > >
> > >
> > > Kind of annoying that Coccinelle doesn't do commutativity itself, but
> > > that's fine.
> >
> > The parse tree is probably not what you would hope it to be.  It's
> > probably, eg:
> >
> > (a + b) + c
> >
> > so it's not straightforward to exchange b and c, without considering lots
> > of special cases.
>
> The general solution might be a pass that removes parens when they don't
> influence the order of operations?

Sorry, they weren't real parentheses.  They were showing how the AST is
organized.  b and c aren't at the same level.

julia

Re: [cocci] Checking the replacement “get_random_u32_above(0)”

[Markus Elfring]

> > > I just sent these in:
> > > https://lore.kernel.org/lkml/20221022014403.3881893-5-Jason@zx2c4.com/
> > 
> > I find the following code details also suspicious from two SmPL rules.
> > 
> > …
> > -   } while (!I);
> > +   I = get_random_u32_above(0);
> > …
> > -   } while (I == 0);
> > +   I = get_random_u32_above(0);
> > …
> > 
> > 
> > * Should such case distinctions be reconsidered?
> > 
> > * Can different function parameters become relevant here?
> 
> * Can you be more specific?
> 
> I have no idea what you're getting at.

I doubt that you would like to map the condition checks “!I” and “I == 0”
to the same function call.

If you would insist to cobble them together, I imagine that it would be nicer
to combine discussed SmPL rules into one by using SmPL disjunctions accordingly.

Regards,
Markus

Re: [cocci] Replacing special do { … } while loops by selected function calls

[Markus Elfring]

> > > I just sent these in:
> > > https://lore.kernel.org/lkml/20221022014403.3881893-5-Jason@zx2c4.com/
> > 
> > I suggest to reconsider the usage of SmPL ellipses in more detail
> > according to your SmPL code demonstration in the description for the change
> > suggestion “[PATCH v1 4/5] treewide: use get_random_u32_{above,below}()
> > instead of manual loop”.
> 
> I'll do `... when != I`.

I find this feedback too terse.

Code exclusion specifications can occasionally be helpful.
I imagine that further case distinctions will point a need out to consider
clarification for additional SmPL code design variants.

Regards,
Markus

Re: [cocci] algebraic simplification possibilities with SmPL

[Markus Elfring]

> I can do something like that. These seem to work:

I wonder about another error response from the software “Coccinelle 1.1.1”
for an SmPL code variant like the following.


@replacement@
expression H, L;
@@
-(get_random_u32_below(H) + L)
+get_random_u32_between(L, H + L)

@cleanup@
expression H, L, E, F;
@@
 get_random_u32_between(L,
  H
(
- - E
  + F
- + E
|
- + E
  + F
- - E
|
- - E
- + E
|
- + E
- - E
)
                       )


linux@linux:…/Projekte/Coccinelle/Probe> spatch --parse-cocci suggestion3_for_Jason_Donenfeld-20221024.cocci
…
minus: parse error: 
  File "suggestion3_for_Jason_Donenfeld-20221024.cocci", line 12, column 0, charpos = 167
  around = '(',
  whole content = (


Can such a test case trigger any further improvements for the advanced application
of SmPL disjunctions?

Regards,
Markus

Re: [cocci] algebraic simplification possibilities with SmPL

[Julia Lawall]

[-- Attachment #1: Type: text/plain, Size: 1099 bytes --]



On Mon, 24 Oct 2022, Markus Elfring wrote:

> > I can do something like that. These seem to work:
>
> I wonder about another error response from the software “Coccinelle 1.1.1”
> for an SmPL code variant like the following.

You can't make a disjunction like that.  The branches of a disjunction has
to be complete terms, not random strings of tokens.

julia


>
>
> @replacement@
> expression H, L;
> @@
> -(get_random_u32_below(H) + L)
> +get_random_u32_between(L, H + L)
>
> @cleanup@
> expression H, L, E, F;
> @@
>  get_random_u32_between(L,
>   H
> (
> - - E
>   + F
> - + E
> |
> - + E
>   + F
> - - E
> |
> - - E
> - + E
> |
> - + E
> - - E
> )
>                        )
>
>
> linux@linux:…/Projekte/Coccinelle/Probe> spatch --parse-cocci suggestion3_for_Jason_Donenfeld-20221024.cocci
> …
> minus: parse error:
>   File "suggestion3_for_Jason_Donenfeld-20221024.cocci", line 12, column 0, charpos = 167
>   around = '(',
>   whole content = (
>
>
> Can such a test case trigger any further improvements for the advanced application
> of SmPL disjunctions?
>
> Regards,
> Markus
>

Re: [cocci] algebraic simplification possibilities with SmPL

[Markus Elfring]

> I can do something like that. These seem to work:

The software “Coccinelle 1.1.1” gave me the impression that the following
SmPL code variant can be acceptable.


@replacement@
expression H, L;
@@
-(get_random_u32_below(H) + L)
+get_random_u32_between(L, H + L)

@cleanup@
expression H, L, E, F;
@@
(
 get_random_u32_between
 (L,
  H
- - E
  + F
- + E
 )
|
 get_random_u32_between
 (L,
  H
- + E
  + F
- - E
 )
|
 get_random_u32_between
 (L,
  H
- - E
- + E
 )
|
 get_random_u32_between
 (L,
  H
- + E
- - E
 )
)


Regards,
Markus

Re: [cocci] algebraic simplification possibilities with SmPL

[Julia Lawall]

[-- Attachment #1: Type: text/plain, Size: 702 bytes --]



On Mon, 24 Oct 2022, Markus Elfring wrote:

> > I can do something like that. These seem to work:
>
> The software “Coccinelle 1.1.1” gave me the impression that the following
> SmPL code variant can be acceptable.
>
>
> @replacement@
> expression H, L;
> @@
> -(get_random_u32_below(H) + L)
> +get_random_u32_between(L, H + L)
>
> @cleanup@
> expression H, L, E, F;
> @@
> (
>  get_random_u32_between
>  (L,
>   H
> - - E
>   + F
> - + E
>  )
> |
>  get_random_u32_between
>  (L,
>   H
> - + E
>   + F
> - - E
>  )
> |
>  get_random_u32_between
>  (L,
>   H
> - - E
> - + E
>  )
> |
>  get_random_u32_between
>  (L,
>   H
> - + E
> - - E
>  )
> )

That is fine.

julia

>
>
> Regards,
> Markus
>