This is an archive of the discontinued LLVM Phabricator instance.

Differential D83499

[MSAN runtime] Add poison_stack function that also updates origin
AbandonedPublic

Authored by guiand on Jul 9 2020, 11:54 AM.

Details

Reviewers
eugenis
vitalybuka
Summary

With eager-checks and msan-poison-stack-with-call enabled, this
saves ~1.5% instrumented binary size.

Diff Detail

Event Timeline

guiand created this revision.Jul 9 2020, 11:54 AM
Herald added projects: Restricted Project, Restricted Project. · View Herald TranscriptJul 9 2020, 11:54 AM
Herald added subscribers: llvm-commits, Restricted Project, hiraditya. · View Herald Transcript
Harbormaster failed remote builds in B63620: Diff 276797!Jul 9 2020, 12:17 PM
vitalybuka accepted this revision.Jul 9 2020, 5:55 PM
vitalybuka added inline comments.
llvm/test/Instrumentation/MemorySanitizer/alloca.ll
9

flag order is inconsistent
also line breaks with \ is unnecessary
long lines should be accepted by clang-format -style file in tests

This revision is now accepted and ready to land.Jul 9 2020, 5:55 PM
eugenis requested changes to this revision.Jul 10 2020, 11:39 AM

I don't think 1.5% is good enough to introduce new runtime functions for the off-by-default code path.

This revision now requires changes to proceed.Jul 10 2020, 11:39 AM
guiand abandoned this revision.Jul 29 2020, 11:41 AM

I agree, this probably isn't going to be worth it.

Revision Contents

PathSize
compiler-rt/
lib/
msan/
5 lines
2 lines
llvm/
lib/
Transforms/
Instrumentation/
34 lines
test/
Instrumentation/
MemorySanitizer/
30 lines

Diff 276797

compiler-rt/lib/msan/msan_interceptors.cpp

Show First 20 Lines • Show All 1,537 Lines • ▼ Show 20 Linesvoid __msan_poison(const void *a, uptr size) {
SetShadow(a, size, __msan::flags()->poison_heap_with_zeroes ? 0 : -1); SetShadow(a, size, __msan::flags()->poison_heap_with_zeroes ? 0 : -1);
} }
void __msan_poison_stack(void *a, uptr size) { void __msan_poison_stack(void *a, uptr size) {
if (!MEM_IS_APP(a)) return; if (!MEM_IS_APP(a)) return;
SetShadow(a, size, __msan::flags()->poison_stack_with_zeroes ? 0 : -1); SetShadow(a, size, __msan::flags()->poison_stack_with_zeroes ? 0 : -1);
} }
void __msan_poison_stack_with_origin(void *a, uptr size, char *descr, uptr pc) {
__msan_poison_stack(a, size);
__msan_set_alloca_origin4(a, size, descr, pc);
}
void __msan_unpoison_param(uptr n) { UnpoisonParam(n); } void __msan_unpoison_param(uptr n) { UnpoisonParam(n); }
void __msan_clear_and_unpoison(void *a, uptr size) { void __msan_clear_and_unpoison(void *a, uptr size) {
REAL(memset)(a, 0, size); REAL(memset)(a, 0, size);
SetShadow(a, size, 0); SetShadow(a, size, 0);
} }
void *__msan_memcpy(void *dest, const void *src, SIZE_T n) { void *__msan_memcpy(void *dest, const void *src, SIZE_T n) {
▲ Show 20 Lines • Show All 162 Lines • Show Last 20 Lines

compiler-rt/lib/msan/msan_interface_internal.h

Show First 20 Lines • Show All 82 Lines • ▼ Show 20 Lines
SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_INTERFACE_ATTRIBUTE
void* __msan_memset(void *s, int c, uptr n); void* __msan_memset(void *s, int c, uptr n);
SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_INTERFACE_ATTRIBUTE
void* __msan_memmove(void* dest, const void* src, uptr n); void* __msan_memmove(void* dest, const void* src, uptr n);
SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_INTERFACE_ATTRIBUTE
void __msan_poison(const void *a, uptr size); void __msan_poison(const void *a, uptr size);
SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_INTERFACE_ATTRIBUTE
void __msan_poison_stack(void *a, uptr size); void __msan_poison_stack(void *a, uptr size);
SANITIZER_INTERFACE_ATTRIBUTE
void __msan_poison_stack_with_origin(void *a, uptr size, char *descr, uptr pc);
// Copy size bytes from src to dst and unpoison the result. // Copy size bytes from src to dst and unpoison the result.
// Useful to implement unsafe loads. // Useful to implement unsafe loads.
SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_INTERFACE_ATTRIBUTE
void __msan_load_unpoisoned(void *src, uptr size, void *dst); void __msan_load_unpoisoned(void *src, uptr size, void *dst);
// Returns the offset of the first (at least partially) poisoned byte, // Returns the offset of the first (at least partially) poisoned byte,
// or -1 if the whole range is good. // or -1 if the whole range is good.
▲ Show 20 Lines • Show All 94 Lines • Show Last 20 Lines

llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp

Show First 20 Lines • Show All 559 Lines • ▼ Show 20 Linesprivate:
// These arrays are indexed by log2(AccessSize). // These arrays are indexed by log2(AccessSize).
FunctionCallee MaybeWarningFn[kNumberOfAccessSizes]; FunctionCallee MaybeWarningFn[kNumberOfAccessSizes];
FunctionCallee MaybeStoreOriginFn[kNumberOfAccessSizes]; FunctionCallee MaybeStoreOriginFn[kNumberOfAccessSizes];
/// Run-time helper that generates a new origin value for a stack /// Run-time helper that generates a new origin value for a stack
/// allocation. /// allocation.
FunctionCallee MsanSetAllocaOrigin4Fn; FunctionCallee MsanSetAllocaOrigin4Fn;
/// Run-time helper that poisons stack on function entry. /// Run-time helpers that poison stack on function entry.
FunctionCallee MsanPoisonStackFn; FunctionCallee MsanPoisonStackFn, MsanPoisonStackWithOriginFn;
/// Run-time helper that records a store (or any event) of an /// Run-time helper that records a store (or any event) of an
/// uninitialized value and returns an updated origin id encoding this info. /// uninitialized value and returns an updated origin id encoding this info.
FunctionCallee MsanChainOriginFn; FunctionCallee MsanChainOriginFn;
/// MSan runtime replacements for memmove, memcpy and memset. /// MSan runtime replacements for memmove, memcpy and memset.
FunctionCallee MemmoveFn, MemcpyFn, MemsetFn; FunctionCallee MemmoveFn, MemcpyFn, MemsetFn;
▲ Show 20 Lines • Show All 254 Lines • ▼ Show 20 Linesvoid MemorySanitizer::createUserspaceApi(Module &M) {
} }
MsanSetAllocaOrigin4Fn = M.getOrInsertFunction( MsanSetAllocaOrigin4Fn = M.getOrInsertFunction(
"__msan_set_alloca_origin4", IRB.getVoidTy(), IRB.getInt8PtrTy(), IntptrTy, "__msan_set_alloca_origin4", IRB.getVoidTy(), IRB.getInt8PtrTy(), IntptrTy,
IRB.getInt8PtrTy(), IntptrTy); IRB.getInt8PtrTy(), IntptrTy);
MsanPoisonStackFn = MsanPoisonStackFn =
M.getOrInsertFunction("__msan_poison_stack", IRB.getVoidTy(), M.getOrInsertFunction("__msan_poison_stack", IRB.getVoidTy(),
IRB.getInt8PtrTy(), IntptrTy); IRB.getInt8PtrTy(), IntptrTy);
MsanPoisonStackWithOriginFn =
M.getOrInsertFunction("__msan_poison_stack_with_origin", IRB.getVoidTy(),
IRB.getInt8PtrTy(), IntptrTy, IRB.getInt8PtrTy(),
IntptrTy);
} }
/// Insert extern declaration of runtime-provided functions and globals. /// Insert extern declaration of runtime-provided functions and globals.
void MemorySanitizer::initializeCallbacks(Module &M) { void MemorySanitizer::initializeCallbacks(Module &M) {
// Only do this once. // Only do this once.
if (CallbacksInitialized) if (CallbacksInitialized)
return; return;
▲ Show 20 Lines • Show All 2,729 Lines • ▼ Show 20 Lines Value *getLocalVarDescription(AllocaInst &I) {
// by __msan_va_arg_overflow_size_tls at the first call. // by __msan_va_arg_overflow_size_tls at the first call.
StackDescription << "----" << I.getName() << "@" << F.getName(); StackDescription << "----" << I.getName() << "@" << F.getName();
return createPrivateNonConstGlobalForString(*F.getParent(), return createPrivateNonConstGlobalForString(*F.getParent(),
StackDescription.str()); StackDescription.str());
} }
void poisonAllocaUserspace(AllocaInst &I, IRBuilder<> &IRB, Value *Len) { void poisonAllocaUserspace(AllocaInst &I, IRBuilder<> &IRB, Value *Len) {
if (PoisonStack && ClPoisonStackWithCall) { if (PoisonStack && ClPoisonStackWithCall) {
if (MS.TrackOrigins) {
Value *Descr = getLocalVarDescription(I);
IRB.CreateCall(MS.MsanPoisonStackWithOriginFn,
{IRB.CreatePointerCast(&I, IRB.getInt8PtrTy()), Len,
IRB.CreatePointerCast(Descr, IRB.getInt8PtrTy()),
IRB.CreatePointerCast(&F, MS.IntptrTy)});
} else {
IRB.CreateCall(MS.MsanPoisonStackFn, IRB.CreateCall(MS.MsanPoisonStackFn,
{IRB.CreatePointerCast(&I, IRB.getInt8PtrTy()), Len}); {IRB.CreatePointerCast(&I, IRB.getInt8PtrTy()), Len});
}
} else { } else {
Value *ShadowBase, *OriginBase; Value *ShadowBase, *OriginBase;
std::tie(ShadowBase, OriginBase) = getShadowOriginPtr( std::tie(ShadowBase, OriginBase) = getShadowOriginPtr(
&I, IRB, IRB.getInt8Ty(), Align(1), /*isStore*/ true); &I, IRB, IRB.getInt8Ty(), Align(1), /*isStore*/ true);
Value *PoisonValue = IRB.getInt8(PoisonStack ? ClPoisonStackPattern : 0); Value *PoisonValue = IRB.getInt8(PoisonStack ? ClPoisonStackPattern : 0);
IRB.CreateMemSet(ShadowBase, PoisonValue, Len, IRB.CreateMemSet(ShadowBase, PoisonValue, Len,
MaybeAlign(I.getAlignment())); MaybeAlign(I.getAlignment()));
}
if (PoisonStack && MS.TrackOrigins) { if (PoisonStack && MS.TrackOrigins) {
Value *Descr = getLocalVarDescription(I); Value *Descr = getLocalVarDescription(I);
IRB.CreateCall(MS.MsanSetAllocaOrigin4Fn, IRB.CreateCall(MS.MsanSetAllocaOrigin4Fn,
{IRB.CreatePointerCast(&I, IRB.getInt8PtrTy()), Len, {IRB.CreatePointerCast(&I, IRB.getInt8PtrTy()), Len,
IRB.CreatePointerCast(Descr, IRB.getInt8PtrTy()), IRB.CreatePointerCast(Descr, IRB.getInt8PtrTy()),
IRB.CreatePointerCast(&F, MS.IntptrTy)}); IRB.CreatePointerCast(&F, MS.IntptrTy)});
} }
} }
}
void poisonAllocaKmsan(AllocaInst &I, IRBuilder<> &IRB, Value *Len) { void poisonAllocaKmsan(AllocaInst &I, IRBuilder<> &IRB, Value *Len) {
Value *Descr = getLocalVarDescription(I); Value *Descr = getLocalVarDescription(I);
if (PoisonStack) { if (PoisonStack) {
IRB.CreateCall(MS.MsanPoisonAllocaFn, IRB.CreateCall(MS.MsanPoisonAllocaFn,
{IRB.CreatePointerCast(&I, IRB.getInt8PtrTy()), Len, {IRB.CreatePointerCast(&I, IRB.getInt8PtrTy()), Len,
IRB.CreatePointerCast(Descr, IRB.getInt8PtrTy())}); IRB.CreatePointerCast(Descr, IRB.getInt8PtrTy())});
} else { } else {
▲ Show 20 Lines • Show All 1,450 Lines • Show Last 20 Lines

llvm/test/Instrumentation/MemorySanitizer/alloca.ll

; RUN: opt < %s -msan-check-access-address=0 -S -passes=msan 2>&1 | FileCheck \ ; RUN: opt < %s -msan-check-access-address=0 -S -passes=msan 2>&1 | FileCheck \
; RUN: %s "--check-prefixes=CHECK,INLINE" ; RUN: %s "--check-prefixes=CHECK,INLINE"
; RUN: opt < %s -msan -msan-check-access-address=0 -S | FileCheck %s --check-prefixes=CHECK,INLINE ; RUN: opt < %s -msan -msan-check-access-address=0 -S | FileCheck %s --check-prefixes=CHECK,INLINE
; RUN: opt < %s -msan-check-access-address=0 -msan-poison-stack-with-call=1 -S \ ; RUN: opt < %s -msan-check-access-address=0 -msan-poison-stack-with-call=1 -S \
; RUN: -passes=msan 2>&1 | FileCheck %s "--check-prefixes=CHECK,CALL" ; RUN: -passes=msan 2>&1 | FileCheck %s "--check-prefixes=CHECK,CALL"
; RUN: opt < %s -msan -msan-check-access-address=0 -msan-poison-stack-with-call=1 -S | FileCheck %s --check-prefixes=CHECK,CALL ; RUN: opt < %s -msan -msan-check-access-address=0 -msan-poison-stack-with-call=1 -S | FileCheck %s --check-prefixes=CHECK,CALL
; RUN: opt < %s -msan-check-access-address=0 -msan-poison-stack-with-call=1 \
vitalybukaUnsubmitted
Not Done
ReplyInline Actions

flag order is inconsistent
also line breaks with \ is unnecessary
long lines should be accepted by clang-format -style file in tests

vitalybuka: flag order is inconsistent also line breaks with \ is unnecessary long lines should be…
; RUN: -msan-track-origins=1 -S -passes=msan 2>&1 | FileCheck %s "--check-prefixes=CHECK,CALL-ORIGIN"
; RUN: opt < %s -msan -msan-check-access-address=0 -msan-track-origins=1 \
; RUN: -msan-poison-stack-with-call=1 -S | FileCheck %s --check-prefixes=CHECK,CALL-ORIGIN
; RUN: opt < %s -msan-check-access-address=0 -msan-track-origins=1 -S \ ; RUN: opt < %s -msan-check-access-address=0 -msan-track-origins=1 -S \
; RUN: -passes=msan 2>&1 | FileCheck %s "--check-prefixes=CHECK,ORIGIN" ; RUN: -passes=msan 2>&1 | FileCheck %s "--check-prefixes=CHECK,INLINE,ORIGIN"
; RUN: opt < %s -msan -msan-check-access-address=0 -msan-track-origins=1 -S | FileCheck %s --check-prefixes=CHECK,ORIGIN ; RUN: opt < %s -msan -msan-check-access-address=0 -msan-track-origins=1 -S | FileCheck %s --check-prefixes=CHECK,INLINE,ORIGIN
; RUN: opt < %s -msan-check-access-address=0 -msan-track-origins=2 -S \ ; RUN: opt < %s -msan-check-access-address=0 -msan-track-origins=2 -S \
; RUN: -passes=msan 2>&1 | FileCheck %s "--check-prefixes=CHECK,ORIGIN" ; RUN: -passes=msan 2>&1 | FileCheck %s "--check-prefixes=CHECK,INLINE,ORIGIN"
; RUN: opt < %s -msan -msan-check-access-address=0 -msan-track-origins=2 -S | FileCheck %s --check-prefixes=CHECK,ORIGIN ; RUN: opt < %s -msan -msan-check-access-address=0 -msan-track-origins=2 -S | FileCheck %s --check-prefixes=CHECK,INLINE,ORIGIN
; RUN: opt < %s -S -passes="msan<kernel>" 2>&1 | FileCheck %s \ ; RUN: opt < %s -S -passes="msan<kernel>" 2>&1 | FileCheck %s \
; RUN: "--check-prefixes=CHECK,KMSAN" ; RUN: "--check-prefixes=CHECK,KMSAN"
; RUN: opt < %s -msan-kernel=1 -S -passes=msan 2>&1 | FileCheck %s \ ; RUN: opt < %s -msan-kernel=1 -S -passes=msan 2>&1 | FileCheck %s \
; RUN: "--check-prefixes=CHECK,KMSAN" ; RUN: "--check-prefixes=CHECK,KMSAN"
; RUN: opt < %s -msan -msan-kernel=1 -S | FileCheck %s --check-prefixes=CHECK,KMSAN ; RUN: opt < %s -msan -msan-kernel=1 -S | FileCheck %s --check-prefixes=CHECK,KMSAN
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 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" target triple = "x86_64-unknown-linux-gnu"
define void @static() sanitize_memory { define void @static() sanitize_memory {
entry: entry:
%x = alloca i32, align 4 %x = alloca i32, align 4
ret void ret void
} }
; CHECK-LABEL: define void @static( ; CHECK-LABEL: define void @static(
; INLINE: call void @llvm.memset.p0i8.i64(i8* align 4 {{.*}}, i8 -1, i64 4, i1 false) ; INLINE: call void @llvm.memset.p0i8.i64(i8* align 4 {{.*}}, i8 -1, i64 4, i1 false)
; CALL: call void @__msan_poison_stack(i8* {{.*}}, i64 4) ; CALL: call void @__msan_poison_stack(i8* {{.*}}, i64 4)
; CALL-ORIGIN: call void @__msan_poison_stack_with_origin(i8* {{.*}}, i64 4
; ORIGIN: call void @__msan_set_alloca_origin4(i8* {{.*}}, i64 4, ; ORIGIN: call void @__msan_set_alloca_origin4(i8* {{.*}}, i64 4,
; KMSAN: call void @__msan_poison_alloca(i8* {{.*}}, i64 4, ; KMSAN: call void @__msan_poison_alloca(i8* {{.*}}, i64 4,
; CHECK: ret void ; CHECK: ret void
define void @dynamic() sanitize_memory { define void @dynamic() sanitize_memory {
entry: entry:
br label %l br label %l
l: l:
%x = alloca i32, align 4 %x = alloca i32, align 4
ret void ret void
} }
; CHECK-LABEL: define void @dynamic( ; CHECK-LABEL: define void @dynamic(
; INLINE: call void @llvm.memset.p0i8.i64(i8* align 4 {{.*}}, i8 -1, i64 4, i1 false) ; INLINE: call void @llvm.memset.p0i8.i64(i8* align 4 {{.*}}, i8 -1, i64 4, i1 false)
; CALL: call void @__msan_poison_stack(i8* {{.*}}, i64 4) ; CALL: call void @__msan_poison_stack(i8* {{.*}}, i64 4)
; CALL-ORIGIN: call void @__msan_poison_stack_with_origin(i8* {{.*}}, i64 4
; ORIGIN: call void @__msan_set_alloca_origin4(i8* {{.*}}, i64 4, ; ORIGIN: call void @__msan_set_alloca_origin4(i8* {{.*}}, i64 4,
; KMSAN: call void @__msan_poison_alloca(i8* {{.*}}, i64 4, ; KMSAN: call void @__msan_poison_alloca(i8* {{.*}}, i64 4,
; CHECK: ret void ; CHECK: ret void
define void @array() sanitize_memory { define void @array() sanitize_memory {
entry: entry:
%x = alloca i32, i64 5, align 4 %x = alloca i32, i64 5, align 4
ret void ret void
} }
; CHECK-LABEL: define void @array( ; CHECK-LABEL: define void @array(
; INLINE: call void @llvm.memset.p0i8.i64(i8* align 4 {{.*}}, i8 -1, i64 20, i1 false) ; INLINE: call void @llvm.memset.p0i8.i64(i8* align 4 {{.*}}, i8 -1, i64 20, i1 false)
; CALL: call void @__msan_poison_stack(i8* {{.*}}, i64 20) ; CALL: call void @__msan_poison_stack(i8* {{.*}}, i64 20)
; CALL-ORIGIN: call void @__msan_poison_stack_with_origin(i8* {{.*}}, i64 20
; ORIGIN: call void @__msan_set_alloca_origin4(i8* {{.*}}, i64 20, ; ORIGIN: call void @__msan_set_alloca_origin4(i8* {{.*}}, i64 20,
; KMSAN: call void @__msan_poison_alloca(i8* {{.*}}, i64 20, ; KMSAN: call void @__msan_poison_alloca(i8* {{.*}}, i64 20,
; CHECK: ret void ; CHECK: ret void
define void @array_non_const(i64 %cnt) sanitize_memory { define void @array_non_const(i64 %cnt) sanitize_memory {
entry: entry:
%x = alloca i32, i64 %cnt, align 4 %x = alloca i32, i64 %cnt, align 4
ret void ret void
} }
; CHECK-LABEL: define void @array_non_const( ; CHECK-LABEL: define void @array_non_const(
; CHECK: %[[A:.*]] = mul i64 4, %cnt ; CHECK: %[[A:.*]] = mul i64 4, %cnt
; INLINE: call void @llvm.memset.p0i8.i64(i8* align 4 {{.*}}, i8 -1, i64 %[[A]], i1 false) ; INLINE: call void @llvm.memset.p0i8.i64(i8* align 4 {{.*}}, i8 -1, i64 %[[A]], i1 false)
; CALL: call void @__msan_poison_stack(i8* {{.*}}, i64 %[[A]]) ; CALL: call void @__msan_poison_stack(i8* {{.*}}, i64 %[[A]])
; CALL-ORIGIN: call void @__msan_poison_stack_with_origin(i8* {{.*}}, i64 %[[A]]
; ORIGIN: call void @__msan_set_alloca_origin4(i8* {{.*}}, i64 %[[A]], ; ORIGIN: call void @__msan_set_alloca_origin4(i8* {{.*}}, i64 %[[A]],
; KMSAN: call void @__msan_poison_alloca(i8* {{.*}}, i64 %[[A]], ; KMSAN: call void @__msan_poison_alloca(i8* {{.*}}, i64 %[[A]],
; CHECK: ret void ; CHECK: ret void
; Check that the local is unpoisoned in the absence of sanitize_memory ; Check that the local is unpoisoned in the absence of sanitize_memory
define void @unpoison_local() { define void @unpoison_local() {
entry: entry:
%x = alloca i32, i64 5, align 4 %x = alloca i32, i64 5, align 4
ret void ret void
} }
; CHECK-LABEL: define void @unpoison_local( ; CHECK-LABEL: define void @unpoison_local(
; INLINE: call void @llvm.memset.p0i8.i64(i8* align 4 {{.*}}, i8 0, i64 20, i1 false) ; INLINE: call void @llvm.memset.p0i8.i64(i8* align 4 {{.*}}, i8 0, i64 20, i1 false)
; CALL: call void @llvm.memset.p0i8.i64(i8* align 4 {{.*}}, i8 0, i64 20, i1 false) ; CALL: call void @llvm.memset.p0i8.i64(i8* align 4 {{.*}}, i8 0, i64 20, i1 false)
; CALL-ORIGIN-NOT: call void @__msan_poison_stack_with_origin(i8* {{.*}}, i64 20
; ORIGIN-NOT: call void @__msan_set_alloca_origin4(i8* {{.*}}, i64 20, ; ORIGIN-NOT: call void @__msan_set_alloca_origin4(i8* {{.*}}, i64 20,
; KMSAN: call void @__msan_unpoison_alloca(i8* {{.*}}, i64 20) ; KMSAN: call void @__msan_unpoison_alloca(i8* {{.*}}, i64 20)
; CHECK: ret void ; CHECK: ret void
; Check that every llvm.lifetime.start() causes poisoning of locals. ; Check that every llvm.lifetime.start() causes poisoning of locals.
define void @lifetime_start() sanitize_memory { define void @lifetime_start() sanitize_memory {
entry: entry:
%x = alloca i32, align 4 %x = alloca i32, align 4
Show All 13 Lines
; CHECK-LABEL: define void @lifetime_start( ; CHECK-LABEL: define void @lifetime_start(
; CHECK-LABEL: entry: ; CHECK-LABEL: entry:
; CHECK: %x = alloca i32 ; CHECK: %x = alloca i32
; CHECK-LABEL: another_bb: ; CHECK-LABEL: another_bb:
; CHECK: call void @llvm.lifetime.start ; CHECK: call void @llvm.lifetime.start
; INLINE: call void @llvm.memset.p0i8.i64(i8* align 4 {{.*}}, i8 -1, i64 4, i1 false) ; INLINE: call void @llvm.memset.p0i8.i64(i8* align 4 {{.*}}, i8 -1, i64 4, i1 false)
; CALL: call void @__msan_poison_stack(i8* {{.*}}, i64 4) ; CALL: call void @__msan_poison_stack(i8* {{.*}}, i64 4)
; CALL-ORIGIN: call void @__msan_poison_stack_with_origin(i8* {{.*}}, i64 4
; ORIGIN: call void @__msan_set_alloca_origin4(i8* {{.*}}, i64 4, ; ORIGIN: call void @__msan_set_alloca_origin4(i8* {{.*}}, i64 4,
; KMSAN: call void @__msan_poison_alloca(i8* {{.*}}, i64 4, ; KMSAN: call void @__msan_poison_alloca(i8* {{.*}}, i64 4,
; CHECK: call void @llvm.lifetime.start ; CHECK: call void @llvm.lifetime.start
; INLINE: call void @llvm.memset.p0i8.i64(i8* align 4 {{.*}}, i8 -1, i64 4, i1 false) ; INLINE: call void @llvm.memset.p0i8.i64(i8* align 4 {{.*}}, i8 -1, i64 4, i1 false)
; CALL: call void @__msan_poison_stack(i8* {{.*}}, i64 4) ; CALL: call void @__msan_poison_stack(i8* {{.*}}, i64 4)
; CALL-ORIGIN: call void @__msan_poison_stack_with_origin(i8* {{.*}}, i64 4
; ORIGIN: call void @__msan_set_alloca_origin4(i8* {{.*}}, i64 4, ; ORIGIN: call void @__msan_set_alloca_origin4(i8* {{.*}}, i64 4,
; KMSAN: call void @__msan_poison_alloca(i8* {{.*}}, i64 4, ; KMSAN: call void @__msan_poison_alloca(i8* {{.*}}, i64 4,
; CHECK: ret void ; CHECK: ret void
; Make sure variable-length arrays are handled correctly. ; Make sure variable-length arrays are handled correctly.
define void @lifetime_start_var(i64 %cnt) sanitize_memory { define void @lifetime_start_var(i64 %cnt) sanitize_memory {
entry: entry:
%x = alloca i32, i64 %cnt, align 4 %x = alloca i32, i64 %cnt, align 4
%c = bitcast i32* %x to i8* %c = bitcast i32* %x to i8*
call void @llvm.lifetime.start.p0i8(i64 -1, i8* nonnull %c) call void @llvm.lifetime.start.p0i8(i64 -1, i8* nonnull %c)
call void @llvm.lifetime.end.p0i8(i64 -1, i8* nonnull %c) call void @llvm.lifetime.end.p0i8(i64 -1, i8* nonnull %c)
ret void ret void
} }
; CHECK-LABEL: define void @lifetime_start_var( ; CHECK-LABEL: define void @lifetime_start_var(
; CHECK-LABEL: entry: ; CHECK-LABEL: entry:
; CHECK: %x = alloca i32, i64 %cnt ; CHECK: %x = alloca i32, i64 %cnt
; CHECK: call void @llvm.lifetime.start ; CHECK: call void @llvm.lifetime.start
; CHECK: %[[A:.*]] = mul i64 4, %cnt ; CHECK: %[[A:.*]] = mul i64 4, %cnt
; INLINE: call void @llvm.memset.p0i8.i64(i8* align 4 {{.*}}, i8 -1, i64 %[[A]], i1 false) ; INLINE: call void @llvm.memset.p0i8.i64(i8* align 4 {{.*}}, i8 -1, i64 %[[A]], i1 false)
; CALL: call void @__msan_poison_stack(i8* {{.*}}, i64 %[[A]]) ; CALL: call void @__msan_poison_stack(i8* {{.*}}, i64 %[[A]])
; CALL-ORIGIN: call void @__msan_poison_stack_with_origin(i8* {{.*}}, i64 %[[A]]
; ORIGIN: call void @__msan_set_alloca_origin4(i8* {{.*}}, i64 %[[A]], ; ORIGIN: call void @__msan_set_alloca_origin4(i8* {{.*}}, i64 %[[A]],
; KMSAN: call void @__msan_poison_alloca(i8* {{.*}}, i64 %[[A]], ; KMSAN: call void @__msan_poison_alloca(i8* {{.*}}, i64 %[[A]],
; CHECK: call void @llvm.lifetime.end ; CHECK: call void @llvm.lifetime.end
; CHECK: ret void ; CHECK: ret void
; If we can't trace one of the lifetime markers to a single alloca, fall back ; If we can't trace one of the lifetime markers to a single alloca, fall back
; to poisoning allocas at the beginning of the function. ; to poisoning allocas at the beginning of the function.
Show All 24 Linesanother_bb:
ret void ret void
} }
; CHECK-LABEL: define void @lifetime_no_alloca( ; CHECK-LABEL: define void @lifetime_no_alloca(
; CHECK-LABEL: entry: ; CHECK-LABEL: entry:
; CHECK: %x = alloca i32 ; CHECK: %x = alloca i32
; INLINE: call void @llvm.memset.p0i8.i64(i8* align 4 {{.*}}, i8 -1, i64 4, i1 false) ; INLINE: call void @llvm.memset.p0i8.i64(i8* align 4 {{.*}}, i8 -1, i64 4, i1 false)
; CALL: call void @__msan_poison_stack(i8* {{.*}}, i64 4) ; CALL: call void @__msan_poison_stack(i8* {{.*}}, i64 4)
; CALL-ORIGIN: call void @__msan_poison_stack_with_origin(i8* {{.*}}, i64 4
; ORIGIN: call void @__msan_set_alloca_origin4(i8* {{.*}}, i64 4, ; ORIGIN: call void @__msan_set_alloca_origin4(i8* {{.*}}, i64 4,
; KMSAN: call void @__msan_poison_alloca(i8* {{.*}}, i64 4, ; KMSAN: call void @__msan_poison_alloca(i8* {{.*}}, i64 4,
; CHECK: %y = alloca i32 ; CHECK: %y = alloca i32
; INLINE: call void @llvm.memset.p0i8.i64(i8* align 4 {{.*}}, i8 -1, i64 4, i1 false) ; INLINE: call void @llvm.memset.p0i8.i64(i8* align 4 {{.*}}, i8 -1, i64 4, i1 false)
; CALL: call void @__msan_poison_stack(i8* {{.*}}, i64 4) ; CALL: call void @__msan_poison_stack(i8* {{.*}}, i64 4)
; CALL-ORIGIN: call void @__msan_poison_stack_with_origin(i8* {{.*}}, i64 4
; ORIGIN: call void @__msan_set_alloca_origin4(i8* {{.*}}, i64 4, ; ORIGIN: call void @__msan_set_alloca_origin4(i8* {{.*}}, i64 4,
; KMSAN: call void @__msan_poison_alloca(i8* {{.*}}, i64 4, ; KMSAN: call void @__msan_poison_alloca(i8* {{.*}}, i64 4,
; CHECK: %z = alloca i32 ; CHECK: %z = alloca i32
; INLINE: call void @llvm.memset.p0i8.i64(i8* align 4 {{.*}}, i8 -1, i64 4, i1 false) ; INLINE: call void @llvm.memset.p0i8.i64(i8* align 4 {{.*}}, i8 -1, i64 4, i1 false)
; CALL: call void @__msan_poison_stack(i8* {{.*}}, i64 4) ; CALL: call void @__msan_poison_stack(i8* {{.*}}, i64 4)
; CALL-ORIGIN: call void @__msan_poison_stack_with_origin(i8* {{.*}}, i64 4
; ORIGIN: call void @__msan_set_alloca_origin4(i8* {{.*}}, i64 4, ; ORIGIN: call void @__msan_set_alloca_origin4(i8* {{.*}}, i64 4,
; KMSAN: call void @__msan_poison_alloca(i8* {{.*}}, i64 4, ; KMSAN: call void @__msan_poison_alloca(i8* {{.*}}, i64 4,
; There're two lifetime intrinsics for %z, but we must instrument it only once. ; There're two lifetime intrinsics for %z, but we must instrument it only once.
; INLINE-NOT: call void @llvm.memset.p0i8.i64(i8* align 4 {{.*}}, i8 -1, i64 4, i1 false) ; INLINE-NOT: call void @llvm.memset.p0i8.i64(i8* align 4 {{.*}}, i8 -1, i64 4, i1 false)
; CALL-NOT: call void @__msan_poison_stack(i8* {{.*}}, i64 4) ; CALL-NOT: call void @__msan_poison_stack(i8* {{.*}}, i64 4)
; CALL-ORIGIN-NOT: call void @__msan_poison_stack_with_origin(i8* {{.*}}, i64 4
; ORIGIN-NOT: call void @__msan_set_alloca_origin4(i8* {{.*}}, i64 4, ; ORIGIN-NOT: call void @__msan_set_alloca_origin4(i8* {{.*}}, i64 4,
; KMSAN-NOT: call void @__msan_poison_alloca(i8* {{.*}}, i64 4, ; KMSAN-NOT: call void @__msan_poison_alloca(i8* {{.*}}, i64 4,
; CHECK-LABEL: another_bb: ; CHECK-LABEL: another_bb:
; CHECK: call void @llvm.lifetime.start ; CHECK: call void @llvm.lifetime.start
; INLINE-NOT: call void @llvm.memset.p0i8.i64(i8* align 4 {{.*}}, i8 -1, i64 4, i1 false) ; INLINE-NOT: call void @llvm.memset.p0i8.i64(i8* align 4 {{.*}}, i8 -1, i64 4, i1 false)
; CALL-NOT: call void @__msan_poison_stack(i8* {{.*}}, i64 4) ; CALL-NOT: call void @__msan_poison_stack(i8* {{.*}}, i64 4)
; CALL-ORIGIN-NOT: call void @__msan_poison_stack_with_origin(i8* {{.*}}, i64 4
; ORIGIN-NOT: call void @__msan_set_alloca_origin4(i8* {{.*}}, i64 4, ; ORIGIN-NOT: call void @__msan_set_alloca_origin4(i8* {{.*}}, i64 4,
; KMSAN-NOT: call void @__msan_poison_alloca(i8* {{.*}}, i64 4, ; KMSAN-NOT: call void @__msan_poison_alloca(i8* {{.*}}, i64 4,
; CHECK: call void @llvm.lifetime.end ; CHECK: call void @llvm.lifetime.end
; CHECK: call void @llvm.lifetime.start ; CHECK: call void @llvm.lifetime.start
; INLINE-NOT: call void @llvm.memset.p0i8.i64(i8* align 4 {{.*}}, i8 -1, i64 4, i1 false) ; INLINE-NOT: call void @llvm.memset.p0i8.i64(i8* align 4 {{.*}}, i8 -1, i64 4, i1 false)
; CALL-NOT: call void @__msan_poison_stack(i8* {{.*}}, i64 4) ; CALL-NOT: call void @__msan_poison_stack(i8* {{.*}}, i64 4)
; CALL-ORIGIN-NOT: call void @__msan_poison_stack_with_origin(i8* {{.*}}, i64 4
; ORIGIN-NOT: call void @__msan_set_alloca_origin4(i8* {{.*}}, i64 4, ; ORIGIN-NOT: call void @__msan_set_alloca_origin4(i8* {{.*}}, i64 4,
; KMSAN-NOT: call void @__msan_poison_alloca(i8* {{.*}}, i64 4, ; KMSAN-NOT: call void @__msan_poison_alloca(i8* {{.*}}, i64 4,
; CHECK: call void @llvm.lifetime.end ; CHECK: call void @llvm.lifetime.end
declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture) declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture)
declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture)