Skip to content

Commit 4824d6d

Browse files
eecksteineeckstein
committed
Swift SIL: improve BasicBlockRange and InstructionRange and add tests
* add `BasicBlockRange.inclusiveRange` * add `insert(contentsOf:)` * add the RangeDumper pass to dump ranges for testing * and add a test file
1 parent 325a0b1 commit 4824d6d

File tree

7 files changed

+314
-38
lines changed

7 files changed

+314
-38
lines changed

‎SwiftCompilerSources/Sources/Optimizer/DataStructures/BasicBlockRange.swift‎

Lines changed: 46 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -51,47 +51,62 @@ struct BasicBlockRange : CustomStringConvertible, CustomReflectable {
5151
/// The dominating begin block.
5252
let begin: BasicBlock
5353

54-
/// The exclusive range, i.e. not containing the end blocks.
55-
private(set) var range: Stack<BasicBlock>
54+
/// The inclusive range, i.e. the exclusive range plus the end blocks.
55+
private(set) var inclusiveRange: Stack<BasicBlock>
5656

57+
/// The exclusive range, i.e. not containing the end blocks.
58+
var range: LazyFilterSequence<Stack<BasicBlock>> {
59+
inclusiveRange.lazy.filter { contains($0) }
60+
}
61+
5762
/// All inserted blocks.
5863
private(set) var inserted: Stack<BasicBlock>
5964

60-
private var insertedSet: BasicBlockSet
65+
private var wasInserted: BasicBlockSet
66+
private var inExclusiveRange: BasicBlockSet
6167
private var worklist: BasicBlockWorklist
6268

6369
init(begin: BasicBlock, _ context: PassContext) {
6470
self.begin = begin
65-
self.range = Stack(context)
71+
self.inclusiveRange = Stack(context)
6672
self.inserted = Stack(context)
67-
self.insertedSet = BasicBlockSet(context)
73+
self.wasInserted = BasicBlockSet(context)
74+
self.inExclusiveRange = BasicBlockSet(context)
6875
self.worklist = BasicBlockWorklist(context)
76+
worklist.pushIfNotVisited(begin)
6977
}
7078

7179
/// Insert a potential end block.
7280
mutating func insert(_ block: BasicBlock) {
73-
if !insertedSet.contains(block) {
74-
insertedSet.insert(block)
81+
if !wasInserted.contains(block) {
82+
wasInserted.insert(block)
7583
inserted.append(block)
7684
}
77-
if block != begin {
78-
worklist.pushIfNotVisited(contentsOf: block.predecessors)
79-
80-
while let b = worklist.pop() {
81-
range.append(b)
82-
if b != begin {
83-
worklist.pushIfNotVisited(contentsOf: b.predecessors)
85+
worklist.pushIfNotVisited(block)
86+
while let b = worklist.pop() {
87+
inclusiveRange.append(b)
88+
if b != begin {
89+
for pred in b.predecessors {
90+
worklist.pushIfNotVisited(pred)
91+
inExclusiveRange.insert(pred)
8492
}
8593
}
8694
}
8795
}
8896

97+
/// Insert a sequence of potential end blocks.
98+
mutating func insert<S: Sequence>(contentsOf other: S) where S.Element == BasicBlock {
99+
for block in other {
100+
insert(block)
101+
}
102+
}
103+
89104
/// Returns true if the exclusive range contains `block`.
90-
func contains(_ block: BasicBlock) -> Bool { worklist.hasBeenPushed(block) }
105+
func contains(_ block: BasicBlock) -> Bool { inExclusiveRange.contains(block) }
91106

92107
/// Returns true if the inclusive range contains `block`.
93108
func inclusiveRangeContains (_ block: BasicBlock) -> Bool {
94-
contains(block) || insertedSet.contains(block)
109+
worklist.hasBeenPushed(block)
95110
}
96111

97112
/// Returns true if the range is valid and that's iff the begin block dominates all blocks of the range.
@@ -104,14 +119,14 @@ struct BasicBlockRange : CustomStringConvertible, CustomReflectable {
104119

105120
/// Returns the end blocks.
106121
var ends: LazyFilterSequence<Stack<BasicBlock>> {
107-
inserted.lazy.filter { !worklist.hasBeenPushed($0) }
122+
inserted.lazy.filter { !contains($0) }
108123
}
109124

110125
/// Returns the exit blocks.
111126
var exits: LazySequence<FlattenSequence<
112-
LazyMapSequence<Stack<BasicBlock>,
127+
LazyMapSequence<LazyFilterSequence<Stack<BasicBlock>>,
113128
LazyFilterSequence<SuccessorArray>>>> {
114-
range.lazy.flatMap {
129+
range.flatMap {
115130
$0.successors.lazy.filter {
116131
!inclusiveRangeContains($0) || $0 == begin
117132
}
@@ -124,22 +139,25 @@ struct BasicBlockRange : CustomStringConvertible, CustomReflectable {
124139
}
125140

126141
var description: String {
127-
"""
128-
begin: \(begin.name)
129-
range: \(range)
130-
ends: \(ends)
131-
exits: \(exits)
132-
interiors: \(interiors)
133-
"""
142+
return (isValid ? "" : "<invalid>\n") +
143+
"""
144+
begin: \(begin.name)
145+
range: \(range)
146+
inclrange: \(inclusiveRange)
147+
ends: \(ends)
148+
exits: \(exits)
149+
interiors: \(interiors)
150+
"""
134151
}
135152

136153
var customMirror: Mirror { Mirror(self, children: []) }
137154

138155
/// TODO: once we have move-only types, make this a real deinit.
139156
mutating func deinitialize() {
140157
worklist.deinitialize()
158+
inExclusiveRange.deinitialize()
159+
wasInserted.deinitialize()
141160
inserted.deinitialize()
142-
insertedSet.deinitialize()
143-
range.deinitialize()
161+
inclusiveRange.deinitialize()
144162
}
145163
}

‎SwiftCompilerSources/Sources/Optimizer/DataStructures/InstructionRange.swift‎

Lines changed: 16 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -12,7 +12,7 @@
1212

1313
import SIL
1414

15-
/// A range of basic blocks.
15+
/// A range of instructions.
1616
///
1717
/// The `InstructionRange` defines a range from a dominating "begin" instruction to one or more "end" instructions.
1818
/// The range is "exclusive", which means that the "end" instructions are not part of the range.
@@ -60,6 +60,13 @@ struct InstructionRange : CustomStringConvertible, CustomReflectable {
6060
blockRange.insert(inst.block)
6161
}
6262

63+
/// Insert a sequence of potential end instructions.
64+
mutating func insert<S: Sequence>(contentsOf other: S) where S.Element == Instruction {
65+
for inst in other {
66+
insert(inst)
67+
}
68+
}
69+
6370
/// Returns true if the exclusive range contains `inst`.
6471
func contains(_ inst: Instruction) -> Bool {
6572
let block = inst.block
@@ -99,7 +106,7 @@ struct InstructionRange : CustomStringConvertible, CustomReflectable {
99106

100107
/// Returns the exit instructions.
101108
var exits: LazyMapSequence<LazySequence<FlattenSequence<
102-
LazyMapSequence<Stack<BasicBlock>,
109+
LazyMapSequence<LazyFilterSequence<Stack<BasicBlock>>,
103110
LazyFilterSequence<SuccessorArray>>>>,
104111
Instruction> {
105112
blockRange.exits.lazy.map { $0.instructions.first! }
@@ -116,21 +123,20 @@ struct InstructionRange : CustomStringConvertible, CustomReflectable {
116123
let isInterior = include
117124
include = true
118125
return isInterior
119-
120126
}
121127
return false
122128
}
123129
}
124130
}
125131

126132
var description: String {
127-
"""
128-
begin: \(begin)
129-
range: \(blockRange.range)
130-
ends: \(ends.map { $0.description }.joined(separator: "\n "))
131-
exits: \(exits.map { $0.description }.joined(separator: "\n "))
132-
interiors:\(interiors.map { $0.description }.joined(separator: "\n "))
133-
"""
133+
return (isValid ? "" : "<invalid>\n") +
134+
"""
135+
begin: \(begin)
136+
ends: \(ends.map { $0.description }.joined(separator: "\n "))
137+
exits: \(exits.map { $0.description }.joined(separator: "\n "))
138+
interiors:\(interiors.map { $0.description }.joined(separator: "\n "))
139+
"""
134140
}
135141

136142
var customMirror: Mirror { Mirror(self, children: []) }

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

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -10,6 +10,7 @@ swift_compiler_sources(Optimizer
1010
AssumeSingleThreaded.swift
1111
SILPrinter.swift
1212
MergeCondFails.swift
13+
RangeDumper.swift
1314
ReleaseDevirtualizer.swift
1415
RunUnitTests.swift
1516
)

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

Lines changed: 98 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,98 @@
1+
//===--- RangeDumper.swift - Dumps escape information ----------------===//
2+
//
3+
// This source file is part of the Swift.org open source project
4+
//
5+
// Copyright (c) 2014 - 2022 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+
import SIL
14+
15+
let rangeDumper = FunctionPass(name: "dump-ranges", {
16+
(function: Function, context: PassContext) in
17+
18+
var begin: Instruction?
19+
var ends = Stack<Instruction>(context)
20+
defer { ends.deinitialize() }
21+
var interiors = Stack<Instruction>(context)
22+
defer { interiors.deinitialize() }
23+
var ins = Stack<Instruction>(context)
24+
defer { ins.deinitialize() }
25+
var outs = Stack<Instruction>(context)
26+
defer { outs.deinitialize() }
27+
28+
for block in function.blocks {
29+
for inst in block.instructions {
30+
if let sli = inst as? StringLiteralInst {
31+
switch sli.string {
32+
case "begin":
33+
precondition(begin == nil, "more than one begin instruction")
34+
begin = sli
35+
case "end":
36+
ends.append(sli)
37+
case "interior":
38+
interiors.append(sli)
39+
case "inside":
40+
ins.append(sli)
41+
case "outside":
42+
outs.append(sli)
43+
default:
44+
break
45+
}
46+
}
47+
}
48+
}
49+
50+
guard let begin = begin else { return }
51+
52+
var instRange = InstructionRange(begin: begin, context)
53+
defer { instRange.deinitialize() }
54+
55+
instRange.insert(contentsOf: ends)
56+
instRange.insert(contentsOf: interiors)
57+
58+
print("Instruction range in \(function.name):")
59+
print(instRange)
60+
print("Block range in \(function.name):")
61+
print(instRange.blockRange)
62+
print("End function \(function.name)\n")
63+
64+
verify(instRange.blockRange, context)
65+
66+
for i in ins {
67+
precondition(instRange.contains(i))
68+
precondition(instRange.inclusiveRangeContains(i))
69+
}
70+
for e in ends {
71+
precondition(!instRange.contains(e))
72+
precondition(instRange.inclusiveRangeContains(e))
73+
}
74+
for o in outs {
75+
precondition(!instRange.contains(o))
76+
precondition(!instRange.inclusiveRangeContains(o))
77+
}
78+
})
79+
80+
private func verify(_ blockRange: BasicBlockRange, _ context: PassContext) {
81+
var inRange = BasicBlockSet(context)
82+
defer { inRange.deinitialize() }
83+
for b in blockRange.range {
84+
inRange.insert(b)
85+
}
86+
87+
var inInclusiveRange = BasicBlockSet(context)
88+
defer { inInclusiveRange.deinitialize() }
89+
for b in blockRange.inclusiveRange {
90+
inInclusiveRange.insert(b)
91+
}
92+
93+
for b in blockRange.begin.function.blocks {
94+
precondition(blockRange.contains(b) == inRange.contains(b))
95+
precondition(blockRange.inclusiveRangeContains(b) == inInclusiveRange.contains(b))
96+
}
97+
}
98+

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

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -51,6 +51,7 @@ private func registerSwiftPasses() {
5151
registerPass(simplifyStrongRetainPass, { simplifyStrongRetainPass.run($0) })
5252
registerPass(simplifyStrongReleasePass, { simplifyStrongReleasePass.run($0) })
5353
registerPass(assumeSingleThreadedPass, { assumeSingleThreadedPass.run($0) })
54+
registerPass(rangeDumper, { rangeDumper.run($0) })
5455
registerPass(runUnitTests, { runUnitTests.run($0) })
5556
registerPass(releaseDevirtualizerPass, { releaseDevirtualizerPass.run($0) })
5657
}

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

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -230,6 +230,8 @@ PASS(FunctionOrderPrinter, "function-order-printer",
230230
"Print Function Order for Testing")
231231
PASS(FunctionSignatureOpts, "function-signature-opts",
232232
"Function Signature Optimization")
233+
SWIFT_FUNCTION_PASS(RangeDumper, "dump-ranges",
234+
"Dumps block and instruction ranges")
233235
PASS(ARCSequenceOpts, "arc-sequence-opts",
234236
"ARC Sequence Optimization")
235237
PASS(ARCLoopOpts, "arc-loop-opts",

0 commit comments

Comments
 (0)