mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-10-19 19:12:56 +02:00
f61800be05
No changes relative to last time, but after a mitigation for an AMDGPU regression landed. --- If SimplifyInstruction() does not succeed in simplifying the instruction, it will compute the known bits of the instruction in the hope that all bits are known and the instruction can be folded to a constant. I have removed a similar optimization from InstCombine in D75801, and would like to drop this one as well. On average, we spend ~1% of total compile-time performing this known bits calculation. However, if we introduce some additional statistics for known bits computations and how many of them succeed in simplifying the instruction we get (on test-suite): instsimplify.NumKnownBits: 216 instsimplify.NumKnownBitsComputed: 13828375 valuetracking.NumKnownBitsComputed: 45860806 Out of ~14M known bits calculations (accounting for approximately one third of all known bits calculations), only 0.0015% succeed in producing a constant. Those cases where we do succeed to compute all known bits will get folded by other passes like InstCombine later. On test-suite, only lencod.test and GCC-C-execute-pr44858.test show a hash difference after this change. On lencod we see an improvement (a loop phi is optimized away), on the GCC torture test a regression (a function return value is determined only after IPSCCP, preventing propagation from a noinline function.) There are various regressions in InstSimplify tests. However, all of these cases are already handled by InstCombine, and corresponding tests have already been added there. Differential Revision: https://reviews.llvm.org/D79294
246 lines
6.2 KiB
LLVM
246 lines
6.2 KiB
LLVM
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
|
|
; RUN: opt < %s -instsimplify -S | FileCheck %s
|
|
|
|
define i32 @test1(i32 %A) {
|
|
; CHECK-LABEL: @test1(
|
|
; CHECK-NEXT: ret i32 [[A:%.*]]
|
|
;
|
|
%B = or i32 %A, 0
|
|
ret i32 %B
|
|
}
|
|
|
|
define i32 @all_ones(i32 %A) {
|
|
; CHECK-LABEL: @all_ones(
|
|
; CHECK-NEXT: ret i32 -1
|
|
;
|
|
%B = or i32 %A, -1
|
|
ret i32 %B
|
|
}
|
|
|
|
define <3 x i8> @all_ones_vec_with_undef_elt(<3 x i8> %A) {
|
|
; CHECK-LABEL: @all_ones_vec_with_undef_elt(
|
|
; CHECK-NEXT: ret <3 x i8> <i8 -1, i8 -1, i8 -1>
|
|
;
|
|
%B = or <3 x i8> %A, <i8 -1, i8 undef, i8 -1>
|
|
ret <3 x i8> %B
|
|
}
|
|
|
|
define i1 @test3(i1 %A) {
|
|
; CHECK-LABEL: @test3(
|
|
; CHECK-NEXT: ret i1 [[A:%.*]]
|
|
;
|
|
%B = or i1 %A, false
|
|
ret i1 %B
|
|
}
|
|
|
|
define i1 @test4(i1 %A) {
|
|
; CHECK-LABEL: @test4(
|
|
; CHECK-NEXT: ret i1 true
|
|
;
|
|
%B = or i1 %A, true
|
|
ret i1 %B
|
|
}
|
|
|
|
define i1 @test5(i1 %A) {
|
|
; CHECK-LABEL: @test5(
|
|
; CHECK-NEXT: ret i1 [[A:%.*]]
|
|
;
|
|
%B = or i1 %A, %A
|
|
ret i1 %B
|
|
}
|
|
|
|
define i32 @test6(i32 %A) {
|
|
; CHECK-LABEL: @test6(
|
|
; CHECK-NEXT: ret i32 [[A:%.*]]
|
|
;
|
|
%B = or i32 %A, %A
|
|
ret i32 %B
|
|
}
|
|
|
|
; A | ~A == -1
|
|
define i32 @test7(i32 %A) {
|
|
; CHECK-LABEL: @test7(
|
|
; CHECK-NEXT: ret i32 -1
|
|
;
|
|
%NotA = xor i32 %A, -1
|
|
%B = or i32 %A, %NotA
|
|
ret i32 %B
|
|
}
|
|
|
|
define i8 @test8(i8 %A) {
|
|
; CHECK-LABEL: @test8(
|
|
; CHECK-NEXT: ret i8 -1
|
|
;
|
|
%B = or i8 %A, -2
|
|
%C = or i8 %B, 1
|
|
ret i8 %C
|
|
}
|
|
|
|
; Test that (A|c1)|(B|c2) == (A|B)|(c1|c2)
|
|
define i8 @test9(i8 %A, i8 %B) {
|
|
; CHECK-LABEL: @test9(
|
|
; CHECK-NEXT: ret i8 -1
|
|
;
|
|
%C = or i8 %A, 1
|
|
%D = or i8 %B, -2
|
|
%E = or i8 %C, %D
|
|
ret i8 %E
|
|
}
|
|
|
|
; (X & C1) | C2 --> (X | C2) & (C1|C2)
|
|
define i8 @test10(i8 %A) {
|
|
; CHECK-LABEL: @test10(
|
|
; CHECK-NEXT: ret i8 -2
|
|
;
|
|
%B = or i8 %A, 1
|
|
%C = and i8 %B, -2
|
|
%D = or i8 %C, -2
|
|
ret i8 %D
|
|
}
|
|
|
|
; The following two cases only get folded by InstCombine,
|
|
; see InstCombine/or-xor.ll.
|
|
|
|
; (X ^ C1) | C2 --> (X | C2) ^ (C1&~C2)
|
|
define i8 @test11(i8 %A) {
|
|
; CHECK-LABEL: @test11(
|
|
; CHECK-NEXT: [[B:%.*]] = or i8 [[A:%.*]], -2
|
|
; CHECK-NEXT: [[C:%.*]] = xor i8 [[B]], 13
|
|
; CHECK-NEXT: [[D:%.*]] = or i8 [[C]], 1
|
|
; CHECK-NEXT: [[E:%.*]] = xor i8 [[D]], 12
|
|
; CHECK-NEXT: ret i8 [[E]]
|
|
;
|
|
%B = or i8 %A, -2
|
|
%C = xor i8 %B, 13
|
|
%D = or i8 %C, 1
|
|
%E = xor i8 %D, 12
|
|
ret i8 %E
|
|
}
|
|
|
|
define i8 @test11v(<2 x i8> %A) {
|
|
; CHECK-LABEL: @test11v(
|
|
; CHECK-NEXT: [[B:%.*]] = or <2 x i8> [[A:%.*]], <i8 -2, i8 0>
|
|
; CHECK-NEXT: [[CV:%.*]] = xor <2 x i8> [[B]], <i8 13, i8 13>
|
|
; CHECK-NEXT: [[C:%.*]] = extractelement <2 x i8> [[CV]], i32 0
|
|
; CHECK-NEXT: [[D:%.*]] = or i8 [[C]], 1
|
|
; CHECK-NEXT: [[E:%.*]] = xor i8 [[D]], 12
|
|
; CHECK-NEXT: ret i8 [[E]]
|
|
;
|
|
%B = or <2 x i8> %A, <i8 -2, i8 0>
|
|
%CV = xor <2 x i8> %B, <i8 13, i8 13>
|
|
%C = extractelement <2 x i8> %CV, i32 0
|
|
%D = or i8 %C, 1
|
|
%E = xor i8 %D, 12
|
|
ret i8 %E
|
|
}
|
|
|
|
; Test the case where integer BitWidth <= 64 && BitWidth % 2 != 0.
|
|
; If we have: ((V + N) & C1) | (V & C2)
|
|
; .. and C2 = ~C1 and C2 is 0+1+ and (N & C2) == 0
|
|
; replace with V+N.
|
|
define i39 @test1_apint(i39 %V, i39 %M) {
|
|
; CHECK-LABEL: @test1_apint(
|
|
; CHECK-NEXT: [[N:%.*]] = and i39 [[M:%.*]], -274877906944
|
|
; CHECK-NEXT: [[A:%.*]] = add i39 [[V:%.*]], [[N]]
|
|
; CHECK-NEXT: ret i39 [[A]]
|
|
;
|
|
%C1 = xor i39 274877906943, -1 ;; C2 = 274877906943
|
|
%N = and i39 %M, 274877906944
|
|
%A = add i39 %V, %N
|
|
%B = and i39 %A, %C1
|
|
%D = and i39 %V, 274877906943
|
|
%R = or i39 %B, %D
|
|
ret i39 %R
|
|
}
|
|
|
|
define i7 @test2_apint(i7 %X) {
|
|
; CHECK-LABEL: @test2_apint(
|
|
; CHECK-NEXT: ret i7 [[X:%.*]]
|
|
;
|
|
%Y = or i7 %X, 0
|
|
ret i7 %Y
|
|
}
|
|
|
|
define i17 @test3_apint(i17 %X) {
|
|
; CHECK-LABEL: @test3_apint(
|
|
; CHECK-NEXT: ret i17 -1
|
|
;
|
|
%Y = or i17 %X, -1
|
|
ret i17 %Y
|
|
}
|
|
|
|
; Test the case where Integer BitWidth > 64 && BitWidth <= 1024.
|
|
; If we have: ((V + N) & C1) | (V & C2)
|
|
; .. and C2 = ~C1 and C2 is 0+1+ and (N & C2) == 0
|
|
; replace with V+N.
|
|
define i399 @test4_apint(i399 %V, i399 %M) {
|
|
; CHECK-LABEL: @test4_apint(
|
|
; CHECK-NEXT: [[N:%.*]] = and i399 [[M:%.*]], 18446742974197923840
|
|
; CHECK-NEXT: [[A:%.*]] = add i399 [[V:%.*]], [[N]]
|
|
; CHECK-NEXT: ret i399 [[A]]
|
|
;
|
|
%C1 = xor i399 274877906943, -1 ;; C2 = 274877906943
|
|
%N = and i399 %M, 18446742974197923840
|
|
%A = add i399 %V, %N
|
|
%B = and i399 %A, %C1
|
|
%D = and i399 %V, 274877906943
|
|
%R = or i399 %D, %B
|
|
ret i399 %R
|
|
}
|
|
|
|
define i777 @test5_apint(i777 %X) {
|
|
; CHECK-LABEL: @test5_apint(
|
|
; CHECK-NEXT: ret i777 [[X:%.*]]
|
|
;
|
|
%Y = or i777 %X, 0
|
|
ret i777 %Y
|
|
}
|
|
|
|
define i117 @test6_apint(i117 %X) {
|
|
; CHECK-LABEL: @test6_apint(
|
|
; CHECK-NEXT: ret i117 -1
|
|
;
|
|
%Y = or i117 %X, -1
|
|
ret i117 %Y
|
|
}
|
|
|
|
; Test the case where integer BitWidth <= 64 && BitWidth % 2 != 0.
|
|
; Vector version of test1_apint with the add commuted
|
|
; If we have: ((V + N) & C1) | (V & C2)
|
|
; .. and C2 = ~C1 and C2 is 0+1+ and (N & C2) == 0
|
|
; replace with V+N.
|
|
define <2 x i39> @test7_apint(<2 x i39> %V, <2 x i39> %M) {
|
|
; CHECK-LABEL: @test7_apint(
|
|
; CHECK-NEXT: [[N:%.*]] = and <2 x i39> [[M:%.*]], <i39 -274877906944, i39 -274877906944>
|
|
; CHECK-NEXT: [[A:%.*]] = add <2 x i39> [[N]], [[V:%.*]]
|
|
; CHECK-NEXT: ret <2 x i39> [[A]]
|
|
;
|
|
%C1 = xor <2 x i39> <i39 274877906943, i39 274877906943>, <i39 -1, i39 -1> ;; C2 = 274877906943
|
|
%N = and <2 x i39> %M, <i39 274877906944, i39 274877906944>
|
|
%A = add <2 x i39> %N, %V
|
|
%B = and <2 x i39> %A, %C1
|
|
%D = and <2 x i39> %V, <i39 274877906943, i39 274877906943>
|
|
%R = or <2 x i39> %B, %D
|
|
ret <2 x i39> %R
|
|
}
|
|
|
|
; Test the case where Integer BitWidth > 64 && BitWidth <= 1024.
|
|
; Vector version of test4_apint with the add and the or commuted
|
|
; If we have: ((V + N) & C1) | (V & C2)
|
|
; .. and C2 = ~C1 and C2 is 0+1+ and (N & C2) == 0
|
|
; replace with V+N.
|
|
define <2 x i399> @test8_apint(<2 x i399> %V, <2 x i399> %M) {
|
|
; CHECK-LABEL: @test8_apint(
|
|
; CHECK-NEXT: [[N:%.*]] = and <2 x i399> [[M:%.*]], <i399 18446742974197923840, i399 18446742974197923840>
|
|
; CHECK-NEXT: [[A:%.*]] = add <2 x i399> [[N]], [[V:%.*]]
|
|
; CHECK-NEXT: ret <2 x i399> [[A]]
|
|
;
|
|
%C1 = xor <2 x i399> <i399 274877906943, i399 274877906943>, <i399 -1, i399 -1> ;; C2 = 274877906943
|
|
%N = and <2 x i399> %M, <i399 18446742974197923840, i399 18446742974197923840>
|
|
%A = add <2 x i399> %N, %V
|
|
%B = and <2 x i399> %A, %C1
|
|
%D = and <2 x i399> %V, <i399 274877906943, i399 274877906943>
|
|
%R = or <2 x i399> %D, %B
|
|
ret <2 x i399> %R
|
|
}
|