[llvm] [InstSimplify] Optimize maximumnum and minimumnum (PR #139581)

[Lewis Crawford via llvm-commits]

================
@@ -921,89 +1170,121 @@ define <2 x double> @minimum_nan_op1_vec(<2 x double> %x) {
   ret <2 x double> %r
 }
 
-define float @maximum_undef_op1(float %x) {
-; CHECK-LABEL: @maximum_undef_op1(
-; CHECK-NEXT:    ret float [[X:%.*]]
+define double @maximum_snan_op0(double %x) {
+; CHECK-LABEL: @maximum_snan_op0(
+; CHECK-NEXT:    ret double 0x7FFC000000000000
 ;
-  %val = call float @llvm.maximum.f32(float %x, float undef)
-  ret float %val
+  %r = call double @llvm.maximum.f64(double 0x7ff4000000000000, double %x)
+  ret double %r
 }
 
-define float @maximum_poison_op1(float %x) {
-; CHECK-LABEL: @maximum_poison_op1(
-; CHECK-NEXT:    ret float [[X:%.*]]
+define double @maximum_snan_op1(double %x) {
+; CHECK-LABEL: @maximum_snan_op1(
+; CHECK-NEXT:    ret double 0x7FFC00000000DEAD
 ;
-  %val = call float @llvm.maximum.f32(float %x, float poison)
-  ret float %val
+  %r = call double @llvm.maximum.f64(double %x, double 0x7ff400000000dead)
+  ret double %r
 }
 
-define float @maximum_undef_op0(float %x) {
-; CHECK-LABEL: @maximum_undef_op0(
-; CHECK-NEXT:    ret float [[X:%.*]]
+define double @minimum_snan_op0(double %x) {
+; CHECK-LABEL: @minimum_snan_op0(
+; CHECK-NEXT:    ret double 0x7FFC000DEAD00000
 ;
-  %val = call float @llvm.maximum.f32(float undef, float %x)
-  ret float %val
+  %r = call double @llvm.minimum.f64(double 0x7ff4000dead00000, double %x)
+  ret double %r
 }
 
-define float @maximum_poison_op0(float %x) {
-; CHECK-LABEL: @maximum_poison_op0(
-; CHECK-NEXT:    ret float [[X:%.*]]
+define double @minimum_snan_op1(double %x) {
+; CHECK-LABEL: @minimum_snan_op1(
+; CHECK-NEXT:    ret double 0x7FFC00DEAD00DEAD
 ;
-  %val = call float @llvm.maximum.f32(float poison, float %x)
-  ret float %val
+  %r = call double @llvm.minimum.f64(double %x, double 0x7ff400dead00dead)
+  ret double %r
 }
 
-define float @minimum_undef_op1(float %x) {
-; CHECK-LABEL: @minimum_undef_op1(
-; CHECK-NEXT:    ret float [[X:%.*]]
+define <2 x double> @maximum_snan_op0_vec_partial_poison(<2 x double> %x) {
+; CHECK-LABEL: @maximum_snan_op0_vec_partial_poison(
+; CHECK-NEXT:    ret <2 x double> <double 0x7FFC000000000000, double poison>
 ;
-  %val = call float @llvm.minimum.f32(float %x, float undef)
-  ret float %val
+  %r = call <2 x double> @llvm.maximum.v2f64(<2 x double> <double 0x7ff4000000000000, double poison>, <2 x double> %x)
+  ret <2 x double> %r
 }
 
-define float @minimum_poison_op1(float %x) {
-; CHECK-LABEL: @minimum_poison_op1(
-; CHECK-NEXT:    ret float [[X:%.*]]
+define <2 x double> @maximum_snan_op1_vec_partial_poison(<2 x double> %x) {
+; CHECK-LABEL: @maximum_snan_op1_vec_partial_poison(
+; CHECK-NEXT:    ret <2 x double> <double 0x7FFC000000000000, double poison>
 ;
-  %val = call float @llvm.minimum.f32(float %x, float poison)
-  ret float %val
+  %r = call <2 x double> @llvm.maximum.v2f64(<2 x double> %x, <2 x double> <double 0x7ff4000000000000, double poison>)
+  ret <2 x double> %r
 }
 
-define float @minimum_undef_op0(float %x) {
-; CHECK-LABEL: @minimum_undef_op0(
-; CHECK-NEXT:    ret float [[X:%.*]]
+define <2 x double> @maximum_snan_op1_vec(<2 x double> %x) {
+; CHECK-LABEL: @maximum_snan_op1_vec(
+; CHECK-NEXT:    ret <2 x double> <double 0x7FFC00000000DEAD, double 0x7FFCFFFFFFFFFFFF>
 ;
-  %val = call float @llvm.minimum.f32(float undef, float %x)
-  ret float %val
+  %r = call <2 x double> @llvm.maximum.v2f64(<2 x double> %x, <2 x double> <double 0x7ff400000000dead, double 0x7ff4ffffffffffff>)
+  ret <2 x double> %r
 }
 
-define float @minimum_poison_op0(float %x) {
-; CHECK-LABEL: @minimum_poison_op0(
-; CHECK-NEXT:    ret float [[X:%.*]]
+define <2 x double> @minimum_snan_op0_vec_partial_poison(<2 x double> %x) {
+; CHECK-LABEL: @minimum_snan_op0_vec_partial_poison(
+; CHECK-NEXT:    ret <2 x double> <double poison, double 0x7FFC000DEAD00000>
 ;
-  %val = call float @llvm.minimum.f32(float poison, float %x)
-  ret float %val
+  %r = call <2 x double> @llvm.minimum.v2f64(<2 x double> <double poison, double 0x7ff4000dead00000>, <2 x double> %x)
+  ret <2 x double> %r
 }
 
-define float @minimum_undef_undef(float %x) {
-; CHECK-LABEL: @minimum_undef_undef(
-; CHECK-NEXT:    ret float undef
+define <2 x double> @minimum_snan_op1_vec_partial_poison(<2 x double> %x) {
+; CHECK-LABEL: @minimum_snan_op1_vec_partial_poison(
+; CHECK-NEXT:    ret <2 x double> <double poison, double 0x7FFC000DEAD00000>
 ;
-  %val = call float @llvm.minimum.f32(float undef, float undef)
-  ret float %val
+  %r = call <2 x double> @llvm.minimum.v2f64(<2 x double> %x, <2 x double> <double poison, double 0x7ff4000dead00000>)
+  ret <2 x double> %r
 }
 
-define float @maximum_undef_undef(float %x) {
-; CHECK-LABEL: @maximum_undef_undef(
-; CHECK-NEXT:    ret float undef
+define <2 x double> @minimum_snan_op1_vec(<2 x double> %x) {
+; CHECK-LABEL: @minimum_snan_op1_vec(
+; CHECK-NEXT:    ret <2 x double> splat (double 0x7FFC00DEAD00DEAD)
 ;
-  %val = call float @llvm.maximum.f32(float undef, float undef)
-  ret float %val
+  %r = call <2 x double> @llvm.minimum.v2f64(<2 x double> %x, <2 x double> <double 0x7ff400dead00dead, double 0x7ff400dead00dead>)
+  ret <2 x double> %r
 }
 
-define float @minimum_same_args(float %x) {
-; CHECK-LABEL: @minimum_same_args(
-; CHECK-NEXT:    ret float [[X:%.*]]
+define float @maximum_poison_op1(float %x) {
+; CHECK-LABEL: @maximum_poison_op1(
+; CHECK-NEXT:    ret float [[X:%.*]]
+;
+  %val = call float @llvm.maximum.f32(float %x, float poison)
+  ret float %val
+}
+
+define float @maximum_poison_op0(float %x) {
+; CHECK-LABEL: @maximum_poison_op0(
+; CHECK-NEXT:    ret float [[X:%.*]]
+;
+  %val = call float @llvm.maximum.f32(float poison, float %x)
+  ret float %val
+}
+
+define float @minimum_poison_op1(float %x) {
+; CHECK-LABEL: @minimum_poison_op1(
+; CHECK-NEXT:    ret float [[X:%.*]]
+;
+  %val = call float @llvm.minimum.f32(float %x, float poison)
+  ret float %val
+}
+
+define float @minimum_poison_op0(float %x) {
+; CHECK-LABEL: @minimum_poison_op0(
+; CHECK-NEXT:    ret float [[X:%.*]]
+;
+  %val = call float @llvm.minimum.f32(float poison, float %x)
----------------
LewisCrawford wrote:

Yes, all versions of the intrinsics will match both undef and poison. I've avoided adding undef versions of the new tests for maximumnum due to the undef depracation effort, and all the automated checking trying to prevent new tests using undef. Initially, I also deleted the pre-existing tests for maxnum/maximum with undef too, but I've un-deleted those now.

https://github.com/llvm/llvm-project/pull/139581