This is an archive of the discontinued LLVM Phabricator instance.

Differential D81700

[MSAN] Pass Origin by parameter to __msan_warning functions
ClosedPublic

Authored by guiand on Jun 11 2020, 5:07 PM.

Details

Reviewers
eugenis
vitalybuka
Commits
rGb0ffa8befe4f: [MSAN] Pass Origin by parameter to __msan_warning functions
Summary

Normally, the Origin is passed over TLS, which seems like it introduces unnecessary overhead. It's in the (extremely) cold path though, so the only overhead is in code size.

But with eager-checks, calls to __msan_warning functions are extremely common, so this becomes a useful optimization.

This can save ~5% code size.

Diff Detail

Event Timeline

guiand created this revision.Jun 11 2020, 5:07 PM
Herald added projects: Restricted Project, Restricted Project. · View Herald TranscriptJun 11 2020, 5:07 PM
Herald added subscribers: llvm-commits, Restricted Project, hiraditya. · View Herald Transcript
guiand added a parent revision: D81699: MemorySanitizer: Add option to insert init checks at call site.Jun 11 2020, 5:07 PM
eugenis added inline comments.Jun 11 2020, 5:17 PM
llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp
771

This is an unconditional improvement, simply apply it in all cases. Keep __msan_warning_noreturn in the runtime library for backwards compatibility, but never issue a call to it in the instrumentation. Update the tests in test/Instrumentation/MemorySanitizer.

eugenis added a reviewer: vitalybuka.Jun 11 2020, 5:58 PM
Harbormaster failed remote builds in B60048: Diff 270264!Jun 11 2020, 6:11 PM
guiand updated this revision to Diff 270281.Jun 11 2020, 6:45 PM
guiand removed a parent revision: D81699: MemorySanitizer: Add option to insert init checks at call site.
guiand retitled this revision from [MSAN] Under eager-checks, pass Origin by parameter to __msan_warning functions to [MSAN] Pass Origin by parameter to __msan_warning functions.

Removed dependency on eager-checks, and updated the tests

Harbormaster failed remote builds in B60059: Diff 270281!Jun 11 2020, 7:48 PM
eugenis accepted this revision.Jun 12 2020, 9:35 AM

LGTM

This revision is now accepted and ready to land.Jun 12 2020, 9:35 AM
vitalybuka accepted this revision.Jun 12 2020, 6:17 PM
Closed by commit rGb0ffa8befe4f: [MSAN] Pass Origin by parameter to __msan_warning functions (authored by guiand, committed by eugenis). · Explain WhyJun 15 2020, 6:14 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
compiler-rt/
lib/
msan/
22 lines
6 lines
llvm/
lib/
Transforms/
Instrumentation/
26 lines
test/
Instrumentation/
MemorySanitizer/
4 lines
2 lines
2 lines
6 lines
8 lines
77 lines
2 lines
2 lines
2 lines
2 lines
4 lines

Diff 270934

compiler-rt/lib/msan/msan.cpp

Show First 20 Lines • Show All 374 Lines • ▼ Show 20 Linesvoid __msan_warning_noreturn() {
(void)sp; (void)sp;
PrintWarning(pc, bp); PrintWarning(pc, bp);
if (__msan::flags()->print_stats) if (__msan::flags()->print_stats)
ReportStats(); ReportStats();
Printf("Exiting\n"); Printf("Exiting\n");
Die(); Die();
} }
void __msan_warning_with_origin(u32 origin) {
GET_CALLER_PC_BP_SP;
(void)sp;
PrintWarningWithOrigin(pc, bp, origin);
if (__msan::flags()->halt_on_error) {
if (__msan::flags()->print_stats)
ReportStats();
Printf("Exiting\n");
Die();
}
}
void __msan_warning_with_origin_noreturn(u32 origin) {
GET_CALLER_PC_BP_SP;
(void)sp;
PrintWarningWithOrigin(pc, bp, origin);
if (__msan::flags()->print_stats)
ReportStats();
Printf("Exiting\n");
Die();
}
static void OnStackUnwind(const SignalContext &sig, const void *, static void OnStackUnwind(const SignalContext &sig, const void *,
BufferedStackTrace *stack) { BufferedStackTrace *stack) {
stack->Unwind(StackTrace::GetNextInstructionPc(sig.pc), sig.bp, sig.context, stack->Unwind(StackTrace::GetNextInstructionPc(sig.pc), sig.bp, sig.context,
common_flags()->fast_unwind_on_fatal); common_flags()->fast_unwind_on_fatal);
} }
static void MsanOnDeadlySignal(int signo, void *siginfo, void *context) { static void MsanOnDeadlySignal(int signo, void *siginfo, void *context) {
HandleDeadlySignal(siginfo, context, GetTid(), &OnStackUnwind, nullptr); HandleDeadlySignal(siginfo, context, GetTid(), &OnStackUnwind, nullptr);
▲ Show 20 Lines • Show All 296 Lines • Show Last 20 Lines

compiler-rt/lib/msan/msan_interface_internal.h

Show All 40 Lines
using __sanitizer::uu64; using __sanitizer::uu64;
using __sanitizer::uu32; using __sanitizer::uu32;
using __sanitizer::uu16; using __sanitizer::uu16;
using __sanitizer::u64; using __sanitizer::u64;
using __sanitizer::u32; using __sanitizer::u32;
using __sanitizer::u16; using __sanitizer::u16;
using __sanitizer::u8; using __sanitizer::u8;
// Versions of the above which take Origin as a parameter
SANITIZER_INTERFACE_ATTRIBUTE
void __msan_warning_with_origin(u32 origin);
SANITIZER_INTERFACE_ATTRIBUTE __attribute__((noreturn)) void
__msan_warning_with_origin_noreturn(u32 origin);
SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_INTERFACE_ATTRIBUTE
void __msan_maybe_warning_1(u8 s, u32 o); void __msan_maybe_warning_1(u8 s, u32 o);
SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_INTERFACE_ATTRIBUTE
void __msan_maybe_warning_2(u16 s, u32 o); void __msan_maybe_warning_2(u16 s, u32 o);
SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_INTERFACE_ATTRIBUTE
void __msan_maybe_warning_4(u32 s, u32 o); void __msan_maybe_warning_4(u32 s, u32 o);
SANITIZER_INTERFACE_ATTRIBUTE SANITIZER_INTERFACE_ATTRIBUTE
void __msan_maybe_warning_8(u64 s, u32 o); void __msan_maybe_warning_8(u64 s, u32 o);
▲ Show 20 Lines • Show All 130 Lines • Show Last 20 Lines

llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp

Show First 20 Lines • Show All 537 Lines • ▼ Show 20 Linesprivate:
/// Thread-local shadow storage for in-register va_arg function /// Thread-local shadow storage for in-register va_arg function
/// parameters (x86_64-specific). /// parameters (x86_64-specific).
Value *VAArgOriginTLS; Value *VAArgOriginTLS;
/// Thread-local shadow storage for va_arg overflow area /// Thread-local shadow storage for va_arg overflow area
/// (x86_64-specific). /// (x86_64-specific).
Value *VAArgOverflowSizeTLS; Value *VAArgOverflowSizeTLS;
/// Thread-local space used to pass origin value to the UMR reporting
/// function.
Value *OriginTLS;
/// Are the instrumentation callbacks set up? /// Are the instrumentation callbacks set up?
bool CallbacksInitialized = false; bool CallbacksInitialized = false;
/// The run-time callback to print a warning. /// The run-time callback to print a warning.
FunctionCallee WarningFn; FunctionCallee WarningFn;
// These arrays are indexed by log2(AccessSize). // These arrays are indexed by log2(AccessSize).
FunctionCallee MaybeWarningFn[kNumberOfAccessSizes]; FunctionCallee MaybeWarningFn[kNumberOfAccessSizes];
▲ Show 20 Lines • Show All 152 Lines • ▼ Show 20 Linesvoid MemorySanitizer::createKernelApi(Module &M) {
// These will be initialized in insertKmsanPrologue(). // These will be initialized in insertKmsanPrologue().
RetvalTLS = nullptr; RetvalTLS = nullptr;
RetvalOriginTLS = nullptr; RetvalOriginTLS = nullptr;
ParamTLS = nullptr; ParamTLS = nullptr;
ParamOriginTLS = nullptr; ParamOriginTLS = nullptr;
VAArgTLS = nullptr; VAArgTLS = nullptr;
VAArgOriginTLS = nullptr; VAArgOriginTLS = nullptr;
VAArgOverflowSizeTLS = nullptr; VAArgOverflowSizeTLS = nullptr;
// OriginTLS is unused in the kernel.
OriginTLS = nullptr;
// __msan_warning() in the kernel takes an origin.
WarningFn = M.getOrInsertFunction("__msan_warning", IRB.getVoidTy(), WarningFn = M.getOrInsertFunction("__msan_warning", IRB.getVoidTy(),
IRB.getInt32Ty()); IRB.getInt32Ty());
// Requests the per-task context state (kmsan_context_state*) from the // Requests the per-task context state (kmsan_context_state*) from the
// runtime library. // runtime library.
MsanContextStateTy = StructType::get( MsanContextStateTy = StructType::get(
ArrayType::get(IRB.getInt64Ty(), kParamTLSSize / 8), ArrayType::get(IRB.getInt64Ty(), kParamTLSSize / 8),
ArrayType::get(IRB.getInt64Ty(), kRetvalTLSSize / 8), ArrayType::get(IRB.getInt64Ty(), kRetvalTLSSize / 8),
ArrayType::get(IRB.getInt64Ty(), kParamTLSSize / 8), ArrayType::get(IRB.getInt64Ty(), kParamTLSSize / 8),
Show All 38 Lines return new GlobalVariable(M, Ty, false, GlobalVariable::ExternalLinkage,
nullptr, Name, nullptr, nullptr, Name, nullptr,
GlobalVariable::InitialExecTLSModel); GlobalVariable::InitialExecTLSModel);
}); });
} }
/// Insert declarations for userspace-specific functions and globals. /// Insert declarations for userspace-specific functions and globals.
void MemorySanitizer::createUserspaceApi(Module &M) { void MemorySanitizer::createUserspaceApi(Module &M) {
IRBuilder<> IRB(*C); IRBuilder<> IRB(*C);
// Create the callback. // Create the callback.
// FIXME: this function should have "Cold" calling conv, // FIXME: this function should have "Cold" calling conv,
eugenisUnsubmitted
Not Done
ReplyInline Actions

This is an unconditional improvement, simply apply it in all cases. Keep __msan_warning_noreturn in the runtime library for backwards compatibility, but never issue a call to it in the instrumentation. Update the tests in test/Instrumentation/MemorySanitizer.

eugenis: This is an unconditional improvement, simply apply it in all cases. Keep…
// which is not yet implemented. // which is not yet implemented.
StringRef WarningFnName = Recover ? "__msan_warning" StringRef WarningFnName = Recover ? "__msan_warning_with_origin"
: "__msan_warning_noreturn"; : "__msan_warning_with_origin_noreturn";
WarningFn = M.getOrInsertFunction(WarningFnName, IRB.getVoidTy()); WarningFn =
M.getOrInsertFunction(WarningFnName, IRB.getVoidTy(), IRB.getInt32Ty());
// Create the global TLS variables. // Create the global TLS variables.
RetvalTLS = RetvalTLS =
getOrInsertGlobal(M, "__msan_retval_tls", getOrInsertGlobal(M, "__msan_retval_tls",
ArrayType::get(IRB.getInt64Ty(), kRetvalTLSSize / 8)); ArrayType::get(IRB.getInt64Ty(), kRetvalTLSSize / 8));
RetvalOriginTLS = getOrInsertGlobal(M, "__msan_retval_origin_tls", OriginTy); RetvalOriginTLS = getOrInsertGlobal(M, "__msan_retval_origin_tls", OriginTy);
Show All 10 Lines VAArgTLS =
ArrayType::get(IRB.getInt64Ty(), kParamTLSSize / 8)); ArrayType::get(IRB.getInt64Ty(), kParamTLSSize / 8));
VAArgOriginTLS = VAArgOriginTLS =
getOrInsertGlobal(M, "__msan_va_arg_origin_tls", getOrInsertGlobal(M, "__msan_va_arg_origin_tls",
ArrayType::get(OriginTy, kParamTLSSize / 4)); ArrayType::get(OriginTy, kParamTLSSize / 4));
VAArgOverflowSizeTLS = VAArgOverflowSizeTLS =
getOrInsertGlobal(M, "__msan_va_arg_overflow_size_tls", IRB.getInt64Ty()); getOrInsertGlobal(M, "__msan_va_arg_overflow_size_tls", IRB.getInt64Ty());
OriginTLS = getOrInsertGlobal(M, "__msan_origin_tls", IRB.getInt32Ty());
for (size_t AccessSizeIndex = 0; AccessSizeIndex < kNumberOfAccessSizes; for (size_t AccessSizeIndex = 0; AccessSizeIndex < kNumberOfAccessSizes;
AccessSizeIndex++) { AccessSizeIndex++) {
unsigned AccessSize = 1 << AccessSizeIndex; unsigned AccessSize = 1 << AccessSizeIndex;
std::string FunctionName = "__msan_maybe_warning_" + itostr(AccessSize); std::string FunctionName = "__msan_maybe_warning_" + itostr(AccessSize);
SmallVector<std::pair<unsigned, Attribute>, 2> MaybeWarningFnAttrs; SmallVector<std::pair<unsigned, Attribute>, 2> MaybeWarningFnAttrs;
MaybeWarningFnAttrs.push_back(std::make_pair( MaybeWarningFnAttrs.push_back(std::make_pair(
AttributeList::FirstArgIndex, Attribute::get(*C, Attribute::ZExt))); AttributeList::FirstArgIndex, Attribute::get(*C, Attribute::ZExt)));
▲ Show 20 Lines • Show All 394 Lines • ▼ Show 20 Lines for (StoreInst *SI : StoreList) {
OriginAlignment, InstrumentWithCalls); OriginAlignment, InstrumentWithCalls);
} }
} }
/// Helper function to insert a warning at IRB's current insert point. /// Helper function to insert a warning at IRB's current insert point.
void insertWarningFn(IRBuilder<> &IRB, Value *Origin) { void insertWarningFn(IRBuilder<> &IRB, Value *Origin) {
if (!Origin) if (!Origin)
Origin = (Value *)IRB.getInt32(0); Origin = (Value *)IRB.getInt32(0);
if (MS.CompileKernel) { assert(Origin->getType()->isIntegerTy());
IRB.CreateCall(MS.WarningFn, Origin); IRB.CreateCall(MS.WarningFn, Origin);
} else {
if (MS.TrackOrigins) {
IRB.CreateStore(Origin, MS.OriginTLS);
}
IRB.CreateCall(MS.WarningFn, {});
}
IRB.CreateCall(MS.EmptyAsm, {}); IRB.CreateCall(MS.EmptyAsm, {});
// FIXME: Insert UnreachableInst if !MS.Recover? // FIXME: Insert UnreachableInst if !MS.Recover?
// This may invalidate some of the following checks and needs to be done // This may invalidate some of the following checks and needs to be done
// at the very end. // at the very end.
} }
void materializeOneCheck(Instruction *OrigIns, Value *Shadow, Value *Origin, void materializeOneCheck(Instruction *OrigIns, Value *Shadow, Value *Origin,
bool AsCall) { bool AsCall) {
▲ Show 20 Lines • Show All 3,761 Lines • Show Last 20 Lines

llvm/test/Instrumentation/MemorySanitizer/atomics.ll

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Linesentry:
%0 = extractvalue { i32, i1 } %pair, 0 %0 = extractvalue { i32, i1 } %pair, 0
ret i32 %0 ret i32 %0
} }
; CHECK-LABEL: @Cmpxchg ; CHECK-LABEL: @Cmpxchg
; CHECK: store { i32, i1 } zeroinitializer, ; CHECK: store { i32, i1 } zeroinitializer,
; CHECK: icmp ; CHECK: icmp
; CHECK: br ; CHECK: br
; CHECK: @__msan_warning ; CHECK: @__msan_warning_with_origin
; CHECK: cmpxchg {{.*}} seq_cst seq_cst ; CHECK: cmpxchg {{.*}} seq_cst seq_cst
; CHECK: store i32 0, {{.*}} @__msan_retval_tls ; CHECK: store i32 0, {{.*}} @__msan_retval_tls
; CHECK: ret i32 ; CHECK: ret i32
; relaxed cmpxchg: bump up to "release monotonic" ; relaxed cmpxchg: bump up to "release monotonic"
define i32 @CmpxchgMonotonic(i32* %p, i32 %a, i32 %b) sanitize_memory { define i32 @CmpxchgMonotonic(i32* %p, i32 %a, i32 %b) sanitize_memory {
entry: entry:
%pair = cmpxchg i32* %p, i32 %a, i32 %b monotonic monotonic %pair = cmpxchg i32* %p, i32 %a, i32 %b monotonic monotonic
%0 = extractvalue { i32, i1 } %pair, 0 %0 = extractvalue { i32, i1 } %pair, 0
ret i32 %0 ret i32 %0
} }
; CHECK-LABEL: @CmpxchgMonotonic ; CHECK-LABEL: @CmpxchgMonotonic
; CHECK: store { i32, i1 } zeroinitializer, ; CHECK: store { i32, i1 } zeroinitializer,
; CHECK: icmp ; CHECK: icmp
; CHECK: br ; CHECK: br
; CHECK: @__msan_warning ; CHECK: @__msan_warning_with_origin
; CHECK: cmpxchg {{.*}} release monotonic ; CHECK: cmpxchg {{.*}} release monotonic
; CHECK: store i32 0, {{.*}} @__msan_retval_tls ; CHECK: store i32 0, {{.*}} @__msan_retval_tls
; CHECK: ret i32 ; CHECK: ret i32
; atomic load: preserve alignment, load shadow value after app value ; atomic load: preserve alignment, load shadow value after app value
define i32 @AtomicLoad(i32* %p) sanitize_memory { define i32 @AtomicLoad(i32* %p) sanitize_memory {
▲ Show 20 Lines • Show All 115 Lines • Show Last 20 Lines

llvm/test/Instrumentation/MemorySanitizer/check-constant-shadow.ll

; RUN: opt < %s -msan-check-access-address=0 -msan-check-constant-shadow=1 \ ; RUN: opt < %s -msan-check-access-address=0 -msan-check-constant-shadow=1 \
; RUN: -msan-track-origins=1 -S -passes=msan 2>&1 | FileCheck %s ; RUN: -msan-track-origins=1 -S -passes=msan 2>&1 | FileCheck %s
; RUN: opt < %s -msan -msan-check-access-address=0 -msan-check-constant-shadow=1 -msan-track-origins=1 -S | FileCheck %s ; RUN: opt < %s -msan -msan-check-access-address=0 -msan-check-constant-shadow=1 -msan-track-origins=1 -S | FileCheck %s
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"
; Test that returning a literal undef from main() triggers an MSan warning. ; Test that returning a literal undef from main() triggers an MSan warning.
; main() is special: it inserts check for the return value ; main() is special: it inserts check for the return value
define i32 @main() nounwind uwtable sanitize_memory { define i32 @main() nounwind uwtable sanitize_memory {
entry: entry:
ret i32 undef ret i32 undef
} }
; CHECK-LABEL: @main ; CHECK-LABEL: @main
; CHECK: call void @__msan_warning_noreturn ; CHECK: call void @__msan_warning_with_origin_noreturn
; CHECK: ret i32 undef ; CHECK: ret i32 undef
; This function stores known initialized value. ; This function stores known initialized value.
; Expect 2 stores: one for the shadow (0), one for the value (42), but no origin. ; Expect 2 stores: one for the shadow (0), one for the value (42), but no origin.
define void @StoreConstant(i32* nocapture %p) nounwind uwtable sanitize_memory { define void @StoreConstant(i32* nocapture %p) nounwind uwtable sanitize_memory {
entry: entry:
store i32 42, i32* %p, align 4 store i32 42, i32* %p, align 4
Show All 30 Lines

llvm/test/Instrumentation/MemorySanitizer/check_access_address.ll

Show All 39 Lines
; CHECK-LABEL: @Store ; CHECK-LABEL: @Store
; CHECK: load {{.*}} @__msan_param_tls ; CHECK: load {{.*}} @__msan_param_tls
; Shadow calculations must happen after the check. ; Shadow calculations must happen after the check.
; CHECK-NOT: xor ; CHECK-NOT: xor
; CHECK: icmp ; CHECK: icmp
; CHECK: br i1 ; CHECK: br i1
; CHECK: {{^[0-9]+}}: ; CHECK: {{^[0-9]+}}:
; CHECK: call void @__msan_warning_noreturn ; CHECK: call void @__msan_warning_with_origin_noreturn
; CHECK: {{^[0-9]+}}: ; CHECK: {{^[0-9]+}}:
; CHECK: xor ; CHECK: xor
; CHECK: store ; CHECK: store
; CHECK: store i32 %x ; CHECK: store i32 %x
; CHECK: ret void ; CHECK: ret void

llvm/test/Instrumentation/MemorySanitizer/csr.ll

Show All 22 Lines
; CHECK: store i32 0, i32* ; CHECK: store i32 0, i32*
; CHECK: call void @llvm.x86.sse.stmxcsr( ; CHECK: call void @llvm.x86.sse.stmxcsr(
; CHECK: ret void ; CHECK: ret void
; ADDR-LABEL: @getcsr( ; ADDR-LABEL: @getcsr(
; ADDR: %[[A:.*]] = load i64, i64* getelementptr inbounds {{.*}} @__msan_param_tls, i32 0, i32 0), align 8 ; ADDR: %[[A:.*]] = load i64, i64* getelementptr inbounds {{.*}} @__msan_param_tls, i32 0, i32 0), align 8
; ADDR: %[[B:.*]] = icmp ne i64 %[[A]], 0 ; ADDR: %[[B:.*]] = icmp ne i64 %[[A]], 0
; ADDR: br i1 %[[B]], label {{.*}}, label ; ADDR: br i1 %[[B]], label {{.*}}, label
; ADDR: call void @__msan_warning_noreturn() ; ADDR: call void @__msan_warning_with_origin_noreturn(i32 0)
; ADDR: call void @llvm.x86.sse.stmxcsr( ; ADDR: call void @llvm.x86.sse.stmxcsr(
; ADDR: ret void ; ADDR: ret void
; Function Attrs: nounwind uwtable ; Function Attrs: nounwind uwtable
define void @setcsr(i32 *%p) sanitize_memory { define void @setcsr(i32 *%p) sanitize_memory {
entry: entry:
%0 = bitcast i32* %p to i8* %0 = bitcast i32* %p to i8*
call void @llvm.x86.sse.ldmxcsr(i8* %0) call void @llvm.x86.sse.ldmxcsr(i8* %0)
ret void ret void
} }
; CHECK-LABEL: @setcsr( ; CHECK-LABEL: @setcsr(
; CHECK: %[[A:.*]] = load i32, i32* %{{.*}}, align 1 ; CHECK: %[[A:.*]] = load i32, i32* %{{.*}}, align 1
; CHECK: %[[B:.*]] = icmp ne i32 %[[A]], 0 ; CHECK: %[[B:.*]] = icmp ne i32 %[[A]], 0
; CHECK: br i1 %[[B]], label {{.*}}, label ; CHECK: br i1 %[[B]], label {{.*}}, label
; CHECK: call void @__msan_warning_noreturn() ; CHECK: call void @__msan_warning_with_origin_noreturn(i32 0)
; CHECK: call void @llvm.x86.sse.ldmxcsr( ; CHECK: call void @llvm.x86.sse.ldmxcsr(
; CHECK: ret void ; CHECK: ret void
; ADDR-LABEL: @setcsr( ; ADDR-LABEL: @setcsr(
; ADDR: %[[A:.*]] = load i64, i64* getelementptr inbounds {{.*}} @__msan_param_tls, i32 0, i32 0), align 8 ; ADDR: %[[A:.*]] = load i64, i64* getelementptr inbounds {{.*}} @__msan_param_tls, i32 0, i32 0), align 8
; ADDR: %[[B:.*]] = icmp ne i64 %[[A]], 0 ; ADDR: %[[B:.*]] = icmp ne i64 %[[A]], 0
; ADDR: br i1 %[[B]], label {{.*}}, label ; ADDR: br i1 %[[B]], label {{.*}}, label
; ADDR: call void @__msan_warning_noreturn() ; ADDR: call void @__msan_warning_with_origin_noreturn(i32 0)
; ADDR: call void @llvm.x86.sse.ldmxcsr( ; ADDR: call void @llvm.x86.sse.ldmxcsr(
; ADDR: ret void ; ADDR: ret void

llvm/test/Instrumentation/MemorySanitizer/masked-store-load.ll

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines
; CHECK: ret void ; CHECK: ret void
; ADDR-LABEL: @Store( ; ADDR-LABEL: @Store(
; ADDR: %[[MASKSHADOW:.*]] = load <4 x i1>, {{.*}}@__msan_param_tls to i64), i64 40) ; ADDR: %[[MASKSHADOW:.*]] = load <4 x i1>, {{.*}}@__msan_param_tls to i64), i64 40)
; ADDR: %[[ADDRSHADOW:.*]] = load i64, {{.*}}[100 x i64]* @__msan_param_tls, i32 0, i32 0) ; ADDR: %[[ADDRSHADOW:.*]] = load i64, {{.*}}[100 x i64]* @__msan_param_tls, i32 0, i32 0)
; ADDR: %[[ADDRBAD:.*]] = icmp ne i64 %[[ADDRSHADOW]], 0 ; ADDR: %[[ADDRBAD:.*]] = icmp ne i64 %[[ADDRSHADOW]], 0
; ADDR: br i1 %[[ADDRBAD]], label {{.*}}, label {{.*}} ; ADDR: br i1 %[[ADDRBAD]], label {{.*}}, label {{.*}}
; ADDR: call void @__msan_warning_noreturn() ; ADDR: call void @__msan_warning_with_origin_noreturn(i32 0)
; ADDR: %[[MASKSHADOWFLAT:.*]] = bitcast <4 x i1> %[[MASKSHADOW]] to i4 ; ADDR: %[[MASKSHADOWFLAT:.*]] = bitcast <4 x i1> %[[MASKSHADOW]] to i4
; ADDR: %[[MASKBAD:.*]] = icmp ne i4 %[[MASKSHADOWFLAT]], 0 ; ADDR: %[[MASKBAD:.*]] = icmp ne i4 %[[MASKSHADOWFLAT]], 0
; ADDR: br i1 %[[MASKBAD]], label {{.*}}, label {{.*}} ; ADDR: br i1 %[[MASKBAD]], label {{.*}}, label {{.*}}
; ADDR: call void @__msan_warning_noreturn() ; ADDR: call void @__msan_warning_with_origin_noreturn(i32 0)
; ADDR: tail call void @llvm.masked.store.v4i64.p0v4i64(<4 x i64> %v, <4 x i64>* %p, i32 1, <4 x i1> %mask) ; ADDR: tail call void @llvm.masked.store.v4i64.p0v4i64(<4 x i64> %v, <4 x i64>* %p, i32 1, <4 x i1> %mask)
; ADDR: ret void ; ADDR: ret void
define <4 x double> @Load(<4 x double>* %p, <4 x double> %v, <4 x i1> %mask) sanitize_memory { define <4 x double> @Load(<4 x double>* %p, <4 x double> %v, <4 x i1> %mask) sanitize_memory {
entry: entry:
%x = call <4 x double> @llvm.masked.load.v4f64.p0v4f64(<4 x double>* %p, i32 1, <4 x i1> %mask, <4 x double> %v) %x = call <4 x double> @llvm.masked.load.v4f64.p0v4f64(<4 x double>* %p, i32 1, <4 x i1> %mask, <4 x double> %v)
Show All 18 Lines
; CHECK: ret <4 x double> %[[X]] ; CHECK: ret <4 x double> %[[X]]
; ADDR-LABEL: @Load( ; ADDR-LABEL: @Load(
; ADDR: %[[MASKSHADOW:.*]] = load <4 x i1>, {{.*}}@__msan_param_tls to i64), i64 40) ; ADDR: %[[MASKSHADOW:.*]] = load <4 x i1>, {{.*}}@__msan_param_tls to i64), i64 40)
; ADDR: %[[ADDRSHADOW:.*]] = load i64, {{.*}}[100 x i64]* @__msan_param_tls, i32 0, i32 0) ; ADDR: %[[ADDRSHADOW:.*]] = load i64, {{.*}}[100 x i64]* @__msan_param_tls, i32 0, i32 0)
; ADDR: %[[ADDRBAD:.*]] = icmp ne i64 %[[ADDRSHADOW]], 0 ; ADDR: %[[ADDRBAD:.*]] = icmp ne i64 %[[ADDRSHADOW]], 0
; ADDR: br i1 %[[ADDRBAD]], label {{.*}}, label {{.*}} ; ADDR: br i1 %[[ADDRBAD]], label {{.*}}, label {{.*}}
; ADDR: call void @__msan_warning_noreturn() ; ADDR: call void @__msan_warning_with_origin_noreturn(i32 0)
; ADDR: %[[MASKSHADOWFLAT:.*]] = bitcast <4 x i1> %[[MASKSHADOW]] to i4 ; ADDR: %[[MASKSHADOWFLAT:.*]] = bitcast <4 x i1> %[[MASKSHADOW]] to i4
; ADDR: %[[MASKBAD:.*]] = icmp ne i4 %[[MASKSHADOWFLAT]], 0 ; ADDR: %[[MASKBAD:.*]] = icmp ne i4 %[[MASKSHADOWFLAT]], 0
; ADDR: br i1 %[[MASKBAD]], label {{.*}}, label {{.*}} ; ADDR: br i1 %[[MASKBAD]], label {{.*}}, label {{.*}}
; ADDR: call void @__msan_warning_noreturn() ; ADDR: call void @__msan_warning_with_origin_noreturn(i32 0)
; ADDR: = call <4 x double> @llvm.masked.load.v4f64.p0v4f64(<4 x double>* %p, i32 1, <4 x i1> %mask, <4 x double> %v) ; ADDR: = call <4 x double> @llvm.masked.load.v4f64.p0v4f64(<4 x double>* %p, i32 1, <4 x i1> %mask, <4 x double> %v)
; ADDR: ret <4 x double> ; ADDR: ret <4 x double>
define void @StoreNoSanitize(<4 x i64>* %p, <4 x i64> %v, <4 x i1> %mask) { define void @StoreNoSanitize(<4 x i64>* %p, <4 x i64> %v, <4 x i1> %mask) {
entry: entry:
tail call void @llvm.masked.store.v4i64.p0v4i64(<4 x i64> %v, <4 x i64>* %p, i32 1, <4 x i1> %mask) tail call void @llvm.masked.store.v4i64.p0v4i64(<4 x i64> %v, <4 x i64>* %p, i32 1, <4 x i1> %mask)
ret void ret void
Show All 20 Lines

llvm/test/Instrumentation/MemorySanitizer/msan_basic.ll

Show All 17 Lines
; CHECK-ORIGINS: @__msan_track_origins = weak_odr constant i32 1 ; CHECK-ORIGINS: @__msan_track_origins = weak_odr constant i32 1
; CHECK-NOT: @__msan_keep_going = weak_odr constant i32 0 ; CHECK-NOT: @__msan_keep_going = weak_odr constant i32 0
; CHECK: @__msan_retval_tls = external thread_local(initialexec) global [{{.*}}] ; CHECK: @__msan_retval_tls = external thread_local(initialexec) global [{{.*}}]
; CHECK: @__msan_retval_origin_tls = external thread_local(initialexec) global i32 ; CHECK: @__msan_retval_origin_tls = external thread_local(initialexec) global i32
; CHECK: @__msan_param_tls = external thread_local(initialexec) global [{{.*}}] ; CHECK: @__msan_param_tls = external thread_local(initialexec) global [{{.*}}]
; CHECK: @__msan_param_origin_tls = external thread_local(initialexec) global [{{.*}}] ; CHECK: @__msan_param_origin_tls = external thread_local(initialexec) global [{{.*}}]
; CHECK: @__msan_va_arg_tls = external thread_local(initialexec) global [{{.*}}] ; CHECK: @__msan_va_arg_tls = external thread_local(initialexec) global [{{.*}}]
; CHECK: @__msan_va_arg_overflow_size_tls = external thread_local(initialexec) global i64 ; CHECK: @__msan_va_arg_overflow_size_tls = external thread_local(initialexec) global i64
; CHECK: @__msan_origin_tls = external thread_local(initialexec) global i32
; Check instrumentation of stores ; Check instrumentation of stores
define void @Store(i32* nocapture %p, i32 %x) nounwind uwtable sanitize_memory { define void @Store(i32* nocapture %p, i32 %x) nounwind uwtable sanitize_memory {
entry: entry:
store i32 %x, i32* %p, align 4 store i32 %x, i32* %p, align 4
ret void ret void
Show All 32 Lines
; CHECK-ORIGINS: {{^[0-9]+}}: ; CHECK-ORIGINS: {{^[0-9]+}}:
; CHECK-ORIGINS: store {{.*}} align 32 ; CHECK-ORIGINS: store {{.*}} align 32
; CHECK-ORIGINS: br label ; CHECK-ORIGINS: br label
; CHECK-ORIGINS: {{^[0-9]+}}: ; CHECK-ORIGINS: {{^[0-9]+}}:
; CHECK: store {{.*}} align 32 ; CHECK: store {{.*}} align 32
; CHECK: ret void ; CHECK: ret void
; load followed by cmp: check that we load the shadow and call __msan_warning. ; load followed by cmp: check that we load the shadow and call __msan_warning_with_origin.
define void @LoadAndCmp(i32* nocapture %a) nounwind uwtable sanitize_memory { define void @LoadAndCmp(i32* nocapture %a) nounwind uwtable sanitize_memory {
entry: entry:
%0 = load i32, i32* %a, align 4 %0 = load i32, i32* %a, align 4
%tobool = icmp eq i32 %0, 0 %tobool = icmp eq i32 %0, 0
br i1 %tobool, label %if.end, label %if.then br i1 %tobool, label %if.end, label %if.then
if.then: ; preds = %entry if.then: ; preds = %entry
tail call void (...) @foo() nounwind tail call void (...) @foo() nounwind
br label %if.end br label %if.end
if.end: ; preds = %entry, %if.then if.end: ; preds = %entry, %if.then
ret void ret void
} }
declare void @foo(...) declare void @foo(...)
; CHECK-LABEL: @LoadAndCmp ; CHECK-LABEL: @LoadAndCmp
; CHECK: %0 = load i32,
; CHECK: = load ; CHECK: = load
; CHECK: = load ; CHECK-ORIGINS: %[[ORIGIN:.*]] = load
; CHECK: call void @__msan_warning_noreturn() ; CHECK: call void @__msan_warning_with_origin_noreturn(i32
; CHECK-ORIGINS-SAME %[[ORIGIN]])
; CHECK-CONT:
; CHECK-NEXT: call void asm sideeffect ; CHECK-NEXT: call void asm sideeffect
; CHECK-NEXT: unreachable ; CHECK-NEXT: unreachable
; CHECK: br i1 %tobool
; CHECK: ret void ; CHECK: ret void
; Check that we store the shadow for the retval. ; Check that we store the shadow for the retval.
define i32 @ReturnInt() nounwind uwtable readnone sanitize_memory { define i32 @ReturnInt() nounwind uwtable readnone sanitize_memory {
entry: entry:
ret i32 123 ret i32 123
} }
▲ Show 20 Lines • Show All 306 Lines • ▼ Show 20 Lines
define i32 @Div(i32 %a, i32 %b) nounwind uwtable readnone sanitize_memory { define i32 @Div(i32 %a, i32 %b) nounwind uwtable readnone sanitize_memory {
entry: entry:
%div = udiv i32 %a, %b %div = udiv i32 %a, %b
ret i32 %div ret i32 %div
} }
; CHECK-LABEL: @Div ; CHECK-LABEL: @Div
; CHECK: icmp ; CHECK: icmp
; CHECK: call void @__msan_warning ; CHECK: call void @__msan_warning_with_origin
; CHECK-NOT: icmp ; CHECK-NOT: icmp
; CHECK: udiv ; CHECK: udiv
; CHECK-NOT: icmp ; CHECK-NOT: icmp
; CHECK: ret i32 ; CHECK: ret i32
; Check that fdiv, unlike udiv, simply propagates shadow. ; Check that fdiv, unlike udiv, simply propagates shadow.
define float @FDiv(float %a, float %b) nounwind uwtable readnone sanitize_memory { define float @FDiv(float %a, float %b) nounwind uwtable readnone sanitize_memory {
Show All 30 Lines
define zeroext i1 @ICmpSLTZero(i32 %x) nounwind uwtable readnone sanitize_memory { define zeroext i1 @ICmpSLTZero(i32 %x) nounwind uwtable readnone sanitize_memory {
%1 = icmp slt i32 %x, 0 %1 = icmp slt i32 %x, 0
ret i1 %1 ret i1 %1
} }
; CHECK-LABEL: @ICmpSLTZero ; CHECK-LABEL: @ICmpSLTZero
; CHECK: icmp slt ; CHECK: icmp slt
; CHECK-NOT: call void @__msan_warning ; CHECK-NOT: call void @__msan_warning_with_origin
; CHECK: icmp slt ; CHECK: icmp slt
; CHECK-NOT: call void @__msan_warning ; CHECK-NOT: call void @__msan_warning_with_origin
; CHECK: ret i1 ; CHECK: ret i1
define zeroext i1 @ICmpSGEZero(i32 %x) nounwind uwtable readnone sanitize_memory { define zeroext i1 @ICmpSGEZero(i32 %x) nounwind uwtable readnone sanitize_memory {
%1 = icmp sge i32 %x, 0 %1 = icmp sge i32 %x, 0
ret i1 %1 ret i1 %1
} }
; CHECK-LABEL: @ICmpSGEZero ; CHECK-LABEL: @ICmpSGEZero
; CHECK: icmp slt ; CHECK: icmp slt
; CHECK-NOT: call void @__msan_warning ; CHECK-NOT: call void @__msan_warning_with_origin
; CHECK: icmp sge ; CHECK: icmp sge
; CHECK-NOT: call void @__msan_warning ; CHECK-NOT: call void @__msan_warning_with_origin
; CHECK: ret i1 ; CHECK: ret i1
define zeroext i1 @ICmpSGTZero(i32 %x) nounwind uwtable readnone sanitize_memory { define zeroext i1 @ICmpSGTZero(i32 %x) nounwind uwtable readnone sanitize_memory {
%1 = icmp sgt i32 0, %x %1 = icmp sgt i32 0, %x
ret i1 %1 ret i1 %1
} }
; CHECK-LABEL: @ICmpSGTZero ; CHECK-LABEL: @ICmpSGTZero
; CHECK: icmp slt ; CHECK: icmp slt
; CHECK-NOT: call void @__msan_warning ; CHECK-NOT: call void @__msan_warning_with_origin
; CHECK: icmp sgt ; CHECK: icmp sgt
; CHECK-NOT: call void @__msan_warning ; CHECK-NOT: call void @__msan_warning_with_origin
; CHECK: ret i1 ; CHECK: ret i1
define zeroext i1 @ICmpSLEZero(i32 %x) nounwind uwtable readnone sanitize_memory { define zeroext i1 @ICmpSLEZero(i32 %x) nounwind uwtable readnone sanitize_memory {
%1 = icmp sle i32 0, %x %1 = icmp sle i32 0, %x
ret i1 %1 ret i1 %1
} }
; CHECK-LABEL: @ICmpSLEZero ; CHECK-LABEL: @ICmpSLEZero
; CHECK: icmp slt ; CHECK: icmp slt
; CHECK-NOT: call void @__msan_warning ; CHECK-NOT: call void @__msan_warning_with_origin
; CHECK: icmp sle ; CHECK: icmp sle
; CHECK-NOT: call void @__msan_warning ; CHECK-NOT: call void @__msan_warning_with_origin
; CHECK: ret i1 ; CHECK: ret i1
; Check that we propagate shadow for x<=-1, x>-1, etc (i.e. sign bit tests) ; Check that we propagate shadow for x<=-1, x>-1, etc (i.e. sign bit tests)
define zeroext i1 @ICmpSLTAllOnes(i32 %x) nounwind uwtable readnone sanitize_memory { define zeroext i1 @ICmpSLTAllOnes(i32 %x) nounwind uwtable readnone sanitize_memory {
%1 = icmp slt i32 -1, %x %1 = icmp slt i32 -1, %x
ret i1 %1 ret i1 %1
} }
; CHECK-LABEL: @ICmpSLTAllOnes ; CHECK-LABEL: @ICmpSLTAllOnes
; CHECK: icmp slt ; CHECK: icmp slt
; CHECK-NOT: call void @__msan_warning ; CHECK-NOT: call void @__msan_warning_with_origin
; CHECK: icmp slt ; CHECK: icmp slt
; CHECK-NOT: call void @__msan_warning ; CHECK-NOT: call void @__msan_warning_with_origin
; CHECK: ret i1 ; CHECK: ret i1
define zeroext i1 @ICmpSGEAllOnes(i32 %x) nounwind uwtable readnone sanitize_memory { define zeroext i1 @ICmpSGEAllOnes(i32 %x) nounwind uwtable readnone sanitize_memory {
%1 = icmp sge i32 -1, %x %1 = icmp sge i32 -1, %x
ret i1 %1 ret i1 %1
} }
; CHECK-LABEL: @ICmpSGEAllOnes ; CHECK-LABEL: @ICmpSGEAllOnes
; CHECK: icmp slt ; CHECK: icmp slt
; CHECK-NOT: call void @__msan_warning ; CHECK-NOT: call void @__msan_warning_with_origin
; CHECK: icmp sge ; CHECK: icmp sge
; CHECK-NOT: call void @__msan_warning ; CHECK-NOT: call void @__msan_warning_with_origin
; CHECK: ret i1 ; CHECK: ret i1
define zeroext i1 @ICmpSGTAllOnes(i32 %x) nounwind uwtable readnone sanitize_memory { define zeroext i1 @ICmpSGTAllOnes(i32 %x) nounwind uwtable readnone sanitize_memory {
%1 = icmp sgt i32 %x, -1 %1 = icmp sgt i32 %x, -1
ret i1 %1 ret i1 %1
} }
; CHECK-LABEL: @ICmpSGTAllOnes ; CHECK-LABEL: @ICmpSGTAllOnes
; CHECK: icmp slt ; CHECK: icmp slt
; CHECK-NOT: call void @__msan_warning ; CHECK-NOT: call void @__msan_warning_with_origin
; CHECK: icmp sgt ; CHECK: icmp sgt
; CHECK-NOT: call void @__msan_warning ; CHECK-NOT: call void @__msan_warning_with_origin
; CHECK: ret i1 ; CHECK: ret i1
define zeroext i1 @ICmpSLEAllOnes(i32 %x) nounwind uwtable readnone sanitize_memory { define zeroext i1 @ICmpSLEAllOnes(i32 %x) nounwind uwtable readnone sanitize_memory {
%1 = icmp sle i32 %x, -1 %1 = icmp sle i32 %x, -1
ret i1 %1 ret i1 %1
} }
; CHECK-LABEL: @ICmpSLEAllOnes ; CHECK-LABEL: @ICmpSLEAllOnes
; CHECK: icmp slt ; CHECK: icmp slt
; CHECK-NOT: call void @__msan_warning ; CHECK-NOT: call void @__msan_warning_with_origin
; CHECK: icmp sle ; CHECK: icmp sle
; CHECK-NOT: call void @__msan_warning ; CHECK-NOT: call void @__msan_warning_with_origin
; CHECK: ret i1 ; CHECK: ret i1
; Check that we propagate shadow for x<0, x>=0, etc (i.e. sign bit tests) ; Check that we propagate shadow for x<0, x>=0, etc (i.e. sign bit tests)
; of the vector arguments. ; of the vector arguments.
define <2 x i1> @ICmpSLT_vector_Zero(<2 x i32*> %x) nounwind uwtable readnone sanitize_memory { define <2 x i1> @ICmpSLT_vector_Zero(<2 x i32*> %x) nounwind uwtable readnone sanitize_memory {
%1 = icmp slt <2 x i32*> %x, zeroinitializer %1 = icmp slt <2 x i32*> %x, zeroinitializer
ret <2 x i1> %1 ret <2 x i1> %1
} }
; CHECK-LABEL: @ICmpSLT_vector_Zero ; CHECK-LABEL: @ICmpSLT_vector_Zero
; CHECK: icmp slt <2 x i64> ; CHECK: icmp slt <2 x i64>
; CHECK-NOT: call void @__msan_warning ; CHECK-NOT: call void @__msan_warning_with_origin
; CHECK: icmp slt <2 x i32*> ; CHECK: icmp slt <2 x i32*>
; CHECK-NOT: call void @__msan_warning ; CHECK-NOT: call void @__msan_warning_with_origin
; CHECK: ret <2 x i1> ; CHECK: ret <2 x i1>
; Check that we propagate shadow for x<=-1, x>0, etc (i.e. sign bit tests) ; Check that we propagate shadow for x<=-1, x>0, etc (i.e. sign bit tests)
; of the vector arguments. ; of the vector arguments.
define <2 x i1> @ICmpSLT_vector_AllOnes(<2 x i32> %x) nounwind uwtable readnone sanitize_memory { define <2 x i1> @ICmpSLT_vector_AllOnes(<2 x i32> %x) nounwind uwtable readnone sanitize_memory {
%1 = icmp slt <2 x i32> <i32 -1, i32 -1>, %x %1 = icmp slt <2 x i32> <i32 -1, i32 -1>, %x
ret <2 x i1> %1 ret <2 x i1> %1
} }
; CHECK-LABEL: @ICmpSLT_vector_AllOnes ; CHECK-LABEL: @ICmpSLT_vector_AllOnes
; CHECK: icmp slt <2 x i32> ; CHECK: icmp slt <2 x i32>
; CHECK-NOT: call void @__msan_warning ; CHECK-NOT: call void @__msan_warning_with_origin
; CHECK: icmp slt <2 x i32> ; CHECK: icmp slt <2 x i32>
; CHECK-NOT: call void @__msan_warning ; CHECK-NOT: call void @__msan_warning_with_origin
; CHECK: ret <2 x i1> ; CHECK: ret <2 x i1>
; Check that we propagate shadow for unsigned relational comparisons with ; Check that we propagate shadow for unsigned relational comparisons with
; constants ; constants
define zeroext i1 @ICmpUGTConst(i32 %x) nounwind uwtable readnone sanitize_memory { define zeroext i1 @ICmpUGTConst(i32 %x) nounwind uwtable readnone sanitize_memory {
entry: entry:
%cmp = icmp ugt i32 %x, 7 %cmp = icmp ugt i32 %x, 7
ret i1 %cmp ret i1 %cmp
} }
; CHECK-LABEL: @ICmpUGTConst ; CHECK-LABEL: @ICmpUGTConst
; CHECK: icmp ugt i32 ; CHECK: icmp ugt i32
; CHECK-NOT: call void @__msan_warning ; CHECK-NOT: call void @__msan_warning_with_origin
; CHECK: icmp ugt i32 ; CHECK: icmp ugt i32
; CHECK-NOT: call void @__msan_warning ; CHECK-NOT: call void @__msan_warning_with_origin
; CHECK: icmp ugt i32 ; CHECK: icmp ugt i32
; CHECK-NOT: call void @__msan_warning ; CHECK-NOT: call void @__msan_warning_with_origin
; CHECK: ret i1 ; CHECK: ret i1
; Check that loads of shadow have the same alignment as the original loads. ; Check that loads of shadow have the same alignment as the original loads.
; Check that loads of origin have the alignment of max(4, original alignment). ; Check that loads of origin have the alignment of max(4, original alignment).
define i32 @ShadowLoadAlignmentLarge() nounwind uwtable sanitize_memory { define i32 @ShadowLoadAlignmentLarge() nounwind uwtable sanitize_memory {
%y = alloca i32, align 64 %y = alloca i32, align 64
Show All 25 Lines
define i32 @ExtractElement(<4 x i32> %vec, i32 %idx) sanitize_memory { define i32 @ExtractElement(<4 x i32> %vec, i32 %idx) sanitize_memory {
%x = extractelement <4 x i32> %vec, i32 %idx %x = extractelement <4 x i32> %vec, i32 %idx
ret i32 %x ret i32 %x
} }
; CHECK-LABEL: @ExtractElement ; CHECK-LABEL: @ExtractElement
; CHECK: extractelement ; CHECK: extractelement
; CHECK: call void @__msan_warning ; CHECK: call void @__msan_warning_with_origin
; CHECK: extractelement ; CHECK: extractelement
; CHECK: ret i32 ; CHECK: ret i32
define <4 x i32> @InsertElement(<4 x i32> %vec, i32 %idx, i32 %x) sanitize_memory { define <4 x i32> @InsertElement(<4 x i32> %vec, i32 %idx, i32 %x) sanitize_memory {
%vec1 = insertelement <4 x i32> %vec, i32 %x, i32 %idx %vec1 = insertelement <4 x i32> %vec, i32 %x, i32 %idx
ret <4 x i32> %vec1 ret <4 x i32> %vec1
} }
; CHECK-LABEL: @InsertElement ; CHECK-LABEL: @InsertElement
; CHECK: insertelement ; CHECK: insertelement
; CHECK: call void @__msan_warning ; CHECK: call void @__msan_warning_with_origin
; CHECK: insertelement ; CHECK: insertelement
; CHECK: ret <4 x i32> ; CHECK: ret <4 x i32>
define <4 x i32> @ShuffleVector(<4 x i32> %vec, <4 x i32> %vec1) sanitize_memory { define <4 x i32> @ShuffleVector(<4 x i32> %vec, <4 x i32> %vec1) sanitize_memory {
%vec2 = shufflevector <4 x i32> %vec, <4 x i32> %vec1, %vec2 = shufflevector <4 x i32> %vec, <4 x i32> %vec1,
<4 x i32> <i32 0, i32 4, i32 1, i32 5> <4 x i32> <i32 0, i32 4, i32 1, i32 5>
ret <4 x i32> %vec2 ret <4 x i32> %vec2
} }
; CHECK-LABEL: @ShuffleVector ; CHECK-LABEL: @ShuffleVector
; CHECK: shufflevector ; CHECK: shufflevector
; CHECK-NOT: call void @__msan_warning ; CHECK-NOT: call void @__msan_warning_with_origin
; CHECK: shufflevector ; CHECK: shufflevector
; CHECK: ret <4 x i32> ; CHECK: ret <4 x i32>
; Test bswap intrinsic instrumentation ; Test bswap intrinsic instrumentation
define i32 @BSwap(i32 %x) nounwind uwtable readnone sanitize_memory { define i32 @BSwap(i32 %x) nounwind uwtable readnone sanitize_memory {
%y = tail call i32 @llvm.bswap.i32(i32 %x) %y = tail call i32 @llvm.bswap.i32(i32 %x)
ret i32 %y ret i32 %y
} }
declare i32 @llvm.bswap.i32(i32) nounwind readnone declare i32 @llvm.bswap.i32(i32) nounwind readnone
; CHECK-LABEL: @BSwap ; CHECK-LABEL: @BSwap
; CHECK-NOT: call void @__msan_warning ; CHECK-NOT: call void @__msan_warning_with_origin
; CHECK: @llvm.bswap.i32 ; CHECK: @llvm.bswap.i32
; CHECK-NOT: call void @__msan_warning ; CHECK-NOT: call void @__msan_warning_with_origin
; CHECK: @llvm.bswap.i32 ; CHECK: @llvm.bswap.i32
; CHECK-NOT: call void @__msan_warning ; CHECK-NOT: call void @__msan_warning_with_origin
; CHECK: ret i32 ; CHECK: ret i32
; Test handling of vectors of pointers. ; Test handling of vectors of pointers.
; Check that shadow of such vector is a vector of integers. ; Check that shadow of such vector is a vector of integers.
define <8 x i8*> @VectorOfPointers(<8 x i8*>* %p) nounwind uwtable sanitize_memory { define <8 x i8*> @VectorOfPointers(<8 x i8*>* %p) nounwind uwtable sanitize_memory {
%x = load <8 x i8*>, <8 x i8*>* %p %x = load <8 x i8*>, <8 x i8*>* %p
ret <8 x i8*> %x ret <8 x i8*> %x
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines
define void @VolatileStore(i32* nocapture %p, i32 %x) nounwind uwtable sanitize_memory { define void @VolatileStore(i32* nocapture %p, i32 %x) nounwind uwtable sanitize_memory {
entry: entry:
store volatile i32 %x, i32* %p, align 4 store volatile i32 %x, i32* %p, align 4
ret void ret void
} }
; CHECK-LABEL: @VolatileStore ; CHECK-LABEL: @VolatileStore
; CHECK-NOT: @__msan_warning ; CHECK-NOT: @__msan_warning_with_origin
; CHECK: ret void ; CHECK: ret void
; Test that checks are omitted and returned value is always initialized if ; Test that checks are omitted and returned value is always initialized if
; sanitize_memory attribute is missing. ; sanitize_memory attribute is missing.
define i32 @NoSanitizeMemory(i32 %x) uwtable { define i32 @NoSanitizeMemory(i32 %x) uwtable {
entry: entry:
%tobool = icmp eq i32 %x, 0 %tobool = icmp eq i32 %x, 0
br i1 %tobool, label %if.end, label %if.then br i1 %tobool, label %if.end, label %if.then
if.then: ; preds = %entry if.then: ; preds = %entry
tail call void @bar() tail call void @bar()
br label %if.end br label %if.end
if.end: ; preds = %entry, %if.then if.end: ; preds = %entry, %if.then
ret i32 %x ret i32 %x
} }
declare void @bar() declare void @bar()
; CHECK-LABEL: @NoSanitizeMemory ; CHECK-LABEL: @NoSanitizeMemory
; CHECK-NOT: @__msan_warning ; CHECK-NOT: @__msan_warning_with_origin
; CHECK: store i32 0, {{.*}} @__msan_retval_tls ; CHECK: store i32 0, {{.*}} @__msan_retval_tls
; CHECK-NOT: @__msan_warning ; CHECK-NOT: @__msan_warning_with_origin
; CHECK: ret i32 ; CHECK: ret i32
; Test that stack allocations are unpoisoned in functions missing ; Test that stack allocations are unpoisoned in functions missing
; sanitize_memory attribute ; sanitize_memory attribute
define i32 @NoSanitizeMemoryAlloca() { define i32 @NoSanitizeMemoryAlloca() {
entry: entry:
▲ Show 20 Lines • Show All 232 Lines • Show Last 20 Lines

llvm/test/Instrumentation/MemorySanitizer/msan_llvm_is_constant.ll

Show All 12 Lines
define dso_local i32 @bar(i32 %v) local_unnamed_addr sanitize_memory { define dso_local i32 @bar(i32 %v) local_unnamed_addr sanitize_memory {
entry: entry:
%0 = tail call i1 @llvm.is.constant.i32(i32 %v) %0 = tail call i1 @llvm.is.constant.i32(i32 %v)
%1 = zext i1 %0 to i32 %1 = zext i1 %0 to i32
ret i32 %1 ret i32 %1
} }
; CHECK-LABEL: bar ; CHECK-LABEL: bar
; CHECK-NOT: call void @__msan_warning ; CHECK-NOT: call void @__msan_warning_with_origin
; Function Attrs: nounwind readnone ; Function Attrs: nounwind readnone
declare i1 @llvm.is.constant.i32(i32) declare i1 @llvm.is.constant.i32(i32)

llvm/test/Instrumentation/MemorySanitizer/msan_llvm_launder_invariant.ll

Show All 19 Linesentry:
%2 = load i8*, i8** %p, align 8 %2 = load i8*, i8** %p, align 8
%3 = call i8* @llvm.launder.invariant.group.p0i8(i8* %2) %3 = call i8* @llvm.launder.invariant.group.p0i8(i8* %2)
%4 = bitcast i8* %3 to %class.Foo* %4 = bitcast i8* %3 to %class.Foo*
%retval.0 = select i1 %call, %class.Foo* %4, %class.Foo* null %retval.0 = select i1 %call, %class.Foo* %4, %class.Foo* null
call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %0) call void @llvm.lifetime.end.p0i8(i64 8, i8* nonnull %0)
ret %class.Foo* %retval.0 ret %class.Foo* %retval.0
} }
; CHECK-NOT: call void @__msan_warning_noreturn ; CHECK-NOT: call void @__msan_warning_with_origin_noreturn
declare dso_local zeroext i1 @_Z2f1PPvb(i8**, i1 zeroext) local_unnamed_addr declare dso_local zeroext i1 @_Z2f1PPvb(i8**, i1 zeroext) local_unnamed_addr
declare i8* @llvm.launder.invariant.group.p0i8(i8*) declare i8* @llvm.launder.invariant.group.p0i8(i8*)
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)
attributes #0 = { sanitize_memory uwtable } attributes #0 = { sanitize_memory uwtable }

llvm/test/Instrumentation/MemorySanitizer/msan_llvm_strip_invariant.ll

; Make sure MSan handles llvm.launder.invariant.group correctly. ; Make sure MSan handles llvm.launder.invariant.group correctly.
; RUN: opt < %s -msan -msan-kernel=1 -O1 -S | FileCheck -check-prefixes=CHECK %s ; RUN: opt < %s -msan -msan-kernel=1 -O1 -S | FileCheck -check-prefixes=CHECK %s
; RUN: opt < %s -msan -O1 -S | FileCheck -check-prefixes=CHECK %s ; RUN: opt < %s -msan -O1 -S | FileCheck -check-prefixes=CHECK %s
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
@flag = dso_local local_unnamed_addr global i8 0, align 1 @flag = dso_local local_unnamed_addr global i8 0, align 1
define dso_local i8* @f(i8* %x) local_unnamed_addr #0 { define dso_local i8* @f(i8* %x) local_unnamed_addr #0 {
entry: entry:
%0 = call i8* @llvm.strip.invariant.group.p0i8(i8* %x) %0 = call i8* @llvm.strip.invariant.group.p0i8(i8* %x)
ret i8* %0 ret i8* %0
} }
; CHECK-NOT: call void @__msan_warning_noreturn ; CHECK-NOT: call void @__msan_warning_with_origin_noreturn
declare i8* @llvm.strip.invariant.group.p0i8(i8*) declare i8* @llvm.strip.invariant.group.p0i8(i8*)
attributes #0 = { sanitize_memory uwtable } attributes #0 = { sanitize_memory uwtable }

llvm/test/Instrumentation/MemorySanitizer/return_from_main.ll

Show All 10 Lines
} }
declare i32 @f() sanitize_memory declare i32 @f() sanitize_memory
; CHECK-LABEL: @main ; CHECK-LABEL: @main
; CHECK: call i32 @f() ; CHECK: call i32 @f()
; CHECK: store i32 0, {{.*}} @__msan_retval_tls ; CHECK: store i32 0, {{.*}} @__msan_retval_tls
; CHECK: br i1 ; CHECK: br i1
; CHECK: call void @__msan_warning_noreturn() ; CHECK: call void @__msan_warning_with_origin_noreturn(i32 0)
; CHECK: ret i32 ; CHECK: ret i32

llvm/test/Instrumentation/MemorySanitizer/vector_cvt.ll

Show All 16 Linesentry:
%0 = tail call i32 @llvm.x86.sse2.cvtsd2si(<2 x double> %value) %0 = tail call i32 @llvm.x86.sse2.cvtsd2si(<2 x double> %value)
ret i32 %0 ret i32 %0
} }
; CHECK-LABEL: @test_cvtsd2si ; CHECK-LABEL: @test_cvtsd2si
; CHECK: [[S:%[_01-9a-z]+]] = extractelement <2 x i64> {{.*}}, i32 0 ; CHECK: [[S:%[_01-9a-z]+]] = extractelement <2 x i64> {{.*}}, i32 0
; CHECK: icmp ne {{.*}}[[S]], 0 ; CHECK: icmp ne {{.*}}[[S]], 0
; CHECK: br ; CHECK: br
; CHECK: call void @__msan_warning_noreturn ; CHECK: call void @__msan_warning_with_origin_noreturn
; CHECK: call i32 @llvm.x86.sse2.cvtsd2si ; CHECK: call i32 @llvm.x86.sse2.cvtsd2si
; CHECK: store i32 0, {{.*}} @__msan_retval_tls ; CHECK: store i32 0, {{.*}} @__msan_retval_tls
; CHECK: ret i32 ; CHECK: ret i32
; x86_mmx packed vector conversion. ; x86_mmx packed vector conversion.
define x86_mmx @test_cvtps2pi(<4 x float> %value) sanitize_memory { define x86_mmx @test_cvtps2pi(<4 x float> %value) sanitize_memory {
entry: entry:
%0 = tail call x86_mmx @llvm.x86.sse.cvtps2pi(<4 x float> %value) %0 = tail call x86_mmx @llvm.x86.sse.cvtps2pi(<4 x float> %value)
ret x86_mmx %0 ret x86_mmx %0
} }
; CHECK-LABEL: @test_cvtps2pi ; CHECK-LABEL: @test_cvtps2pi
; CHECK: extractelement <4 x i32> {{.*}}, i32 0 ; CHECK: extractelement <4 x i32> {{.*}}, i32 0
; CHECK: extractelement <4 x i32> {{.*}}, i32 1 ; CHECK: extractelement <4 x i32> {{.*}}, i32 1
; CHECK: [[S:%[_01-9a-z]+]] = or i32 ; CHECK: [[S:%[_01-9a-z]+]] = or i32
; CHECK: icmp ne {{.*}}[[S]], 0 ; CHECK: icmp ne {{.*}}[[S]], 0
; CHECK: br ; CHECK: br
; CHECK: call void @__msan_warning_noreturn ; CHECK: call void @__msan_warning_with_origin_noreturn
; CHECK: call x86_mmx @llvm.x86.sse.cvtps2pi ; CHECK: call x86_mmx @llvm.x86.sse.cvtps2pi
; CHECK: store i64 0, {{.*}} @__msan_retval_tls ; CHECK: store i64 0, {{.*}} @__msan_retval_tls
; CHECK: ret x86_mmx ; CHECK: ret x86_mmx