[ValueTracking] improve undef/poison analysis for constant vectors

[spatel]

Summary

This overlaps with D76010, but I wanted to check if I'm missing any known corner cases for poison/undef. If so, I can add tests and/or improve the LangRef to make that more obvious.

[aqjune]

As D76010's review is taking time, I'm fine with shipping this first.

llvm/lib/Analysis/ValueTracking.cpp

4633

We should check whether the constant or an element of it is not constexpr too.

[spatel]

Patch updated:
Disallow constant expressions or constant expression elements in a vector (tests added with rG6c3c7a0).
Could we unwrap the ConstExpr by opcode similar to what we are doing for Instruction as a follow-up improvement?

[aqjune]

In D76702#1939368, @spatel wrote:

Could we unwrap the ConstExpr by opcode similar to what we are doing for Instruction as a follow-up improvement?

Oh yes, I agree it will be great.

llvm/lib/Analysis/ValueTracking.cpp

4633

Just realized that struct values can be given to freeze operation as well, sorry. Fully implementing this will require recursive call of this function.
What about covering ConstantDataVector first? The case which raised https://reviews.llvm.org/D76483 's regression was related with constant vector only.

[spatel]

Patch updated:
Just whitelist vector constants in this patch.

[aqjune]

Thank you. I'll update the relevant part at D76010.

llvm/lib/Analysis/ValueTracking.cpp

bool llvm::isGuaranteedNotToBeUndefOrPoison(const Value *V,
                                             const DominatorTree *DT) {
   // If the value is a freeze instruction, then it can never
   // be undef or poison.
   if (isa<FreezeInst>(V))
     return true;
   // TODO: Some instructions are guaranteed to return neither undef
   // nor poison if their arguments are not poison/undef.
 
-  // TODO: Deal with other Constant subclasses.
-  if (isa<ConstantInt>(V) || isa<GlobalVariable>(V))
+  if (auto *C = dyn_cast<Constant>(V)) {
+    // TODO: We can analyze ConstExpr by opcode to determine if there is any
+    //       possibility of poison.
+    if (isa<UndefValue>(C) || isa<ConstantExpr>(C))
+      return false;
+
+    // TODO: Add ConstantFP and pointers.
+    if (isa<ConstantInt>(C) || isa<GlobalVariable>(C) )
       return true;
 
+    if (C->getType()->isVectorTy())
+      return !C->containsUndefElement() && !C->containsConstantExpression();
+
+    // TODO: Recursively analyze aggregates or other constants.
+    return false;
+  }
+
   if (auto PN = dyn_cast<PHINode>(V)) {
     if (llvm::all_of(PN->incoming_values(), [](const Use &U) {
           return isa<ConstantInt>(U.get());
         }))
       return true;
   }
 
   if (auto II = dyn_cast<ICmpInst>(V)) {
     if (llvm::all_of(II->operands(), [](const Value *V) {
           return isGuaranteedNotToBeUndefOrPoison(V);
         }))
       return true;

llvm/test/Transforms/InstSimplify/freeze.ll

 define i32 @make_const() {
 ; CHECK-LABEL: @make_const(
 ; CHECK-NEXT:    ret i32 10
 ;
   %x = freeze i32 10
   ret i32 %x
 }
 
+; TODO: This is not poison.
+
 define float @make_const2() {
 ; CHECK-LABEL: @make_const2(
 ; CHECK-NEXT:    [[X:%.*]] = freeze float 1.000000e+01
 ; CHECK-NEXT:    ret float [[X]]
 ;
   %x = freeze float 10.0
   ret float %x
 }
 
 @glb = constant i32 0
 
 define i32* @make_const_glb() {
 ; CHECK-LABEL: @make_const_glb(
 ; CHECK-NEXT:    ret i32* @glb
 ;
   %k = freeze i32* @glb
   ret i32* %k
 }
 
+; TODO: This is not poison.
+
 define i32()* @make_const_fn() {
 ; CHECK-LABEL: @make_const_fn(
 ; CHECK-NEXT:    [[K:%.*]] = freeze i32 ()* @make_const
 ; CHECK-NEXT:    ret i32 ()* [[K]]
 ;
   %k = freeze i32()* @make_const
   ret i32()* %k
 }
 
+; TODO: This is not poison.
+
 define i32* @make_const_null() {
 ; CHECK-LABEL: @make_const_null(
 ; CHECK-NEXT:    [[K:%.*]] = freeze i32* null
 ; CHECK-NEXT:    ret i32* [[K]]
 ;
   %k = freeze i32* null
   ret i32* %k
 }
 
 define <2 x i32> @constvector() {
 ; CHECK-LABEL: @constvector(
-; CHECK-NEXT:    [[X:%.*]] = freeze <2 x i32> <i32 0, i32 1>
-; CHECK-NEXT:    ret <2 x i32> [[X]]
+; CHECK-NEXT:    ret <2 x i32> <i32 0, i32 1>
 ;
   %x = freeze <2 x i32> <i32 0, i32 1>
   ret <2 x i32> %x
 }
 
 define <3 x i5> @constvector_weird() {
 ; CHECK-LABEL: @constvector_weird(
-; CHECK-NEXT:    [[X:%.*]] = freeze <3 x i5> <i5 0, i5 1, i5 10>
-; CHECK-NEXT:    ret <3 x i5> [[X]]
+; CHECK-NEXT:    ret <3 x i5> <i5 0, i5 1, i5 10>
 ;
   %x = freeze <3 x i5> <i5 0, i5 1, i5 42>
   ret <3 x i5> %x
 }
 
 define <2 x float> @constvector_FP() {
 ; CHECK-LABEL: @constvector_FP(
-; CHECK-NEXT:    [[X:%.*]] = freeze <2 x float> <float 0.000000e+00, float 1.000000e+00>
-; CHECK-NEXT:    ret <2 x float> [[X]]
+; CHECK-NEXT:    ret <2 x float> <float 0.000000e+00, float 1.000000e+00>
 ;
   %x = freeze <2 x float> <float 0.0, float 1.0>
   ret <2 x float> %x
 }
 
+; Negative test
+
 define <2 x i32> @constvector_noopt() {
 ; CHECK-LABEL: @constvector_noopt(
 ; CHECK-NEXT:    [[X:%.*]] = freeze <2 x i32> <i32 0, i32 undef>
 ; CHECK-NEXT:    ret <2 x i32> [[X]]
 ;
   %x = freeze <2 x i32> <i32 0, i32 undef>
   ret <2 x i32> %x
 }
 
+; Negative test
+
 define <3 x i5> @constvector_weird_noopt() {
 ; CHECK-LABEL: @constvector_weird_noopt(
 ; CHECK-NEXT:    [[X:%.*]] = freeze <3 x i5> <i5 0, i5 undef, i5 10>
 ; CHECK-NEXT:    ret <3 x i5> [[X]]
 ;
   %x = freeze <3 x i5> <i5 0, i5 undef, i5 42>
   ret <3 x i5> %x
 }
 
+; Negative test
+
 define <2 x float> @constvector_FP_noopt() {
 ; CHECK-LABEL: @constvector_FP_noopt(
 ; CHECK-NEXT:    [[X:%.*]] = freeze <2 x float> <float 0.000000e+00, float undef>
 ; CHECK-NEXT:    ret <2 x float> [[X]]
 ;
   %x = freeze <2 x float> <float 0.0, float undef>
   ret <2 x float> %x
 }
 
 @g = external global i16, align 1
 
+; Negative test
+
 define float @constant_expr() {
 ; CHECK-LABEL: @constant_expr(
 ; CHECK-NEXT:    [[R:%.*]] = freeze float bitcast (i32 ptrtoint (i16* @g to i32) to float)
 ; CHECK-NEXT:    ret float [[R]]
 ;
   %r = freeze float bitcast (i32 ptrtoint (i16* @g to i32) to float)
   ret float %r
 }
 
+; Negative test
+
 define <2 x i31> @vector_element_constant_expr() {
 ; CHECK-LABEL: @vector_element_constant_expr(
 ; CHECK-NEXT:    [[R:%.*]] = freeze <2 x i31> <i31 34, i31 ptrtoint (i16* @g to i31)>
 ; CHECK-NEXT:    ret <2 x i31> [[R]]
 ;
   %r = freeze <2 x i31> <i31 34, i31 ptrtoint (i16* @g to i31)>
   ret <2 x i31> %r
 }