msan, codegen, instcombine: Keep more lifetime markers used for msan

[vitalybuka]

return hwasan

[vitalybuka]

fix compilation error

[vitalybuka]

update comment

[lebedev.ri]

llvm/test/Transforms/InstCombine/lifetime-sanitizer.ll

37–50

Would be good to have end-to-end test (-O0/-O1/-O2/-O3) in PhaseOrdering.

[eugenis]

LGTM

llvm/test/Transforms/InstCombine/lifetime-sanitizer.ll

37–50

Do you mean exact same test, but with -O0/../-O3 instead of -instcombine?

[lebedev.ri]

llvm/test/Transforms/InstCombine/lifetime-sanitizer.ll

37–50

Yes, but please put it into PhaseOrdering directory,

clang/lib/CodeGen/CGExpr.cpp

case SD_FullExpression: {
       // marker. Instead, start the lifetime of a conditional temporary earlier
       // so that it's unconditional. Don't do this in ASan's use-after-scope
       // mode so that it gets the more precise lifetime marks. If the type has
       // a non-trivial destructor, we'll have a cleanup block for it anyway,
       // so this typically doesn't help; skip it in that case.
       ConditionalEvaluation *OldConditional = nullptr;
       CGBuilderTy::InsertPoint OldIP;
       if (isInConditionalBranch() && !E->getType().isDestructedType() &&
+          !SanOpts.has(SanitizerKind::Memory) &&
           !CGM.getCodeGenOpts().SanitizeAddressUseAfterScope) {
         OldConditional = OutermostConditional;
         OutermostConditional = nullptr;
 
         OldIP = Builder.saveIP();
         llvm::BasicBlock *Block = OldConditional->getStartingBlock();
         Builder.restoreIP(CGBuilderTy::InsertPoint(
             Block, llvm::BasicBlock::iterator(Block->back())));

clang/lib/CodeGen/CodeGenFunction.cpp

 
 /// shouldEmitLifetimeMarkers - Decide whether we need emit the life-time
 /// markers.
 static bool shouldEmitLifetimeMarkers(const CodeGenOptions &CGOpts,
                                       const LangOptions &LangOpts) {
   if (CGOpts.DisableLifetimeMarkers)
     return false;
 
-  // Disable lifetime markers in msan builds.
-  // FIXME: Remove this when msan works with lifetime markers.
-  if (LangOpts.Sanitize.has(SanitizerKind::Memory))
-    return false;
-
-  // Asan uses markers for use-after-scope checks.
-  if (CGOpts.SanitizeAddressUseAfterScope)
+  // Sanitizers may use markers.
+  if (CGOpts.SanitizeAddressUseAfterScope ||
+      LangOpts.Sanitize.has(SanitizerKind::Memory)
     return true;
 
   // For now, only in optimized builds.
   return CGOpts.OptimizationLevel != 0;
 }
 
 CodeGenFunction::CodeGenFunction(CodeGenModule &cgm, bool suppressNewContext)
     : CodeGenTypeCache(cgm), CGM(cgm), Target(cgm.getTarget()),

clang/test/CodeGen/lifetime-sanitizer.c

 // RUN: %clang -target x86_64-linux-gnu -S -emit-llvm -o - -O0 %s | FileCheck %s -check-prefix=CHECK-O0
 // RUN: %clang -target x86_64-linux-gnu -S -emit-llvm -o - -O0 \
 // RUN:     -fsanitize=address -fsanitize-address-use-after-scope %s | \
 // RUN:     FileCheck %s -check-prefix=LIFETIME
+// RUN: %clang -target x86_64-linux-gnu -S -emit-llvm -o - -O0 \
+// RUN:     -fsanitize=memory %s | \
+// RUN:     FileCheck %s -check-prefix=LIFETIME
 
 extern int bar(char *A, int n);
 
 // CHECK-O0-NOT: @llvm.lifetime.start
 int foo(int n) {
   if (n) {
     // LIFETIME: @llvm.lifetime.start.p0i8(i64 10, i8* {{.*}})
     char A[10];

clang/test/CodeGenCXX/lifetime-sanitizer.cpp

 // RUN: %clang -w -target x86_64-linux-gnu -S -emit-llvm -o - -fno-exceptions -O0 %s | \
 // RUN:      FileCheck %s -check-prefixes=CHECK,CHECK-O0 --implicit-check-not=llvm.lifetime
 // RUN: %clang -w -target x86_64-linux-gnu -S -emit-llvm -o - -fno-exceptions -O0 \
 // RUN:     -fsanitize=address -fsanitize-address-use-after-scope %s | \
 // RUN:     FileCheck %s -check-prefixes=CHECK,LIFETIME
+// RUN: %clang -w -target x86_64-linux-gnu -S -emit-llvm -o - -fno-exceptions -O0 \
+// RUN:     -fsanitize=memory %s | \
+// RUN:     FileCheck %s -check-prefixes=CHECK,LIFETIME
 
 extern int bar(char *A, int n);
 
 struct X {
   X();
   ~X();
   int *p;
 };

compiler-rt/test/msan/loop-scope.cpp

+// RUN: %clangxx_msan -O2 %s -o %t && \
+// RUN:     not %run %t 2>&1 | FileCheck %s
+
+#include <stdlib.h>
+
+int *p;
+
+int main() {
+  for (int i = 0; i < 3; i++) {
+    int x;
+    if (i == 0)
+      x = 0;
+    p = &x;
+  }
+  return *p; // BOOM
+  // CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
+  // CHECK:  #0 0x{{.*}} in main {{.*}}loop-scope.cpp:[[@LINE-2]]
+}

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

case Intrinsic::stackrestore: {
     if (!CannotRemove && (isa<ReturnInst>(TI) || isa<ResumeInst>(TI)))
       return eraseInstFromFunction(CI);
     break;
   }
   case Intrinsic::lifetime_start:
     // Asan needs to poison memory to detect invalid access which is possible
     // even for empty lifetime range.
     if (II->getFunction()->hasFnAttribute(Attribute::SanitizeAddress) ||
-        II->getFunction()->hasFnAttribute(Attribute::SanitizeHWAddress))
+        II->getFunction()->hasFnAttribute(Attribute::SanitizeMemory))
       break;
 
     if (removeTriviallyEmptyRange(*II, Intrinsic::lifetime_start,
                                   Intrinsic::lifetime_end, *this))
       return nullptr;
     break;
   case Intrinsic::assume: {
     Value *IIOperand = II->getArgOperand(0);

llvm/test/Transforms/InstCombine/lifetime-sanitizer.ll

entry:
   ; CHECK: call void @llvm.lifetime.start
   ; CHECK-NEXT: call void @llvm.lifetime.end
 
   call void @foo(i8* %text) ; Keep alloca alive
 
   ret void
 }
 
+define void @msan() sanitize_memory {
+entry:
+  ; CHECK-LABEL: @msan(
+  %text = alloca i8, align 1
+
+  call void @llvm.lifetime.start.p0i8(i64 1, i8* %text)
+  call void @llvm.lifetime.end.p0i8(i64 1, i8* %text)
+  ; CHECK: call void @llvm.lifetime.start
+  ; CHECK-NEXT: call void @llvm.lifetime.end
+
+  call void @foo(i8* %text) ; Keep alloca alive
+
+  ret void
+}
+
 define void @no_asan() {
 entry:
   ; CHECK-LABEL: @no_asan(
   %text = alloca i8, align 1
 
   call void @llvm.lifetime.start.p0i8(i64 1, i8* %text)
   call void @llvm.lifetime.end.p0i8(i64 1, i8* %text)
   ; CHECK-NO: call void @llvm.lifetime
 
   call void @foo(i8* %text) ; Keep alloca alive
 
   ret void
 }