[Distributed] Undo new record and mangling scheme for dist.p.witnesses

This change undoes an approach we thought viable to encode distributed
actor remote targets, as encoding their protocol method names. This also
needed extra metadata sections and tricky "find if this is a witness or
not" methods;

Instead, we will be mangling the concrete names; and special handle
proxy types that are prefixed with `$`. This way we will not need extra
metadata records, and can handle generic calls more properly.

This XFAILs one test which was testing new functionality, that is
pending now until we implement the new mangling scheme.

Author: ktoso

include/swift/RemoteInspection/RuntimeHeaders/llvm/BinaryFormat/Swift.def

@@ -30,6 +30,4 @@ HANDLE_SWIFT_SECTION(protocs, "__swift5_protos", "swift5_protocols",
                      ".sw5prt$B")
 HANDLE_SWIFT_SECTION(acfuncs, "__swift5_acfuncs", "swift5_accessible_functions",
                      ".sw5acfn$B")
-HANDLE_SWIFT_SECTION(dacfuncs, "__swift5_acpfuns", "swift5_accessible_protocol_requirement_functions",
-                     ".sw5acpfn$B")
 HANDLE_SWIFT_SECTION(mpenum, "__swift5_mpenum", "swift5_mpenum", ".sw5mpen$B")

include/swift/Runtime/Config.h

@@ -307,10 +307,6 @@ extern uintptr_t __COMPATIBILITY_LIBRARIES_CANNOT_CHECK_THE_IS_SWIFT_BIT_DIRECTL
 #define __ptrauth_swift_accessible_function_record                             \
   __ptrauth(ptrauth_key_process_independent_data, 1,                           \
             SpecialPointerAuthDiscriminators::AccessibleFunctionRecord)
-#define __ptrauth_swift_accessible_protocol_requirement_function_record        \
-  __ptrauth(ptrauth_key_process_independent_data, 1,                           \
-            SpecialPointerAuthDiscriminators::                                 \
-                AccessibleProtocolRequirementFunctionRecord)
 #define __ptrauth_swift_objc_superclass                                        \
   __ptrauth(ptrauth_key_process_independent_data, 1,                           \
             swift::SpecialPointerAuthDiscriminators::ObjCSuperclass)
@@ -359,7 +355,6 @@ extern uintptr_t __COMPATIBILITY_LIBRARIES_CANNOT_CHECK_THE_IS_SWIFT_BIT_DIRECTL
 #define __ptrauth_swift_escalation_notification_function
 #define __ptrauth_swift_dispatch_invoke_function
 #define __ptrauth_swift_accessible_function_record
-#define __ptrauth_swift_accessible_protocol_requirement_function_record
 #define __ptrauth_swift_objc_superclass
 #define __ptrauth_swift_runtime_function_entry
 #define __ptrauth_swift_runtime_function_entry_with_key(__key)

lib/AST/DistributedDecl.cpp

@@ -390,6 +390,7 @@ bool swift::checkDistributedSerializationRequirementIsExactlyCodable(
       std::count(protocols.begin(), protocols.end(), decodable) == 1;
 }
 
+// TODO(distributed): probably can be removed?
 llvm::ArrayRef<ValueDecl *>
 AbstractFunctionDecl::getDistributedMethodWitnessedProtocolRequirements() const {
   auto mutableThis = const_cast<AbstractFunctionDecl *>(this);

lib/IRGen/GenDecl.cpp

@@ -4417,14 +4417,6 @@ void IRGenModule::addAccessibleFunction(SILFunction *func) {
   AccessibleFunctions.push_back(func);
 }
 
-void IRGenModule::addAccessibleFunctionDistributedAliased(
-    std::string mangledRecordName,
-    std::optional<std::string> mangledActorTypeName,
-    SILFunction *func) {
-  AccessibleProtocolFunctions.push_back(AccessibleProtocolFunctionsData(
-      func, mangledRecordName, mangledActorTypeName));
-}
-
 /// Emit the protocol conformance list and return it (if asContiguousArray is
 /// true, otherwise the records are emitted as individual globals and
 /// nullptr is returned).
@@ -4748,11 +4740,10 @@ void IRGenModule::emitAccessibleFunction(
 }
 
 void IRGenModule::emitAccessibleFunctions() {
-  if (AccessibleFunctions.empty() && AccessibleProtocolFunctions.empty())
+  if (AccessibleFunctions.empty())
     return;
 
   StringRef fnsSectionName;
-  StringRef protocolFnsSectionName;
   switch (TargetInfo.OutputObjectFormat) {
   case llvm::Triple::DXContainer:
   case llvm::Triple::GOFF:
@@ -4762,17 +4753,14 @@ void IRGenModule::emitAccessibleFunctions() {
                      "the selected object format.");
   case llvm::Triple::MachO:
     fnsSectionName = "__TEXT, __swift5_acfuncs, regular";
-    protocolFnsSectionName = "__TEXT, __swift5_acpfuns, regular";
     break;
   case llvm::Triple::ELF:
   case llvm::Triple::Wasm:
     fnsSectionName = "swift5_accessible_functions";
-    protocolFnsSectionName = "swift5_accessible_protocol_requirement_functions";
     break;
   case llvm::Triple::XCOFF:
   case llvm::Triple::COFF:
     fnsSectionName = ".sw5acfn$B";
-    protocolFnsSectionName = ".sw5acpfn$B";
     break;
   }
 
@@ -4786,24 +4774,6 @@ void IRGenModule::emitAccessibleFunctions() {
         fnsSectionName, mangledRecordName,
         /*mangledActorName=*/{}, mangledFunctionName, func);
   }
-
-  for (auto accessibleInfo : AccessibleProtocolFunctions) {
-    auto func = accessibleInfo.function;
-
-    std::string mangledRecordName =
-        accessibleInfo.mangledRecordName
-            ? (*accessibleInfo.mangledRecordName)
-            : LinkEntity::forAccessibleFunctionRecord(func).mangleAsString();
-    std::string mangledFunctionName =
-        LinkEntity::forSILFunction(func).mangleAsString();
-    std::string mangledActorName = accessibleInfo.concreteMangledTypeName
-                                       ? *accessibleInfo.concreteMangledTypeName
-                                       : "<none>";
-
-    emitAccessibleFunction(
-        protocolFnsSectionName, mangledRecordName,
-        mangledActorName, mangledFunctionName, func);
-  }
 }
 
 /// Fetch a global reference to a reference to the given Objective-C class.

lib/IRGen/IRGenModule.cpp

@@ -2232,8 +2232,3 @@ bool swift::writeEmptyOutputFilesFor(
   }
   return false;
 }
-IRGenModule::AccessibleProtocolFunctionsData::AccessibleProtocolFunctionsData(
-    SILFunction *function, const std::optional<std::string> &mangledRecordName,
-    const std::optional<std::string> &concreteMangledTypeName)
-    : function(function), mangledRecordName(mangledRecordName),
-      concreteMangledTypeName(concreteMangledTypeName) {}

lib/IRGen/IRGenModule.h

@@ -1152,10 +1152,6 @@ class IRGenModule {
   void addObjCClassStub(llvm::Constant *addr);
   void addProtocolConformance(ConformanceDescription &&conformance);
   void addAccessibleFunction(SILFunction *func);
-  void addAccessibleFunctionDistributedAliased(
-      std::string mangledRecordName,
-      std::optional<std::string> mangledActorTypeName,
-      SILFunction *func);
 
   llvm::Constant *emitSwiftProtocols(bool asContiguousArray);
   llvm::Constant *emitProtocolConformances(bool asContiguousArray);
@@ -1314,25 +1310,6 @@ class IRGenModule {
   /// up at runtime.
   SmallVector<SILFunction *, 4> AccessibleFunctions;
 
-  struct AccessibleProtocolFunctionsData {
-    SILFunction *function;
-    /// Mangled name of the requirement function.
-    std::optional<std::string> mangledRecordName;
-    std::optional<std::string> concreteMangledTypeName;
-    AccessibleProtocolFunctionsData(
-        SILFunction *function,
-        const std::optional<std::string> &mangledRecordName,
-        const std::optional<std::string> &concreteMangledTypeName);
-  };
-  /// List of all functions which are protocol *requirements* which may be
-  /// looked up by name at runtime. The record can be used to pair
-  /// a concrete implementation type with the protocol (record) name,
-  /// in order to locate the *witness* function name on this specific type.
-  ///
-  /// The witness function name can then be used to look up the witness at
-  /// runtime by inspecting `AccessibleFunctions`.
-  SmallVector<AccessibleProtocolFunctionsData, 4> AccessibleProtocolFunctions;
-
   /// Map of Objective-C protocols and protocol references, bitcast to i8*.
   /// The interesting global variables relating to an ObjC protocol.
   struct ObjCProtocolPair {

lib/IRGen/IRGenSIL.cpp

@@ -2476,36 +2476,7 @@ void IRGenSILFunction::emitSILFunction() {
     IGM.emitDistributedTargetAccessor(CurSILFn);
     IGM.addAccessibleFunction(CurSILFn);
 
-    if (auto val = CurSILFn->getLocation().castToASTNode<ValueDecl>()) {
-      if (auto attr =
-              val->getAttrs().getAttribute<DistributedThunkTargetAttr>()) {
-
-        // the original `distributed func`
-        auto func = attr->getTargetFunction();
-
-        auto distributedRequirements = func->getDistributedMethodWitnessedProtocolRequirements();
-        if (distributedRequirements.size() == 1) {
-          auto protocolFunc = distributedRequirements.front();
-          Mangle::ASTMangler mangler;
-          // The mangled name of the requirement is the name of the record
-          auto mangledProtocolFuncName =
-            mangler.mangleDistributedThunk(cast<FuncDecl>(protocolFunc));
-
-          std::optional<std::string> mangledActorTypeName;
-          if (isa<ClassDecl>(func->getDeclContext()->getAsDecl())) {
-            // a concrete type, not a "distributed" protocol
-            mangledActorTypeName = mangler.mangleAnyDecl(
-                func->getDeclContext()->getSelfNominalTypeDecl(),
-                /*prefix=*/true);
-          }
-
-          IGM.addAccessibleFunctionDistributedAliased(
-              /*mangledRecordName=*/mangledProtocolFuncName,
-              /*mangledActorTypeName=*/mangledActorTypeName,
-              CurSILFn);
-        }
-      }
-    }
+    // TODO(distributed): for protocols emit a special accessor
   }
 
   // Configure the dominance resolver.

lib/Sema/CodeSynthesisDistributedActor.cpp

@@ -195,6 +195,17 @@ static void forwardParameters(AbstractFunctionDecl *afd,
   }
 }
 
+static llvm::StringRef
+mangleDistributedThunkForAccessorRecordName(
+    ASTContext &C, AbstractFunctionDecl *thunk) {
+  Mangle::ASTMangler mangler;
+
+  // default mangling
+  auto mangled =
+      C.AllocateCopy(mangler.mangleDistributedThunk(cast<FuncDecl>(thunk)));
+  return mangled;
+}
+
 static std::pair<BraceStmt *, bool>
 deriveBodyDistributed_thunk(AbstractFunctionDecl *thunk, void *context) {
   auto implicit = true;
@@ -519,34 +530,12 @@ deriveBodyDistributed_thunk(AbstractFunctionDecl *thunk, void *context) {
 
   {
     // --- Mangle the thunk name
-    Mangle::ASTMangler mangler;
-
-    // FIXME: cleanup
-    StringLiteralExpr *mangledTargetStringLiteral = nullptr;
-    auto witnessedDistributedRequirements =
-        func->getDistributedMethodWitnessedProtocolRequirements();
-
-    if (witnessedDistributedRequirements.size() == 1) {
-      auto protocolFunc = witnessedDistributedRequirements.front();
-
-      // we expect to witness exactly one distributed requirement,
-      // otherwise we should have diagnosed errors about more than 1 already.
-      std::string mangledString =
-          mangler.mangleDistributedThunk(cast<FuncDecl>(protocolFunc));
-      // FIXME: make it THUNK so the mangling is right
-      // MUST BE LIKE: s4main28GreeterP_ConcreteSystem_StubC5greetSSyYaKFTE
-
-      StringRef mangled = C.AllocateCopy(mangledString);
-      mangledTargetStringLiteral =
-          new (C) StringLiteralExpr(mangled, SourceRange(), implicit);
-    } else {
-      // default mangling
-      auto mangled =
-          C.AllocateCopy(mangler.mangleDistributedThunk(cast<FuncDecl>(thunk)));
-      mangledTargetStringLiteral =
-          new (C) StringLiteralExpr(mangled, SourceRange(), implicit);
-    }
-    assert(mangledTargetStringLiteral && "must be initialized");
+    auto mangledAccessorRecordName =
+        mangleDistributedThunkForAccessorRecordName(C, thunk);
+
+    StringLiteralExpr *mangledTargetStringLiteral =
+        new (C) StringLiteralExpr(mangledAccessorRecordName,
+                                  SourceRange(), implicit);
 
     // --- let target = RemoteCallTarget(<mangled name>)
     targetVar->setInterfaceType(remoteCallTargetTy);

stdlib/public/Distributed/DistributedActor.cpp

@@ -32,94 +32,6 @@ findDistributedAccessor(const char *targetNameStart, size_t targetNameLength) {
   return nullptr;
 }
 
-/// Find an accessible function record given a concrete actor type we're
-/// attempting to make the call on, and the remote call method identifier.
-static const AccessibleFunctionRecord *findDistributedProtocolMethodAccessor(
-    bool findConcreteWitness, const char *targetActorTypeNameStart,
-    size_t targetActorTypeNameLength, const char *targetNameStart,
-    size_t targetNameLength) {
-  // Find using just the method identifier;
-  // This will work if the call is a concrete method identifier
-  if (auto *func = runtime::swift_findAccessibleFunctionForConcreteType(
-          findConcreteWitness, targetActorTypeNameStart,
-          targetActorTypeNameLength, targetNameStart, targetNameLength)) {
-    assert(func->Flags.isDistributed());
-    return func;
-  }
-
-  return nullptr;
-}
-
-/// Given the presence of protocol witness distributed invocation targets,
-/// obtain a concrete target name.
-///
-/// A distributed target can be identified by a protocol method name:
-/// ```
-/// protocol WorkerProtocol {
-///   associatedtype Ret
-///   distributed func func test() -> Ret
-/// }
-/// ```
-///
-/// So the remote call identifier may be "WorkerProtocol.test", however in order
-/// to perform the invocation on a concrete target actor, we need to obtain
-/// the concrete function we are about to invoke -- not least because of
-/// its generic context details.
-///
-/// A concrete type on the server may be:
-///
-/// ```
-/// distributed actor WorkerImpl: WorkerProtocol {
-///   distributed func func test() -> String { "Hello" }
-/// }
-/// ```
-///
-/// Thus this method allows mapping the "protocol method identifier" and
-/// concrete actor name, into the target witness name.
-///
-/// This way the generic context and other concrete information may be obtained
-/// in order to perform the call on the concrete `WorkerImpl` type.
-SWIFT_CC(swift)
-SWIFT_EXPORT_FROM(swiftDistributed)
-TypeNamePair swift_distributed_getConcreteAccessibleWitnessName(
-    DefaultActor *actor, const char *targetNameStart, size_t targetNameLength) {
-
-  // TODO(distributed): Avoid mangling twice; we do it here and in `execute_`
-  auto actorTy = swift_getObjectType(actor);
-  auto actorTyNamePair = swift_getMangledTypeName(actorTy);
-  std::string actorTyName = actorTyNamePair.data;
-
-  auto accessor = findDistributedProtocolMethodAccessor(
-      /*findConcreteWitness=*/true, actorTyNamePair.data,
-      actorTyNamePair.length, targetNameStart, targetNameLength);
-
-  if (!accessor) {
-    return {"", 0};
-  }
-
-  auto concreteNameData = accessor->Name.get();
-  auto concreteNameLength = strlen(accessor->Name.get());
-  return {concreteNameData, concreteNameLength};
-}
-
-SWIFT_CC(swift)
-SWIFT_EXPORT_FROM(swiftDistributed)
-void *swift_distributed_getGenericEnvironmentForConcreteActor(
-    DefaultActor *actor, const char *targetNameStart, size_t targetNameLength) {
-
-  // TODO(distributed): Avoid mangling  twice; we do it here and in `execute_`
-  auto actorTy = swift_getObjectType(actor);
-  auto actorTyNamePair = swift_getMangledTypeName(actorTy);
-
-  auto *accessor = findDistributedProtocolMethodAccessor(
-      /*findConcreteWitness=*/true, actorTyNamePair.data,
-      actorTyNamePair.length, targetNameStart, targetNameLength);
-  if (!accessor) {
-    return nullptr;
-  }
-
-  return accessor->GenericEnvironment.get();
-}
 
 SWIFT_CC(swift)
 SWIFT_EXPORT_FROM(swiftDistributed)
@@ -141,9 +53,7 @@ void *swift_distributed_getGenericEnvironment(const char *targetNameStart,
 ///    numWitnessTables: UInt
 /// ) async throws
 using TargetExecutorSignature =
-    AsyncSignature<void(/*on=*/DefaultActor *, // FIXME(distributed): Make this
-                                               // accept AnyObject and not
-                                               // witness tables
+    AsyncSignature<void(/*on=*/DefaultActor *,
                         /*targetName=*/const char *, /*targetNameSize=*/size_t,
                         /*argumentDecoder=*/HeapObject *,
                         /*argumentTypes=*/const Metadata *const *,