[SGF][Distributed] emitStringLiteral and use it in distributed

Author: ktoso

lib/SILGen/SILGenApply.cpp

@@ -1658,7 +1658,7 @@ class SILGenApply : public Lowering::ExprVisitor<SILGenApply> {
 } // end anonymous namespace
 
 // TODO: move onto SGF directly and reuse in SILGenDistributed and other places
-static PreparedArguments emitStringLiteral(SILGenFunction &SGF, Expr *E,
+static PreparedArguments emitStringLiteralArgs(SILGenFunction &SGF, SILLocation E,
                                            StringRef Str, SGFContext C,
                                         StringLiteralExpr::Encoding encoding) {
   uint64_t Length;
@@ -1695,7 +1695,6 @@ static PreparedArguments emitStringLiteral(SILGenFunction &SGF, Expr *E,
   auto Int1Ty = SILType::getBuiltinIntegerType(1, SGF.getASTContext());
   auto *isASCIIInst = SGF.B.createIntegerLiteral(E, Int1Ty, isASCII);
 
-
   ManagedValue EltsArray[] = {
     ManagedValue::forUnmanaged(string),
     ManagedValue::forUnmanaged(lengthInst),
@@ -1840,7 +1839,7 @@ static bool hasUnownedInnerPointerResult(CanSILFunctionType fnType) {
 static inline PreparedArguments
 buildBuiltinLiteralArgs(SILGenFunction &SGF, SGFContext C,
                         StringLiteralExpr *stringLiteral) {
-  return emitStringLiteral(SGF, stringLiteral, stringLiteral->getValue(), C,
+  return emitStringLiteralArgs(SGF, stringLiteral, stringLiteral->getValue(), C,
                            stringLiteral->getEncoding());
 }
 
@@ -1902,7 +1901,7 @@ buildBuiltinLiteralArgs(SILGenFunction &SGF, SGFContext C,
                         RegexLiteralExpr *expr) {
   auto &ctx = SGF.getASTContext();
   // %0 = string_literal <regex text>
-  auto strLiteralArgs = emitStringLiteral(SGF, expr, expr->getRegexText(), C,
+  auto strLiteralArgs = emitStringLiteralArgs(SGF, expr, expr->getRegexText(), C,
                                           StringLiteralExpr::Encoding::UTF8);
   // %1 = function_ref String.init(
   //   _builtinStringLiteral:utf8CodeUnitCount:isASCII:)
@@ -1949,20 +1948,20 @@ buildBuiltinLiteralArgs(SILGenFunction &SGF, SGFContext C,
   case MagicIdentifierLiteralExpr::FileIDSpelledAsFile:
   case MagicIdentifierLiteralExpr::FileID: {
     std::string value = loc.isValid() ? SGF.getMagicFileIDString(loc) : "";
-    return emitStringLiteral(SGF, magicLiteral, value, C,
+    return emitStringLiteralArgs(SGF, magicLiteral, value, C,
                              magicLiteral->getStringEncoding());
   }
 
   case MagicIdentifierLiteralExpr::FilePathSpelledAsFile:
   case MagicIdentifierLiteralExpr::FilePath: {
     StringRef value = loc.isValid() ? SGF.getMagicFilePathString(loc) : "";
-    return emitStringLiteral(SGF, magicLiteral, value, C,
+    return emitStringLiteralArgs(SGF, magicLiteral, value, C,
                              magicLiteral->getStringEncoding());
   }
 
   case MagicIdentifierLiteralExpr::Function: {
     StringRef value = loc.isValid() ? SGF.getMagicFunctionString() : "";
-    return emitStringLiteral(SGF, magicLiteral, value, C,
+    return emitStringLiteralArgs(SGF, magicLiteral, value, C,
                              magicLiteral->getStringEncoding());
   }
 
@@ -2012,6 +2011,24 @@ static inline PreparedArguments buildBuiltinLiteralArgs(SILGenFunction &SGF,
   }
 }
 
+ManagedValue SILGenFunction::emitStringLiteral(SILLocation loc,
+                                           StringRef text,
+                                           StringLiteralExpr::Encoding encoding,
+                                           SGFContext ctx) {
+  auto &C = getASTContext();
+
+  // === Prepare the arguments
+  auto args = emitStringLiteralArgs(*this, loc, text, ctx, encoding);
+
+  // === Find the constructor
+  auto strInitDecl = C.getStringBuiltinInitDecl(C.getStringDecl());
+
+  RValue r = emitApplyAllocatingInitializer(loc, strInitDecl, std::move(args),
+                                 /*overriddenSelfType*/ Type(), ctx);
+
+  return std::move(r).getScalarValue();
+}
+
 //===----------------------------------------------------------------------===//
 //                             Argument Emission
 //===----------------------------------------------------------------------===//

lib/SILGen/SILGenDistributed.cpp

@@ -29,7 +29,6 @@
 #include "swift/Basic/Defer.h"
 #include "swift/SIL/SILArgument.h"
 #include "swift/SIL/SILDeclRef.h"
-#include "swift/SIL/SILUndef.h"
 #include "swift/SIL/TypeLowering.h"
 #include "swift/SILOptimizer/Utils/DistributedActor.h"
 
@@ -1320,9 +1319,6 @@ void SILGenFunction::emitDistributedThunk(SILDeclRef thunk) {
       B.emitBlock(makeRemoteCallTargetBB);
       createVoidPhiArgument(*this, ctx, makeRemoteCallTargetBB);
 
-      auto mangledName = thunk.mangle(SILDeclRef::ManglingKind::Default);
-      auto mangledNameRef = llvm::StringRef(mangledName.c_str(), mangledName.size()); // FIXME(distributed): can just pass the mangledName?
-
       // --- Get the `RemoteCallTarget` type
 
       // %28 = alloc_stack $RemoteCallTarget, let, name "target" // users: %58, %57, %50, %77, %76, %37
@@ -1333,43 +1329,10 @@ void SILGenFunction::emitDistributedThunk(SILDeclRef thunk) {
       auto remoteCallTargetMetatype = getLoweredType(MetatypeType::get(remoteCallTargetTy));
       auto remoteCallTargetMetatypeValue = B.createMetatype(loc, remoteCallTargetMetatype);
 
-      // %30 = string_literal utf8 "MANGLED_NAME" // user: %35
-      auto mangledNameLiteral =
-          B.createStringLiteral(loc, mangledNameRef,
-                                StringLiteralInst::Encoding::UTF8);
-
-      // %31 = integer_literal $Builtin.Word, 12 // user: %35
-      auto codeUnitCountLiteral =
-          B.createIntegerLiteral(loc,
-                                 SILType::getBuiltinWordType(ctx),
-                                 mangledName.size());
-
-      // %32 = integer_literal $Builtin.Int1, -1 // user: %35
-      auto isAsciiLiteral =
-          B.createIntegerLiteral(loc,
-                                 SILType::getBuiltinIntegerType(1, ctx),
-                                 -1);
-
-      // %33 = metatype $@thin String.Type // user: %35
-      auto StringMetaTy = CanMetatypeType::get(CanType(ctx.getStringType()), MetatypeRepresentation::Thin);
-      auto stringSelf =
-          B.createMetatype(loc,
-                           SILType::getPrimitiveObjectType(StringMetaTy));
-
-      // // function_ref String.init(_builtinStringLiteral:utf8CodeUnitCount:isASCII:)
-      // %34 = function_ref @$sSS21_builtinStringLiteral17utf8CodeUnitCount7isASCIISSBp_BwBi1_tcfC : $@convention(method) (Builtin.RawPointer, Builtin.Word, Builtin.Int1, @thin String.Type) -> @owned String // user: %35
-      auto stringInitDeclRef = ctx.getStringBuiltinInitDecl(ctx.getStringDecl());
-      auto stringInitRef = SILDeclRef(stringInitDeclRef.getDecl(), SILDeclRef::Kind::Allocator);
-      // NotForDefinition since it seems the body of the init function is not there yet:
-       auto stringInitFn = builder.getOrCreateFunction(loc, stringInitRef, NotForDefinition);
-      auto stringInitFnRef = B.createFunctionRef(loc, stringInitFn);
-
-      // %35 = apply %34(%30, %31, %32, %33) : $@convention(method) (Builtin.RawPointer, Builtin.Word, Builtin.Int1, @thin String.Type) -> @owned String // user: %37
-      // auto x = std::move(mangledNameLiteral).getScalarValue()
-      auto mangledNameStringValue =
-          B.createApply(loc, stringInitFnRef, {},
-                        /*args*/{mangledNameLiteral, codeUnitCountLiteral,
-                         isAsciiLiteral, stringSelf});
+      auto mangledName = thunk.mangle(SILDeclRef::ManglingKind::Default);
+      auto mangledNameRef = llvm::StringRef(mangledName.c_str(), mangledName.size()); // FIXME(distributed): can just pass the mangledName?
+
+      auto mangledNameString = emitStringLiteral(loc, mangledNameRef); // FIXME(distributed): trouble with the cleanups running in error BB too...
 
       // --- Create the RemoteCallTarget instance, passing the mangledNameString
       // function_ref RemoteCallTarget.init(_mangledName:)
@@ -1384,7 +1347,7 @@ void SILGenFunction::emitDistributedThunk(SILDeclRef thunk) {
       // %37 = apply %36(%28, %35, %29) : $@convention(method) (@owned String, @thin RemoteCallTarget.Type) -> @out RemoteCallTarget
       B.createApply(
           loc, remoteCallTargetInitFn, {},
-          {/*out*/ remoteCallTargetValue.getValue(), mangledNameStringValue,
+          {/*out*/ remoteCallTargetValue.getValue(), mangledNameString.forward(*this),
            remoteCallTargetMetatypeValue});
 
       // === Prepare `actorSystem.remoteCall()` --------------------------------

lib/SILGen/SILGenFunction.h

@@ -1072,6 +1072,13 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   SourceLocArgs
   emitSourceLocationArgs(SourceLoc loc, SILLocation emitLoc);
 
+  ManagedValue
+  emitStringLiteral(SILLocation loc,
+                    StringRef text,
+                    StringLiteralExpr::Encoding encoding = StringLiteralExpr::Encoding::UTF8,
+                    SGFContext ctx = SGFContext());
+
+
   /// Emit a call to the library intrinsic _doesOptionalHaveValue.
   ///
   /// The result is a Builtin.Int1.