static ManagedValue emitBridgeCollectionToNative(SILGenFunction &gen,
SILLocation loc,
SILDeclRef bridgeFnRef,
ManagedValue collection,
SILType nativeTy) {
SILValue bridgeFn = gen.emitGlobalFunctionRef(loc, bridgeFnRef);
auto collectionTy = nativeTy.getSwiftRValueType()->castTo<BoundGenericType>();
auto subs = collectionTy->getSubstitutions(gen.SGM.M.getSwiftModule(),
nullptr);
auto substFnType = bridgeFn->getType().substGenericArgs(gen.SGM.M, subs);
Type inputType = collection.getType().getSwiftRValueType();
if (!inputType->getOptionalObjectType()) {
SILType loweredOptTy = gen.SGM.getLoweredType(OptionalType::get(inputType));
auto *someDecl = gen.getASTContext().getOptionalSomeDecl();
auto *enumInst = gen.B.createEnum(loc, collection.getValue(), someDecl,
loweredOptTy);
collection = ManagedValue(enumInst, collection.getCleanup());
}
SILValue result = gen.B.createApply(loc, bridgeFn,
substFnType,
nativeTy,
subs,
{ collection.forward(gen) });
return gen.emitManagedRValueWithCleanup(result);
}
static ManagedValue emitCBridgedToNativeValue(SILGenFunction &gen,
SILLocation loc,
ManagedValue v,
SILType nativeTy) {
CanType loweredNativeTy = nativeTy.getSwiftRValueType();
CanType loweredBridgedTy = v.getType().getSwiftRValueType();
if (loweredNativeTy == loweredBridgedTy)
return v;
if (loweredNativeTy.getAnyOptionalObjectType()) {
return gen.emitOptionalToOptional(loc, v, nativeTy,
emitCBridgedToNativeValue);
}
// Bridge Bool to ObjCBool or DarwinBoolean when requested.
if (loweredNativeTy == gen.SGM.Types.getBoolType()) {
if (loweredBridgedTy == gen.SGM.Types.getObjCBoolType()) {
return emitBridgeForeignBoolToBool(gen, loc, v,
gen.SGM.getObjCBoolToBoolFn());
}
if (loweredBridgedTy == gen.SGM.Types.getDarwinBooleanType()) {
return emitBridgeForeignBoolToBool(gen, loc, v,
gen.SGM.getDarwinBooleanToBoolFn());
}
}
// Bridge Objective-C to thick metatypes.
if (auto bridgedMetaTy = dyn_cast<AnyMetatypeType>(loweredBridgedTy)){
if (bridgedMetaTy->getRepresentation() == MetatypeRepresentation::ObjC) {
SILValue native = gen.B.emitObjCToThickMetatype(loc, v.getValue(),
gen.getLoweredType(loweredNativeTy));
return ManagedValue(native, v.getCleanup());
}
}
// Bridge blocks back into native function types.
auto bridgedFTy = dyn_cast<SILFunctionType>(loweredBridgedTy);
if (bridgedFTy
&& bridgedFTy->getRepresentation() == SILFunctionType::Representation::Block){
auto nativeFTy = cast<SILFunctionType>(loweredNativeTy);
if (nativeFTy->getRepresentation() != SILFunctionType::Representation::Block)
return gen.emitBlockToFunc(loc, v, nativeFTy);
}
// Bridge via _ObjectiveCBridgeable.
if (auto conformance =
gen.SGM.getConformanceToObjectiveCBridgeable(loc, loweredNativeTy)) {
if (auto result = emitBridgeObjectiveCToNative(gen, loc, v, conformance))
return *result;
assert(gen.SGM.getASTContext().Diags.hadAnyError() &&
"Bridging code should have complained");
return gen.emitUndef(loc, nativeTy);
}
return v;
}
static ManagedValue emitNativeToCBridgedNonoptionalValue(SILGenFunction &gen,
SILLocation loc,
ManagedValue v,
SILType bridgedTy) {
CanType loweredBridgedTy = bridgedTy.getSwiftRValueType();
CanType loweredNativeTy = v.getType().getSwiftRValueType();
if (loweredNativeTy == loweredBridgedTy)
return v;
// FIXME: Handle this via an _ObjectiveCBridgeable query rather than
// hardcoding String -> NSString.
if (loweredNativeTy == gen.SGM.Types.getStringType()
&& loweredBridgedTy == gen.SGM.Types.getNSStringType()) {
if (auto result = emitBridgeNativeToObjectiveC(gen, loc, v))
return *result;
return gen.emitUndef(loc, bridgedTy);
}
// If the input is a native type with a bridged mapping, convert it.
#define BRIDGE_TYPE(BridgedModule,BridgedType, NativeModule,NativeType,Opt) \
if (loweredNativeTy == gen.SGM.Types.get##NativeType##Type() \
&& loweredBridgedTy == gen.SGM.Types.get##BridgedType##Type()) { \
return emitBridge##NativeType##To##BridgedType(gen, loc, v); \
}
#include "swift/SIL/BridgedTypes.def"
// Bridge thick to Objective-C metatypes.
if (auto bridgedMetaTy = dyn_cast<AnyMetatypeType>(loweredBridgedTy)) {
if (bridgedMetaTy->getRepresentation() == MetatypeRepresentation::ObjC) {
SILValue native = gen.B.emitThickToObjCMetatype(loc, v.getValue(),
SILType::getPrimitiveObjectType(loweredBridgedTy));
return ManagedValue(native, v.getCleanup());
}
}
// Bridge native functions to blocks.
auto bridgedFTy = dyn_cast<SILFunctionType>(loweredBridgedTy);
if (bridgedFTy
&& bridgedFTy->getRepresentation() == SILFunctionType::Representation::Block){
auto nativeFTy = cast<SILFunctionType>(loweredNativeTy);
if (nativeFTy->getRepresentation() != SILFunctionType::Representation::Block)
return gen.emitFuncToBlock(loc, v, bridgedFTy);
}
// If the native type conforms to _ObjectiveCBridgeable, use its
// _bridgeToObjectiveC witness.
if (auto conformance =
gen.SGM.getConformanceToObjectiveCBridgeable(loc, loweredNativeTy)) {
if (auto result = emitBridgeNativeToObjectiveC(gen, loc, v, conformance))
return *result;
return gen.emitUndef(loc, bridgedTy);
}
return v;
}
static ManagedValue emitBridgeNSStringToString(SILGenFunction &gen,
SILLocation loc,
ManagedValue nsstr) {
SILValue bridgeFn =
gen.emitGlobalFunctionRef(loc, gen.SGM.getNSStringToStringFn());
Type inputType = nsstr.getType().getSwiftRValueType();
if (!inputType->getOptionalObjectType()) {
SILType loweredOptTy = gen.SGM.getLoweredType(OptionalType::get(inputType));
auto *someDecl = gen.getASTContext().getOptionalSomeDecl();
auto *enumInst = gen.B.createEnum(loc, nsstr.getValue(), someDecl,
loweredOptTy);
nsstr = ManagedValue(enumInst, nsstr.getCleanup());
}
SILType nativeTy = gen.getLoweredType(gen.SGM.Types.getStringType());
SILValue str = gen.B.createApply(loc, bridgeFn, bridgeFn.getType(), nativeTy,
{}, { nsstr.forward(gen) });
return gen.emitManagedRValueWithCleanup(str);
}
// FIXME: With some changes to their callers, all of the below functions
// could be re-worked to use emitInjectEnum().
ManagedValue
SILGenFunction::emitInjectOptional(SILLocation loc,
ManagedValue v,
CanType inputFormalType,
CanType substFormalType,
const TypeLowering &expectedTL,
SGFContext ctxt) {
// Optional's payload is currently maximally abstracted. FIXME: Eventually
// it shouldn't be.
auto opaque = AbstractionPattern::getOpaque();
OptionalTypeKind substOTK;
auto substObjectType = substFormalType.getAnyOptionalObjectType(substOTK);
auto loweredTy = getLoweredType(opaque, substObjectType);
if (v.getType() != loweredTy)
v = emitTransformedValue(loc, v,
AbstractionPattern(inputFormalType), inputFormalType,
opaque, substObjectType);
auto someDecl = getASTContext().getOptionalSomeDecl(substOTK);
SILType optTy = getLoweredType(substFormalType);
if (v.getType().isAddress()) {
auto buf = getBufferForExprResult(loc, optTy.getObjectType(), ctxt);
auto payload = B.createInitEnumDataAddr(loc, buf, someDecl,
v.getType());
// FIXME: Is it correct to use IsTake here even if v doesn't have a cleanup?
B.createCopyAddr(loc, v.forward(*this), payload,
IsTake, IsInitialization);
B.createInjectEnumAddr(loc, buf, someDecl);
v = manageBufferForExprResult(buf, expectedTL, ctxt);
} else {
auto some = B.createEnum(loc, v.getValue(), someDecl, optTy);
v = ManagedValue(some, v.getCleanup());
}
return v;
}
ManagedValue SILGenFunction::emitExistentialErasure(
SILLocation loc,
CanType concreteFormalType,
const TypeLowering &concreteTL,
const TypeLowering &existentialTL,
ArrayRef<ProtocolConformanceRef> conformances,
SGFContext C,
llvm::function_ref<ManagedValue (SGFContext)> F,
bool allowEmbeddedNSError) {
// Mark the needed conformances as used.
for (auto conformance : conformances)
SGM.useConformance(conformance);
// If we're erasing to the 'Error' type, we might be able to get an NSError
// representation more efficiently.
auto &ctx = getASTContext();
if (ctx.LangOpts.EnableObjCInterop && conformances.size() == 1 &&
conformances[0].getRequirement() == ctx.getErrorDecl() &&
ctx.getNSErrorDecl()) {
auto nsErrorDecl = ctx.getNSErrorDecl();
// If the concrete type is NSError or a subclass thereof, just erase it
// directly.
auto nsErrorType = nsErrorDecl->getDeclaredType()->getCanonicalType();
if (nsErrorType->isExactSuperclassOf(concreteFormalType, nullptr)) {
ManagedValue nsError = F(SGFContext());
if (nsErrorType != concreteFormalType) {
nsError = ManagedValue(B.createUpcast(loc, nsError.getValue(),
getLoweredType(nsErrorType)),
nsError.getCleanup());
}
return emitBridgedToNativeError(loc, nsError);
}
// If the concrete type is known to conform to _BridgedStoredNSError,
// call the _nsError witness getter to extract the NSError directly,
// then just erase the NSError.
if (auto storedNSErrorConformance =
SGM.getConformanceToBridgedStoredNSError(loc, concreteFormalType)) {
auto nsErrorVar = SGM.getNSErrorRequirement(loc);
if (!nsErrorVar) return emitUndef(loc, existentialTL.getLoweredType());
SubstitutionList nsErrorVarSubstitutions;
// Devirtualize. Maybe this should be done implicitly by
// emitPropertyLValue?
if (storedNSErrorConformance->isConcrete()) {
if (auto witnessVar = storedNSErrorConformance->getConcrete()
->getWitness(nsErrorVar, nullptr)) {
nsErrorVar = cast<VarDecl>(witnessVar.getDecl());
nsErrorVarSubstitutions = witnessVar.getSubstitutions();
}
}
auto nativeError = F(SGFContext());
WritebackScope writebackScope(*this);
auto nsError =
emitRValueForPropertyLoad(loc, nativeError, concreteFormalType,
/*super*/ false, nsErrorVar,
nsErrorVarSubstitutions,
AccessSemantics::Ordinary, nsErrorType,
SGFContext())
.getAsSingleValue(*this, loc);
return emitBridgedToNativeError(loc, nsError);
}
// Otherwise, if it's an archetype, try calling the _getEmbeddedNSError()
// witness to try to dig out the embedded NSError. But don't do this
// when we're being called recursively.
if (isa<ArchetypeType>(concreteFormalType) && allowEmbeddedNSError) {
auto contBB = createBasicBlock();
auto isNotPresentBB = createBasicBlock();
auto isPresentBB = createBasicBlock();
// Call swift_stdlib_getErrorEmbeddedNSError to attempt to extract an
// NSError from the value.
auto getEmbeddedNSErrorFn = SGM.getGetErrorEmbeddedNSError(loc);
if (!getEmbeddedNSErrorFn)
return emitUndef(loc, existentialTL.getLoweredType());
Substitution getEmbeddedNSErrorSubstitutions[1] = {
Substitution(concreteFormalType, conformances)
};
ManagedValue concreteValue = F(SGFContext());
ManagedValue potentialNSError =
emitApplyOfLibraryIntrinsic(loc,
getEmbeddedNSErrorFn,
getEmbeddedNSErrorSubstitutions,
{ concreteValue.copy(*this, loc) },
SGFContext())
.getAsSingleValue(*this, loc);
// We're going to consume 'concreteValue' in exactly one branch,
// so kill its cleanup now and recreate it on both branches.
(void) concreteValue.forward(*this);
// Check whether we got an NSError back.
std::pair<EnumElementDecl*, SILBasicBlock*> cases[] = {
{ ctx.getOptionalSomeDecl(), isPresentBB },
{ ctx.getOptionalNoneDecl(), isNotPresentBB }
};
B.createSwitchEnum(loc, potentialNSError.forward(*this),
/*default*/ nullptr, cases);
// If we did get an NSError, emit the existential erasure from that
// NSError.
B.emitBlock(isPresentBB);
SILValue branchArg;
{
// Don't allow cleanups to escape the conditional block.
FullExpr presentScope(Cleanups, CleanupLocation::get(loc));
enterDestroyCleanup(concreteValue.getValue());
// Receive the error value. It's typed as an 'AnyObject' for
// layering reasons, so perform an unchecked cast down to NSError.
SILType anyObjectTy =
potentialNSError.getType().getAnyOptionalObjectType();
SILValue nsError = isPresentBB->createPHIArgument(
anyObjectTy, ValueOwnershipKind::Owned);
nsError = B.createUncheckedRefCast(loc, nsError,
getLoweredType(nsErrorType));
branchArg = emitBridgedToNativeError(loc,
emitManagedRValueWithCleanup(nsError))
.forward(*this);
}
B.createBranch(loc, contBB, branchArg);
// If we did not get an NSError, just directly emit the existential.
// Since this is a recursive call, make sure we don't end up in this
// path again.
B.emitBlock(isNotPresentBB);
{
FullExpr presentScope(Cleanups, CleanupLocation::get(loc));
concreteValue = emitManagedRValueWithCleanup(concreteValue.getValue());
branchArg = emitExistentialErasure(loc, concreteFormalType, concreteTL,
existentialTL, conformances,
SGFContext(),
[&](SGFContext C) {
return concreteValue;
},
/*allowEmbeddedNSError=*/false)
.forward(*this);
}
B.createBranch(loc, contBB, branchArg);
// Continue.
B.emitBlock(contBB);
SILValue existentialResult = contBB->createPHIArgument(
existentialTL.getLoweredType(), ValueOwnershipKind::Owned);
return emitManagedRValueWithCleanup(existentialResult, existentialTL);
}
}
switch (existentialTL.getLoweredType().getObjectType()
.getPreferredExistentialRepresentation(SGM.M, concreteFormalType)) {
case ExistentialRepresentation::None:
llvm_unreachable("not an existential type");
case ExistentialRepresentation::Metatype: {
assert(existentialTL.isLoadable());
SILValue metatype = F(SGFContext()).getUnmanagedValue();
assert(metatype->getType().castTo<AnyMetatypeType>()->getRepresentation()
== MetatypeRepresentation::Thick);
auto upcast =
B.createInitExistentialMetatype(loc, metatype,
existentialTL.getLoweredType(),
conformances);
return ManagedValue::forUnmanaged(upcast);
}
case ExistentialRepresentation::Class: {
assert(existentialTL.isLoadable());
ManagedValue sub = F(SGFContext());
SILValue v = B.createInitExistentialRef(loc,
existentialTL.getLoweredType(),
concreteFormalType,
sub.getValue(),
conformances);
return ManagedValue(v, sub.getCleanup());
}
case ExistentialRepresentation::Boxed: {
// Allocate the existential.
auto *existential = B.createAllocExistentialBox(loc,
existentialTL.getLoweredType(),
concreteFormalType,
conformances);
auto *valueAddr = B.createProjectExistentialBox(loc,
concreteTL.getLoweredType(),
existential);
// Initialize the concrete value in-place.
ExistentialInitialization init(existential, valueAddr, concreteFormalType,
ExistentialRepresentation::Boxed, *this);
ManagedValue mv = F(SGFContext(&init));
if (!mv.isInContext()) {
mv.forwardInto(*this, loc, init.getAddress());
init.finishInitialization(*this);
}
return emitManagedRValueWithCleanup(existential);
}
case ExistentialRepresentation::Opaque: {
// If the concrete value is a pseudogeneric archetype, first erase it to
// its upper bound.
auto anyObjectProto = getASTContext()
.getProtocol(KnownProtocolKind::AnyObject);
auto anyObjectTy = anyObjectProto
? anyObjectProto->getDeclaredType()->getCanonicalType()
: CanType();
auto eraseToAnyObject =
[&, concreteFormalType, F](SGFContext C) -> ManagedValue {
auto concreteValue = F(SGFContext());
auto anyObjectConformance = SGM.SwiftModule
->lookupConformance(concreteFormalType, anyObjectProto, nullptr);
ProtocolConformanceRef buf[] = {
*anyObjectConformance,
};
auto asAnyObject = B.createInitExistentialRef(loc,
SILType::getPrimitiveObjectType(anyObjectTy),
concreteFormalType,
concreteValue.getValue(),
getASTContext().AllocateCopy(buf));
return ManagedValue(asAnyObject, concreteValue.getCleanup());
};
auto concreteTLPtr = &concreteTL;
if (this->F.getLoweredFunctionType()->isPseudogeneric()) {
if (anyObjectTy && concreteFormalType->is<ArchetypeType>()) {
concreteFormalType = anyObjectTy;
concreteTLPtr = &getTypeLowering(anyObjectTy);
F = eraseToAnyObject;
}
}
// Allocate the existential.
SILValue existential =
getBufferForExprResult(loc, existentialTL.getLoweredType(), C);
// Allocate the concrete value inside the container.
SILValue valueAddr = B.createInitExistentialAddr(
loc, existential,
concreteFormalType,
concreteTLPtr->getLoweredType(),
conformances);
// Initialize the concrete value in-place.
InitializationPtr init(
new ExistentialInitialization(existential, valueAddr, concreteFormalType,
ExistentialRepresentation::Opaque,
*this));
ManagedValue mv = F(SGFContext(init.get()));
if (!mv.isInContext()) {
mv.forwardInto(*this, loc, init->getAddress());
init->finishInitialization(*this);
}
return manageBufferForExprResult(existential, existentialTL, C);
}
}
llvm_unreachable("Unhandled ExistentialRepresentation in switch.");
}
ManagedValue SILGenFunction::emitExistentialErasure(
SILLocation loc,
CanType concreteFormalType,
const TypeLowering &concreteTL,
const TypeLowering &existentialTL,
ArrayRef<ProtocolConformanceRef> conformances,
SGFContext C,
llvm::function_ref<ManagedValue (SGFContext)> F,
bool allowEmbeddedNSError) {
// Mark the needed conformances as used.
for (auto conformance : conformances)
SGM.useConformance(conformance);
// If we're erasing to the 'Error' type, we might be able to get an NSError
// representation more efficiently.
auto &ctx = getASTContext();
auto nsError = ctx.getNSErrorDecl();
if (allowEmbeddedNSError && nsError &&
existentialTL.getSemanticType().getSwiftRValueType()->getAnyNominal() ==
ctx.getErrorDecl()) {
// Check whether the concrete type conforms to the _BridgedStoredNSError
// protocol. In that case, call the _nsError witness getter to extract the
// NSError directly.
auto conformance =
SGM.getConformanceToBridgedStoredNSError(loc, concreteFormalType);
CanType nsErrorType =
nsError->getDeclaredInterfaceType()->getCanonicalType();
ProtocolConformanceRef nsErrorConformances[1] = {
ProtocolConformanceRef(SGM.getNSErrorConformanceToError())
};
if (conformance && nsError && SGM.getNSErrorConformanceToError()) {
if (auto witness =
conformance->getWitness(SGM.getNSErrorRequirement(loc), nullptr)) {
// Create a reference to the getter witness.
SILDeclRef getter =
getGetterDeclRef(cast<VarDecl>(witness.getDecl()),
/*isDirectAccessorUse=*/true);
// Compute the substitutions.
ArrayRef<Substitution> substitutions =
concreteFormalType->gatherAllSubstitutions(
SGM.SwiftModule, nullptr);
// Emit the erasure, through the getter to _nsError.
return emitExistentialErasure(
loc, nsErrorType,
getTypeLowering(nsErrorType),
existentialTL,
ctx.AllocateCopy(nsErrorConformances),
C,
[&](SGFContext innerC) -> ManagedValue {
// Call the getter.
return emitGetAccessor(loc, getter, substitutions,
ArgumentSource(loc,
RValue(*this, loc,
concreteFormalType,
F(SGFContext()))),
/*isSuper=*/false,
/*isDirectAccessorUse=*/true,
RValue(), innerC)
.getAsSingleValue(*this, loc);
});
}
}
// Check whether the concrete type is an archetype. If so, call the
// _getEmbeddedNSError() witness to try to dig out the embedded NSError.
if (auto archetypeType = concreteFormalType->getAs<ArchetypeType>()) {
if (std::find(archetypeType->getConformsTo().begin(),
archetypeType->getConformsTo().end(),
ctx.getErrorDecl())
!= archetypeType->getConformsTo().end()) {
auto contBB = createBasicBlock();
auto isNotPresentBB = createBasicBlock();
auto isPresentBB = createBasicBlock();
SILValue existentialResult =
contBB->createBBArg(existentialTL.getLoweredType());
ProtocolConformanceRef trivialErrorConformances[1] = {
ProtocolConformanceRef(ctx.getErrorDecl())
};
Substitution substitutions[1] = {
Substitution(concreteFormalType,
ctx.AllocateCopy(trivialErrorConformances))
};
// Call swift_stdlib_getErrorEmbeddedNSError to attempt to extract an
// NSError from the value.
ManagedValue concreteValue = F(SGFContext());
ManagedValue potentialNSError =
emitApplyOfLibraryIntrinsic(loc,
SGM.getGetErrorEmbeddedNSError(loc),
ctx.AllocateCopy(substitutions),
{ concreteValue },
SGFContext())
.getAsSingleValue(*this, loc);
// Check whether we got an NSError back.
SILValue hasNSError =
emitDoesOptionalHaveValue(loc, potentialNSError.getValue());
B.createCondBranch(loc, hasNSError, isPresentBB, isNotPresentBB);
// If we did get an NSError, emit the existential erasure from that
// NSError.
B.emitBlock(isPresentBB);
SILValue branchArg;
{
// Don't allow cleanups to escape the conditional block.
FullExpr presentScope(Cleanups, CleanupLocation::get(loc));
// Emit the existential erasure from the NSError.
branchArg = emitExistentialErasure(
loc, nsErrorType,
getTypeLowering(nsErrorType),
existentialTL,
ctx.AllocateCopy(nsErrorConformances),
C,
[&](SGFContext innerC) -> ManagedValue {
// Pull the NSError object out of the optional result.
auto &inputTL = getTypeLowering(potentialNSError.getType());
auto nsErrorValue =
emitUncheckedGetOptionalValueFrom(loc, potentialNSError,
inputTL);
// Perform an unchecked cast down to NSError, because it was typed
// as 'AnyObject' for layering reasons.
return ManagedValue(B.createUncheckedRefCast(
loc,
nsErrorValue.getValue(),
getLoweredType(nsErrorType)),
nsErrorValue.getCleanup());
}).forward(*this);
}
B.createBranch(loc, contBB, branchArg);
// If we did not get an NSError, just directly emit the existential
// (recursively).
B.emitBlock(isNotPresentBB);
branchArg = emitExistentialErasure(loc, concreteFormalType, concreteTL,
existentialTL, conformances,
SGFContext(), F,
/*allowEmbeddedNSError=*/false)
.forward(*this);
B.createBranch(loc, contBB, branchArg);
// Continue.
B.emitBlock(contBB);
return emitManagedRValueWithCleanup(existentialResult, existentialTL);
}
}
}
switch (existentialTL.getLoweredType().getObjectType()
.getPreferredExistentialRepresentation(SGM.M, concreteFormalType)) {
case ExistentialRepresentation::None:
llvm_unreachable("not an existential type");
case ExistentialRepresentation::Metatype: {
assert(existentialTL.isLoadable());
SILValue metatype = F(SGFContext()).getUnmanagedValue();
assert(metatype->getType().castTo<AnyMetatypeType>()->getRepresentation()
== MetatypeRepresentation::Thick);
auto upcast =
B.createInitExistentialMetatype(loc, metatype,
existentialTL.getLoweredType(),
conformances);
return ManagedValue::forUnmanaged(upcast);
}
case ExistentialRepresentation::Class: {
assert(existentialTL.isLoadable());
ManagedValue sub = F(SGFContext());
SILValue v = B.createInitExistentialRef(loc,
existentialTL.getLoweredType(),
concreteFormalType,
sub.getValue(),
conformances);
return ManagedValue(v, sub.getCleanup());
}
case ExistentialRepresentation::Boxed: {
// Allocate the existential.
auto *existential = B.createAllocExistentialBox(loc,
existentialTL.getLoweredType(),
concreteFormalType,
conformances);
auto *valueAddr = B.createProjectExistentialBox(loc,
concreteTL.getLoweredType(),
existential);
// Initialize the concrete value in-place.
InitializationPtr init(
new ExistentialInitialization(existential, valueAddr, concreteFormalType,
ExistentialRepresentation::Boxed,
*this));
ManagedValue mv = F(SGFContext(init.get()));
if (!mv.isInContext()) {
mv.forwardInto(*this, loc, init->getAddress());
init->finishInitialization(*this);
}
return emitManagedRValueWithCleanup(existential);
}
case ExistentialRepresentation::Opaque: {
// Allocate the existential.
SILValue existential =
getBufferForExprResult(loc, existentialTL.getLoweredType(), C);
// Allocate the concrete value inside the container.
SILValue valueAddr = B.createInitExistentialAddr(
loc, existential,
concreteFormalType,
concreteTL.getLoweredType(),
conformances);
// Initialize the concrete value in-place.
InitializationPtr init(
new ExistentialInitialization(existential, valueAddr, concreteFormalType,
ExistentialRepresentation::Opaque,
*this));
ManagedValue mv = F(SGFContext(init.get()));
if (!mv.isInContext()) {
mv.forwardInto(*this, loc, init->getAddress());
init->finishInitialization(*this);
}
return manageBufferForExprResult(existential, existentialTL, C);
}
}
}
ManagedValue SILGenFunction::emitExistentialErasure(
SILLocation loc,
CanType concreteFormalType,
const TypeLowering &concreteTL,
const TypeLowering &existentialTL,
const ArrayRef<ProtocolConformance *> &conformances,
SGFContext C,
llvm::function_ref<ManagedValue (SGFContext)> F) {
// Mark the needed conformances as used.
for (auto *conformance : conformances)
SGM.useConformance(conformance);
switch (existentialTL.getLoweredType().getObjectType()
.getPreferredExistentialRepresentation(SGM.M, concreteFormalType)) {
case ExistentialRepresentation::None:
llvm_unreachable("not an existential type");
case ExistentialRepresentation::Metatype: {
assert(existentialTL.isLoadable());
SILValue metatype = F(SGFContext()).getUnmanagedValue();
assert(metatype.getType().castTo<AnyMetatypeType>()->getRepresentation()
== MetatypeRepresentation::Thick);
auto upcast =
B.createInitExistentialMetatype(loc, metatype,
existentialTL.getLoweredType(),
conformances);
return ManagedValue::forUnmanaged(upcast);
}
case ExistentialRepresentation::Class: {
assert(existentialTL.isLoadable());
ManagedValue sub = F(SGFContext());
SILValue v = B.createInitExistentialRef(loc,
existentialTL.getLoweredType(),
concreteFormalType,
sub.getValue(),
conformances);
return ManagedValue(v, sub.getCleanup());
}
case ExistentialRepresentation::Boxed: {
// Allocate the existential.
auto box = B.createAllocExistentialBox(loc,
existentialTL.getLoweredType(),
concreteFormalType,
concreteTL.getLoweredType(),
conformances);
auto existential = box->getExistentialResult();
auto valueAddr = box->getValueAddressResult();
// Initialize the concrete value in-place.
InitializationPtr init(
new ExistentialInitialization(existential, valueAddr, concreteFormalType,
ExistentialRepresentation::Boxed,
*this));
ManagedValue mv = F(SGFContext(init.get()));
if (!mv.isInContext()) {
mv.forwardInto(*this, loc, init->getAddress());
init->finishInitialization(*this);
}
return emitManagedRValueWithCleanup(existential);
}
case ExistentialRepresentation::Opaque: {
// Allocate the existential.
SILValue existential =
getBufferForExprResult(loc, existentialTL.getLoweredType(), C);
// Allocate the concrete value inside the container.
SILValue valueAddr = B.createInitExistentialAddr(
loc, existential,
concreteFormalType,
concreteTL.getLoweredType(),
conformances);
// Initialize the concrete value in-place.
InitializationPtr init(
new ExistentialInitialization(existential, valueAddr, concreteFormalType,
ExistentialRepresentation::Opaque,
*this));
ManagedValue mv = F(SGFContext(init.get()));
if (!mv.isInContext()) {
mv.forwardInto(*this, loc, init->getAddress());
init->finishInitialization(*this);
}
return manageBufferForExprResult(existential, existentialTL, C);
}
}
}
/// Bridge the given Objective-C object to its corresponding Swift
/// value, using the appropriate witness for the
/// _ObjectiveCBridgeable._unconditionallyBridgeFromObjectiveC requirement.
static Optional<ManagedValue>
emitBridgeObjectiveCToNative(SILGenFunction &gen,
SILLocation loc,
ManagedValue objcValue,
ProtocolConformance *conformance) {
// Find the _unconditionallyBridgeFromObjectiveC requirement.
auto requirement =
gen.SGM.getUnconditionallyBridgeFromObjectiveCRequirement(loc);
if (!requirement) return None;
// Retrieve the _unconditionallyBridgeFromObjectiveC witness.
auto witness = conformance->getWitness(requirement, nullptr);
assert(witness);
// Create a reference to the witness.
SILDeclRef witnessConstant(witness.getDecl());
auto witnessRef = gen.emitGlobalFunctionRef(loc, witnessConstant);
// Determine the substitutions.
ArrayRef<Substitution> substitutions;
auto witnessFnTy = witnessRef->getType().castTo<SILFunctionType>();
Type swiftValueType = conformance->getType();
if (auto valueTypeBGT = swiftValueType->getAs<BoundGenericType>()) {
// Compute the substitutions.
substitutions = valueTypeBGT->getSubstitutions(gen.SGM.SwiftModule,
nullptr);
}
// Substitute into the witness function type.
if (!substitutions.empty())
witnessFnTy = witnessFnTy->substGenericArgs(gen.SGM.M, gen.SGM.SwiftModule,
substitutions);
// If the Objective-C value isn't optional, wrap it in an optional.
Type objcValueType = objcValue.getType().getSwiftRValueType();
if (!objcValueType->getOptionalObjectType()) {
SILType loweredOptTy =
gen.SGM.getLoweredType(OptionalType::get(objcValueType));
auto *someDecl = gen.getASTContext().getOptionalSomeDecl();
auto *enumInst = gen.B.createEnum(loc, objcValue.getValue(), someDecl,
loweredOptTy);
objcValue = ManagedValue(enumInst, objcValue.getCleanup());
}
// Call the witness.
Type metatype = MetatypeType::get(swiftValueType);
SILValue metatypeValue = gen.B.createMetatype(loc,
gen.getLoweredType(metatype));
auto witnessCI = gen.getConstantInfo(witnessConstant);
CanType formalResultTy = witnessCI.LoweredInterfaceType.getResult();
// Set up the generic signature.
CanGenericSignature witnessGenericSignature;
if (auto genericSig =
cast<AbstractFunctionDecl>(witness.getDecl())->getGenericSignature())
witnessGenericSignature = genericSig->getCanonicalSignature();
GenericContextScope genericContextScope(gen.SGM.Types,
witnessGenericSignature);
return gen.emitApply(loc, ManagedValue::forUnmanaged(witnessRef),
substitutions,
{ objcValue, ManagedValue::forUnmanaged(metatypeValue) },
witnessFnTy,
AbstractionPattern(witnessGenericSignature,
formalResultTy),
swiftValueType->getCanonicalType(),
ApplyOptions::None, None, None,
SGFContext())
.getAsSingleValue(gen, loc);
}
static ManagedValue emitCBridgedToNativeValue(SILGenFunction &gen,
SILLocation loc,
ManagedValue v,
SILType nativeTy) {
CanType loweredNativeTy = nativeTy.getSwiftRValueType();
CanType loweredBridgedTy = v.getType().getSwiftRValueType();
if (loweredNativeTy == loweredBridgedTy)
return v;
if (loweredNativeTy.getAnyOptionalObjectType()) {
return gen.emitOptionalToOptional(loc, v, nativeTy,
emitCBridgedToNativeValue);
}
// Bridge Bool to ObjCBool or DarwinBoolean when requested.
if (loweredNativeTy == gen.SGM.Types.getBoolType()) {
if (loweredBridgedTy == gen.SGM.Types.getObjCBoolType()) {
return emitBridgeForeignBoolToBool(gen, loc, v,
gen.SGM.getObjCBoolToBoolFn());
}
if (loweredBridgedTy == gen.SGM.Types.getDarwinBooleanType()) {
return emitBridgeForeignBoolToBool(gen, loc, v,
gen.SGM.getDarwinBooleanToBoolFn());
}
}
// Bridge Objective-C to thick metatypes.
if (auto bridgedMetaTy = dyn_cast<AnyMetatypeType>(loweredBridgedTy)){
if (bridgedMetaTy->getRepresentation() == MetatypeRepresentation::ObjC) {
SILValue native = gen.B.emitObjCToThickMetatype(loc, v.getValue(),
gen.getLoweredType(loweredNativeTy));
return ManagedValue(native, v.getCleanup());
}
}
// Bridge blocks back into native function types.
auto bridgedFTy = dyn_cast<SILFunctionType>(loweredBridgedTy);
if (bridgedFTy
&& bridgedFTy->getRepresentation() == SILFunctionType::Representation::Block){
auto nativeFTy = cast<SILFunctionType>(loweredNativeTy);
if (nativeFTy->getRepresentation() != SILFunctionType::Representation::Block)
return gen.emitBlockToFunc(loc, v, nativeFTy);
}
// Bridge NSString to String.
if (auto stringDecl = gen.getASTContext().getStringDecl()) {
if (nativeTy.getSwiftRValueType()->getAnyNominal() == stringDecl) {
return emitBridgeNSStringToString(gen, loc, v);
}
}
// Bridge NSArray to Array.
if (auto arrayDecl = gen.getASTContext().getArrayDecl()) {
if (nativeTy.getSwiftRValueType()->getAnyNominal() == arrayDecl) {
SILDeclRef bridgeFn = gen.SGM.getNSArrayToArrayFn();
return emitBridgeCollectionToNative(gen, loc, bridgeFn, v, nativeTy);
}
}
// Bridge NSDictionary to Dictionary.
if (auto dictDecl = gen.getASTContext().getDictionaryDecl()) {
if (nativeTy.getSwiftRValueType()->getAnyNominal() == dictDecl) {
SILDeclRef bridgeFn = gen.SGM.getNSDictionaryToDictionaryFn();
return emitBridgeCollectionToNative(gen, loc, bridgeFn, v, nativeTy);
}
}
// Bridge NSSet to Set.
if (auto setDecl = gen.getASTContext().getSetDecl()) {
if (nativeTy.getSwiftRValueType()->getAnyNominal() == setDecl) {
SILDeclRef bridgeFn = gen.SGM.getNSSetToSetFn();
return emitBridgeCollectionToNative(gen, loc, bridgeFn, v, nativeTy);
}
}
return v;
}
static ManagedValue emitNativeToCBridgedNonoptionalValue(SILGenFunction &gen,
SILLocation loc,
ManagedValue v,
SILType bridgedTy) {
CanType loweredBridgedTy = bridgedTy.getSwiftRValueType();
CanType loweredNativeTy = v.getType().getSwiftRValueType();
if (loweredNativeTy == loweredBridgedTy)
return v;
// If the input is a native type with a bridged mapping, convert it.
#define BRIDGE_TYPE(BridgedModule,BridgedType, NativeModule,NativeType,Opt) \
if (loweredNativeTy == gen.SGM.Types.get##NativeType##Type() \
&& loweredBridgedTy == gen.SGM.Types.get##BridgedType##Type()) { \
return emitBridge##NativeType##To##BridgedType(gen, loc, v); \
}
#include "swift/SIL/BridgedTypes.def"
// Bridge thick to Objective-C metatypes.
if (auto bridgedMetaTy = dyn_cast<AnyMetatypeType>(loweredBridgedTy)) {
if (bridgedMetaTy->getRepresentation() == MetatypeRepresentation::ObjC) {
SILValue native = gen.B.emitThickToObjCMetatype(loc, v.getValue(),
SILType::getPrimitiveObjectType(loweredBridgedTy));
return ManagedValue(native, v.getCleanup());
}
}
// Bridge native functions to blocks.
auto bridgedFTy = dyn_cast<SILFunctionType>(loweredBridgedTy);
if (bridgedFTy
&& bridgedFTy->getRepresentation() == SILFunctionType::Representation::Block){
auto nativeFTy = cast<SILFunctionType>(loweredNativeTy);
if (nativeFTy->getRepresentation() != SILFunctionType::Representation::Block)
return gen.emitFuncToBlock(loc, v, bridgedFTy);
}
// Bridge Array to NSArray.
if (auto arrayDecl = gen.getASTContext().getArrayDecl()) {
if (v.getType().getSwiftRValueType().getAnyNominal() == arrayDecl) {
SILDeclRef bridgeFn = gen.SGM.getArrayToNSArrayFn();
return emitBridgeCollectionFromNative(gen, loc, bridgeFn, v, bridgedTy);
}
}
// Bridge Dictionary to NSDictionary.
if (auto dictDecl = gen.getASTContext().getDictionaryDecl()) {
if (v.getType().getSwiftRValueType().getAnyNominal() == dictDecl) {
SILDeclRef bridgeFn = gen.SGM.getDictionaryToNSDictionaryFn();
return emitBridgeCollectionFromNative(gen, loc, bridgeFn, v, bridgedTy);
}
}
// Bridge Set to NSSet.
if (auto setDecl = gen.getASTContext().getSetDecl()) {
if (v.getType().getSwiftRValueType().getAnyNominal() == setDecl) {
SILDeclRef bridgeFn = gen.SGM.getSetToNSSetFn();
return emitBridgeCollectionFromNative(gen, loc, bridgeFn, v, bridgedTy);
}
}
return v;
}
void SILGenFunction::emitClassConstructorInitializer(ConstructorDecl *ctor) {
MagicFunctionName = SILGenModule::getMagicFunctionName(ctor);
assert(ctor->getBody() && "Class constructor without a body?");
// True if this constructor delegates to a peer constructor with self.init().
bool isDelegating = false;
if (!ctor->hasStubImplementation()) {
isDelegating = ctor->getDelegatingOrChainedInitKind(nullptr) ==
ConstructorDecl::BodyInitKind::Delegating;
}
// Set up the 'self' argument. If this class has a superclass, we set up
// self as a box. This allows "self reassignment" to happen in super init
// method chains, which is important for interoperating with Objective-C
// classes. We also use a box for delegating constructors, since the
// delegated-to initializer may also replace self.
//
// TODO: If we could require Objective-C classes to have an attribute to get
// this behavior, we could avoid runtime overhead here.
VarDecl *selfDecl = ctor->getImplicitSelfDecl();
auto *dc = ctor->getDeclContext();
auto selfClassDecl = dc->getAsClassOrClassExtensionContext();
bool NeedsBoxForSelf = isDelegating ||
(selfClassDecl->hasSuperclass() && !ctor->hasStubImplementation());
bool usesObjCAllocator = Lowering::usesObjCAllocator(selfClassDecl);
// If needed, mark 'self' as uninitialized so that DI knows to
// enforce its DI properties on stored properties.
MarkUninitializedInst::Kind MUKind;
if (isDelegating)
MUKind = MarkUninitializedInst::DelegatingSelf;
else if (selfClassDecl->requiresStoredPropertyInits() &&
usesObjCAllocator) {
// Stored properties will be initialized in a separate
// .cxx_construct method called by the Objective-C runtime.
assert(selfClassDecl->hasSuperclass() &&
"Cannot use ObjC allocation without a superclass");
MUKind = MarkUninitializedInst::DerivedSelfOnly;
} else if (selfClassDecl->hasSuperclass())
MUKind = MarkUninitializedInst::DerivedSelf;
else
MUKind = MarkUninitializedInst::RootSelf;
if (NeedsBoxForSelf) {
// Allocate the local variable for 'self'.
emitLocalVariableWithCleanup(selfDecl, MUKind)->finishInitialization(*this);
}
// Emit the prolog for the non-self arguments.
// FIXME: Handle self along with the other body patterns.
uint16_t ArgNo = emitProlog(ctor->getParameterList(1),
TupleType::getEmpty(F.getASTContext()), ctor,
ctor->hasThrows());
SILType selfTy = getLoweredLoadableType(selfDecl->getType());
ManagedValue selfArg = B.createInputFunctionArgument(selfTy, selfDecl);
if (!NeedsBoxForSelf) {
SILLocation PrologueLoc(selfDecl);
PrologueLoc.markAsPrologue();
SILDebugVariable DbgVar(selfDecl->isLet(), ++ArgNo);
B.createDebugValue(PrologueLoc, selfArg.getValue(), DbgVar);
}
if (!ctor->hasStubImplementation()) {
assert(selfTy.hasReferenceSemantics() &&
"can't emit a value type ctor here");
if (NeedsBoxForSelf) {
SILLocation prologueLoc = RegularLocation(ctor);
prologueLoc.markAsPrologue();
// SEMANTIC ARC TODO: When the verifier is complete, review this.
B.emitStoreValueOperation(prologueLoc, selfArg.forward(*this),
VarLocs[selfDecl].value,
StoreOwnershipQualifier::Init);
} else {
selfArg = B.createMarkUninitialized(selfDecl, selfArg, MUKind);
VarLocs[selfDecl] = VarLoc::get(selfArg.getValue());
}
}
// Prepare the end of initializer location.
SILLocation endOfInitLoc = RegularLocation(ctor);
endOfInitLoc.pointToEnd();
// Create a basic block to jump to for the implicit 'self' return.
// We won't emit the block until after we've emitted the body.
prepareEpilog(Type(), ctor->hasThrows(),
CleanupLocation::get(endOfInitLoc));
auto resultType = ctor->mapTypeIntoContext(ctor->getResultInterfaceType());
// If the constructor can fail, set up an alternative epilog for constructor
// failure.
SILBasicBlock *failureExitBB = nullptr;
SILArgument *failureExitArg = nullptr;
auto &resultLowering = getTypeLowering(resultType);
if (ctor->getFailability() != OTK_None) {
SILBasicBlock *failureBB = createBasicBlock(FunctionSection::Postmatter);
RegularLocation loc(ctor);
loc.markAutoGenerated();
// On failure, we'll clean up everything and return nil instead.
SILGenSavedInsertionPoint savedIP(*this, failureBB,
FunctionSection::Postmatter);
failureExitBB = createBasicBlock();
failureExitArg = failureExitBB->createPHIArgument(
resultLowering.getLoweredType(), ValueOwnershipKind::Owned);
Cleanups.emitCleanupsForReturn(ctor);
SILValue nilResult =
B.createEnum(loc, SILValue(), getASTContext().getOptionalNoneDecl(),
resultLowering.getLoweredType());
B.createBranch(loc, failureExitBB, nilResult);
B.setInsertionPoint(failureExitBB);
B.createReturn(loc, failureExitArg);
FailDest = JumpDest(failureBB, Cleanups.getCleanupsDepth(), ctor);
}
// Handle member initializers.
if (isDelegating) {
// A delegating initializer does not initialize instance
// variables.
} else if (ctor->hasStubImplementation()) {
// Nor does a stub implementation.
} else if (selfClassDecl->requiresStoredPropertyInits() &&
usesObjCAllocator) {
// When the class requires all stored properties to have initial
// values and we're using Objective-C's allocation, stored
// properties are initialized via the .cxx_construct method, which
// will be called by the runtime.
// Note that 'self' has been fully initialized at this point.
} else {
// Emit the member initializers.
emitMemberInitializers(ctor, selfDecl, selfClassDecl);
}
emitProfilerIncrement(ctor->getBody());
// Emit the constructor body.
emitStmt(ctor->getBody());
// Emit the call to super.init() right before exiting from the initializer.
if (NeedsBoxForSelf) {
if (auto *SI = ctor->getSuperInitCall()) {
B.setInsertionPoint(ReturnDest.getBlock());
emitRValue(SI);
B.emitBlock(B.splitBlockForFallthrough(), ctor);
ReturnDest = JumpDest(B.getInsertionBB(),
ReturnDest.getDepth(),
ReturnDest.getCleanupLocation());
B.clearInsertionPoint();
}
}
CleanupStateRestorationScope SelfCleanupSave(Cleanups);
// Build a custom epilog block, since the AST representation of the
// constructor decl (which has no self in the return type) doesn't match the
// SIL representation.
{
// Ensure that before we add additional cleanups, that we have emitted all
// cleanups at this point.
assert(!Cleanups.hasAnyActiveCleanups(getCleanupsDepth(),
ReturnDest.getDepth()) &&
"emitting epilog in wrong scope");
SILGenSavedInsertionPoint savedIP(*this, ReturnDest.getBlock());
auto cleanupLoc = CleanupLocation(ctor);
// If we're using a box for self, reload the value at the end of the init
// method.
if (NeedsBoxForSelf) {
ManagedValue storedSelf =
ManagedValue::forUnmanaged(VarLocs[selfDecl].value);
selfArg = B.createLoadCopy(cleanupLoc, storedSelf);
} else {
// We have to do a retain because we are returning the pointer +1.
//
// SEMANTIC ARC TODO: When the verifier is complete, we will need to
// change this to selfArg = B.emitCopyValueOperation(...). Currently due
// to the way that SILGen performs folding of copy_value, destroy_value,
// the returned selfArg may be deleted causing us to have a
// dead-pointer. Instead just use the old self value since we have a
// class.
selfArg = B.createCopyValue(cleanupLoc, selfArg);
}
// Inject the self value into an optional if the constructor is failable.
if (ctor->getFailability() != OTK_None) {
RegularLocation loc(ctor);
loc.markAutoGenerated();
selfArg = B.createEnum(loc, selfArg,
getASTContext().getOptionalSomeDecl(),
getLoweredLoadableType(resultType));
}
// Save our cleanup state. We want all other potential cleanups to fire, but
// not this one.
if (selfArg.hasCleanup())
SelfCleanupSave.pushCleanupState(selfArg.getCleanup(),
CleanupState::Dormant);
// Translate our cleanup to the new top cleanup.
//
// This is needed to preserve the invariant in getEpilogBB that when
// cleanups are emitted, everything above ReturnDest.getDepth() has been
// emitted. This is not true if we use ManagedValue and friends in the
// epilogBB, thus the translation. We perform the same check above that
// getEpilogBB performs to ensure that we still do not have the same
// problem.
ReturnDest = std::move(ReturnDest).translate(getTopCleanup());
}
// Emit the epilog and post-matter.
auto returnLoc = emitEpilog(ctor, /*UsesCustomEpilog*/true);
// Unpop our selfArg cleanup, so we can forward.
std::move(SelfCleanupSave).pop();
// Finish off the epilog by returning. If this is a failable ctor, then we
// actually jump to the failure epilog to keep the invariant that there is
// only one SIL return instruction per SIL function.
if (B.hasValidInsertionPoint()) {
if (failureExitBB)
B.createBranch(returnLoc, failureExitBB, selfArg.forward(*this));
else
B.createReturn(returnLoc, selfArg.forward(*this));
}
}
