[llvm] [InstSimplify] Fold the rest of trivially vectorizable intrinsics (PR #149243)
via llvm-commits
llvm-commits at lists.llvm.org
Wed Jul 16 20:56:53 PDT 2025
https://github.com/badumbatish created https://github.com/llvm/llvm-project/pull/149243
Fixes https://github.com/llvm/llvm-project/issues/146769
Test cases added to `llvm/test/Transforms/InstSimplify/fold-intrinsics.ll`
>From d42b25722c2bc34841893a523b7e654ee8f09494 Mon Sep 17 00:00:00 2001
From: Jasmine Tang <jjasmine at igalia.com>
Date: Wed, 16 Jul 2025 19:59:40 -0700
Subject: [PATCH 1/2] Precommit test for folding poison of trivially
vectorizable intrinsics
---
.../InstSimplify/fold-intrinsics.ll | 378 ++++++++++++++++++
1 file changed, 378 insertions(+)
diff --git a/llvm/test/Transforms/InstSimplify/fold-intrinsics.ll b/llvm/test/Transforms/InstSimplify/fold-intrinsics.ll
index e4cfa4673a979..5eba0d1b2f20d 100644
--- a/llvm/test/Transforms/InstSimplify/fold-intrinsics.ll
+++ b/llvm/test/Transforms/InstSimplify/fold-intrinsics.ll
@@ -286,3 +286,381 @@ define void @tanh_poison(ptr %P) {
ret void
}
+
+
+define void @exp_poison(ptr %P) {
+; CHECK-LABEL: @exp_poison(
+; CHECK-NEXT: [[EXP_F32:%.*]] = call float @llvm.exp.f32(float poison)
+; CHECK-NEXT: store volatile float [[EXP_F32]], ptr [[P:%.*]], align 4
+; CHECK-NEXT: [[EXP_2XF32:%.*]] = call <2 x float> @llvm.exp.v2f32(<2 x float> poison)
+; CHECK-NEXT: store volatile <2 x float> [[EXP_2XF32]], ptr [[P]], align 8
+; CHECK-NEXT: [[EXP_4XF64:%.*]] = call <4 x double> @llvm.exp.v4f64(<4 x double> poison)
+; CHECK-NEXT: store volatile <4 x double> [[EXP_4XF64]], ptr [[P]], align 32
+; CHECK-NEXT: [[EXP2_F32:%.*]] = call float @llvm.exp2.f32(float poison)
+; CHECK-NEXT: store volatile float [[EXP2_F32]], ptr [[P]], align 4
+; CHECK-NEXT: [[EXP2_2XF32:%.*]] = call <2 x float> @llvm.exp2.v2f32(<2 x float> poison)
+; CHECK-NEXT: store volatile <2 x float> [[EXP2_2XF32]], ptr [[P]], align 8
+; CHECK-NEXT: [[EXP2_4XF64:%.*]] = call <4 x double> @llvm.exp2.v4f64(<4 x double> poison)
+; CHECK-NEXT: store volatile <4 x double> [[EXP2_4XF64]], ptr [[P]], align 32
+; CHECK-NEXT: [[EXP10_F32:%.*]] = call float @llvm.exp10.f32(float poison)
+; CHECK-NEXT: store volatile float [[EXP10_F32]], ptr [[P]], align 4
+; CHECK-NEXT: [[EXP10_2XF32:%.*]] = call <2 x float> @llvm.exp10.v2f32(<2 x float> poison)
+; CHECK-NEXT: store volatile <2 x float> [[EXP10_2XF32]], ptr [[P]], align 8
+; CHECK-NEXT: [[EXP10_4XF64:%.*]] = call <4 x double> @llvm.exp10.v4f64(<4 x double> poison)
+; CHECK-NEXT: store volatile <4 x double> [[EXP10_4XF64]], ptr [[P]], align 32
+; CHECK-NEXT: ret void
+;
+ %exp_f32 = call float @llvm.exp(float poison)
+ store volatile float %exp_f32, ptr %P
+
+ %exp_2xf32 = call <2 x float> @llvm.exp(<2 x float> poison)
+ store volatile <2 x float> %exp_2xf32, ptr %P
+
+ %exp_4xf64 = call <4 x double> @llvm.exp(<4 x double> poison)
+ store volatile <4 x double> %exp_4xf64, ptr %P
+
+ %exp2_f32 = call float @llvm.exp2(float poison)
+ store volatile float %exp2_f32, ptr %P
+
+ %exp2_2xf32 = call <2 x float> @llvm.exp2(<2 x float> poison)
+ store volatile <2 x float> %exp2_2xf32, ptr %P
+
+ %exp2_4xf64 = call <4 x double> @llvm.exp2(<4 x double> poison)
+ store volatile <4 x double> %exp2_4xf64, ptr %P
+
+ %exp10_f32 = call float @llvm.exp10(float poison)
+ store volatile float %exp10_f32, ptr %P
+
+ %exp10_2xf32 = call <2 x float> @llvm.exp10(<2 x float> poison)
+ store volatile <2 x float> %exp10_2xf32, ptr %P
+
+ %exp10_4xf64 = call <4 x double> @llvm.exp10(<4 x double> poison)
+ store volatile <4 x double> %exp10_4xf64, ptr %P
+ ret void
+}
+
+
+define void @log_poison(ptr %P) {
+; CHECK-LABEL: @log_poison(
+; CHECK-NEXT: [[LOG_F32:%.*]] = call float @llvm.log.f32(float poison)
+; CHECK-NEXT: store volatile float [[LOG_F32]], ptr [[P:%.*]], align 4
+; CHECK-NEXT: [[LOG_2XF32:%.*]] = call <2 x float> @llvm.log.v2f32(<2 x float> poison)
+; CHECK-NEXT: store volatile <2 x float> [[LOG_2XF32]], ptr [[P]], align 8
+; CHECK-NEXT: [[LOG_4XF64:%.*]] = call <4 x double> @llvm.log.v4f64(<4 x double> poison)
+; CHECK-NEXT: store volatile <4 x double> [[LOG_4XF64]], ptr [[P]], align 32
+; CHECK-NEXT: [[LOG2_F32:%.*]] = call float @llvm.log2.f32(float poison)
+; CHECK-NEXT: store volatile float [[LOG2_F32]], ptr [[P]], align 4
+; CHECK-NEXT: [[LOG2_2XF32:%.*]] = call <2 x float> @llvm.log2.v2f32(<2 x float> poison)
+; CHECK-NEXT: store volatile <2 x float> [[LOG2_2XF32]], ptr [[P]], align 8
+; CHECK-NEXT: [[LOG2_4XF64:%.*]] = call <4 x double> @llvm.log2.v4f64(<4 x double> poison)
+; CHECK-NEXT: store volatile <4 x double> [[LOG2_4XF64]], ptr [[P]], align 32
+; CHECK-NEXT: [[LOG10_F32:%.*]] = call float @llvm.log10.f32(float poison)
+; CHECK-NEXT: store volatile float [[LOG10_F32]], ptr [[P]], align 4
+; CHECK-NEXT: [[LOG10_2XF32:%.*]] = call <2 x float> @llvm.log10.v2f32(<2 x float> poison)
+; CHECK-NEXT: store volatile <2 x float> [[LOG10_2XF32]], ptr [[P]], align 8
+; CHECK-NEXT: [[LOG10_4XF64:%.*]] = call <4 x double> @llvm.log10.v4f64(<4 x double> poison)
+; CHECK-NEXT: store volatile <4 x double> [[LOG10_4XF64]], ptr [[P]], align 32
+; CHECK-NEXT: ret void
+;
+ %log_f32 = call float @llvm.log(float poison)
+ store volatile float %log_f32, ptr %P
+
+ %log_2xf32 = call <2 x float> @llvm.log(<2 x float> poison)
+ store volatile <2 x float> %log_2xf32, ptr %P
+
+ %log_4xf64 = call <4 x double> @llvm.log(<4 x double> poison)
+ store volatile <4 x double> %log_4xf64, ptr %P
+
+ %log2_f32 = call float @llvm.log2(float poison)
+ store volatile float %log2_f32, ptr %P
+
+ %log2_2xf32 = call <2 x float> @llvm.log2(<2 x float> poison)
+ store volatile <2 x float> %log2_2xf32, ptr %P
+
+ %log2_4xf64 = call <4 x double> @llvm.log2(<4 x double> poison)
+ store volatile <4 x double> %log2_4xf64, ptr %P
+
+ %log10_f32 = call float @llvm.log10(float poison)
+ store volatile float %log10_f32, ptr %P
+
+ %log10_2xf32 = call <2 x float> @llvm.log10(<2 x float> poison)
+ store volatile <2 x float> %log10_2xf32, ptr %P
+
+ %log10_4xf64 = call <4 x double> @llvm.log10(<4 x double> poison)
+ store volatile <4 x double> %log10_4xf64, ptr %P
+ ret void
+}
+
+
+define void @modf_poison(ptr %P) {
+; CHECK-LABEL: @modf_poison(
+; CHECK-NEXT: [[MODF_F32:%.*]] = call { float, float } @llvm.modf.f32(float poison)
+; CHECK-NEXT: store volatile { float, float } [[MODF_F32]], ptr [[P:%.*]], align 4
+; CHECK-NEXT: [[MODF_2XF32:%.*]] = call { <2 x float>, <2 x float> } @llvm.modf.v2f32(<2 x float> poison)
+; CHECK-NEXT: store volatile { <2 x float>, <2 x float> } [[MODF_2XF32]], ptr [[P]], align 8
+; CHECK-NEXT: [[MODF_4XF64:%.*]] = call { <4 x double>, <4 x double> } @llvm.modf.v4f64(<4 x double> poison)
+; CHECK-NEXT: store volatile { <4 x double>, <4 x double> } [[MODF_4XF64]], ptr [[P]], align 32
+; CHECK-NEXT: ret void
+;
+ %modf_f32 = call { float, float } @llvm.modf(float poison)
+ store volatile { float, float } %modf_f32, ptr %P
+
+ %modf_2xf32 = call { <2 x float>, <2 x float> } @llvm.modf(<2 x float> poison)
+ store volatile { <2 x float>, <2 x float> } %modf_2xf32, ptr %P
+
+ %modf_4xf64 = call { <4 x double>, <4 x double> } @llvm.modf(<4 x double> poison)
+ store volatile { <4 x double>, <4 x double> } %modf_4xf64, ptr %P
+
+ ret void
+}
+
+
+define void @floor_poison(ptr %P) {
+; CHECK-LABEL: @floor_poison(
+; CHECK-NEXT: [[FLOOR_F32:%.*]] = call float @llvm.floor.f32(float poison)
+; CHECK-NEXT: store volatile float [[FLOOR_F32]], ptr [[P:%.*]], align 4
+; CHECK-NEXT: [[FLOOR_2XF32:%.*]] = call <2 x float> @llvm.floor.v2f32(<2 x float> poison)
+; CHECK-NEXT: store volatile <2 x float> [[FLOOR_2XF32]], ptr [[P]], align 8
+; CHECK-NEXT: [[FLOOR_4XF64:%.*]] = call <4 x double> @llvm.floor.v4f64(<4 x double> poison)
+; CHECK-NEXT: store volatile <4 x double> [[FLOOR_4XF64]], ptr [[P]], align 32
+; CHECK-NEXT: ret void
+;
+ %floor_f32 = call float @llvm.floor(float poison)
+ store volatile float %floor_f32, ptr %P
+
+ %floor_2xf32 = call <2 x float> @llvm.floor(<2 x float> poison)
+ store volatile <2 x float> %floor_2xf32, ptr %P
+
+ %floor_4xf64 = call <4 x double> @llvm.floor(<4 x double> poison)
+ store volatile <4 x double> %floor_4xf64, ptr %P
+
+ ret void
+}
+
+
+define void @ceil_poison(ptr %P) {
+; CHECK-LABEL: @ceil_poison(
+; CHECK-NEXT: [[CEIL_F32:%.*]] = call float @llvm.ceil.f32(float poison)
+; CHECK-NEXT: store volatile float [[CEIL_F32]], ptr [[P:%.*]], align 4
+; CHECK-NEXT: [[CEIL_2XF32:%.*]] = call <2 x float> @llvm.ceil.v2f32(<2 x float> poison)
+; CHECK-NEXT: store volatile <2 x float> [[CEIL_2XF32]], ptr [[P]], align 8
+; CHECK-NEXT: [[CEIL_4XF64:%.*]] = call <4 x double> @llvm.ceil.v4f64(<4 x double> poison)
+; CHECK-NEXT: store volatile <4 x double> [[CEIL_4XF64]], ptr [[P]], align 32
+; CHECK-NEXT: ret void
+;
+ %ceil_f32 = call float @llvm.ceil(float poison)
+ store volatile float %ceil_f32, ptr %P
+
+ %ceil_2xf32 = call <2 x float> @llvm.ceil(<2 x float> poison)
+ store volatile <2 x float> %ceil_2xf32, ptr %P
+
+ %ceil_4xf64 = call <4 x double> @llvm.ceil(<4 x double> poison)
+ store volatile <4 x double> %ceil_4xf64, ptr %P
+
+ ret void
+}
+
+
+define void @trunc_poison(ptr %P) {
+; CHECK-LABEL: @trunc_poison(
+; CHECK-NEXT: [[TRUNC_F32:%.*]] = call float @llvm.trunc.f32(float poison)
+; CHECK-NEXT: store volatile float [[TRUNC_F32]], ptr [[P:%.*]], align 4
+; CHECK-NEXT: [[TRUNC_2XF32:%.*]] = call <2 x float> @llvm.trunc.v2f32(<2 x float> poison)
+; CHECK-NEXT: store volatile <2 x float> [[TRUNC_2XF32]], ptr [[P]], align 8
+; CHECK-NEXT: [[TRUNC_4XF64:%.*]] = call <4 x double> @llvm.trunc.v4f64(<4 x double> poison)
+; CHECK-NEXT: store volatile <4 x double> [[TRUNC_4XF64]], ptr [[P]], align 32
+; CHECK-NEXT: ret void
+;
+ %trunc_f32 = call float @llvm.trunc(float poison)
+ store volatile float %trunc_f32, ptr %P
+
+ %trunc_2xf32 = call <2 x float> @llvm.trunc(<2 x float> poison)
+ store volatile <2 x float> %trunc_2xf32, ptr %P
+
+ %trunc_4xf64 = call <4 x double> @llvm.trunc(<4 x double> poison)
+ store volatile <4 x double> %trunc_4xf64, ptr %P
+
+ ret void
+}
+
+define void @rint_poison(ptr %P) {
+; CHECK-LABEL: @rint_poison(
+; CHECK-NEXT: [[RINT_F32:%.*]] = call float @llvm.rint.f32(float poison)
+; CHECK-NEXT: store volatile float [[RINT_F32]], ptr [[P:%.*]], align 4
+; CHECK-NEXT: [[RINT_2XF32:%.*]] = call <2 x float> @llvm.rint.v2f32(<2 x float> poison)
+; CHECK-NEXT: store volatile <2 x float> [[RINT_2XF32]], ptr [[P]], align 8
+; CHECK-NEXT: [[RINT_4XF64:%.*]] = call <4 x double> @llvm.rint.v4f64(<4 x double> poison)
+; CHECK-NEXT: store volatile <4 x double> [[RINT_4XF64]], ptr [[P]], align 32
+; CHECK-NEXT: ret void
+;
+ %rint_f32 = call float @llvm.rint(float poison)
+ store volatile float %rint_f32, ptr %P
+
+ %rint_2xf32 = call <2 x float> @llvm.rint(<2 x float> poison)
+ store volatile <2 x float> %rint_2xf32, ptr %P
+
+ %rint_4xf64 = call <4 x double> @llvm.rint(<4 x double> poison)
+ store volatile <4 x double> %rint_4xf64, ptr %P
+
+ ret void
+}
+
+define void @nearbyint_poison(ptr %P) {
+; CHECK-LABEL: @nearbyint_poison(
+; CHECK-NEXT: [[NEARBYINT_F32:%.*]] = call float @llvm.nearbyint.f32(float poison)
+; CHECK-NEXT: store volatile float [[NEARBYINT_F32]], ptr [[P:%.*]], align 4
+; CHECK-NEXT: [[NEARBYINT_2XF32:%.*]] = call <2 x float> @llvm.nearbyint.v2f32(<2 x float> poison)
+; CHECK-NEXT: store volatile <2 x float> [[NEARBYINT_2XF32]], ptr [[P]], align 8
+; CHECK-NEXT: [[NEARBYINT_4XF64:%.*]] = call <4 x double> @llvm.nearbyint.v4f64(<4 x double> poison)
+; CHECK-NEXT: store volatile <4 x double> [[NEARBYINT_4XF64]], ptr [[P]], align 32
+; CHECK-NEXT: ret void
+;
+ %nearbyint_f32 = call float @llvm.nearbyint(float poison)
+ store volatile float %nearbyint_f32, ptr %P
+
+ %nearbyint_2xf32 = call <2 x float> @llvm.nearbyint(<2 x float> poison)
+ store volatile <2 x float> %nearbyint_2xf32, ptr %P
+
+ %nearbyint_4xf64 = call <4 x double> @llvm.nearbyint(<4 x double> poison)
+ store volatile <4 x double> %nearbyint_4xf64, ptr %P
+
+ ret void
+}
+
+
+define void @round_poison(ptr %P) {
+; CHECK-LABEL: @round_poison(
+; CHECK-NEXT: [[ROUND_F32:%.*]] = call float @llvm.round.f32(float poison)
+; CHECK-NEXT: store volatile float [[ROUND_F32]], ptr [[P:%.*]], align 4
+; CHECK-NEXT: [[ROUND_2XF32:%.*]] = call <2 x float> @llvm.round.v2f32(<2 x float> poison)
+; CHECK-NEXT: store volatile <2 x float> [[ROUND_2XF32]], ptr [[P]], align 8
+; CHECK-NEXT: [[ROUND_4XF64:%.*]] = call <4 x double> @llvm.round.v4f64(<4 x double> poison)
+; CHECK-NEXT: store volatile <4 x double> [[ROUND_4XF64]], ptr [[P]], align 32
+; CHECK-NEXT: ret void
+;
+ %round_f32 = call float @llvm.round(float poison)
+ store volatile float %round_f32, ptr %P
+
+ %round_2xf32 = call <2 x float> @llvm.round(<2 x float> poison)
+ store volatile <2 x float> %round_2xf32, ptr %P
+
+ %round_4xf64 = call <4 x double> @llvm.round(<4 x double> poison)
+ store volatile <4 x double> %round_4xf64, ptr %P
+
+ ret void
+}
+
+
+define void @roundeven_poison(ptr %P) {
+; CHECK-LABEL: @roundeven_poison(
+; CHECK-NEXT: [[ROUNDEVEN_F32:%.*]] = call float @llvm.roundeven.f32(float poison)
+; CHECK-NEXT: store volatile float [[ROUNDEVEN_F32]], ptr [[P:%.*]], align 4
+; CHECK-NEXT: [[ROUNDEVEN_2XF32:%.*]] = call <2 x float> @llvm.roundeven.v2f32(<2 x float> poison)
+; CHECK-NEXT: store volatile <2 x float> [[ROUNDEVEN_2XF32]], ptr [[P]], align 8
+; CHECK-NEXT: [[ROUNDEVEN_4XF64:%.*]] = call <4 x double> @llvm.roundeven.v4f64(<4 x double> poison)
+; CHECK-NEXT: store volatile <4 x double> [[ROUNDEVEN_4XF64]], ptr [[P]], align 32
+; CHECK-NEXT: ret void
+;
+ %roundeven_f32 = call float @llvm.roundeven(float poison)
+ store volatile float %roundeven_f32, ptr %P
+
+ %roundeven_2xf32 = call <2 x float> @llvm.roundeven(<2 x float> poison)
+ store volatile <2 x float> %roundeven_2xf32, ptr %P
+
+ %roundeven_4xf64 = call <4 x double> @llvm.roundeven(<4 x double> poison)
+ store volatile <4 x double> %roundeven_4xf64, ptr %P
+
+ ret void
+}
+
+
+define void @lrint_poison(ptr %P) {
+; CHECK-LABEL: @lrint_poison(
+; CHECK-NEXT: [[LRINT_F32:%.*]] = call i32 @llvm.lrint.i32.f32(float poison)
+; CHECK-NEXT: store volatile i32 [[LRINT_F32]], ptr [[P:%.*]], align 4
+; CHECK-NEXT: [[LRINT_2XF32:%.*]] = call <2 x i32> @llvm.lrint.v2i32.v2f32(<2 x float> poison)
+; CHECK-NEXT: store volatile <2 x i32> [[LRINT_2XF32]], ptr [[P]], align 8
+; CHECK-NEXT: [[LRINT_4XF64:%.*]] = call <4 x i64> @llvm.lrint.v4i64.v4f64(<4 x double> poison)
+; CHECK-NEXT: store volatile <4 x i64> [[LRINT_4XF64]], ptr [[P]], align 32
+; CHECK-NEXT: ret void
+;
+ %lrint_f32 = call i32 @llvm.lrint(float poison)
+ store volatile i32 %lrint_f32, ptr %P
+
+ %lrint_2xf32 = call <2 x i32> @llvm.lrint(<2 x float> poison)
+ store volatile <2 x i32> %lrint_2xf32, ptr %P
+
+ %lrint_4xf64 = call <4 x i64> @llvm.lrint(<4 x double> poison)
+ store volatile <4 x i64> %lrint_4xf64, ptr %P
+
+ ret void
+}
+
+
+define void @llrint_poison(ptr %P) {
+; CHECK-LABEL: @llrint_poison(
+; CHECK-NEXT: [[LLRINT_F32:%.*]] = call i32 @llvm.llrint.i32.f32(float poison)
+; CHECK-NEXT: store volatile i32 [[LLRINT_F32]], ptr [[P:%.*]], align 4
+; CHECK-NEXT: [[LLRINT_2XF32:%.*]] = call <2 x i32> @llvm.llrint.v2i32.v2f32(<2 x float> poison)
+; CHECK-NEXT: store volatile <2 x i32> [[LLRINT_2XF32]], ptr [[P]], align 8
+; CHECK-NEXT: [[LLRINT_4XF64:%.*]] = call <4 x i64> @llvm.llrint.v4i64.v4f64(<4 x double> poison)
+; CHECK-NEXT: store volatile <4 x i64> [[LLRINT_4XF64]], ptr [[P]], align 32
+; CHECK-NEXT: ret void
+;
+ %llrint_f32 = call i32 @llvm.llrint(float poison)
+ store volatile i32 %llrint_f32, ptr %P
+
+ %llrint_2xf32 = call <2 x i32> @llvm.llrint(<2 x float> poison)
+ store volatile <2 x i32> %llrint_2xf32, ptr %P
+
+ %llrint_4xf64 = call <4 x i64> @llvm.llrint(<4 x double> poison)
+ store volatile <4 x i64> %llrint_4xf64, ptr %P
+
+ ret void
+}
+
+
+define void @umul_fix_poison(ptr %P) {
+; CHECK-LABEL: @umul_fix_poison(
+; CHECK-NEXT: [[UMUL_FIX_I16:%.*]] = call i16 @llvm.umul.fix.i16(i16 poison, i16 poison, i32 2)
+; CHECK-NEXT: store volatile i16 [[UMUL_FIX_I16]], ptr [[P:%.*]], align 2
+; CHECK-NEXT: [[UMUL_FIX_I32:%.*]] = call i32 @llvm.umul.fix.i32(i32 poison, i32 poison, i32 2)
+; CHECK-NEXT: store volatile i32 [[UMUL_FIX_I32]], ptr [[P]], align 4
+; CHECK-NEXT: [[UMUL_FIX_4XI32:%.*]] = call <4 x i32> @llvm.umul.fix.v4i32(<4 x i32> poison, <4 x i32> poison, i32 2)
+; CHECK-NEXT: store volatile <4 x i32> [[UMUL_FIX_4XI32]], ptr [[P]], align 16
+; CHECK-NEXT: ret void
+;
+ %umul_fix_i16 = call i16 @llvm.umul.fix(i16 poison, i16 poison, i32 2)
+ store volatile i16 %umul_fix_i16, ptr %P
+
+ %umul_fix_i32 = call i32 @llvm.umul.fix(i32 poison, i32 poison, i32 2)
+ store volatile i32 %umul_fix_i32, ptr %P
+
+ %umul_fix_4xi32 = call <4 x i32> @llvm.umul.fix(<4 x i32> poison, <4 x i32> poison, i32 2)
+ store volatile <4 x i32> %umul_fix_4xi32, ptr %P
+
+ ret void
+}
+
+
+define void @umul_fix_sat_poison(ptr %P) {
+; CHECK-LABEL: @umul_fix_sat_poison(
+; CHECK-NEXT: [[UMUL_FIX_SATI16:%.*]] = call i16 @llvm.umul.fix.sat.i16(i16 poison, i16 poison, i32 2)
+; CHECK-NEXT: store volatile i16 [[UMUL_FIX_SATI16]], ptr [[P:%.*]], align 2
+; CHECK-NEXT: [[UMUL_FIX_SATI32:%.*]] = call i32 @llvm.umul.fix.sat.i32(i32 poison, i32 poison, i32 2)
+; CHECK-NEXT: store volatile i32 [[UMUL_FIX_SATI32]], ptr [[P]], align 4
+; CHECK-NEXT: [[UMUL_FIX_SAT4XI32:%.*]] = call <4 x i32> @llvm.umul.fix.sat.v4i32(<4 x i32> poison, <4 x i32> poison, i32 2)
+; CHECK-NEXT: store volatile <4 x i32> [[UMUL_FIX_SAT4XI32]], ptr [[P]], align 16
+; CHECK-NEXT: ret void
+;
+ %umul_fix_sati16 = call i16 @llvm.umul.fix.sat(i16 poison, i16 poison, i32 2)
+ store volatile i16 %umul_fix_sati16, ptr %P
+
+ %umul_fix_sati32 = call i32 @llvm.umul.fix.sat(i32 poison, i32 poison, i32 2)
+ store volatile i32 %umul_fix_sati32, ptr %P
+
+ %umul_fix_sat4xi32 = call <4 x i32> @llvm.umul.fix.sat(<4 x i32> poison, <4 x i32> poison, i32 2)
+ store volatile <4 x i32> %umul_fix_sat4xi32, ptr %P
+
+ ret void
+}
>From 2c93da915ba4cbe0084bd71df1afafe09370cbd3 Mon Sep 17 00:00:00 2001
From: Jasmine Tang <jjasmine at igalia.com>
Date: Wed, 16 Jul 2025 20:36:34 -0700
Subject: [PATCH 2/2] Fix the rest of the cases in #146769
---
llvm/lib/Analysis/ValueTracking.cpp | 18 ++
llvm/test/Transforms/InstSimplify/exp10.ll | 9 +-
.../InstSimplify/fold-intrinsics.ll | 162 ++++++------------
llvm/unittests/Analysis/ValueTrackingTest.cpp | 28 +--
4 files changed, 89 insertions(+), 128 deletions(-)
diff --git a/llvm/lib/Analysis/ValueTracking.cpp b/llvm/lib/Analysis/ValueTracking.cpp
index 61a322be03da1..af85ce4077ec8 100644
--- a/llvm/lib/Analysis/ValueTracking.cpp
+++ b/llvm/lib/Analysis/ValueTracking.cpp
@@ -7912,6 +7912,8 @@ bool llvm::intrinsicPropagatesPoison(Intrinsic::ID IID) {
case Intrinsic::ushl_sat:
case Intrinsic::smul_fix:
case Intrinsic::smul_fix_sat:
+ case Intrinsic::umul_fix:
+ case Intrinsic::umul_fix_sat:
case Intrinsic::pow:
case Intrinsic::powi:
case Intrinsic::sin:
@@ -7928,6 +7930,22 @@ bool llvm::intrinsicPropagatesPoison(Intrinsic::ID IID) {
case Intrinsic::atan2:
case Intrinsic::canonicalize:
case Intrinsic::sqrt:
+ case Intrinsic::exp:
+ case Intrinsic::exp2:
+ case Intrinsic::exp10:
+ case Intrinsic::log:
+ case Intrinsic::log2:
+ case Intrinsic::log10:
+ case Intrinsic::modf:
+ case Intrinsic::floor:
+ case Intrinsic::ceil:
+ case Intrinsic::trunc:
+ case Intrinsic::rint:
+ case Intrinsic::nearbyint:
+ case Intrinsic::round:
+ case Intrinsic::roundeven:
+ case Intrinsic::lrint:
+ case Intrinsic::llrint:
return true;
default:
return false;
diff --git a/llvm/test/Transforms/InstSimplify/exp10.ll b/llvm/test/Transforms/InstSimplify/exp10.ll
index c415c419aad84..17c081137ad1c 100644
--- a/llvm/test/Transforms/InstSimplify/exp10.ll
+++ b/llvm/test/Transforms/InstSimplify/exp10.ll
@@ -57,8 +57,7 @@ define <vscale x 2 x float> @exp10_exp10_scalable_vector(<vscale x 2 x float> %x
define float @exp10_poison() {
; CHECK-LABEL: define float @exp10_poison() {
-; CHECK-NEXT: [[RET:%.*]] = call float @llvm.exp10.f32(float poison)
-; CHECK-NEXT: ret float [[RET]]
+; CHECK-NEXT: ret float poison
;
%ret = call float @llvm.exp10.f32(float poison)
ret float %ret
@@ -66,8 +65,7 @@ define float @exp10_poison() {
define <2 x float> @exp10_poison_vector() {
; CHECK-LABEL: define <2 x float> @exp10_poison_vector() {
-; CHECK-NEXT: [[RET:%.*]] = call <2 x float> @llvm.exp10.v2f32(<2 x float> poison)
-; CHECK-NEXT: ret <2 x float> [[RET]]
+; CHECK-NEXT: ret <2 x float> poison
;
%ret = call <2 x float> @llvm.exp10.v2f32(<2 x float> poison)
ret <2 x float> %ret
@@ -75,8 +73,7 @@ define <2 x float> @exp10_poison_vector() {
define <vscale x 2 x float> @exp10_poison_scaleable_vector() {
; CHECK-LABEL: define <vscale x 2 x float> @exp10_poison_scaleable_vector() {
-; CHECK-NEXT: [[RET:%.*]] = call <vscale x 2 x float> @llvm.exp10.nxv2f32(<vscale x 2 x float> poison)
-; CHECK-NEXT: ret <vscale x 2 x float> [[RET]]
+; CHECK-NEXT: ret <vscale x 2 x float> poison
;
%ret = call <vscale x 2 x float> @llvm.exp10.nxv2f32(<vscale x 2 x float> poison)
ret <vscale x 2 x float> %ret
diff --git a/llvm/test/Transforms/InstSimplify/fold-intrinsics.ll b/llvm/test/Transforms/InstSimplify/fold-intrinsics.ll
index 5eba0d1b2f20d..45f5e3768725f 100644
--- a/llvm/test/Transforms/InstSimplify/fold-intrinsics.ll
+++ b/llvm/test/Transforms/InstSimplify/fold-intrinsics.ll
@@ -290,24 +290,15 @@ define void @tanh_poison(ptr %P) {
define void @exp_poison(ptr %P) {
; CHECK-LABEL: @exp_poison(
-; CHECK-NEXT: [[EXP_F32:%.*]] = call float @llvm.exp.f32(float poison)
-; CHECK-NEXT: store volatile float [[EXP_F32]], ptr [[P:%.*]], align 4
-; CHECK-NEXT: [[EXP_2XF32:%.*]] = call <2 x float> @llvm.exp.v2f32(<2 x float> poison)
-; CHECK-NEXT: store volatile <2 x float> [[EXP_2XF32]], ptr [[P]], align 8
-; CHECK-NEXT: [[EXP_4XF64:%.*]] = call <4 x double> @llvm.exp.v4f64(<4 x double> poison)
-; CHECK-NEXT: store volatile <4 x double> [[EXP_4XF64]], ptr [[P]], align 32
-; CHECK-NEXT: [[EXP2_F32:%.*]] = call float @llvm.exp2.f32(float poison)
-; CHECK-NEXT: store volatile float [[EXP2_F32]], ptr [[P]], align 4
-; CHECK-NEXT: [[EXP2_2XF32:%.*]] = call <2 x float> @llvm.exp2.v2f32(<2 x float> poison)
-; CHECK-NEXT: store volatile <2 x float> [[EXP2_2XF32]], ptr [[P]], align 8
-; CHECK-NEXT: [[EXP2_4XF64:%.*]] = call <4 x double> @llvm.exp2.v4f64(<4 x double> poison)
-; CHECK-NEXT: store volatile <4 x double> [[EXP2_4XF64]], ptr [[P]], align 32
-; CHECK-NEXT: [[EXP10_F32:%.*]] = call float @llvm.exp10.f32(float poison)
-; CHECK-NEXT: store volatile float [[EXP10_F32]], ptr [[P]], align 4
-; CHECK-NEXT: [[EXP10_2XF32:%.*]] = call <2 x float> @llvm.exp10.v2f32(<2 x float> poison)
-; CHECK-NEXT: store volatile <2 x float> [[EXP10_2XF32]], ptr [[P]], align 8
-; CHECK-NEXT: [[EXP10_4XF64:%.*]] = call <4 x double> @llvm.exp10.v4f64(<4 x double> poison)
-; CHECK-NEXT: store volatile <4 x double> [[EXP10_4XF64]], ptr [[P]], align 32
+; CHECK-NEXT: store volatile float poison, ptr [[P:%.*]], align 4
+; CHECK-NEXT: store volatile <2 x float> poison, ptr [[P]], align 8
+; CHECK-NEXT: store volatile <4 x double> poison, ptr [[P]], align 32
+; CHECK-NEXT: store volatile float poison, ptr [[P]], align 4
+; CHECK-NEXT: store volatile <2 x float> poison, ptr [[P]], align 8
+; CHECK-NEXT: store volatile <4 x double> poison, ptr [[P]], align 32
+; CHECK-NEXT: store volatile float poison, ptr [[P]], align 4
+; CHECK-NEXT: store volatile <2 x float> poison, ptr [[P]], align 8
+; CHECK-NEXT: store volatile <4 x double> poison, ptr [[P]], align 32
; CHECK-NEXT: ret void
;
%exp_f32 = call float @llvm.exp(float poison)
@@ -342,24 +333,15 @@ define void @exp_poison(ptr %P) {
define void @log_poison(ptr %P) {
; CHECK-LABEL: @log_poison(
-; CHECK-NEXT: [[LOG_F32:%.*]] = call float @llvm.log.f32(float poison)
-; CHECK-NEXT: store volatile float [[LOG_F32]], ptr [[P:%.*]], align 4
-; CHECK-NEXT: [[LOG_2XF32:%.*]] = call <2 x float> @llvm.log.v2f32(<2 x float> poison)
-; CHECK-NEXT: store volatile <2 x float> [[LOG_2XF32]], ptr [[P]], align 8
-; CHECK-NEXT: [[LOG_4XF64:%.*]] = call <4 x double> @llvm.log.v4f64(<4 x double> poison)
-; CHECK-NEXT: store volatile <4 x double> [[LOG_4XF64]], ptr [[P]], align 32
-; CHECK-NEXT: [[LOG2_F32:%.*]] = call float @llvm.log2.f32(float poison)
-; CHECK-NEXT: store volatile float [[LOG2_F32]], ptr [[P]], align 4
-; CHECK-NEXT: [[LOG2_2XF32:%.*]] = call <2 x float> @llvm.log2.v2f32(<2 x float> poison)
-; CHECK-NEXT: store volatile <2 x float> [[LOG2_2XF32]], ptr [[P]], align 8
-; CHECK-NEXT: [[LOG2_4XF64:%.*]] = call <4 x double> @llvm.log2.v4f64(<4 x double> poison)
-; CHECK-NEXT: store volatile <4 x double> [[LOG2_4XF64]], ptr [[P]], align 32
-; CHECK-NEXT: [[LOG10_F32:%.*]] = call float @llvm.log10.f32(float poison)
-; CHECK-NEXT: store volatile float [[LOG10_F32]], ptr [[P]], align 4
-; CHECK-NEXT: [[LOG10_2XF32:%.*]] = call <2 x float> @llvm.log10.v2f32(<2 x float> poison)
-; CHECK-NEXT: store volatile <2 x float> [[LOG10_2XF32]], ptr [[P]], align 8
-; CHECK-NEXT: [[LOG10_4XF64:%.*]] = call <4 x double> @llvm.log10.v4f64(<4 x double> poison)
-; CHECK-NEXT: store volatile <4 x double> [[LOG10_4XF64]], ptr [[P]], align 32
+; CHECK-NEXT: store volatile float poison, ptr [[P:%.*]], align 4
+; CHECK-NEXT: store volatile <2 x float> poison, ptr [[P]], align 8
+; CHECK-NEXT: store volatile <4 x double> poison, ptr [[P]], align 32
+; CHECK-NEXT: store volatile float poison, ptr [[P]], align 4
+; CHECK-NEXT: store volatile <2 x float> poison, ptr [[P]], align 8
+; CHECK-NEXT: store volatile <4 x double> poison, ptr [[P]], align 32
+; CHECK-NEXT: store volatile float poison, ptr [[P]], align 4
+; CHECK-NEXT: store volatile <2 x float> poison, ptr [[P]], align 8
+; CHECK-NEXT: store volatile <4 x double> poison, ptr [[P]], align 32
; CHECK-NEXT: ret void
;
%log_f32 = call float @llvm.log(float poison)
@@ -394,12 +376,9 @@ define void @log_poison(ptr %P) {
define void @modf_poison(ptr %P) {
; CHECK-LABEL: @modf_poison(
-; CHECK-NEXT: [[MODF_F32:%.*]] = call { float, float } @llvm.modf.f32(float poison)
-; CHECK-NEXT: store volatile { float, float } [[MODF_F32]], ptr [[P:%.*]], align 4
-; CHECK-NEXT: [[MODF_2XF32:%.*]] = call { <2 x float>, <2 x float> } @llvm.modf.v2f32(<2 x float> poison)
-; CHECK-NEXT: store volatile { <2 x float>, <2 x float> } [[MODF_2XF32]], ptr [[P]], align 8
-; CHECK-NEXT: [[MODF_4XF64:%.*]] = call { <4 x double>, <4 x double> } @llvm.modf.v4f64(<4 x double> poison)
-; CHECK-NEXT: store volatile { <4 x double>, <4 x double> } [[MODF_4XF64]], ptr [[P]], align 32
+; CHECK-NEXT: store volatile { float, float } poison, ptr [[P:%.*]], align 4
+; CHECK-NEXT: store volatile { <2 x float>, <2 x float> } poison, ptr [[P]], align 8
+; CHECK-NEXT: store volatile { <4 x double>, <4 x double> } poison, ptr [[P]], align 32
; CHECK-NEXT: ret void
;
%modf_f32 = call { float, float } @llvm.modf(float poison)
@@ -417,12 +396,9 @@ define void @modf_poison(ptr %P) {
define void @floor_poison(ptr %P) {
; CHECK-LABEL: @floor_poison(
-; CHECK-NEXT: [[FLOOR_F32:%.*]] = call float @llvm.floor.f32(float poison)
-; CHECK-NEXT: store volatile float [[FLOOR_F32]], ptr [[P:%.*]], align 4
-; CHECK-NEXT: [[FLOOR_2XF32:%.*]] = call <2 x float> @llvm.floor.v2f32(<2 x float> poison)
-; CHECK-NEXT: store volatile <2 x float> [[FLOOR_2XF32]], ptr [[P]], align 8
-; CHECK-NEXT: [[FLOOR_4XF64:%.*]] = call <4 x double> @llvm.floor.v4f64(<4 x double> poison)
-; CHECK-NEXT: store volatile <4 x double> [[FLOOR_4XF64]], ptr [[P]], align 32
+; CHECK-NEXT: store volatile float poison, ptr [[P:%.*]], align 4
+; CHECK-NEXT: store volatile <2 x float> poison, ptr [[P]], align 8
+; CHECK-NEXT: store volatile <4 x double> poison, ptr [[P]], align 32
; CHECK-NEXT: ret void
;
%floor_f32 = call float @llvm.floor(float poison)
@@ -440,12 +416,9 @@ define void @floor_poison(ptr %P) {
define void @ceil_poison(ptr %P) {
; CHECK-LABEL: @ceil_poison(
-; CHECK-NEXT: [[CEIL_F32:%.*]] = call float @llvm.ceil.f32(float poison)
-; CHECK-NEXT: store volatile float [[CEIL_F32]], ptr [[P:%.*]], align 4
-; CHECK-NEXT: [[CEIL_2XF32:%.*]] = call <2 x float> @llvm.ceil.v2f32(<2 x float> poison)
-; CHECK-NEXT: store volatile <2 x float> [[CEIL_2XF32]], ptr [[P]], align 8
-; CHECK-NEXT: [[CEIL_4XF64:%.*]] = call <4 x double> @llvm.ceil.v4f64(<4 x double> poison)
-; CHECK-NEXT: store volatile <4 x double> [[CEIL_4XF64]], ptr [[P]], align 32
+; CHECK-NEXT: store volatile float poison, ptr [[P:%.*]], align 4
+; CHECK-NEXT: store volatile <2 x float> poison, ptr [[P]], align 8
+; CHECK-NEXT: store volatile <4 x double> poison, ptr [[P]], align 32
; CHECK-NEXT: ret void
;
%ceil_f32 = call float @llvm.ceil(float poison)
@@ -463,12 +436,9 @@ define void @ceil_poison(ptr %P) {
define void @trunc_poison(ptr %P) {
; CHECK-LABEL: @trunc_poison(
-; CHECK-NEXT: [[TRUNC_F32:%.*]] = call float @llvm.trunc.f32(float poison)
-; CHECK-NEXT: store volatile float [[TRUNC_F32]], ptr [[P:%.*]], align 4
-; CHECK-NEXT: [[TRUNC_2XF32:%.*]] = call <2 x float> @llvm.trunc.v2f32(<2 x float> poison)
-; CHECK-NEXT: store volatile <2 x float> [[TRUNC_2XF32]], ptr [[P]], align 8
-; CHECK-NEXT: [[TRUNC_4XF64:%.*]] = call <4 x double> @llvm.trunc.v4f64(<4 x double> poison)
-; CHECK-NEXT: store volatile <4 x double> [[TRUNC_4XF64]], ptr [[P]], align 32
+; CHECK-NEXT: store volatile float poison, ptr [[P:%.*]], align 4
+; CHECK-NEXT: store volatile <2 x float> poison, ptr [[P]], align 8
+; CHECK-NEXT: store volatile <4 x double> poison, ptr [[P]], align 32
; CHECK-NEXT: ret void
;
%trunc_f32 = call float @llvm.trunc(float poison)
@@ -485,12 +455,9 @@ define void @trunc_poison(ptr %P) {
define void @rint_poison(ptr %P) {
; CHECK-LABEL: @rint_poison(
-; CHECK-NEXT: [[RINT_F32:%.*]] = call float @llvm.rint.f32(float poison)
-; CHECK-NEXT: store volatile float [[RINT_F32]], ptr [[P:%.*]], align 4
-; CHECK-NEXT: [[RINT_2XF32:%.*]] = call <2 x float> @llvm.rint.v2f32(<2 x float> poison)
-; CHECK-NEXT: store volatile <2 x float> [[RINT_2XF32]], ptr [[P]], align 8
-; CHECK-NEXT: [[RINT_4XF64:%.*]] = call <4 x double> @llvm.rint.v4f64(<4 x double> poison)
-; CHECK-NEXT: store volatile <4 x double> [[RINT_4XF64]], ptr [[P]], align 32
+; CHECK-NEXT: store volatile float poison, ptr [[P:%.*]], align 4
+; CHECK-NEXT: store volatile <2 x float> poison, ptr [[P]], align 8
+; CHECK-NEXT: store volatile <4 x double> poison, ptr [[P]], align 32
; CHECK-NEXT: ret void
;
%rint_f32 = call float @llvm.rint(float poison)
@@ -507,12 +474,9 @@ define void @rint_poison(ptr %P) {
define void @nearbyint_poison(ptr %P) {
; CHECK-LABEL: @nearbyint_poison(
-; CHECK-NEXT: [[NEARBYINT_F32:%.*]] = call float @llvm.nearbyint.f32(float poison)
-; CHECK-NEXT: store volatile float [[NEARBYINT_F32]], ptr [[P:%.*]], align 4
-; CHECK-NEXT: [[NEARBYINT_2XF32:%.*]] = call <2 x float> @llvm.nearbyint.v2f32(<2 x float> poison)
-; CHECK-NEXT: store volatile <2 x float> [[NEARBYINT_2XF32]], ptr [[P]], align 8
-; CHECK-NEXT: [[NEARBYINT_4XF64:%.*]] = call <4 x double> @llvm.nearbyint.v4f64(<4 x double> poison)
-; CHECK-NEXT: store volatile <4 x double> [[NEARBYINT_4XF64]], ptr [[P]], align 32
+; CHECK-NEXT: store volatile float poison, ptr [[P:%.*]], align 4
+; CHECK-NEXT: store volatile <2 x float> poison, ptr [[P]], align 8
+; CHECK-NEXT: store volatile <4 x double> poison, ptr [[P]], align 32
; CHECK-NEXT: ret void
;
%nearbyint_f32 = call float @llvm.nearbyint(float poison)
@@ -530,12 +494,9 @@ define void @nearbyint_poison(ptr %P) {
define void @round_poison(ptr %P) {
; CHECK-LABEL: @round_poison(
-; CHECK-NEXT: [[ROUND_F32:%.*]] = call float @llvm.round.f32(float poison)
-; CHECK-NEXT: store volatile float [[ROUND_F32]], ptr [[P:%.*]], align 4
-; CHECK-NEXT: [[ROUND_2XF32:%.*]] = call <2 x float> @llvm.round.v2f32(<2 x float> poison)
-; CHECK-NEXT: store volatile <2 x float> [[ROUND_2XF32]], ptr [[P]], align 8
-; CHECK-NEXT: [[ROUND_4XF64:%.*]] = call <4 x double> @llvm.round.v4f64(<4 x double> poison)
-; CHECK-NEXT: store volatile <4 x double> [[ROUND_4XF64]], ptr [[P]], align 32
+; CHECK-NEXT: store volatile float poison, ptr [[P:%.*]], align 4
+; CHECK-NEXT: store volatile <2 x float> poison, ptr [[P]], align 8
+; CHECK-NEXT: store volatile <4 x double> poison, ptr [[P]], align 32
; CHECK-NEXT: ret void
;
%round_f32 = call float @llvm.round(float poison)
@@ -553,12 +514,9 @@ define void @round_poison(ptr %P) {
define void @roundeven_poison(ptr %P) {
; CHECK-LABEL: @roundeven_poison(
-; CHECK-NEXT: [[ROUNDEVEN_F32:%.*]] = call float @llvm.roundeven.f32(float poison)
-; CHECK-NEXT: store volatile float [[ROUNDEVEN_F32]], ptr [[P:%.*]], align 4
-; CHECK-NEXT: [[ROUNDEVEN_2XF32:%.*]] = call <2 x float> @llvm.roundeven.v2f32(<2 x float> poison)
-; CHECK-NEXT: store volatile <2 x float> [[ROUNDEVEN_2XF32]], ptr [[P]], align 8
-; CHECK-NEXT: [[ROUNDEVEN_4XF64:%.*]] = call <4 x double> @llvm.roundeven.v4f64(<4 x double> poison)
-; CHECK-NEXT: store volatile <4 x double> [[ROUNDEVEN_4XF64]], ptr [[P]], align 32
+; CHECK-NEXT: store volatile float poison, ptr [[P:%.*]], align 4
+; CHECK-NEXT: store volatile <2 x float> poison, ptr [[P]], align 8
+; CHECK-NEXT: store volatile <4 x double> poison, ptr [[P]], align 32
; CHECK-NEXT: ret void
;
%roundeven_f32 = call float @llvm.roundeven(float poison)
@@ -576,12 +534,9 @@ define void @roundeven_poison(ptr %P) {
define void @lrint_poison(ptr %P) {
; CHECK-LABEL: @lrint_poison(
-; CHECK-NEXT: [[LRINT_F32:%.*]] = call i32 @llvm.lrint.i32.f32(float poison)
-; CHECK-NEXT: store volatile i32 [[LRINT_F32]], ptr [[P:%.*]], align 4
-; CHECK-NEXT: [[LRINT_2XF32:%.*]] = call <2 x i32> @llvm.lrint.v2i32.v2f32(<2 x float> poison)
-; CHECK-NEXT: store volatile <2 x i32> [[LRINT_2XF32]], ptr [[P]], align 8
-; CHECK-NEXT: [[LRINT_4XF64:%.*]] = call <4 x i64> @llvm.lrint.v4i64.v4f64(<4 x double> poison)
-; CHECK-NEXT: store volatile <4 x i64> [[LRINT_4XF64]], ptr [[P]], align 32
+; CHECK-NEXT: store volatile i32 poison, ptr [[P:%.*]], align 4
+; CHECK-NEXT: store volatile <2 x i32> poison, ptr [[P]], align 8
+; CHECK-NEXT: store volatile <4 x i64> poison, ptr [[P]], align 32
; CHECK-NEXT: ret void
;
%lrint_f32 = call i32 @llvm.lrint(float poison)
@@ -599,12 +554,9 @@ define void @lrint_poison(ptr %P) {
define void @llrint_poison(ptr %P) {
; CHECK-LABEL: @llrint_poison(
-; CHECK-NEXT: [[LLRINT_F32:%.*]] = call i32 @llvm.llrint.i32.f32(float poison)
-; CHECK-NEXT: store volatile i32 [[LLRINT_F32]], ptr [[P:%.*]], align 4
-; CHECK-NEXT: [[LLRINT_2XF32:%.*]] = call <2 x i32> @llvm.llrint.v2i32.v2f32(<2 x float> poison)
-; CHECK-NEXT: store volatile <2 x i32> [[LLRINT_2XF32]], ptr [[P]], align 8
-; CHECK-NEXT: [[LLRINT_4XF64:%.*]] = call <4 x i64> @llvm.llrint.v4i64.v4f64(<4 x double> poison)
-; CHECK-NEXT: store volatile <4 x i64> [[LLRINT_4XF64]], ptr [[P]], align 32
+; CHECK-NEXT: store volatile i32 poison, ptr [[P:%.*]], align 4
+; CHECK-NEXT: store volatile <2 x i32> poison, ptr [[P]], align 8
+; CHECK-NEXT: store volatile <4 x i64> poison, ptr [[P]], align 32
; CHECK-NEXT: ret void
;
%llrint_f32 = call i32 @llvm.llrint(float poison)
@@ -622,12 +574,9 @@ define void @llrint_poison(ptr %P) {
define void @umul_fix_poison(ptr %P) {
; CHECK-LABEL: @umul_fix_poison(
-; CHECK-NEXT: [[UMUL_FIX_I16:%.*]] = call i16 @llvm.umul.fix.i16(i16 poison, i16 poison, i32 2)
-; CHECK-NEXT: store volatile i16 [[UMUL_FIX_I16]], ptr [[P:%.*]], align 2
-; CHECK-NEXT: [[UMUL_FIX_I32:%.*]] = call i32 @llvm.umul.fix.i32(i32 poison, i32 poison, i32 2)
-; CHECK-NEXT: store volatile i32 [[UMUL_FIX_I32]], ptr [[P]], align 4
-; CHECK-NEXT: [[UMUL_FIX_4XI32:%.*]] = call <4 x i32> @llvm.umul.fix.v4i32(<4 x i32> poison, <4 x i32> poison, i32 2)
-; CHECK-NEXT: store volatile <4 x i32> [[UMUL_FIX_4XI32]], ptr [[P]], align 16
+; CHECK-NEXT: store volatile i16 poison, ptr [[P:%.*]], align 2
+; CHECK-NEXT: store volatile i32 poison, ptr [[P]], align 4
+; CHECK-NEXT: store volatile <4 x i32> poison, ptr [[P]], align 16
; CHECK-NEXT: ret void
;
%umul_fix_i16 = call i16 @llvm.umul.fix(i16 poison, i16 poison, i32 2)
@@ -645,12 +594,9 @@ define void @umul_fix_poison(ptr %P) {
define void @umul_fix_sat_poison(ptr %P) {
; CHECK-LABEL: @umul_fix_sat_poison(
-; CHECK-NEXT: [[UMUL_FIX_SATI16:%.*]] = call i16 @llvm.umul.fix.sat.i16(i16 poison, i16 poison, i32 2)
-; CHECK-NEXT: store volatile i16 [[UMUL_FIX_SATI16]], ptr [[P:%.*]], align 2
-; CHECK-NEXT: [[UMUL_FIX_SATI32:%.*]] = call i32 @llvm.umul.fix.sat.i32(i32 poison, i32 poison, i32 2)
-; CHECK-NEXT: store volatile i32 [[UMUL_FIX_SATI32]], ptr [[P]], align 4
-; CHECK-NEXT: [[UMUL_FIX_SAT4XI32:%.*]] = call <4 x i32> @llvm.umul.fix.sat.v4i32(<4 x i32> poison, <4 x i32> poison, i32 2)
-; CHECK-NEXT: store volatile <4 x i32> [[UMUL_FIX_SAT4XI32]], ptr [[P]], align 16
+; CHECK-NEXT: store volatile i16 poison, ptr [[P:%.*]], align 2
+; CHECK-NEXT: store volatile i32 poison, ptr [[P]], align 4
+; CHECK-NEXT: store volatile <4 x i32> poison, ptr [[P]], align 16
; CHECK-NEXT: ret void
;
%umul_fix_sati16 = call i16 @llvm.umul.fix.sat(i16 poison, i16 poison, i32 2)
diff --git a/llvm/unittests/Analysis/ValueTrackingTest.cpp b/llvm/unittests/Analysis/ValueTrackingTest.cpp
index 4b476551f63d9..6af20065213ac 100644
--- a/llvm/unittests/Analysis/ValueTrackingTest.cpp
+++ b/llvm/unittests/Analysis/ValueTrackingTest.cpp
@@ -915,11 +915,11 @@ TEST(ValueTracking, propagatesPoison) {
{true, "call float @llvm.sin.f32(float %fx)", 0},
{true, "call float @llvm.cos.f32(float %fx)", 0},
{true, "call float @llvm.pow.f32(float %fx, float %fy)", 0},
- {false, "call float @llvm.exp.f32(float %fx)", 0},
- {false, "call float @llvm.exp2.f32(float %fx)", 0},
- {false, "call float @llvm.log.f32(float %fx)", 0},
- {false, "call float @llvm.log10.f32(float %fx)", 0},
- {false, "call float @llvm.log2.f32(float %fx)", 0},
+ {true, "call float @llvm.exp.f32(float %fx)", 0},
+ {true, "call float @llvm.exp2.f32(float %fx)", 0},
+ {true, "call float @llvm.log.f32(float %fx)", 0},
+ {true, "call float @llvm.log10.f32(float %fx)", 0},
+ {true, "call float @llvm.log2.f32(float %fx)", 0},
{false, "call float @llvm.fma.f32(float %fx, float %fx, float %fy)", 0},
{false, "call float @llvm.fabs.f32(float %fx)", 0},
{false, "call float @llvm.minnum.f32(float %fx, float %fy)", 0},
@@ -927,17 +927,17 @@ TEST(ValueTracking, propagatesPoison) {
{false, "call float @llvm.minimum.f32(float %fx, float %fy)", 0},
{false, "call float @llvm.maximum.f32(float %fx, float %fy)", 0},
{false, "call float @llvm.copysign.f32(float %fx, float %fy)", 0},
- {false, "call float @llvm.floor.f32(float %fx)", 0},
- {false, "call float @llvm.ceil.f32(float %fx)", 0},
- {false, "call float @llvm.trunc.f32(float %fx)", 0},
- {false, "call float @llvm.rint.f32(float %fx)", 0},
- {false, "call float @llvm.nearbyint.f32(float %fx)", 0},
- {false, "call float @llvm.round.f32(float %fx)", 0},
- {false, "call float @llvm.roundeven.f32(float %fx)", 0},
+ {true, "call float @llvm.floor.f32(float %fx)", 0},
+ {true, "call float @llvm.ceil.f32(float %fx)", 0},
+ {true, "call float @llvm.trunc.f32(float %fx)", 0},
+ {true, "call float @llvm.rint.f32(float %fx)", 0},
+ {true, "call float @llvm.nearbyint.f32(float %fx)", 0},
+ {true, "call float @llvm.round.f32(float %fx)", 0},
+ {true, "call float @llvm.roundeven.f32(float %fx)", 0},
{false, "call i32 @llvm.lround.f32(float %fx)", 0},
{false, "call i64 @llvm.llround.f32(float %fx)", 0},
- {false, "call i32 @llvm.lrint.f32(float %fx)", 0},
- {false, "call i64 @llvm.llrint.f32(float %fx)", 0},
+ {true, "call i32 @llvm.lrint.f32(float %fx)", 0},
+ {true, "call i64 @llvm.llrint.f32(float %fx)", 0},
{false, "call float @llvm.fmuladd.f32(float %fx, float %fx, float %fy)",
0}};
More information about the llvm-commits
mailing list