1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
|
//===--- SimplificationPasses.swift ----------------------------------------==//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2023 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
import SIL
//===--------------------------------------------------------------------===//
// Instruction protocols
//===--------------------------------------------------------------------===//
/// Instructions which can be simplified at all optimization levels
protocol Simplifyable : Instruction {
func simplify(_ context: SimplifyContext)
}
/// Instructions which can be simplified at -Onone
protocol OnoneSimplifyable : Simplifyable {
}
/// Instructions which can only be simplified at the end of the -Onone pipeline
protocol LateOnoneSimplifyable : Instruction {
func simplifyLate(_ context: SimplifyContext)
}
//===--------------------------------------------------------------------===//
// Simplification passes
//===--------------------------------------------------------------------===//
let ononeSimplificationPass = FunctionPass(name: "onone-simplification") {
(function: Function, context: FunctionPassContext) in
runSimplification(on: function, context, preserveDebugInfo: true) {
if let i = $0 as? OnoneSimplifyable {
i.simplify($1)
}
}
}
let simplificationPass = FunctionPass(name: "simplification") {
(function: Function, context: FunctionPassContext) in
runSimplification(on: function, context, preserveDebugInfo: false) {
if let i = $0 as? Simplifyable {
i.simplify($1)
}
}
}
let lateOnoneSimplificationPass = FunctionPass(name: "late-onone-simplification") {
(function: Function, context: FunctionPassContext) in
runSimplification(on: function, context, preserveDebugInfo: true) {
if let i = $0 as? LateOnoneSimplifyable {
i.simplifyLate($1)
} else if let i = $0 as? OnoneSimplifyable {
i.simplify($1)
}
}
}
//===--------------------------------------------------------------------===//
// Pass implementation
//===--------------------------------------------------------------------===//
@discardableResult
func runSimplification(on function: Function, _ context: FunctionPassContext,
preserveDebugInfo: Bool,
_ simplify: (Instruction, SimplifyContext) -> ()) -> Bool {
var worklist = InstructionWorklist(context)
defer { worklist.deinitialize() }
var changed = false
let simplifyCtxt = context.createSimplifyContext(preserveDebugInfo: preserveDebugInfo,
notifyInstructionChanged: {
worklist.pushIfNotVisited($0)
changed = true
})
// Push in reverse order so that popping from the tail of the worklist visits instruction in forward order again.
worklist.pushIfNotVisited(contentsOf: function.reversedInstructions)
// Run multiple iterations because cleanupDeadCode can add new candidates to the worklist.
repeat {
// The core worklist-loop.
while let instruction = worklist.popAndForget() {
if instruction.isDeleted {
continue
}
if !context.options.enableSimplification(for: instruction) {
continue
}
if !context.continueWithNextSubpassRun(for: instruction) {
return changed
}
simplify(instruction, simplifyCtxt)
}
cleanupDeadInstructions(in: function, preserveDebugInfo, context)
cleanupDeadBlocks(in: function, pushNewCandidatesTo: &worklist, context)
} while !worklist.isEmpty
if context.needFixStackNesting {
function.fixStackNesting(context)
}
return changed
}
private func cleanupDeadInstructions(in function: Function,
_ preserveDebugInfo: Bool,
_ context: FunctionPassContext) {
if preserveDebugInfo {
context.removeTriviallyDeadInstructionsPreservingDebugInfo(in: function)
} else {
context.removeTriviallyDeadInstructionsIgnoringDebugUses(in: function)
}
}
private func cleanupDeadBlocks(in function: Function,
pushNewCandidatesTo worklist: inout InstructionWorklist,
_ context: FunctionPassContext) {
if context.removeDeadBlocks(in: function) {
// After deleting dead blocks their (still alive) successor blocks may become eligible for block merging.
// Therefore we re-run simplification for all branch instructions.
for block in function.blocks.reversed() {
if let bi = block.terminator as? BranchInst {
worklist.pushIfNotVisited(bi)
}
}
}
}
|
