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
|
// RUN: %target-sil-opt -access-enforcement-opts -debug-only=access-enforcement-opts -verify %s -o /dev/null 2>&1 | %FileCheck %s
//
// REQUIRES: asserts
//
// This tests four kinds of AccessEnforcementOpts fast paths:
//
// 1. During identifyAccess, determine if there are either any
// identical accesses or an accesses that aren't already marked
// no_nested_storage. If there are neither, then skip the subsequent
// data flow analysis.
//
// 2. In StorageSet, indicate whether identical storage was seen
// elsewhere in the function. During dataflow, only add an access to
// the out-of-scope access set if was marked as having identical
// storage with another access.
//
// 3. If no access pairs can be merged, avoid analyzing SCC regions in
// the control flow graph.
//
// 4. During data flow, don't track in scope conflicts for
// instructions already marked [no_nested_conflict].
sil_stage canonical
import Builtin
import Swift
import SwiftShims
public class TestEarlyBail {
@_hasStorage var prop1: Int { get set }
@_hasStorage var prop2: Int { get set }
}
// All accesses are no_nested_conflict, and none are identical. Bail.
// (1) Skipping AccessConflictAndMergeAnalysis...
//
// CHECK-LABEL: Running local AccessEnforcementOpts on testEarlyBail
// CHECK-NOT: Processing
// CHECK-NOT: No conflict on one path
// CHECK-NOT: Folding
// CHECK-NOT: Merging
// CHECK: Skipping AccessConflictAndMergeAnalysis...
sil [ossa] @testEarlyBail : $@convention(method) (@owned TestEarlyBail) -> @owned TestEarlyBail {
bb0(%0 : @owned $TestEarlyBail):
%borrow = begin_borrow %0 : $TestEarlyBail
%adr1 = ref_element_addr %borrow : $TestEarlyBail, #TestEarlyBail.prop1
%a1 = begin_access [modify] [dynamic] [no_nested_conflict] %adr1 : $*Int
%v1 = load [trivial] %a1 : $*Int
end_access %a1 : $*Int
%adr2 = ref_element_addr %borrow : $TestEarlyBail, #TestEarlyBail.prop2
%a2 = begin_access [modify] [dynamic] [no_nested_conflict] %adr2 : $*Int
%v2 = load [trivial] %a2 : $*Int
end_access %a2 : $*Int
end_borrow %borrow : $TestEarlyBail
return %0 : $TestEarlyBail
}
// An access is not marked no_nested_conflict. Need to run analysis.
// NOT (1) Skipping AccessConflictAndMergeAnalysis...
// (2) Ignoring unique access...
// (3) Skipping SCC analysis...
//
// CHECK-LABEL: Running local AccessEnforcementOpts on testEarlyBailNeedsFolding
// CHECK: Processing Function: testEarlyBailNeedsFolding
// CHECK: No conflict on one path from [[ACCESS:%.*]] = begin_access [modify] [dynamic] %{{.*}} : $*Int
// CHECK-NEXT: to end_access [[ACCESS]] : $*Int
// CHECK: Ignoring unmergeable access: [[ACCESS]] = begin_access [modify] [dynamic] %{{.*}} : $*Int
// CHECK: Folding [[ACCESS]] = begin_access [modify] [dynamic] [no_nested_conflict] %{{.*}} : $*Int
// CHECK: Skipping SCC Analysis...
sil [ossa] @testEarlyBailNeedsFolding : $@convention(method) (@owned TestEarlyBail) -> @owned TestEarlyBail {
bb0(%0 : @owned $TestEarlyBail):
%borrow = begin_borrow %0 : $TestEarlyBail
%adr1 = ref_element_addr %borrow : $TestEarlyBail, #TestEarlyBail.prop1
%a1 = begin_access [modify] [dynamic] %adr1 : $*Int
%v1 = load [trivial] %a1 : $*Int
end_access %a1 : $*Int
end_borrow %borrow : $TestEarlyBail
return %0 : $TestEarlyBail
}
// Two accesses have the same storage. Need to run analysis.
// NOT (1) Skipping AccessConflictAndMergeAnalysis...
// NOT (2) Ignoring unique access...
// (4) No Conflict On Path
// (4) NOT No Conflict On Path
// NOT (3) Skipping SCC analysis...
//
// CHECK-LABEL: Running local AccessEnforcementOpts on testEarlyBailMayMerge
// CHECK: Processing Function: testEarlyBailMayMerge
// CHECK: No conflict on one path from [[ACCESS1:%.*]] = begin_access [modify] [dynamic] %{{.*}} : $*Int
// CHECK: to end_access [[ACCESS1]] : $*Int
// CHECK: Found mergeable pair: [[ACCESS1]] = begin_access [modify] [dynamic] %{{.*}} : $*Int
// CHECK-NEXT: with [[ACCESS2:%.*]] = begin_access [modify] [dynamic] [no_nested_conflict] %{{.*}} : $*Int
// CHECK-NOT: No conflict on one path from [[ACCESS2]]
// CHECK: Ignoring unmergeable access: [[ACCESS2]] = begin_access [modify] [dynamic] [no_nested_conflict] %{{.*}} : $*Int
// CHECK-NOT: No conflict on one path from [[ACCESS2]]
//
// Note: The order that accesses with no nested conflicts are "Folded" is nondeterministic.
// CHECK-DAG: Folding [[ACCESS1]] = begin_access [modify] [dynamic] [no_nested_conflict] %{{.*}} : $*Int
// CHECK-DAG: Folding [[ACCESS2]] = begin_access [modify] [dynamic] [no_nested_conflict] %{{.*}} : $*Int
// CHECK: Merging [[ACCESS2]] = begin_access [modify] [dynamic] [no_nested_conflict] %{{.*}} : $*Int
// CHECK-NEXT: into [[ACCESS1]] = begin_access [modify] [dynamic] [no_nested_conflict] %{{.*}} : $*Int
// CHECK-NOT: Skipping SCC Analysis...
sil [ossa] @testEarlyBailMayMerge : $@convention(method) (@owned TestEarlyBail) -> @owned TestEarlyBail {
bb0(%0 : @owned $TestEarlyBail):
%borrow = begin_borrow %0 : $TestEarlyBail
%adr1 = ref_element_addr %borrow : $TestEarlyBail, #TestEarlyBail.prop1
%a1 = begin_access [modify] [dynamic] %adr1 : $*Int
%v1 = load [trivial] %a1 : $*Int
end_access %a1 : $*Int
%adr2 = ref_element_addr %borrow : $TestEarlyBail, #TestEarlyBail.prop1
%a2 = begin_access [modify] [dynamic] [no_nested_conflict] %adr2 : $*Int
%v2 = load [trivial] %a2 : $*Int
end_access %a2 : $*Int
end_borrow %borrow : $TestEarlyBail
return %0 : $TestEarlyBail
}
|
