RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2025-02-28 00:07:22 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[hwasan] Remove lazy thread-initialisation

Browse Source 
This was an experiment made possible by a non-standard feature of the
Android dynamic loader.

It required introducing a flag to tell the compiler which ABI was being
targeted.
This flag is no longer needed, since the generated code now works for
both ABI's.

We leave that flag untouched for backwards compatibility. This also
means that if we need to distinguish between targeted ABI's again
we can do that without disturbing any existing workflows.

We leave a comment in the source code and mention in the help text to
explain this for any confused person reading the code in the future.

Patch by Matthew Malcomson

Differential Revision: https://reviews.llvm.org/D69574
This commit is contained in:
David Spickett 2019-11-04 10:58:46 +00:00
parent 7b87fa876f
commit 7d79fa7e02
2 changed files with 2 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
lib/Transforms/Instrumentation/HWAddressSanitizer.cpp
View File

@ -284,7 +284,6 @@ private:
FunctionCallee HwasanTagMemoryFunc;
FunctionCallee HwasanGenerateTagFunc;
FunctionCallee HwasanThreadEnterFunc;
Constant *ShadowGlobal;
@ -473,9 +472,6 @@ void HWAddressSanitizer::initializeCallbacks(Module &M) {
HWAsanHandleVfork =
M.getOrInsertFunction("__hwasan_handle_vfork", IRB.getVoidTy(), IntptrTy);
HwasanThreadEnterFunc =
M.getOrInsertFunction("__hwasan_thread_enter", IRB.getVoidTy());
}
Value *HWAddressSanitizer::getDynamicShadowIfunc(IRBuilder<> &IRB) {
@ -934,34 +930,13 @@ void HWAddressSanitizer::emitPrologue(IRBuilder<> &IRB, bool WithFrameRecord) {
Value *SlotPtr = getHwasanThreadSlotPtr(IRB, IntptrTy);
assert(SlotPtr);
Instruction *ThreadLong = IRB.CreateLoad(IntptrTy, SlotPtr);
Function *F = IRB.GetInsertBlock()->getParent();
if (F->getFnAttribute("hwasan-abi").getValueAsString() == "interceptor") {
Value *ThreadLongEqZero =
IRB.CreateICmpEQ(ThreadLong, ConstantInt::get(IntptrTy, 0));
auto *Br = cast<BranchInst>(SplitBlockAndInsertIfThen(
ThreadLongEqZero, cast<Instruction>(ThreadLongEqZero)->getNextNode(),
false, MDBuilder(*C).createBranchWeights(1, 100000)));
IRB.SetInsertPoint(Br);
// FIXME: This should call a new runtime function with a custom calling
// convention to avoid needing to spill all arguments here.
IRB.CreateCall(HwasanThreadEnterFunc);
LoadInst *ReloadThreadLong = IRB.CreateLoad(IntptrTy, SlotPtr);
IRB.SetInsertPoint(&*Br->getSuccessor(0)->begin());
PHINode *ThreadLongPhi = IRB.CreatePHI(IntptrTy, 2);
ThreadLongPhi->addIncoming(ThreadLong, ThreadLong->getParent());
ThreadLongPhi->addIncoming(ReloadThreadLong, ReloadThreadLong->getParent());
ThreadLong = ThreadLongPhi;
}
Value *ThreadLong = IRB.CreateLoad(IntptrTy, SlotPtr);
// Extract the address field from ThreadLong. Unnecessary on AArch64 with TBI.
Value *ThreadLongMaybeUntagged =
TargetTriple.isAArch64() ? ThreadLong : untagPointer(IRB, ThreadLong);
if (WithFrameRecord) {
Function *F = IRB.GetInsertBlock()->getParent();
StackBaseTag = IRB.CreateAShr(ThreadLong, 3);
// Prepare ring buffer data.

39
test/Instrumentation/HWAddressSanitizer/lazy-thread-init.ll
View File

@ -1,39 +0,0 @@
; RUN: opt -S -hwasan < %s | FileCheck %s
target triple = "aarch64--linux-android"
declare i32 @bar([16 x i32]* %p)
define void @alloca() sanitize_hwaddress "hwasan-abi"="interceptor" {
; CHECK: alloca [16 x i32]
; CHECK: [[A:%[^ ]*]] = call i8* @llvm.thread.pointer()
; CHECK: [[B:%[^ ]*]] = getelementptr i8, i8* [[A]], i32 48
; CHECK: [[C:%[^ ]*]] = bitcast i8* [[B]] to i64*
; CHECK: [[LOAD:%[^ ]*]] = load i64, i64* [[C]]
; CHECK: [[ICMP:%[^ ]*]] = icmp eq i64 [[LOAD]], 0
; CHECK: br i1 [[ICMP]], label %[[INIT:[^,]*]], label %[[CONT:[^,]*]], !prof [[PROF:![0-9]+]]
; CHECK: [[INIT]]:
; CHECK: call void @__hwasan_thread_enter()
; CHECK: [[RELOAD:%[^ ]*]] = load i64, i64* [[C]]
; CHECK: br label %[[CONT]]
; CHECK: [[CONT]]:
; CHECK: phi i64 [ [[LOAD]], %0 ], [ [[RELOAD]], %[[INIT]] ]
; CHECK: alloca i8
%p = alloca [16 x i32]
%size = call i32 @bar([16 x i32]* %p)
%q = alloca i8, i32 %size
ret void
}
define i32 @load(i32* %p) sanitize_hwaddress "hwasan-abi"="interceptor" {
; CHECK: [[SHADOW:%[^ ]*]] = call i8* asm "", "=r,0"([0 x i8]* @__hwasan_shadow)
; CHECK-NOT: icmp
; CHECK: call void @llvm.hwasan.check.memaccess(i8* [[SHADOW]],
%v = load i32, i32* %p
ret i32 %v
}
; CHECK: [[PROF]] = !{!"branch_weights", i32 1, i32 100000}