averello/swift-mirror
1
0
Fork 0
mirror of https://github.com/apple/swift.git synced 2025-12-21 12:14:44 +01:00
Code Issues Packages Projects Releases Wiki Activity
Files
cc4c4584bfa25559fd5396fe6222fba901b301cf
swift-mirror/test/SILOptimizer/access_dom_overlap.sil
Erik Eckstein 7cceaff5f3 SIL: don't print operand types in textual SIL 
Type annotations for instruction operands are omitted, e.g.

```
  %3 = struct $S(%1, %2)
```

Operand types are redundant anyway and were only used for sanity checking in the SIL parser.

But: operand types _are_ printed if the definition of the operand value was not printed yet.
This happens:

* if the block with the definition appears after the block where the operand's instruction is located

* if a block or instruction is printed in isolation, e.g. in a debugger

The old behavior can be restored with `-Xllvm -sil-print-types`.
This option is added to many existing test files which check for operand types in their check-lines.
2024-11-21 18:49:52 +01:00

524 lines
22 KiB
Plaintext
Raw Blame History

// RUN: %target-sil-opt -sil-print-types -access-enforcement-dom %s -enable-sil-verify-all | %FileCheck %s
//
// Test AccessEnforcementDom in the presence of overlapping access scopes.
sil_stage canonical
import Builtin
import Swift
import SwiftShims
@_hasInitialValue @_hasStorage var globalInt: Int64 { get set }
// globalInt
sil_global hidden @globalInt : $Int64
// -----------------------------------------------------------------------------
// (read, read), read
// Yes, can optimize if the dominating access is nested outside another dynamic.
// CHECK-LABEL: sil hidden [noinline] @testDominatingOverlapRDRD_RD : $@convention(thin) () -> () {
// CHECK: begin_access [read] [dynamic] [[GA:%.*]] : $*Int64
// CHECK: begin_access [read] [dynamic] [[GA]] : $*Int64
// CHECK: begin_access [read] [static] [no_nested_conflict] [[GA]] : $*Int64
// CHECK-LABEL: } // end sil function 'testDominatingOverlapRDRD_RD'
sil hidden [noinline] @testDominatingOverlapRDRD_RD : $@convention(thin) () -> () {
bb0:
%ga = global_addr @globalInt : $*Int64
%a1 = begin_access [read] [dynamic] %ga : $*Int64
%a2 = begin_access [read] [dynamic] %ga : $*Int64
end_access %a2 : $*Int64
end_access %a1 : $*Int64
%a3 = begin_access [read] [dynamic] [no_nested_conflict] %ga : $*Int64
end_access %a3 : $*Int64
%z = tuple ()
return %z : $()
}
// Yes, can optimize if the dominating access is nested inside.
// CHECK-LABEL: sil hidden [noinline] @testDominatingOverlapRSRD_RD : $@convention(thin) () -> () {
// CHECK: begin_access [read] [static] [[GA:%.*]] : $*Int64
// CHECK: begin_access [read] [dynamic] [[GA]] : $*Int64
// CHECK: begin_access [read] [static] [no_nested_conflict] [[GA]] : $*Int64
// CHECK-LABEL: } // end sil function 'testDominatingOverlapRSRD_RD'
sil hidden [noinline] @testDominatingOverlapRSRD_RD : $@convention(thin) () -> () {
bb0:
%ga = global_addr @globalInt : $*Int64
%a1 = begin_access [read] [static] %ga : $*Int64
%a2 = begin_access [read] [dynamic] %ga : $*Int64
end_access %a2 : $*Int64
end_access %a1 : $*Int64
%a3 = begin_access [read] [dynamic] [no_nested_conflict] %ga : $*Int64
end_access %a3 : $*Int64
%z = tuple ()
return %z : $()
}
// Yes, can optimize if the dominating access is nested outside.
// CHECK-LABEL: sil hidden [noinline] @testDominatingOverlapRDRS_RD : $@convention(thin) () -> () {
// CHECK: begin_access [read] [dynamic] [[GA:%.*]] : $*Int64
// CHECK: begin_access [read] [static] [[GA]] : $*Int64
// CHECK: begin_access [read] [static] [no_nested_conflict] [[GA]] : $*Int64
// CHECK-LABEL: } // end sil function 'testDominatingOverlapRDRS_RD'
sil hidden [noinline] @testDominatingOverlapRDRS_RD : $@convention(thin) () -> () {
bb0:
%ga = global_addr @globalInt : $*Int64
%a1 = begin_access [read] [dynamic] %ga : $*Int64
%a2 = begin_access [read] [static] %ga : $*Int64
end_access %a2 : $*Int64
end_access %a1 : $*Int64
%a3 = begin_access [read] [dynamic] [no_nested_conflict] %ga : $*Int64
end_access %a3 : $*Int64
%z = tuple ()
return %z : $()
}
// -----------------------------------------------------------------------------
// (read, read), modify
// No, cannot promote nested read to write.
// CHECK-LABEL: sil hidden [noinline] @testDominatingOverlapRDRD_MD : $@convention(thin) () -> () {
// CHECK: begin_access [read] [dynamic] [[GA:%.*]] : $*Int64
// CHECK: begin_access [read] [dynamic] [[GA]] : $*Int64
// CHECK: begin_access [modify] [dynamic] [no_nested_conflict] [[GA]] : $*Int64
// CHECK-LABEL: } // end sil function 'testDominatingOverlapRDRD_MD'
sil hidden [noinline] @testDominatingOverlapRDRD_MD : $@convention(thin) () -> () {
bb0:
%ga = global_addr @globalInt : $*Int64
%a1 = begin_access [read] [dynamic] %ga : $*Int64
%a2 = begin_access [read] [dynamic] %ga : $*Int64
end_access %a2 : $*Int64
end_access %a1 : $*Int64
%a3 = begin_access [modify] [dynamic] [no_nested_conflict] %ga : $*Int64
end_access %a3 : $*Int64
%z = tuple ()
return %z : $()
}
// No, cannot promote nested read to write.
// CHECK-LABEL: sil hidden [noinline] @testDominatingOverlapRSRD_MD : $@convention(thin) () -> () {
// CHECK: begin_access [read] [static] [[GA:%.*]] : $*Int64
// CHECK: begin_access [read] [dynamic] [[GA]] : $*Int64
// CHECK: begin_access [modify] [dynamic] [no_nested_conflict] [[GA]] : $*Int64
// CHECK-LABEL: } // end sil function 'testDominatingOverlapRSRD_MD'
sil hidden [noinline] @testDominatingOverlapRSRD_MD : $@convention(thin) () -> () {
bb0:
%ga = global_addr @globalInt : $*Int64
%a1 = begin_access [read] [static] %ga : $*Int64
%a2 = begin_access [read] [dynamic] %ga : $*Int64
end_access %a2 : $*Int64
end_access %a1 : $*Int64
%a3 = begin_access [modify] [dynamic] [no_nested_conflict] %ga : $*Int64
end_access %a3 : $*Int64
%z = tuple ()
return %z : $()
}
// No, cannot promote nested read to write.
// CHECK-LABEL: sil hidden [noinline] @testDominatingOverlapRDRS_MD : $@convention(thin) () -> () {
// CHECK: begin_access [read] [dynamic] [[GA:%.*]] : $*Int64
// CHECK: begin_access [read] [static] [[GA]] : $*Int64
// CHECK: begin_access [modify] [dynamic] [no_nested_conflict] [[GA]] : $*Int64
// CHECK-LABEL: } // end sil function 'testDominatingOverlapRDRS_MD'
sil hidden [noinline] @testDominatingOverlapRDRS_MD : $@convention(thin) () -> () {
bb0:
%ga = global_addr @globalInt : $*Int64
%a1 = begin_access [read] [dynamic] %ga : $*Int64
%a2 = begin_access [read] [static] %ga : $*Int64
end_access %a2 : $*Int64
end_access %a1 : $*Int64
%a3 = begin_access [modify] [dynamic] [no_nested_conflict] %ga : $*Int64
end_access %a3 : $*Int64
%z = tuple ()
return %z : $()
}
// -----------------------------------------------------------------------------
// (read, modify), read
// Yes, can optimize if the dominating access is nested outside.
// CHECK-LABEL: sil hidden [noinline] @testDominatingOverlapRDMD_RD : $@convention(thin) () -> () {
// CHECK: begin_access [read] [dynamic] [[GA:%.*]] : $*Int64
// CHECK: begin_access [modify] [dynamic] [[GA]] : $*Int64
// CHECK: begin_access [read] [static] [no_nested_conflict] [[GA]] : $*Int64
// CHECK-LABEL: } // end sil function 'testDominatingOverlapRDMD_RD'
sil hidden [noinline] @testDominatingOverlapRDMD_RD : $@convention(thin) () -> () {
bb0:
%ga = global_addr @globalInt : $*Int64
%a1 = begin_access [read] [dynamic] %ga : $*Int64
%a2 = begin_access [modify] [dynamic] %ga : $*Int64
end_access %a2 : $*Int64
end_access %a1 : $*Int64
%a3 = begin_access [read] [dynamic] [no_nested_conflict] %ga : $*Int64
end_access %a3 : $*Int64
%z = tuple ()
return %z : $()
}
// Yes, can optimize if the dominating access is nested inside.
// CHECK-LABEL: sil hidden [noinline] @testDominatingOverlapRSMD_RD : $@convention(thin) () -> () {
// CHECK: begin_access [read] [static] [[GA:%.*]] : $*Int64
// CHECK: begin_access [modify] [dynamic] [[GA]] : $*Int64
// CHECK: begin_access [read] [static] [no_nested_conflict] [[GA]] : $*Int64
// CHECK-LABEL: } // end sil function 'testDominatingOverlapRSMD_RD'
sil hidden [noinline] @testDominatingOverlapRSMD_RD : $@convention(thin) () -> () {
bb0:
%ga = global_addr @globalInt : $*Int64
%a1 = begin_access [read] [static] %ga : $*Int64
%a2 = begin_access [modify] [dynamic] %ga : $*Int64
end_access %a2 : $*Int64
end_access %a1 : $*Int64
%a3 = begin_access [read] [dynamic] [no_nested_conflict] %ga : $*Int64
end_access %a3 : $*Int64
%z = tuple ()
return %z : $()
}
// Yes, can optimize if the dominating access is nested outside.
// CHECK-LABEL: sil hidden [noinline] @testDominatingOverlapRDMS_RD : $@convention(thin) () -> () {
// CHECK: begin_access [read] [dynamic] [[GA:%.*]] : $*Int64
// CHECK: begin_access [modify] [static] [[GA]] : $*Int64
// CHECK: begin_access [read] [static] [no_nested_conflict] [[GA]] : $*Int64
// CHECK-LABEL: } // end sil function 'testDominatingOverlapRDMS_RD'
sil hidden [noinline] @testDominatingOverlapRDMS_RD : $@convention(thin) () -> () {
bb0:
%ga = global_addr @globalInt : $*Int64
%a1 = begin_access [read] [dynamic] %ga : $*Int64
%a2 = begin_access [modify] [static] %ga : $*Int64
end_access %a2 : $*Int64
end_access %a1 : $*Int64
%a3 = begin_access [read] [dynamic] [no_nested_conflict] %ga : $*Int64
end_access %a3 : $*Int64
%z = tuple ()
return %z : $()
}
// -----------------------------------------------------------------------------
// (read, modify), modify
// Yes, can promote if the nested access is a modify.
// CHECK-LABEL: sil hidden [noinline] @testDominatingOverlapRDMD_MD : $@convention(thin) () -> () {
// CHECK: begin_access [modify] [dynamic] [[GA:%.*]] : $*Int64
// CHECK: begin_access [modify] [dynamic] [[GA]] : $*Int64
// CHECK: begin_access [modify] [static] [no_nested_conflict] [[GA]] : $*Int64
// CHECK-LABEL: } // end sil function 'testDominatingOverlapRDMD_MD'
sil hidden [noinline] @testDominatingOverlapRDMD_MD : $@convention(thin) () -> () {
bb0:
%ga = global_addr @globalInt : $*Int64
%a1 = begin_access [read] [dynamic] %ga : $*Int64
%a2 = begin_access [modify] [dynamic] %ga : $*Int64
end_access %a2 : $*Int64
end_access %a1 : $*Int64
%a3 = begin_access [modify] [dynamic] [no_nested_conflict] %ga : $*Int64
end_access %a3 : $*Int64
%z = tuple ()
return %z : $()
}
// Yes, can optimize if the dominating access is nested inside.
// CHECK-LABEL: sil hidden [noinline] @testDominatingOverlapRSMD_MD : $@convention(thin) () -> () {
// CHECK: begin_access [read] [static] [[GA:%.*]] : $*Int64
// CHECK: begin_access [modify] [dynamic] [[GA]] : $*Int64
// CHECK: begin_access [modify] [static] [no_nested_conflict] [[GA]] : $*Int64
// CHECK-LABEL: } // end sil function 'testDominatingOverlapRSMD_MD'
sil hidden [noinline] @testDominatingOverlapRSMD_MD : $@convention(thin) () -> () {
bb0:
%ga = global_addr @globalInt : $*Int64
%a1 = begin_access [read] [static] %ga : $*Int64
%a2 = begin_access [modify] [dynamic] %ga : $*Int64
end_access %a2 : $*Int64
end_access %a1 : $*Int64
%a3 = begin_access [modify] [dynamic] [no_nested_conflict] %ga : $*Int64
end_access %a3 : $*Int64
%z = tuple ()
return %z : $()
}
// Yes, can promote if the nested access is a modify.
// CHECK-LABEL: sil hidden [noinline] @testDominatingOverlapRDMS_MD : $@convention(thin) () -> () {
// CHECK: begin_access [modify] [dynamic] [[GA:%.*]] : $*Int64
// CHECK: begin_access [modify] [static] [[GA]] : $*Int64
// CHECK: begin_access [modify] [static] [no_nested_conflict] [[GA]] : $*Int64
// CHECK-LABEL: } // end sil function 'testDominatingOverlapRDMS_MD'
sil hidden [noinline] @testDominatingOverlapRDMS_MD : $@convention(thin) () -> () {
bb0:
%ga = global_addr @globalInt : $*Int64
%a1 = begin_access [read] [dynamic] %ga : $*Int64
%a2 = begin_access [modify] [static] %ga : $*Int64
end_access %a2 : $*Int64
end_access %a1 : $*Int64
%a3 = begin_access [modify] [dynamic] [no_nested_conflict] %ga : $*Int64
end_access %a3 : $*Int64
%z = tuple ()
return %z : $()
}
// -----------------------------------------------------------------------------
// read, (read, read)
// No, cannot optimize a nested access.
// CHECK-LABEL: sil hidden [noinline] @testDominatingOverlapRD_RDRD : $@convention(thin) () -> () {
// CHECK: begin_access [read] [dynamic] [[GA:%.*]] : $*Int64
// CHECK: begin_access [read] [dynamic] [[GA]] : $*Int64
// CHECK: begin_access [read] [dynamic] [no_nested_conflict] [[GA]] : $*Int64
// CHECK-LABEL: } // end sil function 'testDominatingOverlapRD_RDRD'
sil hidden [noinline] @testDominatingOverlapRD_RDRD : $@convention(thin) () -> () {
bb0:
%ga = global_addr @globalInt : $*Int64
%a1 = begin_access [read] [dynamic] %ga : $*Int64
end_access %a1 : $*Int64
%a2 = begin_access [read] [dynamic] %ga : $*Int64
%a3 = begin_access [read] [dynamic] [no_nested_conflict] %ga : $*Int64
end_access %a3 : $*Int64
end_access %a2 : $*Int64
%z = tuple ()
return %z : $()
}
// No, cannot optimize a nested access.
// CHECK-LABEL: sil hidden [noinline] @testDominatingOverlapRD_RSRD : $@convention(thin) () -> () {
// CHECK: begin_access [read] [dynamic] [[GA:%.*]] : $*Int64
// CHECK: begin_access [read] [static] [[GA]] : $*Int64
// CHECK: begin_access [read] [dynamic] [no_nested_conflict] [[GA]] : $*Int64
// CHECK-LABEL: } // end sil function 'testDominatingOverlapRD_RSRD'
sil hidden [noinline] @testDominatingOverlapRD_RSRD : $@convention(thin) () -> () {
bb0:
%ga = global_addr @globalInt : $*Int64
%a1 = begin_access [read] [dynamic] %ga : $*Int64
end_access %a1 : $*Int64
%a2 = begin_access [read] [static] %ga : $*Int64
%a3 = begin_access [read] [dynamic] [no_nested_conflict] %ga : $*Int64
end_access %a3 : $*Int64
end_access %a2 : $*Int64
%z = tuple ()
return %z : $()
}
// -----------------------------------------------------------------------------
// read, (read, modify)
// No, cannot optimize a nested access.
// CHECK-LABEL: sil hidden [noinline] @testDominatingOverlapRD_RDMD : $@convention(thin) () -> () {
// CHECK: begin_access [read] [dynamic] [[GA:%.*]] : $*Int64
// CHECK: begin_access [read] [dynamic] [[GA]] : $*Int64
// CHECK: begin_access [modify] [dynamic] [no_nested_conflict] [[GA]] : $*Int64
// CHECK-LABEL: } // end sil function 'testDominatingOverlapRD_RDMD'
sil hidden [noinline] @testDominatingOverlapRD_RDMD : $@convention(thin) () -> () {
bb0:
%ga = global_addr @globalInt : $*Int64
%a1 = begin_access [read] [dynamic] %ga : $*Int64
end_access %a1 : $*Int64
%a2 = begin_access [read] [dynamic] %ga : $*Int64
%a3 = begin_access [modify] [dynamic] [no_nested_conflict] %ga : $*Int64
end_access %a3 : $*Int64
end_access %a2 : $*Int64
%z = tuple ()
return %z : $()
}
// No, cannot optimize a nested access.
// CHECK-LABEL: sil hidden [noinline] @testDominatingOverlapRD_RSMD : $@convention(thin) () -> () {
// CHECK: begin_access [read] [dynamic] [[GA:%.*]] : $*Int64
// CHECK: begin_access [read] [static] [[GA]] : $*Int64
// CHECK: begin_access [modify] [dynamic] [no_nested_conflict] [[GA]] : $*Int64
// CHECK-LABEL: } // end sil function 'testDominatingOverlapRD_RSMD'
sil hidden [noinline] @testDominatingOverlapRD_RSMD : $@convention(thin) () -> () {
bb0:
%ga = global_addr @globalInt : $*Int64
%a1 = begin_access [read] [dynamic] %ga : $*Int64
end_access %a1 : $*Int64
%a2 = begin_access [read] [static] %ga : $*Int64
%a3 = begin_access [modify] [dynamic] [no_nested_conflict] %ga : $*Int64
end_access %a3 : $*Int64
end_access %a2 : $*Int64
%z = tuple ()
return %z : $()
}
// -----------------------------------------------------------------------------
// read, (modify, read)
// No, cannot optimize a nested access.
// CHECK-LABEL: sil hidden [noinline] @testDominatingOverlapRD_MDRD : $@convention(thin) () -> () {
// CHECK: begin_access [read] [dynamic] [[GA:%.*]] : $*Int64
// CHECK: begin_access [modify] [dynamic] [[GA]] : $*Int64
// CHECK: begin_access [read] [dynamic] [no_nested_conflict] [[GA]] : $*Int64
// CHECK-LABEL: } // end sil function 'testDominatingOverlapRD_MDRD'
sil hidden [noinline] @testDominatingOverlapRD_MDRD : $@convention(thin) () -> () {
bb0:
%ga = global_addr @globalInt : $*Int64
%a1 = begin_access [read] [dynamic] %ga : $*Int64
end_access %a1 : $*Int64
%a2 = begin_access [modify] [dynamic] %ga : $*Int64
%a3 = begin_access [read] [dynamic] [no_nested_conflict] %ga : $*Int64
end_access %a3 : $*Int64
end_access %a2 : $*Int64
%z = tuple ()
return %z : $()
}
// No, cannot optimize a nested access.
// CHECK-LABEL: sil hidden [noinline] @testDominatingOverlapRD_MSRD : $@convention(thin) () -> () {
// CHECK: begin_access [read] [dynamic] [[GA:%.*]] : $*Int64
// CHECK: begin_access [modify] [static] [[GA]] : $*Int64
// CHECK: begin_access [read] [dynamic] [no_nested_conflict] [[GA]] : $*Int64
// CHECK-LABEL: } // end sil function 'testDominatingOverlapRD_MSRD'
sil hidden [noinline] @testDominatingOverlapRD_MSRD : $@convention(thin) () -> () {
bb0:
%ga = global_addr @globalInt : $*Int64
%a1 = begin_access [read] [dynamic] %ga : $*Int64
end_access %a1 : $*Int64
%a2 = begin_access [modify] [static] %ga : $*Int64
%a3 = begin_access [read] [dynamic] [no_nested_conflict] %ga : $*Int64
end_access %a3 : $*Int64
end_access %a2 : $*Int64
%z = tuple ()
return %z : $()
}
// -----------------------------------------------------------------------------
// read, (modify, modify)
// No, cannot optimize a nested access.
// CHECK-LABEL: sil hidden [noinline] @testDominatingOverlapRD_MDMD : $@convention(thin) () -> () {
// CHECK: begin_access [read] [dynamic] [[GA:%.*]] : $*Int64
// CHECK: begin_access [modify] [dynamic] [[GA]] : $*Int64
// CHECK: begin_access [modify] [dynamic] [no_nested_conflict] [[GA]] : $*Int64
// CHECK-LABEL: } // end sil function 'testDominatingOverlapRD_MDMD'
sil hidden [noinline] @testDominatingOverlapRD_MDMD : $@convention(thin) () -> () {
bb0:
%ga = global_addr @globalInt : $*Int64
%a1 = begin_access [read] [dynamic] %ga : $*Int64
end_access %a1 : $*Int64
%a2 = begin_access [modify] [dynamic] %ga : $*Int64
%a3 = begin_access [modify] [dynamic] [no_nested_conflict] %ga : $*Int64
end_access %a3 : $*Int64
end_access %a2 : $*Int64
%z = tuple ()
return %z : $()
}
// No, cannot optimize a nested access.
// CHECK-LABEL: sil hidden [noinline] @testDominatingOverlapRD_MSMD : $@convention(thin) () -> () {
// CHECK: begin_access [read] [dynamic] [[GA:%.*]] : $*Int64
// CHECK: begin_access [modify] [static] [[GA]] : $*Int64
// CHECK: begin_access [modify] [dynamic] [no_nested_conflict] [[GA]] : $*Int64
// CHECK-LABEL: } // end sil function 'testDominatingOverlapRD_MSMD'
sil hidden [noinline] @testDominatingOverlapRD_MSMD : $@convention(thin) () -> () {
bb0:
%ga = global_addr @globalInt : $*Int64
%a1 = begin_access [read] [dynamic] %ga : $*Int64
end_access %a1 : $*Int64
%a2 = begin_access [modify] [static] %ga : $*Int64
%a3 = begin_access [modify] [dynamic] [no_nested_conflict] %ga : $*Int64
end_access %a3 : $*Int64
end_access %a2 : $*Int64
%z = tuple ()
return %z : $()
}
// -----------------------------------------------------------------------------
// modify, (read, read)
// No, cannot optimize a nested access.
// CHECK-LABEL: sil hidden [noinline] @testDominatingOverlapMD_RDRD : $@convention(thin) () -> () {
// CHECK: begin_access [modify] [dynamic] [[GA:%.*]] : $*Int64
// CHECK: begin_access [read] [dynamic] [[GA]] : $*Int64
// CHECK: begin_access [read] [dynamic] [no_nested_conflict] [[GA]] : $*Int64
// CHECK-LABEL: } // end sil function 'testDominatingOverlapMD_RDRD'
sil hidden [noinline] @testDominatingOverlapMD_RDRD : $@convention(thin) () -> () {
bb0:
%ga = global_addr @globalInt : $*Int64
%a1 = begin_access [modify] [dynamic] %ga : $*Int64
end_access %a1 : $*Int64
%a2 = begin_access [read] [dynamic] %ga : $*Int64
%a3 = begin_access [read] [dynamic] [no_nested_conflict] %ga : $*Int64
end_access %a3 : $*Int64
end_access %a2 : $*Int64
%z = tuple ()
return %z : $()
}
// No, cannot optimize a nested access.
// CHECK-LABEL: sil hidden [noinline] @testDominatingOverlapMD_RSRD : $@convention(thin) () -> () {
// CHECK: begin_access [modify] [dynamic] [[GA:%.*]] : $*Int64
// CHECK: begin_access [read] [static] [[GA]] : $*Int64
// CHECK: begin_access [read] [dynamic] [no_nested_conflict] [[GA]] : $*Int64
// CHECK-LABEL: } // end sil function 'testDominatingOverlapMD_RSRD'
sil hidden [noinline] @testDominatingOverlapMD_RSRD : $@convention(thin) () -> () {
bb0:
%ga = global_addr @globalInt : $*Int64
%a1 = begin_access [modify] [dynamic] %ga : $*Int64
end_access %a1 : $*Int64
%a2 = begin_access [read] [static] %ga : $*Int64
%a3 = begin_access [read] [dynamic] [no_nested_conflict] %ga : $*Int64
end_access %a3 : $*Int64
end_access %a2 : $*Int64
%z = tuple ()
return %z : $()
}
// -----------------------------------------------------------------------------
// modify, (read, modify)
// No, cannot optimize a nested access.
// CHECK-LABEL: sil hidden [noinline] @testDominatingOverlapMD_RDMD : $@convention(thin) () -> () {
// CHECK: begin_access [modify] [dynamic] [[GA:%.*]] : $*Int64
// CHECK: begin_access [read] [dynamic] [[GA]] : $*Int64
// CHECK: begin_access [modify] [dynamic] [no_nested_conflict] [[GA]] : $*Int64
// CHECK-LABEL: } // end sil function 'testDominatingOverlapMD_RDMD'
sil hidden [noinline] @testDominatingOverlapMD_RDMD : $@convention(thin) () -> () {
bb0:
%ga = global_addr @globalInt : $*Int64
%a1 = begin_access [modify] [dynamic] %ga : $*Int64
end_access %a1 : $*Int64
%a2 = begin_access [read] [dynamic] %ga : $*Int64
%a3 = begin_access [modify] [dynamic] [no_nested_conflict] %ga : $*Int64
end_access %a3 : $*Int64
end_access %a2 : $*Int64
%z = tuple ()
return %z : $()
}
// No, cannot optimize a nested access.
// CHECK-LABEL: sil hidden [noinline] @testDominatingOverlapMD_RSMD : $@convention(thin) () -> () {
// CHECK: begin_access [modify] [dynamic] [[GA:%.*]] : $*Int64
// CHECK: begin_access [read] [static] [[GA]] : $*Int64
// CHECK: begin_access [modify] [dynamic] [no_nested_conflict] [[GA]] : $*Int64
// CHECK-LABEL: } // end sil function 'testDominatingOverlapMD_RSMD'
sil hidden [noinline] @testDominatingOverlapMD_RSMD : $@convention(thin) () -> () {
bb0:
%ga = global_addr @globalInt : $*Int64
%a1 = begin_access [modify] [dynamic] %ga : $*Int64
end_access %a1 : $*Int64
%a2 = begin_access [read] [static] %ga : $*Int64
%a3 = begin_access [modify] [dynamic] [no_nested_conflict] %ga : $*Int64
end_access %a3 : $*Int64
end_access %a2 : $*Int64
%z = tuple ()
return %z : $()
}
// -----------------------------------------------------------------------------
// Unidentifiable access
// No, cannot optimized nest access inside an non-uniquely identified access.
// CHECK-LABEL: sil hidden [noinline] @testDominatingOverlapUnidentifiable : $@convention(thin) (@inout Int64) -> () {
// CHECK: begin_access [modify] [dynamic] [[GA:%.*]] : $*Int64
// CHECK: begin_access [read] [static] %0 : $*Int64
// CHECK: begin_access [read] [dynamic] [no_nested_conflict] [[GA]] : $*Int64
// CHECK-LABEL: } // end sil function 'testDominatingOverlapUnidentifiable'
sil hidden [noinline] @testDominatingOverlapUnidentifiable : $@convention(thin) (@inout Int64) -> () {
bb0(%0 : $*Int64):
%ga = global_addr @globalInt : $*Int64
%a1 = begin_access [modify] [dynamic] %ga : $*Int64
end_access %a1 : $*Int64
%a2 = begin_access [read] [static] %0 : $*Int64
%a3 = begin_access [read] [dynamic] [no_nested_conflict] %ga : $*Int64
end_access %a3 : $*Int64
end_access %a2 : $*Int64
%z = tuple ()
return %z : $()
}
Reference in New Issue View Git Blame Copy Permalink