Skip to content

Commit 136b87e

Browse files
committed
SIL: a new library intrinsic to "finalize" array literals
For COW support in SIL it's required to "finalize" array literals. _finalizeUninitializedArray is a compiler known stdlib function which is called after all elements of an array literal are stored. This runtime function marks the array literal as finished. %uninitialized_result_tuple = apply %_allocateUninitializedArray(%count) %mutable_array = tuple_extract %uninitialized_result_tuple, 0 %elem_base_address = tuple_extract %uninitialized_result_tuple, 1 ... store %elem_0 to %elem_addr_0 store %elem_1 to %elem_addr_1 ... %final_array = apply %_finalizeUninitializedArray(%mutable_array) In this commit _finalizeUninitializedArray is still a no-op because the COW support is not used in the Array implementation yet.
1 parent 50231cb commit 136b87e

19 files changed

+210
-77
lines changed

include/swift/AST/KnownDecls.def

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -44,6 +44,8 @@ FUNC_DECL(AllocateUninitializedArray,
4444
"_allocateUninitializedArray")
4545
FUNC_DECL(DeallocateUninitializedArray,
4646
"_deallocateUninitializedArray")
47+
FUNC_DECL(FinalizeUninitializedArray,
48+
"_finalizeUninitializedArray")
4749

4850
FUNC_DECL(ForceBridgeFromObjectiveC,
4951
"_forceBridgeFromObjectiveC")

lib/SIL/IR/SILModule.cpp

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -355,6 +355,7 @@ bool SILModule::linkFunction(SILFunction *F, SILModule::LinkingMode Mode) {
355355

356356
SILFunction *SILModule::findFunction(StringRef Name, SILLinkage Linkage) {
357357
assert((Linkage == SILLinkage::Public ||
358+
Linkage == SILLinkage::SharedExternal ||
358359
Linkage == SILLinkage::PublicExternal) &&
359360
"Only a lookup of public functions is supported currently");
360361

@@ -405,6 +406,9 @@ SILFunction *SILModule::findFunction(StringRef Name, SILLinkage Linkage) {
405406
// compilation, simply convert it into an external declaration,
406407
// so that a compiled version from the shared library is used.
407408
if (F->isDefinition() &&
409+
// Don't eliminate bodies of _alwaysEmitIntoClient functions
410+
// (PublicNonABI linkage is de-serialized as SharedExternal)
411+
F->getLinkage() != SILLinkage::SharedExternal &&
408412
!F->getModule().getOptions().shouldOptimize()) {
409413
F->convertToDeclaration();
410414
}

lib/SILGen/SILGenApply.cpp

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -4962,6 +4962,22 @@ void SILGenFunction::emitUninitializedArrayDeallocation(SILLocation loc,
49624962
SGFContext());
49634963
}
49644964

4965+
ManagedValue SILGenFunction::emitUninitializedArrayFinalization(SILLocation loc,
4966+
SILValue array) {
4967+
auto &Ctx = getASTContext();
4968+
auto finalize = Ctx.getFinalizeUninitializedArray();
4969+
4970+
CanType arrayTy = array->getType().getASTType();
4971+
4972+
// Invoke the intrinsic.
4973+
auto subMap = arrayTy->getContextSubstitutionMap(SGM.M.getSwiftModule(),
4974+
Ctx.getArrayDecl());
4975+
RValue result = emitApplyOfLibraryIntrinsic(loc, finalize, subMap,
4976+
ManagedValue::forUnmanaged(array),
4977+
SGFContext());
4978+
return std::move(result).getScalarValue();
4979+
}
4980+
49654981
namespace {
49664982
/// A cleanup that deallocates an uninitialized array.
49674983
class DeallocateUninitializedArray: public Cleanup {

lib/SILGen/SILGenExpr.cpp

Lines changed: 5 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -2113,10 +2113,11 @@ ManagedValue Lowering::emitEndVarargs(SILGenFunction &SGF, SILLocation loc,
21132113
SGF.Cleanups.setCleanupState(varargs.getAbortCleanup(), CleanupState::Dead);
21142114

21152115
// Reactivate the result cleanup.
2116-
auto result = varargs.getArray();
2117-
if (result.hasCleanup())
2118-
SGF.Cleanups.setCleanupState(result.getCleanup(), CleanupState::Active);
2119-
return result;
2116+
auto array = varargs.getArray();
2117+
if (array.hasCleanup())
2118+
SGF.Cleanups.setCleanupState(array.getCleanup(), CleanupState::Active);
2119+
2120+
return SGF.emitUninitializedArrayFinalization(loc, array.forward(SGF));
21202121
}
21212122

21222123
RValue RValueEmitter::visitTupleExpr(TupleExpr *E, SGFContext C) {

lib/SILGen/SILGenFunction.h

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1187,6 +1187,7 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
11871187

11881188
CleanupHandle enterDeallocateUninitializedArrayCleanup(SILValue array);
11891189
void emitUninitializedArrayDeallocation(SILLocation loc, SILValue array);
1190+
ManagedValue emitUninitializedArrayFinalization(SILLocation loc, SILValue array);
11901191

11911192
/// Emit a cleanup for an owned value that should be written back at end of
11921193
/// scope if the value is not forwarded.

lib/SILOptimizer/LoopTransforms/COWArrayOpt.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -642,7 +642,7 @@ bool COWArrayOpt::hasLoopOnlyDestructorSafeArrayOperations() {
642642

643643
// Semantic calls are safe.
644644
ArraySemanticsCall Sem(Inst);
645-
if (Sem) {
645+
if (Sem && Sem.hasSelf()) {
646646
auto Kind = Sem.getKind();
647647
// Safe because they create new arrays.
648648
if (Kind == ArrayCallKind::kArrayInit ||

lib/SILOptimizer/LoopTransforms/ForEachLoopUnroll.cpp

Lines changed: 9 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -323,8 +323,15 @@ void ArrayInfo::classifyUsesOfArray(SILValue arrayValue) {
323323
// as the array itself is not modified (which is possible with reference
324324
// types).
325325
ArraySemanticsCall arrayOp(user);
326-
if (!arrayOp.doesNotChangeArray())
327-
mayBeWritten = true;
326+
if (arrayOp.doesNotChangeArray())
327+
continue;
328+
329+
if (arrayOp.getKind() == swift::ArrayCallKind::kArrayFinalizeIntrinsic) {
330+
classifyUsesOfArray((ApplyInst *)arrayOp);
331+
continue;
332+
}
333+
334+
mayBeWritten = true;
328335
}
329336
}
330337

lib/SILOptimizer/Mandatory/OSLogOptimization.cpp

Lines changed: 15 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -539,6 +539,15 @@ static SILValue emitCodeForConstantArray(ArrayRef<SILValue> elements,
539539
module.findFunction(allocatorMangledName, SILLinkage::PublicExternal);
540540
assert(arrayAllocateFun);
541541

542+
FuncDecl *arrayFinalizeDecl = astContext.getFinalizeUninitializedArray();
543+
assert(arrayFinalizeDecl);
544+
std::string finalizeMangledName =
545+
SILDeclRef(arrayFinalizeDecl, SILDeclRef::Kind::Func).mangle();
546+
SILFunction *arrayFinalizeFun =
547+
module.findFunction(finalizeMangledName, SILLinkage::SharedExternal);
548+
assert(arrayFinalizeFun);
549+
module.linkFunction(arrayFinalizeFun);
550+
542551
// Call the _allocateUninitializedArray function with numElementsSIL. The
543552
// call returns a two-element tuple, where the first element is the newly
544553
// created array and the second element is a pointer to the internal storage
@@ -596,7 +605,12 @@ static SILValue emitCodeForConstantArray(ArrayRef<SILValue> elements,
596605
StoreOwnershipQualifier::Init);
597606
elementIndex++;
598607
}
599-
return arraySIL;
608+
FunctionRefInst *arrayFinalizeRef =
609+
builder.createFunctionRef(loc, arrayFinalizeFun);
610+
ApplyInst *finalizedArray = builder.createApply(
611+
loc, arrayFinalizeRef, subMap, ArrayRef<SILValue>(arraySIL));
612+
613+
return finalizedArray;
600614
}
601615

602616
/// Given a SILValue \p value, return the instruction immediately following the

stdlib/public/core/ArrayShared.swift

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -64,6 +64,18 @@ func _deallocateUninitializedArray<Element>(
6464
array._deallocateUninitialized()
6565
}
6666

67+
@_alwaysEmitIntoClient
68+
@_semantics("array.finalize_intrinsic")
69+
@_effects(readnone)
70+
public // COMPILER_INTRINSIC
71+
func _finalizeUninitializedArray<Element>(
72+
_ array: __owned Array<Element>
73+
) -> Array<Element> {
74+
var mutableArray = array
75+
// TODO: enable this once Array had an _endMutation function
76+
// mutableArray._endMutation()
77+
return mutableArray
78+
}
6779

6880
extension Collection {
6981
// Utility method for collections that wish to implement

test/AutoDiff/SILOptimizer/activity_analysis.swift

Lines changed: 47 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -254,6 +254,8 @@ func testArrayUninitializedIntrinsic(_ x: Float, _ y: Float) -> [Float] {
254254
// CHECK: [ACTIVE] %9 = pointer_to_address %8 : $Builtin.RawPointer to [strict] $*Float
255255
// CHECK: [VARIED] %11 = integer_literal $Builtin.Word, 1
256256
// CHECK: [ACTIVE] %12 = index_addr %9 : $*Float, %11 : $Builtin.Word
257+
// CHECK: [NONE] // function_ref _finalizeUninitializedArray<A>(_:)
258+
// CHECK: [ACTIVE] %15 = apply %14<Float>(%7) : $@convention(thin) <τ_0_0> (@owned Array<τ_0_0>) -> @owned Array<τ_0_0>
257259

258260
@differentiable(where T: Differentiable)
259261
func testArrayUninitializedIntrinsicGeneric<T>(_ x: T, _ y: T) -> [T] {
@@ -271,6 +273,8 @@ func testArrayUninitializedIntrinsicGeneric<T>(_ x: T, _ y: T) -> [T] {
271273
// CHECK: [ACTIVE] %9 = pointer_to_address %8 : $Builtin.RawPointer to [strict] $*T
272274
// CHECK: [VARIED] %11 = integer_literal $Builtin.Word, 1
273275
// CHECK: [ACTIVE] %12 = index_addr %9 : $*T, %11 : $Builtin.Word
276+
// CHECK: [NONE] // function_ref _finalizeUninitializedArray<A>(_:)
277+
// CHECK: [ACTIVE] %15 = apply %14<T>(%7) : $@convention(thin) <τ_0_0> (@owned Array<τ_0_0>) -> @owned Array<τ_0_0>
274278

275279
// TF-952: Test array literal initialized from an address (e.g. `var`).
276280
@differentiable
@@ -298,6 +302,8 @@ func testArrayUninitializedIntrinsicAddress(_ x: Float, _ y: Float) -> [Float] {
298302
// CHECK: [VARIED] %24 = integer_literal $Builtin.Word, 1
299303
// CHECK: [ACTIVE] %25 = index_addr %20 : $*Float, %24 : $Builtin.Word
300304
// CHECK: [ACTIVE] %26 = begin_access [read] [static] %4 : $*Float
305+
// CHECK: [NONE] // function_ref _finalizeUninitializedArray<A>(_:)
306+
// CHECK: [ACTIVE] %30 = apply %29<Float>(%18) : $@convention(thin) <τ_0_0> (@owned Array<τ_0_0>) -> @owned Array<τ_0_0>
301307

302308
// TF-952: Test array literal initialized with `apply` direct results.
303309
@differentiable
@@ -320,6 +326,8 @@ func testArrayUninitializedIntrinsicFunctionResult(_ x: Float, _ y: Float) -> [F
320326
// CHECK: [USEFUL] %16 = metatype $@thin Float.Type
321327
// CHECK: [NONE] // function_ref static Float.* infix(_:_:)
322328
// CHECK: [ACTIVE] %18 = apply %17(%0, %1, %16) : $@convention(method) (Float, Float, @thin Float.Type) -> Float
329+
// CHECK: [NONE] // function_ref _finalizeUninitializedArray<A>(_:)
330+
// CHECK: [ACTIVE] %21 = apply %20<Float>(%7) : $@convention(thin) <τ_0_0> (@owned Array<τ_0_0>) -> @owned Array<τ_0_0>
323331

324332
// TF-975: Test nested array literals.
325333
@differentiable
@@ -338,28 +346,32 @@ func testArrayUninitializedIntrinsicNested(_ x: Float, _ y: Float) -> [Float] {
338346
// CHECK: [ACTIVE] %9 = pointer_to_address %8 : $Builtin.RawPointer to [strict] $*Float
339347
// CHECK: [VARIED] %11 = integer_literal $Builtin.Word, 1
340348
// CHECK: [ACTIVE] %12 = index_addr %9 : $*Float, %11 : $Builtin.Word
341-
// CHECK: [USEFUL] %15 = integer_literal $Builtin.Word, 2
349+
// CHECK: [NONE] // function_ref _finalizeUninitializedArray<A>(_:)
350+
// CHECK: [ACTIVE] %15 = apply %14<Float>(%7) : $@convention(thin) <τ_0_0> (@owned Array<τ_0_0>) -> @owned Array<τ_0_0>
351+
// CHECK: [USEFUL] %17 = integer_literal $Builtin.Word, 2
342352
// CHECK: [NONE] // function_ref _allocateUninitializedArray<A>(_:)
343-
// CHECK: [ACTIVE] %17 = apply %16<Float>(%15) : $@convention(thin) <τ_0_0> (Builtin.Word) -> (@owned Array<τ_0_0>, Builtin.RawPointer)
344-
// CHECK: [ACTIVE] (**%18**, %19) = destructure_tuple %17 : $(Array<Float>, Builtin.RawPointer)
345-
// CHECK: [VARIED] (%18, **%19**) = destructure_tuple %17 : $(Array<Float>, Builtin.RawPointer)
346-
// CHECK: [ACTIVE] %20 = pointer_to_address %19 : $Builtin.RawPointer to [strict] $*Float
347-
// CHECK: [ACTIVE] %21 = begin_borrow %7 : $Array<Float>
348-
// CHECK: [USEFUL] %22 = integer_literal $Builtin.IntLiteral, 0
349-
// CHECK: [USEFUL] %23 = metatype $@thin Int.Type
353+
// CHECK: [ACTIVE] %19 = apply %18<Float>(%17) : $@convention(thin) <τ_0_0> (Builtin.Word) -> (@owned Array<τ_0_0>, Builtin.RawPointer)
354+
// CHECK: [ACTIVE] (**%20**, %21) = destructure_tuple %19 : $(Array<Float>, Builtin.RawPointer)
355+
// CHECK: [VARIED] (%20, **%21**) = destructure_tuple %19 : $(Array<Float>, Builtin.RawPointer)
356+
// CHECK: [ACTIVE] %22 = pointer_to_address %21 : $Builtin.RawPointer to [strict] $*Float
357+
// CHECK: [ACTIVE] %23 = begin_borrow %15 : $Array<Float>
358+
// CHECK: [USEFUL] %24 = integer_literal $Builtin.IntLiteral, 0
359+
// CHECK: [USEFUL] %25 = metatype $@thin Int.Type
350360
// CHECK: [NONE] // function_ref Int.init(_builtinIntegerLiteral:)
351-
// CHECK: [USEFUL] %25 = apply %24(%22, %23) : $@convention(method) (Builtin.IntLiteral, @thin Int.Type) -> Int
361+
// CHECK: [USEFUL] %27 = apply %26(%24, %25) : $@convention(method) (Builtin.IntLiteral, @thin Int.Type) -> Int
352362
// CHECK: [NONE] // function_ref Array.subscript.getter
353-
// CHECK: [NONE] %27 = apply %26<Float>(%20, %25, %21) : $@convention(method) <τ_0_0> (Int, @guaranteed Array<τ_0_0>) -> @out τ_0_0
354-
// CHECK: [VARIED] %28 = integer_literal $Builtin.Word, 1
355-
// CHECK: [ACTIVE] %29 = index_addr %20 : $*Float, %28 : $Builtin.Word
356-
// CHECK: [ACTIVE] %30 = begin_borrow %7 : $Array<Float>
357-
// CHECK: [USEFUL] %31 = integer_literal $Builtin.IntLiteral, 1
358-
// CHECK: [USEFUL] %32 = metatype $@thin Int.Type
363+
// CHECK: [NONE] %29 = apply %28<Float>(%22, %27, %23) : $@convention(method) <τ_0_0> (Int, @guaranteed Array<τ_0_0>) -> @out τ_0_0
364+
// CHECK: [VARIED] %30 = integer_literal $Builtin.Word, 1
365+
// CHECK: [ACTIVE] %31 = index_addr %22 : $*Float, %30 : $Builtin.Word
366+
// CHECK: [ACTIVE] %32 = begin_borrow %15 : $Array<Float>
367+
// CHECK: [USEFUL] %33 = integer_literal $Builtin.IntLiteral, 1
368+
// CHECK: [USEFUL] %34 = metatype $@thin Int.Type
359369
// CHECK: [NONE] // function_ref Int.init(_builtinIntegerLiteral:)
360-
// CHECK: [USEFUL] %34 = apply %33(%31, %32) : $@convention(method) (Builtin.IntLiteral, @thin Int.Type) -> Int
370+
// CHECK: [USEFUL] %36 = apply %35(%33, %34) : $@convention(method) (Builtin.IntLiteral, @thin Int.Type) -> Int
361371
// CHECK: [NONE] // function_ref Array.subscript.getter
362-
// CHECK: [NONE] %36 = apply %35<Float>(%29, %34, %30) : $@convention(method) <τ_0_0> (Int, @guaranteed Array<τ_0_0>) -> @out τ_0_0
372+
// CHECK: [NONE] %38 = apply %37<Float>(%31, %36, %32) : $@convention(method) <τ_0_0> (Int, @guaranteed Array<τ_0_0>) -> @out τ_0_0
373+
// CHECK: [NONE] // function_ref _finalizeUninitializedArray<A>(_:)
374+
// CHECK: [ACTIVE] %40 = apply %39<Float>(%20) : $@convention(thin) <τ_0_0> (@owned Array<τ_0_0>) -> @owned Array<τ_0_0>
363375

364376
// TF-978: Test array literal initialized with `apply` indirect results.
365377
struct Wrapper<T: Differentiable>: Differentiable {
@@ -388,6 +400,8 @@ func testArrayUninitializedIntrinsicApplyIndirectResult<T>(_ x: T, _ y: T) -> [W
388400
// CHECK: [ACTIVE] %19 = alloc_stack $T
389401
// CHECK: [NONE] // function_ref Wrapper.init(value:)
390402
// CHECK: [NONE] %22 = apply %21<T>(%17, %19, %18) : $@convention(method) <τ_0_0 where τ_0_0 : Differentiable> (@in τ_0_0, @thin Wrapper<τ_0_0>.Type) -> @out Wrapper<τ_0_0>
403+
// CHECK: [NONE] // function_ref _finalizeUninitializedArray<A>(_:)
404+
// CHECK: [ACTIVE] %25 = apply %24<Wrapper<T>>(%7) : $@convention(thin) <τ_0_0> (@owned Array<τ_0_0>) -> @owned Array<τ_0_0>
391405

392406
//===----------------------------------------------------------------------===//
393407
// `inout` argument differentiation
@@ -647,24 +661,26 @@ func testBeginApplyActiveButInitiallyNonactiveInoutArgument(x: Float) -> Float {
647661
// CHECK: [USEFUL] %10 = metatype $@thin Float.Type
648662
// CHECK: [NONE] // function_ref Float.init(_builtinIntegerLiteral:)
649663
// CHECK: [USEFUL] %12 = apply %11(%9, %10) : $@convention(method) (Builtin.IntLiteral, @thin Float.Type) -> Float
650-
// CHECK: [USEFUL] %15 = integer_literal $Builtin.IntLiteral, 0
651-
// CHECK: [USEFUL] %16 = metatype $@thin Int.Type
664+
// CHECK: [NONE] // function_ref _finalizeUninitializedArray<A>(_:)
665+
// CHECK: [USEFUL] %15 = apply %14<Float>(%6) : $@convention(thin) <τ_0_0> (@owned Array<τ_0_0>) -> @owned Array<τ_0_0>
666+
// CHECK: [USEFUL] %17 = integer_literal $Builtin.IntLiteral, 0
667+
// CHECK: [USEFUL] %18 = metatype $@thin Int.Type
652668
// CHECK: [NONE] // function_ref Int.init(_builtinIntegerLiteral:)
653-
// CHECK: [USEFUL] %18 = apply %17(%15, %16) : $@convention(method) (Builtin.IntLiteral, @thin Int.Type) -> Int
654-
// CHECK: [ACTIVE] %19 = begin_access [modify] [static] %2 : $*Array<Float>
669+
// CHECK: [USEFUL] %20 = apply %19(%17, %18) : $@convention(method) (Builtin.IntLiteral, @thin Int.Type) -> Int
670+
// CHECK: [ACTIVE] %21 = begin_access [modify] [static] %2 : $*Array<Float>
655671
// CHECK: [NONE] // function_ref Array.subscript.modify
656-
// CHECK: [ACTIVE] (**%21**, %22) = begin_apply %20<Float>(%18, %19) : $@yield_once @convention(method) <τ_0_0> (Int, @inout Array<τ_0_0>) -> @yields @inout τ_0_0
657-
// CHECK: [VARIED] (%21, **%22**) = begin_apply %20<Float>(%18, %19) : $@yield_once @convention(method) <τ_0_0> (Int, @inout Array<τ_0_0>) -> @yields @inout τ_0_0
658-
// CHECK: [USEFUL] %26 = integer_literal $Builtin.IntLiteral, 0
659-
// CHECK: [USEFUL] %27 = metatype $@thin Int.Type
672+
// CHECK: [ACTIVE] (**%23**, %24) = begin_apply %22<Float>(%20, %21) : $@yield_once @convention(method) <τ_0_0> (Int, @inout Array<τ_0_0>) -> @yields @inout τ_0_0
673+
// CHECK: [VARIED] (%23, **%24**) = begin_apply %22<Float>(%20, %21) : $@yield_once @convention(method) <τ_0_0> (Int, @inout Array<τ_0_0>) -> @yields @inout τ_0_0
674+
// CHECK: [USEFUL] %28 = integer_literal $Builtin.IntLiteral, 0
675+
// CHECK: [USEFUL] %29 = metatype $@thin Int.Type
660676
// CHECK: [NONE] // function_ref Int.init(_builtinIntegerLiteral:)
661-
// CHECK: [USEFUL] %29 = apply %28(%26, %27) : $@convention(method) (Builtin.IntLiteral, @thin Int.Type) -> Int
662-
// CHECK: [ACTIVE] %30 = begin_access [read] [static] %2 : $*Array<Float>
663-
// CHECK: [ACTIVE] %31 = load_borrow %30 : $*Array<Float>
664-
// CHECK: [ACTIVE] %32 = alloc_stack $Float
677+
// CHECK: [USEFUL] %31 = apply %30(%28, %29) : $@convention(method) (Builtin.IntLiteral, @thin Int.Type) -> Int
678+
// CHECK: [ACTIVE] %32 = begin_access [read] [static] %2 : $*Array<Float>
679+
// CHECK: [ACTIVE] %33 = load_borrow %32 : $*Array<Float>
680+
// CHECK: [ACTIVE] %34 = alloc_stack $Float
665681
// CHECK: [NONE] // function_ref Array.subscript.getter
666-
// CHECK: [NONE] %34 = apply %33<Float>(%32, %29, %31) : $@convention(method) <τ_0_0> (Int, @guaranteed Array<τ_0_0>) -> @out τ_0_0
667-
// CHECK: [ACTIVE] %35 = load [trivial] %32 : $*Float
682+
// CHECK: [NONE] %36 = apply %35<Float>(%34, %31, %33) : $@convention(method) <τ_0_0> (Int, @guaranteed Array<τ_0_0>) -> @out τ_0_0
683+
// CHECK: [ACTIVE] %37 = load [trivial] %34 : $*Float
668684

669685
//===----------------------------------------------------------------------===//
670686
// Class differentiation

test/IRGen/unmanaged_objc_throw_func.swift

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -15,11 +15,11 @@ import Foundation
1515
// CHECK-NEXT: %[[T2:.+]] = extractvalue { %swift.bridge*, i8* } %[[T0]], 1
1616
// CHECK-NEXT: %[[T3:.+]] = bitcast i8* %[[T2]] to %TSi*
1717
// CHECK-NEXT: %._value = getelementptr inbounds %TSi, %TSi* %[[T3]], i32 0, i32 0
18-
// CHECK-NEXT: store i{{32|64}} 1, i{{32|64}}* %._value, align {{[0-9]+}}
19-
// CHECK-NEXT: %[[T4:.+]] = call swiftcc %TSo7NSArrayC* @"$sSa10FoundationE19_bridgeToObjectiveCSo7NSArrayCyF"(%swift.bridge* %[[T1]], %swift.type* @"$sSiN")
18+
// CHECK: %[[T7:.+]] = call swiftcc %swift.bridge* @"$ss27_finalizeUninitializedArrayySayxGABnlF"(%swift.bridge* %[[T1]], %swift.type* @"$sSiN")
19+
// CHECK: %[[T4:.+]] = call swiftcc %TSo7NSArrayC* @"$sSa10FoundationE19_bridgeToObjectiveCSo7NSArrayCyF"(%swift.bridge* %[[T7]], %swift.type* @"$sSiN")
2020
// CHECK-NEXT: %[[T5:.+]] = bitcast %TSo7NSArrayC* %[[T4]] to %TSo10CFArrayRefa*
2121
// CHECK-NEXT: store %TSo10CFArrayRefa* %[[T5]]
22-
// CHECK-NEXT: call void @swift_bridgeObjectRelease(%swift.bridge* %[[T1]]) #{{[0-9]+}}
22+
// CHECK-NEXT: call void @swift_bridgeObjectRelease(%swift.bridge* %{{[0-9]+}}) #{{[0-9]+}}
2323
// CHECK-NEXT: %[[T6:.+]] = bitcast %TSo10CFArrayRefa* %[[T5]] to i8*
2424
// CHECK-NEXT: call void @llvm.objc.release(i8* %[[T6]])
2525
// CHECK-NEXT: ret %TSo10CFArrayRefa* %[[T5]]

test/SILGen/arguments.swift

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -14,6 +14,10 @@ func _allocateUninitializedArray<T>(_: Builtin.Word)
1414
Builtin.int_trap()
1515
}
1616

17+
func _finalizeUninitializedArray<T>(_ a: Array<T>) -> Array<T> {
18+
return a
19+
}
20+
1721
func _deallocateUninitializedArray<T>(_: Array<T>) {}
1822

1923
var i:Int, f:Float, c:UnicodeScalar

test/SILGen/errors.swift

Lines changed: 5 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -639,10 +639,12 @@ func test_variadic(_ cat: Cat) throws {
639639
// CHECK: [[NORM_3]]([[CAT3:%.*]] : @owned $Cat):
640640
// CHECK-NEXT: store [[CAT3]] to [init] [[ELT3]]
641641
// Complete the call and return.
642+
// CHECK: [[FIN_FN:%.*]] = function_ref @$ss27_finalizeUninitializedArrayySayxGABnlF
643+
// CHECK: [[FIN_ARRAY:%.*]] = apply [[FIN_FN]]<Cat>([[ARRAY]])
642644
// CHECK: [[TAKE_FN:%.*]] = function_ref @$s6errors14take_many_catsyyAA3CatCd_tKF : $@convention(thin) (@guaranteed Array<Cat>) -> @error Error
643-
// CHECK-NEXT: try_apply [[TAKE_FN]]([[ARRAY]]) : $@convention(thin) (@guaranteed Array<Cat>) -> @error Error, normal [[NORM_CALL:bb[0-9]+]], error [[ERR_CALL:bb[0-9]+]]
645+
// CHECK-NEXT: try_apply [[TAKE_FN]]([[FIN_ARRAY]]) : $@convention(thin) (@guaranteed Array<Cat>) -> @error Error, normal [[NORM_CALL:bb[0-9]+]], error [[ERR_CALL:bb[0-9]+]]
644646
// CHECK: [[NORM_CALL]]([[T0:%.*]] : $()):
645-
// CHECK-NEXT: destroy_value [[ARRAY]]
647+
// CHECK-NEXT: destroy_value [[FIN_ARRAY]]
646648
// CHECK-NEXT: [[T0:%.*]] = tuple ()
647649
// CHECK-NEXT: return
648650
// Failure from element 0.
@@ -671,7 +673,7 @@ func test_variadic(_ cat: Cat) throws {
671673
// CHECK-NEXT: br [[RETHROW]]([[ERROR]] : $Error)
672674
// Failure from call.
673675
// CHECK: [[ERR_CALL]]([[ERROR:%.*]] : @owned $Error):
674-
// CHECK-NEXT: destroy_value [[ARRAY]]
676+
// CHECK-NEXT: destroy_value [[FIN_ARRAY]]
675677
// CHECK-NEXT: br [[RETHROW]]([[ERROR]] : $Error)
676678
// Rethrow.
677679
// CHECK: [[RETHROW]]([[ERROR:%.*]] : @owned $Error):

0 commit comments

Comments
 (0)