List of missing peephole optimizations

[MaxGraey]

Is it possible doing some trivial logical simplifications for now? Or better wait souper with z3 solver for that?
like simplify from:

(func $test (export "test") (type $t0) (param $p0 i32) (result i32)
    get_local $p0
    i32.const 10
    i32.gt_s
    get_local $p0
    i32.const 10
    i32.eq
    i32.or)

to:

(func $test (export "test") (type $t0) (param $p0 i32) (result i32)
    get_local $p0
    i32.const 9
    i32.gt_s)

or:

(func $test (export "test") (type $t0) (param $p0 i32) (result i32)
    get_local $p0
    i32.const 10
    i32.ge_s)

DONE:
from:

  get_global $i
  i32.const 0
  i32.le_s
  i32.eqz
  if

to:

  get_global $i
  i32.const 0
  i32.gt_s
  if

[kripken]

Good idea, we should do these!

It's not hard to add them. The correct pass is OptimizeInstructions (src/passes/OptimizeInstructions.cpp). Do you want to do it?

[MaxGraey]

Oh, great! I think better if you start some basics and may be after I add additional methods/rules for that pass =)

[kripken]

@MaxGraey Sounds good, I can get the stuff set up so that it's just a matter of adding the specific rules into that pattern. Take a look at d3e5d44 - I added the first rule into combineOr there, and a test in $combine-or. The rest should be straightforward, let me know if you need any help.

(I realized I need to land a few other things before that commit, so I can't land it right now, but posting this now so you can get started if you want.)

[MaxGraey]

Great! Are you plan merge this to master? Or I can just fork oi2 and continue work in separate branch?

btw I use one trick with range checking if all arguments is unsigned. Like:

(x >= C0) & (x <= C1)

where x, C0 and C1 are unsigned ints

(unsigned)x - C0 <= C1 - C0

Also integer sequence of logical expressions like:

(x == C) | (x == C + 1) | ... | (x == N)

could transform to:

(unsigned)(x - C) <= N - C

is it make sense implement this rule as well, wdyt?

[kripken]

@MaxGraey

Yes, for now fork oi2 and work on that, since I might not be able to land it today.

That unsigned trick looks valid to me. Maybe leave it for a separate PR afterwards though, so there isn't too much in one?

[MaxGraey]

Also figure outing some useful rules for integer (sing/unsign) comparators:

x > x - 1

could always transform to:

x != MIN_VALUE

and

x + 1 > x

could always transform to:

x != MAX_VALUE

[MaxGraey]

Also wdyt using for x != 0:

get_local $0
i32.eqz
i32.eqz

instead

get_local $0
i32.const 0
i32.ne

This reducing code by 1 byte, but generate worse machine code so this probably useful only for shrink code >= 2. Of course this not very likely code because if/else/select don't require this operation explicitly

[kripken]

Comment before last looks good to me.

Last comment also looks good - as you said in if or select etc. inputs we can flip the arms and avoid != 0 anyhow, but there are cases when it happens elsewhere, so i think it's a good rule to add.

[kripken]

@MaxGraey how are you getting along with these optimizations? Anything I can help with?

[MaxGraey]

@kripken Sorry, currently I busy on work but I hope I will return to this on weekend

[MaxGraey]

Just note. Found another possible improvments like transform this:

i32.const 1
i32.const 0
get_local $p0
select

or this:

get_local $p0
if $I0 (result i32)
  i32.const 1
else
  i32.const 0
end

to this (depending on $p0 type)

get_local $p0
i32.const 0
i32.ne

UPDATE

Implemented in #2869

[MaxGraey]

More possible optimizations:

1. from:

(func $t1 (export "t1") (type $t0) (param $p0 i32) (result i32)
    get_local $p0
    i32.const 0
    i32.lt_s)

to:

(func $t1 (export "t1") (type $t0) (param $p0 i32) (result i32)
    get_local $p0
    i32.const 31
    i32.shr_s)

2. from:

 (func $t2 (export "t2") (type $t0) (param $p0 i32) (result i32)
    get_local $p0
    i32.const -1
    i32.ne)

to (but not always possible, probably valid only if result used as i1 in next steps):

(func $t2 (export "t2") (type $t0) (param $p0 i32) (result i32)
    get_local $p0
    i32.const -1
    i32.xor)