Merge pull request swiftlang#29680 from gottesmm/pr-5cabc7ee4a3e006145b5d4716d59ba51ba0c547b

[builtin] Add a new SIL builtin convertStrongToUnsafeUnowned()

Author: gottesmm

include/swift/AST/Builtins.def

@@ -444,6 +444,31 @@ BUILTIN_SIL_OPERATION(AllocWithTailElems, "allocWithTailElems", Special)
 /// Projects the first tail-allocated element of type E from a class C.
 BUILTIN_SIL_OPERATION(ProjectTailElems, "projectTailElems", Special)
 
+/// Unsafely convert a value of type T to an unowned value.
+///
+/// It has type (T, @inout @unowned(unsafe) T) -> (). The reason for the weird
+/// signature is to work around issues with results in SILGen builtin emission.
+BUILTIN_SIL_OPERATION(ConvertStrongToUnownedUnsafe, "convertStrongToUnownedUnsafe", Special)
+
+/// Unsafely convert a value of type @inout @unowned(unsafe) T to a loaded
+/// guaranteed T value that has a lifetime guaranteed by the passed in base
+/// value of type BaseTy.
+///
+/// It has type (@in_guaranteed BaseTy, @in_guaranteed @unowned (unsafe) T) -> @guaranteed T.
+///
+/// NOTE: Saying the result is a guaranteed T is a bit of a misnomer. We aren't
+/// emitting a builtin call, but are just emitting SIL directly.
+///
+/// NOTE: Even though the signature is as mentioned above, we actually tell the
+/// AST we have the signature:
+///
+///   <BaseT, T, U> (BaseT, T) -> U
+///
+/// We then perform the actual type checking in SILGen and assert on
+/// failure. This is an early, unsupported feature so this is sufficient for
+/// now.
+BUILTIN_SIL_OPERATION(ConvertUnownedUnsafeToGuaranteed, "convertUnownedUnsafeToGuaranteed", Special)
+
 #undef BUILTIN_SIL_OPERATION
 
 // BUILTIN_RUNTIME_CALL - A call into a runtime function.
@@ -634,6 +659,12 @@ BUILTIN_MISC_OPERATION(PoundAssert, "poundAssert", "", Special)
 
 // BUILTIN_MISC_OPERATION_WITH_SILGEN - Miscellaneous operations that are
 // specially emitted during SIL generation.
+//
+// The intention is that this is meant for builtins that need a named
+// builtin representation so one can create a builtin instruction in
+// SIL, but that also need special SILGen behavior. If an operation
+// just emits custom SIL and does not need to be able to form a
+// builtin instruction, please use BUILTIN_SIL_OPERATION.
 #ifndef BUILTIN_MISC_OPERATION_WITH_SILGEN
 #define BUILTIN_MISC_OPERATION_WITH_SILGEN(Id, Name, Attrs, Overload) \
   BUILTIN_MISC_OPERATION(Id, Name, Attrs, Overload)

include/swift/SIL/SILType.h

@@ -459,6 +459,24 @@ class SILType {
     return SILType(getASTType().getReferenceStorageReferent(), getCategory());
   }
 
+  /// Return the reference ownership of this type if it is a reference storage
+  /// type. Otherwse, return None.
+  Optional<ReferenceOwnership> getReferenceStorageOwnership() const {
+    auto type = getASTType()->getAs<ReferenceStorageType>();
+    if (!type)
+      return None;
+    return type->getOwnership();
+  }
+
+  /// Attempt to wrap the passed in type as a type with reference ownership \p
+  /// ownership. For simplicity, we always return an address since reference
+  /// storage types may not be loadable (e.x.: weak ownership).
+  SILType getReferenceStorageType(const ASTContext &ctx,
+                                  ReferenceOwnership ownership) const {
+    auto *type = ReferenceStorageType::get(getASTType(), ownership, ctx);
+    return SILType::getPrimitiveAddressType(type->getCanonicalType());
+  }
+
   /// Transform the function type SILType by replacing all of its interface
   /// generic args with the appropriate item from the substitution.
   ///

lib/AST/Builtins.cpp

@@ -940,6 +940,38 @@ static ValueDecl *getGlobalStringTablePointer(ASTContext &Context,
   return getBuiltinFunction(Id, {stringType}, Context.TheRawPointerType);
 }
 
+static ValueDecl *getConvertStrongToUnownedUnsafe(ASTContext &ctx,
+                                                  Identifier id) {
+  // We actually want this:
+  //
+  // (T, inout unowned (unsafe) T) -> ()
+  //
+  // But for simplicity, we actually accept T, U and do the checking
+  // in the emission method that everything works up. This is a
+  // builtin, so we can crash.
+  BuiltinFunctionBuilder builder(ctx, 2);
+  builder.addParameter(makeGenericParam(0));
+  builder.addParameter(makeGenericParam(1), ValueOwnership::InOut);
+  builder.setResult(makeConcrete(TupleType::getEmpty(ctx)));
+  return builder.build(id);
+}
+
+static ValueDecl *getConvertUnownedUnsafeToGuaranteed(ASTContext &ctx,
+                                                      Identifier id) {
+  // We actually want this:
+  //
+  ///   <BaseT, T> (BaseT, @inout unowned(unsafe) T) -> T
+  //
+  // But for simplicity, we actually accept three generic params T, U and do the
+  // checking in the emission method that everything works up. This is a
+  // builtin, so we can crash.
+  BuiltinFunctionBuilder builder(ctx, 3);
+  builder.addParameter(makeGenericParam(0));                        // Base
+  builder.addParameter(makeGenericParam(1), ValueOwnership::InOut); // Unmanaged
+  builder.setResult(makeGenericParam(2)); // Guaranteed Result
+  return builder.build(id);
+}
+
 static ValueDecl *getPoundAssert(ASTContext &Context, Identifier Id) {
   auto int1Type = BuiltinIntegerType::get(1, Context);
   auto optionalRawPointerType = BoundGenericEnumType::get(
@@ -1996,6 +2028,12 @@ ValueDecl *swift::getBuiltinValueDecl(ASTContext &Context, Identifier Id) {
   case BuiltinValueKind::GlobalStringTablePointer:
     return getGlobalStringTablePointer(Context, Id);
 
+  case BuiltinValueKind::ConvertStrongToUnownedUnsafe:
+    return getConvertStrongToUnownedUnsafe(Context, Id);
+
+  case BuiltinValueKind::ConvertUnownedUnsafeToGuaranteed:
+    return getConvertUnownedUnsafeToGuaranteed(Context, Id);
+
   case BuiltinValueKind::PoundAssert:
     return getPoundAssert(Context, Id);
 

lib/SIL/ValueOwnership.cpp

@@ -547,7 +547,6 @@ UNOWNED_OR_NONE_DEPENDING_ON_RESULT(ZeroInitializer)
       BuiltinInst *BI, StringRef Attr) { \
     llvm_unreachable("builtin should have been lowered in SILGen"); \
   }
-
 #include "swift/AST/Builtins.def"
 
 ValueOwnershipKind

lib/SILGen/LValue.h

@@ -405,7 +405,16 @@ class LValue {
     assert(&component == Path.back().get());
     Path.pop_back();
   }
-  
+
+  /// Pop the last component off this LValue unsafely. Validates that the
+  /// component is of kind \p kind as a sanity check.
+  ///
+  /// Please be careful when using this!
+  void unsafelyDropLastComponent(PathComponent::KindTy kind) & {
+    assert(kind == Path.back()->getKind());
+    Path.pop_back();
+  }
+
   /// Add a new component at the end of the access path of this lvalue.
   template <class T, class... As>
   void add(As &&... args) {

lib/SILGen/SILGenBuilder.cpp

@@ -844,3 +844,12 @@ ManagedValue SILGenBuilder::createProjectBox(SILLocation loc, ManagedValue mv,
   auto *pbi = createProjectBox(loc, mv.getValue(), index);
   return ManagedValue::forUnmanaged(pbi);
 }
+
+ManagedValue SILGenBuilder::createMarkDependence(SILLocation loc,
+                                                 ManagedValue value,
+                                                 ManagedValue base) {
+  CleanupCloner cloner(*this, value);
+  auto *mdi = createMarkDependence(loc, value.forward(getSILGenFunction()),
+                                   base.forward(getSILGenFunction()));
+  return cloner.clone(mdi);
+}

lib/SILGen/SILGenBuilder.h

@@ -368,6 +368,10 @@ class SILGenBuilder : public SILBuilder {
   using SILBuilder::createProjectBox;
   ManagedValue createProjectBox(SILLocation loc, ManagedValue mv,
                                 unsigned index);
+
+  using SILBuilder::createMarkDependence;
+  ManagedValue createMarkDependence(SILLocation loc, ManagedValue value,
+                                    ManagedValue base);
 };
 
 } // namespace Lowering

lib/SILGen/SILGenBuiltin.cpp

@@ -1045,6 +1045,123 @@ emitBuiltinGlobalStringTablePointer(SILGenFunction &SGF, SILLocation loc,
   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 Optional<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::forUnmanaged(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().getOptionalObjectType()) {
+    llvm::errs()
+        << "Invalid usage of Builtin.convertStrongToUnownedUnsafe. lhsType "
+           "must be T and rhsType must be inout unsafe(unowned) Optional<T>"
+        << "lhsType: " << objectSrcValue->getType() << "\n"
+        << "rhsType: " << inoutDest->getType() << "\n";
+    llvm::report_fatal_error("standard fatal error msg");
+  }
+
+  // Ok. We have the right types. First convert objectSrcValue to its
+  // unowned representation.
+  SILType optionalType = SILType::getOptionalType(objectSrcValue->getType());
+  SILValue someVal =
+      SGF.B.createOptionalSome(loc, objectSrcValue, optionalType);
+
+  SILType unmanagedOptType = someVal->getType().getReferenceStorageType(
+      SGF.getASTContext(), ReferenceOwnership::Unmanaged);
+  SILValue unownedObjectSrcValue = SGF.B.createRefToUnmanaged(
+      loc, someVal, unmanagedOptType.getObjectType());
+  SGF.B.emitStoreValueOperation(loc, unownedObjectSrcValue, inoutDest,
+                                StoreOwnershipQualifier::Trivial);
+  return ManagedValue::forUnmanaged(SGF.emitEmptyTuple(loc));
+}
+
+/// Emit SIL for the named builtin: convertUnownedUnsafeToGuaranteed.
+///
+/// We assume our convention is:
+///
+/// <BaseT, T> (BaseT, @in_guaranteed @unmanaged Optional<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::forUnmanaged(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, ValueOwnershipKind::Guaranteed);
+  auto guaranteedNonTrivialRefMV =
+      SGF.emitManagedBorrowedRValueWithCleanup(guaranteedNonTrivialRef);
+  auto someDecl = SGF.getASTContext().getOptionalSomeDecl();
+
+  // Then unsafely extract from the optional.
+  auto extMV =
+      SGF.B.createUncheckedEnumData(loc, guaranteedNonTrivialRefMV, someDecl);
+
+  // Now create a mark dependence on our base and return the result.
+  return SGF.B.createMarkDependence(loc, extMV, baseMV);
+}
+
 Optional<SpecializedEmitter>
 SpecializedEmitter::forDecl(SILGenModule &SGM, SILDeclRef function) {
   // Only consider standalone declarations in the Builtin module.

lib/SILGen/SILGenExpr.cpp

@@ -297,6 +297,30 @@ SILGenFunction::emitManagedBorrowedRValueWithCleanup(SILValue original,
   return emitManagedBorrowedRValueWithCleanup(original, borrowed, lowering);
 }
 
+ManagedValue
+SILGenFunction::emitManagedBorrowedRValueWithCleanup(SILValue borrowed) {
+  auto &lowering = getTypeLowering(borrowed->getType());
+  return emitManagedBorrowedRValueWithCleanup(borrowed, lowering);
+}
+
+ManagedValue SILGenFunction::emitManagedBorrowedRValueWithCleanup(
+    SILValue borrowed, const TypeLowering &lowering) {
+  assert(lowering.getLoweredType().getObjectType() ==
+         borrowed->getType().getObjectType());
+  if (lowering.isTrivial())
+    return ManagedValue::forUnmanaged(borrowed);
+
+  if (borrowed->getType().isObject() &&
+      borrowed.getOwnershipKind() == ValueOwnershipKind::None)
+    return ManagedValue::forUnmanaged(borrowed);
+
+  if (borrowed->getType().isObject()) {
+    Cleanups.pushCleanup<EndBorrowCleanup>(borrowed);
+  }
+
+  return ManagedValue(borrowed, CleanupHandle::invalid());
+}
+
 ManagedValue SILGenFunction::emitManagedBorrowedRValueWithCleanup(
     SILValue original, SILValue borrowed, const TypeLowering &lowering) {
   assert(lowering.getLoweredType().getObjectType() ==

lib/SILGen/SILGenFunction.h

@@ -1338,6 +1338,11 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
                                       const TypeLowering &lowering);
   ManagedValue emitManagedBeginBorrow(SILLocation loc, SILValue v);
 
+  ManagedValue
+  emitManagedBorrowedRValueWithCleanup(SILValue borrowedValue,
+                                       const TypeLowering &lowering);
+  ManagedValue emitManagedBorrowedRValueWithCleanup(SILValue borrowedValue);
+
   ManagedValue emitManagedBorrowedRValueWithCleanup(SILValue original,
                                                     SILValue borrowedValue);
   ManagedValue emitManagedBorrowedRValueWithCleanup(