ManagedValue SILGenBuilder::formalAccessBufferForExpr( SILLocation loc, SILType ty, const TypeLowering &lowering, SGFContext context, llvm::function_ref<void(SILValue)> rvalueEmitter) { // If we have a single-buffer "emit into" initialization, use that for the // result. SILValue address = context.getAddressForInPlaceInitialization(SGF, loc); // If we couldn't emit into the Initialization, emit into a temporary // allocation. if (!address) { address = SGF.emitTemporaryAllocation(loc, ty.getObjectType()); } rvalueEmitter(address); // If we have a single-buffer "emit into" initialization, use that for the // result. if (context.finishInPlaceInitialization(SGF)) { return ManagedValue::forInContext(); } // Add a cleanup for the temporary we allocated. if (lowering.isTrivial()) return ManagedValue::forUnmanaged(address); return SGF.emitFormalAccessManagedBufferWithCleanup(loc, address); }
ManagedValue SILGenBuilder::createLoadTake(SILLocation loc, ManagedValue v, const TypeLowering &lowering) { assert(lowering.getLoweredType().getAddressType() == v.getType()); SILValue result = lowering.emitLoadOfCopy(*this, loc, v.forward(SGF), IsTake); if (lowering.isTrivial()) return ManagedValue::forUnmanaged(result); assert(!lowering.isAddressOnly() && "cannot retain an unloadable type"); return SGF.emitManagedRValueWithCleanup(result, lowering); }
ManagedValue SILGenBuilder::createCopyValue(SILLocation loc, ManagedValue originalValue, const TypeLowering &lowering) { if (lowering.isTrivial()) return originalValue; SILType ty = originalValue.getType(); assert(!ty.isAddress() && "Can not perform a copy value of an address typed " "value"); if (ty.isObject() && originalValue.getOwnershipKind() == ValueOwnershipKind::Any) { return originalValue; } SILValue result = lowering.emitCopyValue(*this, loc, originalValue.getValue()); return SGF.emitManagedRValueWithCleanup(result, lowering); }