lib/SILGen/SILGenForeignError.cpp - third_party/swift - Git at Google

 //===--- SILGenForeignError.cpp - Error-handling code emission ------------===//
 //
 // This source file is part of the Swift.org open source project
 //
 // Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See http://swift.org/LICENSE.txt for license information
 // See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
 //
 //===----------------------------------------------------------------------===//

 #include "SILGen.h"
 #include "SILGenFunction.h"
 #include "ASTVisitor.h"
 #include "LValue.h"
 #include "RValue.h"
 #include "Scope.h"
 #include "swift/SIL/SILArgument.h"
 #include "swift/SIL/SILUndef.h"
 #include "swift/AST/ForeignErrorConvention.h"
 #include "swift/AST/DiagnosticsSIL.h"

 using namespace swift;
 using namespace Lowering;

 namespace {
   /// An abstract interface for producing bridged errors.
   struct BridgedErrorSource {
     virtual ~BridgedErrorSource() = default;
     virtual SILValue emitBridged(SILGenFunction &gen, SILLocation loc,
                                  CanType bridgedError) const = 0;
     virtual void emitRelease(SILGenFunction &gen, SILLocation loc) const = 0;
   };
 }

 /// Emit a store of a native error to the foreign-error slot.
 static void emitStoreToForeignErrorSlot(SILGenFunction &gen,
                                         SILLocation loc,
                                         SILValue foreignErrorSlot,
                                         const BridgedErrorSource &errorSrc) {
   ASTContext &ctx = gen.getASTContext();

   // The foreign error slot has type SomePointer<SomeError?>,
   // or possibly an optional thereof.

   // If the pointer itself is optional, we need to branch based on
   // whether it's really there.
   OptionalTypeKind errorPtrOptKind;
   if (SILType errorPtrObjectTy =
         foreignErrorSlot->getType()
                         .getAnyOptionalObjectType(gen.SGM.M, errorPtrOptKind)) {
     SILBasicBlock *contBB = gen.createBasicBlock();
     SILBasicBlock *noSlotBB = gen.createBasicBlock();
     SILBasicBlock *hasSlotBB = gen.createBasicBlock();
     gen.B.createSwitchEnum(loc, foreignErrorSlot, nullptr,
                  { { ctx.getOptionalSomeDecl(errorPtrOptKind), hasSlotBB },
                    { ctx.getOptionalNoneDecl(errorPtrOptKind), noSlotBB } });

     // If we have the slot, emit a store to it.
     gen.B.emitBlock(hasSlotBB);
     SILValue slot = hasSlotBB->createBBArg(errorPtrObjectTy);
     emitStoreToForeignErrorSlot(gen, loc, slot, errorSrc);
     gen.B.createBranch(loc, contBB);

     // Otherwise, just release the error.
     gen.B.emitBlock(noSlotBB);
     errorSrc.emitRelease(gen, loc);
     gen.B.createBranch(loc, contBB);

     // Continue.
     gen.B.emitBlock(contBB);
     return;
   }

   // Okay, break down the components of SomePointer<SomeError?>.
   // TODO: this should really be an unlowered AST type?
   CanType bridgedErrorPtrType =
     foreignErrorSlot->getType().getSwiftRValueType();

   PointerTypeKind ptrKind;
   CanType bridgedErrorProto =
     CanType(bridgedErrorPtrType->getAnyPointerElementType(ptrKind));

   FullExpr scope(gen.Cleanups, CleanupLocation::get(loc));
   WritebackScope writebacks(gen);

   // Convert the error to a bridged form.
   SILValue bridgedError = errorSrc.emitBridged(gen, loc, bridgedErrorProto);

   // Store to the "pointee" property.
   // If we can't find it, diagnose and then just don't store anything.
   VarDecl *pointeeProperty = ctx.getPointerPointeePropertyDecl(ptrKind);
   if (!pointeeProperty) {
     gen.SGM.diagnose(loc, diag::could_not_find_pointer_pointee_property,
                      bridgedErrorPtrType);
     return;
   }

   // Otherwise, do a normal assignment.
   LValue lvalue =
     gen.emitPropertyLValue(loc, ManagedValue::forUnmanaged(foreignErrorSlot),
                            bridgedErrorPtrType, pointeeProperty,
                            AccessKind::Write,
                            AccessSemantics::Ordinary);
   RValue rvalue(gen, loc, bridgedErrorProto,
                 gen.emitManagedRValueWithCleanup(bridgedError));
   gen.emitAssignToLValue(loc, std::move(rvalue), std::move(lvalue));
 }

 /// Emit a value of a certain integer-like type.
 static SILValue emitIntValue(SILGenFunction &gen, SILLocation loc,
                              SILType type, unsigned value) {
   if (auto structDecl = type.getStructOrBoundGenericStruct()) {
     auto properties = structDecl->getStoredProperties();
     assert(std::next(properties.begin()) == properties.end());
     SILType fieldType = type.getFieldType(*properties.begin(), gen.SGM.M);
     SILValue fieldValue = emitIntValue(gen, loc, fieldType, value);
     return gen.B.createStruct(loc, type, fieldValue);
   }

   assert(type.is<BuiltinIntegerType>());
   return gen.B.createIntegerLiteral(loc, type, value);
 }

 namespace {
   /// An error source that bridges a native error.
   class EpilogErrorSource : public BridgedErrorSource {
     SILValue NativeError;
   public:
     EpilogErrorSource(SILValue nativeError) : NativeError(nativeError) {}

     SILValue emitBridged(SILGenFunction &gen, SILLocation loc,
                          CanType bridgedErrorProto) const override {
       bool errorShouldBeOptional = false;
       CanType bridgedErrorObjectType = bridgedErrorProto;
       OptionalTypeKind optErrorKind;
       if (auto objectType =
             bridgedErrorProto.getAnyOptionalObjectType(optErrorKind)) {
         bridgedErrorObjectType = objectType;
         errorShouldBeOptional = true;
       }

       SILValue bridgedError = gen.emitNativeToBridgedError(loc,
                                 gen.emitManagedRValueWithCleanup(NativeError),
                                 bridgedErrorObjectType).forward(gen);

       // Inject into an optional if necessary.
       if (errorShouldBeOptional) {
         bridgedError =
           gen.B.createOptionalSome(loc, bridgedError, optErrorKind,
                                    gen.getLoweredType(bridgedErrorProto));
       }

       return bridgedError;
     }

     void emitRelease(SILGenFunction &gen, SILLocation loc) const override {
       gen.B.emitReleaseValueOperation(loc, NativeError);
     }
   };

   /// An error source that produces nil errors.
   class NilErrorSource : public BridgedErrorSource {
   public:
     SILValue emitBridged(SILGenFunction &gen, SILLocation loc,
                          CanType bridgedError) const override {
       SILType optTy = gen.getLoweredType(bridgedError);
       return gen.B.createOptionalNone(loc, optTy);
     }

     void emitRelease(SILGenFunction &gen, SILLocation loc) const override {
     }
   };
 }

 /// Given that we are throwing a native error, turn it into a bridged
 /// error, dispose of it in the correct way, and create the appropriate
 /// normal return value for the given foreign-error convention.
 SILValue SILGenFunction::
 emitBridgeErrorForForeignError(SILLocation loc,
                                SILValue nativeError,
                                SILType bridgedResultType,
                                SILValue foreignErrorSlot,
                                const ForeignErrorConvention &foreignError) {
   FullExpr scope(Cleanups, CleanupLocation::get(loc));

   // Store the error to the foreign error slot.
   emitStoreToForeignErrorSlot(*this, loc, foreignErrorSlot,
                               EpilogErrorSource(nativeError));

   switch (foreignError.getKind()) {
   case ForeignErrorConvention::ZeroResult:
     return emitIntValue(*this, loc, bridgedResultType, 0);
   case ForeignErrorConvention::ZeroPreservedResult:
     return emitIntValue(*this, loc, bridgedResultType, 0);
   case ForeignErrorConvention::NonZeroResult:
     return emitIntValue(*this, loc, bridgedResultType, 1);
   case ForeignErrorConvention::NilResult:
     return B.createOptionalNone(loc, bridgedResultType);
   case ForeignErrorConvention::NonNilError:
     return SILUndef::get(bridgedResultType, SGM.M);
   }
   llvm_unreachable("bad foreign error convention kind");
 }

 /// Given that we are returning a normal value, convert it to a
 /// bridged representation and set up a return value according to the
 /// given foreign-error convention.
 SILValue SILGenFunction::
 emitBridgeReturnValueForForeignError(SILLocation loc,
                                      SILValue result,
                                      SILFunctionTypeRepresentation repr,
                                      SILType bridgedType,
                                      SILValue foreignErrorSlot,
                                const ForeignErrorConvention &foreignError) {
   FullExpr scope(Cleanups, CleanupLocation::get(loc));

   switch (foreignError.getKind()) {
   // If an error is signalled by a zero result, return non-zero.
   case ForeignErrorConvention::ZeroResult:
     return emitIntValue(*this, loc, bridgedType, 1);

   // If an error is signalled by a non-zero result, return zero.
   case ForeignErrorConvention::NonZeroResult:
     return emitIntValue(*this, loc, bridgedType, 0);

   // If an error is signalled by a zero result, but we've preserved
   // the rest of the return value, then just return the normal
   // result, assuming (hoping!) that it isn't zero.
   case ForeignErrorConvention::ZeroPreservedResult:
     return result;

   // If an error is signalled by a nil result, inject a non-nil result.
   case ForeignErrorConvention::NilResult: {
     OptionalTypeKind optKind;
     auto bridgedObjectType =
       bridgedType.getSwiftRValueType().getAnyOptionalObjectType(optKind);
     ManagedValue bridgedResult =
       emitNativeToBridgedValue(loc, emitManagedRValueWithCleanup(result),
                                repr, bridgedObjectType);

     auto someResult =
       B.createOptionalSome(loc, bridgedResult.forward(*this), optKind,
                            bridgedType);
     return someResult;
   }

   // If an error is signalled by a non-nil error, be sure to store a
   // nil error there.
   case ForeignErrorConvention::NonNilError: {
     // Store nil to the foreign error slot.
     emitStoreToForeignErrorSlot(*this, loc, foreignErrorSlot, NilErrorSource());

     // The actual result value just needs to be bridged normally.
     ManagedValue bridgedValue =
       emitNativeToBridgedValue(loc, emitManagedRValueWithCleanup(result),
                                repr, bridgedType.getSwiftRValueType());
     return bridgedValue.forward(*this);
   }
   }
   llvm_unreachable("bad foreign error convention kind");
 }

 /// Step out of the current control flow to emit a foreign error block,
 /// which loads from the error slot and jumps to the error slot.
 void SILGenFunction::emitForeignErrorBlock(SILLocation loc,
                                            SILBasicBlock *errorBB,
                                            ManagedValue errorSlot) {
   SavedInsertionPoint savedIP(*this, errorBB, FunctionSection::Postmatter);

   // Load the error (taking responsibility for it).  In theory, this
   // is happening within conditional code, so we need to be only
   // conditionally claiming the value.  In practice, claiming it
   // unconditionally is fine because we want to assume it's nil in the
   // other path.
   SILValue errorV = B.createLoad(loc, errorSlot.forward(*this));
   ManagedValue error = emitManagedRValueWithCleanup(errorV);

   // Turn the error into an Error value.
   error = emitBridgedToNativeError(loc, error);

   // Propagate.
   FullExpr scope(Cleanups, CleanupLocation::get(loc));
   emitThrow(loc, error);
 }

 /// Unwrap a value of a wrapped integer type to get at the juicy
 /// Builtin.IntegerN value within.
 static SILValue emitUnwrapIntegerResult(SILGenFunction &gen,
                                         SILLocation loc,
                                         SILValue value) {
   while (!value->getType().is<BuiltinIntegerType>()) {
     auto structDecl = value->getType().getStructOrBoundGenericStruct();
     assert(structDecl && "value for error result wasn't of struct type!");
     assert(std::next(structDecl->getStoredProperties().begin())
              == structDecl->getStoredProperties().end());
     auto property = *structDecl->getStoredProperties().begin();
     value = gen.B.createStructExtract(loc, value, property);
   }

   return value;
 }

 /// Perform a foreign error check by testing whether the call result is zero.
 /// The call result is otherwise ignored.
 static void
 emitResultIsZeroErrorCheck(SILGenFunction &gen, SILLocation loc,
                            ManagedValue result, ManagedValue errorSlot,
                            bool suppressErrorCheck, bool zeroIsError) {
   // Just ignore the call result if we're suppressing the error check.
   if (suppressErrorCheck) {
     return;
   }

   SILValue resultValue =
     emitUnwrapIntegerResult(gen, loc, result.getUnmanagedValue());
   SILValue zero =
     gen.B.createIntegerLiteral(loc, resultValue->getType(), 0);

   ASTContext &ctx = gen.getASTContext();
   SILValue resultIsError =
     gen.B.createBuiltinBinaryFunction(loc,
                                       zeroIsError ? "cmp_eq" : "cmp_ne",
                                       resultValue->getType(),
                                       SILType::getBuiltinIntegerType(1, ctx),
                                       {resultValue, zero});

   SILBasicBlock *errorBB = gen.createBasicBlock(FunctionSection::Postmatter);
   SILBasicBlock *contBB = gen.createBasicBlock();
   gen.B.createCondBranch(loc, resultIsError, errorBB, contBB);

   gen.emitForeignErrorBlock(loc, errorBB, errorSlot);

   gen.B.emitBlock(contBB);
 }

 /// Perform a foreign error check by testing whether the call result is nil.
 static ManagedValue
 emitResultIsNilErrorCheck(SILGenFunction &gen, SILLocation loc,
                           ManagedValue origResult, ManagedValue errorSlot,
                           bool suppressErrorCheck) {
   // Take local ownership of the optional result value.
   SILValue optionalResult = origResult.forward(gen);

   OptionalTypeKind optKind;
   SILType resultObjectType =
     optionalResult->getType().getAnyOptionalObjectType(gen.SGM.M, optKind);

   ASTContext &ctx = gen.getASTContext();

   // If we're suppressing the check, just do an unchecked take.
   if (suppressErrorCheck) {
     SILValue objectResult =
       gen.B.createUncheckedEnumData(loc, optionalResult,
                                     ctx.getOptionalSomeDecl(optKind));
     return gen.emitManagedRValueWithCleanup(objectResult);
   }

   // Switch on the optional result.
   SILBasicBlock *errorBB = gen.createBasicBlock(FunctionSection::Postmatter);
   SILBasicBlock *contBB = gen.createBasicBlock();
   gen.B.createSwitchEnum(loc, optionalResult, /*default*/ nullptr,
                          { { ctx.getOptionalSomeDecl(optKind), contBB },
                            { ctx.getOptionalNoneDecl(optKind), errorBB } });

   // Emit the error block.
   gen.emitForeignErrorBlock(loc, errorBB, errorSlot);

   // In the continuation block, take ownership of the now non-optional
   // result value.
   gen.B.emitBlock(contBB);
   SILValue objectResult = contBB->createBBArg(resultObjectType);
   return gen.emitManagedRValueWithCleanup(objectResult);
 }

 /// Perform a foreign error check by testing whether the error was nil.
 static void
 emitErrorIsNonNilErrorCheck(SILGenFunction &gen, SILLocation loc,
                             ManagedValue errorSlot, bool suppressErrorCheck) {
   // If we're suppressing the check, just don't check.
   if (suppressErrorCheck) return;

   SILValue optionalError = gen.B.createLoad(loc, errorSlot.getValue());

   OptionalTypeKind optKind;
   optionalError->getType().getAnyOptionalObjectType(gen.SGM.M, optKind);

   ASTContext &ctx = gen.getASTContext();

   // Switch on the optional error.
   SILBasicBlock *errorBB = gen.createBasicBlock(FunctionSection::Postmatter);
   SILBasicBlock *contBB = gen.createBasicBlock();
   gen.B.createSwitchEnum(loc, optionalError, /*default*/ nullptr,
                          { { ctx.getOptionalSomeDecl(optKind), errorBB },
                            { ctx.getOptionalNoneDecl(optKind), contBB } });

   // Emit the error block.  Just be lazy and reload the error there.
   gen.emitForeignErrorBlock(loc, errorBB, errorSlot);

   // Return the result.
   gen.B.emitBlock(contBB);
   return;
 }

 /// Emit a check for whether a non-native function call produced an
 /// error.
 ///
 /// \c results should be left with only values that match the formal
 /// direct results of the function.
 void
 SILGenFunction::emitForeignErrorCheck(SILLocation loc,
                                       SmallVectorImpl<ManagedValue> &results,
                                       ManagedValue errorSlot,
                                       bool suppressErrorCheck,
                                 const ForeignErrorConvention &foreignError) {
   // All of this is autogenerated.
   loc.markAutoGenerated();

   switch (foreignError.getKind()) {
   case ForeignErrorConvention::ZeroPreservedResult:
     assert(results.size() == 1);
     emitResultIsZeroErrorCheck(*this, loc, results[0], errorSlot,
                                suppressErrorCheck,
                                /*zeroIsError*/ true);
     return;
   case ForeignErrorConvention::ZeroResult:
     assert(results.size() == 1);
     emitResultIsZeroErrorCheck(*this, loc, results.pop_back_val(),
                                errorSlot, suppressErrorCheck,
                                /*zeroIsError*/ true);
     return;
   case ForeignErrorConvention::NonZeroResult:
     assert(results.size() == 1);
     emitResultIsZeroErrorCheck(*this, loc, results.pop_back_val(),
                                errorSlot, suppressErrorCheck,
                                /*zeroIsError*/ false);
     return;
   case ForeignErrorConvention::NilResult:
     assert(results.size() == 1);
     results[0] = emitResultIsNilErrorCheck(*this, loc, results[0], errorSlot,
                                            suppressErrorCheck);
     return;
   case ForeignErrorConvention::NonNilError:
     // Leave the direct results alone.
     emitErrorIsNonNilErrorCheck(*this, loc, errorSlot, suppressErrorCheck);
     return;
   }
   llvm_unreachable("bad foreign error convention kind");
 }
	//===--- SILGenForeignError.cpp - Error-handling code emission ------------===//
	//
	// This source file is part of the Swift.org open source project
	//
	// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
	// Licensed under Apache License v2.0 with Runtime Library Exception
	//
	// See http://swift.org/LICENSE.txt for license information
	// See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
	//
	//===----------------------------------------------------------------------===//

	#include "SILGen.h"
	#include "SILGenFunction.h"
	#include "ASTVisitor.h"
	#include "LValue.h"
	#include "RValue.h"
	#include "Scope.h"
	#include "swift/SIL/SILArgument.h"
	#include "swift/SIL/SILUndef.h"
	#include "swift/AST/ForeignErrorConvention.h"
	#include "swift/AST/DiagnosticsSIL.h"

	using namespace swift;
	using namespace Lowering;

	namespace {
	/// An abstract interface for producing bridged errors.
	struct BridgedErrorSource {
	virtual ~BridgedErrorSource() = default;
	virtual SILValue emitBridged(SILGenFunction &gen, SILLocation loc,
	CanType bridgedError) const = 0;
	virtual void emitRelease(SILGenFunction &gen, SILLocation loc) const = 0;
	};
	}

	/// Emit a store of a native error to the foreign-error slot.
	static void emitStoreToForeignErrorSlot(SILGenFunction &gen,
	SILLocation loc,
	SILValue foreignErrorSlot,
	const BridgedErrorSource &errorSrc) {
	ASTContext &ctx = gen.getASTContext();

	// The foreign error slot has type SomePointer<SomeError?>,
	// or possibly an optional thereof.

	// If the pointer itself is optional, we need to branch based on
	// whether it's really there.
	OptionalTypeKind errorPtrOptKind;
	if (SILType errorPtrObjectTy =
	foreignErrorSlot->getType()
	.getAnyOptionalObjectType(gen.SGM.M, errorPtrOptKind)) {
	SILBasicBlock *contBB = gen.createBasicBlock();
	SILBasicBlock *noSlotBB = gen.createBasicBlock();
	SILBasicBlock *hasSlotBB = gen.createBasicBlock();
	gen.B.createSwitchEnum(loc, foreignErrorSlot, nullptr,
	{ { ctx.getOptionalSomeDecl(errorPtrOptKind), hasSlotBB },
	{ ctx.getOptionalNoneDecl(errorPtrOptKind), noSlotBB } });

	// If we have the slot, emit a store to it.
	gen.B.emitBlock(hasSlotBB);
	SILValue slot = hasSlotBB->createBBArg(errorPtrObjectTy);
	emitStoreToForeignErrorSlot(gen, loc, slot, errorSrc);
	gen.B.createBranch(loc, contBB);

	// Otherwise, just release the error.
	gen.B.emitBlock(noSlotBB);
	errorSrc.emitRelease(gen, loc);
	gen.B.createBranch(loc, contBB);

	// Continue.
	gen.B.emitBlock(contBB);
	return;
	}

	// Okay, break down the components of SomePointer<SomeError?>.
	// TODO: this should really be an unlowered AST type?
	CanType bridgedErrorPtrType =
	foreignErrorSlot->getType().getSwiftRValueType();

	PointerTypeKind ptrKind;
	CanType bridgedErrorProto =
	CanType(bridgedErrorPtrType->getAnyPointerElementType(ptrKind));

	FullExpr scope(gen.Cleanups, CleanupLocation::get(loc));
	WritebackScope writebacks(gen);

	// Convert the error to a bridged form.
	SILValue bridgedError = errorSrc.emitBridged(gen, loc, bridgedErrorProto);

	// Store to the "pointee" property.
	// If we can't find it, diagnose and then just don't store anything.
	VarDecl *pointeeProperty = ctx.getPointerPointeePropertyDecl(ptrKind);
	if (!pointeeProperty) {
	gen.SGM.diagnose(loc, diag::could_not_find_pointer_pointee_property,
	bridgedErrorPtrType);
	return;
	}

	// Otherwise, do a normal assignment.
	LValue lvalue =
	gen.emitPropertyLValue(loc, ManagedValue::forUnmanaged(foreignErrorSlot),
	bridgedErrorPtrType, pointeeProperty,
	AccessKind::Write,
	AccessSemantics::Ordinary);
	RValue rvalue(gen, loc, bridgedErrorProto,
	gen.emitManagedRValueWithCleanup(bridgedError));
	gen.emitAssignToLValue(loc, std::move(rvalue), std::move(lvalue));
	}

	/// Emit a value of a certain integer-like type.
	static SILValue emitIntValue(SILGenFunction &gen, SILLocation loc,
	SILType type, unsigned value) {
	if (auto structDecl = type.getStructOrBoundGenericStruct()) {
	auto properties = structDecl->getStoredProperties();
	assert(std::next(properties.begin()) == properties.end());
	SILType fieldType = type.getFieldType(*properties.begin(), gen.SGM.M);
	SILValue fieldValue = emitIntValue(gen, loc, fieldType, value);
	return gen.B.createStruct(loc, type, fieldValue);
	}

	assert(type.is<BuiltinIntegerType>());
	return gen.B.createIntegerLiteral(loc, type, value);
	}

	namespace {
	/// An error source that bridges a native error.
	class EpilogErrorSource : public BridgedErrorSource {
	SILValue NativeError;
	public:
	EpilogErrorSource(SILValue nativeError) : NativeError(nativeError) {}

	SILValue emitBridged(SILGenFunction &gen, SILLocation loc,
	CanType bridgedErrorProto) const override {
	bool errorShouldBeOptional = false;
	CanType bridgedErrorObjectType = bridgedErrorProto;
	OptionalTypeKind optErrorKind;
	if (auto objectType =
	bridgedErrorProto.getAnyOptionalObjectType(optErrorKind)) {
	bridgedErrorObjectType = objectType;
	errorShouldBeOptional = true;
	}

	SILValue bridgedError = gen.emitNativeToBridgedError(loc,
	gen.emitManagedRValueWithCleanup(NativeError),
	bridgedErrorObjectType).forward(gen);

	// Inject into an optional if necessary.
	if (errorShouldBeOptional) {
	bridgedError =
	gen.B.createOptionalSome(loc, bridgedError, optErrorKind,
	gen.getLoweredType(bridgedErrorProto));
	}

	return bridgedError;
	}

	void emitRelease(SILGenFunction &gen, SILLocation loc) const override {
	gen.B.emitReleaseValueOperation(loc, NativeError);
	}
	};

	/// An error source that produces nil errors.
	class NilErrorSource : public BridgedErrorSource {
	public:
	SILValue emitBridged(SILGenFunction &gen, SILLocation loc,
	CanType bridgedError) const override {
	SILType optTy = gen.getLoweredType(bridgedError);
	return gen.B.createOptionalNone(loc, optTy);
	}

	void emitRelease(SILGenFunction &gen, SILLocation loc) const override {
	}
	};
	}

	/// Given that we are throwing a native error, turn it into a bridged
	/// error, dispose of it in the correct way, and create the appropriate
	/// normal return value for the given foreign-error convention.
	SILValue SILGenFunction::
	emitBridgeErrorForForeignError(SILLocation loc,
	SILValue nativeError,
	SILType bridgedResultType,
	SILValue foreignErrorSlot,
	const ForeignErrorConvention &foreignError) {
	FullExpr scope(Cleanups, CleanupLocation::get(loc));

	// Store the error to the foreign error slot.
	emitStoreToForeignErrorSlot(*this, loc, foreignErrorSlot,
	EpilogErrorSource(nativeError));

	switch (foreignError.getKind()) {
	case ForeignErrorConvention::ZeroResult:
	return emitIntValue(*this, loc, bridgedResultType, 0);
	case ForeignErrorConvention::ZeroPreservedResult:
	return emitIntValue(*this, loc, bridgedResultType, 0);
	case ForeignErrorConvention::NonZeroResult:
	return emitIntValue(*this, loc, bridgedResultType, 1);
	case ForeignErrorConvention::NilResult:
	return B.createOptionalNone(loc, bridgedResultType);
	case ForeignErrorConvention::NonNilError:
	return SILUndef::get(bridgedResultType, SGM.M);
	}
	llvm_unreachable("bad foreign error convention kind");
	}

	/// Given that we are returning a normal value, convert it to a
	/// bridged representation and set up a return value according to the
	/// given foreign-error convention.
	SILValue SILGenFunction::
	emitBridgeReturnValueForForeignError(SILLocation loc,
	SILValue result,
	SILFunctionTypeRepresentation repr,
	SILType bridgedType,
	SILValue foreignErrorSlot,
	const ForeignErrorConvention &foreignError) {
	FullExpr scope(Cleanups, CleanupLocation::get(loc));

	switch (foreignError.getKind()) {
	// If an error is signalled by a zero result, return non-zero.
	case ForeignErrorConvention::ZeroResult:
	return emitIntValue(*this, loc, bridgedType, 1);

	// If an error is signalled by a non-zero result, return zero.
	case ForeignErrorConvention::NonZeroResult:
	return emitIntValue(*this, loc, bridgedType, 0);

	// If an error is signalled by a zero result, but we've preserved
	// the rest of the return value, then just return the normal
	// result, assuming (hoping!) that it isn't zero.
	case ForeignErrorConvention::ZeroPreservedResult:
	return result;

	// If an error is signalled by a nil result, inject a non-nil result.
	case ForeignErrorConvention::NilResult: {
	OptionalTypeKind optKind;
	auto bridgedObjectType =
	bridgedType.getSwiftRValueType().getAnyOptionalObjectType(optKind);
	ManagedValue bridgedResult =
	emitNativeToBridgedValue(loc, emitManagedRValueWithCleanup(result),
	repr, bridgedObjectType);

	auto someResult =
	B.createOptionalSome(loc, bridgedResult.forward(*this), optKind,
	bridgedType);
	return someResult;
	}

	// If an error is signalled by a non-nil error, be sure to store a
	// nil error there.
	case ForeignErrorConvention::NonNilError: {
	// Store nil to the foreign error slot.
	emitStoreToForeignErrorSlot(*this, loc, foreignErrorSlot, NilErrorSource());

	// The actual result value just needs to be bridged normally.
	ManagedValue bridgedValue =
	emitNativeToBridgedValue(loc, emitManagedRValueWithCleanup(result),
	repr, bridgedType.getSwiftRValueType());
	return bridgedValue.forward(*this);
	}
	}
	llvm_unreachable("bad foreign error convention kind");
	}

	/// Step out of the current control flow to emit a foreign error block,
	/// which loads from the error slot and jumps to the error slot.
	void SILGenFunction::emitForeignErrorBlock(SILLocation loc,
	SILBasicBlock *errorBB,
	ManagedValue errorSlot) {
	SavedInsertionPoint savedIP(*this, errorBB, FunctionSection::Postmatter);

	// Load the error (taking responsibility for it). In theory, this
	// is happening within conditional code, so we need to be only
	// conditionally claiming the value. In practice, claiming it
	// unconditionally is fine because we want to assume it's nil in the
	// other path.
	SILValue errorV = B.createLoad(loc, errorSlot.forward(*this));
	ManagedValue error = emitManagedRValueWithCleanup(errorV);

	// Turn the error into an Error value.
	error = emitBridgedToNativeError(loc, error);

	// Propagate.
	FullExpr scope(Cleanups, CleanupLocation::get(loc));
	emitThrow(loc, error);
	}

	/// Unwrap a value of a wrapped integer type to get at the juicy
	/// Builtin.IntegerN value within.
	static SILValue emitUnwrapIntegerResult(SILGenFunction &gen,
	SILLocation loc,
	SILValue value) {
	while (!value->getType().is<BuiltinIntegerType>()) {
	auto structDecl = value->getType().getStructOrBoundGenericStruct();
	assert(structDecl && "value for error result wasn't of struct type!");
	assert(std::next(structDecl->getStoredProperties().begin())
	== structDecl->getStoredProperties().end());
	auto property = *structDecl->getStoredProperties().begin();
	value = gen.B.createStructExtract(loc, value, property);
	}

	return value;
	}

	/// Perform a foreign error check by testing whether the call result is zero.
	/// The call result is otherwise ignored.
	static void
	emitResultIsZeroErrorCheck(SILGenFunction &gen, SILLocation loc,
	ManagedValue result, ManagedValue errorSlot,
	bool suppressErrorCheck, bool zeroIsError) {
	// Just ignore the call result if we're suppressing the error check.
	if (suppressErrorCheck) {
	return;
	}

	SILValue resultValue =
	emitUnwrapIntegerResult(gen, loc, result.getUnmanagedValue());
	SILValue zero =
	gen.B.createIntegerLiteral(loc, resultValue->getType(), 0);

	ASTContext &ctx = gen.getASTContext();
	SILValue resultIsError =
	gen.B.createBuiltinBinaryFunction(loc,
	zeroIsError ? "cmp_eq" : "cmp_ne",
	resultValue->getType(),
	SILType::getBuiltinIntegerType(1, ctx),
	{resultValue, zero});

	SILBasicBlock *errorBB = gen.createBasicBlock(FunctionSection::Postmatter);
	SILBasicBlock *contBB = gen.createBasicBlock();
	gen.B.createCondBranch(loc, resultIsError, errorBB, contBB);

	gen.emitForeignErrorBlock(loc, errorBB, errorSlot);

	gen.B.emitBlock(contBB);
	}

	/// Perform a foreign error check by testing whether the call result is nil.
	static ManagedValue
	emitResultIsNilErrorCheck(SILGenFunction &gen, SILLocation loc,
	ManagedValue origResult, ManagedValue errorSlot,
	bool suppressErrorCheck) {
	// Take local ownership of the optional result value.
	SILValue optionalResult = origResult.forward(gen);

	OptionalTypeKind optKind;
	SILType resultObjectType =
	optionalResult->getType().getAnyOptionalObjectType(gen.SGM.M, optKind);

	ASTContext &ctx = gen.getASTContext();

	// If we're suppressing the check, just do an unchecked take.
	if (suppressErrorCheck) {
	SILValue objectResult =
	gen.B.createUncheckedEnumData(loc, optionalResult,
	ctx.getOptionalSomeDecl(optKind));
	return gen.emitManagedRValueWithCleanup(objectResult);
	}

	// Switch on the optional result.
	SILBasicBlock *errorBB = gen.createBasicBlock(FunctionSection::Postmatter);
	SILBasicBlock *contBB = gen.createBasicBlock();
	gen.B.createSwitchEnum(loc, optionalResult, /default/ nullptr,
	{ { ctx.getOptionalSomeDecl(optKind), contBB },
	{ ctx.getOptionalNoneDecl(optKind), errorBB } });

	// Emit the error block.
	gen.emitForeignErrorBlock(loc, errorBB, errorSlot);

	// In the continuation block, take ownership of the now non-optional
	// result value.
	gen.B.emitBlock(contBB);
	SILValue objectResult = contBB->createBBArg(resultObjectType);
	return gen.emitManagedRValueWithCleanup(objectResult);
	}

	/// Perform a foreign error check by testing whether the error was nil.
	static void
	emitErrorIsNonNilErrorCheck(SILGenFunction &gen, SILLocation loc,
	ManagedValue errorSlot, bool suppressErrorCheck) {
	// If we're suppressing the check, just don't check.
	if (suppressErrorCheck) return;

	SILValue optionalError = gen.B.createLoad(loc, errorSlot.getValue());

	OptionalTypeKind optKind;
	optionalError->getType().getAnyOptionalObjectType(gen.SGM.M, optKind);

	ASTContext &ctx = gen.getASTContext();

	// Switch on the optional error.
	SILBasicBlock *errorBB = gen.createBasicBlock(FunctionSection::Postmatter);
	SILBasicBlock *contBB = gen.createBasicBlock();
	gen.B.createSwitchEnum(loc, optionalError, /default/ nullptr,
	{ { ctx.getOptionalSomeDecl(optKind), errorBB },
	{ ctx.getOptionalNoneDecl(optKind), contBB } });

	// Emit the error block. Just be lazy and reload the error there.
	gen.emitForeignErrorBlock(loc, errorBB, errorSlot);

	// Return the result.
	gen.B.emitBlock(contBB);
	return;
	}

	/// Emit a check for whether a non-native function call produced an
	/// error.
	///
	/// \c results should be left with only values that match the formal
	/// direct results of the function.
	void
	SILGenFunction::emitForeignErrorCheck(SILLocation loc,
	SmallVectorImpl<ManagedValue> &results,
	ManagedValue errorSlot,
	bool suppressErrorCheck,
	const ForeignErrorConvention &foreignError) {
	// All of this is autogenerated.
	loc.markAutoGenerated();

	switch (foreignError.getKind()) {
	case ForeignErrorConvention::ZeroPreservedResult:
	assert(results.size() == 1);
	emitResultIsZeroErrorCheck(*this, loc, results[0], errorSlot,
	suppressErrorCheck,
	/zeroIsError/ true);
	return;
	case ForeignErrorConvention::ZeroResult:
	assert(results.size() == 1);
	emitResultIsZeroErrorCheck(*this, loc, results.pop_back_val(),
	errorSlot, suppressErrorCheck,
	/zeroIsError/ true);
	return;
	case ForeignErrorConvention::NonZeroResult:
	assert(results.size() == 1);
	emitResultIsZeroErrorCheck(*this, loc, results.pop_back_val(),
	errorSlot, suppressErrorCheck,
	/zeroIsError/ false);
	return;
	case ForeignErrorConvention::NilResult:
	assert(results.size() == 1);
	results[0] = emitResultIsNilErrorCheck(*this, loc, results[0], errorSlot,
	suppressErrorCheck);
	return;
	case ForeignErrorConvention::NonNilError:
	// Leave the direct results alone.
	emitErrorIsNonNilErrorCheck(*this, loc, errorSlot, suppressErrorCheck);
	return;
	}
	llvm_unreachable("bad foreign error convention kind");
	}