[llvm] r286135 - [tsan] Cast floating-point types correctly when instrumenting atomic accesses, LLVM part
Kuba Brecka via llvm-commits
llvm-commits at lists.llvm.org
Mon Nov 7 11:09:56 PST 2016
Author: kuba.brecka
Date: Mon Nov 7 13:09:56 2016
New Revision: 286135
URL: http://llvm.org/viewvc/llvm-project?rev=286135&view=rev
Log:
[tsan] Cast floating-point types correctly when instrumenting atomic accesses, LLVM part
Although rare, atomic accesses to floating-point types seem to be valid, i.e. `%a = load atomic float ...`. The TSan instrumentation pass however tries to emit inttoptr, which is incorrect, we should use a bitcast here. Anyway, IRBuilder already has a convenient helper function for this.
Differential Revision: https://reviews.llvm.org/D26266
Added:
llvm/trunk/test/Instrumentation/ThreadSanitizer/atomic-non-integer.ll
Modified:
llvm/trunk/lib/Transforms/Instrumentation/ThreadSanitizer.cpp
Modified: llvm/trunk/lib/Transforms/Instrumentation/ThreadSanitizer.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Instrumentation/ThreadSanitizer.cpp?rev=286135&r1=286134&r2=286135&view=diff
==============================================================================
--- llvm/trunk/lib/Transforms/Instrumentation/ThreadSanitizer.cpp (original)
+++ llvm/trunk/lib/Transforms/Instrumentation/ThreadSanitizer.cpp Mon Nov 7 13:09:56 2016
@@ -549,11 +549,6 @@ bool ThreadSanitizer::instrumentMemIntri
return false;
}
-static Value *createIntOrPtrToIntCast(Value *V, Type* Ty, IRBuilder<> &IRB) {
- return isa<PointerType>(V->getType()) ?
- IRB.CreatePtrToInt(V, Ty) : IRB.CreateIntCast(V, Ty, false);
-}
-
// Both llvm and ThreadSanitizer atomic operations are based on C++11/C1x
// standards. For background see C++11 standard. A slightly older, publicly
// available draft of the standard (not entirely up-to-date, but close enough
@@ -576,15 +571,9 @@ bool ThreadSanitizer::instrumentAtomic(I
Value *Args[] = {IRB.CreatePointerCast(Addr, PtrTy),
createOrdering(&IRB, LI->getOrdering())};
Type *OrigTy = cast<PointerType>(Addr->getType())->getElementType();
- if (Ty == OrigTy) {
- Instruction *C = CallInst::Create(TsanAtomicLoad[Idx], Args);
- ReplaceInstWithInst(I, C);
- } else {
- // We are loading a pointer, so we need to cast the return value.
- Value *C = IRB.CreateCall(TsanAtomicLoad[Idx], Args);
- Instruction *Cast = CastInst::Create(Instruction::IntToPtr, C, OrigTy);
- ReplaceInstWithInst(I, Cast);
- }
+ Value *C = IRB.CreateCall(TsanAtomicLoad[Idx], Args);
+ Value *Cast = IRB.CreateBitOrPointerCast(C, OrigTy);
+ I->replaceAllUsesWith(Cast);
} else if (StoreInst *SI = dyn_cast<StoreInst>(I)) {
Value *Addr = SI->getPointerOperand();
int Idx = getMemoryAccessFuncIndex(Addr, DL);
@@ -595,7 +584,7 @@ bool ThreadSanitizer::instrumentAtomic(I
Type *Ty = Type::getIntNTy(IRB.getContext(), BitSize);
Type *PtrTy = Ty->getPointerTo();
Value *Args[] = {IRB.CreatePointerCast(Addr, PtrTy),
- createIntOrPtrToIntCast(SI->getValueOperand(), Ty, IRB),
+ IRB.CreateBitOrPointerCast(SI->getValueOperand(), Ty),
createOrdering(&IRB, SI->getOrdering())};
CallInst *C = CallInst::Create(TsanAtomicStore[Idx], Args);
ReplaceInstWithInst(I, C);
@@ -626,9 +615,9 @@ bool ThreadSanitizer::instrumentAtomic(I
Type *Ty = Type::getIntNTy(IRB.getContext(), BitSize);
Type *PtrTy = Ty->getPointerTo();
Value *CmpOperand =
- createIntOrPtrToIntCast(CASI->getCompareOperand(), Ty, IRB);
+ IRB.CreateBitOrPointerCast(CASI->getCompareOperand(), Ty);
Value *NewOperand =
- createIntOrPtrToIntCast(CASI->getNewValOperand(), Ty, IRB);
+ IRB.CreateBitOrPointerCast(CASI->getNewValOperand(), Ty);
Value *Args[] = {IRB.CreatePointerCast(Addr, PtrTy),
CmpOperand,
NewOperand,
Added: llvm/trunk/test/Instrumentation/ThreadSanitizer/atomic-non-integer.ll
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Instrumentation/ThreadSanitizer/atomic-non-integer.ll?rev=286135&view=auto
==============================================================================
--- llvm/trunk/test/Instrumentation/ThreadSanitizer/atomic-non-integer.ll (added)
+++ llvm/trunk/test/Instrumentation/ThreadSanitizer/atomic-non-integer.ll Mon Nov 7 13:09:56 2016
@@ -0,0 +1,51 @@
+; RUN: opt < %s -tsan -S | FileCheck %s
+; Check that atomic memory operations on floating-point types are converted to calls into ThreadSanitizer runtime.
+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"
+
+define float @load_float(float* %fptr) {
+ %v = load atomic float, float* %fptr unordered, align 4
+ ret float %v
+ ; CHECK-LABEL: load_float
+ ; CHECK: call i32 @__tsan_atomic32_load(i32* %{{.+}}, i32 0)
+ ; CHECK: bitcast i32 {{.+}} to float
+}
+
+define double @load_double(double* %fptr) {
+ %v = load atomic double, double* %fptr unordered, align 8
+ ret double %v
+ ; CHECK-LABEL: load_double
+ ; CHECK: call i64 @__tsan_atomic64_load(i64* %{{.+}}, i32 0)
+ ; CHECK: bitcast i64 {{.+}} to double
+}
+
+define fp128 @load_fp128(fp128* %fptr) {
+ %v = load atomic fp128, fp128* %fptr unordered, align 16
+ ret fp128 %v
+ ; CHECK-LABEL: load_fp128
+ ; CHECK: call i128 @__tsan_atomic128_load(i128* %{{.+}}, i32 0)
+ ; CHECK: bitcast i128 {{.+}} to fp128
+}
+
+define void @store_float(float* %fptr, float %v) {
+ store atomic float %v, float* %fptr unordered, align 4
+ ret void
+ ; CHECK-LABEL: store_float
+ ; CHECK: bitcast float %v to i32
+ ; CHECK: call void @__tsan_atomic32_store(i32* %{{.+}}, i32 %{{.+}}, i32 0)
+}
+
+define void @store_double(double* %fptr, double %v) {
+ store atomic double %v, double* %fptr unordered, align 8
+ ret void
+ ; CHECK-LABEL: store_double
+ ; CHECK: bitcast double %v to i64
+ ; CHECK: call void @__tsan_atomic64_store(i64* %{{.+}}, i64 %{{.+}}, i32 0)
+}
+
+define void @store_fp128(fp128* %fptr, fp128 %v) {
+ store atomic fp128 %v, fp128* %fptr unordered, align 16
+ ret void
+ ; CHECK-LABEL: store_fp128
+ ; CHECK: bitcast fp128 %v to i128
+ ; CHECK: call void @__tsan_atomic128_store(i128* %{{.+}}, i128 %{{.+}}, i32 0)
+}
More information about the llvm-commits
mailing list