Add swift_getTypeByMangledNameInContextInMetadataState such that we can

use getTypeByMangledName when abstract metadata state is requested

This can significantly reduce the code size of apps constructing deeply
nested types with conditional conformances.

Requires a new runtime.

rdar://57157619

Author: aschwaighofer

include/swift/AST/ASTContext.h

@@ -577,6 +577,11 @@ class ASTContext final {
   /// compiler for the target platform.
   AvailabilityContext getSwift51Availability();
 
+  /// Get the runtime availability of
+  /// swift_getTypeByMangledNameInContextInMetadataState.
+  AvailabilityContext getTypesInAbstractMetadataStateAvailability();
+
+
   //===--------------------------------------------------------------------===//
   // Diagnostics Helper functions
   //===--------------------------------------------------------------------===//

include/swift/Runtime/RuntimeFunctions.def

@@ -1409,6 +1409,20 @@ FUNCTION(GetTypeByMangledNameInContext, swift_getTypeByMangledNameInContext,
          ARGS(Int8PtrTy, SizeTy, TypeContextDescriptorPtrTy, Int8PtrPtrTy),
          ATTRS(NoUnwind, ArgMemOnly))
 
+// const Metadata *swift_getTypeByMangledNameInContextInMetadataState(
+//                        size_t metadataState,
+//                        const char *typeNameStart,
+//                        size_t typeNameLength,
+//                        const TargetContextDescriptor<InProcess> *context,
+//                        const void * const *genericArgs)
+FUNCTION(GetTypeByMangledNameInContextInMetadataState,
+         swift_getTypeByMangledNameInContextInMetadataState, SwiftCC,
+         GetTypesInAbstractMetadataStateAvailability,
+         RETURNS(TypeMetadataPtrTy),
+         ARGS(SizeTy, Int8PtrTy, SizeTy, TypeContextDescriptorPtrTy,
+              Int8PtrPtrTy),
+         ATTRS(NoUnwind, ArgMemOnly))
+
 #undef RETURNS
 #undef ARGS
 #undef ATTRS

lib/AST/Availability.cpp

@@ -237,3 +237,17 @@ AvailabilityContext ASTContext::getSwift51Availability() {
     return AvailabilityContext::alwaysAvailable();
   }
 }
+
+AvailabilityContext ASTContext::getTypesInAbstractMetadataStateAvailability() {
+  auto target = LangOpts.Target;
+
+  if (target.isMacOSX() ) {
+    return AvailabilityContext(
+        VersionRange::allGTE(llvm::VersionTuple(10, 99, 0)));
+  } else if (target.isiOS() || target.isWatchOS()) {
+    return AvailabilityContext(
+        VersionRange::allGTE(llvm::VersionTuple(9999, 0, 0)));
+  } else {
+    return AvailabilityContext::alwaysAvailable();
+  }
+}

lib/IRGen/IRGenModule.cpp

@@ -564,6 +564,16 @@ namespace RuntimeConstants {
     return RuntimeAvailability::AlwaysAvailable;
   }
 
+  RuntimeAvailability
+  GetTypesInAbstractMetadataStateAvailability(ASTContext &context) {
+    auto featureAvailability =
+        context.getTypesInAbstractMetadataStateAvailability();
+    if (!isDeploymentAvailabilityContainedIn(context, featureAvailability)) {
+      return RuntimeAvailability::ConditionallyAvailable;
+    }
+    return RuntimeAvailability::AlwaysAvailable;
+  }
+
   RuntimeAvailability DynamicReplacementAvailability(ASTContext &Context) {
     auto featureAvailability = Context.getSwift51Availability();
     if (!isDeploymentAvailabilityContainedIn(Context, featureAvailability)) {

lib/IRGen/MetadataRequest.cpp

@@ -2156,16 +2156,29 @@ static bool shouldAccessByMangledName(IRGenModule &IGM, CanType type) {
 
 }
 
+static bool canIssueIncompleteMetadataRequests(IRGenModule &IGM) {
+  // We can only answer blocking complete metadata requests with the <=5.1
+  // runtime ABI entry points.
+  auto &context = IGM.getSwiftModule()->getASTContext();
+  auto deploymentAvailability =
+      AvailabilityContext::forDeploymentTarget(context);
+  return deploymentAvailability.isContainedIn(
+      context.getTypesInAbstractMetadataStateAvailability());
+}
+
 /// Emit a call to a type metadata accessor using a mangled name.
 static MetadataResponse
 emitMetadataAccessByMangledName(IRGenFunction &IGF, CanType type,
                                 DynamicMetadataRequest request) {
-  // TODO: We can only answer blocking complete metadata requests with the
-  // <=5.1 runtime ABI entry points.
-  assert(request.isStaticallyBlockingComplete()
-         && "can only form complete metadata by mangled name");
-  
   auto &IGM = IGF.IGM;
+
+  // We can only answer blocking complete metadata requests with the <=5.1
+  // runtime ABI entry points.
+  assert((request.isStaticallyBlockingComplete() ||
+          (request.isStaticallyAbstract() &&
+           canIssueIncompleteMetadataRequests(IGM))) &&
+         "can only form complete metadata by mangled name");
+
   llvm::Constant *mangledString;
   unsigned mangledStringSize;
   std::tie(mangledString, mangledStringSize) =
@@ -2198,11 +2211,15 @@ emitMetadataAccessByMangledName(IRGenFunction &IGF, CanType type,
   }
 
   // Get or create a shared helper function to do the instantiation.
+  auto instantiationFnName =
+      request.isStaticallyAbstract()
+          ? "__swift_instantiateConcreteTypeFromMangledNameAbstract"
+          : "__swift_instantiateConcreteTypeFromMangledName";
   auto instantiationFn = cast<llvm::Function>(
-       IGM.getModule()
-         ->getOrInsertFunction("__swift_instantiateConcreteTypeFromMangledName",
-                               IGF.IGM.TypeMetadataPtrTy, cache->getType())
-        .getCallee());
+      IGM.getModule()
+          ->getOrInsertFunction(instantiationFnName, IGF.IGM.TypeMetadataPtrTy,
+                                cache->getType())
+          .getCallee());
   if (instantiationFn->empty()) {
     ApplyIRLinkage(IRLinkage::InternalLinkOnceODR)
       .to(instantiationFn);
@@ -2212,7 +2229,7 @@ emitMetadataAccessByMangledName(IRGenFunction &IGF, CanType type,
                                   llvm::Attribute::NoInline);
     IGM.setHasFramePointer(instantiationFn, false);
 
-    [&IGM, instantiationFn]{
+    [&IGM, instantiationFn, request]{
       IRGenFunction subIGF(IGM, instantiationFn);
 
       auto params = subIGF.collectParameters();
@@ -2279,15 +2296,26 @@ emitMetadataAccessByMangledName(IRGenFunction &IGF, CanType type,
       auto stringAddr = subIGF.Builder.CreateAdd(stringAddrBase,
                                                  stringAddrOffset);
       stringAddr = subIGF.Builder.CreateIntToPtr(stringAddr, IGM.Int8PtrTy);
-      
-      auto call =
-        subIGF.Builder.CreateCall(IGM.getGetTypeByMangledNameInContextFn(),
-               {stringAddr,
-                size,
-                // TODO: Use mangled name lookup in generic
-                // contexts?
-                llvm::ConstantPointerNull::get(IGM.TypeContextDescriptorPtrTy),
-                llvm::ConstantPointerNull::get(IGM.Int8PtrPtrTy)});
+
+      llvm::CallInst *call;
+      if (request.isStaticallyAbstract()) {
+        call = subIGF.Builder.CreateCall(
+            IGM.getGetTypeByMangledNameInContextInMetadataStateFn(),
+            {llvm::ConstantInt::get(IGM.SizeTy, (size_t)MetadataState::Abstract),
+             stringAddr, size,
+             // TODO: Use mangled name lookup in generic
+             // contexts?
+             llvm::ConstantPointerNull::get(IGM.TypeContextDescriptorPtrTy),
+             llvm::ConstantPointerNull::get(IGM.Int8PtrPtrTy)});
+      } else {
+        call = subIGF.Builder.CreateCall(
+            IGM.getGetTypeByMangledNameInContextFn(),
+            {stringAddr, size,
+             // TODO: Use mangled name lookup in generic
+             // contexts?
+             llvm::ConstantPointerNull::get(IGM.TypeContextDescriptorPtrTy),
+             llvm::ConstantPointerNull::get(IGM.Int8PtrPtrTy)});
+      }
       call->setDoesNotThrow();
       call->setDoesNotAccessMemory();
       call->setCallingConv(IGM.SwiftCC);
@@ -2339,14 +2367,13 @@ emitCallToTypeMetadataAccessFunction(IRGenFunction &IGF, CanType type,
   // single access by mangled name instead, if we're asking for complete
   // metadata.
   //
-  // TODO: The getTypeByMangledNameInContext entry point in Swift <=5.1 can
-  // only answer requests for complete metadata. We could introduce new
-  // entry points that could answer all metadata requests.
-  if (request.isStaticallyBlockingComplete()
-      && shouldAccessByMangledName(IGF.IGM, type)) {
+  if ((request.isStaticallyBlockingComplete() ||
+       (request.isStaticallyAbstract() &&
+        canIssueIncompleteMetadataRequests(IGF.IGM))) &&
+      shouldAccessByMangledName(IGF.IGM, type)) {
     return emitMetadataAccessByMangledName(IGF, type, request);
   }
-    
+
   llvm::Constant *accessor =
     getOrCreateTypeMetadataAccessFunction(IGF.IGM, type);
   llvm::CallInst *call = IGF.Builder.CreateCall(accessor, { request.get(IGF) });

stdlib/public/runtime/MetadataLookup.cpp

@@ -1708,6 +1708,26 @@ swift_getTypeByMangledNameInContext(
     }).getMetadata();
 }
 
+SWIFT_CC(swift) SWIFT_RUNTIME_EXPORT
+const Metadata * _Nullable
+swift_getTypeByMangledNameInContextInMetadataState(
+                        size_t metadataState,
+                        const char *typeNameStart,
+                        size_t typeNameLength,
+                        const TargetContextDescriptor<InProcess> *context,
+                        const void * const *genericArgs) {
+  llvm::StringRef typeName(typeNameStart, typeNameLength);
+  SubstGenericParametersFromMetadata substitutions(context, genericArgs);
+  return swift_getTypeByMangledName((MetadataState)metadataState, typeName,
+    genericArgs,
+    [&substitutions](unsigned depth, unsigned index) {
+      return substitutions.getMetadata(depth, index);
+    },
+    [&substitutions](const Metadata *type, unsigned index) {
+      return substitutions.getWitnessTable(type, index);
+    }).getMetadata();
+}
+
 /// Demangle a mangled name, but don't allow symbolic references.
 SWIFT_CC(swift) SWIFT_RUNTIME_STDLIB_INTERNAL
 const Metadata *_Nullable

test/IRGen/conditional_conformances_gettypemetdatabyname.swift

@@ -0,0 +1,6 @@
+// RUN: %target-swift-frontend -target x86_64-apple-macosx10.99 -emit-ir %S/../Inputs/conditional_conformance_basic_conformances.swift | %FileCheck %S/../Inputs/conditional_conformance_basic_conformances.swift --check-prefix=TYPEBYNAME
+
+// Too many pointer-sized integers in the IR
+// REQUIRES: PTRSIZE=64
+// REQUIRES: OS=macosx
+

test/Inputs/conditional_conformance_basic_conformances.swift

@@ -100,6 +100,28 @@ public func single_concrete() {
 // CHECK-NEXT:    ret i8** [[T0]]
 // CHECK-NEXT:  }
 
+// TYPEBYNAME-LABEL: define linkonce_odr hidden i8** @"$s42conditional_conformance_basic_conformances6SingleVyAA4IsP2VGACyxGAA2P1A2A0G0RzlWl"()
+// TYPEBYNAME-NEXT:  entry:
+// TYPEBYNAME-NEXT:    %conditional.requirement.buffer = alloca [1 x i8**], align 8
+// TYPEBYNAME-NEXT:    [[CACHE:%.*]] = load i8**, i8*** @"$s42conditional_conformance_basic_conformances6SingleVyAA4IsP2VGACyxGAA2P1A2A0G0RzlWL", align 8
+// TYPEBYNAME-NEXT:    [[IS_NULL:%.*]] = icmp eq i8** [[CACHE]], null
+// TYPEBYNAME-NEXT:    br i1 [[IS_NULL]], label %cacheIsNull, label %cont
+
+// TYPEBYNAME:       cacheIsNull:
+// TYPEBYNAME-NEXT:    [[T0:%.*]] = call %swift.type* @__swift_instantiateConcreteTypeFromMangledNameAbstract({ i32, i32 }* @"$s42conditional_conformance_basic_conformances6SingleVyAA4IsP2VGMD")
+// TYPEBYNAME-NEXT:    [[CONDITIONAL_REQUIREMENTS:%.*]] = getelementptr inbounds [1 x i8**], [1 x i8**]* %conditional.requirement.buffer, i32 0, i32 0
+// TYPEBYNAME-NEXT:    [[A_P2_PTR:%.*]] = getelementptr inbounds i8**, i8*** [[CONDITIONAL_REQUIREMENTS]], i32 0
+// TYPEBYNAME-NEXT:    store i8** getelementptr inbounds ([1 x i8*], [1 x i8*]* @"$s42conditional_conformance_basic_conformances4IsP2VAA0F0AAWP", i32 0, i32 0), i8*** [[A_P2_PTR]], align 8
+
+// TYPEBYNAME-NEXT:    [[Single_P1:%.*]] = call i8** @swift_getWitnessTable
+// TYPEBYNAME-NEXT:    store atomic i8** [[Single_P1]], i8*** @"$s42conditional_conformance_basic_conformances6SingleVyAA4IsP2VGACyxGAA2P1A2A0G0RzlWL" release, align 8
+// TYPEBYNAME-NEXT:    br label %cont
+
+// TYPEBYNAME:       cont:
+// TYPEBYNAME-NEXT:    [[T0:%.*]] = phi i8** [ [[CACHE]], %entry ], [ [[Single_P1]], %cacheIsNull ]
+// TYPEBYNAME-NEXT:    ret i8** [[T0]]
+// TYPEBYNAME-NEXT:  }
+
 
 public struct Double<B, C> {}
 extension Double: P1 where B: P2, C: P3 {