[Distributed] Func metadata operations and implement executeDistributedTarget entry (#40605)

* [Distributed] Implement func metadata and executeDistributedTarget

dont expose new entrypoints

able to get all the way to calling _execute

* [Distributed] reimplement distributed get type info impls

* [Distributed] comment out distributed_actor_remoteCall for now

* [Distributed] disable test on linux for now

Author: ktoso

include/swift/AST/KnownIdentifiers.def

@@ -266,6 +266,8 @@ IDENTIFIER(using)
 IDENTIFIER(assignID)
 IDENTIFIER(resignID)
 IDENTIFIER(resolve)
+IDENTIFIER(remoteCall)
+IDENTIFIER(makeInvocation)
 IDENTIFIER(system)
 IDENTIFIER(ID)
 IDENTIFIER(id)

include/swift/Demangling/Demangle.h

@@ -258,6 +258,10 @@ class Node {
   // Reverses the order of children.
   void reverseChildren(size_t StartingAt = 0);
 
+  // Find a node by its kind, traversing the node depth-first,
+  // and bailing out early if not found at the 'maxDepth'.
+  NodePointer findByKind(Node::Kind kind, int maxDepth);
+
   /// Prints the whole node tree in readable form to stderr.
   ///
   /// Useful to be called from the debugger.

include/swift/Demangling/TypeDecoder.h

@@ -1262,6 +1262,7 @@ return {}; // Not Implemented!
     // TODO: Handle OpaqueReturnType, when we're in the middle of reconstructing
     // the defining decl
     default:
+
       return MAKE_NODE_TYPE_ERROR0(Node, "unexpected kind");
     }
   }

lib/Demangling/Demangler.cpp

@@ -417,6 +417,20 @@ void Node::reverseChildren(size_t StartingAt) {
   }
 }
 
+Node* Node::findByKind(Node::Kind kind, int maxDepth) {
+  if (getKind() == kind)
+    return this;
+
+  if (maxDepth <= 0)
+    return nullptr;
+
+  for (auto node : *this)
+    if (auto matchingChild = node->findByKind(kind, maxDepth - 1))
+      return matchingChild;
+
+  return nullptr;
+}
+
 //////////////////////////////////
 // NodeFactory member functions //
 //////////////////////////////////

lib/IRGen/Callee.h

@@ -176,6 +176,7 @@ namespace irgen {
       AsyncLetGetThrowing,
       AsyncLetFinish,
       TaskGroupWaitNext,
+      DistributedExecuteTarget,
     };
 
     class Kind {
@@ -221,6 +222,7 @@ namespace irgen {
         case SpecialKind::AsyncLetWait:
         case SpecialKind::AsyncLetWaitThrowing:
         case SpecialKind::TaskGroupWaitNext:
+        case SpecialKind::DistributedExecuteTarget:
           return false;
         }
 
@@ -243,6 +245,7 @@ namespace irgen {
         case SpecialKind::AsyncLetGetThrowing:
         case SpecialKind::AsyncLetFinish:
         case SpecialKind::TaskGroupWaitNext:
+        case SpecialKind::DistributedExecuteTarget:
           return true;
         }
         llvm_unreachable("covered switch");

lib/IRGen/GenDistributed.cpp

@@ -210,7 +210,7 @@ void DistributedAccessor::computeArguments(llvm::Value *argumentBuffer,
         Address(currentOffset, IGM.getPointerAlignment()),
         IGM.getStoragePointerType(paramTy));
 
-    // 3. Adjust typed pointer to the alignement of the type.
+    // 3. Adjust typed pointer to the alignment of the type.
     auto alignedOffset = typeInfo.roundUpToTypeAlignment(IGF, eltPtr, paramTy);
 
     if (paramTy.isObject()) {

lib/IRGen/IRGenModule.h

@@ -401,7 +401,7 @@ class IRGenerator {
   /// Emit type metadata records for types without explicit protocol conformance.
   void emitTypeMetadataRecords();
 
-  /// Emit type metadata recrods for functions that can be looked up by name at
+  /// Emit type metadata records for functions that can be looked up by name at
   /// runtime.
   void emitAccessibleFunctions();
 

lib/IRGen/IRGenSIL.cpp

@@ -2573,6 +2573,9 @@ FunctionPointer::Kind irgen::classifyFunctionPointerKind(SILFunction *fn) {
 
     if (name.equals("swift_taskGroup_wait_next_throwing"))
       return SpecialKind::TaskGroupWaitNext;
+
+    if (name.equals("swift_distributed_execute_target"))
+      return SpecialKind::DistributedExecuteTarget;
   }
 
   return fn->getLoweredFunctionType();

stdlib/public/Concurrency/Actor.cpp

@@ -1721,17 +1721,21 @@ static void ::swift_distributed_execute_target_resume(
 
 SWIFT_CC(swiftasync)
 void ::swift_distributed_execute_target(
-    SWIFT_ASYNC_CONTEXT AsyncContext *callerContext, DefaultActor *actor,
-    const char *targetNameStart, size_t targetNameLength, void *argumentBuffer,
+    SWIFT_ASYNC_CONTEXT AsyncContext *callerContext,
+    DefaultActor *actor,
+    const char *targetNameStart, size_t targetNameLength,
+    void *argumentBuffer,
     void *resultBuffer) {
   auto *accessor = findDistributedAccessor(targetNameStart, targetNameLength);
-
-  if (!accessor)
-    return;
+  if (!accessor) {
+    assert(false && "no distributed accessor accessor");
+    return; // FIXME(distributed): return -1 here so the lib can fail the call
+  }
 
   auto *asyncFnPtr = reinterpret_cast<
       const AsyncFunctionPointer<DistributedAccessorSignature> *>(
       accessor->Function.get());
+  assert(asyncFnPtr && "no function pointer for distributed_execute_target");
 
   DistributedAccessorSignature::FunctionType *accessorEntry =
       asyncFnPtr->Function.get();

stdlib/public/Distributed/CMakeLists.txt

@@ -18,6 +18,7 @@ add_swift_target_library(swift_Distributed ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} I
   AssertDistributed.swift
   DistributedActor.swift
   DistributedActorSystem.swift
+  DistributedMetadata.swift
   HeterogeneousBuffer.swift
 
   SWIFT_MODULE_DEPENDS_LINUX Glibc