Make opaque type descriptors dynamically replaceable

This is to support dynamic function replacement of functions with opaque
result type.

This approach requires that all state is thrown away (that could contain the
old returned type for an opaque type) between replacements.

rdar://48887938

Author: aschwaighofer

include/swift/Demangling/DemangleNodes.def

@@ -266,6 +266,10 @@ NODE(AccessorFunctionReference)
 NODE(OpaqueType)
 NODE(OpaqueTypeDescriptorSymbolicReference)
 NODE(OpaqueTypeDescriptor)
+NODE(OpaqueTypeDescriptorAccessor)
+NODE(OpaqueTypeDescriptorAccessorImpl)
+NODE(OpaqueTypeDescriptorAccessorKey)
+NODE(OpaqueTypeDescriptorAccessorVar)
 NODE(OpaqueReturnType)
 CONTEXT_NODE(OpaqueReturnTypeOf)
 

include/swift/IRGen/Linking.h

@@ -199,6 +199,10 @@ class LinkEntity {
     /// The descriptor for an opaque type.
     /// The pointer is an OpaqueTypeDecl*.
     OpaqueTypeDescriptor,
+    OpaqueTypeDescriptorAccessor,
+    OpaqueTypeDescriptorAccessorImpl,
+    OpaqueTypeDescriptorAccessorKey,
+    OpaqueTypeDescriptorAccessorVar,
 
     /// The metadata pattern for a generic nominal type.
     /// The pointer is a NominalTypeDecl*.
@@ -706,6 +710,30 @@ class LinkEntity {
     return entity;
   }
 
+  static LinkEntity forOpaqueTypeDescriptorAccessor(OpaqueTypeDecl *decl) {
+    LinkEntity entity;
+    entity.setForDecl(Kind::OpaqueTypeDescriptorAccessor, decl);
+    return entity;
+  }
+
+  static LinkEntity forOpaqueTypeDescriptorAccessorImpl(OpaqueTypeDecl *decl) {
+    LinkEntity entity;
+    entity.setForDecl(Kind::OpaqueTypeDescriptorAccessorImpl, decl);
+    return entity;
+  }
+
+  static LinkEntity forOpaqueTypeDescriptorAccessorKey(OpaqueTypeDecl *decl) {
+    LinkEntity entity;
+    entity.setForDecl(Kind::OpaqueTypeDescriptorAccessorKey, decl);
+    return entity;
+  }
+
+  static LinkEntity forOpaqueTypeDescriptorAccessorVar(OpaqueTypeDecl *decl) {
+    LinkEntity entity;
+    entity.setForDecl(Kind::OpaqueTypeDescriptorAccessorVar, decl);
+    return entity;
+  }
+
   static LinkEntity forPropertyDescriptor(AbstractStorageDecl *decl) {
     assert(decl->exportsPropertyDescriptor());
     LinkEntity entity;

lib/Demangling/Demangler.cpp

@@ -1805,6 +1805,18 @@ NodePointer Demangler::demangleMetatype() {
       return createWithPoppedType(Node::Kind::GenericTypeMetadataPattern);
     case 'a':
       return createWithPoppedType(Node::Kind::TypeMetadataAccessFunction);
+    case 'g':
+      return createWithChild(Node::Kind::OpaqueTypeDescriptorAccessor,
+                             popNode());
+    case 'h':
+      return createWithChild(Node::Kind::OpaqueTypeDescriptorAccessorImpl,
+                             popNode());
+    case 'j':
+      return createWithChild(Node::Kind::OpaqueTypeDescriptorAccessorKey,
+                             popNode());
+    case 'k':
+      return createWithChild(Node::Kind::OpaqueTypeDescriptorAccessorVar,
+                             popNode());
     case 'I':
       return createWithPoppedType(Node::Kind::TypeMetadataInstantiationCache);
     case 'i':

lib/Demangling/NodePrinter.cpp

@@ -415,6 +415,10 @@ class NodePrinter {
     case Node::Kind::ObjCMetadataUpdateFunction:
     case Node::Kind::ObjCResilientClassStub:
     case Node::Kind::OpaqueTypeDescriptor:
+    case Node::Kind::OpaqueTypeDescriptorAccessor:
+    case Node::Kind::OpaqueTypeDescriptorAccessorImpl:
+    case Node::Kind::OpaqueTypeDescriptorAccessorKey:
+    case Node::Kind::OpaqueTypeDescriptorAccessorVar:
     case Node::Kind::Owned:
     case Node::Kind::OwningAddressor:
     case Node::Kind::OwningMutableAddressor:
@@ -1733,6 +1737,22 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
     Printer << "opaque type descriptor for ";
     print(Node->getChild(0));
     return nullptr;
+  case Node::Kind::OpaqueTypeDescriptorAccessor:
+    Printer << "opaque type descriptor accessor for ";
+    print(Node->getChild(0));
+    return nullptr;
+  case Node::Kind::OpaqueTypeDescriptorAccessorImpl:
+    Printer << "opaque type descriptor accessor impl for ";
+    print(Node->getChild(0));
+    return nullptr;
+  case Node::Kind::OpaqueTypeDescriptorAccessorKey:
+    Printer << "opaque type descriptor accessor key for ";
+    print(Node->getChild(0));
+    return nullptr;
+  case Node::Kind::OpaqueTypeDescriptorAccessorVar:
+    Printer << "opaque type descriptor accessor var for ";
+    print(Node->getChild(0));
+    return nullptr;
   case Node::Kind::CoroutineContinuationPrototype:
     Printer << "coroutine continuation prototype for ";
     print(Node->getChild(0));

lib/Demangling/OldRemangler.cpp

@@ -2038,6 +2038,18 @@ void Remangler::mangleOpaqueType(Node *node) {
 void Remangler::mangleOpaqueTypeDescriptor(Node *node) {
   unreachable("unsupported");
 }
+void Remangler::mangleOpaqueTypeDescriptorAccessor(Node *node) {
+  unreachable("unsupported");
+}
+void Remangler::mangleOpaqueTypeDescriptorAccessorImpl(Node *node) {
+  unreachable("unsupported");
+}
+void Remangler::mangleOpaqueTypeDescriptorAccessorKey(Node *node) {
+  unreachable("unsupported");
+}
+void Remangler::mangleOpaqueTypeDescriptorAccessorVar(Node *node) {
+  unreachable("unsupported");
+}
 void Remangler::mangleAccessorFunctionReference(Node *node) {
   unreachable("can't remangle");
 }

lib/Demangling/Remangler.cpp

@@ -1599,6 +1599,26 @@ void Remangler::mangleOpaqueTypeDescriptor(Node *node) {
   Buffer << "MQ";
 }
 
+void Remangler::mangleOpaqueTypeDescriptorAccessor(Node *node) {
+  mangleSingleChildNode(node);
+  Buffer << "Mg";
+}
+
+void Remangler::mangleOpaqueTypeDescriptorAccessorImpl(Node *node) {
+  mangleSingleChildNode(node);
+  Buffer << "Mh";
+}
+
+void Remangler::mangleOpaqueTypeDescriptorAccessorKey(Node *node) {
+  mangleSingleChildNode(node);
+  Buffer << "Mj";
+}
+
+void Remangler::mangleOpaqueTypeDescriptorAccessorVar(Node *node) {
+  mangleSingleChildNode(node);
+  Buffer << "Mk";
+}
+
 void Remangler::manglePropertyDescriptor(Node *node) {
   mangleSingleChildNode(node);
   Buffer << "MV";

lib/IRGen/GenArchetype.cpp

@@ -19,6 +19,7 @@
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/GenericEnvironment.h"
+#include "swift/AST/IRGenOptions.h"
 #include "swift/AST/Types.h"
 #include "swift/IRGen/Linking.h"
 #include "swift/SIL/SILValue.h"
@@ -389,7 +390,6 @@ llvm::Value *irgen::emitDynamicTypeOfOpaqueArchetype(IRGenFunction &IGF,
                                                      Address addr,
                                                      SILType type) {
   auto archetype = type.castTo<ArchetypeType>();
-
   // Acquire the archetype's static metadata.
   llvm::Value *metadata =
     emitArchetypeTypeMetadataRef(IGF, archetype, MetadataState::Complete)
@@ -450,14 +450,31 @@ withOpaqueTypeGenericArgs(IRGenFunction &IGF,
   }
 }
 
+static llvm::Value *
+getAddressOfOpaqueTypeDescriptor(IRGenFunction &IGF,
+                                 OpaqueTypeDecl *opaqueDecl) {
+  auto &IGM = IGF.IGM;
+
+  // Support dynamically replacing the return type as part of dynamic function
+  // replacement.
+  if (!IGM.getOptions().shouldOptimize()) {
+    auto descriptorAccessor = IGM.getAddrOfOpaqueTypeDescriptorAccessFunction(
+        opaqueDecl, NotForDefinition, false);
+    auto desc = IGF.Builder.CreateCall(descriptorAccessor, {});
+    desc->setDoesNotThrow();
+    desc->setCallingConv(IGM.SwiftCC);
+    return desc;
+  }
+  return IGM.getAddrOfOpaqueTypeDescriptor(opaqueDecl, ConstantInit());
+}
+
 MetadataResponse irgen::emitOpaqueTypeMetadataRef(IRGenFunction &IGF,
                                           CanOpaqueTypeArchetypeType archetype,
                                           DynamicMetadataRequest request) {
   auto accessorFn = IGF.IGM.getGetOpaqueTypeMetadataFn();
   auto opaqueDecl = archetype->getDecl();
-  auto descriptor = IGF.IGM
-   .getAddrOfOpaqueTypeDescriptor(opaqueDecl, ConstantInit());
 
+  auto *descriptor = getAddressOfOpaqueTypeDescriptor(IGF, opaqueDecl);
   auto indexValue = llvm::ConstantInt::get(IGF.IGM.SizeTy, 0);
 
   llvm::CallInst *result = nullptr;
@@ -482,8 +499,9 @@ llvm::Value *irgen::emitOpaqueTypeWitnessTableRef(IRGenFunction &IGF,
                                           ProtocolDecl *protocol) {
   auto accessorFn = IGF.IGM.getGetOpaqueTypeConformanceFn();
   auto opaqueDecl = archetype->getDecl();
-  auto descriptor = IGF.IGM
-    .getAddrOfOpaqueTypeDescriptor(opaqueDecl, ConstantInit());
+
+
+  llvm::Value *descriptor = getAddressOfOpaqueTypeDescriptor(IGF, opaqueDecl);
 
   auto foundProtocol = std::find(archetype->getConformsTo().begin(),
                                  archetype->getConformsTo().end(),