mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
249f2d030a
`ReadOnly, ArgMemOnly` previously meant `can only read argument memory`.
But with the rebranch changes, this became `(can only read *all* memory)
and (can read or write argument memory)`. Use `ArgMemReadOnly` for this
instead.
To expand on this, these attributes (prior to memory effects) used to be
split into two. There was the *kind* of access, eg.
```
readnone
readonly
writeonly
```
and the accessed *location*, eg.
```
argmemonly
inaccessiblememonly
inaccessiblemem_or_argmemonly
```
So `RuntimeFunctions.def` would use `ReadOnly, ArgMemOnly` to mean `can
only read argument memory`.
In the previous rebranch commits, this was changed such that `ReadOnly`
mapped to `MemoryEffectsBase::readOnly()` and `ArgMemOnly` to
`MemoryEffectsBase::argMemOnly()`.
And there lies the issue -
- `MemoryEffectsBase::readOnly()` == `MemoryEffectsBase(Ref)` ie. all
locations can only read
- `MemoryEffectsBase::argMemOnly()` == `MemoryEffectsBase(ArgMem,
ModRef)`, ie. can only access argument memory
But then OR'ing those together this would become:
```
ArgMem: ModRef, InaccessibleMem: Ref, Other: Ref
```
rather than the previously intended:
```
ArgMem: Ref, InaccessibleMem: NoModRef, Other: NoModRef
```
68 lines
2.2 KiB
Plaintext
68 lines
2.2 KiB
Plaintext
// RUN: %target-swift-frontend -emit-ir %s | %FileCheck %s
|
|
//sil_stage canonical
|
|
|
|
import Builtin
|
|
import Swift
|
|
import SwiftShims
|
|
|
|
private class XXX{}
|
|
|
|
sil @XXX_dtor : $@convention(method) (@owned XXX) -> ()
|
|
sil @XXX_ctor : $@convention(method) (@owned XXX) -> @owned XXX
|
|
|
|
// CHECK: target datalayout
|
|
|
|
// No @owned or @out parameters -- function is not read only at LLVM level,
|
|
// because Swift level read only attribute is not automatically mapped
|
|
// to the LLVM read only attribute, unless IRGen can prove by analyzing
|
|
// the function body that this function is really read only.
|
|
|
|
// CHECK-NOT: ; Function Attrs:{{.*}}memory(read)
|
|
// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @function_foo(
|
|
sil [readonly] @function_foo : $@convention(thin) (Int) -> () {
|
|
bb0(%0 : $Int):
|
|
%1 = tuple ()
|
|
return %1 : $()
|
|
}
|
|
|
|
// No @owned or @out parameters -- function is not read only at LLVM level,
|
|
// because Swift level read none attribute is not automatically mapped
|
|
// to the LLVM read only attribute, unless IRGen can prove by analyzing
|
|
// the function body that this function is really read only or read none.
|
|
|
|
// CHECK-NOT: ; Function Attrs:{{.*}}memory(read)
|
|
// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @function_foo2(
|
|
sil [readnone] @function_foo2 : $@convention(thin) (Int) -> () {
|
|
bb0(%0 : $Int):
|
|
%1 = tuple ()
|
|
return %1 : $()
|
|
}
|
|
|
|
// There's an @owned parameter, and destructors can call arbitrary code
|
|
// -- function is not read only at LLVM level
|
|
|
|
// CHECK-NOT: ; Function Attrs:{{.*}}memory(read)
|
|
// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @function_bar(
|
|
sil [readonly] @function_bar : $@convention(thin) (@owned XXX) -> () {
|
|
bb0(%0 : $XXX):
|
|
strong_release %0 : $XXX
|
|
%1 = tuple ()
|
|
return %1 : $()
|
|
}
|
|
|
|
// There's an @out parameter -- function is not read only at LLVM level
|
|
|
|
// CHECK-NOT: ; Function Attrs:{{.*}}memory(read)
|
|
// CHECK: define{{( dllexport)?}}{{( protected)?}} swiftcc void @function_baz(
|
|
sil [readonly] @function_baz : $@convention(thin) () -> (@out Any) {
|
|
bb0(%0 : $*Any):
|
|
init_existential_addr %0 : $*Any, $()
|
|
%1 = tuple ()
|
|
return %1 : $()
|
|
}
|
|
|
|
sil_vtable XXX {
|
|
#XXX.deinit!deallocator: @XXX_dtor
|
|
#XXX.init!initializer: @XXX_ctor
|
|
}
|