This is an archive of the discontinued LLVM Phabricator instance.

Differential D117285

[msan] Copy origin of byval arguments
ClosedPublic

Authored by vitalybuka on Jan 13 2022, 11:56 PM.

Details

Reviewers
kda
eugenis
Commits
rGbddc814b442a: [msan] Copy origin of byval arguments
Summary

Depends on D117278

Diff Detail

Unit TestsFailed

TimeTest
850 msx64 debian > SanitizerCommon-tsan-x86_64-Linux.Linux::decorate_proc_maps.cpp
2,960 msx64 debian > libomp.tasking::kmp_taskwait_depend_all.c

Event Timeline

vitalybuka created this revision.Jan 13 2022, 11:56 PM
Herald added a subscriber: hiraditya. · View Herald TranscriptJan 13 2022, 11:56 PM
vitalybuka requested review of this revision.Jan 13 2022, 11:56 PM
Herald added a project: Restricted Project. · View Herald TranscriptJan 13 2022, 11:56 PM
Herald added a subscriber: llvm-commits. · View Herald Transcript
vitalybuka added a child revision: D117286: [msan] Reset shadow of byval before call.Jan 13 2022, 11:57 PM
Harbormaster completed remote builds in B143331: Diff 399914.Jan 14 2022, 12:34 AM
vitalybuka updated this revision to Diff 399984.Jan 14 2022, 6:59 AM

fix condition

Harbormaster completed remote builds in B143379: Diff 399984.Jan 14 2022, 8:04 AM
eugenis accepted this revision.Jan 14 2022, 12:40 PM

LGTM

A compiler-rt test for origin propagation would be great.

llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp
1742

This can get weird if the byval pointer is less than 4 byte aligned, but the alternatives are not pretty, either.

Also, you can bump the alignment std::max(CopyAlign, kMinOriginAlignment).

This revision is now accepted and ready to land.Jan 14 2022, 12:40 PM
kda accepted this revision.Jan 14 2022, 5:49 PM

LGTM

vitalybuka updated this revision to Diff 400261.Jan 15 2022, 12:48 AM

alignment

vitalybuka updated this revision to Diff 400262.Jan 15 2022, 12:48 AM

format

vitalybuka requested review of this revision.Jan 15 2022, 12:51 AM
vitalybuka added inline comments.
llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp
1742

Not sure if OriginPtr can be aligned higher then kMinOriginAlignment, as origin_tls base is 4 bytes aligned.
CpOriginPtr can be aligned higher, but I guess it does not matter here.

Also please notice the I changed copy size.

vitalybuka added 1 blocking reviewer(s): eugenis.Jan 15 2022, 12:52 AM
Harbormaster completed remote builds in B143575: Diff 400262.Jan 15 2022, 1:47 AM
vitalybuka updated this revision to Diff 400331.Jan 15 2022, 5:37 PM

Add FIXME about size

Harbormaster completed remote builds in B143630: Diff 400331.Jan 15 2022, 6:19 PM
vitalybuka added a comment.Jan 21 2022, 2:02 PM

ping

vitalybuka added a comment.Jan 27 2022, 12:21 PM

ping again

eugenis accepted this revision.Jan 27 2022, 2:08 PM

LGTM

llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp
1742

yes, you are right

This revision is now accepted and ready to land.Jan 27 2022, 2:08 PM
This revision was landed with ongoing or failed builds.Jan 27 2022, 4:24 PM
Closed by commit rGbddc814b442a: [msan] Copy origin of byval arguments (authored by vitalybuka). · Explain Why
This revision was automatically updated to reflect the committed changes.
vitalybuka added a commit: rGbddc814b442a: [msan] Copy origin of byval arguments.

Revision Contents

PathSize
llvm/
lib/
Transforms/
Instrumentation/
48 lines
test/
Instrumentation/
MemorySanitizer/
16 lines

Diff 400331

llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp

Show First 20 Lines • Show All 176 Lines • ▼ Show 20 Lines
#include "llvm/IR/LLVMContext.h" #include "llvm/IR/LLVMContext.h"
#include "llvm/IR/MDBuilder.h" #include "llvm/IR/MDBuilder.h"
#include "llvm/IR/Module.h" #include "llvm/IR/Module.h"
#include "llvm/IR/Type.h" #include "llvm/IR/Type.h"
#include "llvm/IR/Value.h" #include "llvm/IR/Value.h"
#include "llvm/IR/ValueMap.h" #include "llvm/IR/ValueMap.h"
#include "llvm/InitializePasses.h" #include "llvm/InitializePasses.h"
#include "llvm/Pass.h" #include "llvm/Pass.h"
#include "llvm/Support/Alignment.h"
#include "llvm/Support/AtomicOrdering.h" #include "llvm/Support/AtomicOrdering.h"
#include "llvm/Support/Casting.h" #include "llvm/Support/Casting.h"
#include "llvm/Support/CommandLine.h" #include "llvm/Support/CommandLine.h"
#include "llvm/Support/Compiler.h" #include "llvm/Support/Compiler.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
#include "llvm/Support/ErrorHandling.h" #include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/MathExtras.h" #include "llvm/Support/MathExtras.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
▲ Show 20 Lines • Show All 1,520 Lines • ▼ Show 20 Lines if (Argument *A = dyn_cast<Argument>(V)) {
if (A == &FArg) { if (A == &FArg) {
bool Overflow = ArgOffset + Size > kParamTLSSize; bool Overflow = ArgOffset + Size > kParamTLSSize;
if (FArg.hasByValAttr()) { if (FArg.hasByValAttr()) {
// ByVal pointer itself has clean shadow. We copy the actual // ByVal pointer itself has clean shadow. We copy the actual
// argument shadow to the underlying memory. // argument shadow to the underlying memory.
// Figure out maximal valid memcpy alignment. // Figure out maximal valid memcpy alignment.
const Align ArgAlign = DL.getValueOrABITypeAlignment( const Align ArgAlign = DL.getValueOrABITypeAlignment(
MaybeAlign(FArg.getParamAlignment()), FArg.getParamByValType()); MaybeAlign(FArg.getParamAlignment()), FArg.getParamByValType());
Value *CpShadowPtr = Value *CpShadowPtr, *CpOriginPtr;
std::tie(CpShadowPtr, CpOriginPtr) =
getShadowOriginPtr(V, EntryIRB, EntryIRB.getInt8Ty(), ArgAlign, getShadowOriginPtr(V, EntryIRB, EntryIRB.getInt8Ty(), ArgAlign,
/*isStore*/ true) /*isStore*/ true);
.first;
// TODO(glider): need to copy origins.
if (!PropagateShadow || Overflow) { if (!PropagateShadow || Overflow) {
// ParamTLS overflow. // ParamTLS overflow.
EntryIRB.CreateMemSet( EntryIRB.CreateMemSet(
CpShadowPtr, Constant::getNullValue(EntryIRB.getInt8Ty()), CpShadowPtr, Constant::getNullValue(EntryIRB.getInt8Ty()),
Size, ArgAlign); Size, ArgAlign);
} else { } else {
Value *Base = getShadowPtrForArgument(&FArg, EntryIRB, ArgOffset); Value *Base = getShadowPtrForArgument(&FArg, EntryIRB, ArgOffset);
const Align CopyAlign = std::min(ArgAlign, kShadowTLSAlignment); const Align CopyAlign = std::min(ArgAlign, kShadowTLSAlignment);
Value *Cpy = EntryIRB.CreateMemCpy(CpShadowPtr, CopyAlign, Base, Value *Cpy = EntryIRB.CreateMemCpy(CpShadowPtr, CopyAlign, Base,
CopyAlign, Size); CopyAlign, Size);
LLVM_DEBUG(dbgs() << " ByValCpy: " << *Cpy << "\n"); LLVM_DEBUG(dbgs() << " ByValCpy: " << *Cpy << "\n");
(void)Cpy; (void)Cpy;
if (MS.TrackOrigins) {
Value *OriginPtr =
getOriginPtrForArgument(&FArg, EntryIRB, ArgOffset);
// FIXME: OriginSize should be:
eugenisUnsubmitted
Not Done
ReplyInline Actions

This can get weird if the byval pointer is less than 4 byte aligned, but the alternatives are not pretty, either.

Also, you can bump the alignment std::max(CopyAlign, kMinOriginAlignment).

eugenis: This can get weird if the byval pointer is less than 4 byte aligned, but the alternatives are…
vitalybukaAuthorUnsubmitted
Done
ReplyInline Actions

Not sure if OriginPtr can be aligned higher then kMinOriginAlignment, as origin_tls base is 4 bytes aligned.
CpOriginPtr can be aligned higher, but I guess it does not matter here.

Also please notice the I changed copy size.

vitalybuka: Not sure if OriginPtr can be aligned higher then kMinOriginAlignment, as origin_tls base is 4…
eugenisUnsubmitted
Not Done
ReplyInline Actions

yes, you are right

eugenis: yes, you are right
// alignTo(V % kMinOriginAlignment + Size, kMinOriginAlignment)
unsigned OriginSize = alignTo(Size, kMinOriginAlignment);
EntryIRB.CreateMemCpy(
CpOriginPtr,
/* by getShadowOriginPtr */ kMinOriginAlignment, OriginPtr,
/* by origin_tls[ArgOffset] */ kMinOriginAlignment,
OriginSize);
}
} }
} }
if (!PropagateShadow || Overflow || FArg.hasByValAttr() || if (!PropagateShadow || Overflow || FArg.hasByValAttr() ||
(MS.EagerChecks && FArg.hasAttribute(Attribute::NoUndef))) { (MS.EagerChecks && FArg.hasAttribute(Attribute::NoUndef))) {
*ShadowPtr = getCleanShadow(V); *ShadowPtr = getCleanShadow(V);
setOrigin(A, getCleanOrigin()); setOrigin(A, getCleanOrigin());
} else { } else {
▲ Show 20 Lines • Show All 1,950 Lines • ▼ Show 20 Lines for (auto ArgIt = CB.arg_begin(), End = CB.arg_end(); ArgIt != End;
bool ByVal = CB.paramHasAttr(i, Attribute::ByVal); bool ByVal = CB.paramHasAttr(i, Attribute::ByVal);
bool NoUndef = CB.paramHasAttr(i, Attribute::NoUndef); bool NoUndef = CB.paramHasAttr(i, Attribute::NoUndef);
bool EagerCheck = MayCheckCall && !ByVal && NoUndef; bool EagerCheck = MayCheckCall && !ByVal && NoUndef;
if (EagerCheck) { if (EagerCheck) {
insertShadowCheck(A, &CB); insertShadowCheck(A, &CB);
Size = DL.getTypeAllocSize(A->getType()); Size = DL.getTypeAllocSize(A->getType());
} else { } else {
bool ArgIsInitialized = false;
Value *Store = nullptr; Value *Store = nullptr;
// Compute the Shadow for arg even if it is ByVal, because // Compute the Shadow for arg even if it is ByVal, because
// in that case getShadow() will copy the actual arg shadow to // in that case getShadow() will copy the actual arg shadow to
// __msan_param_tls. // __msan_param_tls.
Value *ArgShadow = getShadow(A); Value *ArgShadow = getShadow(A);
Value *ArgShadowBase = getShadowPtrForArgument(A, IRB, ArgOffset); Value *ArgShadowBase = getShadowPtrForArgument(A, IRB, ArgOffset);
LLVM_DEBUG(dbgs() << " Arg#" << i << ": " << *A LLVM_DEBUG(dbgs() << " Arg#" << i << ": " << *A
<< " Shadow: " << *ArgShadow << "\n"); << " Shadow: " << *ArgShadow << "\n");
if (ByVal) { if (ByVal) {
// ByVal requires some special handling as it's too big for a single // ByVal requires some special handling as it's too big for a single
// load // load
assert(A->getType()->isPointerTy() && assert(A->getType()->isPointerTy() &&
"ByVal argument is not a pointer!"); "ByVal argument is not a pointer!");
Size = DL.getTypeAllocSize(CB.getParamByValType(i)); Size = DL.getTypeAllocSize(CB.getParamByValType(i));
if (ArgOffset + Size > kParamTLSSize) if (ArgOffset + Size > kParamTLSSize)
break; break;
const MaybeAlign ParamAlignment(CB.getParamAlign(i)); const MaybeAlign ParamAlignment(CB.getParamAlign(i));
MaybeAlign Alignment = llvm::None; MaybeAlign Alignment = llvm::None;
if (ParamAlignment) if (ParamAlignment)
Alignment = std::min(*ParamAlignment, kShadowTLSAlignment); Alignment = std::min(*ParamAlignment, kShadowTLSAlignment);
Value *AShadowPtr = Value *AShadowPtr, *AOriginPtr;
std::tie(AShadowPtr, AOriginPtr) =
getShadowOriginPtr(A, IRB, IRB.getInt8Ty(), Alignment, getShadowOriginPtr(A, IRB, IRB.getInt8Ty(), Alignment,
/*isStore*/ false) /*isStore*/ false);
.first;
if (!PropagateShadow) { if (!PropagateShadow) {
Store = IRB.CreateMemSet(ArgShadowBase, Store = IRB.CreateMemSet(ArgShadowBase,
Constant::getNullValue(IRB.getInt8Ty()), Constant::getNullValue(IRB.getInt8Ty()),
Size, Alignment); Size, Alignment);
} else { } else {
Store = IRB.CreateMemCpy(ArgShadowBase, Alignment, AShadowPtr, Store = IRB.CreateMemCpy(ArgShadowBase, Alignment, AShadowPtr,
Alignment, Size); Alignment, Size);
if (MS.TrackOrigins) {
Value *ArgOriginBase = getOriginPtrForArgument(A, IRB, ArgOffset);
// FIXME: OriginSize should be:
// alignTo(A % kMinOriginAlignment + Size, kMinOriginAlignment)
unsigned OriginSize = alignTo(Size, kMinOriginAlignment);
IRB.CreateMemCpy(
ArgOriginBase,
/* by origin_tls[ArgOffset] */ kMinOriginAlignment,
AOriginPtr,
/* by getShadowOriginPtr */ kMinOriginAlignment, OriginSize);
}
} }
} else { } else {
// Any other parameters mean we need bit-grained tracking of uninit // Any other parameters mean we need bit-grained tracking of uninit
// data // data
Size = DL.getTypeAllocSize(A->getType()); Size = DL.getTypeAllocSize(A->getType());
if (ArgOffset + Size > kParamTLSSize) if (ArgOffset + Size > kParamTLSSize)
break; break;
Store = IRB.CreateAlignedStore(ArgShadow, ArgShadowBase, Store = IRB.CreateAlignedStore(ArgShadow, ArgShadowBase,
kShadowTLSAlignment); kShadowTLSAlignment);
Constant *Cst = dyn_cast<Constant>(ArgShadow); Constant *Cst = dyn_cast<Constant>(ArgShadow);
if (Cst && Cst->isNullValue()) if (MS.TrackOrigins && !(Cst && Cst->isNullValue())) {
ArgIsInitialized = true;
}
if (MS.TrackOrigins && !ArgIsInitialized)
IRB.CreateStore(getOrigin(A), IRB.CreateStore(getOrigin(A),
getOriginPtrForArgument(A, IRB, ArgOffset)); getOriginPtrForArgument(A, IRB, ArgOffset));
}
}
(void)Store; (void)Store;
assert(Store != nullptr); assert(Store != nullptr);
LLVM_DEBUG(dbgs() << " Param:" << *Store << "\n"); LLVM_DEBUG(dbgs() << " Param:" << *Store << "\n");
} }
assert(Size != 0); assert(Size != 0);
ArgOffset += alignTo(Size, kShadowTLSAlignment); ArgOffset += alignTo(Size, kShadowTLSAlignment);
} }
LLVM_DEBUG(dbgs() << " done with call args\n"); LLVM_DEBUG(dbgs() << " done with call args\n");
▲ Show 20 Lines • Show All 1,610 Lines • Show Last 20 Lines

llvm/test/Instrumentation/MemorySanitizer/byval.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt < %s -S -passes="msan<track-origins=1>" 2>&1 | FileCheck %s --implicit-check-not "call void @llvm.mem" --implicit-check-not " load" --implicit-check-not " store" ; RUN: opt < %s -S -passes="msan<track-origins=1>" 2>&1 | FileCheck %s --implicit-check-not "call void @llvm.mem" --implicit-check-not " load" --implicit-check-not " store"
; RUN: opt < %s -S -msan -msan-track-origins=1 | FileCheck %s --implicit-check-not "call void @llvm.mem" --implicit-check-not " load" --implicit-check-not " store" ; RUN: opt < %s -S -msan -msan-track-origins=1 | FileCheck %s --implicit-check-not "call void @llvm.mem" --implicit-check-not " load" --implicit-check-not " store"
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"
declare void @FnByVal(i128* byval(i128) %p); declare void @FnByVal(i128* byval(i128) %p);
declare void @Fn(i128* %p); declare void @Fn(i128* %p);
define i128 @ByValArgument(i32, i128* byval(i128) %p) sanitize_memory { define i128 @ByValArgument(i32, i128* byval(i128) %p) sanitize_memory {
; CHECK-LABEL: @ByValArgument( ; CHECK-LABEL: @ByValArgument(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %[[#]], i8* align 8 inttoptr (i64 add (i64 ptrtoint ([100 x i64]* @__msan_param_tls to i64), i64 8) to i8*), i64 16, i1 false) ; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %[[#]], i8* align 8 inttoptr (i64 add (i64 ptrtoint ([100 x i64]* @__msan_param_tls to i64), i64 8) to i8*), i64 16, i1 false)
; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %[[#]], i8* align 4 inttoptr (i64 add (i64 ptrtoint ([200 x i32]* @__msan_param_origin_tls to i64), i64 8) to i8*), i64 16, i1 false)
; CHECK: [[X:%.*]] = load i128, i128* %p, align 8 ; CHECK: [[X:%.*]] = load i128, i128* %p, align 8
; CHECK: [[_MSLD:%.*]] = load i128, i128* %[[#]], align 8 ; CHECK: [[_MSLD:%.*]] = load i128, i128* %[[#]], align 8
; CHECK: %[[#]] = load i32, i32* %[[#]], align 8 ; CHECK: %[[#]] = load i32, i32* %[[#]], align 8
; CHECK: store i128 [[_MSLD]], i128* bitcast ([100 x i64]* @__msan_retval_tls to i128*), align 8 ; CHECK: store i128 [[_MSLD]], i128* bitcast ([100 x i64]* @__msan_retval_tls to i128*), align 8
; CHECK: store i32 %[[#]], i32* @__msan_retval_origin_tls, align 4 ; CHECK: store i32 %[[#]], i32* @__msan_retval_origin_tls, align 4
; CHECK: ret i128 [[X]] ; CHECK: ret i128 [[X]]
; ;
entry: entry:
Show All 10 Lines
; CHECK: store i32 0, i32* @__msan_retval_origin_tls, align 4 ; CHECK: store i32 0, i32* @__msan_retval_origin_tls, align 4
; CHECK: ret i128 [[X]] ; CHECK: ret i128 [[X]]
; ;
entry: entry:
%x = load i128, i128* %p %x = load i128, i128* %p
ret i128 %x ret i128 %x
} }
; FIXME: Origin of byval pointee is not propagated.
define void @ByValForward(i32, i128* byval(i128) %p) sanitize_memory { define void @ByValForward(i32, i128* byval(i128) %p) sanitize_memory {
; CHECK-LABEL: @ByValForward( ; CHECK-LABEL: @ByValForward(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %[[#]], i8* align 8 inttoptr (i64 add (i64 ptrtoint ([100 x i64]* @__msan_param_tls to i64), i64 8) to i8*), i64 16, i1 false) ; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %[[#]], i8* align 8 inttoptr (i64 add (i64 ptrtoint ([100 x i64]* @__msan_param_tls to i64), i64 8) to i8*), i64 16, i1 false)
; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %[[#]], i8* align 4 inttoptr (i64 add (i64 ptrtoint ([200 x i32]* @__msan_param_origin_tls to i64), i64 8) to i8*), i64 16, i1 false)
; CHECK: store i64 0, i64* getelementptr inbounds ([100 x i64], [100 x i64]* @__msan_param_tls, i32 0, i32 0), align 8 ; CHECK: store i64 0, i64* getelementptr inbounds ([100 x i64], [100 x i64]* @__msan_param_tls, i32 0, i32 0), align 8
; CHECK: call void @Fn(i128* %p) ; CHECK: call void @Fn(i128* %p)
; CHECK: ret void ; CHECK: ret void
; ;
entry: entry:
call void @Fn(i128* %p) call void @Fn(i128* %p)
ret void ret void
} }
define void @ByValForwardNoSanitize(i32, i128* byval(i128) %p) { define void @ByValForwardNoSanitize(i32, i128* byval(i128) %p) {
; CHECK-LABEL: @ByValForwardNoSanitize( ; CHECK-LABEL: @ByValForwardNoSanitize(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK: call void @llvm.memset.p0i8.i64(i8* align 8 %[[#]], i8 0, i64 16, i1 false) ; CHECK: call void @llvm.memset.p0i8.i64(i8* align 8 %[[#]], i8 0, i64 16, i1 false)
; CHECK: store i64 0, i64* getelementptr inbounds ([100 x i64], [100 x i64]* @__msan_param_tls, i32 0, i32 0), align 8 ; CHECK: store i64 0, i64* getelementptr inbounds ([100 x i64], [100 x i64]* @__msan_param_tls, i32 0, i32 0), align 8
; CHECK: call void @Fn(i128* %p) ; CHECK: call void @Fn(i128* %p)
; CHECK: ret void ; CHECK: ret void
; ;
entry: entry:
call void @Fn(i128* %p) call void @Fn(i128* %p)
ret void ret void
} }
; FIXME: Origin of %p byval pointee is not propagated.
define void @ByValForwardByVal(i32, i128* byval(i128) %p) sanitize_memory { define void @ByValForwardByVal(i32, i128* byval(i128) %p) sanitize_memory {
; CHECK-LABEL: @ByValForwardByVal( ; CHECK-LABEL: @ByValForwardByVal(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %[[#]], i8* align 8 inttoptr (i64 add (i64 ptrtoint ([100 x i64]* @__msan_param_tls to i64), i64 8) to i8*), i64 16, i1 false) ; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 8 %[[#]], i8* align 8 inttoptr (i64 add (i64 ptrtoint ([100 x i64]* @__msan_param_tls to i64), i64 8) to i8*), i64 16, i1 false)
; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %[[#]], i8* align 4 inttoptr (i64 add (i64 ptrtoint ([200 x i32]* @__msan_param_origin_tls to i64), i64 8) to i8*), i64 16, i1 false)
; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* bitcast ([100 x i64]* @__msan_param_tls to i8*), i8* %[[#]], i64 16, i1 false) ; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* bitcast ([100 x i64]* @__msan_param_tls to i8*), i8* %[[#]], i64 16, i1 false)
; CHECK: store i32 0, i32* getelementptr inbounds ([200 x i32], [200 x i32]* @__msan_param_origin_tls, i32 0, i32 0), align 4 ; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 bitcast ([200 x i32]* @__msan_param_origin_tls to i8*), i8* align 4 %[[#]], i64 16, i1 false)
; CHECK: call void @FnByVal(i128* byval(i128) %p) ; CHECK: call void @FnByVal(i128* byval(i128) %p)
; CHECK: ret void ; CHECK: ret void
; ;
entry: entry:
call void @FnByVal(i128* byval(i128) %p) call void @FnByVal(i128* byval(i128) %p)
ret void ret void
} }
define void @ByValForwardByValNoSanitize(i32, i128* byval(i128) %p) { define void @ByValForwardByValNoSanitize(i32, i128* byval(i128) %p) {
; CHECK-LABEL: @ByValForwardByValNoSanitize( ; CHECK-LABEL: @ByValForwardByValNoSanitize(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK: call void @llvm.memset.p0i8.i64(i8* align 8 %[[#]], i8 0, i64 16, i1 false) ; CHECK: call void @llvm.memset.p0i8.i64(i8* align 8 %[[#]], i8 0, i64 16, i1 false)
; CHECK: call void @llvm.memset.p0i8.i64(i8* bitcast ([100 x i64]* @__msan_param_tls to i8*), i8 0, i64 16, i1 false) ; CHECK: call void @llvm.memset.p0i8.i64(i8* bitcast ([100 x i64]* @__msan_param_tls to i8*), i8 0, i64 16, i1 false)
; CHECK: store i32 0, i32* getelementptr inbounds ([200 x i32], [200 x i32]* @__msan_param_origin_tls, i32 0, i32 0), align 4
; CHECK: call void @FnByVal(i128* byval(i128) %p) ; CHECK: call void @FnByVal(i128* byval(i128) %p)
; CHECK: ret void ; CHECK: ret void
; ;
entry: entry:
call void @FnByVal(i128* byval(i128) %p) call void @FnByVal(i128* byval(i128) %p)
ret void ret void
} }
declare void @FnByVal8(i8* byval(i8) %p); declare void @FnByVal8(i8* byval(i8) %p);
declare void @Fn8(i8* %p); declare void @Fn8(i8* %p);
define i8 @ByValArgument8(i32, i8* byval(i8) %p) sanitize_memory { define i8 @ByValArgument8(i32, i8* byval(i8) %p) sanitize_memory {
; CHECK-LABEL: @ByValArgument8( ; CHECK-LABEL: @ByValArgument8(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %[[#]], i8* align 1 inttoptr (i64 add (i64 ptrtoint ([100 x i64]* @__msan_param_tls to i64), i64 8) to i8*), i64 1, i1 false) ; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %[[#]], i8* align 1 inttoptr (i64 add (i64 ptrtoint ([100 x i64]* @__msan_param_tls to i64), i64 8) to i8*), i64 1, i1 false)
; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %[[#]], i8* align 4 inttoptr (i64 add (i64 ptrtoint ([200 x i32]* @__msan_param_origin_tls to i64), i64 8) to i8*), i64 4, i1 false)
; CHECK: [[X:%.*]] = load i8, i8* %p, align 1 ; CHECK: [[X:%.*]] = load i8, i8* %p, align 1
; CHECK: [[_MSLD:%.*]] = load i8, i8* %[[#]], align 1 ; CHECK: [[_MSLD:%.*]] = load i8, i8* %[[#]], align 1
; CHECK: %[[#]] = load i32, i32* %[[#]], align 4 ; CHECK: %[[#]] = load i32, i32* %[[#]], align 4
; CHECK: store i8 [[_MSLD]], i8* bitcast ([100 x i64]* @__msan_retval_tls to i8*), align 8 ; CHECK: store i8 [[_MSLD]], i8* bitcast ([100 x i64]* @__msan_retval_tls to i8*), align 8
; CHECK: store i32 %[[#]], i32* @__msan_retval_origin_tls, align 4 ; CHECK: store i32 %[[#]], i32* @__msan_retval_origin_tls, align 4
; CHECK: ret i8 [[X]] ; CHECK: ret i8 [[X]]
; ;
entry: entry:
Show All 14 Linesentry:
%x = load i8, i8* %p %x = load i8, i8* %p
ret i8 %x ret i8 %x
} }
define void @ByValForward8(i32, i8* byval(i8) %p) sanitize_memory { define void @ByValForward8(i32, i8* byval(i8) %p) sanitize_memory {
; CHECK-LABEL: @ByValForward8( ; CHECK-LABEL: @ByValForward8(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %[[#]], i8* align 1 inttoptr (i64 add (i64 ptrtoint ([100 x i64]* @__msan_param_tls to i64), i64 8) to i8*), i64 1, i1 false) ; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %[[#]], i8* align 1 inttoptr (i64 add (i64 ptrtoint ([100 x i64]* @__msan_param_tls to i64), i64 8) to i8*), i64 1, i1 false)
; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %[[#]], i8* align 4 inttoptr (i64 add (i64 ptrtoint ([200 x i32]* @__msan_param_origin_tls to i64), i64 8) to i8*), i64 4, i1 false)
; CHECK: store i64 0, i64* getelementptr inbounds ([100 x i64], [100 x i64]* @__msan_param_tls, i32 0, i32 0), align 8 ; CHECK: store i64 0, i64* getelementptr inbounds ([100 x i64], [100 x i64]* @__msan_param_tls, i32 0, i32 0), align 8
; CHECK: call void @Fn8(i8* %p) ; CHECK: call void @Fn8(i8* %p)
; CHECK: ret void ; CHECK: ret void
; ;
entry: entry:
call void @Fn8(i8* %p) call void @Fn8(i8* %p)
ret void ret void
} }
Show All 10 Linesentry:
call void @Fn8(i8* %p) call void @Fn8(i8* %p)
ret void ret void
} }
define void @ByValForwardByVal8(i32, i8* byval(i8) %p) sanitize_memory { define void @ByValForwardByVal8(i32, i8* byval(i8) %p) sanitize_memory {
; CHECK-LABEL: @ByValForwardByVal8( ; CHECK-LABEL: @ByValForwardByVal8(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %[[#]], i8* align 1 inttoptr (i64 add (i64 ptrtoint ([100 x i64]* @__msan_param_tls to i64), i64 8) to i8*), i64 1, i1 false) ; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 %[[#]], i8* align 1 inttoptr (i64 add (i64 ptrtoint ([100 x i64]* @__msan_param_tls to i64), i64 8) to i8*), i64 1, i1 false)
; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %[[#]], i8* align 4 inttoptr (i64 add (i64 ptrtoint ([200 x i32]* @__msan_param_origin_tls to i64), i64 8) to i8*), i64 4, i1 false)
; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* bitcast ([100 x i64]* @__msan_param_tls to i8*), i8* %[[#]], i64 1, i1 false) ; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* bitcast ([100 x i64]* @__msan_param_tls to i8*), i8* %[[#]], i64 1, i1 false)
; CHECK: store i32 0, i32* getelementptr inbounds ([200 x i32], [200 x i32]* @__msan_param_origin_tls, i32 0, i32 0), align 4 ; CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 bitcast ([200 x i32]* @__msan_param_origin_tls to i8*), i8* align 4 %[[#]], i64 4, i1 false)
; CHECK: call void @FnByVal8(i8* byval(i8) %p) ; CHECK: call void @FnByVal8(i8* byval(i8) %p)
; CHECK: ret void ; CHECK: ret void
; ;
entry: entry:
call void @FnByVal8(i8* byval(i8) %p) call void @FnByVal8(i8* byval(i8) %p)
ret void ret void
} }
; FIXME: Shadow for byval should be reset not copied before the call.
define void @ByValForwardByValNoSanitize8(i32, i8* byval(i8) %p) { define void @ByValForwardByValNoSanitize8(i32, i8* byval(i8) %p) {
; CHECK-LABEL: @ByValForwardByValNoSanitize8( ; CHECK-LABEL: @ByValForwardByValNoSanitize8(
; CHECK-NEXT: entry: ; CHECK-NEXT: entry:
; CHECK: call void @llvm.memset.p0i8.i64(i8* align 1 %[[#]], i8 0, i64 1, i1 false) ; CHECK: call void @llvm.memset.p0i8.i64(i8* align 1 %[[#]], i8 0, i64 1, i1 false)
; CHECK: call void @llvm.memset.p0i8.i64(i8* bitcast ([100 x i64]* @__msan_param_tls to i8*), i8 0, i64 1, i1 false) ; CHECK: call void @llvm.memset.p0i8.i64(i8* bitcast ([100 x i64]* @__msan_param_tls to i8*), i8 0, i64 1, i1 false)
; CHECK: store i32 0, i32* getelementptr inbounds ([200 x i32], [200 x i32]* @__msan_param_origin_tls, i32 0, i32 0), align 4
; CHECK: call void @FnByVal8(i8* byval(i8) %p) ; CHECK: call void @FnByVal8(i8* byval(i8) %p)
; CHECK: ret void ; CHECK: ret void
; ;
entry: entry:
call void @FnByVal8(i8* byval(i8) %p) call void @FnByVal8(i8* byval(i8) %p)
ret void ret void
} }