Skip to content

Commit 75bd5b0

Browse files
meg-guptameg-gupta
committed
Add LifetimeDependenceScopeFixup pass
1 parent 14578db commit 75bd5b0

File tree

9 files changed

+306
-5
lines changed

9 files changed

+306
-5
lines changed

‎SwiftCompilerSources/Sources/Optimizer/FunctionPasses/CMakeLists.txt‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,7 @@ swift_compiler_sources(Optimizer
2020
LetPropertyLowering.swift
2121
LifetimeDependenceDiagnostics.swift
2222
LifetimeDependenceInsertion.swift
23+
LifetimeDependenceScopeFixup.swift
2324
ObjectOutliner.swift
2425
ObjCBridgingOptimization.swift
2526
MergeCondFails.swift

‎SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceScopeFixup.swift‎

Lines changed: 141 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,141 @@
1+
//===--- LifetimeDependenceScopeFixup.swift ----------------------------===//
2+
//
3+
// This source file is part of the Swift.org open source project
4+
//
5+
// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors
6+
// Licensed under Apache License v2.0 with Runtime Library Exception
7+
//
8+
// See https://swift.org/LICENSE.txt for license information
9+
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
10+
//
11+
//===---------------------------------------------------------------------===//
12+
13+
// For an apply that returns a lifetime dependent value,
14+
// LifetimeDependenceInsertion inserts mark_dependence [unresolved] on parent
15+
// value's access scope. LifetimeDependenceScopeFixup then extends the access
16+
// scope to cover all uses of the dependent value.
17+
18+
// This pass must run after LifetimeDependenceInsertion and before
19+
// LifetimeDependenceDiagnostics.
20+
21+
import SIL
22+
23+
private let verbose = false
24+
25+
private func log(_ message: @autoclosure () -> String) {
26+
if verbose {
27+
print("### \(message())")
28+
}
29+
}
30+
31+
let lifetimeDependenceScopeFixupPass = FunctionPass(
32+
name: "lifetime-dependence-scope-fixup")
33+
{ (function: Function, context: FunctionPassContext) in
34+
log("Scope fixup for lifetime dependence in \(function.name)")
35+
36+
for instruction in function.instructions {
37+
guard let markDep = instruction as? MarkDependenceInst else {
38+
continue
39+
}
40+
if let lifetimeDep = LifetimeDependence(markDep, context) {
41+
fixup(dependence: lifetimeDep, context)
42+
}
43+
}
44+
}
45+
46+
private func fixup(dependence: LifetimeDependence,
47+
_ context: FunctionPassContext) {
48+
log("Scope fixup for lifetime dependent instructions: \(dependence)")
49+
50+
guard case .access(let bai) = dependence.scope else {
51+
return
52+
}
53+
var range = InstructionRange(begin: bai, context)
54+
var walker = LifetimeDependenceScopeFixupWalker(bai.parentFunction, context) {
55+
range.insert($0.instruction)
56+
return .continueWalk
57+
}
58+
defer {walker.deinitialize()}
59+
_ = walker.walkDown(root: dependence.dependentValue)
60+
defer {range.deinitialize()}
61+
62+
var beginAccess = bai
63+
while (true) {
64+
var endAcceses = [Instruction]()
65+
// Collect original end_access instructions
66+
for end in beginAccess.endInstructions {
67+
endAcceses.append(end)
68+
}
69+
70+
// Insert original end_access instructions to prevent access scope shortening
71+
range.insert(contentsOf: endAcceses)
72+
assert(!range.ends.isEmpty)
73+
74+
// Create new end_access at the end of extended uses
75+
for end in range.ends {
76+
let endBuilder = Builder(after: end, context)
77+
_ = endBuilder.createEndAccess(beginAccess: beginAccess)
78+
}
79+
80+
// Delete original end_access instructions
81+
for endAccess in endAcceses {
82+
context.erase(instruction: endAccess)
83+
}
84+
85+
// TODO: Add SIL support for lifetime dependence and write unit test
86+
// for nested access scopes
87+
guard case let .scope(enclosingBeginAccess) = beginAccess.address.enclosingAccessScope else {
88+
break
89+
}
90+
beginAccess = enclosingBeginAccess
91+
}
92+
}
93+
94+
private struct LifetimeDependenceScopeFixupWalker : LifetimeDependenceDefUseWalker {
95+
let function: Function
96+
let context: Context
97+
let visitor: (Operand) -> WalkResult
98+
var visitedValues: ValueSet
99+
100+
init(_ function: Function, _ context: Context, visitor: @escaping (Operand) -> WalkResult) {
101+
self.function = function
102+
self.context = context
103+
self.visitor = visitor
104+
self.visitedValues = ValueSet(context)
105+
}
106+
107+
mutating func deinitialize() {
108+
visitedValues.deinitialize()
109+
}
110+
111+
mutating func needWalk(for value: Value) -> Bool {
112+
visitedValues.insert(value)
113+
}
114+
115+
mutating func deadValue(_ value: Value, using operand: Operand?)
116+
-> WalkResult {
117+
if let operand {
118+
return visitor(operand)
119+
}
120+
return .continueWalk
121+
}
122+
123+
mutating func leafUse(of operand: Operand) -> WalkResult {
124+
return visitor(operand)
125+
}
126+
127+
mutating func escapingDependence(on operand: Operand) -> WalkResult {
128+
_ = visitor(operand)
129+
return .abortWalk
130+
}
131+
132+
mutating func returnedDependence(result: Operand) -> WalkResult {
133+
return .continueWalk
134+
}
135+
136+
mutating func returnedDependence(address: FunctionArgument,
137+
using operand: Operand) -> WalkResult {
138+
return .continueWalk
139+
}
140+
}
141+

‎SwiftCompilerSources/Sources/Optimizer/PassManager/PassRegistration.swift‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -91,7 +91,7 @@ private func registerSwiftPasses() {
9191
registerPass(deinitDevirtualizer, { deinitDevirtualizer.run($0) })
9292
registerPass(lifetimeDependenceDiagnosticsPass, { lifetimeDependenceDiagnosticsPass.run($0) })
9393
registerPass(lifetimeDependenceInsertionPass, { lifetimeDependenceInsertionPass.run($0) })
94-
94+
registerPass(lifetimeDependenceScopeFixupPass, { lifetimeDependenceScopeFixupPass.run($0) })
9595
// Instruction passes
9696
registerForSILCombine(BeginCOWMutationInst.self, { run(BeginCOWMutationInst.self, $0) })
9797
registerForSILCombine(GlobalValueInst.self, { run(GlobalValueInst.self, $0) })

‎include/swift/SILOptimizer/PassManager/Passes.def‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -290,6 +290,9 @@ SWIFT_FUNCTION_PASS(LifetimeDependenceDiagnostics,
290290
SWIFT_FUNCTION_PASS(LifetimeDependenceInsertion,
291291
"lifetime-dependence-insertion",
292292
"Insert Lifetime Dependence Markers")
293+
SWIFT_FUNCTION_PASS(LifetimeDependenceScopeFixup,
294+
"lifetime-dependence-scope-fixup",
295+
"Fixup scope for lifetime dependence")
293296
PASS(LoopCanonicalizer, "loop-canonicalizer",
294297
"Loop Canonicalization")
295298
PASS(LoopInfoPrinter, "loop-info-printer",

‎lib/SILOptimizer/PassManager/PassPipeline.cpp‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -301,6 +301,9 @@ SILPassPipelinePlan::getSILGenPassPipeline(const SILOptions &Options) {
301301
if (EnableLifetimeDependenceDiagnostics || EnableLifetimeDependenceInsertion) {
302302
P.addLifetimeDependenceInsertion();
303303
}
304+
if (EnableLifetimeDependenceDiagnostics) {
305+
P.addLifetimeDependenceScopeFixup();
306+
}
304307
if (SILViewSILGenCFG) {
305308
addCFGPrinterPipeline(P, "SIL View SILGen CFG");
306309
}

‎test/SIL/implicit_lifetime_dependence.swift‎

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -34,7 +34,6 @@ struct MutableBufferView : ~Escapable, ~Copyable {
3434
}
3535
}
3636

37-
/*
3837
// rdar://121983770
3938
func testBasic() {
4039
let capacity = 4
@@ -46,7 +45,6 @@ func testBasic() {
4645
use(newView)
4746
}
4847
}
49-
*/
5048

5149
// CHECK-LABEL: sil hidden @$s28implicit_lifetime_dependence6deriveyAA10BufferViewVADF : $@convention(thin) (@guaranteed BufferView) -> _scope(1) @owned BufferView {
5250
func derive(_ x: borrowing BufferView) -> BufferView {

‎test/SILOptimizer/lifetime_dependence_borrow_fail.swift‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,8 @@
55
// RUN: -module-name test \
66
// RUN: -disable-experimental-parser-round-trip \
77
// RUN: -enable-experimental-feature NonescapableTypes \
8-
// RUN: -Xllvm -enable-lifetime-dependence-diagnostics
8+
// RUN: -Xllvm -enable-lifetime-dependence-diagnostics \
9+
// RUN: -enable-experimental-lifetime-dependence-inference
910

1011
// REQUIRES: swift_in_compiler
1112

‎test/SILOptimizer/lifetime_dependence_generic_fail.swift‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -33,5 +33,5 @@ public struct PView: P {
3333
public func pview_ret_concrete(pview: consuming PView) -> _consume(pview) View {
3434
return pview.getDefault() // expected-error {{lifetime-dependent value escapes its scope}}
3535
// expected-note @-1 {{it depends on this scoped access to variable 'pview'}}
36-
// expected-note @-2 {{this use of the lifetime-dependent value is out of scope}}
36+
// expected-note @-2 {{this use causes the lifetime-dependent value to escape}}
3737
}

‎test/SILOptimizer/lifetime_dependence_scope_fixup.swift‎

Lines changed: 154 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,154 @@
1+
// RUN: %target-swift-frontend %s -emit-sil -o /dev/null -verify \
2+
// RUN: -enable-builtin-module \
3+
// RUN: -enable-experimental-feature NonescapableTypes \
4+
// RUN: -disable-experimental-parser-round-trip \
5+
// RUN: -enable-experimental-feature NoncopyableGenerics \
6+
// RUN: -enable-experimental-lifetime-dependence-inference \
7+
// RUN: -Xllvm -enable-lifetime-dependence-diagnostics=true
8+
// REQUIRES: asserts
9+
// REQUIRES: noncopyable_generics
10+
// REQUIRES: swift_in_compiler
11+
12+
struct NCContainer : ~Copyable {
13+
let ptr: UnsafeRawBufferPointer
14+
init(_ ptr: UnsafeRawBufferPointer) {
15+
self.ptr = ptr
16+
}
17+
}
18+
19+
struct NEContainer : ~Escapable {
20+
let ptr: UnsafeRawBufferPointer
21+
@_unsafeNonescapableResult
22+
init(_ ptr: UnsafeRawBufferPointer) {
23+
self.ptr = ptr
24+
}
25+
}
26+
27+
struct View : ~Escapable {
28+
let ptr: UnsafeRawBufferPointer
29+
@_unsafeNonescapableResult
30+
init(_ ptr: UnsafeRawBufferPointer) {
31+
self.ptr = ptr
32+
}
33+
init(_ otherBV: borrowing View) {
34+
self.ptr = otherBV.ptr
35+
}
36+
init(_ k: borrowing NCContainer) {
37+
self.ptr = k.ptr
38+
}
39+
init(_ k: consuming NEContainer) {
40+
self.ptr = k.ptr
41+
}
42+
}
43+
44+
struct MutableView : ~Copyable, ~Escapable {
45+
let ptr: UnsafeRawBufferPointer
46+
@_unsafeNonescapableResult
47+
init(_ ptr: UnsafeRawBufferPointer) {
48+
self.ptr = ptr
49+
}
50+
init(_ otherBV: borrowing View) {
51+
self.ptr = otherBV.ptr
52+
}
53+
init(_ k: consuming NCContainer) {
54+
self.ptr = k.ptr
55+
}
56+
}
57+
58+
func use(_ o : borrowing View) {}
59+
func mutate(_ x: inout NCContainer) { }
60+
func mutate(_ x: inout View) { }
61+
func mutate(_ x: inout NEContainer) { }
62+
func consume(_ o : consuming View) {}
63+
func use(_ o : borrowing MutableView) {}
64+
func consume(_ o : consuming MutableView) {}
65+
66+
func getConsumingView(_ x: consuming NEContainer) -> _consume(x) View {
67+
return View(x)
68+
}
69+
70+
func getConsumingView(_ x: consuming View) -> _consume(x) View {
71+
return View(x.ptr)
72+
}
73+
74+
func getBorrowingView(_ x: borrowing View) -> _borrow(x) View {
75+
return View(x.ptr)
76+
}
77+
78+
func getBorrowingView(_ x: borrowing NCContainer) -> _borrow(x) View {
79+
return View(x.ptr)
80+
}
81+
82+
func getBorrowingView(_ x: borrowing NEContainer) -> _borrow(x) View {
83+
return View(x.ptr)
84+
}
85+
86+
func test1(_ a: Array<Int>) {
87+
a.withUnsafeBytes {
88+
var x = NEContainer($0)
89+
mutate(&x)
90+
let view = getConsumingView(x)
91+
let newView = View(view)
92+
use(newView)
93+
consume(view)
94+
}
95+
}
96+
97+
func test2(_ a: Array<Int>) {
98+
a.withUnsafeBytes {
99+
var x = NCContainer($0)
100+
mutate(&x)
101+
let view = getBorrowingView(x)
102+
use(view)
103+
consume(view)
104+
}
105+
}
106+
107+
func test3(_ a: Array<Int>) {
108+
a.withUnsafeBytes {
109+
var x = View($0)
110+
mutate(&x)
111+
let view = getConsumingView(x)
112+
use(view)
113+
consume(view)
114+
}
115+
}
116+
117+
func test4(_ a: Array<Int>) {
118+
a.withUnsafeBytes {
119+
var x = NCContainer($0)
120+
mutate(&x)
121+
let view = MutableView(x)
122+
use(view)
123+
consume(view)
124+
}
125+
}
126+
127+
func test5(_ a: Array<Int>) {
128+
a.withUnsafeBytes {
129+
let x = NEContainer($0)
130+
let view = getBorrowingView(x)
131+
let anotherView = getConsumingView(view)
132+
use(anotherView)
133+
}
134+
}
135+
136+
func test6(_ a: Array<Int>) {
137+
var p : View?
138+
a.withUnsafeBytes {
139+
var x = NCContainer($0)
140+
mutate(&x)
141+
let view = View(x)
142+
p = view
143+
}
144+
use(p!)
145+
}
146+
147+
func test7(_ a: UnsafeRawBufferPointer) {
148+
var x = NEContainer(a)
149+
do {
150+
let view = getBorrowingView(x)
151+
use(view)
152+
}
153+
mutate(&x)
154+
}

0 commit comments

Comments
 (0)