This is an archive of the discontinued LLVM Phabricator instance.

Differential D86672

[StackSafety] Ignore allocas with partial lifetime markers
ClosedPublic

Authored by vitalybuka on Aug 26 2020, 8:00 PM.

Details

Reviewers
ChuanqiXu
eugenis
Commits
rGa40660551ea1: [StackSafety] Ignore allocas with partial lifetime markers

Diff Detail

Event Timeline

vitalybuka created this revision.Aug 26 2020, 8:00 PM
Herald added a project: Restricted Project. · View Herald TranscriptAug 26 2020, 8:00 PM
Herald added subscribers: llvm-commits, hiraditya. · View Herald Transcript
vitalybuka requested review of this revision.Aug 26 2020, 8:00 PM
vitalybuka added reviewers: ChuanqiXu, eugenis.Aug 26 2020, 8:00 PM
vitalybuka mentioned this in D84630: [StackSafety] Skip ambiguous lifetime analysis.Aug 26 2020, 8:05 PM
Harbormaster completed remote builds in B69713: Diff 288171.Aug 26 2020, 8:33 PM
vitalybuka planned changes to this revision.Aug 26 2020, 10:34 PM

isPointerOffset is not what I need

ChuanqiXu added a comment.Aug 26 2020, 10:43 PM
In D86672#2240988, @vitalybuka wrote:

isPointerOffset is not what I need

Could we use AI == II.getArgOperand(1)->stripPointerCasts() to judge this situation?

vitalybuka added a comment.Aug 27 2020, 1:53 AM
In D86672#2240996, @ChuanqiXu wrote:
In D86672#2240988, @vitalybuka wrote:

isPointerOffset is not what I need

Could we use AI == II.getArgOperand(1)->stripPointerCasts() to judge this situation?

this can't see through phi nodes.

vitalybuka updated this revision to Diff 288253.Aug 27 2020, 2:50 AM

fix offset

vitalybuka added a parent revision: D86692: [NFC][ValueTracking] Add OffsetZero into findAllocaForValue.Aug 27 2020, 2:51 AM
Harbormaster completed remote builds in B69750: Diff 288253.Aug 27 2020, 2:54 AM
eugenis accepted this revision.Aug 27 2020, 12:48 PM

I wonder if, to be completely correct, we need to rewrite all lifetime calls when extending allocas to 16 bytes in AArch64StackTagging? After all, tag store (llvm.aarch64.stg) is a 16-byte write and it will appear to span beyond the lifetime limits.

This change LGTM.

This revision is now accepted and ready to land.Aug 27 2020, 12:48 PM
This revision was landed with ongoing or failed builds.Aug 27 2020, 1:54 PM
Closed by commit rGa40660551ea1: [StackSafety] Ignore allocas with partial lifetime markers (authored by vitalybuka). · Explain Why
This revision was automatically updated to reflect the committed changes.
vitalybuka added a commit: rGa40660551ea1: [StackSafety] Ignore allocas with partial lifetime markers.

Revision Contents

PathSize
llvm/
lib/
Analysis/
31 lines
test/
Analysis/
StackSafetyAnalysis/
90 lines
Transforms/
SafeStack/
X86/
12 lines

Diff 288171

llvm/lib/Analysis/StackLifetime.cpp

Show First 20 Lines • Show All 58 Lines • ▼ Show 20 Lines auto It = std::upper_bound(Instructions.begin() + ItBB->getSecond().first + 1,
[](const Instruction *L, const Instruction *R) { [](const Instruction *L, const Instruction *R) {
return L->comesBefore(R); return L->comesBefore(R);
}); });
--It; --It;
unsigned InstNum = It - Instructions.begin(); unsigned InstNum = It - Instructions.begin();
return getLiveRange(AI).test(InstNum); return getLiveRange(AI).test(InstNum);
} }
// Return unique alloca completely covered by lifetime marker.
static const AllocaInst *findMatchingAlloca(const IntrinsicInst &II,
const DataLayout &DL) {
const AllocaInst *AI = llvm::findAllocaForValue(II.getArgOperand(1));
if (!AI)
return nullptr;
auto AllocaSizeInBits = AI->getAllocationSizeInBits(DL);
if (!AllocaSizeInBits)
return nullptr;
int64_t AllocaSize = AllocaSizeInBits.getValue() / 8;
auto *Size = dyn_cast<ConstantInt>(II.getArgOperand(0));
if (!Size)
return nullptr;
int64_t LifetimeSize = Size->getSExtValue();
if (LifetimeSize != -1 && LifetimeSize != AllocaSize)
return nullptr;
auto Offset = isPointerOffset(AI, II.getArgOperand(1), DL);
if (!Offset || Offset.getValue())
return nullptr;
return AI;
}
void StackLifetime::collectMarkers() { void StackLifetime::collectMarkers() {
InterestingAllocas.resize(NumAllocas); InterestingAllocas.resize(NumAllocas);
DenseMap<const BasicBlock *, SmallDenseMap<const IntrinsicInst *, Marker>> DenseMap<const BasicBlock *, SmallDenseMap<const IntrinsicInst *, Marker>>
BBMarkerSet; BBMarkerSet;
const DataLayout &DL = F.getParent()->getDataLayout();
// Compute the set of start/end markers per basic block. // Compute the set of start/end markers per basic block.
for (const BasicBlock *BB : depth_first(&F)) { for (const BasicBlock *BB : depth_first(&F)) {
for (const Instruction &I : *BB) { for (const Instruction &I : *BB) {
const IntrinsicInst *II = dyn_cast<IntrinsicInst>(&I); const IntrinsicInst *II = dyn_cast<IntrinsicInst>(&I);
if (!II || !II->isLifetimeStartOrEnd()) if (!II || !II->isLifetimeStartOrEnd())
continue; continue;
const AllocaInst *AI = llvm::findAllocaForValue(II->getArgOperand(1)); const AllocaInst *AI = findMatchingAlloca(*II, DL);
if (!AI) { if (!AI) {
HasUnknownLifetimeStartOrEnd = true; HasUnknownLifetimeStartOrEnd = true;
continue; continue;
} }
auto It = AllocaNumbering.find(AI); auto It = AllocaNumbering.find(AI);
if (It == AllocaNumbering.end()) if (It == AllocaNumbering.end())
continue; continue;
auto AllocaNo = It->second; auto AllocaNo = It->second;
▲ Show 20 Lines • Show All 290 Lines • Show Last 20 Lines

llvm/test/Analysis/StackSafetyAnalysis/lifetime.ll

Show First 20 Lines • Show All 642 Lines • ▼ Show 20 Lines
} }
define void @end_loop() { define void @end_loop() {
; CHECK-LABEL: define void @end_loop() ; CHECK-LABEL: define void @end_loop()
entry: entry:
; CHECK: entry: ; CHECK: entry:
; CHECK-NEXT: Alive: <> ; CHECK-NEXT: Alive: <>
%x = alloca i8, align 4 %x = alloca i8, align 4
call void @llvm.lifetime.start.p0i8(i64 4, i8* %x) call void @llvm.lifetime.start.p0i8(i64 1, i8* %x)
; CHECK: call void @llvm.lifetime.start.p0i8(i64 4, i8* %x) ; CHECK: call void @llvm.lifetime.start.p0i8(i64 1, i8* %x)
; CHECK-NEXT: Alive: <x> ; CHECK-NEXT: Alive: <x>
br label %l2 br label %l2
l2: ; preds = %l2, %entry l2: ; preds = %l2, %entry
; CHECK: l2: ; CHECK: l2:
; MAY-NEXT: Alive: <x> ; MAY-NEXT: Alive: <x>
; MUST-NEXT: Alive: <> ; MUST-NEXT: Alive: <>
call void @capture8(i8* %x) call void @capture8(i8* %x)
call void @llvm.lifetime.end.p0i8(i64 4, i8* %x) call void @llvm.lifetime.end.p0i8(i64 1, i8* %x)
; CHECK: call void @llvm.lifetime.end.p0i8(i64 4, i8* %x) ; CHECK: call void @llvm.lifetime.end.p0i8(i64 1, i8* %x)
; CHECK-NEXT: Alive: <> ; CHECK-NEXT: Alive: <>
br label %l2 br label %l2
} }
define void @start_loop() { define void @start_loop() {
; CHECK-LABEL: define void @start_loop() ; CHECK-LABEL: define void @start_loop()
entry: entry:
; CHECK: entry: ; CHECK: entry:
; CHECK-NEXT: Alive: <> ; CHECK-NEXT: Alive: <>
%x = alloca i8, align 4 %x = alloca i8, align 4
%y = alloca i8, align 4 %y = alloca i8, align 4
call void @llvm.lifetime.start.p0i8(i64 4, i8* %x) call void @llvm.lifetime.start.p0i8(i64 1, i8* %x)
; CHECK: call void @llvm.lifetime.start.p0i8(i64 4, i8* %x) ; CHECK: call void @llvm.lifetime.start.p0i8(i64 1, i8* %x)
; CHECK-NEXT: Alive: <x> ; CHECK-NEXT: Alive: <x>
br label %l2 br label %l2
l2: ; preds = %l2, %entry l2: ; preds = %l2, %entry
; CHECK: l2: ; CHECK: l2:
; CHECK-NEXT: Alive: <x> ; CHECK-NEXT: Alive: <x>
call void @llvm.lifetime.start.p0i8(i64 4, i8* %y) call void @llvm.lifetime.start.p0i8(i64 1, i8* %y)
; CHECK: call void @llvm.lifetime.start.p0i8(i64 4, i8* %y) ; CHECK: call void @llvm.lifetime.start.p0i8(i64 1, i8* %y)
; CHECK-NEXT: Alive: <x y> ; CHECK-NEXT: Alive: <x y>
call void @capture8(i8* %y) call void @capture8(i8* %y)
call void @llvm.lifetime.end.p0i8(i64 4, i8* %y) call void @llvm.lifetime.end.p0i8(i64 1, i8* %y)
; CHECK: call void @llvm.lifetime.end.p0i8(i64 4, i8* %y) ; CHECK: call void @llvm.lifetime.end.p0i8(i64 1, i8* %y)
; CHECK-NEXT: Alive: <x> ; CHECK-NEXT: Alive: <x>
call void @llvm.lifetime.start.p0i8(i64 4, i8* %x) call void @llvm.lifetime.start.p0i8(i64 1, i8* %x)
; CHECK: call void @llvm.lifetime.start.p0i8(i64 4, i8* %x) ; CHECK: call void @llvm.lifetime.start.p0i8(i64 1, i8* %x)
; CHECK-NEXT: Alive: <x> ; CHECK-NEXT: Alive: <x>
call void @capture8(i8* %x) call void @capture8(i8* %x)
br label %l2 br label %l2
} }
%struct.char_array = type { [500 x i8] } %struct.char_array = type { [500 x i8] }
▲ Show 20 Lines • Show All 49 Lines • ▼ Show 20 Lines; CHECK-NEXT: Alive: <>
br i1 %a, label %if.then, label %if.else br i1 %a, label %if.then, label %if.else
; CHECK: br i1 %a, label %if.then, label %if.else ; CHECK: br i1 %a, label %if.then, label %if.else
; CHECK-NEXT: Alive: <> ; CHECK-NEXT: Alive: <>
if.then: if.then:
; CHECK: if.then: ; CHECK: if.then:
; CHECK-NEXT: Alive: <> ; CHECK-NEXT: Alive: <>
call void @llvm.lifetime.start.p0i8(i64 4, i8* %y) call void @llvm.lifetime.start.p0i8(i64 1, i8* %y)
; CHECK: call void @llvm.lifetime.start.p0i8(i64 4, i8* %y) ; CHECK: call void @llvm.lifetime.start.p0i8(i64 1, i8* %y)
; CHECK-NEXT: Alive: <y> ; CHECK-NEXT: Alive: <y>
br label %if.end br label %if.end
; CHECK: br label %if.end ; CHECK: br label %if.end
; CHECK-NEXT: Alive: <y> ; CHECK-NEXT: Alive: <y>
if.else: if.else:
; CHECK: if.else: ; CHECK: if.else:
; CHECK-NEXT: Alive: <> ; CHECK-NEXT: Alive: <>
call void @llvm.lifetime.start.p0i8(i64 4, i8* %y) call void @llvm.lifetime.start.p0i8(i64 1, i8* %y)
; CHECK: call void @llvm.lifetime.start.p0i8(i64 4, i8* %y) ; CHECK: call void @llvm.lifetime.start.p0i8(i64 1, i8* %y)
; CHECK-NEXT: Alive: <y> ; CHECK-NEXT: Alive: <y>
call void @llvm.lifetime.start.p0i8(i64 4, i8* %x) call void @llvm.lifetime.start.p0i8(i64 1, i8* %x)
; CHECK: call void @llvm.lifetime.start.p0i8(i64 4, i8* %x) ; CHECK: call void @llvm.lifetime.start.p0i8(i64 1, i8* %x)
; CHECK-NEXT: Alive: <x y> ; CHECK-NEXT: Alive: <x y>
br label %if.end br label %if.end
; CHECK: br label %if.end ; CHECK: br label %if.end
; CHECK-NEXT: Alive: <x y> ; CHECK-NEXT: Alive: <x y>
if.end: if.end:
; CHECK: if.end: ; CHECK: if.end:
; MAY-NEXT: Alive: <x y> ; MAY-NEXT: Alive: <x y>
; MUST-NEXT: Alive: <y> ; MUST-NEXT: Alive: <y>
ret void ret void
} }
define void @unreachable() { define void @unreachable() {
; CHECK-LABEL: define void @unreachable ; CHECK-LABEL: define void @unreachable
entry: entry:
; CHECK: entry: ; CHECK: entry:
; CHECK-NEXT: Alive: <> ; CHECK-NEXT: Alive: <>
%x = alloca i8, align 4 %x = alloca i8, align 4
%y = alloca i8, align 4 %y = alloca i8, align 4
call void @llvm.lifetime.start.p0i8(i64 4, i8* %y) call void @llvm.lifetime.start.p0i8(i64 1, i8* %y)
; CHECK: call void @llvm.lifetime.start.p0i8(i64 4, i8* %y) ; CHECK: call void @llvm.lifetime.start.p0i8(i64 1, i8* %y)
; CHECK-NEXT: Alive: <y> ; CHECK-NEXT: Alive: <y>
call void @llvm.lifetime.start.p0i8(i64 4, i8* %x) call void @llvm.lifetime.start.p0i8(i64 1, i8* %x)
; CHECK: call void @llvm.lifetime.start.p0i8(i64 4, i8* %x) ; CHECK: call void @llvm.lifetime.start.p0i8(i64 1, i8* %x)
; CHECK-NEXT: Alive: <x y> ; CHECK-NEXT: Alive: <x y>
br label %end br label %end
; CHECK: br label %end ; CHECK: br label %end
; CHECK-NEXT: Alive: <x y> ; CHECK-NEXT: Alive: <x y>
dead: dead:
; CHECK: dead: ; CHECK: dead:
▲ Show 20 Lines • Show All 61 Lines • ▼ Show 20 Lines; MUST-NEXT: Alive: <>
call void @llvm.lifetime.end.p0i8(i64 1, i8* %x) call void @llvm.lifetime.end.p0i8(i64 1, i8* %x)
; CHECK: call void @llvm.lifetime.end.p0i8(i64 1, i8* %x) ; CHECK: call void @llvm.lifetime.end.p0i8(i64 1, i8* %x)
; MAY-NEXT: Alive: <x y> ; MAY-NEXT: Alive: <x y>
; MUST-NEXT: Alive: <> ; MUST-NEXT: Alive: <>
ret void ret void
} }
define void @alloca_offset() {
; CHECK-LABEL: define void @alloca_offset
entry:
; CHECK: entry:
; MAY-NEXT: Alive: <x>
; MUST-NEXT: Alive: <>
%x = alloca [5 x i32], align 4
%x2 = getelementptr [5 x i32], [5 x i32]* %x, i64 0, i64 1
call void @llvm.lifetime.start.p0i32(i64 20, i32* %x2)
; CHECK: call void @llvm.lifetime.start.p0i32(i64 20, i32* %x2)
; MAY-NEXT: Alive: <x>
; MUST-NEXT: Alive: <>
call void @llvm.lifetime.end.p0i32(i64 20, i32* %x2)
; CHECK: call void @llvm.lifetime.end.p0i32(i64 20, i32* %x2)
; MAY-NEXT: Alive: <x>
; MUST-NEXT: Alive: <>
ret void
}
define void @alloca_size() {
; CHECK-LABEL: define void @alloca_size
entry:
; CHECK: entry:
; MAY-NEXT: Alive: <x>
; MUST-NEXT: Alive: <>
%x = alloca [5 x i32], align 4
%x2 = getelementptr [5 x i32], [5 x i32]* %x, i64 0, i64 0
call void @llvm.lifetime.start.p0i32(i64 15, i32* %x2)
; CHECK: call void @llvm.lifetime.start.p0i32(i64 15, i32* %x2)
; MAY-NEXT: Alive: <x>
; MUST-NEXT: Alive: <>
call void @llvm.lifetime.end.p0i32(i64 15, i32* %x2)
; CHECK: call void @llvm.lifetime.end.p0i32(i64 15, i32* %x2)
; MAY-NEXT: Alive: <x>
; MUST-NEXT: Alive: <>
ret void
}
declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
declare void @llvm.lifetime.start.p0i32(i64, i32* nocapture)
declare void @llvm.lifetime.end.p0i32(i64, i32* nocapture)
declare void @capture8(i8*) declare void @capture8(i8*)
declare void @capture32(i32*) declare void @capture32(i32*)
declare void @capture64(i64*) declare void @capture64(i64*)
declare void @capture100x32([100 x i32]*) declare void @capture100x32([100 x i32]*)

llvm/test/Transforms/SafeStack/X86/layout-frag.ll

; Test that safestack layout reuses a region w/o fragmentation. ; Test that safestack layout reuses a region w/o fragmentation.
; RUN: opt -safe-stack -safe-stack-coloring=1 -S -mtriple=x86_64-pc-linux-gnu < %s -o - | FileCheck %s ; RUN: opt -safe-stack -safe-stack-coloring=1 -S -mtriple=x86_64-pc-linux-gnu < %s -o - | FileCheck %s
define void @f() safestack { define void @f() safestack {
; CHECK-LABEL: define void @f ; CHECK-LABEL: define void @f
entry: entry:
; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr ; CHECK: %[[USP:.*]] = load i8*, i8** @__safestack_unsafe_stack_ptr
; CHECK: getelementptr i8, i8* %[[USP]], i32 -16 ; CHECK: getelementptr i8, i8* %[[USP]], i32 -16
%x0 = alloca i64, align 8 %x0 = alloca i64, align 8
%x1 = alloca i8, align 1 %x1 = alloca i8, align 1
%x2 = alloca i64, align 8 %x2 = alloca i64, align 8
%x0a = bitcast i64* %x0 to i8* %x0a = bitcast i64* %x0 to i8*
%x2a = bitcast i64* %x2 to i8* %x2a = bitcast i64* %x2 to i8*
call void @llvm.lifetime.start.p0i8(i64 4, i8* %x0a) call void @llvm.lifetime.start.p0i8(i64 8, i8* %x0a)
call void @capture64(i64* %x0) call void @capture64(i64* %x0)
call void @llvm.lifetime.end.p0i8(i64 4, i8* %x0a) call void @llvm.lifetime.end.p0i8(i64 8, i8* %x0a)
call void @llvm.lifetime.start.p0i8(i64 4, i8* %x1) call void @llvm.lifetime.start.p0i8(i64 1, i8* %x1)
call void @llvm.lifetime.start.p0i8(i64 4, i8* %x2a) call void @llvm.lifetime.start.p0i8(i64 8, i8* %x2a)
call void @capture8(i8* %x1) call void @capture8(i8* %x1)
call void @capture64(i64* %x2) call void @capture64(i64* %x2)
call void @llvm.lifetime.end.p0i8(i64 4, i8* %x1) call void @llvm.lifetime.end.p0i8(i64 1, i8* %x1)
call void @llvm.lifetime.end.p0i8(i64 4, i8* %x2a) call void @llvm.lifetime.end.p0i8(i64 8, i8* %x2a)
; Test that i64 allocas share space. ; Test that i64 allocas share space.
; CHECK: getelementptr i8, i8* %unsafe_stack_ptr, i32 -8 ; CHECK: getelementptr i8, i8* %unsafe_stack_ptr, i32 -8
; CHECK: getelementptr i8, i8* %unsafe_stack_ptr, i32 -9 ; CHECK: getelementptr i8, i8* %unsafe_stack_ptr, i32 -9
; CHECK: getelementptr i8, i8* %unsafe_stack_ptr, i32 -8 ; CHECK: getelementptr i8, i8* %unsafe_stack_ptr, i32 -8
ret void ret void
} }
declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture) declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture) declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
declare void @capture8(i8*) declare void @capture8(i8*)
declare void @capture64(i64*) declare void @capture64(i64*)