Skip to content

[InstCombine] Fold umax/umin(nuw_shl(z, x), nuw_shl(z, y)) -> nuw_shl(z, umax/umin(x, y)) and umax/umin(nuw_shl(x, z), nuw_shl(y, z)) -> nuw_shl(umax/umin(x, y), z) #131076

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
dtcxzyw merged 15 commits into from
Mar 15, 2025
Merged

[InstCombine] Fold umax/umin(nuw_shl(z, x), nuw_shl(z, y)) -> nuw_shl(z, umax/umin(x, y)) and umax/umin(nuw_shl(x, z), nuw_shl(y, z)) -> nuw_shl(umax/umin(x, y), z) #131076

Show file tree
Hide file tree
Changes from 4 commits
Commits
Show all changes
15 commits
Select commit Hold shift + click to select a range
3ea75f4
[InstCombine] Add pre-commit tests
el-ev Mar 13, 2025
a11d23d
[InstCombine] Fold ` umax(nuw_shl(C0, x), nuw_shl(C0, y)) -> nuw_shl(…
el-ev Mar 13, 2025
ed5a722
adjust test for variables as base
el-ev Mar 13, 2025
e09c615
adjust transformation for variables as base
el-ev Mar 13, 2025
ff81d9b
update affected testcase
el-ev Mar 13, 2025
77d3461
add nsw flag testcase
el-ev Mar 13, 2025
27e0a48
preserve nsw flag
el-ev Mar 13, 2025
2930936
add test for cases where rhs of shl are equal
el-ev Mar 13, 2025
fe32b6f
support cases where rhs are equal
el-ev Mar 13, 2025
080fc1d
refactor into `foldIntrinsicUsingDistributiveLaws`
el-ev Mar 14, 2025
3133f1d
update tests
el-ev Mar 14, 2025
46f31fc
codestyle
el-ev Mar 14, 2025
6cbc76d
fix intrinsic-distributive.ll commutative tests
el-ev Mar 14, 2025
e313f96
add intrinsic-distributive commutative regression tests
el-ev Mar 14, 2025
7fda0f4
fix missed swap pattern
el-ev Mar 14, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
11 changes: 11 additions & 0 deletions llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1887,6 +1887,17 @@ Instruction *InstCombinerImpl::visitCallInst(CallInst &CI) {
if (Instruction *I = foldMaxMulShift(I1, I0))
return I;
}

// umax(nuw_shl(base, x), nuw_shl(base, y)) -> nuw_shl(base, umax(x, y))
// umin(nuw_shl(base, x), nuw_shl(base, y)) -> nuw_shl(base, umin(x, y))
Value *Base;
Value *Shamt1, *Shamt2;
if (match(I0, m_OneUse(m_NUWShl(m_Value(Base), m_Value(Shamt1)))) &&
match(I1, m_OneUse(m_NUWShl(m_Deferred(Base), m_Value(Shamt2))))) {
Value *MaxMin = Builder.CreateBinaryIntrinsic(IID, Shamt1, Shamt2);
return BinaryOperator::CreateNUWShl(Base, MaxMin);
}

// If both operands of unsigned min/max are sign-extended, it is still ok
// to narrow the operation.
[[fallthrough]];
Expand Down
308 changes: 308 additions & 0 deletions llvm/test/Transforms/InstCombine/shift-uminmax.ll
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,308 @@
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 5
; RUN: opt < %s -passes=instcombine -S | FileCheck %s

; For the following patterns:
; umax(nuw_shl(base, x), nuw_shl(base, y)) -> nuw_shl(base, umax(x, y))
; umin(nuw_shl(base, x), nuw_shl(base, y)) -> nuw_shl(base, umin(x, y))

define i32 @test_umax_shl(i32 %base, i32 %x, i32 %y) {
; CHECK-LABEL: define i32 @test_umax_shl(
; CHECK-SAME: i32 [[BASE:%.*]], i32 [[X:%.*]], i32 [[Y:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = call i32 @llvm.umax.i32(i32 [[X]], i32 [[Y]])
; CHECK-NEXT: [[MAX:%.*]] = shl nuw i32 [[BASE]], [[TMP1]]
; CHECK-NEXT: ret i32 [[MAX]]
;
%shl_x = shl nuw i32 %base, %x
%shl_y = shl nuw i32 %base, %y
%max = call i32 @llvm.umax.i32(i32 %shl_x, i32 %shl_y)
ret i32 %max
}

define i32 @test_umin_shl(i32 %base, i32 %x, i32 %y) {
; CHECK-LABEL: define i32 @test_umin_shl(
; CHECK-SAME: i32 [[BASE:%.*]], i32 [[X:%.*]], i32 [[Y:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = call i32 @llvm.umin.i32(i32 [[X]], i32 [[Y]])
; CHECK-NEXT: [[MIN:%.*]] = shl nuw i32 [[BASE]], [[TMP1]]
; CHECK-NEXT: ret i32 [[MIN]]
;
%shl_x = shl nuw i32 %base, %x
%shl_y = shl nuw i32 %base, %y
%min = call i32 @llvm.umin.i32(i32 %shl_x, i32 %shl_y)
ret i32 %min
}

define i32 @test_umax_shl_const1(i32 %x, i32 %y) {
; CHECK-LABEL: define i32 @test_umax_shl_const1(
; CHECK-SAME: i32 [[X:%.*]], i32 [[Y:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = call i32 @llvm.umax.i32(i32 [[X]], i32 [[Y]])
; CHECK-NEXT: [[MAX:%.*]] = shl nuw i32 1, [[TMP1]]
; CHECK-NEXT: ret i32 [[MAX]]
;
%shl_x = shl nuw i32 1, %x
%shl_y = shl nuw i32 1, %y
%max = call i32 @llvm.umax.i32(i32 %shl_x, i32 %shl_y)
ret i32 %max
}

define i32 @test_umin_shl_const1(i32 %x, i32 %y) {
; CHECK-LABEL: define i32 @test_umin_shl_const1(
; CHECK-SAME: i32 [[X:%.*]], i32 [[Y:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = call i32 @llvm.umin.i32(i32 [[X]], i32 [[Y]])
; CHECK-NEXT: [[MIN:%.*]] = shl nuw i32 1, [[TMP1]]
; CHECK-NEXT: ret i32 [[MIN]]
;
%shl_x = shl nuw i32 1, %x
%shl_y = shl nuw i32 1, %y
%min = call i32 @llvm.umin.i32(i32 %shl_x, i32 %shl_y)
ret i32 %min
}

define i32 @test_umax_shl_const5(i32 %x, i32 %y) {
; CHECK-LABEL: define i32 @test_umax_shl_const5(
; CHECK-SAME: i32 [[X:%.*]], i32 [[Y:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = call i32 @llvm.umax.i32(i32 [[X]], i32 [[Y]])
; CHECK-NEXT: [[MAX:%.*]] = shl nuw i32 5, [[TMP1]]
; CHECK-NEXT: ret i32 [[MAX]]
;
%shl_x = shl nuw i32 5, %x
%shl_y = shl nuw i32 5, %y
%max = call i32 @llvm.umax.i32(i32 %shl_x, i32 %shl_y)
ret i32 %max
}

define i32 @test_umin_shl_const5(i32 %x, i32 %y) {
; CHECK-LABEL: define i32 @test_umin_shl_const5(
; CHECK-SAME: i32 [[X:%.*]], i32 [[Y:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = call i32 @llvm.umin.i32(i32 [[X]], i32 [[Y]])
; CHECK-NEXT: [[MIN:%.*]] = shl nuw i32 5, [[TMP1]]
; CHECK-NEXT: ret i32 [[MIN]]
;
%shl_x = shl nuw i32 5, %x
%shl_y = shl nuw i32 5, %y
%min = call i32 @llvm.umin.i32(i32 %shl_x, i32 %shl_y)
ret i32 %min
}

declare void @use(i8)

define i32 @test_umax_shl_multi_use(i32 %base, i32 %x, i32 %y) {
; CHECK-LABEL: define i32 @test_umax_shl_multi_use(
; CHECK-SAME: i32 [[BASE:%.*]], i32 [[X:%.*]], i32 [[Y:%.*]]) {
; CHECK-NEXT: [[SHL_X:%.*]] = shl nuw i32 [[BASE]], [[X]]
; CHECK-NEXT: [[SHL_Y:%.*]] = shl nuw i32 [[BASE]], [[Y]]
; CHECK-NEXT: call void @use(i32 [[SHL_X]])
; CHECK-NEXT: call void @use(i32 [[SHL_Y]])
; CHECK-NEXT: [[MAX:%.*]] = call i32 @llvm.umax.i32(i32 [[SHL_X]], i32 [[SHL_Y]])
; CHECK-NEXT: ret i32 [[MAX]]
;
%shl_x = shl nuw i32 %base, %x
%shl_y = shl nuw i32 %base, %y
call void @use(i32 %shl_x)
call void @use(i32 %shl_y)
%max = call i32 @llvm.umax.i32(i32 %shl_x, i32 %shl_y)
ret i32 %max
}

define i32 @test_umin_shl_multi_use(i32 %base, i32 %x, i32 %y) {
; CHECK-LABEL: define i32 @test_umin_shl_multi_use(
; CHECK-SAME: i32 [[BASE:%.*]], i32 [[X:%.*]], i32 [[Y:%.*]]) {
; CHECK-NEXT: [[SHL_X:%.*]] = shl nuw i32 [[BASE]], [[X]]
; CHECK-NEXT: [[SHL_Y:%.*]] = shl nuw i32 [[BASE]], [[Y]]
; CHECK-NEXT: call void @use(i32 [[SHL_X]])
; CHECK-NEXT: call void @use(i32 [[SHL_Y]])
; CHECK-NEXT: [[MIN:%.*]] = call i32 @llvm.umin.i32(i32 [[SHL_X]], i32 [[SHL_Y]])
; CHECK-NEXT: ret i32 [[MIN]]
;
%shl_x = shl nuw i32 %base, %x
%shl_y = shl nuw i32 %base, %y
call void @use(i32 %shl_x)
call void @use(i32 %shl_y)
%min = call i32 @llvm.umin.i32(i32 %shl_x, i32 %shl_y)
ret i32 %min
}

define i32 @test_umax_shl_commuted(i32 %base, i32 %x, i32 %y) {
; CHECK-LABEL: define i32 @test_umax_shl_commuted(
; CHECK-SAME: i32 [[BASE:%.*]], i32 [[X:%.*]], i32 [[Y:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = call i32 @llvm.umax.i32(i32 [[Y]], i32 [[X]])
; CHECK-NEXT: [[MAX:%.*]] = shl nuw i32 [[BASE]], [[TMP1]]
; CHECK-NEXT: ret i32 [[MAX]]
;
%shl_x = shl nuw i32 %base, %x
%shl_y = shl nuw i32 %base, %y
%max = call i32 @llvm.umax.i32(i32 %shl_y, i32 %shl_x)
ret i32 %max
}

define i32 @test_umin_shl_commuted(i32 %base, i32 %x, i32 %y) {
; CHECK-LABEL: define i32 @test_umin_shl_commuted(
; CHECK-SAME: i32 [[BASE:%.*]], i32 [[X:%.*]], i32 [[Y:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = call i32 @llvm.umin.i32(i32 [[Y]], i32 [[X]])
; CHECK-NEXT: [[MIN:%.*]] = shl nuw i32 [[BASE]], [[TMP1]]
; CHECK-NEXT: ret i32 [[MIN]]
;
%shl_x = shl nuw i32 %base, %x
%shl_y = shl nuw i32 %base, %y
%min = call i32 @llvm.umin.i32(i32 %shl_y, i32 %shl_x)
ret i32 %min
}

define <2 x i32> @test_umax_shl_vector(<2 x i32> %base, <2 x i32> %x, <2 x i32> %y) {
; CHECK-LABEL: define <2 x i32> @test_umax_shl_vector(
; CHECK-SAME: <2 x i32> [[BASE:%.*]], <2 x i32> [[X:%.*]], <2 x i32> [[Y:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = call <2 x i32> @llvm.umax.v2i32(<2 x i32> [[X]], <2 x i32> [[Y]])
; CHECK-NEXT: [[MAX:%.*]] = shl nuw <2 x i32> [[BASE]], [[TMP1]]
; CHECK-NEXT: ret <2 x i32> [[MAX]]
;
%shl_x = shl nuw <2 x i32> %base, %x
%shl_y = shl nuw <2 x i32> %base, %y
%max = call <2 x i32> @llvm.umax.v2i32(<2 x i32> %shl_x, <2 x i32> %shl_y)
ret <2 x i32> %max
}

define <2 x i32> @test_umin_shl_vector(<2 x i32> %base, <2 x i32> %x, <2 x i32> %y) {
; CHECK-LABEL: define <2 x i32> @test_umin_shl_vector(
; CHECK-SAME: <2 x i32> [[BASE:%.*]], <2 x i32> [[X:%.*]], <2 x i32> [[Y:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = call <2 x i32> @llvm.umin.v2i32(<2 x i32> [[X]], <2 x i32> [[Y]])
; CHECK-NEXT: [[MIN:%.*]] = shl nuw <2 x i32> [[BASE]], [[TMP1]]
; CHECK-NEXT: ret <2 x i32> [[MIN]]
;
%shl_x = shl nuw <2 x i32> %base, %x
%shl_y = shl nuw <2 x i32> %base, %y
%min = call <2 x i32> @llvm.umin.v2i32(<2 x i32> %shl_x, <2 x i32> %shl_y)
ret <2 x i32> %min
}

define <2 x i32> @test_umax_shl_vector_splat(<2 x i32> %x, <2 x i32> %y) {
; CHECK-LABEL: define <2 x i32> @test_umax_shl_vector_splat(
; CHECK-SAME: <2 x i32> [[X:%.*]], <2 x i32> [[Y:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = call <2 x i32> @llvm.umax.v2i32(<2 x i32> [[X]], <2 x i32> [[Y]])
; CHECK-NEXT: [[MAX:%.*]] = shl nuw <2 x i32> splat (i32 1), [[TMP1]]
; CHECK-NEXT: ret <2 x i32> [[MAX]]
;
%shl_x = shl nuw <2 x i32> <i32 1, i32 1>, %x
%shl_y = shl nuw <2 x i32> <i32 1, i32 1>, %y
%max = call <2 x i32> @llvm.umax.v2i32(<2 x i32> %shl_x, <2 x i32> %shl_y)
ret <2 x i32> %max
}

define <2 x i32> @test_umin_shl_vector_splat(<2 x i32> %x, <2 x i32> %y) {
; CHECK-LABEL: define <2 x i32> @test_umin_shl_vector_splat(
; CHECK-SAME: <2 x i32> [[X:%.*]], <2 x i32> [[Y:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = call <2 x i32> @llvm.umin.v2i32(<2 x i32> [[X]], <2 x i32> [[Y]])
; CHECK-NEXT: [[MIN:%.*]] = shl nuw <2 x i32> splat (i32 1), [[TMP1]]
; CHECK-NEXT: ret <2 x i32> [[MIN]]
;
%shl_x = shl nuw <2 x i32> <i32 1, i32 1>, %x
%shl_y = shl nuw <2 x i32> <i32 1, i32 1>, %y
%min = call <2 x i32> @llvm.umin.v2i32(<2 x i32> %shl_x, <2 x i32> %shl_y)
ret <2 x i32> %min
}

define <2 x i32> @test_umax_shl_vector_splat_poison(<2 x i32> %x, <2 x i32> %y) {
; CHECK-LABEL: define <2 x i32> @test_umax_shl_vector_splat_poison(
; CHECK-SAME: <2 x i32> [[X:%.*]], <2 x i32> [[Y:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = call <2 x i32> @llvm.umax.v2i32(<2 x i32> [[X]], <2 x i32> [[Y]])
; CHECK-NEXT: [[MAX:%.*]] = shl nuw <2 x i32> <i32 1, i32 poison>, [[TMP1]]
; CHECK-NEXT: ret <2 x i32> [[MAX]]
;
%shl_x = shl nuw <2 x i32> <i32 1, i32 poison>, %x
%shl_y = shl nuw <2 x i32> <i32 1, i32 poison>, %y
%max = call <2 x i32> @llvm.umax.v2i32(<2 x i32> %shl_x, <2 x i32> %shl_y)
ret <2 x i32> %max
}

define <2 x i32> @test_umin_shl_vector_splat_poison(<2 x i32> %x, <2 x i32> %y) {
; CHECK-LABEL: define <2 x i32> @test_umin_shl_vector_splat_poison(
; CHECK-SAME: <2 x i32> [[X:%.*]], <2 x i32> [[Y:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = call <2 x i32> @llvm.umin.v2i32(<2 x i32> [[X]], <2 x i32> [[Y]])
; CHECK-NEXT: [[MIN:%.*]] = shl nuw <2 x i32> <i32 1, i32 poison>, [[TMP1]]
; CHECK-NEXT: ret <2 x i32> [[MIN]]
;
%shl_x = shl nuw <2 x i32> <i32 1, i32 poison>, %x
%shl_y = shl nuw <2 x i32> <i32 1, i32 poison>, %y
%min = call <2 x i32> @llvm.umin.v2i32(<2 x i32> %shl_x, <2 x i32> %shl_y)
ret <2 x i32> %min
}

define <2 x i32> @test_umax_shl_vector_non_splat(<2 x i32> %x, <2 x i32> %y) {
; CHECK-LABEL: define <2 x i32> @test_umax_shl_vector_non_splat(
; CHECK-SAME: <2 x i32> [[X:%.*]], <2 x i32> [[Y:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = call <2 x i32> @llvm.umax.v2i32(<2 x i32> [[X]], <2 x i32> [[Y]])
; CHECK-NEXT: [[MAX:%.*]] = shl nuw <2 x i32> <i32 1, i32 2>, [[TMP1]]
; CHECK-NEXT: ret <2 x i32> [[MAX]]
;
%shl_x = shl nuw <2 x i32> <i32 1, i32 2>, %x
%shl_y = shl nuw <2 x i32> <i32 1, i32 2>, %y
%max = call <2 x i32> @llvm.umax.v2i32(<2 x i32> %shl_x, <2 x i32> %shl_y)
ret <2 x i32> %max
}

define <2 x i32> @test_umin_shl_vector_non_splat(<2 x i32> %x, <2 x i32> %y) {
; CHECK-LABEL: define <2 x i32> @test_umin_shl_vector_non_splat(
; CHECK-SAME: <2 x i32> [[X:%.*]], <2 x i32> [[Y:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = call <2 x i32> @llvm.umin.v2i32(<2 x i32> [[X]], <2 x i32> [[Y]])
; CHECK-NEXT: [[MIN:%.*]] = shl nuw <2 x i32> <i32 1, i32 2>, [[TMP1]]
; CHECK-NEXT: ret <2 x i32> [[MIN]]
;
%shl_x = shl nuw <2 x i32> <i32 1, i32 2>, %x
%shl_y = shl nuw <2 x i32> <i32 1, i32 2>, %y
%min = call <2 x i32> @llvm.umin.v2i32(<2 x i32> %shl_x, <2 x i32> %shl_y)
ret <2 x i32> %min
}

define i32 @test_umax_shl_different_base(i32 %base1, i32 %base2, i32 %x, i32 %y) {
; CHECK-LABEL: define i32 @test_umax_shl_different_base(
; CHECK-SAME: i32 [[BASE1:%.*]], i32 [[BASE2:%.*]], i32 [[X:%.*]], i32 [[Y:%.*]]) {
; CHECK-NEXT: [[SHL_X:%.*]] = shl nuw i32 [[BASE1]], [[X]]
; CHECK-NEXT: [[SHL_Y:%.*]] = shl nuw i32 [[BASE2]], [[Y]]
; CHECK-NEXT: [[MAX:%.*]] = call i32 @llvm.umax.i32(i32 [[SHL_X]], i32 [[SHL_Y]])
; CHECK-NEXT: ret i32 [[MAX]]
;
%shl_x = shl nuw i32 %base1, %x
%shl_y = shl nuw i32 %base2, %y
%max = call i32 @llvm.umax.i32(i32 %shl_x, i32 %shl_y)
ret i32 %max
}

define i32 @test_umin_shl_different_base(i32 %base1, i32 %base2, i32 %x, i32 %y) {
; CHECK-LABEL: define i32 @test_umin_shl_different_base(
; CHECK-SAME: i32 [[BASE1:%.*]], i32 [[BASE2:%.*]], i32 [[X:%.*]], i32 [[Y:%.*]]) {
; CHECK-NEXT: [[SHL_X:%.*]] = shl nuw i32 [[BASE1]], [[X]]
; CHECK-NEXT: [[SHL_Y:%.*]] = shl nuw i32 [[BASE2]], [[Y]]
; CHECK-NEXT: [[MIN:%.*]] = call i32 @llvm.umin.i32(i32 [[SHL_X]], i32 [[SHL_Y]])
; CHECK-NEXT: ret i32 [[MIN]]
;
%shl_x = shl nuw i32 %base1, %x
%shl_y = shl nuw i32 %base2, %y
%min = call i32 @llvm.umin.i32(i32 %shl_x, i32 %shl_y)
ret i32 %min
}

define i32 @test_umax_shl_no_nuw_flag(i32 %x, i32 %y) {
; CHECK-LABEL: define i32 @test_umax_shl_no_nuw_flag(
; CHECK-SAME: i32 [[X:%.*]], i32 [[Y:%.*]]) {
; CHECK-NEXT: [[SHL_X:%.*]] = shl i32 2, [[X]]
; CHECK-NEXT: [[SHL_Y:%.*]] = shl i32 2, [[Y]]
; CHECK-NEXT: [[MAX:%.*]] = call i32 @llvm.umax.i32(i32 [[SHL_X]], i32 [[SHL_Y]])
; CHECK-NEXT: ret i32 [[MAX]]
;
%shl_x = shl i32 2, %x
%shl_y = shl i32 2, %y
%max = call i32 @llvm.umax.i32(i32 %shl_x, i32 %shl_y)
ret i32 %max
}

define i32 @test_umin_shl_no_nuw_flag(i32 %x, i32 %y) {
; CHECK-LABEL: define i32 @test_umin_shl_no_nuw_flag(
; CHECK-SAME: i32 [[X:%.*]], i32 [[Y:%.*]]) {
; CHECK-NEXT: [[SHL_X:%.*]] = shl i32 2, [[X]]
; CHECK-NEXT: [[SHL_Y:%.*]] = shl i32 2, [[Y]]
; CHECK-NEXT: [[MIN:%.*]] = call i32 @llvm.umin.i32(i32 [[SHL_X]], i32 [[SHL_Y]])
; CHECK-NEXT: ret i32 [[MIN]]
;
%shl_x = shl i32 2, %x
%shl_y = shl i32 2, %y
%min = call i32 @llvm.umin.i32(i32 %shl_x, i32 %shl_y)
ret i32 %min
}
Loading