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
|
//===--- PassRegistration.swift - Register optimization passes -------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2021 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
import OptimizerBridging
@_cdecl("initializeSwiftModules")
public func initializeSwiftModules() {
registerSILClasses()
registerSwiftAnalyses()
registerUtilities()
registerSwiftPasses()
registerOptimizerTests()
}
private func registerPass(
_ pass: ModulePass,
_ runFn: @escaping (@convention(c) (BridgedPassContext) -> ())) {
pass.name._withBridgedStringRef { nameStr in
SILPassManager_registerModulePass(nameStr, runFn)
}
}
private func registerPass(
_ pass: FunctionPass,
_ runFn: @escaping (@convention(c) (BridgedFunctionPassCtxt) -> ())) {
pass.name._withBridgedStringRef { nameStr in
SILPassManager_registerFunctionPass(nameStr, runFn)
}
}
protocol SILCombineSimplifyable : Instruction {
func simplify(_ context: SimplifyContext)
}
private func run<InstType: SILCombineSimplifyable>(_ instType: InstType.Type,
_ bridgedCtxt: BridgedInstructionPassCtxt) {
let inst = bridgedCtxt.instruction.getAs(instType)
let context = SimplifyContext(_bridged: bridgedCtxt.passContext,
notifyInstructionChanged: {inst in},
preserveDebugInfo: false)
inst.simplify(context)
}
private func registerForSILCombine<InstType: SILCombineSimplifyable>(
_ instType: InstType.Type,
_ runFn: @escaping (@convention(c) (BridgedInstructionPassCtxt) -> ())) {
String(describing: instType)._withBridgedStringRef { instClassStr in
SILCombine_registerInstructionPass(instClassStr, runFn)
}
}
private func registerSwiftPasses() {
// Module passes
registerPass(mandatoryPerformanceOptimizations, { mandatoryPerformanceOptimizations.run($0) })
registerPass(readOnlyGlobalVariablesPass, { readOnlyGlobalVariablesPass.run($0) })
registerPass(stackProtection, { stackProtection.run($0) })
// Function passes
registerPass(allocVectorLowering, { allocVectorLowering.run($0) })
registerPass(asyncDemotion, { asyncDemotion.run($0) })
registerPass(booleanLiteralFolding, { booleanLiteralFolding.run($0) })
registerPass(letPropertyLowering, { letPropertyLowering.run($0) })
registerPass(mergeCondFailsPass, { mergeCondFailsPass.run($0) })
registerPass(computeEscapeEffects, { computeEscapeEffects.run($0) })
registerPass(computeSideEffects, { computeSideEffects.run($0) })
registerPass(initializeStaticGlobalsPass, { initializeStaticGlobalsPass.run($0) })
registerPass(objCBridgingOptimization, { objCBridgingOptimization.run($0) })
registerPass(objectOutliner, { objectOutliner.run($0) })
registerPass(stackPromotion, { stackPromotion.run($0) })
registerPass(functionStackProtection, { functionStackProtection.run($0) })
registerPass(assumeSingleThreadedPass, { assumeSingleThreadedPass.run($0) })
registerPass(releaseDevirtualizerPass, { releaseDevirtualizerPass.run($0) })
registerPass(simplificationPass, { simplificationPass.run($0) })
registerPass(ononeSimplificationPass, { ononeSimplificationPass.run($0) })
registerPass(lateOnoneSimplificationPass, { lateOnoneSimplificationPass.run($0) })
registerPass(cleanupDebugStepsPass, { cleanupDebugStepsPass.run($0) })
registerPass(namedReturnValueOptimization, { namedReturnValueOptimization.run($0) })
registerPass(stripObjectHeadersPass, { stripObjectHeadersPass.run($0) })
registerPass(deadStoreElimination, { deadStoreElimination.run($0) })
registerPass(redundantLoadElimination, { redundantLoadElimination.run($0) })
registerPass(earlyRedundantLoadElimination, { earlyRedundantLoadElimination.run($0) })
registerPass(deinitDevirtualizer, { deinitDevirtualizer.run($0) })
registerPass(lifetimeDependenceDiagnosticsPass, { lifetimeDependenceDiagnosticsPass.run($0) })
registerPass(lifetimeDependenceInsertionPass, { lifetimeDependenceInsertionPass.run($0) })
registerPass(lifetimeDependenceScopeFixupPass, { lifetimeDependenceScopeFixupPass.run($0) })
// Instruction passes
registerForSILCombine(BeginCOWMutationInst.self, { run(BeginCOWMutationInst.self, $0) })
registerForSILCombine(GlobalValueInst.self, { run(GlobalValueInst.self, $0) })
registerForSILCombine(StrongRetainInst.self, { run(StrongRetainInst.self, $0) })
registerForSILCombine(StrongReleaseInst.self, { run(StrongReleaseInst.self, $0) })
registerForSILCombine(RetainValueInst.self, { run(RetainValueInst.self, $0) })
registerForSILCombine(ReleaseValueInst.self, { run(ReleaseValueInst.self, $0) })
registerForSILCombine(LoadInst.self, { run(LoadInst.self, $0) })
registerForSILCombine(CopyValueInst.self, { run(CopyValueInst.self, $0) })
registerForSILCombine(DestroyValueInst.self, { run(DestroyValueInst.self, $0) })
registerForSILCombine(DestructureStructInst.self, { run(DestructureStructInst.self, $0) })
registerForSILCombine(DestructureTupleInst.self, { run(DestructureTupleInst.self, $0) })
// Test passes
registerPass(functionUsesDumper, { functionUsesDumper.run($0) })
registerPass(silPrinterPass, { silPrinterPass.run($0) })
registerPass(escapeInfoDumper, { escapeInfoDumper.run($0) })
registerPass(addressEscapeInfoDumper, { addressEscapeInfoDumper.run($0) })
registerPass(accessDumper, { accessDumper.run($0) })
registerPass(deadEndBlockDumper, { deadEndBlockDumper.run($0) })
registerPass(memBehaviorDumper, { memBehaviorDumper.run($0) })
registerPass(rangeDumper, { rangeDumper.run($0) })
registerPass(runUnitTests, { runUnitTests.run($0) })
registerPass(testInstructionIteration, { testInstructionIteration.run($0) })
}
private func registerSwiftAnalyses() {
AliasAnalysis.register()
CalleeAnalysis.register()
}
private func registerUtilities() {
registerVerifier()
}
|
