[InstCombine] Remove foldSelectICmpEq() fold (#122098)

This fold matches complex patterns, for which we have no proof of
real-world relevance, and which does not actually handle the originally
mot

[InstCombine] Remove foldSelectICmpEq() fold (#122098)

This fold matches complex patterns, for which we have no proof of
real-world relevance, and which does not actually handle the originally
motivating cases from https://github.com/llvm/llvm-project/issues/71792
either.

In https://github.com/llvm/llvm-project/pull/121708 and
https://github.com/llvm/llvm-project/pull/121753 we have handled some
simpler variants by extending existing folds.

I propose to remove this code until we have evidence that it is useful
for something.

show more ...

[InstSimplify] Use multi-op replacement when simplify `select` (#121708)

- **[InstSimplify] Refactor `simplifyWithOpsReplaced` to allow multiple
replacements; NFC**
- **[InstSimplify] Use multi-op

[InstSimplify] Use multi-op replacement when simplify `select` (#121708)

- **[InstSimplify] Refactor `simplifyWithOpsReplaced` to allow multiple
replacements; NFC**
- **[InstSimplify] Use multi-op replacement when simplify `select`**

In the case of `select X | Y == 0 :...` or `select X & Y == -1 : ...`
we can do more simplifications by trying to replace both `X` and `Y`
with the respective constant at once.

Handles some cases for https://github.com/llvm/llvm-project/pull/121672
more generically.

show more ...

[InstSimplify] Simplify both operands of select before comparing (#121753)

In the simplifySelectWithEquivalence fold, simplify both operands before
comparing them, instead of comparing one simplifi

[InstSimplify] Simplify both operands of select before comparing (#121753)

In the simplifySelectWithEquivalence fold, simplify both operands before
comparing them, instead of comparing one simplified operand with a
non-simplified operand. This is slightly more powerful.

show more ...

[InstCombine] Recursively replace condition with constant in select arms (#120011)

This patch is proposed to reduce the number of selects with undefs
introduced by https://github.com/llvm/llvm-proj

[InstCombine] Recursively replace condition with constant in select arms (#120011)

This patch is proposed to reduce the number of selects with undefs
introduced by https://github.com/llvm/llvm-project/pull/119884.

show more ...

[InstCombine] Fold `X Pred C2 ? X BOp C1 : C2 BOp C1` to `min/max(X, C2) BOp C1` (#116888)

Fixes #82414.

General Proof: https://alive2.llvm.org/ce/z/ERjNs4
Proof for Tests: https://alive2.llvm.

[InstCombine] Fold `X Pred C2 ? X BOp C1 : C2 BOp C1` to `min/max(X, C2) BOp C1` (#116888)

Fixes #82414.

General Proof: https://alive2.llvm.org/ce/z/ERjNs4
Proof for Tests: https://alive2.llvm.org/ce/z/K-934G

This PR transforms `select` instructions of the form `select (Cmp X C1)
(BOp X C2) C3` to `BOp (min/max X C1) C2` iff `C3 == BOp C1 C2`.

This helps in eliminating a noop loop in
https://github.com/rust-lang/rust/issues/123845 but does not improve
optimizations.

show more ...

[LLVM][IR] Use splat syntax when printing ConstantExpr based splats. (#116856)

This brings the printing of scalable vector constant splats inline with
their fixed length counterparts.

[InstCombine] Use InstSimplify in FoldOpIntoSelect (#116073)

Instead of only trying to constant fold the select arms, try to simplify
them. This subsumes https://github.com/llvm/llvm-project/pull/1

[InstCombine] Use InstSimplify in FoldOpIntoSelect (#116073)

Instead of only trying to constant fold the select arms, try to simplify
them. This subsumes https://github.com/llvm/llvm-project/pull/115969
which implements this for extractvalue only.

This is still fairly limited in that we will usually only call
FoldOpIntoSelect in the first place if we have a constant operand. This
can be relaxed in the future if worthwhile.

show more ...

[InstCombine] Add extra tests for FoldOpIntoSelect (NFC)

[LLVM][IR] Use splat syntax when printing Constant[Data]Vector. (#112548)

[InstCombine] Remove some of the complexity-based canonicalization (#91185)

The idea behind this canonicalization is that it allows us to handle less
patterns, because we know that some will be can

[InstCombine] Remove some of the complexity-based canonicalization (#91185)

The idea behind this canonicalization is that it allows us to handle less
patterns, because we know that some will be canonicalized away. This is
indeed very useful to e.g. know that constants are always on the right.

However, this is only useful if the canonicalization is actually
reliable. This is the case for constants, but not for arguments: Moving
these to the right makes it look like the "more complex" expression is
guaranteed to be on the left, but this is not actually the case in
practice. It fails as soon as you replace the argument with another
instruction.

The end result is that it looks like things correctly work in tests,
while they actually don't. We use the "thwart complexity-based
canonicalization" trick to handle this in tests, but it's often a
challenge for new contributors to get this right, and based on the
regressions this PR originally exposed, we clearly don't get this right
in many cases.

For this reason, I think that it's better to remove this complexity
canonicalization. It will make it much easier to write tests for
commuted cases and make sure that they are handled.

show more ...

[InstCombine] Do not use operand info in `replaceInInstruction` (#99492)

Consider the following case:
```
%cmp = icmp eq ptr %p, null
%load = load i32, ptr %p, align 4
%sel = select i1 %cmp, i32

[InstCombine] Do not use operand info in `replaceInInstruction` (#99492)

Consider the following case:
```
%cmp = icmp eq ptr %p, null
%load = load i32, ptr %p, align 4
%sel = select i1 %cmp, i32 %load, i32 0
```
`foldSelectValueEquivalence` converts `load i32, ptr %p, align 4` into
`load i32, ptr null, align 4`, which causes immediate UB. `%load` is
speculatable, but it doesn't hold after operand substitution.

This patch introduces a new helper
`isSafeToSpeculativelyExecuteWithVariableReplaced`. It ignores operand
info in these instructions since their operands will be replaced later.

Fixes #99436.

---------

Co-authored-by: Nikita Popov <github@npopov.com>

show more ...

[test] Remove immarg parameter attribute from calls (#97432)

It is documented that immarg is only valid on intrinsic declarations,
although the verifier also tolerates it on intrinsic calls.

Thi

[test] Remove immarg parameter attribute from calls (#97432)

It is documented that immarg is only valid on intrinsic declarations,
although the verifier also tolerates it on intrinsic calls.

This patch updates tests that are not specifically testing the
behavior of the IR parser or verifier.

show more ...

[InstCombine] Add tests for simplification based on select known bits (NFC)

[InstCombine] Simplify select using KnownBits of condition (#95923)

Simplify the arms of a select based on the KnownBits implied by its condition.
For now this only handles the case where the selec

[InstCombine] Simplify select using KnownBits of condition (#95923)

Simplify the arms of a select based on the KnownBits implied by its condition.
For now this only handles the case where the select arm folds to a constant,
but this can be generalized to handle other patterns by using
SimplifyDemandedBits instead (in that case we would also have to limit to
non-undef conditions).

This is implemented by adding a new member to SimplifyQuery that can be used
to inject an additional condition. The affected values are pre-computed and
we don't call computeKnownBits() if the select arms don't contain affected
values. This reduces the cost in some pathological cases.

show more ...

[InstCombine] Fold `(icmp eq/ne (xor x, y), C1)` even if multiuse

Two folds unlocked:
`(icmp eq/ne (xor x, C0), C1)` -> `(icmp eq/ne x, C2)`
`(icmp eq/ne (xor x, y), 0)` -> `(icmp eq/ne x, y

[InstCombine] Fold `(icmp eq/ne (xor x, y), C1)` even if multiuse

Two folds unlocked:
`(icmp eq/ne (xor x, C0), C1)` -> `(icmp eq/ne x, C2)`
`(icmp eq/ne (xor x, y), 0)` -> `(icmp eq/ne x, y)`

This fixes regressions assosiated with #87180

Closes #87275

show more ...

[InstCombine] Improve coverage of `foldSelectValueEquivalence` for constants

We don't need the `noundef` check if the new simplification is a
constant.

This cleans up regressions from folding multi

[InstCombine] Improve coverage of `foldSelectValueEquivalence` for constants

We don't need the `noundef` check if the new simplification is a
constant.

This cleans up regressions from folding multiuse:
`(icmp eq/ne (sub/xor x, y), 0)` -> `(icmp eq/ne x, y)`.

Closes #88298

show more ...

[InstCombine] Add tests for expanding `foldSelectValueEquivalence`; NFC

[ValueTracking] Make undef element check more precise

If we're only checking for undef, then also only look for undef
elements in the vector (rather than undef and poison).

[InstCombine] Only requite not-undef in select equiv fold

As the comment already indicates, only replacement with undef
is problematic, as it introduces an additional use of undef.
Use the correct V

[InstCombine] Only requite not-undef in select equiv fold

As the comment already indicates, only replacement with undef
is problematic, as it introduces an additional use of undef.
Use the correct ValueTracking helper.

show more ...

[InstCombine] Add more tests for select equivalence fold (NFC)

[IR] Remove support for icmp and fcmp constant expressions (#93038)

Remove support for the icmp and fcmp constant expressions.

This is part of:
https://discourse.llvm.org/t/rfc-remove-most-const

[IR] Remove support for icmp and fcmp constant expressions (#93038)

Remove support for the icmp and fcmp constant expressions.

This is part of:
https://discourse.llvm.org/t/rfc-remove-most-constant-expressions/63179

As usual, many of the updated tests will no longer test what they were
originally intended to -- this is hard to preserve when constant
expressions get removed, and in many cases just impossible as the
existence of a specific kind of constant expression was the cause of the
issue in the first place.

show more ...

[InstSimplify] Do not simplify freeze in `simplifyWithOpReplaced` (#91215)

See the LangRef:
> All uses of a value returned by the same ‘freeze’ instruction are
guaranteed to always observe the sam

[InstSimplify] Do not simplify freeze in `simplifyWithOpReplaced` (#91215)

See the LangRef:
> All uses of a value returned by the same ‘freeze’ instruction are
guaranteed to always observe the same value, while different ‘freeze’
instructions may yield different values.

It is incorrect to replace freezes with the simplified value.

Proof:
https://alive2.llvm.org/ce/z/3Dn9Cd
https://alive2.llvm.org/ce/z/Qyh5h6

Fixes https://github.com/llvm/llvm-project/issues/91178

show more ...

[InstCombine] Swap out range metadata to range attribute for cttz/ctlz/ctpop (#88776)

Since all optimizations that use range metadata now also handle range attribute, this patch replaces writes of

[InstCombine] Swap out range metadata to range attribute for cttz/ctlz/ctpop (#88776)

Since all optimizations that use range metadata now also handle range attribute, this patch replaces writes of
range metadata for call instructions to range attributes.

show more ...

[InstCombine] Fix poison propagation in select of bitwise fold (#89701)

We're replacing the select with the false value here, but it may be more
poisonous if m_Not contains poison elements. Fix thi

[InstCombine] Fix poison propagation in select of bitwise fold (#89701)

We're replacing the select with the false value here, but it may be more
poisonous if m_Not contains poison elements. Fix this by introducing a
m_NotForbidPoison matcher and using it here.

Fixes https://github.com/llvm/llvm-project/issues/89500.

show more ...

[InstCombine] Add test for #89500 (NFC)