[value-tracking] see through returned attribute.

[vitalybuka]

LGTM This function is used in HWAsan and Asan only. Please make sure check-asan still OK.

llvm/lib/Analysis/ValueTracking.cpp

if (AllocaInst *AI = dyn_cast<AllocaInst>(V)) {
         AddWork(IncValue);
     } else if (auto *SI = dyn_cast<SelectInst>(V)) {
       AddWork(SI->getTrueValue());
       AddWork(SI->getFalseValue());
     } else if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(V)) {
       if (OffsetZero && !GEP->hasAllZeroIndices())
         return nullptr;
       AddWork(GEP->getPointerOperand());
+    } else if (CallBase *CB = dyn_cast<CallBase>(V)) {
+      Value *Returned = CB->getReturnedArgOperand();
+      if (Returned)
+        AddWork(Returned);
+      else
+        return nullptr;
     } else {
       return nullptr;
     }
   } while (!Worklist.empty());
 
   return Result;
 }
 

llvm/test/Instrumentation/HWAddressSanitizer/stack-safety-analysis.ll

 define i32 @test_retptr(i32* %a) sanitize_hwaddress {
 entry:
   ; CHECK-LABEL: @test_retptr
   ; NOSAFETY: call {{.*}}__hwasan_generate_tag
   ; NOSAFETY: call {{.*}}__hwasan_store
   ; SAFETY: call {{.*}}__hwasan_generate_tag
   ; SAFETY-NOT: call {{.*}}__hwasan_store
   ; NOSTACK-NOT: call {{.*}}__hwasan_generate_tag
-  ; TODO: Do not emit this store.
-  ; NOSTACK: call {{.*}}__hwasan_store
+  ; NOSTACK-NOT: call {{.*}}__hwasan_store
   %buf.sroa.0 = alloca i8, align 4
   call void @llvm.lifetime.start.p0i8(i64 1, i8* nonnull %buf.sroa.0)
   %ptr = call i8* @retptr(i8* %buf.sroa.0)
   store volatile i8 0, i8* %ptr, align 4, !tbaa !8
   call void @llvm.lifetime.end.p0i8(i64 1, i8* nonnull %buf.sroa.0)
   ret i32 0
 }
 

llvm/unittests/Analysis/ValueTrackingTest.cpp

false, false},
       bb1:
         %r = phi i32* [ %a, %entry ], [ %b, %bb1 ]
         br i1 %cond, label %bb1, label %exit
 
       exit:
         ret void
       })",
      false, false},
+    {R"(
+      declare i32* @retptr(i32* returned)
+      define void @test(i1 %cond) {
+        %a = alloca i32
+        %r = call i32* @retptr(i32* %a)
+        ret void
+      })",
+     true, true},
+    {R"(
+      declare i32* @fun(i32*)
+      define void @test(i1 %cond) {
+        %a = alloca i32
+        %r = call i32* @fun(i32* %a)
+        ret void
+      })",
+     false, false},
 };
 
 TEST_P(FindAllocaForValueTest, findAllocaForValue) {
   auto M = parseModule(GetParam().IR);
   Function *F = M->getFunction("test");
   Instruction *I = &findInstructionByName(F, "r");
   const AllocaInst *AI = findAllocaForValue(I);
   EXPECT_EQ(!!AI, GetParam().AnyOffsetResult);