[ValueTracking] Infer context for arguments

[reames]

Summary

This is yet another alternative patch in the D93974, D97077. and D97092 family.

The notion of this patch is that we can set the context for the argument the same way we do for instructions. This doesn't solve the ephemeral value case, but as demonstrated by the test cases, it does handle other cases.

I'm going to respond on D97092 with a bit more context. We could view this change as splitting out part of the functionality from D97092, or as a step towards a possible alternate.

[reames]

A common issue to all four alternative approaches has come up in the review for D97092. Marking this as Plan Changes until discussion converges and we decide what to do about the common issue.

llvm/lib/Analysis/ValueTracking.cpp

static const Instruction *safeCxtI(const Value *V, const Instruction *CxtI) {
   if (CxtI && CxtI->getParent())
     return CxtI;
 
   // If the value is really an already-inserted instruction, then use that.
   CxtI = dyn_cast<Instruction>(V);
   if (CxtI && CxtI->getParent())
     return CxtI;
 
+  // For an argument, we can use the start of the function.
+  if (auto *A = dyn_cast<Argument>(V))
+    if (A->getParent() && !A->getParent()->empty())
+      return CxtI = &*(A->getParent()->getEntryBlock().begin());
+
   return nullptr;
 }
 
 static const Instruction *safeCxtI(const Value *V1, const Value *V2, const Instruction *CxtI) {
   // If we've been provided with a context instruction, then use that (provided
   // it has been inserted).
   if (CxtI && CxtI->getParent())
     return CxtI;
 
   // If the value is really an already-inserted instruction, then use that.
   CxtI = dyn_cast<Instruction>(V1);
   if (CxtI && CxtI->getParent())
     return CxtI;
 
   CxtI = dyn_cast<Instruction>(V2);
   if (CxtI && CxtI->getParent())
     return CxtI;
 
+  // For an argument, we can use the start of the function.
+  if (auto *A = dyn_cast<Argument>(V1))
+    if (A->getParent() && !A->getParent()->empty())
+      return CxtI = &*(A->getParent()->getEntryBlock().begin());
+
+  if (auto *A = dyn_cast<Argument>(V2))
+    if (A->getParent() && !A->getParent()->empty())
+      return CxtI = &*(A->getParent()->getEntryBlock().begin());
+
   return nullptr;
 }
 
 static bool getShuffleDemandedElts(const ShuffleVectorInst *Shuf,
                                    const APInt &DemandedElts,
                                    APInt &DemandedLHS, APInt &DemandedRHS) {
   // The length of scalable vectors is unknown at compile time, thus we
   // cannot check their values

llvm/test/Analysis/ScalarEvolution/ranges.ll

;
   ret i64 %ashr
 }
 
 
 define i32 @shl(i32 %a) {
 ; CHECK-LABEL: 'shl'
 ; CHECK-NEXT:  Classifying expressions for: @shl
 ; CHECK-NEXT:    %res = shl i32 %a, 2
-; CHECK-NEXT:    --> (4 * %a) U: [0,-3) S: [-2147483648,2147483645)
+; CHECK-NEXT:    --> (4 * %a)<nuw><nsw> U: [0,4093) S: [0,4093)
 ; CHECK-NEXT:  Determining loop execution counts for: @shl
 ;
   %res = shl i32 %a, 2
   %pos = icmp ult i32 %a, 1024
   call void @llvm.assume(i1 %pos)
   ret i32 %res
 }
 
 define i32 @lshr(i32 %a) {
 ; CHECK-LABEL: 'lshr'
 ; CHECK-NEXT:  Classifying expressions for: @lshr
 ; CHECK-NEXT:    %res = lshr i32 %a, 31
-; CHECK-NEXT:    --> (%a /u -2147483648) U: [0,2) S: [0,2)
+; CHECK-NEXT:    --> (%a /u -2147483648) U: [0,1) S: [0,1)
 ; CHECK-NEXT:  Determining loop execution counts for: @lshr
 ;
   %res = lshr i32 %a, 31
   %pos = icmp sge i32 %a, 0
   call void @llvm.assume(i1 %pos)
   ret i32 %res
 }
 
 
 define i32 @udiv(i32 %a) {
 ; CHECK-LABEL: 'udiv'
 ; CHECK-NEXT:  Classifying expressions for: @udiv
 ; CHECK-NEXT:    %res = udiv i32 %a, -2147483648
-; CHECK-NEXT:    --> (%a /u -2147483648) U: [0,2) S: [0,2)
+; CHECK-NEXT:    --> (%a /u -2147483648) U: [0,1) S: [0,1)
 ; CHECK-NEXT:  Determining loop execution counts for: @udiv
 ;
   %res = udiv i32 %a, 2147483648
   %pos = icmp sge i32 %a, 0
   call void @llvm.assume(i1 %pos)
   ret i32 %res
 }
 
 define i64 @sext(i8 %a) {
 ; CHECK-LABEL: 'sext'
 ; CHECK-NEXT:  Classifying expressions for: @sext
 ; CHECK-NEXT:    %res = sext i8 %a to i64
-; CHECK-NEXT:    --> (sext i8 %a to i64) U: [-128,128) S: [-128,128)
+; CHECK-NEXT:    --> (zext i8 %a to i64) U: [0,128) S: [0,128)
 ; CHECK-NEXT:  Determining loop execution counts for: @sext
 ;
   %res = sext i8 %a to i64
   %pos = icmp sge i8 %a, 0
   call void @llvm.assume(i1 %pos)
   ret i64 %res
 }
 
 define i64 @zext(i8 %a) {
 ; CHECK-LABEL: 'zext'
 ; CHECK-NEXT:  Classifying expressions for: @zext
 ; CHECK-NEXT:    %res = zext i8 %a to i64
-; CHECK-NEXT:    --> (zext i8 %a to i64) U: [0,256) S: [0,256)
+; CHECK-NEXT:    --> (zext i8 %a to i64) U: [0,128) S: [0,128)
 ; CHECK-NEXT:  Determining loop execution counts for: @zext
 ;
   %res = zext i8 %a to i64
   %pos = icmp sge i8 %a, 0
   call void @llvm.assume(i1 %pos)
   ret i64 %res
 }