averello/swift-mirror
1
0
Fork 0
mirror of https://github.com/apple/swift.git synced 2025-12-14 20:36:38 +01:00
Code Issues Packages Projects Releases Wiki Activity
Files
weird-codegen
swift-mirror/lib/SILGen/SILGenBuiltin.cpp
Alejandro Alonso 0f30cdfb31 Allow Builtin.emplace to have typed throws
2025-01-08 10:37:16 -08:00

2247 lines
98 KiB
C++
Raw Permalink Blame History

//===--- SILGenBuiltin.cpp - SIL generation for builtin call sites -------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
#include "SpecializedEmitter.h"
#include "ArgumentSource.h"
#include "Cleanup.h"
#include "Conversion.h"
#include "Initialization.h"
#include "LValue.h"
#include "RValue.h"
#include "Scope.h"
#include "SILGenFunction.h"
#include "swift/AST/ASTContext.h"
#include "swift/AST/Builtins.h"
#include "swift/AST/DiagnosticsSIL.h"
#include "swift/AST/DistributedDecl.h"
#include "swift/AST/FileUnit.h"
#include "swift/AST/GenericEnvironment.h"
#include "swift/AST/Module.h"
#include "swift/AST/ProtocolConformance.h"
#include "swift/AST/ReferenceCounting.h"
#include "swift/Basic/Assertions.h"
#include "swift/SIL/SILArgument.h"
#include "swift/SIL/SILUndef.h"
#include "swift/AST/TypeCheckRequests.h" // FIXME: Temporary
#include "swift/AST/NameLookupRequests.h" // FIXME: Temporary
using namespace swift;
using namespace Lowering;
/// Break down an expression that's the formal argument expression to
/// a builtin function, returning its individualized arguments.
///
/// Because these are builtin operations, we can make some structural
/// assumptions about the expression used to call them.
static std::optional<SmallVector<Expr *, 2>>
decomposeArguments(SILGenFunction &SGF, SILLocation loc,
PreparedArguments &&args, unsigned expectedCount) {
SmallVector<Expr*, 2> result;
auto sources = std::move(args).getSources();
if (sources.size() == expectedCount) {
for (auto &&source : sources)
result.push_back(std::move(source).asKnownExpr());
return result;
}
SGF.SGM.diagnose(loc, diag::invalid_sil_builtin,
"argument to builtin should be a literal tuple");
return std::nullopt;
}
static ManagedValue emitBuiltinRetain(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap substitutions,
ArrayRef<ManagedValue> args,
SGFContext C) {
// The value was produced at +1; we can produce an unbalanced retain simply by
// disabling the cleanup. But this would violate ownership semantics. Instead,
// we must allow for the cleanup and emit a new unmanaged retain value.
SGF.B.createUnmanagedRetainValue(loc, args[0].getValue(),
SGF.B.getDefaultAtomicity());
return ManagedValue::forObjectRValueWithoutOwnership(SGF.emitEmptyTuple(loc));
}
static ManagedValue emitBuiltinRelease(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap substitutions,
ArrayRef<ManagedValue> args,
SGFContext C) {
// The value was produced at +1, so to produce an unbalanced
// release we need to leave the cleanup intact and then do a *second*
// release.
SGF.B.createUnmanagedReleaseValue(loc, args[0].getValue(),
SGF.B.getDefaultAtomicity());
return ManagedValue::forObjectRValueWithoutOwnership(SGF.emitEmptyTuple(loc));
}
static ManagedValue emitBuiltinAutorelease(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap substitutions,
ArrayRef<ManagedValue> args,
SGFContext C) {
SGF.B.createUnmanagedAutoreleaseValue(loc, args[0].getValue(),
SGF.B.getDefaultAtomicity());
return ManagedValue::forObjectRValueWithoutOwnership(SGF.emitEmptyTuple(loc));
}
/// Specialized emitter for Builtin.load and Builtin.take.
static ManagedValue emitBuiltinLoadOrTake(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap substitutions,
ArrayRef<ManagedValue> args,
SGFContext C,
IsTake_t isTake,
bool isStrict,
bool isInvariant,
llvm::MaybeAlign align) {
assert(substitutions.getReplacementTypes().size() == 1 &&
"load should have single substitution");
assert(args.size() == 1 && "load should have a single argument");
// The substitution gives the type of the load. This is always a
// first-class type; there is no way to e.g. produce a @weak load
// with this builtin.
auto &rvalueTL = SGF.getTypeLowering(substitutions.getReplacementTypes()[0]);
SILType loadedType = rvalueTL.getLoweredType();
// Convert the pointer argument to a SIL address.
//
// Default to an unaligned pointer. This can be optimized in the presence of
// Builtin.assumeAlignment.
SILValue addr = SGF.B.createPointerToAddress(loc, args[0].getUnmanagedValue(),
loadedType.getAddressType(),
isStrict, isInvariant, align);
// Perform the load.
return SGF.emitLoad(loc, addr, rvalueTL, C, isTake);
}
static ManagedValue emitBuiltinLoad(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap substitutions,
ArrayRef<ManagedValue> args,
SGFContext C) {
// Regular loads assume natural alignment.
return emitBuiltinLoadOrTake(SGF, loc, substitutions, args,
C, IsNotTake,
/*isStrict*/ true, /*isInvariant*/ false,
llvm::MaybeAlign());
}
static ManagedValue emitBuiltinLoadRaw(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap substitutions,
ArrayRef<ManagedValue> args,
SGFContext C) {
// Raw loads cannot assume alignment.
return emitBuiltinLoadOrTake(SGF, loc, substitutions, args,
C, IsNotTake,
/*isStrict*/ false, /*isInvariant*/ false,
llvm::MaybeAlign(1));
}
static ManagedValue emitBuiltinLoadInvariant(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap substitutions,
ArrayRef<ManagedValue> args,
SGFContext C) {
// Regular loads assume natural alignment.
return emitBuiltinLoadOrTake(SGF, loc, substitutions, args,
C, IsNotTake,
/*isStrict*/ false, /*isInvariant*/ true,
llvm::MaybeAlign());
}
static ManagedValue emitBuiltinTake(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap substitutions,
ArrayRef<ManagedValue> args,
SGFContext C) {
// Regular loads assume natural alignment.
return emitBuiltinLoadOrTake(SGF, loc, substitutions, args,
C, IsTake,
/*isStrict*/ true, /*isInvariant*/ false,
llvm::MaybeAlign());
}
/// Specialized emitter for Builtin.destroy.
static ManagedValue emitBuiltinDestroy(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap substitutions,
ArrayRef<ManagedValue> args,
SGFContext C) {
assert(args.size() == 2 && "destroy should have two arguments");
assert(substitutions.getReplacementTypes().size() == 1 &&
"destroy should have a single substitution");
// The substitution determines the type of the thing we're destroying.
auto &ti = SGF.getTypeLowering(substitutions.getReplacementTypes()[0]);
// Destroy is a no-op for trivial types.
if (ti.isTrivial())
return ManagedValue::forObjectRValueWithoutOwnership(
SGF.emitEmptyTuple(loc));
SILType destroyType = ti.getLoweredType();
// Convert the pointer argument to a SIL address.
SILValue addr =
SGF.B.createPointerToAddress(loc, args[1].getUnmanagedValue(),
destroyType.getAddressType(),
/*isStrict*/ true,
/*isInvariant*/ false);
// Destroy the value indirectly. Canonicalization will promote to loads
// and releases if appropriate.
SGF.B.createDestroyAddr(loc, addr);
return ManagedValue::forObjectRValueWithoutOwnership(SGF.emitEmptyTuple(loc));
}
static ManagedValue emitBuiltinStore(SILGenFunction &SGF, SILLocation loc,
SubstitutionMap substitutions,
ArrayRef<ManagedValue> args, SGFContext C,
bool isStrict, bool isInvariant,
llvm::MaybeAlign alignment) {
assert(args.size() >= 2 && "should have two arguments");
assert(substitutions.getReplacementTypes().size() == 1 &&
"should have a single substitution");
// The substitution determines the type of the thing we're destroying.
CanType formalTy = substitutions.getReplacementTypes()[0]->getCanonicalType();
SILType loweredTy = SGF.getLoweredType(formalTy);
// Convert the destination pointer argument to a SIL address.
SILValue addr = SGF.B.createPointerToAddress(
loc, args.back().getUnmanagedValue(), loweredTy.getAddressType(),
isStrict, isInvariant, alignment);
// Build the value to be stored, reconstructing tuples if needed.
auto src = RValue(SGF, args.slice(0, args.size() - 1), formalTy);
std::move(src).ensurePlusOne(SGF, loc).assignInto(SGF, loc, addr);
return ManagedValue::forObjectRValueWithoutOwnership(SGF.emitEmptyTuple(loc));
}
static ManagedValue emitBuiltinAssign(SILGenFunction &SGF, SILLocation loc,
SubstitutionMap substitutions,
ArrayRef<ManagedValue> args,
SGFContext C) {
return emitBuiltinStore(SGF, loc, substitutions, args, C, /*isStrict=*/true,
/*isInvariant=*/false, llvm::MaybeAlign());
}
static ManagedValue emitBuiltinStoreRaw(SILGenFunction &SGF, SILLocation loc,
SubstitutionMap substitutions,
ArrayRef<ManagedValue> args,
SGFContext C) {
return emitBuiltinStore(SGF, loc, substitutions, args, C, /*isStrict=*/false,
/*isInvariant=*/false, llvm::MaybeAlign(1));
}
/// Emit Builtin.initialize by evaluating the operand directly into
/// the address.
static ManagedValue emitBuiltinInit(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap substitutions,
PreparedArguments &&preparedArgs,
SGFContext C) {
auto argsOrError = decomposeArguments(SGF, loc, std::move(preparedArgs), 2);
if (!argsOrError)
return ManagedValue::forObjectRValueWithoutOwnership(
SGF.emitEmptyTuple(loc));
auto args = *argsOrError;
CanType formalType =
substitutions.getReplacementTypes()[0]->getCanonicalType();
auto &formalTL = SGF.getTypeLowering(formalType);
SILValue addr = SGF.emitRValueAsSingleValue(args[1]).getUnmanagedValue();
addr = SGF.B.createPointerToAddress(
loc, addr, formalTL.getLoweredType().getAddressType(),
/*isStrict*/ true,
/*isInvariant*/ false);
TemporaryInitialization init(addr, CleanupHandle::invalid());
SGF.emitExprInto(args[0], &init);
return ManagedValue::forObjectRValueWithoutOwnership(SGF.emitEmptyTuple(loc));
}
/// Specialized emitter for Builtin.fixLifetime.
static ManagedValue emitBuiltinFixLifetime(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap substitutions,
ArrayRef<ManagedValue> args,
SGFContext C) {
for (auto arg : args) {
SGF.B.createFixLifetime(loc, arg.getValue());
}
return ManagedValue::forObjectRValueWithoutOwnership(SGF.emitEmptyTuple(loc));
}
static ManagedValue emitCastToReferenceType(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap substitutions,
ArrayRef<ManagedValue> args,
SGFContext C,
SILType objPointerType) {
assert(args.size() == 1 && "cast should have a single argument");
assert(substitutions.getReplacementTypes().size() == 1 &&
"cast should have a type substitution");
// Bail if the source type is not a class reference of some kind.
Type argTy = substitutions.getReplacementTypes()[0];
if (!argTy->mayHaveSuperclass() && !argTy->isClassExistentialType()) {
SGF.SGM.diagnose(loc, diag::invalid_sil_builtin,
"castToNativeObject source must be a class");
return SGF.emitUndef(objPointerType);
}
// Grab the argument.
ManagedValue arg = args[0];
// If the argument is existential, open it.
if (argTy->isClassExistentialType()) {
auto openedTy =
OpenedArchetypeType::get(argTy->getCanonicalType());
SILType loweredOpenedTy = SGF.getLoweredLoadableType(openedTy);
arg = SGF.B.createOpenExistentialRef(loc, arg, loweredOpenedTy);
}
// Return the cast result.
return SGF.B.createUncheckedRefCast(loc, arg, objPointerType);
}
/// Specialized emitter for Builtin.unsafeCastToNativeObject.
static ManagedValue emitBuiltinUnsafeCastToNativeObject(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap substitutions,
ArrayRef<ManagedValue> args,
SGFContext C) {
return emitCastToReferenceType(SGF, loc, substitutions, args, C,
SILType::getNativeObjectType(SGF.F.getASTContext()));
}
/// Specialized emitter for Builtin.castToNativeObject.
static ManagedValue emitBuiltinCastToNativeObject(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap substitutions,
ArrayRef<ManagedValue> args,
SGFContext C) {
auto ty = args[0].getType().getASTType();
(void)ty;
assert(ty->getReferenceCounting() == ReferenceCounting::Native &&
"Can only cast types that use native reference counting to native "
"object");
return emitBuiltinUnsafeCastToNativeObject(SGF, loc, substitutions,
args, C);
}
static ManagedValue emitCastFromReferenceType(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap substitutions,
ArrayRef<ManagedValue> args,
SGFContext C) {
assert(args.size() == 1 && "cast should have a single argument");
assert(substitutions.getReplacementTypes().size() == 1 &&
"cast should have a single substitution");
// The substitution determines the destination type.
SILType destType =
SGF.getLoweredType(substitutions.getReplacementTypes()[0]);
// Bail if the source type is not a class reference of some kind.
if (!substitutions.getReplacementTypes()[0]->isBridgeableObjectType()
|| !destType.isObject()) {
SGF.SGM.diagnose(loc, diag::invalid_sil_builtin,
"castFromNativeObject dest must be an object type");
// Recover by propagating an undef result.
return SGF.emitUndef(destType);
}
return SGF.B.createUncheckedRefCast(loc, args[0], destType);
}
/// Specialized emitter for Builtin.castFromNativeObject.
static ManagedValue emitBuiltinCastFromNativeObject(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap substitutions,
ArrayRef<ManagedValue> args,
SGFContext C) {
return emitCastFromReferenceType(SGF, loc, substitutions, args, C);
}
/// Specialized emitter for Builtin.bridgeToRawPointer.
static ManagedValue emitBuiltinBridgeToRawPointer(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap substitutions,
ArrayRef<ManagedValue> args,
SGFContext C) {
assert(args.size() == 1 && "bridge should have a single argument");
// Take the reference type argument and cast it to RawPointer.
// RawPointers do not have ownership semantics, so the cleanup on the
// argument remains.
SILType rawPointerType = SILType::getRawPointerType(SGF.F.getASTContext());
SILValue result = SGF.B.createRefToRawPointer(loc, args[0].getValue(),
rawPointerType);
return ManagedValue::forObjectRValueWithoutOwnership(result);
}
/// Specialized emitter for Builtin.bridgeFromRawPointer.
static ManagedValue emitBuiltinBridgeFromRawPointer(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap substitutions,
ArrayRef<ManagedValue> args,
SGFContext C) {
assert(substitutions.getReplacementTypes().size() == 1 &&
"bridge should have a single substitution");
assert(args.size() == 1 && "bridge should have a single argument");
// The substitution determines the destination type.
// FIXME: Archetype destination type?
auto &destLowering =
SGF.getTypeLowering(substitutions.getReplacementTypes()[0]);
assert(destLowering.isLoadable());
SILType destType = destLowering.getLoweredType();
// Take the raw pointer argument and cast it to the destination type.
SILValue result = SGF.B.createRawPointerToRef(loc, args[0].getUnmanagedValue(),
destType);
// The result has ownership semantics, so retain it with a cleanup.
return SGF.emitManagedCopy(loc, result, destLowering);
}
static ManagedValue emitBuiltinAddressOfBuiltins(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap substitutions,
PreparedArguments &&preparedArgs,
SGFContext C, bool stackProtected) {
SILType rawPointerType = SILType::getRawPointerType(SGF.getASTContext());
auto argsOrError = decomposeArguments(SGF, loc, std::move(preparedArgs), 1);
if (!argsOrError)
return SGF.emitUndef(rawPointerType);
auto argument = (*argsOrError)[0];
// If the argument is inout, try forming its lvalue. This builtin only works
// if it's trivially physically projectable.
auto inout = cast<InOutExpr>(argument->getSemanticsProvidingExpr());
auto lv = SGF.emitLValue(inout->getSubExpr(), SGFAccessKind::ReadWrite);
if (!lv.isPhysical() || !lv.isLoadingPure()) {
SGF.SGM.diagnose(argument->getLoc(), diag::non_physical_addressof);
return SGF.emitUndef(rawPointerType);
}
auto addr = SGF.emitAddressOfLValue(argument, std::move(lv))
.getLValueAddress();
// Take the address argument and cast it to RawPointer.
SILValue result = SGF.B.createAddressToPointer(loc, addr, rawPointerType,
stackProtected);
return ManagedValue::forObjectRValueWithoutOwnership(result);
}
/// Specialized emitter for Builtin.addressof.
static ManagedValue emitBuiltinAddressOf(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap substitutions,
PreparedArguments &&preparedArgs,
SGFContext C) {
return emitBuiltinAddressOfBuiltins(SGF, loc, substitutions, std::move(preparedArgs), C,
/*stackProtected=*/ true);
}
static ManagedValue emitBuiltinUnprotectedAddressOf(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap substitutions,
PreparedArguments &&preparedArgs,
SGFContext C) {
return emitBuiltinAddressOfBuiltins(SGF, loc, substitutions, std::move(preparedArgs), C,
/*stackProtected=*/ false);
}
/// Specialized emitter for Builtin.addressOfBorrow.
static ManagedValue emitBuiltinAddressOfBorrowBuiltins(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap substitutions,
PreparedArguments &&preparedArgs,
SGFContext C, bool stackProtected) {
SILType rawPointerType = SILType::getRawPointerType(SGF.getASTContext());
auto argsOrError = decomposeArguments(SGF, loc, std::move(preparedArgs), 1);
if (!argsOrError)
return SGF.emitUndef(rawPointerType);
auto argument = (*argsOrError)[0];
SILValue addr;
// Try to borrow the argument at +0 indirect.
// If the argument is a reference to a borrowed addressable parameter, then
// use that parameter's stable address.
if (auto addressableAddr = SGF.tryEmitAddressableParameterAsAddress(
ArgumentSource(argument),
ValueOwnership::Shared)) {
addr = addressableAddr.getValue();
} else {
// We otherwise only support the builtin applied to values that
// are naturally emitted borrowed in memory. (But it would probably be good
// to phase this out since it's not really well-defined how long
// the resulting pointer is good for without something like addressability.)
auto borrow = SGF.emitRValue(argument, SGFContext::AllowGuaranteedPlusZero)
.getAsSingleValue(SGF, argument);
if (!SGF.F.getConventions().useLoweredAddresses()) {
auto &context = SGF.getASTContext();
auto identifier =
stackProtected
? context.getIdentifier("addressOfBorrowOpaque")
: context.getIdentifier("unprotectedAddressOfBorrowOpaque");
auto builtin = SGF.B.createBuiltin(loc, identifier, rawPointerType,
substitutions, {borrow.getValue()});
return ManagedValue::forObjectRValueWithoutOwnership(builtin);
}
if (!borrow.isPlusZero() || !borrow.getType().isAddress()) {
SGF.SGM.diagnose(argument->getLoc(), diag::non_borrowed_indirect_addressof);
return SGF.emitUndef(rawPointerType);
}
addr = borrow.getValue();
}
// Take the address argument and cast it to RawPointer.
SILValue result = SGF.B.createAddressToPointer(loc, addr, rawPointerType,
stackProtected);
return ManagedValue::forObjectRValueWithoutOwnership(result);
}
/// Specialized emitter for Builtin.addressOfBorrow.
static ManagedValue emitBuiltinAddressOfBorrow(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap substitutions,
PreparedArguments &&preparedArgs,
SGFContext C) {
return emitBuiltinAddressOfBorrowBuiltins(SGF, loc, substitutions,
std::move(preparedArgs), C, /*stackProtected=*/ true);
}
/// Specialized emitter for Builtin.addressOfBorrow.
static ManagedValue emitBuiltinUnprotectedAddressOfBorrow(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap substitutions,
PreparedArguments &&preparedArgs,
SGFContext C) {
return emitBuiltinAddressOfBorrowBuiltins(SGF, loc, substitutions,
std::move(preparedArgs), C, /*stackProtected=*/ false);
}
/// Specialized emitter for Builtin.gepRaw.
static ManagedValue emitBuiltinGepRaw(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap substitutions,
ArrayRef<ManagedValue> args,
SGFContext C) {
assert(args.size() == 2 && "gepRaw should be given two arguments");
SILValue offsetPtr = SGF.B.createIndexRawPointer(loc,
args[0].getUnmanagedValue(),
args[1].getUnmanagedValue());
return ManagedValue::forObjectRValueWithoutOwnership(offsetPtr);
}
/// Specialized emitter for Builtin.gep.
static ManagedValue emitBuiltinGep(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap substitutions,
ArrayRef<ManagedValue> args,
SGFContext C) {
assert(substitutions.getReplacementTypes().size() == 1 &&
"gep should have two substitutions");
assert(args.size() == 3 && "gep should be given three arguments");
SILType ElemTy = SGF.getLoweredType(substitutions.getReplacementTypes()[0]);
SILType RawPtrType = args[0].getUnmanagedValue()->getType();
SILValue addr = SGF.B.createPointerToAddress(loc,
args[0].getUnmanagedValue(),
ElemTy.getAddressType(),
/*strict*/ true,
/*invariant*/ false);
addr = SGF.B.createIndexAddr(loc, addr, args[1].getUnmanagedValue(),
/*needsStackProtection=*/ true);
addr = SGF.B.createAddressToPointer(loc, addr, RawPtrType,
/*needsStackProtection=*/ true);
return ManagedValue::forObjectRValueWithoutOwnership(addr);
}
/// Specialized emitter for Builtin.getTailAddr.
static ManagedValue emitBuiltinGetTailAddr(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap substitutions,
ArrayRef<ManagedValue> args,
SGFContext C) {
assert(substitutions.getReplacementTypes().size() == 2 &&
"getTailAddr should have two substitutions");
assert(args.size() == 4 && "gep should be given four arguments");
SILType ElemTy = SGF.getLoweredType(substitutions.getReplacementTypes()[0]);
SILType TailTy = SGF.getLoweredType(substitutions.getReplacementTypes()[1]);
SILType RawPtrType = args[0].getUnmanagedValue()->getType();
SILValue addr = SGF.B.createPointerToAddress(loc,
args[0].getUnmanagedValue(),
ElemTy.getAddressType(),
/*strict*/ true,
/*invariant*/ false);
addr = SGF.B.createTailAddr(loc, addr, args[1].getUnmanagedValue(),
TailTy.getAddressType());
addr = SGF.B.createAddressToPointer(loc, addr, RawPtrType,
/*needsStackProtection=*/ false);
return ManagedValue::forObjectRValueWithoutOwnership(addr);
}
/// Specialized emitter for Builtin.beginUnpairedModifyAccess.
static ManagedValue emitBuiltinBeginUnpairedModifyAccess(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap substitutions,
ArrayRef<ManagedValue> args,
SGFContext C) {
assert(substitutions.getReplacementTypes().size() == 1 &&
"Builtin.beginUnpairedModifyAccess should have one substitution");
assert(args.size() == 3 &&
"beginUnpairedModifyAccess should be given three arguments");
SILType elemTy = SGF.getLoweredType(substitutions.getReplacementTypes()[0]);
SILValue addr = SGF.B.createPointerToAddress(loc,
args[0].getUnmanagedValue(),
elemTy.getAddressType(),
/*strict*/ true,
/*invariant*/ false);
SILType valueBufferTy =
SGF.getLoweredType(SGF.getASTContext().TheUnsafeValueBufferType);
SILValue buffer =
SGF.B.createPointerToAddress(loc, args[1].getUnmanagedValue(),
valueBufferTy.getAddressType(),
/*strict*/ true,
/*invariant*/ false);
SGF.B.createBeginUnpairedAccess(loc, addr, buffer, SILAccessKind::Modify,
SILAccessEnforcement::Dynamic,
/*noNestedConflict*/ false,
/*fromBuiltin*/ true);
return ManagedValue::forObjectRValueWithoutOwnership(SGF.emitEmptyTuple(loc));
}
/// Specialized emitter for Builtin.performInstantaneousReadAccess
static ManagedValue emitBuiltinPerformInstantaneousReadAccess(
SILGenFunction &SGF, SILLocation loc, SubstitutionMap substitutions,
ArrayRef<ManagedValue> args, SGFContext C) {
assert(substitutions.getReplacementTypes().size() == 1 &&
"Builtin.performInstantaneousReadAccess should have one substitution");
assert(args.size() == 2 &&
"Builtin.performInstantaneousReadAccess should be given "
"two arguments");
SILType elemTy = SGF.getLoweredType(substitutions.getReplacementTypes()[0]);
SILValue addr = SGF.B.createPointerToAddress(loc,
args[0].getUnmanagedValue(),
elemTy.getAddressType(),
/*strict*/ true,
/*invariant*/ false);
SILType valueBufferTy =
SGF.getLoweredType(SGF.getASTContext().TheUnsafeValueBufferType);
SILValue unusedBuffer = SGF.emitTemporaryAllocation(loc, valueBufferTy);
// Begin an "unscoped" read access. No nested conflict is possible because
// the compiler should generate the actual read for the KeyPath expression
// immediately after the call to this builtin, which forms the address of
// that real access. When noNestedConflict=true, no EndUnpairedAccess should
// be emitted.
//
// Unpaired access is necessary because a BeginAccess/EndAccess pair with no
// use will be trivially optimized away.
SGF.B.createBeginUnpairedAccess(loc, addr, unusedBuffer, SILAccessKind::Read,
SILAccessEnforcement::Dynamic,
/*noNestedConflict*/ true,
/*fromBuiltin*/ true);
return ManagedValue::forObjectRValueWithoutOwnership(SGF.emitEmptyTuple(loc));
}
/// Specialized emitter for Builtin.endUnpairedAccessModifyAccess.
static ManagedValue emitBuiltinEndUnpairedAccess(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap substitutions,
ArrayRef<ManagedValue> args,
SGFContext C) {
assert(substitutions.empty() &&
"Builtin.endUnpairedAccess should have no substitutions");
assert(args.size() == 1 &&
"endUnpairedAccess should be given one argument");
SILType valueBufferTy =
SGF.getLoweredType(SGF.getASTContext().TheUnsafeValueBufferType);
SILValue buffer = SGF.B.createPointerToAddress(loc,
args[0].getUnmanagedValue(),
valueBufferTy.getAddressType(),
/*strict*/ true,
/*invariant*/ false);
SGF.B.createEndUnpairedAccess(loc, buffer, SILAccessEnforcement::Dynamic,
/*aborted*/ false,
/*fromBuiltin*/ true);
return ManagedValue::forObjectRValueWithoutOwnership(SGF.emitEmptyTuple(loc));
}
/// Specialized emitter for the legacy Builtin.condfail.
static ManagedValue emitBuiltinLegacyCondFail(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap substitutions,
ArrayRef<ManagedValue> args,
SGFContext C) {
assert(args.size() == 1 && "condfail should be given one argument");
SGF.B.createCondFail(loc, args[0].getUnmanagedValue(),
"unknown runtime failure");
return ManagedValue::forObjectRValueWithoutOwnership(SGF.emitEmptyTuple(loc));
}
/// Specialized emitter for Builtin.castReference.
static ManagedValue
emitBuiltinCastReference(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap substitutions,
ArrayRef<ManagedValue> args,
SGFContext C) {
assert(args.size() == 1 && "castReference should be given one argument");
assert(substitutions.getReplacementTypes().size() == 2 &&
"castReference should have two subs");
auto fromTy = substitutions.getReplacementTypes()[0];
auto toTy = substitutions.getReplacementTypes()[1];
auto &fromTL = SGF.getTypeLowering(fromTy);
auto &toTL = SGF.getTypeLowering(toTy);
assert(!fromTL.isTrivial() && !toTL.isTrivial() && "expected ref type");
auto arg = args[0];
// TODO: Fix this API.
if (!fromTL.isAddress() || !toTL.isAddress()) {
if (SILType::canRefCast(arg.getType(), toTL.getLoweredType(), SGF.SGM.M)) {
// Create a reference cast, forwarding the cleanup.
// The cast takes the source reference.
return SGF.B.createUncheckedRefCast(loc, arg, toTL.getLoweredType());
}
}
// We are either casting between address-only types, or cannot promote to a
// cast of reference values.
//
// If the from/to types are invalid, then use a cast that will fail at
// runtime. We cannot catch these errors with SIL verification because they
// may legitimately occur during code specialization on dynamically
// unreachable paths.
//
// TODO: For now, we leave invalid casts in address form so that the runtime
// will trap. We could emit a noreturn call here instead which would provide
// more information to the optimizer.
SILValue srcVal = arg.ensurePlusOne(SGF, loc).forward(SGF);
SILValue fromAddr;
if (!fromTL.isAddress()) {
// Move the loadable value into a "source temp". Since the source and
// dest are RC identical, store the reference into the source temp without
// a retain. The cast will load the reference from the source temp and
// store it into a dest temp effectively forwarding the cleanup.
fromAddr = SGF.emitTemporaryAllocation(loc, srcVal->getType());
fromTL.emitStore(SGF.B, loc, srcVal, fromAddr,
StoreOwnershipQualifier::Init);
} else {
// The cast loads directly from the source address.
fromAddr = srcVal;
}
// Create a "dest temp" to hold the reference after casting it.
SILValue toAddr = SGF.emitTemporaryAllocation(loc, toTL.getLoweredType());
SGF.B.createUncheckedRefCastAddr(loc, fromAddr, fromTy->getCanonicalType(),
toAddr, toTy->getCanonicalType());
// Forward it along and register a cleanup.
if (toTL.isAddress())
return SGF.emitManagedBufferWithCleanup(toAddr);
// Load the destination value.
auto result = toTL.emitLoad(SGF.B, loc, toAddr, LoadOwnershipQualifier::Take);
return SGF.emitManagedRValueWithCleanup(result);
}
/// Specialized emitter for Builtin.reinterpretCast.
static ManagedValue emitBuiltinReinterpretCast(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap substitutions,
ArrayRef<ManagedValue> args,
SGFContext C) {
assert(args.size() == 1 && "reinterpretCast should be given one argument");
assert(substitutions.getReplacementTypes().size() == 2 &&
"reinterpretCast should have two subs");
auto &fromTL = SGF.getTypeLowering(substitutions.getReplacementTypes()[0]);
auto &toTL = SGF.getTypeLowering(substitutions.getReplacementTypes()[1]);
// If casting between address types, cast the address.
if (fromTL.isAddress() || toTL.isAddress()) {
SILValue fromAddr;
// If the from value is not an address, move it to a buffer.
if (!fromTL.isAddress()) {
fromAddr = SGF.emitTemporaryAllocation(loc, args[0].getValue()->getType());
fromTL.emitStore(SGF.B, loc, args[0].getValue(), fromAddr,
StoreOwnershipQualifier::Init);
} else {
fromAddr = args[0].getValue();
}
auto toAddr = SGF.B.createUncheckedAddrCast(loc, fromAddr,
toTL.getLoweredType().getAddressType());
// Load and retain the destination value if it's loadable. Leave the cleanup
// on the original value since we don't know anything about it's type.
if (!toTL.isAddress()) {
return SGF.emitManagedLoadCopy(loc, toAddr, toTL);
}
// Leave the cleanup on the original value.
if (toTL.isTrivial())
return ManagedValue::forTrivialAddressRValue(toAddr);
// Initialize the +1 result buffer without taking the incoming value. The
// source and destination cleanups will be independent.
return SGF.B.bufferForExpr(
loc, toTL.getLoweredType(), toTL, C,
[&](SILValue bufferAddr) {
SGF.B.createCopyAddr(loc, toAddr, bufferAddr, IsNotTake,
IsInitialization);
});
}
// Create the appropriate bitcast based on the source and dest types.
ManagedValue in = args[0];
SILType resultTy = toTL.getLoweredType();
return SGF.B.createUncheckedBitCast(loc, in, resultTy);
}
/// Specialized emitter for Builtin.castToBridgeObject.
static ManagedValue emitBuiltinCastToBridgeObject(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap subs,
ArrayRef<ManagedValue> args,
SGFContext C) {
assert(args.size() == 2 && "cast should have two arguments");
assert(subs.getReplacementTypes().size() == 1 &&
"cast should have a type substitution");
// Take the reference type argument and cast it to BridgeObject.
SILType objPointerType = SILType::getBridgeObjectType(SGF.F.getASTContext());
// Bail if the source type is not a class reference of some kind.
auto sourceType = subs.getReplacementTypes()[0];
if (!sourceType->mayHaveSuperclass() &&
!sourceType->isClassExistentialType()) {
SGF.SGM.diagnose(loc, diag::invalid_sil_builtin,
"castToBridgeObject source must be a class");
return SGF.emitUndef(objPointerType);
}
ManagedValue ref = args[0];
SILValue bits = args[1].getUnmanagedValue();
// If the argument is existential, open it.
if (sourceType->isClassExistentialType()) {
auto openedTy = OpenedArchetypeType::get(sourceType->getCanonicalType());
SILType loweredOpenedTy = SGF.getLoweredLoadableType(openedTy);
ref = SGF.B.createOpenExistentialRef(loc, ref, loweredOpenedTy);
}
return SGF.B.createRefToBridgeObject(loc, ref, bits);
}
/// Specialized emitter for Builtin.castReferenceFromBridgeObject.
static ManagedValue emitBuiltinCastReferenceFromBridgeObject(
SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap subs,
ArrayRef<ManagedValue> args,
SGFContext C) {
assert(args.size() == 1 && "cast should have one argument");
assert(subs.getReplacementTypes().size() == 1 &&
"cast should have a type substitution");
// The substitution determines the destination type.
auto destTy = subs.getReplacementTypes()[0];
SILType destType = SGF.getLoweredType(destTy);
// Bail if the source type is not a class reference of some kind.
if (!destTy->isBridgeableObjectType() || !destType.isObject()) {
SGF.SGM.diagnose(loc, diag::invalid_sil_builtin,
"castReferenceFromBridgeObject dest must be an object type");
// Recover by propagating an undef result.
return SGF.emitUndef(destType);
}
return SGF.B.createBridgeObjectToRef(loc, args[0], destType);
}
static ManagedValue emitBuiltinCastBitPatternFromBridgeObject(
SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap subs,
ArrayRef<ManagedValue> args,
SGFContext C) {
assert(args.size() == 1 && "cast should have one argument");
assert(subs.empty() && "cast should not have subs");
SILType wordType = SILType::getBuiltinWordType(SGF.getASTContext());
SILValue result = SGF.B.createBridgeObjectToWord(loc, args[0].getValue(),
wordType);
return ManagedValue::forObjectRValueWithoutOwnership(result);
}
static ManagedValue emitBuiltinClassifyBridgeObject(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap subs,
ArrayRef<ManagedValue> args,
SGFContext C) {
assert(args.size() == 1 && "classify should have one argument");
assert(subs.empty() && "classify should not have subs");
SILValue result = SGF.B.createClassifyBridgeObject(loc, args[0].getValue());
return ManagedValue::forObjectRValueWithoutOwnership(result);
}
static ManagedValue emitBuiltinValueToBridgeObject(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap subs,
ArrayRef<ManagedValue> args,
SGFContext C) {
assert(args.size() == 1 && "ValueToBridgeObject should have one argument");
assert(subs.getReplacementTypes().size() == 1 &&
"ValueToBridgeObject should have one sub");
Type argTy = subs.getReplacementTypes()[0];
if (!argTy->is<BuiltinIntegerType>()) {
SGF.SGM.diagnose(loc, diag::invalid_sil_builtin,
"argument to builtin should be a builtin integer");
SILType objPointerType = SILType::getBridgeObjectType(SGF.F.getASTContext());
return SGF.emitUndef(objPointerType);
}
SILValue result = SGF.B.createValueToBridgeObject(loc, args[0].getValue());
return SGF.emitManagedCopy(loc, result);
}
// This should only accept as an operand type single-refcounted-pointer types,
// class existentials, or single-payload enums (optional). Type checking must be
// deferred until IRGen so Builtin.isUnique can be called from a transparent
// generic wrapper (we can only type check after specialization).
static ManagedValue emitBuiltinIsUnique(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap subs,
ArrayRef<ManagedValue> args,
SGFContext C) {
assert(subs.getReplacementTypes().size() == 1 &&
"isUnique should have a single substitution");
assert(args.size() == 1 && "isUnique should have a single argument");
assert((args[0].getType().isAddress() && !args[0].hasCleanup()) &&
"Builtin.isUnique takes an address.");
return ManagedValue::forObjectRValueWithoutOwnership(
SGF.B.createIsUnique(loc, args[0].getValue()));
}
// This force-casts the incoming address to NativeObject assuming the caller has
// performed all necessary checks. For example, this may directly cast a
// single-payload enum to a NativeObject reference.
static ManagedValue
emitBuiltinIsUnique_native(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap subs,
ArrayRef<ManagedValue> args,
SGFContext C) {
assert(subs.getReplacementTypes().size() == 1 &&
"isUnique_native should have one sub.");
assert(args.size() == 1 && "isUnique_native should have one arg.");
auto ToType =
SILType::getNativeObjectType(SGF.getASTContext()).getAddressType();
auto toAddr = SGF.B.createUncheckedAddrCast(loc, args[0].getValue(), ToType);
SILValue result = SGF.B.createIsUnique(loc, toAddr);
return ManagedValue::forObjectRValueWithoutOwnership(result);
}
static ManagedValue
emitBuiltinBeginCOWMutation(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap subs,
ArrayRef<ManagedValue> args,
SGFContext C) {
assert(subs.getReplacementTypes().size() == 1 &&
"BeginCOWMutation should have one sub.");
assert(args.size() == 1 && "isUnique_native should have one arg.");
SILValue refAddr = args[0].getValue();
auto *ref = SGF.B.createLoad(loc, refAddr, LoadOwnershipQualifier::Take);
BeginCOWMutationInst *beginCOW = SGF.B.createBeginCOWMutation(loc, ref, /*isNative*/ false);
SGF.B.createStore(loc, beginCOW->getBufferResult(), refAddr, StoreOwnershipQualifier::Init);
return ManagedValue::forObjectRValueWithoutOwnership(
beginCOW->getUniquenessResult());
}
static ManagedValue
emitBuiltinBeginCOWMutation_native(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap subs,
ArrayRef<ManagedValue> args,
SGFContext C) {
assert(subs.getReplacementTypes().size() == 1 &&
"BeginCOWMutation should have one sub.");
assert(args.size() == 1 && "isUnique_native should have one arg.");
SILValue refAddr = args[0].getValue();
auto *ref = SGF.B.createLoad(loc, refAddr, LoadOwnershipQualifier::Take);
BeginCOWMutationInst *beginCOW = SGF.B.createBeginCOWMutation(loc, ref, /*isNative*/ true);
SGF.B.createStore(loc, beginCOW->getBufferResult(), refAddr, StoreOwnershipQualifier::Init);
return ManagedValue::forObjectRValueWithoutOwnership(
beginCOW->getUniquenessResult());
}
static ManagedValue
emitBuiltinEndCOWMutation(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap subs,
ArrayRef<ManagedValue> args,
SGFContext C) {
assert(subs.getReplacementTypes().size() == 1 &&
"EndCOWMutation should have one sub.");
assert(args.size() == 1 && "isUnique_native should have one arg.");
SILValue refAddr = args[0].getValue();
auto ref = SGF.B.createLoad(loc, refAddr, LoadOwnershipQualifier::Take);
auto endRef = SGF.B.createEndCOWMutation(loc, ref, /*keepUnique=*/ false);
SGF.B.createStore(loc, endRef, refAddr, StoreOwnershipQualifier::Init);
return ManagedValue::forObjectRValueWithoutOwnership(SGF.emitEmptyTuple(loc));
}
static ManagedValue emitBuiltinBindMemory(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap subs,
ArrayRef<ManagedValue> args,
SGFContext C) {
assert(subs.getReplacementTypes().size() == 1 && "bindMemory should have a single substitution");
assert(args.size() == 3 && "bindMemory should have three arguments");
// The substitution determines the element type for bound memory.
CanType boundFormalType = subs.getReplacementTypes()[0]->getCanonicalType();
SILType boundType = SGF.getLoweredType(boundFormalType);
auto *bindMemory = SGF.B.createBindMemory(loc, args[0].getValue(),
args[1].getValue(), boundType);
return ManagedValue::forObjectRValueWithoutOwnership(bindMemory);
}
static ManagedValue emitBuiltinRebindMemory(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap subs,
ArrayRef<ManagedValue> args,
SGFContext C) {
assert(subs.empty() && "rebindMemory should have no substitutions");
assert(args.size() == 2 && "rebindMemory should have two arguments");
auto *rebindMemory = SGF.B.createRebindMemory(loc, args[0].getValue(),
args[1].getValue());
return ManagedValue::forObjectRValueWithoutOwnership(rebindMemory);
}
static ManagedValue emitBuiltinAllocWithTailElems(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap subs,
ArrayRef<ManagedValue> args,
SGFContext C) {
unsigned NumTailTypes = subs.getReplacementTypes().size() - 1;
assert(args.size() == NumTailTypes * 2 + 1 &&
"wrong number of substitutions for allocWithTailElems");
// The substitution determines the element type for bound memory.
auto replacementTypes = subs.getReplacementTypes();
SILType RefType = SGF.getLoweredType(replacementTypes[0]->
getCanonicalType()).getObjectType();
SmallVector<ManagedValue, 4> Counts;
SmallVector<SILType, 4> ElemTypes;
for (unsigned Idx = 0; Idx < NumTailTypes; ++Idx) {
Counts.push_back(args[Idx * 2 + 1]);
ElemTypes.push_back(SGF.getLoweredType(replacementTypes[Idx+1]->
getCanonicalType()).getObjectType());
}
ManagedValue Metatype = args[0];
if (isa<MetatypeInst>(Metatype)) {
auto InstanceType =
Metatype.getType().castTo<MetatypeType>().getInstanceType();
assert(InstanceType == RefType.getASTType() &&
"substituted type does not match operand metatype");
(void) InstanceType;
return SGF.B.createAllocRef(loc, RefType, false,
ElemTypes, Counts);
} else {
return SGF.B.createAllocRefDynamic(loc, Metatype, RefType, false,
ElemTypes, Counts);
}
}
static ManagedValue emitBuiltinProjectTailElems(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap subs,
ArrayRef<ManagedValue> args,
SGFContext C) {
assert(subs.getReplacementTypes().size() == 2 &&
"allocWithTailElems should have two substitutions");
assert(args.size() == 2 &&
"allocWithTailElems should have three arguments");
// The substitution determines the element type for bound memory.
SILType ElemType = SGF.getLoweredType(subs.getReplacementTypes()[1]->
getCanonicalType()).getObjectType();
SILValue result = SGF.B.createRefTailAddr(
loc, args[0].borrow(SGF, loc).getValue(), ElemType.getAddressType());
SILType rawPointerType = SILType::getRawPointerType(SGF.F.getASTContext());
result = SGF.B.createAddressToPointer(loc, result, rawPointerType,
/*needsStackProtection=*/ false);
return ManagedValue::forObjectRValueWithoutOwnership(result);
}
/// Specialized emitter for type traits.
template<TypeTraitResult (TypeBase::*Trait)(),
BuiltinValueKind Kind>
static ManagedValue emitBuiltinTypeTrait(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap substitutions,
ArrayRef<ManagedValue> args,
SGFContext C) {
assert(substitutions.getReplacementTypes().size() == 1
&& "type trait should take a single type parameter");
assert(args.size() == 1
&& "type trait should take a single argument");
unsigned result;
auto traitTy = substitutions.getReplacementTypes()[0]->getCanonicalType();
switch ((traitTy.getPointer()->*Trait)()) {
// If the type obviously has or lacks the trait, emit a constant result.
case TypeTraitResult::IsNot:
result = 0;
break;
case TypeTraitResult::Is:
result = 1;
break;
// If not, emit the builtin call normally. Specialization may be able to
// eliminate it later, or we'll lower it away at IRGen time.
case TypeTraitResult::CanBe: {
auto &C = SGF.getASTContext();
auto int8Ty = BuiltinIntegerType::get(8, C)->getCanonicalType();
auto apply = SGF.B.createBuiltin(loc,
C.getIdentifier(getBuiltinName(Kind)),
SILType::getPrimitiveObjectType(int8Ty),
substitutions, args[0].getValue());
return ManagedValue::forObjectRValueWithoutOwnership(apply);
}
}
// Produce the result as an integer literal constant.
auto val = SGF.B.createIntegerLiteral(
loc, SILType::getBuiltinIntegerType(8, SGF.getASTContext()),
(uintmax_t)result);
return ManagedValue::forObjectRValueWithoutOwnership(val);
}
static ManagedValue emitBuiltinAutoDiffApplyDerivativeFunction(
AutoDiffDerivativeFunctionKind kind, unsigned arity,
bool throws, SILGenFunction &SGF, SILLocation loc,
SubstitutionMap substitutions, ArrayRef<ManagedValue> args, SGFContext C) {
// FIXME(https://github.com/apple/swift/issues/54259): Support throwing functions.
assert(!throws && "Throwing functions are not yet supported");
auto origFnVal = args[0];
SmallVector<SILValue, 2> origFnArgVals;
for (auto& arg : args.drop_front(1))
origFnArgVals.push_back(arg.getValue());
auto origFnType = origFnVal.getType().castTo<SILFunctionType>();
auto origFnUnsubstType = origFnType->getUnsubstitutedType(SGF.getModule());
if (origFnType != origFnUnsubstType) {
origFnVal = SGF.B.createConvertFunction(
loc, origFnVal, SILType::getPrimitiveObjectType(origFnUnsubstType),
/*withoutActuallyEscaping*/ false);
}
// Get the derivative function.
origFnVal = SGF.B.createBeginBorrow(loc, origFnVal);
SILValue derivativeFn = SGF.B.createDifferentiableFunctionExtract(
loc, kind, origFnVal.getValue());
auto derivativeFnType = derivativeFn->getType().castTo<SILFunctionType>();
assert(derivativeFnType->getNumResults() == 2);
assert(derivativeFnType->getNumParameters() == origFnArgVals.size());
auto derivativeFnUnsubstType =
derivativeFnType->getUnsubstitutedType(SGF.getModule());
if (derivativeFnType != derivativeFnUnsubstType) {
derivativeFn = SGF.B.createConvertFunction(
loc, derivativeFn,
SILType::getPrimitiveObjectType(derivativeFnUnsubstType),
/*withoutActuallyEscaping*/ false);
}
// We don't need to destroy the original function or retain the
// `derivativeFn`, because they are noescape.
assert(origFnType->isTrivialNoEscape());
assert(derivativeFnType->isTrivialNoEscape());
// Do the apply for the indirect result case.
if (derivativeFnType->hasIndirectFormalResults() &&
SGF.SGM.M.useLoweredAddresses()) {
auto indResBuffer = SGF.getBufferForExprResult(
loc, derivativeFnType->getAllResultsInterfaceType(), C);
SmallVector<SILValue, 3> applyArgs;
applyArgs.push_back(SGF.B.createTupleElementAddr(loc, indResBuffer, 0));
for (auto origFnArgVal : origFnArgVals)
applyArgs.push_back(origFnArgVal);
auto differential = SGF.B.createApply(loc, derivativeFn, SubstitutionMap(),
applyArgs);
derivativeFn = SILValue();
SGF.B.createStore(loc, differential,
SGF.B.createTupleElementAddr(loc, indResBuffer, 1),
StoreOwnershipQualifier::Init);
return SGF.manageBufferForExprResult(
indResBuffer, SGF.getTypeLowering(indResBuffer->getType()), C);
}
// Do the apply for the direct result case.
auto resultTuple = SGF.B.createApply(
loc, derivativeFn, SubstitutionMap(), origFnArgVals);
derivativeFn = SILValue();
return SGF.emitManagedRValueWithCleanup(resultTuple);
}
static ManagedValue emitBuiltinAutoDiffApplyTransposeFunction(
unsigned arity, bool throws, SILGenFunction &SGF, SILLocation loc,
SubstitutionMap substitutions, ArrayRef<ManagedValue> args, SGFContext C) {
// FIXME(https://github.com/apple/swift/issues/54259): Support throwing functions.
assert(!throws && "Throwing functions are not yet supported");
auto origFnVal = args.front().getValue();
SmallVector<SILValue, 2> origFnArgVals;
for (auto &arg : args.drop_front(1))
origFnArgVals.push_back(arg.getValue());
// Get the transpose function.
SILValue transposeFn = SGF.B.createLinearFunctionExtract(
loc, LinearDifferentiableFunctionTypeComponent::Transpose, origFnVal);
auto transposeFnType = transposeFn->getType().castTo<SILFunctionType>();
auto transposeFnUnsubstType =
transposeFnType->getUnsubstitutedType(SGF.getModule());
if (transposeFnType != transposeFnUnsubstType) {
transposeFn = SGF.B.createConvertFunction(
loc, transposeFn,
SILType::getPrimitiveObjectType(transposeFnUnsubstType),
/*withoutActuallyEscaping*/ false);
transposeFnType = transposeFn->getType().castTo<SILFunctionType>();
}
SmallVector<SILValue, 2> applyArgs;
if (transposeFnType->hasIndirectFormalResults())
applyArgs.push_back(
SGF.getBufferForExprResult(
loc, transposeFnType->getAllResultsInterfaceType(), C));
for (auto paramArg : args.drop_front()) {
applyArgs.push_back(paramArg.getValue());
}
auto *apply = SGF.B.createApply(
loc, transposeFn, SubstitutionMap(), applyArgs);
if (transposeFnType->hasIndirectFormalResults()) {
auto resultAddress = applyArgs.front();
AbstractionPattern pattern(
SGF.F.getLoweredFunctionType()->getSubstGenericSignature(),
resultAddress->getType().getASTType());
auto &tl =
SGF.getTypeLowering(pattern, resultAddress->getType().getASTType());
return SGF.manageBufferForExprResult(resultAddress, tl, C);
} else {
return SGF.emitManagedRValueWithCleanup(apply);
}
}
static ManagedValue emitBuiltinApplyDerivative(
SILGenFunction &SGF, SILLocation loc, SubstitutionMap substitutions,
ArrayRef<ManagedValue> args, SGFContext C) {
auto *callExpr = loc.castToASTNode<CallExpr>();
auto builtinDecl = cast<FuncDecl>(cast<DeclRefExpr>(
cast<DotSyntaxBaseIgnoredExpr>(callExpr->getDirectCallee())->getRHS())
->getDecl());
const auto builtinName = builtinDecl->getBaseIdentifier().str();
AutoDiffDerivativeFunctionKind kind;
unsigned arity;
bool throws;
auto successfullyParsed = autodiff::getBuiltinApplyDerivativeConfig(
builtinName, kind, arity, throws);
assert(successfullyParsed);
return emitBuiltinAutoDiffApplyDerivativeFunction(
kind, arity, throws, SGF, loc, substitutions, args, C);
}
static ManagedValue emitBuiltinApplyTranspose(
SILGenFunction &SGF, SILLocation loc, SubstitutionMap substitutions,
ArrayRef<ManagedValue> args, SGFContext C) {
auto *callExpr = loc.castToASTNode<CallExpr>();
auto builtinDecl = cast<FuncDecl>(cast<DeclRefExpr>(
cast<DotSyntaxBaseIgnoredExpr>(callExpr->getDirectCallee())->getRHS())
->getDecl());
const auto builtinName = builtinDecl->getBaseIdentifier().str();
unsigned arity;
bool throws;
auto successfullyParsed = autodiff::getBuiltinApplyTransposeConfig(
builtinName, arity, throws);
assert(successfullyParsed);
return emitBuiltinAutoDiffApplyTransposeFunction(
arity, throws, SGF, loc, substitutions, args, C);
}
/// Emit SIL for the named builtin: globalStringTablePointer. Unlike the default
/// ownership convention for named builtins, which is to take (non-trivial)
/// arguments as Owned, this builtin accepts owned as well as guaranteed
/// arguments, and hence doesn't require the arguments to be at +1. Therefore,
/// this builtin is emitted specially.
static ManagedValue
emitBuiltinGlobalStringTablePointer(SILGenFunction &SGF, SILLocation loc,
SubstitutionMap subs,
ArrayRef<ManagedValue> args, SGFContext C) {
assert(args.size() == 1);
SILValue argValue = args[0].getValue();
auto &astContext = SGF.getASTContext();
Identifier builtinId = astContext.getIdentifier(
getBuiltinName(BuiltinValueKind::GlobalStringTablePointer));
auto resultVal = SGF.B.createBuiltin(loc, builtinId,
SILType::getRawPointerType(astContext),
subs, ArrayRef<SILValue>(argValue));
return SGF.emitManagedRValueWithCleanup(resultVal);
}
/// Emit SIL for the named builtin:
/// convertStrongToUnownedUnsafe. Unlike the default ownership
/// convention for named builtins, which is to take (non-trivial)
/// arguments as Owned, this builtin accepts owned as well as
/// guaranteed arguments, and hence doesn't require the arguments to
/// be at +1. Therefore, this builtin is emitted specially.
///
/// We assume our convention is (T, @inout @unmanaged T) -> ()
static ManagedValue emitBuiltinConvertStrongToUnownedUnsafe(
SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
PreparedArguments &&preparedArgs, SGFContext C) {
auto argsOrError = decomposeArguments(SGF, loc, std::move(preparedArgs), 2);
if (!argsOrError)
return ManagedValue::forObjectRValueWithoutOwnership(
SGF.emitEmptyTuple(loc));
auto args = *argsOrError;
// First get our object at +0 if we can.
auto object = SGF.emitRValue(args[0], SGFContext::AllowGuaranteedPlusZero)
.getAsSingleValue(SGF, args[0]);
// Borrow it and get the value.
SILValue objectSrcValue = object.borrow(SGF, loc).getValue();
// Then create our inout.
auto inout = cast<InOutExpr>(args[1]->getSemanticsProvidingExpr());
auto lv =
SGF.emitLValue(inout->getSubExpr(), SGFAccessKind::BorrowedAddressRead);
lv.unsafelyDropLastComponent(PathComponent::OwnershipKind);
if (!lv.isPhysical() || !lv.isLoadingPure()) {
llvm::report_fatal_error("Builtin.convertStrongToUnownedUnsafe passed "
"non-physical, non-pure lvalue as 2nd arg");
}
SILValue inoutDest =
SGF.emitAddressOfLValue(args[1], std::move(lv)).getLValueAddress();
SILType destType = inoutDest->getType().getObjectType();
// Make sure our types match up as we expect.
if (objectSrcValue->getType() !=
destType.getReferenceStorageReferentType().getObjectType()) {
llvm::errs()
<< "Invalid usage of Builtin.convertStrongToUnownedUnsafe. lhsType "
"must be T and rhsType must be inout unsafe(unowned) T"
<< "lhsType: " << objectSrcValue->getType() << "\n"
<< "rhsType: " << inoutDest->getType() << "\n";
llvm::report_fatal_error("standard fatal error msg");
}
SILType unmanagedOptType = objectSrcValue->getType().getReferenceStorageType(
SGF.getASTContext(), ReferenceOwnership::Unmanaged);
SILValue unownedObjectSrcValue = SGF.B.createRefToUnmanaged(
loc, objectSrcValue, unmanagedOptType.getObjectType());
SGF.B.emitStoreValueOperation(loc, unownedObjectSrcValue, inoutDest,
StoreOwnershipQualifier::Trivial);
return ManagedValue::forObjectRValueWithoutOwnership(SGF.emitEmptyTuple(loc));
}
/// Emit SIL for the named builtin: convertUnownedUnsafeToGuaranteed.
///
/// We assume our convention is:
///
/// <BaseT, T> (BaseT, @inout @unowned(unsafe) T) -> @guaranteed T
///
static ManagedValue emitBuiltinConvertUnownedUnsafeToGuaranteed(
SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
PreparedArguments &&preparedArgs, SGFContext C) {
auto argsOrError = decomposeArguments(SGF, loc, std::move(preparedArgs), 2);
if (!argsOrError)
return ManagedValue::forObjectRValueWithoutOwnership(
SGF.emitEmptyTuple(loc));
auto args = *argsOrError;
// First grab our base and borrow it.
auto baseMV =
SGF.emitRValueAsSingleValue(args[0], SGFContext::AllowGuaranteedPlusZero)
.borrow(SGF, args[0]);
// Then grab our LValue operand, drop the last ownership component.
auto srcLV = SGF.emitLValue(args[1]->getSemanticsProvidingExpr(),
SGFAccessKind::BorrowedAddressRead);
srcLV.unsafelyDropLastComponent(PathComponent::OwnershipKind);
if (!srcLV.isPhysical() || !srcLV.isLoadingPure()) {
llvm::report_fatal_error("Builtin.convertUnownedUnsafeToGuaranteed passed "
"non-physical, non-pure lvalue as 2nd arg");
}
// Grab our address and load our unmanaged and convert it to a ref.
SILValue srcAddr =
SGF.emitAddressOfLValue(args[1], std::move(srcLV)).getLValueAddress();
SILValue srcValue = SGF.B.emitLoadValueOperation(
loc, srcAddr, LoadOwnershipQualifier::Trivial);
SILValue unownedNonTrivialRef = SGF.B.createUnmanagedToRef(
loc, srcValue, srcValue->getType().getReferenceStorageReferentType());
// Now convert our unownedNonTrivialRef from unowned ownership to guaranteed
// ownership and create a cleanup for it.
SILValue guaranteedNonTrivialRef = SGF.B.createUncheckedOwnershipConversion(
loc, unownedNonTrivialRef, OwnershipKind::Guaranteed);
auto guaranteedNonTrivialRefMV =
SGF.emitManagedBorrowedRValueWithCleanup(guaranteedNonTrivialRef);
// Now create a mark dependence on our base and return the result.
return SGF.B.createMarkDependence(loc, guaranteedNonTrivialRefMV, baseMV,
MarkDependenceKind::Escaping);
}
// Emit SIL for the named builtin: getCurrentAsyncTask.
static ManagedValue emitBuiltinGetCurrentAsyncTask(
SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
PreparedArguments &&preparedArgs, SGFContext C) {
ASTContext &ctx = SGF.getASTContext();
auto apply = SGF.B.createBuiltin(
loc,
ctx.getIdentifier(getBuiltinName(BuiltinValueKind::GetCurrentAsyncTask)),
SGF.getLoweredType(ctx.TheNativeObjectType), SubstitutionMap(), { });
return SGF.emitManagedRValueWithEndLifetimeCleanup(apply);
}
// Emit SIL for the named builtin: cancelAsyncTask.
static ManagedValue emitBuiltinCancelAsyncTask(
SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
ArrayRef<ManagedValue> args, SGFContext C) {
return SGF.emitCancelAsyncTask(loc, args[0].borrow(SGF, loc).forward(SGF));
}
// Emit SIL for the named builtin: endAsyncLet.
static ManagedValue emitBuiltinEndAsyncLet(
SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
ArrayRef<ManagedValue> args, SGFContext C) {
return SGF.emitCancelAsyncTask(loc, args[0].borrow(SGF, loc).forward(SGF));
}
// Emit SIL for the named builtin: getCurrentExecutor.
static ManagedValue emitBuiltinGetCurrentExecutor(
SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
PreparedArguments &&preparedArgs, SGFContext C) {
// We don't support this builtin anymore in SILGen.
// TODO: just remove it?
SGF.SGM.diagnose(loc, diag::unsupported_sil_builtin,
getBuiltinName(BuiltinValueKind::GetCurrentExecutor));
auto &ctx = SGF.getASTContext();
auto executorType = SILType::getPrimitiveObjectType(ctx.TheExecutorType);
auto optionalExecutorType = SILType::getOptionalType(executorType);
return SGF.emitUndef(optionalExecutorType);
}
// Emit SIL for sizeof/strideof/alignof.
// These formally take a metatype argument that's never actually used, so
// we ignore it.
static ManagedValue emitBuiltinSizeof(
SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
PreparedArguments &&preparedArgs, SGFContext C) {
auto &ctx = SGF.getASTContext();
return ManagedValue::forObjectRValueWithoutOwnership(SGF.B.createBuiltin(
loc, ctx.getIdentifier(getBuiltinName(BuiltinValueKind::Sizeof)),
SILType::getBuiltinWordType(ctx), subs, {}));
}
static ManagedValue emitBuiltinStrideof(
SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
PreparedArguments &&preparedArgs, SGFContext C) {
auto &ctx = SGF.getASTContext();
return ManagedValue::forObjectRValueWithoutOwnership(SGF.B.createBuiltin(
loc, ctx.getIdentifier(getBuiltinName(BuiltinValueKind::Strideof)),
SILType::getBuiltinWordType(ctx), subs, {}));
}
static ManagedValue emitBuiltinAlignof(
SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
PreparedArguments &&preparedArgs, SGFContext C) {
auto &ctx = SGF.getASTContext();
return ManagedValue::forObjectRValueWithoutOwnership(SGF.B.createBuiltin(
loc, ctx.getIdentifier(getBuiltinName(BuiltinValueKind::Alignof)),
SILType::getBuiltinWordType(ctx), subs, {}));
}
enum class CreateTaskOptions {
/// The builtin has optional arguments for everything.
OptionalEverything = 0x1,
/// The builtin is for a DiscardingTaskGroup and so expects the function
/// to return Void.
Discarding = 0x2,
/// The builtin has a non-optional TaskGroup argument.
TaskGroup = 0x4,
/// The builtin has a non-optional TaskExecutor argument.
TaskExecutor = 0x8,
};
/// Emit SIL for the various createAsyncTask builtins.
static ManagedValue emitCreateAsyncTask(SILGenFunction &SGF, SILLocation loc,
SubstitutionMap subs,
PreparedArguments &&preparedArgs,
OptionSet<CreateTaskOptions> options) {
#ifndef NDEBUG
if (options & CreateTaskOptions::Discarding) {
assert(!subs);
} else {
assert(subs && subs.getReplacementTypes().size() == 1);
}
#endif
ASTContext &ctx = SGF.getASTContext();
auto args = std::move(preparedArgs).getSources();
unsigned nextArgIdx = 0;
auto nextArg = [&]() -> ArgumentSource && {
return std::move(args[nextArgIdx++]);
};
auto emitOptionalSome = [&](ArgumentSource &&arg) {
auto loc = arg.getLocation();
auto value = std::move(arg).getAsSingleValue(SGF);
return SGF.B.createOptionalSome(loc, value);
};
auto emitOptionalNone = [&](CanType argType) {
auto ty = SGF.getLoweredType(argType.wrapInOptionalType());
return SGF.B.createManagedOptionalNone(loc, ty);
};
ManagedValue flags = nextArg().getAsSingleValue(SGF);
ManagedValue initialExecutor = [&] {
if (options & CreateTaskOptions::OptionalEverything) {
return nextArg().getAsSingleValue(SGF);
} else {
return emitOptionalNone(ctx.TheExecutorType);
}
}();
ManagedValue taskGroup = [&] {
if (options & CreateTaskOptions::OptionalEverything) {
return nextArg().getAsSingleValue(SGF);
} else if (options & CreateTaskOptions::TaskGroup) {
return emitOptionalSome(nextArg());
} else {
return emitOptionalNone(ctx.TheRawPointerType);
}
}();
ManagedValue taskExecutorDeprecated = [&] {
if (options & CreateTaskOptions::OptionalEverything) {
return nextArg().getAsSingleValue(SGF);
} else if (options & CreateTaskOptions::TaskExecutor) {
return emitOptionalSome(nextArg());
} else {
return emitOptionalNone(ctx.TheExecutorType);
}
}();
ManagedValue taskExecutorConsuming = [&] {
if (options & CreateTaskOptions::OptionalEverything) {
return nextArg().getAsSingleValue(SGF);
} else if (auto theTaskExecutorProto = ctx.getProtocol(KnownProtocolKind::TaskExecutor)) {
return emitOptionalNone(theTaskExecutorProto->getDeclaredExistentialType()
->getCanonicalType());
} else {
// This builtin executor type here is just a placeholder type for being
// able to pass 'nil' for it with SDKs which do not have the TaskExecutor
// type.
return emitOptionalNone(ctx.TheExecutorType);
}
}();
auto functionValue = [&] {
// No reabstraction required.
if (options & CreateTaskOptions::Discarding) {
return nextArg().getAsSingleValue(SGF);
}
// We need to emit the function properly reabstracted.
// This generally isn't a problem because this builtin is used in a
// generic context, but we can be safe.
auto &&fnArg = nextArg();
bool hasSending = ctx.LangOpts.hasFeature(Feature::SendingArgsAndResults);
auto extInfo =
ASTExtInfoBuilder()
.withAsync()
.withThrows()
.withSendable(!hasSending)
.withRepresentation(GenericFunctionType::Representation::Swift)
.build();
auto genericSig = subs.getGenericSignature().getCanonicalSignature();
auto genericResult = GenericTypeParamType::getType(/*depth*/ 0, /*index*/ 0,
SGF.getASTContext());
// <T> () async throws -> T
CanType functionTy =
GenericFunctionType::get(genericSig, {}, genericResult, extInfo)
->getCanonicalType();
AbstractionPattern origParamType(genericSig, functionTy);
CanType substParamType = fnArg.getSubstRValueType();
auto loweredParamTy = SGF.getLoweredType(origParamType, substParamType);
// The main actor path doesn't give us a value that actually matches the
// formal type at all, so this is the best we can do.
SILType loweredSubstParamTy;
if (fnArg.isRValue()) {
loweredSubstParamTy = fnArg.peekRValue().getTypeOfSingleValue();
} else {
loweredSubstParamTy = SGF.getLoweredType(substParamType);
}
auto conversion =
Conversion::getSubstToOrig(origParamType, substParamType,
loweredSubstParamTy, loweredParamTy);
return std::move(fnArg).getConverted(SGF, conversion);
}();
assert(nextArgIdx == args.size() && "didn't exhaust builtin arguments?");
SILValue builtinArgs[] = {
flags.getUnmanagedValue(),
initialExecutor.getUnmanagedValue(),
taskGroup.getUnmanagedValue(),
taskExecutorDeprecated.getUnmanagedValue(),
taskExecutorConsuming.forward(SGF),
functionValue.forward(SGF)
};
auto builtinID =
ctx.getIdentifier(getBuiltinName(BuiltinValueKind::CreateAsyncTask));
auto resultTy = SGF.getLoweredType(getAsyncTaskAndContextType(ctx));
auto apply = SGF.B.createBuiltin(loc, builtinID, resultTy, subs, builtinArgs);
return SGF.emitManagedRValueWithCleanup(apply);
}
// Emit SIL for the named builtin: createAsyncTaskInGroup.
static ManagedValue emitBuiltinCreateAsyncTaskInGroup(
SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
PreparedArguments &&args, SGFContext C) {
return emitCreateAsyncTask(SGF, loc, subs, std::move(args),
{ CreateTaskOptions::TaskGroup });
}
// Emit SIL for the named builtin: createAsyncDiscardingTaskInGroup.
static ManagedValue emitBuiltinCreateAsyncDiscardingTaskInGroup(
SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
PreparedArguments &&args, SGFContext C) {
return emitCreateAsyncTask(SGF, loc, subs, std::move(args),
{ CreateTaskOptions::TaskGroup, CreateTaskOptions::Discarding });
}
// Emit SIL for the named builtin: createAsyncTaskWithExecutor.
static ManagedValue emitBuiltinCreateAsyncTaskWithExecutor(
SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
PreparedArguments &&args, SGFContext C) {
return emitCreateAsyncTask(SGF, loc, subs, std::move(args),
{ CreateTaskOptions::TaskExecutor });
}
// Emit SIL for the named builtin: createAsyncTaskInGroupWithExecutor.
static ManagedValue emitBuiltinCreateAsyncTaskInGroupWithExecutor(
SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
PreparedArguments &&args, SGFContext C) {
return emitCreateAsyncTask(SGF, loc, subs, std::move(args),
{ CreateTaskOptions::TaskGroup, CreateTaskOptions::TaskExecutor });
}
// Emit SIL for the named builtin: createAsyncTaskInGroupWithExecutor.
static ManagedValue emitBuiltinCreateAsyncDiscardingTaskInGroupWithExecutor(
SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
PreparedArguments &&args, SGFContext C) {
return emitCreateAsyncTask(SGF, loc, subs, std::move(args),
{ CreateTaskOptions::TaskGroup, CreateTaskOptions::TaskExecutor,
CreateTaskOptions::Discarding });
}
// Emit SIL for the named builtin: createAsyncTask.
static ManagedValue emitBuiltinCreateAsyncTask(
SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
PreparedArguments &&args, SGFContext C) {
return emitCreateAsyncTask(SGF, loc, subs, std::move(args), {});
}
// Emit SIL for the named builtin: createTask.
static ManagedValue emitBuiltinCreateTask(
SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
PreparedArguments &&args, SGFContext C) {
return emitCreateAsyncTask(SGF, loc, subs, std::move(args),
{ CreateTaskOptions::OptionalEverything });
}
// Emit SIL for the named builtin: createDiscardingTask.
static ManagedValue emitBuiltinCreateDiscardingTask(
SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
PreparedArguments &&args, SGFContext C) {
return emitCreateAsyncTask(SGF, loc, subs, std::move(args),
{ CreateTaskOptions::OptionalEverything,
CreateTaskOptions::Discarding });
}
// Emit SIL for the named builtin: createTaskGroup.
// These formally take a metatype argument that's never actually used, so
// we ignore it.
static ManagedValue emitBuiltinCreateTaskGroup(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap subs,
ArrayRef<ManagedValue> args,
SGFContext C) {
auto &ctx = SGF.getASTContext();
auto resultType = SILType::getRawPointerType(ctx);
auto value = SGF.B.createBuiltin(
loc, ctx.getIdentifier(getBuiltinName(BuiltinValueKind::CreateTaskGroup)),
resultType, subs, {});
return ManagedValue::forObjectRValueWithoutOwnership(value);
}
// Emit SIL for the named builtin: createTaskGroupWithFlags.
// These formally take a metatype argument that's never actually used, so
// we ignore it.
static ManagedValue emitBuiltinCreateTaskGroupWithFlags(
SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
ArrayRef<ManagedValue> args, SGFContext C) {
auto &ctx = SGF.getASTContext();
auto resultType = SILType::getRawPointerType(ctx);
auto value = SGF.B.createBuiltin(
loc,
ctx.getIdentifier(
getBuiltinName(BuiltinValueKind::CreateTaskGroupWithFlags)),
resultType, subs, {args[0].getValue()});
return ManagedValue::forObjectRValueWithoutOwnership(value);
}
ManagedValue
SILGenFunction::emitCreateAsyncMainTask(SILLocation loc, SubstitutionMap subs,
ManagedValue flags,
ManagedValue mainFunctionRef) {
auto &ctx = getASTContext();
CanType flagsType = ctx.getIntType()->getCanonicalType();
bool hasSending = ctx.LangOpts.hasFeature(Feature::SendingArgsAndResults);
CanType functionType =
FunctionType::get(
{}, ctx.TheEmptyTupleType,
ASTExtInfo().withAsync().withThrows().withSendable(!hasSending))
->getCanonicalType();
using Param = FunctionType::Param;
PreparedArguments args({Param(flagsType), Param(functionType)});
args.add(loc, RValue(*this, loc, flagsType, flags));
args.add(loc, RValue(*this, loc, functionType, mainFunctionRef));
return emitCreateAsyncTask(*this, loc, subs, std::move(args), {});
}
// Shared implementation of withUnsafeContinuation and
// withUnsafe[Throwing]Continuation.
static ManagedValue emitBuiltinWithUnsafeContinuation(
SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
ArrayRef<ManagedValue> args, SGFContext C, bool throws) {
// Allocate space to receive the resume value when the continuation is
// resumed.
auto substResultType = subs.getReplacementTypes()[0]->getCanonicalType();
auto opaqueResumeType = SGF.getLoweredType(AbstractionPattern::getOpaque(),
substResultType);
auto resumeBuf = SGF.emitTemporaryAllocation(loc, opaqueResumeType);
// Capture the current continuation.
auto continuation = SGF.B.createGetAsyncContinuationAddr(loc, resumeBuf,
substResultType,
throws);
// Get the callee value.
auto substFnType = args[0].getType().castTo<SILFunctionType>();
SILValue fnValue = (substFnType->isCalleeConsumed()
? args[0].forward(SGF)
: args[0].getValue());
// Call the provided function value.
SGF.B.createApply(loc, fnValue, {}, {continuation});
// Await the continuation.
SILBasicBlock *resumeBlock = SGF.createBasicBlock();
SILBasicBlock *errorBlock = nullptr;
if (throws)
errorBlock = SGF.createBasicBlock(FunctionSection::Postmatter);
SGF.B.createAwaitAsyncContinuation(loc, continuation, resumeBlock, errorBlock);
// Propagate an error if we have one.
if (throws) {
SGF.B.emitBlock(errorBlock);
Scope errorScope(SGF, loc);
auto errorTy = SGF.getASTContext().getErrorExistentialType();
auto errorVal = SGF.B.createTermResult(
SILType::getPrimitiveObjectType(errorTy), OwnershipKind::Owned);
SGF.emitThrow(loc, errorVal, true);
}
SGF.B.emitBlock(resumeBlock);
// The incoming value is the maximally-abstracted result type of the
// continuation. Move it out of the resume buffer and reabstract it if
// necessary.
auto resumeResult = SGF.emitLoad(loc, resumeBuf,
AbstractionPattern::getOpaque(),
substResultType,
SGF.getTypeLowering(substResultType),
SGFContext(), IsTake);
return resumeResult;
}
// Emit SIL for the named builtin: withUnsafeContinuation
static ManagedValue emitBuiltinWithUnsafeContinuation(
SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
ArrayRef<ManagedValue> args, SGFContext C) {
return emitBuiltinWithUnsafeContinuation(SGF, loc, subs, args, C,
/*throws=*/false);
}
// Emit SIL for the named builtin: withUnsafeThrowingContinuation
static ManagedValue emitBuiltinWithUnsafeThrowingContinuation(
SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
ArrayRef<ManagedValue> args, SGFContext C) {
return emitBuiltinWithUnsafeContinuation(SGF, loc, subs, args, C,
/*throws=*/true);
}
static ManagedValue emitBuiltinHopToActor(SILGenFunction &SGF, SILLocation loc,
SubstitutionMap subs,
ArrayRef<ManagedValue> args,
SGFContext C) {
SGF.emitHopToActorValue(loc, args[0]);
return ManagedValue::forObjectRValueWithoutOwnership(SGF.emitEmptyTuple(loc));
}
static ManagedValue emitBuiltinPackLength(SILGenFunction &SGF, SILLocation loc,
SubstitutionMap subs,
ArrayRef<ManagedValue> args,
SGFContext C) {
auto argTy = args[0].getType().getASTType();
auto tupleTy = CanTupleType(argTy->getMetatypeInstanceType()
->castTo<TupleType>());
auto packTy = tupleTy.getInducedPackType();
return ManagedValue::forObjectRValueWithoutOwnership(
SGF.B.createPackLength(loc, packTy));
}
static ManagedValue emitBuiltinAutoDiffCreateLinearMapContextWithType(
SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
ArrayRef<ManagedValue> args, SGFContext C) {
ASTContext &ctx = SGF.getASTContext();
auto *builtinApply = SGF.B.createBuiltin(
loc,
ctx.getIdentifier(getBuiltinName(
BuiltinValueKind::AutoDiffCreateLinearMapContextWithType)),
SILType::getNativeObjectType(ctx), subs,
/*args*/ {args[0].getValue()});
return SGF.emitManagedRValueWithCleanup(builtinApply);
}
static ManagedValue emitBuiltinAutoDiffProjectTopLevelSubcontext(
SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
ArrayRef<ManagedValue> args, SGFContext C) {
ASTContext &ctx = SGF.getASTContext();
auto *builtinApply = SGF.B.createBuiltin(
loc,
ctx.getIdentifier(
getBuiltinName(BuiltinValueKind::AutoDiffProjectTopLevelSubcontext)),
SILType::getRawPointerType(ctx),
subs,
/*args*/ {args[0].borrow(SGF, loc).getValue()});
return ManagedValue::forObjectRValueWithoutOwnership(builtinApply);
}
static ManagedValue emitBuiltinAutoDiffAllocateSubcontextWithType(
SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
ArrayRef<ManagedValue> args, SGFContext C) {
ASTContext &ctx = SGF.getASTContext();
auto *builtinApply = SGF.B.createBuiltin(
loc,
ctx.getIdentifier(
getBuiltinName(BuiltinValueKind::AutoDiffAllocateSubcontextWithType)),
SILType::getRawPointerType(ctx), subs,
/*args*/ {args[0].borrow(SGF, loc).getValue(), args[1].getValue()});
return ManagedValue::forObjectRValueWithoutOwnership(builtinApply);
}
// The only reason these need special attention is that we want these to
// be borrowed arguments, but the default emitter doesn't handle borrowed
// arguments correctly.
static ManagedValue emitBuildExecutorRef(SILGenFunction &SGF, SILLocation loc,
SubstitutionMap subs,
ArrayRef<ManagedValue> args,
BuiltinValueKind builtin) {
ASTContext &ctx = SGF.getASTContext();
auto builtinID = ctx.getIdentifier(getBuiltinName(builtin));
SmallVector<SILValue,1> argValues;
if (!args.empty())
argValues.push_back(args[0].borrow(SGF, loc).getValue());
auto builtinApply = SGF.B.createBuiltin(loc, builtinID,
SILType::getPrimitiveObjectType(ctx.TheExecutorType),
subs, argValues);
return ManagedValue::forObjectRValueWithoutOwnership(builtinApply);
}
static ManagedValue emitBuiltinBuildOrdinaryTaskExecutorRef(
SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
ArrayRef<ManagedValue> args, SGFContext C) {
return emitBuildExecutorRef(SGF, loc, subs, args,
BuiltinValueKind::BuildOrdinaryTaskExecutorRef);
}
static ManagedValue emitBuiltinBuildOrdinarySerialExecutorRef(
SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
ArrayRef<ManagedValue> args, SGFContext C) {
return emitBuildExecutorRef(SGF, loc, subs, args,
BuiltinValueKind::BuildOrdinarySerialExecutorRef);
}
static ManagedValue emitBuiltinBuildComplexEqualitySerialExecutorRef(
SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
ArrayRef<ManagedValue> args, SGFContext C) {
return emitBuildExecutorRef(SGF, loc, subs, args,
BuiltinValueKind::BuildComplexEqualitySerialExecutorRef);
}
static ManagedValue emitBuiltinBuildDefaultActorExecutorRef(
SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
ArrayRef<ManagedValue> args, SGFContext C) {
return emitBuildExecutorRef(SGF, loc, subs, args,
BuiltinValueKind::BuildDefaultActorExecutorRef);
}
static ManagedValue emitBuiltinBuildMainActorExecutorRef(
SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
ArrayRef<ManagedValue> args, SGFContext C) {
return emitBuildExecutorRef(SGF, loc, subs, args,
BuiltinValueKind::BuildMainActorExecutorRef);
}
static ManagedValue emitBuiltinExtractFunctionIsolation(
SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
PreparedArguments &&args, SGFContext C) {
auto argSources = std::move(args).getSources();
assert(argSources.size() == 1);
auto argType = argSources[0].getSubstRValueType();
if (auto fnType = dyn_cast<AnyFunctionType>(argType);
!fnType || !fnType->getIsolation().isErased()) {
SGF.SGM.diagnose(argSources[0].getLocation(),
diag::builtin_get_function_isolation_bad_argument);
return SGF.emitUndef(SILType::getOpaqueIsolationType(SGF.getASTContext()));
}
return SGF.emitExtractFunctionIsolation(loc, std::move(argSources[0]), C);
}
static ManagedValue emitBuiltinGetEnumTag(SILGenFunction &SGF, SILLocation loc,
SubstitutionMap subs,
ArrayRef<ManagedValue> args,
SGFContext C) {
auto &ctx = SGF.getASTContext();
auto bi = SGF.B.createBuiltin(
loc, ctx.getIdentifier(getBuiltinName(BuiltinValueKind::GetEnumTag)),
SILType::getBuiltinIntegerType(32, ctx), subs,
{ args[0].getValue() });
return ManagedValue::forObjectRValueWithoutOwnership(bi);
}
static ManagedValue emitBuiltinInjectEnumTag(SILGenFunction &SGF, SILLocation loc,
SubstitutionMap subs,
ArrayRef<ManagedValue> args,
SGFContext C) {
auto &ctx = SGF.getASTContext();
auto bi = SGF.B.createBuiltin(
loc, ctx.getIdentifier(getBuiltinName(BuiltinValueKind::InjectEnumTag)),
SILType::getEmptyTupleType(ctx), subs,
{ args[0].getValue(), args[1].getValue() });
return ManagedValue::forObjectRValueWithoutOwnership(bi);
}
void SILGenModule::noteMemberRefExpr(MemberRefExpr *e) {
VarDecl *var = cast<VarDecl>(e->getMember().getDecl());
// If the member is the special `asLocalActor` operation on
// distributed actors, make sure we have the conformance needed
// for a builtin.
ASTContext &ctx = var->getASTContext();
if (isDistributedActorAsLocalActorComputedProperty(var)) {
useConformance(getDistributedActorAsActorConformanceRef(ctx));
}
}
static ManagedValue emitBuiltinDistributedActorAsAnyActor(
SILGenFunction &SGF, SILLocation loc, SubstitutionMap subs,
ArrayRef<ManagedValue> args, SGFContext C) {
return SGF.emitDistributedActorAsAnyActor(loc, subs, args[0]);
}
static ManagedValue emitBuiltinAddressOfRawLayout(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap subs,
ArrayRef<ManagedValue> args,
SGFContext C) {
auto &ctx = SGF.getASTContext();
auto bi = SGF.B.createBuiltin(
loc, ctx.getIdentifier(getBuiltinName(BuiltinValueKind::AddressOfRawLayout)),
SILType::getRawPointerType(ctx), subs,
{ args[0].getValue() });
return ManagedValue::forObjectRValueWithoutOwnership(bi);
}
static ManagedValue emitBuiltinEmplace(SILGenFunction &SGF,
SILLocation loc,
SubstitutionMap subs,
ArrayRef<ManagedValue> args,
SGFContext C) {
// TODO: deal with reabstraction of the result type
auto &Ctx = SGF.getASTContext();
auto resultASTTy = subs.getReplacementTypes()[0];
auto &loweredBufferTy = SGF.getTypeLowering(AbstractionPattern::getOpaque(),
resultASTTy);
bool didEmitInto;
Initialization *dest;
std::unique_ptr<Initialization> destOwner;
// Use the context destination if available.
if (C.getEmitInto()
&& C.getEmitInto()->canPerformInPlaceInitialization()) {
didEmitInto = true;
dest = C.getEmitInto();
} else {
didEmitInto = false;
destOwner = SGF.emitTemporary(loc, loweredBufferTy);
dest = destOwner.get();
}
auto buffer = dest->getAddressForInPlaceInitialization(SGF, loc);
// Zero-initialize the buffer.
// Aside from providing a modicum of predictability if the memory isn't
// actually initialized, this also serves to communicate to DI that the memory
// is considered initialized from this point.
auto zeroInit = getBuiltinValueDecl(Ctx,
Ctx.getIdentifier("zeroInitializer"));
SGF.B.createBuiltin(loc, zeroInit->getBaseIdentifier(),
SILType::getEmptyTupleType(Ctx),
SubstitutionMap::get(zeroInit->getInnermostDeclContext()
->getGenericSignatureOfContext(),
{resultASTTy},
LookUpConformanceInModule()),
buffer);
SILValue bufferPtr = SGF.B.createAddressToPointer(loc, buffer,
SILType::getPrimitiveObjectType(SGF.getASTContext().TheRawPointerType),
/*needs stack protection*/ true);
auto fnType = args[0].getValue()->getType().castTo<SILFunctionType>();
if (fnType->hasErrorResult()) {
auto normalBB = SGF.createBasicBlock();
auto errorBB = SGF.createBasicBlock();
SGF.B.createTryApply(loc, args[0].getValue(), {},
{SGF.IndirectErrorResult, bufferPtr}, normalBB, errorBB);
// Error branch
{
SGF.B.emitBlock(errorBB);
SGF.Cleanups.emitCleanupsForReturn(CleanupLocation(loc), IsForUnwind);
SGF.B.createThrowAddr(loc);
}
SGF.B.emitBlock(normalBB);
normalBB->createPhiArgument(SILType::getEmptyTupleType(Ctx),
OwnershipKind::Owned);
} else {
SGF.B.createApply(loc, args[0].getValue(), {}, bufferPtr);
}
dest->finishInitialization(SGF);
if (didEmitInto) {
return ManagedValue::forInContext();
}
auto resultTy = SGF.getLoweredType(subs.getReplacementTypes()[0]);
// If the result is naturally address-only, then we can adopt the stack slot
// as the value directly.
if (resultTy == loweredBufferTy.getLoweredType().getAddressType()) {
return SGF.emitManagedRValueWithCleanup(buffer);
}
// If the result is loadable, load it.
return SGF.B.createLoadTake(loc, ManagedValue::forLValue(buffer));
}
std::optional<SpecializedEmitter>
SpecializedEmitter::forDecl(SILGenModule &SGM, SILDeclRef function) {
// Only consider standalone declarations in the Builtin module.
if (function.kind != SILDeclRef::Kind::Func)
return std::nullopt;
if (!function.hasDecl())
return std::nullopt;
ValueDecl *decl = function.getDecl();
if (!isa<BuiltinUnit>(decl->getDeclContext()))
return std::nullopt;
const auto name = decl->getBaseIdentifier();
const BuiltinInfo &builtin = SGM.M.getBuiltinInfo(name);
switch (builtin.ID) {
// All the non-SIL, non-type-trait builtins should use the
// named-builtin logic, which just emits the builtin as a call to a
// builtin function. This includes builtins that aren't even declared
// in Builtins.def, i.e. all of the LLVM intrinsics.
//
// We do this in a separate pass over Builtins.def to avoid creating
// a bunch of identical cases.
#define BUILTIN(Id, Name, Attrs) \
case BuiltinValueKind::Id:
#define BUILTIN_SIL_OPERATION(Id, Name, Overload)
#define BUILTIN_MISC_OPERATION_WITH_SILGEN(Id, Name, Attrs, Overload)
#define BUILTIN_SANITIZER_OPERATION(Id, Name, Attrs)
#define BUILTIN_TYPE_CHECKER_OPERATION(Id, Name)
#define BUILTIN_TYPE_TRAIT_OPERATION(Id, Name)
#include "swift/AST/Builtins.def"
case BuiltinValueKind::None:
return SpecializedEmitter(name);
// Do a second pass over Builtins.def, ignoring all the cases for
// which we emitted something above.
#define BUILTIN(Id, Name, Attrs)
// Use specialized emitters for SIL builtins.
#define BUILTIN_SIL_OPERATION(Id, Name, Overload) \
case BuiltinValueKind::Id: \
return SpecializedEmitter(&emitBuiltin##Id);
#define BUILTIN_MISC_OPERATION_WITH_SILGEN(Id, Name, Attrs, Overload) \
case BuiltinValueKind::Id: \
return SpecializedEmitter(&emitBuiltin##Id);
// Sanitizer builtins should never directly be called; they should only
// be inserted as instrumentation by SILGen.
#define BUILTIN_SANITIZER_OPERATION(Id, Name, Attrs) \
case BuiltinValueKind::Id: \
llvm_unreachable("Sanitizer builtin called directly?");
#define BUILTIN_TYPE_CHECKER_OPERATION(Id, Name) \
case BuiltinValueKind::Id: \
llvm_unreachable( \
"Compile-time type checker operation should not make it to SIL!");
// Lower away type trait builtins when they're trivially solvable.
#define BUILTIN_TYPE_TRAIT_OPERATION(Id, Name) \
case BuiltinValueKind::Id: \
return SpecializedEmitter(&emitBuiltinTypeTrait<&TypeBase::Name, \
BuiltinValueKind::Id>);
#include "swift/AST/Builtins.def"
}
llvm_unreachable("bad builtin kind");
}
Reference in New Issue View Git Blame Copy Permalink