test/SILOptimizer/access_dom.sil - third_party/swift - Git at Google

 // RUN: %target-sil-opt -access-enforcement-dom %s -enable-sil-verify-all | %FileCheck %s
 //
 // Test the AccessEnforcementDom pass in isolation. This ensures that
 // no upstream passes have removed SIL-level access markers that are
 // required to ensure the pass is not overly optimistic.

 sil_stage canonical

 import Builtin
 import Swift
 import SwiftShims

 struct X {
   @_hasStorage var i: Int64 { get set }
   init(i: Int64)
   init()
 }

 var globalX: X

 var globalOtherX: X

 sil_global hidden @globalX : $X

 sil_global hidden @globalOtherX : $X

 sil hidden @Xinit : $@convention(method) (@thin X.Type) -> X {
 bb0(%0 : $@thin X.Type):
   %1 = alloc_stack $X, var, name "self"
   %2 = integer_literal $Builtin.Int64, 7
   %3 = struct $Int64 (%2 : $Builtin.Int64)
   %4 = struct_element_addr %1 : $*X, #X.i
   store %3 to %4 : $*Int64
   %6 = struct $X (%3 : $Int64)
   dealloc_stack %1 : $*X
   return %6 : $X
 }

 // public func testDomSimpleRead() {
 // Checks 3 scopes, two of which are dominated and access the same storage
 //
 // CHECK-LABEL: sil @testDomSimpleRead : $@convention(thin) () -> () {
 // CHECK: [[GLOBAL:%.*]] = global_addr @globalX : $*X
 // CHECK-NEXT: [[BEGIN:%.*]] = begin_access [read] [dynamic] [[GLOBAL]] : $*X
 // CHECK-NEXT: load [[BEGIN]] : $*X
 // CHECK-NEXT: end_access [[BEGIN]] : $*X
 // CHECK-NEXT: [[BEGIN:%.*]] = begin_access [read] [static] [no_nested_conflict] [[GLOBAL]] : $*X
 // CHECK-NEXT: load [[BEGIN]] : $*X
 // CHECK-NEXT: end_access [[BEGIN]] : $*X
 // CHECK-NEXT: [[BEGIN:%.*]] = begin_access [read] [static] [no_nested_conflict] [[GLOBAL]] : $*X
 // CHECK-NEXT: load [[BEGIN]] : $*X
 // CHECK-NEXT: end_access [[BEGIN]] : $*X
 // CHECK-NOT: begin_access
 // CHECK-LABEL: } // end sil function 'testDomSimpleRead'
 sil @testDomSimpleRead : $@convention(thin) () -> () {
 bb0:
   %0 = global_addr @globalX: $*X
   %1 = begin_access [read] [dynamic] %0 : $*X
   %2 = load %1 : $*X
   end_access %1 : $*X
   %4 = begin_access [read] [dynamic] [no_nested_conflict] %0 : $*X
   %5 = load %4 : $*X
   end_access %4 : $*X
   %7 = begin_access [read] [dynamic] [no_nested_conflict] %0 : $*X
   %8 = load %7 : $*X
   end_access %7 : $*X
   %10 = tuple ()
   return %10 : $()
 }

 // public func testDomSimpleWrite() {
 // Checks 3 scopes, two of which are dominated and access the same storage
 //
 // CHECK-LABEL: sil @testDomSimpleWrite : $@convention(thin) () -> () {
 // CHECK: [[GLOBAL:%.*]] = global_addr @globalX : $*X
 // CHECK-NEXT: [[BEGIN:%.*]] = begin_access [modify] [dynamic] [[GLOBAL]] : $*X
 // CHECK-NEXT: load [[BEGIN]] : $*X
 // CHECK-NEXT: end_access [[BEGIN]] : $*X
 // CHECK: [[BEGIN:%.*]] = begin_access [modify] [static] [no_nested_conflict] [[GLOBAL]] : $*X
 // CHECK: store {{.*}} to [[BEGIN]] : $*X
 // CHECK-NEXT: end_access [[BEGIN]] : $*X
 // CHECK-NEXT: [[BEGIN:%.*]] = begin_access [read] [static] [no_nested_conflict] [[GLOBAL]] : $*X
 // CHECK-NEXT: load [[BEGIN]] : $*X
 // CHECK-NEXT: end_access [[BEGIN]] : $*X
 // CHECK-NOT: begin_access
 // CHECK-LABEL: } // end sil function 'testDomSimpleWrite'
 sil @testDomSimpleWrite : $@convention(thin) () -> () {
 bb0:
   %0 = global_addr @globalX: $*X
   %1 = begin_access [modify] [dynamic] %0 : $*X
   %2 = load %1 : $*X
   end_access %1 : $*X
   %4 = metatype $@thin X.Type
   // function_ref X.init()
   %5 = function_ref @Xinit : $@convention(method) (@thin X.Type) -> X
   %6 = apply %5(%4) : $@convention(method) (@thin X.Type) -> X
   %7 = begin_access [modify] [dynamic] [no_nested_conflict] %0 : $*X
   store %6 to %7 : $*X
   end_access %7 : $*X
   %10 = begin_access [read] [dynamic] [no_nested_conflict] %0 : $*X
   %11 = load %10 : $*X
   end_access %10 : $*X
   %12 = tuple ()
   return %12 : $()
 }

 // public func testDomAcrossBBs() {
 // Checks static-setting of scopes across basic blocks
 //
 // CHECK-LABEL: sil @testDomAcrossBBs : $@convention(thin) () -> () {
 // CHECK: [[GLOBAL:%.*]] = global_addr @globalX : $*X
 // CHECK-NEXT: [[BEGIN:%.*]] = begin_access [modify] [dynamic] [[GLOBAL]] : $*X
 // CHECK-NEXT: load [[BEGIN]] : $*X
 // CHECK-NEXT: end_access [[BEGIN]] : $*X
 // CHECK-NEXT: br bb1
 // CHECK: br bb2
 // CHECK: bb2:
 // CHECK-NEXT: [[BEGIN:%.*]] = begin_access [modify] [static] [no_nested_conflict] [[GLOBAL]] : $*X
 // CHECK: load [[BEGIN]] : $*X
 // CHECK-NEXT: end_access [[BEGIN]] : $*X
 // CHECK-NOT: begin_access
 // CHECK-LABEL: } // end sil function 'testDomAcrossBBs'
 sil @testDomAcrossBBs : $@convention(thin) () -> () {
 bb0:
   %0 = global_addr @globalX: $*X
   %1 = begin_access [modify] [dynamic] %0 : $*X
   %2 = load %1 : $*X
   end_access %1 : $*X
   br bb1

 bb1:
   br bb2

 bb2:
   %4 = begin_access [modify] [dynamic] [no_nested_conflict] %0 : $*X
   %5 = load %4 : $*X
   end_access %4 : $*X
   %7 = tuple ()
   return %7 : $()
 }

 // public func testDomAcrossInnerLoop() {
 // Checksstatic-setting of scopes across an inner loop
 //
 // CHECK-LABEL: sil @testDomAcrossInnerLoop : $@convention(thin) () -> () {
 // CHECK: [[GLOBAL:%.*]] = global_addr @globalX : $*X
 // CHECK-NEXT: [[BEGIN:%.*]] = begin_access [modify] [dynamic] [[GLOBAL]] : $*X
 // CHECK-NEXT: load [[BEGIN]] : $*X
 // CHECK-NEXT: end_access [[BEGIN]] : $*X
 // CHECK-NEXT: br bb1
 // CHECK: cond_br {{.*}}, bb1, bb2
 // CHECK: bb2:
 // CHECK-NEXT: [[BEGIN:%.*]] = begin_access [modify] [static] [no_nested_conflict] [[GLOBAL]] : $*X
 // CHECK: load [[BEGIN]] : $*X
 // CHECK-NEXT: end_access [[BEGIN]] : $*X
 // CHECK-NOT: begin_access
 // CHECK-LABEL: } // end sil function 'testDomAcrossInnerLoop'
 sil @testDomAcrossInnerLoop : $@convention(thin) () -> () {
 bb0:
   %0 = global_addr @globalX: $*X
   %1 = begin_access [modify] [dynamic] %0 : $*X
   %2 = load %1 : $*X
   end_access %1 : $*X
   br bb1

 bb1:
   %cond = integer_literal $Builtin.Int1, 1
   cond_br %cond, bb1, bb2

 bb2:
   %4 = begin_access [modify] [dynamic] [no_nested_conflict] %0 : $*X
   %5 = load %4 : $*X
   end_access %4 : $*X
   %7 = tuple ()
   return %7 : $()
 }

 // public func testIrreducibleGraph() {
 // Checks domination in an irreducible control flow
 //
 // CHECK-LABEL: sil @testIrreducibleGraph : $@convention(thin) () -> () {
 // CHECK: [[GLOBAL:%.*]] = global_addr @globalX : $*X
 // CHECK-NEXT: [[BEGIN:%.*]] = begin_access [modify] [dynamic] [[GLOBAL]] : $*X
 // CHECK-NEXT: load [[BEGIN]] : $*X
 // CHECK-NEXT: end_access [[BEGIN]] : $*X
 // CHECK-NEXT: br bb1
 // CHECK: [[BEGIN2:%.*]] = begin_access [modify] [static] [no_nested_conflict] [[GLOBAL]] : $*X
 // CHECK-NEXT: load [[BEGIN2]] : $*X
 // CHECK-NEXT: end_access [[BEGIN2]] : $*X
 // CHECK: cond_br {{.*}}, bb2, bb3
 // CHECK: [[BEGIN3:%.*]] = begin_access [read] [static] [no_nested_conflict] [[GLOBAL]] : $*X
 // CHECK-NEXT: load [[BEGIN3]] : $*X
 // CHECK-NEXT: end_access [[BEGIN3]] : $*X
 // CHECK: cond_br {{.*}}, bb3, bb4
 // CHECK: [[BEGIN4:%.*]] = begin_access [read] [static] [no_nested_conflict] [[GLOBAL]] : $*X
 // CHECK-NEXT: load [[BEGIN4]] : $*X
 // CHECK-NEXT: end_access [[BEGIN4]] : $*X
 // CHECK: cond_br {{.*}}, bb2, bb1
 // CHECK: [[BEGIN5:%.*]] = begin_access [read] [static] [no_nested_conflict] [[GLOBAL]] : $*X
 // CHECK-NEXT: load [[BEGIN5]] : $*X
 // CHECK-NEXT: end_access [[BEGIN5]] : $*X
 // CHECK-NOT: begin_access
 // CHECK-LABEL: } // end sil function 'testIrreducibleGraph'
 sil @testIrreducibleGraph : $@convention(thin) () -> () {
 bb0:
   %0 = global_addr @globalX: $*X
   %1 = begin_access [read] [dynamic] %0 : $*X
   %2 = load %1 : $*X
   end_access %1 : $*X
   br bb1

 bb1:
   %4 = begin_access [modify] [dynamic] [no_nested_conflict] %0 : $*X
   %5 = load %4 : $*X
   end_access %4 : $*X
   %cond1 = integer_literal $Builtin.Int1, 1
   cond_br %cond1, bb2, bb3

 bb2:
   %6 = begin_access [read] [dynamic] [no_nested_conflict] %0 : $*X
   %7 = load %6 : $*X
   end_access %6 : $*X
   %cond2 = integer_literal $Builtin.Int1, 1
   cond_br %cond2, bb3, bb4

 bb3:
   %8 = begin_access [read] [dynamic] [no_nested_conflict] %0 : $*X
   %9 = load %8 : $*X
   end_access %8 : $*X
   %cond3 = integer_literal $Builtin.Int1, 1
   cond_br %cond3, bb2, bb1

 bb4:
   %10 = begin_access [read] [dynamic] [no_nested_conflict] %0 : $*X
   %11 = load %10 : $*X
   end_access %10 : $*X
   %12 = tuple ()
   return %12 : $()
 }

 // public func testIrreducibleGraph2() {
 // Checks detection of irreducible control flow / bail for *some* of them
 //
 // CHECK-LABEL: sil @testIrreducibleGraph2 : $@convention(thin) () -> () {
 // CHECK: [[GLOBAL:%.*]] = global_addr @globalX : $*X
 // CHECK-NEXT: br bb1
 // CHECK: cond_br {{.*}}, bb2, bb3
 // CHECK: bb2:
 // CHECK: [[BEGIN2:%.*]] = begin_access [read] [dynamic] [no_nested_conflict] [[GLOBAL]] : $*X
 // CHECK-NEXT: load [[BEGIN2]] : $*X
 // CHECK-NEXT: end_access [[BEGIN2]] : $*X
 // CHECK-NEXT: br bb3
 // CHECK: bb3:
 // CHECK: [[BEGIN3:%.*]] = begin_access [read] [dynamic] [no_nested_conflict] [[GLOBAL]] : $*X
 // CHECK-NEXT: load [[BEGIN3]] : $*X
 // CHECK-NEXT: end_access [[BEGIN3]] : $*X
 // CHECK: br bb4
 // CHECK: [[BEGIN4:%.*]] = begin_access [read] [static] [no_nested_conflict] [[GLOBAL]] : $*X
 // CHECK-NEXT: load [[BEGIN4]] : $*X
 // CHECK-NEXT: end_access [[BEGIN4]] : $*X
 // CHECK: cond_br {{.*}}, bb2, bb5
 // CHECK: [[BEGIN5:%.*]] = begin_access [read] [static] [no_nested_conflict] [[GLOBAL]] : $*X
 // CHECK-NEXT: load [[BEGIN5]] : $*X
 // CHECK-NEXT: end_access [[BEGIN5]] : $*X
 // CHECK-NOT: begin_access
 // CHECK-LABEL: } // end sil function 'testIrreducibleGraph2'
 sil @testIrreducibleGraph2 : $@convention(thin) () -> () {
 bb0:
   %0 = global_addr @globalX: $*X
   br bb1

 bb1:
   %cond1 = integer_literal $Builtin.Int1, 1
   cond_br %cond1, bb2, bb3

 bb2:
   %6 = begin_access [read] [dynamic] [no_nested_conflict] %0 : $*X
   %7 = load %6 : $*X
   end_access %6 : $*X
   br bb3

 bb3:
   %8 = begin_access [read] [dynamic] [no_nested_conflict] %0 : $*X
   %9 = load %8 : $*X
   end_access %8 : $*X
   br bb4

 bb4:
   %10 = begin_access [read] [dynamic] [no_nested_conflict] %0 : $*X
   %11 = load %10 : $*X
   end_access %10 : $*X
   %cond2 = integer_literal $Builtin.Int1, 1
   cond_br %cond2, bb2, bb5

 bb5:
   %13 = begin_access [read] [dynamic] [no_nested_conflict] %0 : $*X
   %14 = load %13 : $*X
   end_access %13 : $*X
   %16 = tuple ()
   return %16 : $()
 }

 // public func testDomUnpaired() {
 // Checks 3 scopes, two of which are dominated and access the same storage
 // However, The second access is unpaired - we can’t optimized
 //
 // CHECK-LABEL: sil @testDomUnpaired : $@convention(thin) () -> () {
 // CHECK: [[GLOBAL:%.*]] = global_addr @globalX : $*X
 // CHECK-NEXT: [[BEGIN:%.*]] = begin_access [read] [dynamic] [[GLOBAL]] : $*X
 // CHECK-NEXT: load [[BEGIN]] : $*X
 // CHECK-NEXT: end_access [[BEGIN]] : $*X
 // CHECK-NEXT: [[ALLOC:%.*]] = alloc_stack $Builtin.UnsafeValueBuffer
 // CHECK-NEXT: begin_unpaired_access [read] [dynamic] [[GLOBAL]] : $*X, [[ALLOC]] : $*Builtin.UnsafeValueBuffer
 // CHECK-NEXT: end_unpaired_access [dynamic] [[ALLOC]] : $*Builtin.UnsafeValueBuffer
 // CHECK-NEXT: [[BEGIN:%.*]] = begin_access [read] [dynamic] [no_nested_conflict] [[GLOBAL]] : $*X
 // CHECK-NEXT: load [[BEGIN]] : $*X
 // CHECK-NEXT: end_access [[BEGIN]] : $*X
 // CHECK-NOT: begin_access
 // CHECK-LABEL: } // end sil function 'testDomUnpaired'
 sil @testDomUnpaired : $@convention(thin) () -> () {
 bb0:
   %0 = global_addr @globalX: $*X
   %1 = begin_access [read] [dynamic] %0 : $*X
   %2 = load %1 : $*X
   end_access %1 : $*X
   %buffer = alloc_stack $Builtin.UnsafeValueBuffer
   begin_unpaired_access [read] [dynamic] %0 : $*X, %buffer : $*Builtin.UnsafeValueBuffer
   end_unpaired_access [dynamic] %buffer : $*Builtin.UnsafeValueBuffer
   %7 = begin_access [read] [dynamic] [no_nested_conflict] %0 : $*X
   %8 = load %7 : $*X
   end_access %7 : $*X
   dealloc_stack %buffer : $*Builtin.UnsafeValueBuffer
   %10 = tuple ()
   return %10 : $()
 }

 // public func testLoopDominatingAccessAdderSimple() {
 // Checks creation of new scope in loop preheader
 //
 // CHECK-LABEL: sil @testLoopDominatingAccessAdderSimple : $@convention(thin) () -> () {
 // CHECK: [[GLOBAL:%.*]] = global_addr @globalX : $*X
 // CHECK: bb1:
 // CHECK-NEXT: [[BEGIN:%.*]] = begin_access [read] [dynamic] [no_nested_conflict] [[GLOBAL]] : $*X
 // CHECK-NEXT: end_access [[BEGIN]] : $*X
 // CHECK: bb3:
 // CHECK: [[BEGIN2:%.*]] = begin_access [read] [static] [no_nested_conflict] [[GLOBAL]] : $*X
 // CHECK-NEXT: load [[BEGIN2]] : $*X
 // CHECK-NEXT: end_access [[BEGIN2]] : $*X
 // CHECK: cond_br {{.*}}, bb2, bb4
 // CHECK-LABEL: } // end sil function 'testLoopDominatingAccessAdderSimple'
 sil @testLoopDominatingAccessAdderSimple : $@convention(thin) () -> () {
 bb0:
   %0 = global_addr @globalX: $*X
   br bb1

 bb1:
   br bb2

 bb2:
   br bb3

 bb3:
   %4 = begin_access [read] [dynamic] [no_nested_conflict] %0 : $*X
   %5 = load %4 : $*X
   end_access %4 : $*X
   %cond = integer_literal $Builtin.Int1, 1
   cond_br %cond, bb2, bb4

 bb4:
   %10 = tuple ()
   return %10 : $()
 }

 // public func testLoopDominatingAccessAdderBailSimple() {
 // Checks bailing on the creation of new scope in loop preheader if the access has a nested conflict
 //
 // CHECK-LABEL: sil @testLoopDominatingAccessAdderBailSimple : $@convention(thin) () -> () {
 // CHECK: [[GLOBAL:%.*]] = global_addr @globalX : $*X
 // CHECK: bb1:
 // CHECK-NEXT: br bb2
 // CHECK: bb3:
 // CHECK: [[BEGIN2:%.*]] = begin_access [read] [dynamic] [[GLOBAL]] : $*X
 // CHECK-NEXT: load [[BEGIN2]] : $*X
 // CHECK-NEXT: end_access [[BEGIN2]] : $*X
 // CHECK: cond_br {{.*}}, bb2, bb4
 // CHECK-LABEL: } // end sil function 'testLoopDominatingAccessAdderBailSimple'
 sil @testLoopDominatingAccessAdderBailSimple : $@convention(thin) () -> () {
 bb0:
   %0 = global_addr @globalX: $*X
   br bb1

 bb1:
   br bb2

 bb2:
   br bb3

 bb3:
   %4 = begin_access [read] [dynamic] %0 : $*X
   %5 = load %4 : $*X
   end_access %4 : $*X
   %cond = integer_literal $Builtin.Int1, 1
   cond_br %cond, bb2, bb4

 bb4:
   %10 = tuple ()
   return %10 : $()
 }

 // public func testLoopDominatingAccessAdderMulti() {
 // Checks creation of a single new scope in loop preheader if we have multi-access in loop
 //
 // CHECK-LABEL: sil @testLoopDominatingAccessAdderMulti : $@convention(thin) () -> () {
 // CHECK: [[GLOBAL:%.*]] = global_addr @globalX : $*X
 // CHECK: bb1:
 // CHECK-NEXT: [[BEGIN:%.*]] = begin_access [read] [dynamic] [no_nested_conflict] [[GLOBAL]] : $*X
 // CHECK-NEXT: end_access [[BEGIN]] : $*X
 // CHECK: bb3:
 // CHECK: [[BEGIN2:%.*]] = begin_access [read] [static] [no_nested_conflict] [[GLOBAL]] : $*X
 // CHECK-NEXT: load [[BEGIN2]] : $*X
 // CHECK-NEXT: end_access [[BEGIN2]] : $*X
 // CHECK: [[BEGIN3:%.*]] = begin_access [read] [static] [no_nested_conflict] [[GLOBAL]] : $*X
 // CHECK-NEXT: load [[BEGIN3]] : $*X
 // CHECK-NEXT: end_access [[BEGIN3]] : $*X
 // CHECK: cond_br {{.*}}, bb2, bb4
 // CHECK-LABEL: } // end sil function 'testLoopDominatingAccessAdderMulti'
 sil @testLoopDominatingAccessAdderMulti : $@convention(thin) () -> () {
 bb0:
   %0 = global_addr @globalX: $*X
   br bb1

 bb1:
   br bb2

 bb2:
   br bb3

 bb3:
   %4 = begin_access [read] [dynamic] [no_nested_conflict] %0 : $*X
   %5 = load %4 : $*X
   end_access %4 : $*X
   %6 = begin_access [read] [dynamic] [no_nested_conflict] %0 : $*X
   %7 = load %6 : $*X
   end_access %6 : $*X
   %cond = integer_literal $Builtin.Int1, 1
   cond_br %cond, bb2, bb4

 bb4:
   %10 = tuple ()
   return %10 : $()
 }

 // public func testLoopDominatingAccessAdderMultiChangeKind() {
 // Checks creation of a single new scope in loop preheader with [modify]
 // if one of the accesses changes the kind we first encounter
 //
 // CHECK-LABEL: sil @testLoopDominatingAccessAdderMultiChangeKind : $@convention(thin) () -> () {
 // CHECK: [[GLOBAL:%.*]] = global_addr @globalX : $*X
 // CHECK: bb1:
 // CHECK-NEXT: [[BEGIN:%.*]] = begin_access [modify] [dynamic] [no_nested_conflict] [[GLOBAL]] : $*X
 // CHECK-NEXT: end_access [[BEGIN]] : $*X
 // CHECK: bb3:
 // CHECK: [[BEGIN2:%.*]] = begin_access [read] [static] [no_nested_conflict] [[GLOBAL]] : $*X
 // CHECK-NEXT: load [[BEGIN2]] : $*X
 // CHECK-NEXT: end_access [[BEGIN2]] : $*X
 // CHECK: [[BEGIN3:%.*]] = begin_access [modify] [static] [no_nested_conflict] [[GLOBAL]] : $*X
 // CHECK-NEXT: load [[BEGIN3]] : $*X
 // CHECK-NEXT: end_access [[BEGIN3]] : $*X
 // CHECK: [[BEGIN4:%.*]] = begin_access [read] [static] [no_nested_conflict] [[GLOBAL]] : $*X
 // CHECK-NEXT: load [[BEGIN4]] : $*X
 // CHECK-NEXT: end_access [[BEGIN4]] : $*X
 // CHECK: cond_br {{.*}}, bb2, bb4
 // CHECK-LABEL: } // end sil function 'testLoopDominatingAccessAdderMultiChangeKind'
 sil @testLoopDominatingAccessAdderMultiChangeKind : $@convention(thin) () -> () {
 bb0:
   %0 = global_addr @globalX: $*X
   br bb1

 bb1:
   br bb2

 bb2:
   br bb3

 bb3:
   %4 = begin_access [read] [dynamic] [no_nested_conflict] %0 : $*X
   %5 = load %4 : $*X
   end_access %4 : $*X
   %6 = begin_access [modify] [dynamic] [no_nested_conflict] %0 : $*X
   %7 = load %6 : $*X
   end_access %6 : $*X
   %8 = begin_access [read] [dynamic] [no_nested_conflict] %0 : $*X
   %9 = load %8 : $*X
   end_access %8 : $*X
   %cond = integer_literal $Builtin.Int1, 1
   cond_br %cond, bb2, bb4

 bb4:
   %10 = tuple ()
   return %10 : $()
 }

 // public func testBailOnNestedDomWrite() {
 // Checks that we bail when the dominated begin comes before the dominating begin
 //
 // CHECK-LABEL: sil @testBailOnNestedDomWrite : $@convention(thin) () -> () {
 // CHECK: bb0:
 // CHECK: [[GLOBAL:%.*]] = global_addr @globalX : $*X
 // CHECK: [[BEGIN:%.*]] = begin_access [modify] [dynamic] [[GLOBAL]] : $*X
 // CHECK: [[BEGIN2:%.*]] = begin_access [modify] [dynamic] [no_nested_conflict] [[GLOBAL]] : $*X
 // CHECK-LABEL: } // end sil function 'testBailOnNestedDomWrite'
 sil @testBailOnNestedDomWrite : $@convention(thin) () -> () {
 bb0:
   %0 = global_addr @globalX: $*X
   %4 = begin_access [modify] [dynamic] %0 : $*X
   %5 = load %4 : $*X
   %7 = begin_access [modify] [dynamic] [no_nested_conflict] %0 : $*X
   %8 = load %7 : $*X
   end_access %7 : $*X
   end_access %4 : $*X
   %10 = tuple ()
   return %10 : $()
 }

 // public func testOptOnNestedDomRead() {
 //
 // Bail on a nested access. The dominator-based algorithm does not
 // remove nested access scopes because those could generally be
 // conflicts. This one just happens to be a read-read, so it isn't a real
 // conflict.
 //
 // FIXME: simple nested dynamic reads to identical storage could very
 // easily be removed via separate logic, but it does not fit with the
 // dominator-based algorithm. For example, during the analysis phase, we
 // could simply mark the "fully nested" read scopes, then convert them to
 // [static] right after the analysis, removing them from the result
 // map. I didn't do this because I don't know if it happens in practice.
 //
 // CHECK-LABEL: sil @testOptOnNestedDomRead : $@convention(thin) () -> () {
 // CHECK: bb0:
 // CHECK: [[GLOBAL:%.*]] = global_addr @globalX : $*X
 // CHECK: [[BEGIN:%.*]] = begin_access [read] [dynamic] [[GLOBAL]] : $*X
 // CHECK: [[BEGIN2:%.*]] = begin_access [read] [dynamic] [no_nested_conflict] [[GLOBAL]] : $*X
 // CHECK-LABEL: } // end sil function 'testOptOnNestedDomRead'
 sil @testOptOnNestedDomRead : $@convention(thin) () -> () {
 bb0:
   %0 = global_addr @globalX: $*X
   %4 = begin_access [read] [dynamic] %0 : $*X
   %5 = load %4 : $*X
   %7 = begin_access [read] [dynamic] [no_nested_conflict] %0 : $*X
   %8 = load %7 : $*X
   end_access %7 : $*X
   end_access %4 : $*X
   %10 = tuple ()
   return %10 : $()
 }
	// RUN: %target-sil-opt -access-enforcement-dom %s -enable-sil-verify-all \| %FileCheck %s
	//
	// Test the AccessEnforcementDom pass in isolation. This ensures that
	// no upstream passes have removed SIL-level access markers that are
	// required to ensure the pass is not overly optimistic.

	sil_stage canonical

	import Builtin
	import Swift
	import SwiftShims

	struct X {
	@_hasStorage var i: Int64 { get set }
	init(i: Int64)
	init()
	}

	var globalX: X

	var globalOtherX: X

	sil_global hidden @globalX : $X

	sil_global hidden @globalOtherX : $X

	sil hidden @Xinit : $@convention(method) (@thin X.Type) -> X {
	bb0(%0 : $@thin X.Type):
	%1 = alloc_stack $X, var, name "self"
	%2 = integer_literal $Builtin.Int64, 7
	%3 = struct $Int64 (%2 : $Builtin.Int64)
	%4 = struct_element_addr %1 : $*X, #X.i
	store %3 to %4 : $*Int64
	%6 = struct $X (%3 : $Int64)
	dealloc_stack %1 : $*X
	return %6 : $X
	}

	// public func testDomSimpleRead() {
	// Checks 3 scopes, two of which are dominated and access the same storage
	//
	// CHECK-LABEL: sil @testDomSimpleRead : $@convention(thin) () -> () {
	// CHECK: [[GLOBAL:%.]] = global_addr @globalX : $X
	// CHECK-NEXT: [[BEGIN:%.]] = begin_access [read] [dynamic] [[GLOBAL]] : $X
	// CHECK-NEXT: load [[BEGIN]] : $*X
	// CHECK-NEXT: end_access [[BEGIN]] : $*X
	// CHECK-NEXT: [[BEGIN:%.]] = begin_access [read] [static] [no_nested_conflict] [[GLOBAL]] : $X
	// CHECK-NEXT: load [[BEGIN]] : $*X
	// CHECK-NEXT: end_access [[BEGIN]] : $*X
	// CHECK-NEXT: [[BEGIN:%.]] = begin_access [read] [static] [no_nested_conflict] [[GLOBAL]] : $X
	// CHECK-NEXT: load [[BEGIN]] : $*X
	// CHECK-NEXT: end_access [[BEGIN]] : $*X
	// CHECK-NOT: begin_access
	// CHECK-LABEL: } // end sil function 'testDomSimpleRead'
	sil @testDomSimpleRead : $@convention(thin) () -> () {
	bb0:
	%0 = global_addr @globalX: $*X
	%1 = begin_access [read] [dynamic] %0 : $*X
	%2 = load %1 : $*X
	end_access %1 : $*X
	%4 = begin_access [read] [dynamic] [no_nested_conflict] %0 : $*X
	%5 = load %4 : $*X
	end_access %4 : $*X
	%7 = begin_access [read] [dynamic] [no_nested_conflict] %0 : $*X
	%8 = load %7 : $*X
	end_access %7 : $*X
	%10 = tuple ()
	return %10 : $()
	}

	// public func testDomSimpleWrite() {
	// Checks 3 scopes, two of which are dominated and access the same storage
	//
	// CHECK-LABEL: sil @testDomSimpleWrite : $@convention(thin) () -> () {
	// CHECK: [[GLOBAL:%.]] = global_addr @globalX : $X
	// CHECK-NEXT: [[BEGIN:%.]] = begin_access [modify] [dynamic] [[GLOBAL]] : $X
	// CHECK-NEXT: load [[BEGIN]] : $*X
	// CHECK-NEXT: end_access [[BEGIN]] : $*X
	// CHECK: [[BEGIN:%.]] = begin_access [modify] [static] [no_nested_conflict] [[GLOBAL]] : $X
	// CHECK: store {{.}} to [[BEGIN]] : $X
	// CHECK-NEXT: end_access [[BEGIN]] : $*X
	// CHECK-NEXT: [[BEGIN:%.]] = begin_access [read] [static] [no_nested_conflict] [[GLOBAL]] : $X
	// CHECK-NEXT: load [[BEGIN]] : $*X
	// CHECK-NEXT: end_access [[BEGIN]] : $*X
	// CHECK-NOT: begin_access
	// CHECK-LABEL: } // end sil function 'testDomSimpleWrite'
	sil @testDomSimpleWrite : $@convention(thin) () -> () {
	bb0:
	%0 = global_addr @globalX: $*X
	%1 = begin_access [modify] [dynamic] %0 : $*X
	%2 = load %1 : $*X
	end_access %1 : $*X
	%4 = metatype $@thin X.Type
	// function_ref X.init()
	%5 = function_ref @Xinit : $@convention(method) (@thin X.Type) -> X
	%6 = apply %5(%4) : $@convention(method) (@thin X.Type) -> X
	%7 = begin_access [modify] [dynamic] [no_nested_conflict] %0 : $*X
	store %6 to %7 : $*X
	end_access %7 : $*X
	%10 = begin_access [read] [dynamic] [no_nested_conflict] %0 : $*X
	%11 = load %10 : $*X
	end_access %10 : $*X
	%12 = tuple ()
	return %12 : $()
	}

	// public func testDomAcrossBBs() {
	// Checks static-setting of scopes across basic blocks
	//
	// CHECK-LABEL: sil @testDomAcrossBBs : $@convention(thin) () -> () {
	// CHECK: [[GLOBAL:%.]] = global_addr @globalX : $X
	// CHECK-NEXT: [[BEGIN:%.]] = begin_access [modify] [dynamic] [[GLOBAL]] : $X
	// CHECK-NEXT: load [[BEGIN]] : $*X
	// CHECK-NEXT: end_access [[BEGIN]] : $*X
	// CHECK-NEXT: br bb1
	// CHECK: br bb2
	// CHECK: bb2:
	// CHECK-NEXT: [[BEGIN:%.]] = begin_access [modify] [static] [no_nested_conflict] [[GLOBAL]] : $X
	// CHECK: load [[BEGIN]] : $*X
	// CHECK-NEXT: end_access [[BEGIN]] : $*X
	// CHECK-NOT: begin_access
	// CHECK-LABEL: } // end sil function 'testDomAcrossBBs'
	sil @testDomAcrossBBs : $@convention(thin) () -> () {
	bb0:
	%0 = global_addr @globalX: $*X
	%1 = begin_access [modify] [dynamic] %0 : $*X
	%2 = load %1 : $*X
	end_access %1 : $*X
	br bb1

	bb1:
	br bb2

	bb2:
	%4 = begin_access [modify] [dynamic] [no_nested_conflict] %0 : $*X
	%5 = load %4 : $*X
	end_access %4 : $*X
	%7 = tuple ()
	return %7 : $()
	}

	// public func testDomAcrossInnerLoop() {
	// Checksstatic-setting of scopes across an inner loop
	//
	// CHECK-LABEL: sil @testDomAcrossInnerLoop : $@convention(thin) () -> () {
	// CHECK: [[GLOBAL:%.]] = global_addr @globalX : $X
	// CHECK-NEXT: [[BEGIN:%.]] = begin_access [modify] [dynamic] [[GLOBAL]] : $X
	// CHECK-NEXT: load [[BEGIN]] : $*X
	// CHECK-NEXT: end_access [[BEGIN]] : $*X
	// CHECK-NEXT: br bb1
	// CHECK: cond_br {{.*}}, bb1, bb2
	// CHECK: bb2:
	// CHECK-NEXT: [[BEGIN:%.]] = begin_access [modify] [static] [no_nested_conflict] [[GLOBAL]] : $X
	// CHECK: load [[BEGIN]] : $*X
	// CHECK-NEXT: end_access [[BEGIN]] : $*X
	// CHECK-NOT: begin_access
	// CHECK-LABEL: } // end sil function 'testDomAcrossInnerLoop'
	sil @testDomAcrossInnerLoop : $@convention(thin) () -> () {
	bb0:
	%0 = global_addr @globalX: $*X
	%1 = begin_access [modify] [dynamic] %0 : $*X
	%2 = load %1 : $*X
	end_access %1 : $*X
	br bb1

	bb1:
	%cond = integer_literal $Builtin.Int1, 1
	cond_br %cond, bb1, bb2

	bb2:
	%4 = begin_access [modify] [dynamic] [no_nested_conflict] %0 : $*X
	%5 = load %4 : $*X
	end_access %4 : $*X
	%7 = tuple ()
	return %7 : $()
	}

	// public func testIrreducibleGraph() {
	// Checks domination in an irreducible control flow
	//
	// CHECK-LABEL: sil @testIrreducibleGraph : $@convention(thin) () -> () {
	// CHECK: [[GLOBAL:%.]] = global_addr @globalX : $X
	// CHECK-NEXT: [[BEGIN:%.]] = begin_access [modify] [dynamic] [[GLOBAL]] : $X
	// CHECK-NEXT: load [[BEGIN]] : $*X
	// CHECK-NEXT: end_access [[BEGIN]] : $*X
	// CHECK-NEXT: br bb1
	// CHECK: [[BEGIN2:%.]] = begin_access [modify] [static] [no_nested_conflict] [[GLOBAL]] : $X
	// CHECK-NEXT: load [[BEGIN2]] : $*X
	// CHECK-NEXT: end_access [[BEGIN2]] : $*X
	// CHECK: cond_br {{.*}}, bb2, bb3
	// CHECK: [[BEGIN3:%.]] = begin_access [read] [static] [no_nested_conflict] [[GLOBAL]] : $X
	// CHECK-NEXT: load [[BEGIN3]] : $*X
	// CHECK-NEXT: end_access [[BEGIN3]] : $*X
	// CHECK: cond_br {{.*}}, bb3, bb4
	// CHECK: [[BEGIN4:%.]] = begin_access [read] [static] [no_nested_conflict] [[GLOBAL]] : $X
	// CHECK-NEXT: load [[BEGIN4]] : $*X
	// CHECK-NEXT: end_access [[BEGIN4]] : $*X
	// CHECK: cond_br {{.*}}, bb2, bb1
	// CHECK: [[BEGIN5:%.]] = begin_access [read] [static] [no_nested_conflict] [[GLOBAL]] : $X
	// CHECK-NEXT: load [[BEGIN5]] : $*X
	// CHECK-NEXT: end_access [[BEGIN5]] : $*X
	// CHECK-NOT: begin_access
	// CHECK-LABEL: } // end sil function 'testIrreducibleGraph'
	sil @testIrreducibleGraph : $@convention(thin) () -> () {
	bb0:
	%0 = global_addr @globalX: $*X
	%1 = begin_access [read] [dynamic] %0 : $*X
	%2 = load %1 : $*X
	end_access %1 : $*X
	br bb1

	bb1:
	%4 = begin_access [modify] [dynamic] [no_nested_conflict] %0 : $*X
	%5 = load %4 : $*X
	end_access %4 : $*X
	%cond1 = integer_literal $Builtin.Int1, 1
	cond_br %cond1, bb2, bb3

	bb2:
	%6 = begin_access [read] [dynamic] [no_nested_conflict] %0 : $*X
	%7 = load %6 : $*X
	end_access %6 : $*X
	%cond2 = integer_literal $Builtin.Int1, 1
	cond_br %cond2, bb3, bb4

	bb3:
	%8 = begin_access [read] [dynamic] [no_nested_conflict] %0 : $*X
	%9 = load %8 : $*X
	end_access %8 : $*X
	%cond3 = integer_literal $Builtin.Int1, 1
	cond_br %cond3, bb2, bb1

	bb4:
	%10 = begin_access [read] [dynamic] [no_nested_conflict] %0 : $*X
	%11 = load %10 : $*X
	end_access %10 : $*X
	%12 = tuple ()
	return %12 : $()
	}

	// public func testIrreducibleGraph2() {
	// Checks detection of irreducible control flow / bail for some of them
	//
	// CHECK-LABEL: sil @testIrreducibleGraph2 : $@convention(thin) () -> () {
	// CHECK: [[GLOBAL:%.]] = global_addr @globalX : $X
	// CHECK-NEXT: br bb1
	// CHECK: cond_br {{.*}}, bb2, bb3
	// CHECK: bb2:
	// CHECK: [[BEGIN2:%.]] = begin_access [read] [dynamic] [no_nested_conflict] [[GLOBAL]] : $X
	// CHECK-NEXT: load [[BEGIN2]] : $*X
	// CHECK-NEXT: end_access [[BEGIN2]] : $*X
	// CHECK-NEXT: br bb3
	// CHECK: bb3:
	// CHECK: [[BEGIN3:%.]] = begin_access [read] [dynamic] [no_nested_conflict] [[GLOBAL]] : $X
	// CHECK-NEXT: load [[BEGIN3]] : $*X
	// CHECK-NEXT: end_access [[BEGIN3]] : $*X
	// CHECK: br bb4
	// CHECK: [[BEGIN4:%.]] = begin_access [read] [static] [no_nested_conflict] [[GLOBAL]] : $X
	// CHECK-NEXT: load [[BEGIN4]] : $*X
	// CHECK-NEXT: end_access [[BEGIN4]] : $*X
	// CHECK: cond_br {{.*}}, bb2, bb5
	// CHECK: [[BEGIN5:%.]] = begin_access [read] [static] [no_nested_conflict] [[GLOBAL]] : $X
	// CHECK-NEXT: load [[BEGIN5]] : $*X
	// CHECK-NEXT: end_access [[BEGIN5]] : $*X
	// CHECK-NOT: begin_access
	// CHECK-LABEL: } // end sil function 'testIrreducibleGraph2'
	sil @testIrreducibleGraph2 : $@convention(thin) () -> () {
	bb0:
	%0 = global_addr @globalX: $*X
	br bb1

	bb1:
	%cond1 = integer_literal $Builtin.Int1, 1
	cond_br %cond1, bb2, bb3

	bb2:
	%6 = begin_access [read] [dynamic] [no_nested_conflict] %0 : $*X
	%7 = load %6 : $*X
	end_access %6 : $*X
	br bb3

	bb3:
	%8 = begin_access [read] [dynamic] [no_nested_conflict] %0 : $*X
	%9 = load %8 : $*X
	end_access %8 : $*X
	br bb4

	bb4:
	%10 = begin_access [read] [dynamic] [no_nested_conflict] %0 : $*X
	%11 = load %10 : $*X
	end_access %10 : $*X
	%cond2 = integer_literal $Builtin.Int1, 1
	cond_br %cond2, bb2, bb5

	bb5:
	%13 = begin_access [read] [dynamic] [no_nested_conflict] %0 : $*X
	%14 = load %13 : $*X
	end_access %13 : $*X
	%16 = tuple ()
	return %16 : $()
	}

	// public func testDomUnpaired() {
	// Checks 3 scopes, two of which are dominated and access the same storage
	// However, The second access is unpaired - we can’t optimized
	//
	// CHECK-LABEL: sil @testDomUnpaired : $@convention(thin) () -> () {
	// CHECK: [[GLOBAL:%.]] = global_addr @globalX : $X
	// CHECK-NEXT: [[BEGIN:%.]] = begin_access [read] [dynamic] [[GLOBAL]] : $X
	// CHECK-NEXT: load [[BEGIN]] : $*X
	// CHECK-NEXT: end_access [[BEGIN]] : $*X
	// CHECK-NEXT: [[ALLOC:%.*]] = alloc_stack $Builtin.UnsafeValueBuffer
	// CHECK-NEXT: begin_unpaired_access [read] [dynamic] [[GLOBAL]] : $X, [[ALLOC]] : $Builtin.UnsafeValueBuffer
	// CHECK-NEXT: end_unpaired_access [dynamic] [[ALLOC]] : $*Builtin.UnsafeValueBuffer
	// CHECK-NEXT: [[BEGIN:%.]] = begin_access [read] [dynamic] [no_nested_conflict] [[GLOBAL]] : $X
	// CHECK-NEXT: load [[BEGIN]] : $*X
	// CHECK-NEXT: end_access [[BEGIN]] : $*X
	// CHECK-NOT: begin_access
	// CHECK-LABEL: } // end sil function 'testDomUnpaired'
	sil @testDomUnpaired : $@convention(thin) () -> () {
	bb0:
	%0 = global_addr @globalX: $*X
	%1 = begin_access [read] [dynamic] %0 : $*X
	%2 = load %1 : $*X
	end_access %1 : $*X
	%buffer = alloc_stack $Builtin.UnsafeValueBuffer
	begin_unpaired_access [read] [dynamic] %0 : $X, %buffer : $Builtin.UnsafeValueBuffer
	end_unpaired_access [dynamic] %buffer : $*Builtin.UnsafeValueBuffer
	%7 = begin_access [read] [dynamic] [no_nested_conflict] %0 : $*X
	%8 = load %7 : $*X
	end_access %7 : $*X
	dealloc_stack %buffer : $*Builtin.UnsafeValueBuffer
	%10 = tuple ()
	return %10 : $()
	}

	// public func testLoopDominatingAccessAdderSimple() {
	// Checks creation of new scope in loop preheader
	//
	// CHECK-LABEL: sil @testLoopDominatingAccessAdderSimple : $@convention(thin) () -> () {
	// CHECK: [[GLOBAL:%.]] = global_addr @globalX : $X
	// CHECK: bb1:
	// CHECK-NEXT: [[BEGIN:%.]] = begin_access [read] [dynamic] [no_nested_conflict] [[GLOBAL]] : $X
	// CHECK-NEXT: end_access [[BEGIN]] : $*X
	// CHECK: bb3:
	// CHECK: [[BEGIN2:%.]] = begin_access [read] [static] [no_nested_conflict] [[GLOBAL]] : $X
	// CHECK-NEXT: load [[BEGIN2]] : $*X
	// CHECK-NEXT: end_access [[BEGIN2]] : $*X
	// CHECK: cond_br {{.*}}, bb2, bb4
	// CHECK-LABEL: } // end sil function 'testLoopDominatingAccessAdderSimple'
	sil @testLoopDominatingAccessAdderSimple : $@convention(thin) () -> () {
	bb0:
	%0 = global_addr @globalX: $*X
	br bb1

	bb1:
	br bb2

	bb2:
	br bb3

	bb3:
	%4 = begin_access [read] [dynamic] [no_nested_conflict] %0 : $*X
	%5 = load %4 : $*X
	end_access %4 : $*X
	%cond = integer_literal $Builtin.Int1, 1
	cond_br %cond, bb2, bb4

	bb4:
	%10 = tuple ()
	return %10 : $()
	}

	// public func testLoopDominatingAccessAdderBailSimple() {
	// Checks bailing on the creation of new scope in loop preheader if the access has a nested conflict
	//
	// CHECK-LABEL: sil @testLoopDominatingAccessAdderBailSimple : $@convention(thin) () -> () {
	// CHECK: [[GLOBAL:%.]] = global_addr @globalX : $X
	// CHECK: bb1:
	// CHECK-NEXT: br bb2
	// CHECK: bb3:
	// CHECK: [[BEGIN2:%.]] = begin_access [read] [dynamic] [[GLOBAL]] : $X
	// CHECK-NEXT: load [[BEGIN2]] : $*X
	// CHECK-NEXT: end_access [[BEGIN2]] : $*X
	// CHECK: cond_br {{.*}}, bb2, bb4
	// CHECK-LABEL: } // end sil function 'testLoopDominatingAccessAdderBailSimple'
	sil @testLoopDominatingAccessAdderBailSimple : $@convention(thin) () -> () {
	bb0:
	%0 = global_addr @globalX: $*X
	br bb1

	bb1:
	br bb2

	bb2:
	br bb3

	bb3:
	%4 = begin_access [read] [dynamic] %0 : $*X
	%5 = load %4 : $*X
	end_access %4 : $*X
	%cond = integer_literal $Builtin.Int1, 1
	cond_br %cond, bb2, bb4

	bb4:
	%10 = tuple ()
	return %10 : $()
	}

	// public func testLoopDominatingAccessAdderMulti() {
	// Checks creation of a single new scope in loop preheader if we have multi-access in loop
	//
	// CHECK-LABEL: sil @testLoopDominatingAccessAdderMulti : $@convention(thin) () -> () {
	// CHECK: [[GLOBAL:%.]] = global_addr @globalX : $X
	// CHECK: bb1:
	// CHECK-NEXT: [[BEGIN:%.]] = begin_access [read] [dynamic] [no_nested_conflict] [[GLOBAL]] : $X
	// CHECK-NEXT: end_access [[BEGIN]] : $*X
	// CHECK: bb3:
	// CHECK: [[BEGIN2:%.]] = begin_access [read] [static] [no_nested_conflict] [[GLOBAL]] : $X
	// CHECK-NEXT: load [[BEGIN2]] : $*X
	// CHECK-NEXT: end_access [[BEGIN2]] : $*X
	// CHECK: [[BEGIN3:%.]] = begin_access [read] [static] [no_nested_conflict] [[GLOBAL]] : $X
	// CHECK-NEXT: load [[BEGIN3]] : $*X
	// CHECK-NEXT: end_access [[BEGIN3]] : $*X
	// CHECK: cond_br {{.*}}, bb2, bb4
	// CHECK-LABEL: } // end sil function 'testLoopDominatingAccessAdderMulti'
	sil @testLoopDominatingAccessAdderMulti : $@convention(thin) () -> () {
	bb0:
	%0 = global_addr @globalX: $*X
	br bb1

	bb1:
	br bb2

	bb2:
	br bb3

	bb3:
	%4 = begin_access [read] [dynamic] [no_nested_conflict] %0 : $*X
	%5 = load %4 : $*X
	end_access %4 : $*X
	%6 = begin_access [read] [dynamic] [no_nested_conflict] %0 : $*X
	%7 = load %6 : $*X
	end_access %6 : $*X
	%cond = integer_literal $Builtin.Int1, 1
	cond_br %cond, bb2, bb4

	bb4:
	%10 = tuple ()
	return %10 : $()
	}

	// public func testLoopDominatingAccessAdderMultiChangeKind() {
	// Checks creation of a single new scope in loop preheader with [modify]
	// if one of the accesses changes the kind we first encounter
	//
	// CHECK-LABEL: sil @testLoopDominatingAccessAdderMultiChangeKind : $@convention(thin) () -> () {
	// CHECK: [[GLOBAL:%.]] = global_addr @globalX : $X
	// CHECK: bb1:
	// CHECK-NEXT: [[BEGIN:%.]] = begin_access [modify] [dynamic] [no_nested_conflict] [[GLOBAL]] : $X
	// CHECK-NEXT: end_access [[BEGIN]] : $*X
	// CHECK: bb3:
	// CHECK: [[BEGIN2:%.]] = begin_access [read] [static] [no_nested_conflict] [[GLOBAL]] : $X
	// CHECK-NEXT: load [[BEGIN2]] : $*X
	// CHECK-NEXT: end_access [[BEGIN2]] : $*X
	// CHECK: [[BEGIN3:%.]] = begin_access [modify] [static] [no_nested_conflict] [[GLOBAL]] : $X
	// CHECK-NEXT: load [[BEGIN3]] : $*X
	// CHECK-NEXT: end_access [[BEGIN3]] : $*X
	// CHECK: [[BEGIN4:%.]] = begin_access [read] [static] [no_nested_conflict] [[GLOBAL]] : $X
	// CHECK-NEXT: load [[BEGIN4]] : $*X
	// CHECK-NEXT: end_access [[BEGIN4]] : $*X
	// CHECK: cond_br {{.*}}, bb2, bb4
	// CHECK-LABEL: } // end sil function 'testLoopDominatingAccessAdderMultiChangeKind'
	sil @testLoopDominatingAccessAdderMultiChangeKind : $@convention(thin) () -> () {
	bb0:
	%0 = global_addr @globalX: $*X
	br bb1

	bb1:
	br bb2

	bb2:
	br bb3

	bb3:
	%4 = begin_access [read] [dynamic] [no_nested_conflict] %0 : $*X
	%5 = load %4 : $*X
	end_access %4 : $*X
	%6 = begin_access [modify] [dynamic] [no_nested_conflict] %0 : $*X
	%7 = load %6 : $*X
	end_access %6 : $*X
	%8 = begin_access [read] [dynamic] [no_nested_conflict] %0 : $*X
	%9 = load %8 : $*X
	end_access %8 : $*X
	%cond = integer_literal $Builtin.Int1, 1
	cond_br %cond, bb2, bb4

	bb4:
	%10 = tuple ()
	return %10 : $()
	}

	// public func testBailOnNestedDomWrite() {
	// Checks that we bail when the dominated begin comes before the dominating begin
	//
	// CHECK-LABEL: sil @testBailOnNestedDomWrite : $@convention(thin) () -> () {
	// CHECK: bb0:
	// CHECK: [[GLOBAL:%.]] = global_addr @globalX : $X
	// CHECK: [[BEGIN:%.]] = begin_access [modify] [dynamic] [[GLOBAL]] : $X
	// CHECK: [[BEGIN2:%.]] = begin_access [modify] [dynamic] [no_nested_conflict] [[GLOBAL]] : $X
	// CHECK-LABEL: } // end sil function 'testBailOnNestedDomWrite'
	sil @testBailOnNestedDomWrite : $@convention(thin) () -> () {
	bb0:
	%0 = global_addr @globalX: $*X
	%4 = begin_access [modify] [dynamic] %0 : $*X
	%5 = load %4 : $*X
	%7 = begin_access [modify] [dynamic] [no_nested_conflict] %0 : $*X
	%8 = load %7 : $*X
	end_access %7 : $*X
	end_access %4 : $*X
	%10 = tuple ()
	return %10 : $()
	}

	// public func testOptOnNestedDomRead() {
	//
	// Bail on a nested access. The dominator-based algorithm does not
	// remove nested access scopes because those could generally be
	// conflicts. This one just happens to be a read-read, so it isn't a real
	// conflict.
	//
	// FIXME: simple nested dynamic reads to identical storage could very
	// easily be removed via separate logic, but it does not fit with the
	// dominator-based algorithm. For example, during the analysis phase, we
	// could simply mark the "fully nested" read scopes, then convert them to
	// [static] right after the analysis, removing them from the result
	// map. I didn't do this because I don't know if it happens in practice.
	//
	// CHECK-LABEL: sil @testOptOnNestedDomRead : $@convention(thin) () -> () {
	// CHECK: bb0:
	// CHECK: [[GLOBAL:%.]] = global_addr @globalX : $X
	// CHECK: [[BEGIN:%.]] = begin_access [read] [dynamic] [[GLOBAL]] : $X
	// CHECK: [[BEGIN2:%.]] = begin_access [read] [dynamic] [no_nested_conflict] [[GLOBAL]] : $X
	// CHECK-LABEL: } // end sil function 'testOptOnNestedDomRead'
	sil @testOptOnNestedDomRead : $@convention(thin) () -> () {
	bb0:
	%0 = global_addr @globalX: $*X
	%4 = begin_access [read] [dynamic] %0 : $*X
	%5 = load %4 : $*X
	%7 = begin_access [read] [dynamic] [no_nested_conflict] %0 : $*X
	%8 = load %7 : $*X
	end_access %7 : $*X
	end_access %4 : $*X
	%10 = tuple ()
	return %10 : $()
	}