[asan] Add flag to allow lifetime analysis of problematic allocas

[vitalybuka]

Summary

Could be useful for comparison when we suspect that alloca was skipped
because of this.

llvm/trunk/lib/Transforms/Instrumentation/AddressSanitizer.cpp

static cl::opt<bool> ClUseAfterReturn("asan-use-after-return",
                                       cl::Hidden, cl::init(true));
 static cl::opt<bool> ClUseAfterScope("asan-use-after-scope",
                                      cl::desc("Check stack-use-after-scope"),
                                      cl::Hidden, cl::init(false));
 static cl::opt<bool> ClExperimentalPoisoning(
     "asan-experimental-poisoning",
     cl::desc("Enable experimental red zones and scope poisoning"), cl::Hidden,
     cl::init(true));
+static cl::opt<bool> ClSkipAmbiguousLifetimeAllocas(
+    "asan-skip-ambiguous-lifetime-allocas",
+    cl::desc("Disabled lifetime check for allocas with ambiguous lifetime"),
+    cl::Hidden, cl::init(true));
 // This flag may need to be replaced with -f[no]asan-globals.
 static cl::opt<bool> ClGlobals("asan-globals",
                                cl::desc("Handle global objects"), cl::Hidden,
                                cl::init(true));
 static cl::opt<bool> ClInitializers("asan-initialization-order",
                                     cl::desc("Handle C++ initializer order"),
                                     cl::Hidden, cl::init(true));
 static cl::opt<bool> ClInvalidPointerPairs(

 
 // Removes allocas for which exists at least one block simultaneously
 // reachable in both states: allocas is inside the scope, and alloca is outside
 // of the scope. We don't have enough information to validate access to such
 // variable, so we just remove such allocas from lifetime analysis.
 // This is workaround for PR28267.
 void removeAllocasWithAmbiguousLifetime(
     SmallVectorImpl<FunctionStackPoisoner::AllocaPoisonCall> &PoisonCallVec) {
+  if (!ClSkipAmbiguousLifetimeAllocas)
+    return;
   DenseMap<const AllocaInst *, AllocaLifetimeChecker> Checkers;
   for (const auto &APC : PoisonCallVec)
     Checkers[APC.AI].AddMarker(APC.InsBefore->getParent(), !APC.DoPoison);
 
   auto IsAmbiguous =
       [&Checkers](const FunctionStackPoisoner::AllocaPoisonCall &APC) {
         return Checkers[APC.AI].HasAmbiguousLifetime();
       };

llvm/trunk/test/Instrumentation/AddressSanitizer/lifetime.ll

 ; Test handling of llvm.lifetime intrinsics.
-; RUN: opt < %s -asan -asan-module -asan-use-after-scope -asan-use-after-return=0 -S | FileCheck %s
-; RUN: opt < %s -asan -asan-module -asan-use-after-scope -asan-use-after-return=0 -asan-instrument-dynamic-allocas=0 -S | FileCheck %s --check-prefix=CHECK-NO-DYNAMIC
+; RUN: opt < %s -asan -asan-module -asan-use-after-scope -asan-use-after-return=0 -S | FileCheck %s --check-prefixes=CHECK,CHECK-DEFAULT
+; RUN: opt < %s -asan -asan-module -asan-use-after-scope -asan-use-after-return=0 -asan-instrument-dynamic-allocas=0 -S | FileCheck %s --check-prefixes=CHECK,CHECK-NO-DYNAMIC
+; RUN: opt < %s -asan -asan-module -asan-use-after-scope -asan-use-after-return=0 -asan-skip-ambiguous-lifetime-allocas=0 -S | FileCheck %s --check-prefixes=CHECK,CHECK-AMBIGUOUS
 
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 declare void @llvm.lifetime.start(i64, i8* nocapture) nounwind
 declare void @llvm.lifetime.end(i64, i8* nocapture) nounwind
 
 define void @lifetime_no_size() sanitize_address {
define void @lifetime() sanitize_address {
   ; CHECK: store i8 -8, i8* %{{[0-9]+}}
   ; CHECK-NEXT: call void @llvm.lifetime.end
 
   ; Lifetime intrinsics for array.
   %arr = alloca [10 x i32], align 16
   %arr.ptr = bitcast [10 x i32]* %arr to i8*
 
   call void @llvm.lifetime.start(i64 40, i8* %arr.ptr)
-  ; CHECK: call void @__asan_unpoison_stack_memory(i64 %{{[^ ]+}}, i64 40)
+  ; CHECK-DEFAULT: call void @__asan_unpoison_stack_memory(i64 %{{[^ ]+}}, i64 40)
   ; CHECK-NO-DYNAMIC-NOT: call void @__asan_unpoison_stack_memory(i64 %{{[^ ]+}}, i64 40)
 
   store volatile i8 0, i8* %arr.ptr
   ; CHECK: store volatile
 
   call void @llvm.lifetime.end(i64 40, i8* %arr.ptr)
-  ; CHECK: call void @__asan_poison_stack_memory(i64 %{{[^ ]+}}, i64 40)
+  ; CHECK-DEFAULT: call void @__asan_poison_stack_memory(i64 %{{[^ ]+}}, i64 40)
   ; CHECK-NO-DYNAMIC-NOT: call void @__asan_poison_stack_memory(i64 %{{[^ ]+}}, i64 40)
 
   ; One more lifetime start/end for the same variable %i.
   call void @llvm.lifetime.start(i64 2, i8* %i.ptr)
   ; CHECK: store i8 4, i8* %{{[0-9]+}}
   ; CHECK-NEXT: llvm.lifetime.start
 
   store volatile i8 0, i8* %i.ptr
entry:
   ; CHECK-NEXT: call void @llvm.lifetime.start
 
   br i1 %x, label %bb0, label %bb1
 
 bb0:
   ; CHECK-LABEL: bb0:
 
   call void @llvm.lifetime.start(i64 1, i8* %j)
-  ; CHECK-NOT: store i8 1, i8* %{{[0-9]+}}
+  ; CHECK-DEFAULT-NOT: store i8 1, i8* %{{[0-9]+}}
+  ; CHECK-AMBIGUOUS: store i8 1, i8* %{{[0-9]+}}
   ; CHECK-NEXT: call void @llvm.lifetime.start
 
   br label %bb1
 
 bb1:
   ; CHECK-LABEL: bb1:
 
   store volatile i8 0, i8* %i
   store volatile i8 0, i8* %j
 
   call void @llvm.lifetime.end(i64 1, i8* %i)
   ; CHECK: store i8 -8, i8* %{{[0-9]+}}
   ; CHECK-NEXT: call void @llvm.lifetime.end
 
   call void @llvm.lifetime.end(i64 1, i8* %j)
-  ; CHECK-NOT: store i8 -8, i8* %{{[0-9]+}}
+  ; CHECK-DEFAULT-NOT: store i8 -8, i8* %{{[0-9]+}}
+  ; CHECK-AMBIGUOUS: store i8 -8, i8* %{{[0-9]+}}
   ; CHECK-NEXT: call void @llvm.lifetime.end
 
   ret void
 }
 
 ; Check that arguments of lifetime may come from phi nodes.
 define void @phi_args(i1 %x) sanitize_address {
   ; CHECK-LABEL: define void @phi_args(i1 %x)