mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
7cceaff5f3
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.
73 lines
2.9 KiB
Swift
73 lines
2.9 KiB
Swift
|
|
// RUN: %target-swift-emit-silgen -Xllvm -sil-print-types -parse-stdlib -module-name Swift %s | %FileCheck %s
|
|
|
|
@_marker protocol Copyable {}
|
|
|
|
class C {}
|
|
|
|
enum Optional<T> {
|
|
case none
|
|
case some(T)
|
|
}
|
|
|
|
precedencegroup AssignmentPrecedence {
|
|
assignment: true
|
|
associativity: right
|
|
}
|
|
|
|
struct Holder {
|
|
unowned(unsafe) var value: C
|
|
}
|
|
|
|
_ = Holder(value: C())
|
|
// CHECK-LABEL:sil hidden [ossa] @$ss6HolderV{{[_0-9a-zA-Z]*}}fC : $@convention(method) (@owned C, @thin Holder.Type) -> Holder
|
|
// CHECK: bb0([[T0:%.*]] : @owned $C,
|
|
// CHECK-NEXT: [[T1:%.*]] = ref_to_unmanaged [[T0]] : $C to $@sil_unmanaged C
|
|
// CHECK-NEXT: destroy_value [[T0]] : $C
|
|
// CHECK-NEXT: [[T2:%.*]] = struct $Holder ([[T1]] : $@sil_unmanaged C)
|
|
// CHECK-NEXT: return [[T2]] : $Holder
|
|
// CHECK-NEXT: } // end sil function '$ss6HolderV5valueABs1CC_tcfC'
|
|
func set(holder holder: inout Holder) {
|
|
holder.value = C()
|
|
}
|
|
|
|
// CHECK-LABEL: sil hidden [ossa] @$ss3set6holderys6HolderVz_tF : $@convention(thin) (@inout Holder) -> () {
|
|
// CHECK: bb0([[ADDR:%.*]] : $*Holder):
|
|
// CHECK: [[T0:%.*]] = function_ref @$ss1CC{{[_0-9a-zA-Z]*}}fC
|
|
// CHECK: [[C:%.*]] = apply [[T0]](
|
|
// CHECK-NEXT: [[WRITE:%.*]] = begin_access [modify] [unknown] [[ADDR]] : $*Holder
|
|
// CHECK-NEXT: [[T0:%.*]] = struct_element_addr [[WRITE]] : $*Holder, #Holder.value
|
|
// CHECK-NEXT: [[T1:%.*]] = ref_to_unmanaged [[C]]
|
|
// CHECK-NEXT: assign [[T1]] to [[T0]]
|
|
// CHECK-NEXT: destroy_value [[C]]
|
|
// CHECK-NEXT: end_access [[WRITE]] : $*Holder
|
|
// CHECK: } // end sil function '$ss3set6holderys6HolderVz_tF'
|
|
|
|
func get(holder holder: inout Holder) -> C {
|
|
return holder.value
|
|
}
|
|
// CHECK-LABEL: sil hidden [ossa] @$ss3get6holders1CCs6HolderVz_tF : $@convention(thin) (@inout Holder) -> @owned C {
|
|
// CHECK: bb0([[ADDR:%.*]] : $*Holder):
|
|
// CHECK-NEXT: debug_value %0 : $*Holder, var, name "holder", argno 1, expr op_deref
|
|
// CHECK-NEXT: [[READ:%.*]] = begin_access [read] [unknown] [[ADDR]] : $*Holder
|
|
// CHECK-NEXT: [[T0:%.*]] = struct_element_addr [[READ]] : $*Holder, #Holder.value
|
|
// CHECK-NEXT: [[T1:%.*]] = load [trivial] [[T0]] : $*@sil_unmanaged C
|
|
// CHECK-NEXT: [[T2:%.*]] = strong_copy_unmanaged_value [[T1]]
|
|
// CHECK-NEXT: end_access [[READ]] : $*Holder
|
|
// CHECK-NEXT: return [[T2]]
|
|
|
|
func project(fn fn: () -> Holder) -> C {
|
|
return fn().value
|
|
}
|
|
// CHECK-LABEL: sil hidden [ossa] @$ss7project2fns1CCs6HolderVyXE_tF : $@convention(thin) (@guaranteed @noescape @callee_guaranteed () -> Holder) -> @owned C {
|
|
// CHECK: bb0([[FN:%.*]] : @guaranteed $@noescape @callee_guaranteed () -> Holder):
|
|
// CHECK-NEXT: debug_value
|
|
// CHECK-NEXT: [[FNC:%.*]] = copy_value [[FN]]
|
|
// CHECK-NEXT: [[FNB:%.*]] = begin_borrow [[FNC]]
|
|
// CHECK-NEXT: [[T0:%.*]] = apply [[FNB]]()
|
|
// CHECK-NEXT: end_borrow [[FNB]]
|
|
// CHECK-NEXT: [[T1:%.*]] = struct_extract [[T0]] : $Holder, #Holder.value
|
|
// CHECK-NEXT: [[T2:%.*]] = strong_copy_unmanaged_value [[T1]]
|
|
// CHECK-NEXT: destroy_value [[FNC]]
|
|
// CHECK-NEXT: return [[T2]]
|