[llvm] [ValueTracking] Add support for overflow detection functions is `isKnownNonZero` (PR #87701)
via llvm-commits
llvm-commits at lists.llvm.org
Tue Apr 9 22:20:50 PDT 2024
https://github.com/goldsteinn updated https://github.com/llvm/llvm-project/pull/87701
>From 4ac637d189f477e7a410be65e705add1fa14f620 Mon Sep 17 00:00:00 2001
From: Noah Goldstein <goldstein.w.n at gmail.com>
Date: Wed, 3 Apr 2024 21:36:35 -0500
Subject: [PATCH 1/3] [ValueTracking] Add tests for overflow detection
functions is `isKnownNonZero`; NFC
---
.../test/Transforms/InstCombine/known-bits.ll | 381 ++++++++++++++++++
1 file changed, 381 insertions(+)
diff --git a/llvm/test/Transforms/InstCombine/known-bits.ll b/llvm/test/Transforms/InstCombine/known-bits.ll
index 769f7661fc8dc0..ddd5970ccabdb8 100644
--- a/llvm/test/Transforms/InstCombine/known-bits.ll
+++ b/llvm/test/Transforms/InstCombine/known-bits.ll
@@ -630,5 +630,386 @@ define i8 @or_ne_bits_must_be_unset2_fail(i8 %x, i8 %y) {
ret i8 %r
}
+declare void @use.i1(i1)
+declare void @use.i8(i8)
+
+declare void @use.2xi1(<2 x i1>)
+
+define i1 @extract_value_uadd(<2 x i8> %xx, <2 x i8> %yy) {
+; CHECK-LABEL: @extract_value_uadd(
+; CHECK-NEXT: [[X0:%.*]] = and <2 x i8> [[XX:%.*]], <i8 63, i8 -1>
+; CHECK-NEXT: [[Y0:%.*]] = and <2 x i8> [[YY:%.*]], <i8 63, i8 -1>
+; CHECK-NEXT: [[X:%.*]] = add nuw <2 x i8> [[X0]], <i8 1, i8 0>
+; CHECK-NEXT: [[Y:%.*]] = add nuw <2 x i8> [[Y0]], <i8 1, i8 0>
+; CHECK-NEXT: [[ADD_UOV:%.*]] = call { <2 x i8>, <2 x i1> } @llvm.uadd.with.overflow.v2i8(<2 x i8> [[X]], <2 x i8> [[Y]])
+; CHECK-NEXT: [[ADD:%.*]] = extractvalue { <2 x i8>, <2 x i1> } [[ADD_UOV]], 0
+; CHECK-NEXT: [[UOV:%.*]] = extractvalue { <2 x i8>, <2 x i1> } [[ADD_UOV]], 1
+; CHECK-NEXT: call void @use.2xi1(<2 x i1> [[UOV]])
+; CHECK-NEXT: [[ADD_ELE:%.*]] = extractelement <2 x i8> [[ADD]], i64 0
+; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[ADD_ELE]], 0
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %x0 = and <2 x i8> %xx, <i8 63, i8 255>
+ %y0 = and <2 x i8> %yy, <i8 63, i8 255>
+ %x = add nuw <2 x i8> %x0, <i8 1, i8 0>
+ %y = add nuw <2 x i8> %y0, <i8 1, i8 0>
+
+ %add_uov = call { <2 x i8>, <2 x i1> } @llvm.uadd.with.overflow(<2 x i8> %x, <2 x i8> %y)
+ %add = extractvalue { <2 x i8>, <2 x i1> } %add_uov, 0
+ %uov = extractvalue { <2 x i8>, <2 x i1> } %add_uov, 1
+ call void @use.2xi1(<2 x i1> %uov)
+ %add_ele = extractelement <2 x i8> %add, i32 0
+ %r = icmp eq i8 %add_ele, 0
+ ret i1 %r
+}
+
+define i1 @extract_value_uadd2(<2 x i8> %xx, <2 x i8> %yy) {
+; CHECK-LABEL: @extract_value_uadd2(
+; CHECK-NEXT: [[X0:%.*]] = and <2 x i8> [[XX:%.*]], <i8 -1, i8 63>
+; CHECK-NEXT: [[Y0:%.*]] = and <2 x i8> [[YY:%.*]], <i8 -1, i8 63>
+; CHECK-NEXT: [[X:%.*]] = add nuw <2 x i8> [[X0]], <i8 0, i8 1>
+; CHECK-NEXT: [[Y:%.*]] = add nuw <2 x i8> [[Y0]], <i8 0, i8 1>
+; CHECK-NEXT: [[ADD_UOV:%.*]] = call { <2 x i8>, <2 x i1> } @llvm.uadd.with.overflow.v2i8(<2 x i8> [[X]], <2 x i8> [[Y]])
+; CHECK-NEXT: [[ADD:%.*]] = extractvalue { <2 x i8>, <2 x i1> } [[ADD_UOV]], 0
+; CHECK-NEXT: [[UOV:%.*]] = extractvalue { <2 x i8>, <2 x i1> } [[ADD_UOV]], 1
+; CHECK-NEXT: call void @use.2xi1(<2 x i1> [[UOV]])
+; CHECK-NEXT: [[ADD_ELE:%.*]] = extractelement <2 x i8> [[ADD]], i64 1
+; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[ADD_ELE]], 0
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %x0 = and <2 x i8> %xx, <i8 255, i8 63>
+ %y0 = and <2 x i8> %yy, <i8 255, i8 63>
+ %x = add nuw <2 x i8> %x0, <i8 0, i8 1>
+ %y = add nuw <2 x i8> %y0, <i8 0, i8 1>
+
+ %add_uov = call { <2 x i8>, <2 x i1> } @llvm.uadd.with.overflow(<2 x i8> %x, <2 x i8> %y)
+ %add = extractvalue { <2 x i8>, <2 x i1> } %add_uov, 0
+ %uov = extractvalue { <2 x i8>, <2 x i1> } %add_uov, 1
+ call void @use.2xi1(<2 x i1> %uov)
+ %add_ele = extractelement <2 x i8> %add, i32 1
+ %r = icmp eq i8 %add_ele, 0
+ ret i1 %r
+}
+
+define i1 @extract_value_uadd_fail(<2 x i8> %xx, <2 x i8> %yy) {
+; CHECK-LABEL: @extract_value_uadd_fail(
+; CHECK-NEXT: [[X0:%.*]] = and <2 x i8> [[XX:%.*]], <i8 63, i8 -1>
+; CHECK-NEXT: [[Y0:%.*]] = and <2 x i8> [[YY:%.*]], <i8 63, i8 -1>
+; CHECK-NEXT: [[X:%.*]] = add nuw <2 x i8> [[X0]], <i8 1, i8 0>
+; CHECK-NEXT: [[Y:%.*]] = add nuw <2 x i8> [[Y0]], <i8 1, i8 0>
+; CHECK-NEXT: [[ADD_UOV:%.*]] = call { <2 x i8>, <2 x i1> } @llvm.uadd.with.overflow.v2i8(<2 x i8> [[X]], <2 x i8> [[Y]])
+; CHECK-NEXT: [[ADD:%.*]] = extractvalue { <2 x i8>, <2 x i1> } [[ADD_UOV]], 0
+; CHECK-NEXT: [[UOV:%.*]] = extractvalue { <2 x i8>, <2 x i1> } [[ADD_UOV]], 1
+; CHECK-NEXT: call void @use.2xi1(<2 x i1> [[UOV]])
+; CHECK-NEXT: [[ADD_ELE:%.*]] = extractelement <2 x i8> [[ADD]], i64 1
+; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[ADD_ELE]], 0
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %x0 = and <2 x i8> %xx, <i8 63, i8 255>
+ %y0 = and <2 x i8> %yy, <i8 63, i8 255>
+ %x = add nuw <2 x i8> %x0, <i8 1, i8 0>
+ %y = add nuw <2 x i8> %y0, <i8 1, i8 0>
+
+ %add_uov = call { <2 x i8>, <2 x i1> } @llvm.uadd.with.overflow(<2 x i8> %x, <2 x i8> %y)
+ %add = extractvalue { <2 x i8>, <2 x i1> } %add_uov, 0
+ %uov = extractvalue { <2 x i8>, <2 x i1> } %add_uov, 1
+ call void @use.2xi1(<2 x i1> %uov)
+ %add_ele = extractelement <2 x i8> %add, i32 1
+ %r = icmp eq i8 %add_ele, 0
+ ret i1 %r
+}
+
+define i1 @extract_value_uadd_fail2(<2 x i8> %xx, <2 x i8> %yy, i32 %idx) {
+; CHECK-LABEL: @extract_value_uadd_fail2(
+; CHECK-NEXT: [[X0:%.*]] = and <2 x i8> [[XX:%.*]], <i8 63, i8 -1>
+; CHECK-NEXT: [[Y0:%.*]] = and <2 x i8> [[YY:%.*]], <i8 63, i8 -1>
+; CHECK-NEXT: [[X:%.*]] = add nuw <2 x i8> [[X0]], <i8 1, i8 0>
+; CHECK-NEXT: [[Y:%.*]] = add nuw <2 x i8> [[Y0]], <i8 1, i8 0>
+; CHECK-NEXT: [[ADD_UOV:%.*]] = call { <2 x i8>, <2 x i1> } @llvm.uadd.with.overflow.v2i8(<2 x i8> [[X]], <2 x i8> [[Y]])
+; CHECK-NEXT: [[ADD:%.*]] = extractvalue { <2 x i8>, <2 x i1> } [[ADD_UOV]], 0
+; CHECK-NEXT: [[UOV:%.*]] = extractvalue { <2 x i8>, <2 x i1> } [[ADD_UOV]], 1
+; CHECK-NEXT: call void @use.2xi1(<2 x i1> [[UOV]])
+; CHECK-NEXT: [[ADD_ELE:%.*]] = extractelement <2 x i8> [[ADD]], i32 [[IDX:%.*]]
+; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[ADD_ELE]], 0
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %x0 = and <2 x i8> %xx, <i8 63, i8 255>
+ %y0 = and <2 x i8> %yy, <i8 63, i8 255>
+ %x = add nuw <2 x i8> %x0, <i8 1, i8 0>
+ %y = add nuw <2 x i8> %y0, <i8 1, i8 0>
+
+ %add_uov = call { <2 x i8>, <2 x i1> } @llvm.uadd.with.overflow(<2 x i8> %x, <2 x i8> %y)
+ %add = extractvalue { <2 x i8>, <2 x i1> } %add_uov, 0
+ %uov = extractvalue { <2 x i8>, <2 x i1> } %add_uov, 1
+ call void @use.2xi1(<2 x i1> %uov)
+ %add_ele = extractelement <2 x i8> %add, i32 %idx
+ %r = icmp eq i8 %add_ele, 0
+ ret i1 %r
+}
+
+define i1 @extract_value_uadd_fail3(<2 x i8> %xx, <2 x i8> %yy) {
+; CHECK-LABEL: @extract_value_uadd_fail3(
+; CHECK-NEXT: [[X0:%.*]] = and <2 x i8> [[XX:%.*]], <i8 127, i8 127>
+; CHECK-NEXT: [[Y0:%.*]] = and <2 x i8> [[YY:%.*]], <i8 127, i8 127>
+; CHECK-NEXT: [[X:%.*]] = add nuw <2 x i8> [[X0]], <i8 1, i8 1>
+; CHECK-NEXT: [[Y:%.*]] = add nuw <2 x i8> [[Y0]], <i8 1, i8 1>
+; CHECK-NEXT: [[ADD_UOV:%.*]] = call { <2 x i8>, <2 x i1> } @llvm.uadd.with.overflow.v2i8(<2 x i8> [[X]], <2 x i8> [[Y]])
+; CHECK-NEXT: [[ADD:%.*]] = extractvalue { <2 x i8>, <2 x i1> } [[ADD_UOV]], 0
+; CHECK-NEXT: [[UOV:%.*]] = extractvalue { <2 x i8>, <2 x i1> } [[ADD_UOV]], 1
+; CHECK-NEXT: call void @use.2xi1(<2 x i1> [[UOV]])
+; CHECK-NEXT: [[ADD_ELE:%.*]] = extractelement <2 x i8> [[ADD]], i64 0
+; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[ADD_ELE]], 0
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %x0 = and <2 x i8> %xx, <i8 127, i8 127>
+ %y0 = and <2 x i8> %yy, <i8 127, i8 127>
+ %x = add nuw <2 x i8> %x0, <i8 1, i8 1>
+ %y = add nuw <2 x i8> %y0, <i8 1, i8 1>
+
+ %add_uov = call { <2 x i8>, <2 x i1> } @llvm.uadd.with.overflow(<2 x i8> %x, <2 x i8> %y)
+ %add = extractvalue { <2 x i8>, <2 x i1> } %add_uov, 0
+ %uov = extractvalue { <2 x i8>, <2 x i1> } %add_uov, 1
+ call void @use.2xi1(<2 x i1> %uov)
+ %add_ele = extractelement <2 x i8> %add, i32 0
+ %r = icmp eq i8 %add_ele, 0
+ ret i1 %r
+}
+
+define i1 @extract_value_sadd(i8 %xx, i8 %yy) {
+; CHECK-LABEL: @extract_value_sadd(
+; CHECK-NEXT: [[X:%.*]] = add nuw i8 [[XX:%.*]], 1
+; CHECK-NEXT: [[Y:%.*]] = add nuw i8 [[YY:%.*]], 1
+; CHECK-NEXT: [[X_LEMMA:%.*]] = icmp sgt i8 [[X]], -1
+; CHECK-NEXT: [[Y_LEMMA:%.*]] = icmp sgt i8 [[Y]], -1
+; CHECK-NEXT: call void @llvm.assume(i1 [[X_LEMMA]])
+; CHECK-NEXT: call void @llvm.assume(i1 [[Y_LEMMA]])
+; CHECK-NEXT: [[ADD_SOV:%.*]] = call { i8, i1 } @llvm.sadd.with.overflow.i8(i8 [[X]], i8 [[Y]])
+; CHECK-NEXT: [[ADD:%.*]] = extractvalue { i8, i1 } [[ADD_SOV]], 0
+; CHECK-NEXT: [[SOV:%.*]] = extractvalue { i8, i1 } [[ADD_SOV]], 1
+; CHECK-NEXT: call void @use.i1(i1 [[SOV]])
+; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[ADD]], 0
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %x = add nuw i8 %xx, 1
+ %y = add nuw i8 %yy, 1
+ %x_lemma = icmp ult i8 %x, 128
+ %y_lemma = icmp ult i8 %y, 128
+ call void @llvm.assume(i1 %x_lemma)
+ call void @llvm.assume(i1 %y_lemma)
+
+ %add_sov = call { i8, i1 } @llvm.sadd.with.overflow(i8 %x, i8 %y)
+ %add = extractvalue { i8, i1 } %add_sov, 0
+ %sov = extractvalue { i8, i1 } %add_sov, 1
+ call void @use.i1(i1 %sov)
+ %r = icmp eq i8 %add, 0
+ ret i1 %r
+}
+
+define i1 @extract_value_sadd_fail(i8 %xx, i8 %yy) {
+; CHECK-LABEL: @extract_value_sadd_fail(
+; CHECK-NEXT: [[X:%.*]] = add i8 [[XX:%.*]], 1
+; CHECK-NEXT: [[Y:%.*]] = add i8 [[YY:%.*]], 1
+; CHECK-NEXT: [[ADD_SOV:%.*]] = call { i8, i1 } @llvm.sadd.with.overflow.i8(i8 [[X]], i8 [[Y]])
+; CHECK-NEXT: [[ADD:%.*]] = extractvalue { i8, i1 } [[ADD_SOV]], 0
+; CHECK-NEXT: [[SOV:%.*]] = extractvalue { i8, i1 } [[ADD_SOV]], 1
+; CHECK-NEXT: call void @use.i1(i1 [[SOV]])
+; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[ADD]], 0
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %x = add i8 %xx, 1
+ %y = add i8 %yy, 1
+
+ %add_sov = call { i8, i1 } @llvm.sadd.with.overflow(i8 %x, i8 %y)
+ %add = extractvalue { i8, i1 } %add_sov, 0
+ %sov = extractvalue { i8, i1 } %add_sov, 1
+ call void @use.i1(i1 %sov)
+ %r = icmp eq i8 %add, 0
+ ret i1 %r
+}
+
+define i1 @extract_value_usub(i8 %x, i8 %zz) {
+; CHECK-LABEL: @extract_value_usub(
+; CHECK-NEXT: [[Z:%.*]] = add nuw i8 [[ZZ:%.*]], 1
+; CHECK-NEXT: [[Y:%.*]] = add i8 [[Z]], [[X:%.*]]
+; CHECK-NEXT: [[SUB_UOV:%.*]] = call { i8, i1 } @llvm.usub.with.overflow.i8(i8 [[X]], i8 [[Y]])
+; CHECK-NEXT: [[SUB:%.*]] = extractvalue { i8, i1 } [[SUB_UOV]], 0
+; CHECK-NEXT: [[UOV:%.*]] = extractvalue { i8, i1 } [[SUB_UOV]], 1
+; CHECK-NEXT: call void @use.i1(i1 [[UOV]])
+; CHECK-NEXT: call void @use.i8(i8 [[SUB]])
+; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[SUB]], 0
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %z = add nuw i8 %zz, 1
+ %y = add i8 %x, %z
+
+ %sub_uov = call { i8, i1 } @llvm.usub.with.overflow(i8 %x, i8 %y)
+ %sub = extractvalue { i8, i1 } %sub_uov, 0
+ %uov = extractvalue { i8, i1 } %sub_uov, 1
+ call void @use.i1(i1 %uov)
+ call void @use.i8(i8 %sub)
+ %r = icmp eq i8 %sub, 0
+ ret i1 %r
+}
+
+define i1 @extract_value_usub_fail(i8 %x, i8 %z) {
+; CHECK-LABEL: @extract_value_usub_fail(
+; CHECK-NEXT: [[Y:%.*]] = add i8 [[X:%.*]], [[Z:%.*]]
+; CHECK-NEXT: [[SUB_UOV:%.*]] = call { i8, i1 } @llvm.usub.with.overflow.i8(i8 [[X]], i8 [[Y]])
+; CHECK-NEXT: [[SUB:%.*]] = extractvalue { i8, i1 } [[SUB_UOV]], 0
+; CHECK-NEXT: [[UOV:%.*]] = extractvalue { i8, i1 } [[SUB_UOV]], 1
+; CHECK-NEXT: call void @use.i1(i1 [[UOV]])
+; CHECK-NEXT: call void @use.i8(i8 [[SUB]])
+; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[SUB]], 0
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %y = add i8 %x, %z
+ %sub_uov = call { i8, i1 } @llvm.usub.with.overflow(i8 %x, i8 %y)
+ %sub = extractvalue { i8, i1 } %sub_uov, 0
+ %uov = extractvalue { i8, i1 } %sub_uov, 1
+ call void @use.i1(i1 %uov)
+ call void @use.i8(i8 %sub)
+ %r = icmp eq i8 %sub, 0
+ ret i1 %r
+}
+
+define i1 @extract_value_ssub(i8 %x, i8 %zz) {
+; CHECK-LABEL: @extract_value_ssub(
+; CHECK-NEXT: [[Z:%.*]] = add nuw i8 [[ZZ:%.*]], 1
+; CHECK-NEXT: [[Y:%.*]] = add i8 [[Z]], [[X:%.*]]
+; CHECK-NEXT: [[SUB_SOV:%.*]] = call { i8, i1 } @llvm.ssub.with.overflow.i8(i8 [[Y]], i8 [[X]])
+; CHECK-NEXT: [[SUB:%.*]] = extractvalue { i8, i1 } [[SUB_SOV]], 0
+; CHECK-NEXT: [[SOV:%.*]] = extractvalue { i8, i1 } [[SUB_SOV]], 1
+; CHECK-NEXT: call void @use.i1(i1 [[SOV]])
+; CHECK-NEXT: call void @use.i8(i8 [[SUB]])
+; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[SUB]], 0
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %z = add nuw i8 %zz, 1
+ %y = add i8 %x, %z
+
+ %sub_sov = call { i8, i1 } @llvm.ssub.with.overflow(i8 %y, i8 %x)
+ %sub = extractvalue { i8, i1 } %sub_sov, 0
+ %sov = extractvalue { i8, i1 } %sub_sov, 1
+ call void @use.i1(i1 %sov)
+ call void @use.i8(i8 %sub)
+ %r = icmp eq i8 %sub, 0
+ ret i1 %r
+}
+
+define i1 @extract_value_ssub_fail(i8 %x) {
+; CHECK-LABEL: @extract_value_ssub_fail(
+; CHECK-NEXT: [[SUB_SOV:%.*]] = call { i8, i1 } @llvm.ssub.with.overflow.i8(i8 10, i8 [[X:%.*]])
+; CHECK-NEXT: [[SUB:%.*]] = extractvalue { i8, i1 } [[SUB_SOV]], 0
+; CHECK-NEXT: [[SOV:%.*]] = extractvalue { i8, i1 } [[SUB_SOV]], 1
+; CHECK-NEXT: call void @use.i1(i1 [[SOV]])
+; CHECK-NEXT: call void @use.i8(i8 [[SUB]])
+; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[SUB]], 0
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %sub_sov = call { i8, i1 } @llvm.ssub.with.overflow(i8 10, i8 %x)
+ %sub = extractvalue { i8, i1 } %sub_sov, 0
+ %sov = extractvalue { i8, i1 } %sub_sov, 1
+ call void @use.i1(i1 %sov)
+ call void @use.i8(i8 %sub)
+ %r = icmp eq i8 %sub, 0
+ ret i1 %r
+}
+
+define i1 @extract_value_umul(i8 %xx, i8 %yy) {
+; CHECK-LABEL: @extract_value_umul(
+; CHECK-NEXT: [[X:%.*]] = or i8 [[XX:%.*]], 1
+; CHECK-NEXT: [[Y:%.*]] = add nuw i8 [[YY:%.*]], 1
+; CHECK-NEXT: [[MUL_UOV:%.*]] = call { i8, i1 } @llvm.umul.with.overflow.i8(i8 [[X]], i8 [[Y]])
+; CHECK-NEXT: [[MUL:%.*]] = extractvalue { i8, i1 } [[MUL_UOV]], 0
+; CHECK-NEXT: [[UOV:%.*]] = extractvalue { i8, i1 } [[MUL_UOV]], 1
+; CHECK-NEXT: call void @use.i1(i1 [[UOV]])
+; CHECK-NEXT: call void @use.i8(i8 [[MUL]])
+; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[MUL]], 0
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %x = or i8 %xx, 1
+ %y = add nuw i8 %yy, 1
+
+ %mul_uov = call { i8, i1 } @llvm.umul.with.overflow(i8 %x, i8 %y)
+ %mul = extractvalue { i8, i1 } %mul_uov, 0
+ %uov = extractvalue { i8, i1 } %mul_uov, 1
+ call void @use.i1(i1 %uov)
+ call void @use.i8(i8 %mul)
+ %r = icmp eq i8 %mul, 0
+ ret i1 %r
+}
+
+define i1 @extract_value_umul_fail(i8 %xx, i8 %yy) {
+; CHECK-LABEL: @extract_value_umul_fail(
+; CHECK-NEXT: [[X:%.*]] = or i8 [[XX:%.*]], 2
+; CHECK-NEXT: [[Y:%.*]] = add nuw i8 [[YY:%.*]], 1
+; CHECK-NEXT: [[MUL_UOV:%.*]] = call { i8, i1 } @llvm.umul.with.overflow.i8(i8 [[X]], i8 [[Y]])
+; CHECK-NEXT: [[MUL:%.*]] = extractvalue { i8, i1 } [[MUL_UOV]], 0
+; CHECK-NEXT: [[UOV:%.*]] = extractvalue { i8, i1 } [[MUL_UOV]], 1
+; CHECK-NEXT: call void @use.i1(i1 [[UOV]])
+; CHECK-NEXT: call void @use.i8(i8 [[MUL]])
+; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[MUL]], 0
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %x = or i8 %xx, 2
+ %y = add nuw i8 %yy, 1
+
+ %mul_uov = call { i8, i1 } @llvm.umul.with.overflow(i8 %x, i8 %y)
+ %mul = extractvalue { i8, i1 } %mul_uov, 0
+ %uov = extractvalue { i8, i1 } %mul_uov, 1
+ call void @use.i1(i1 %uov)
+ call void @use.i8(i8 %mul)
+ %r = icmp eq i8 %mul, 0
+ ret i1 %r
+}
+
+define i1 @extract_value_smul(i8 %xx, i8 %yy) {
+; CHECK-LABEL: @extract_value_smul(
+; CHECK-NEXT: [[X:%.*]] = or i8 [[XX:%.*]], 1
+; CHECK-NEXT: [[Y:%.*]] = add nuw i8 [[YY:%.*]], 1
+; CHECK-NEXT: [[MUL_SOV:%.*]] = call { i8, i1 } @llvm.smul.with.overflow.i8(i8 [[Y]], i8 [[X]])
+; CHECK-NEXT: [[MUL:%.*]] = extractvalue { i8, i1 } [[MUL_SOV]], 0
+; CHECK-NEXT: [[SOV:%.*]] = extractvalue { i8, i1 } [[MUL_SOV]], 1
+; CHECK-NEXT: call void @use.i1(i1 [[SOV]])
+; CHECK-NEXT: call void @use.i8(i8 [[MUL]])
+; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[MUL]], 0
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %x = or i8 %xx, 1
+ %y = add nuw i8 %yy, 1
+
+ %mul_sov = call { i8, i1 } @llvm.smul.with.overflow(i8 %y, i8 %x)
+ %mul = extractvalue { i8, i1 } %mul_sov, 0
+ %sov = extractvalue { i8, i1 } %mul_sov, 1
+ call void @use.i1(i1 %sov)
+ call void @use.i8(i8 %mul)
+ %r = icmp eq i8 %mul, 0
+ ret i1 %r
+}
+
+define i1 @extract_value_smul_fail(i8 %xx, i8 %yy) {
+; CHECK-LABEL: @extract_value_smul_fail(
+; CHECK-NEXT: [[X:%.*]] = or i8 [[XX:%.*]], 1
+; CHECK-NEXT: [[Y:%.*]] = add i8 [[YY:%.*]], 1
+; CHECK-NEXT: [[MUL_SOV:%.*]] = call { i8, i1 } @llvm.smul.with.overflow.i8(i8 [[Y]], i8 [[X]])
+; CHECK-NEXT: [[MUL:%.*]] = extractvalue { i8, i1 } [[MUL_SOV]], 0
+; CHECK-NEXT: [[SOV:%.*]] = extractvalue { i8, i1 } [[MUL_SOV]], 1
+; CHECK-NEXT: call void @use.i1(i1 [[SOV]])
+; CHECK-NEXT: call void @use.i8(i8 [[MUL]])
+; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[MUL]], 0
+; CHECK-NEXT: ret i1 [[R]]
+;
+ %x = or i8 %xx, 1
+ %y = add i8 %yy, 1
+
+ %mul_sov = call { i8, i1 } @llvm.smul.with.overflow(i8 %y, i8 %x)
+ %mul = extractvalue { i8, i1 } %mul_sov, 0
+ %sov = extractvalue { i8, i1 } %mul_sov, 1
+ call void @use.i1(i1 %sov)
+ call void @use.i8(i8 %mul)
+ %r = icmp eq i8 %mul, 0
+ ret i1 %r
+}
+
declare void @use(i1)
declare void @sink(i8)
>From e5d45a5d00890dcdeea4731896f2215ed6cc93db Mon Sep 17 00:00:00 2001
From: Noah Goldstein <goldstein.w.n at gmail.com>
Date: Wed, 3 Apr 2024 15:33:18 -0500
Subject: [PATCH 2/3] [ValueTracking] Split `isNonZero(mul)` logic to a helper;
NFC
---
llvm/lib/Analysis/ValueTracking.cpp | 57 ++++++++++++++++-------------
1 file changed, 31 insertions(+), 26 deletions(-)
diff --git a/llvm/lib/Analysis/ValueTracking.cpp b/llvm/lib/Analysis/ValueTracking.cpp
index ca48cfe7738154..09fff83f7c30e4 100644
--- a/llvm/lib/Analysis/ValueTracking.cpp
+++ b/llvm/lib/Analysis/ValueTracking.cpp
@@ -2463,6 +2463,34 @@ static bool isNonZeroSub(const APInt &DemandedElts, unsigned Depth,
return ::isKnownNonEqual(X, Y, Depth, Q);
}
+static bool isNonZeroMul(const APInt &DemandedElts, unsigned Depth,
+ const SimplifyQuery &Q, unsigned BitWidth, Value *X,
+ Value *Y, bool NSW, bool NUW) {
+ // If X and Y are non-zero then so is X * Y as long as the multiplication
+ // does not overflow.
+ if (NSW || NUW)
+ return isKnownNonZero(X, DemandedElts, Depth, Q) &&
+ isKnownNonZero(Y, DemandedElts, Depth, Q);
+
+ // If either X or Y is odd, then if the other is non-zero the result can't
+ // be zero.
+ KnownBits XKnown = computeKnownBits(X, DemandedElts, Depth, Q);
+ if (XKnown.One[0])
+ return isKnownNonZero(Y, DemandedElts, Depth, Q);
+
+ KnownBits YKnown = computeKnownBits(Y, DemandedElts, Depth, Q);
+ if (YKnown.One[0])
+ return XKnown.isNonZero() || isKnownNonZero(X, DemandedElts, Depth, Q);
+
+ // If there exists any subset of X (sX) and subset of Y (sY) s.t sX * sY is
+ // non-zero, then X * Y is non-zero. We can find sX and sY by just taking
+ // the lowest known One of X and Y. If they are non-zero, the result
+ // must be non-zero. We can check if LSB(X) * LSB(Y) != 0 by doing
+ // X.CountLeadingZeros + Y.CountLeadingZeros < BitWidth.
+ return (XKnown.countMaxTrailingZeros() + YKnown.countMaxTrailingZeros()) <
+ BitWidth;
+}
+
static bool isNonZeroShift(const Operator *I, const APInt &DemandedElts,
unsigned Depth, const SimplifyQuery &Q,
const KnownBits &KnownVal) {
@@ -2658,33 +2686,10 @@ static bool isKnownNonZeroFromOperator(const Operator *I,
Q.IIQ.hasNoUnsignedWrap(BO));
}
case Instruction::Mul: {
- // If X and Y are non-zero then so is X * Y as long as the multiplication
- // does not overflow.
const OverflowingBinaryOperator *BO = cast<OverflowingBinaryOperator>(I);
- if (Q.IIQ.hasNoSignedWrap(BO) || Q.IIQ.hasNoUnsignedWrap(BO))
- return isKnownNonZero(I->getOperand(0), DemandedElts, Depth, Q) &&
- isKnownNonZero(I->getOperand(1), DemandedElts, Depth, Q);
-
- // If either X or Y is odd, then if the other is non-zero the result can't
- // be zero.
- KnownBits XKnown =
- computeKnownBits(I->getOperand(0), DemandedElts, Depth, Q);
- if (XKnown.One[0])
- return isKnownNonZero(I->getOperand(1), DemandedElts, Depth, Q);
-
- KnownBits YKnown =
- computeKnownBits(I->getOperand(1), DemandedElts, Depth, Q);
- if (YKnown.One[0])
- return XKnown.isNonZero() ||
- isKnownNonZero(I->getOperand(0), DemandedElts, Depth, Q);
-
- // If there exists any subset of X (sX) and subset of Y (sY) s.t sX * sY is
- // non-zero, then X * Y is non-zero. We can find sX and sY by just taking
- // the lowest known One of X and Y. If they are non-zero, the result
- // must be non-zero. We can check if LSB(X) * LSB(Y) != 0 by doing
- // X.CountLeadingZeros + Y.CountLeadingZeros < BitWidth.
- return (XKnown.countMaxTrailingZeros() + YKnown.countMaxTrailingZeros()) <
- BitWidth;
+ return isNonZeroMul(DemandedElts, Depth, Q, BitWidth, I->getOperand(0),
+ I->getOperand(1), Q.IIQ.hasNoSignedWrap(BO),
+ Q.IIQ.hasNoUnsignedWrap(BO));
}
case Instruction::Select: {
// (C ? X : Y) != 0 if X != 0 and Y != 0.
>From 22c90949b496b3fef96bfa0886a7dd8108c225df Mon Sep 17 00:00:00 2001
From: Noah Goldstein <goldstein.w.n at gmail.com>
Date: Wed, 3 Apr 2024 15:35:17 -0500
Subject: [PATCH 3/3] [ValueTracking] Add support for overflow detection
functions is `isKnownNonZero`
Adds support for: `{s,u}{add,sub,mul}.with.overflow`
The logic is identical to the the non-overflow binops, we where just
missing the cases.
---
llvm/lib/Analysis/ValueTracking.cpp | 23 ++++++++++++++++
.../test/Transforms/InstCombine/known-bits.ll | 26 +++++--------------
2 files changed, 30 insertions(+), 19 deletions(-)
diff --git a/llvm/lib/Analysis/ValueTracking.cpp b/llvm/lib/Analysis/ValueTracking.cpp
index 09fff83f7c30e4..ce7c414721b1b6 100644
--- a/llvm/lib/Analysis/ValueTracking.cpp
+++ b/llvm/lib/Analysis/ValueTracking.cpp
@@ -2790,6 +2790,29 @@ static bool isKnownNonZeroFromOperator(const Operator *I,
// handled in isKnownNonZero.
return false;
}
+ case Instruction::ExtractValue: {
+ const WithOverflowInst *WO;
+ if (match(I, m_ExtractValue<0>(m_WithOverflowInst(WO)))) {
+ switch (WO->getBinaryOp()) {
+ default:
+ break;
+ case Instruction::Add:
+ return isNonZeroAdd(DemandedElts, Depth, Q, BitWidth,
+ WO->getArgOperand(0), WO->getArgOperand(1),
+ /*NSW=*/false,
+ /*NUW=*/false);
+ case Instruction::Sub:
+ return isNonZeroSub(DemandedElts, Depth, Q, BitWidth,
+ WO->getArgOperand(0), WO->getArgOperand(1));
+ case Instruction::Mul:
+ return isNonZeroMul(DemandedElts, Depth, Q, BitWidth,
+ WO->getArgOperand(0), WO->getArgOperand(1),
+ /*NSW=*/false, /*NUW=*/false);
+ break;
+ }
+ }
+ break;
+ }
case Instruction::Call:
case Instruction::Invoke: {
const auto *Call = cast<CallBase>(I);
diff --git a/llvm/test/Transforms/InstCombine/known-bits.ll b/llvm/test/Transforms/InstCombine/known-bits.ll
index ddd5970ccabdb8..e27e4a3eddfbb1 100644
--- a/llvm/test/Transforms/InstCombine/known-bits.ll
+++ b/llvm/test/Transforms/InstCombine/known-bits.ll
@@ -642,12 +642,9 @@ define i1 @extract_value_uadd(<2 x i8> %xx, <2 x i8> %yy) {
; CHECK-NEXT: [[X:%.*]] = add nuw <2 x i8> [[X0]], <i8 1, i8 0>
; CHECK-NEXT: [[Y:%.*]] = add nuw <2 x i8> [[Y0]], <i8 1, i8 0>
; CHECK-NEXT: [[ADD_UOV:%.*]] = call { <2 x i8>, <2 x i1> } @llvm.uadd.with.overflow.v2i8(<2 x i8> [[X]], <2 x i8> [[Y]])
-; CHECK-NEXT: [[ADD:%.*]] = extractvalue { <2 x i8>, <2 x i1> } [[ADD_UOV]], 0
; CHECK-NEXT: [[UOV:%.*]] = extractvalue { <2 x i8>, <2 x i1> } [[ADD_UOV]], 1
; CHECK-NEXT: call void @use.2xi1(<2 x i1> [[UOV]])
-; CHECK-NEXT: [[ADD_ELE:%.*]] = extractelement <2 x i8> [[ADD]], i64 0
-; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[ADD_ELE]], 0
-; CHECK-NEXT: ret i1 [[R]]
+; CHECK-NEXT: ret i1 false
;
%x0 = and <2 x i8> %xx, <i8 63, i8 255>
%y0 = and <2 x i8> %yy, <i8 63, i8 255>
@@ -670,12 +667,9 @@ define i1 @extract_value_uadd2(<2 x i8> %xx, <2 x i8> %yy) {
; CHECK-NEXT: [[X:%.*]] = add nuw <2 x i8> [[X0]], <i8 0, i8 1>
; CHECK-NEXT: [[Y:%.*]] = add nuw <2 x i8> [[Y0]], <i8 0, i8 1>
; CHECK-NEXT: [[ADD_UOV:%.*]] = call { <2 x i8>, <2 x i1> } @llvm.uadd.with.overflow.v2i8(<2 x i8> [[X]], <2 x i8> [[Y]])
-; CHECK-NEXT: [[ADD:%.*]] = extractvalue { <2 x i8>, <2 x i1> } [[ADD_UOV]], 0
; CHECK-NEXT: [[UOV:%.*]] = extractvalue { <2 x i8>, <2 x i1> } [[ADD_UOV]], 1
; CHECK-NEXT: call void @use.2xi1(<2 x i1> [[UOV]])
-; CHECK-NEXT: [[ADD_ELE:%.*]] = extractelement <2 x i8> [[ADD]], i64 1
-; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[ADD_ELE]], 0
-; CHECK-NEXT: ret i1 [[R]]
+; CHECK-NEXT: ret i1 false
;
%x0 = and <2 x i8> %xx, <i8 255, i8 63>
%y0 = and <2 x i8> %yy, <i8 255, i8 63>
@@ -784,11 +778,9 @@ define i1 @extract_value_sadd(i8 %xx, i8 %yy) {
; CHECK-NEXT: call void @llvm.assume(i1 [[X_LEMMA]])
; CHECK-NEXT: call void @llvm.assume(i1 [[Y_LEMMA]])
; CHECK-NEXT: [[ADD_SOV:%.*]] = call { i8, i1 } @llvm.sadd.with.overflow.i8(i8 [[X]], i8 [[Y]])
-; CHECK-NEXT: [[ADD:%.*]] = extractvalue { i8, i1 } [[ADD_SOV]], 0
; CHECK-NEXT: [[SOV:%.*]] = extractvalue { i8, i1 } [[ADD_SOV]], 1
; CHECK-NEXT: call void @use.i1(i1 [[SOV]])
-; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[ADD]], 0
-; CHECK-NEXT: ret i1 [[R]]
+; CHECK-NEXT: ret i1 false
;
%x = add nuw i8 %xx, 1
%y = add nuw i8 %yy, 1
@@ -836,8 +828,7 @@ define i1 @extract_value_usub(i8 %x, i8 %zz) {
; CHECK-NEXT: [[UOV:%.*]] = extractvalue { i8, i1 } [[SUB_UOV]], 1
; CHECK-NEXT: call void @use.i1(i1 [[UOV]])
; CHECK-NEXT: call void @use.i8(i8 [[SUB]])
-; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[SUB]], 0
-; CHECK-NEXT: ret i1 [[R]]
+; CHECK-NEXT: ret i1 false
;
%z = add nuw i8 %zz, 1
%y = add i8 %x, %z
@@ -881,8 +872,7 @@ define i1 @extract_value_ssub(i8 %x, i8 %zz) {
; CHECK-NEXT: [[SOV:%.*]] = extractvalue { i8, i1 } [[SUB_SOV]], 1
; CHECK-NEXT: call void @use.i1(i1 [[SOV]])
; CHECK-NEXT: call void @use.i8(i8 [[SUB]])
-; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[SUB]], 0
-; CHECK-NEXT: ret i1 [[R]]
+; CHECK-NEXT: ret i1 false
;
%z = add nuw i8 %zz, 1
%y = add i8 %x, %z
@@ -924,8 +914,7 @@ define i1 @extract_value_umul(i8 %xx, i8 %yy) {
; CHECK-NEXT: [[UOV:%.*]] = extractvalue { i8, i1 } [[MUL_UOV]], 1
; CHECK-NEXT: call void @use.i1(i1 [[UOV]])
; CHECK-NEXT: call void @use.i8(i8 [[MUL]])
-; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[MUL]], 0
-; CHECK-NEXT: ret i1 [[R]]
+; CHECK-NEXT: ret i1 false
;
%x = or i8 %xx, 1
%y = add nuw i8 %yy, 1
@@ -972,8 +961,7 @@ define i1 @extract_value_smul(i8 %xx, i8 %yy) {
; CHECK-NEXT: [[SOV:%.*]] = extractvalue { i8, i1 } [[MUL_SOV]], 1
; CHECK-NEXT: call void @use.i1(i1 [[SOV]])
; CHECK-NEXT: call void @use.i8(i8 [[MUL]])
-; CHECK-NEXT: [[R:%.*]] = icmp eq i8 [[MUL]], 0
-; CHECK-NEXT: ret i1 [[R]]
+; CHECK-NEXT: ret i1 false
;
%x = or i8 %xx, 1
%y = add nuw i8 %yy, 1
More information about the llvm-commits
mailing list