[CoroutineAccessors] Witness and vtable dispatch.

And thunking.

Author: nate-chandler

include/swift/Demangling/DemangleNodes.def

@@ -408,6 +408,7 @@ NODE(DependentGenericInverseConformanceRequirement)
 NODE(Integer)
 NODE(NegativeInteger)
 NODE(DependentGenericParamValueMarker)
+NODE(CoroFunctionPointer)
 
 #undef CONTEXT_NODE
 #undef NODE

include/swift/IRGen/Linking.h

@@ -585,6 +585,11 @@ class LinkEntity {
     /// The pointer is the llvm::Function* for a partial apply forwarder.
     PartialApplyForwarderCoroFunctionPointer,
 
+    /// An coro function pointer to a function which is known to exist whose
+    /// name is known.
+    /// The pointer is a const char* of the name.
+    KnownCoroFunctionPointer,
+
     /// An coro function pointer for a distributed accessor (method or
     /// property).
     /// The pointer is a SILFunction*.
@@ -1553,6 +1558,15 @@ class LinkEntity {
     return entity;
   }
 
+  static LinkEntity forKnownCoroFunctionPointer(const char *name) {
+    LinkEntity entity;
+    entity.Pointer = const_cast<char *>(name);
+    entity.SecondaryPointer = nullptr;
+    entity.Data =
+        LINKENTITY_SET_FIELD(Kind, unsigned(Kind::KnownCoroFunctionPointer));
+    return entity;
+  }
+
   LinkEntity getUnderlyingEntityForCoroFunctionPointer() const {
     LinkEntity entity;
     entity.Pointer = Pointer;

include/swift/SIL/SILDeclRef.h

@@ -612,6 +612,7 @@ struct SILDeclRef {
   }
 
   bool hasAsync() const;
+  bool isCalleeAllocatedCoroutine() const;
 
 private:
   friend struct llvm::DenseMapInfo<swift::SILDeclRef>;

lib/AST/Decl.cpp

@@ -10931,7 +10931,7 @@ bool AccessorDecl::isRequirementWithSynthesizedDefaultImplementation() const {
   if (!requiresFeatureCoroutineAccessors(getAccessorKind())) {
     return false;
   }
-  if (getStorage()->getOverrideLoc()) {
+  if (!requiresNewWitnessTableEntry()) {
     return false;
   }
   return getStorage()->requiresCorrespondingUnderscoredCoroutineAccessor(

lib/Demangling/NodePrinter.cpp

@@ -657,6 +657,7 @@ class NodePrinter {
     case Node::Kind::ObjectiveCProtocolSymbolicReference:
     case Node::Kind::DependentGenericInverseConformanceRequirement:
     case Node::Kind::DependentGenericParamValueMarker:
+    case Node::Kind::CoroFunctionPointer:
       return false;
     }
     printer_unreachable("bad node kind");
@@ -3478,6 +3479,9 @@ NodePointer NodePrinter::print(NodePointer Node, unsigned depth,
     Printer << signedValue;
     return nullptr;
   }
+  case Node::Kind::CoroFunctionPointer:
+    Printer << "coro function pointer to ";
+    return nullptr;
   }
 
   printer_unreachable("bad node kind!");

lib/IRGen/Callee.h

@@ -206,9 +206,11 @@ namespace irgen {
     FunctionPointerKind(SpecialKind kind)
       : value(unsigned(kind) + SpecialOffset) {}
     FunctionPointerKind(CanSILFunctionType fnType)
-      : FunctionPointerKind(fnType->isAsync()
-                              ? BasicKind::AsyncFunctionPointer
-                              : BasicKind::Function) {}
+        : FunctionPointerKind(fnType->isAsync()
+                                  ? BasicKind::AsyncFunctionPointer
+                              : fnType->isCalleeAllocatedCoroutine()
+                                  ? BasicKind::CoroFunctionPointer
+                                  : BasicKind::Function) {}
 
     static FunctionPointerKind defaultSync() {
       return BasicKind::Function;

lib/IRGen/GenCall.cpp

@@ -5151,13 +5151,11 @@ static llvm::Constant *getCoroAllocWrapperFn(IRGenModule &IGM) {
       /*optionalLinkageOverride=*/nullptr, llvm::CallingConv::SwiftCoro);
 }
 
-void irgen::emitYieldOnce2CoroutineEntry(
-    IRGenFunction &IGF, LinkEntity coroFunction, CanSILFunctionType fnType,
-    NativeCCEntryPointArgumentEmission &emission) {
-  auto *buffer = emission.getCoroutineBuffer();
-  auto cfp = cast<llvm::GlobalVariable>(
-      IGF.IGM.getAddrOfCoroFunctionPointer(coroFunction));
-  llvm::Value *allocator = emission.getCoroutineAllocator();
+void irgen::emitYieldOnce2CoroutineEntry(IRGenFunction &IGF,
+                                         CanSILFunctionType fnType,
+                                         llvm::Value *buffer,
+                                         llvm::Value *allocator,
+                                         llvm::GlobalVariable *cfp) {
   IGF.setCoroutineAllocator(allocator);
   auto isSwiftCoroCCAvailable =
       IGF.IGM.SwiftCoroCC == llvm::CallingConv::SwiftCoro;
@@ -5170,6 +5168,15 @@ void irgen::emitYieldOnce2CoroutineEntry(
       Size(-1) /*dynamic-to-IRGen size*/, IGF.IGM.getCoroStaticFrameAlignment(),
       {cfp, allocator}, allocFn, deallocFn, {});
 }
+void irgen::emitYieldOnce2CoroutineEntry(
+    IRGenFunction &IGF, LinkEntity coroFunction, CanSILFunctionType fnType,
+    NativeCCEntryPointArgumentEmission &emission) {
+  auto *buffer = emission.getCoroutineBuffer();
+  auto cfp = cast<llvm::GlobalVariable>(
+      IGF.IGM.getAddrOfCoroFunctionPointer(coroFunction));
+  llvm::Value *allocator = emission.getCoroutineAllocator();
+  emitYieldOnce2CoroutineEntry(IGF, fnType, buffer, allocator, cfp);
+}
 
 static Address createOpaqueBufferAlloca(IRGenFunction &IGF,
                                         Size size, Alignment align) {

lib/IRGen/GenCall.h

@@ -231,6 +231,10 @@ namespace irgen {
   emitYieldOnce2CoroutineEntry(IRGenFunction &IGF, LinkEntity coroFunction,
                                CanSILFunctionType coroutineType,
                                NativeCCEntryPointArgumentEmission &emission);
+  void emitYieldOnce2CoroutineEntry(IRGenFunction &IGF,
+                                    CanSILFunctionType fnType,
+                                    llvm::Value *buffer, llvm::Value *allocator,
+                                    llvm::GlobalVariable *cfp);
 
   Address emitAllocYieldManyCoroutineBuffer(IRGenFunction &IGF);
   void emitDeallocYieldManyCoroutineBuffer(IRGenFunction &IGF, Address buffer);

lib/IRGen/GenClass.cpp

@@ -3103,11 +3103,19 @@ FunctionPointer irgen::emitVirtualMethodValue(IRGenFunction &IGF,
     auto fnPtr = llvm::ConstantExpr::getBitCast(methodInfo.getDirectImpl(),
                                            signature.getType()->getPointerTo());
     llvm::Constant *secondaryValue = nullptr;
+    auto *accessor = dyn_cast<AccessorDecl>(method.getDecl());
     if (cast<AbstractFunctionDecl>(method.getDecl())->hasAsync()) {
       auto *silFn = IGF.IGM.getSILFunctionForAsyncFunctionPointer(
           methodInfo.getDirectImpl());
       secondaryValue = cast<llvm::Constant>(
           IGF.IGM.getAddrOfSILFunction(silFn, NotForDefinition));
+    } else if (accessor &&
+               requiresFeatureCoroutineAccessors(accessor->getAccessorKind())) {
+      assert(methodType->isCalleeAllocatedCoroutine());
+      auto *silFn = IGF.IGM.getSILFunctionForCoroFunctionPointer(
+          methodInfo.getDirectImpl());
+      secondaryValue = cast<llvm::Constant>(
+          IGF.IGM.getAddrOfSILFunction(silFn, NotForDefinition));
     }
     return FunctionPointer::forDirect(methodType, fnPtr, secondaryValue,
                                       signature, true);

lib/IRGen/GenConstant.cpp

@@ -396,9 +396,13 @@ Explosion irgen::emitConstantValue(IRGenModule &IGM, SILValue operand,
     llvm::Constant *fnPtr = IGM.getAddrOfSILFunction(fn, NotForDefinition);
     CanSILFunctionType fnType = FRI->getType().getAs<SILFunctionType>();
 
-    if (irgen::classifyFunctionPointerKind(fn).isAsyncFunctionPointer()) {
+    auto fpKind = irgen::classifyFunctionPointerKind(fn);
+    if (fpKind.isAsyncFunctionPointer()) {
       llvm::Constant *asyncFnPtr = IGM.getAddrOfAsyncFunctionPointer(fn);
       fnPtr = llvm::ConstantExpr::getBitCast(asyncFnPtr, fnPtr->getType());
+    } else if (fpKind.isCoroFunctionPointer()) {
+      llvm::Constant *coroFnPtr = IGM.getAddrOfCoroFunctionPointer(fn);
+      fnPtr = llvm::ConstantExpr::getBitCast(coroFnPtr, fnPtr->getType());
     }
 
     auto authInfo = PointerAuthInfo::forFunctionPointer(IGM, fnType);