IRGen: Emit and use accessors for generic type metadata

Instead of directly emitting calls to swift_getGenericMetadata*() and
referencing metadata templates, call a metadata accessor function
corresponding to the UnboundGenericType of the NominalTypeDecl.

The body of this accessor forwards arguments to a runtime metadata
instantiation function, together with the template.

Also, move some code around, so that metadata accesses which are
only done as part of the body of a metadata accessor function are
handled separately in emitTypeMetadataAccessFunction().

Apart from protocol conformances, this means metadata templates are
no longer referenced from outside the module where they were defined.

Author: slavapestov

docs/Runtime.md

@@ -282,10 +282,6 @@ detail used to implement resilient per-type metadata accessor functions.
 000000000001f1f0 T _swift_getFunctionTypeMetadata2
 000000000001f250 T _swift_getFunctionTypeMetadata3
 000000000001e940 T _swift_getGenericMetadata
-000000000001e9c0 T _swift_getGenericMetadata1
-000000000001ea60 T _swift_getGenericMetadata2
-000000000001eb00 T _swift_getGenericMetadata3
-000000000001eba0 T _swift_getGenericMetadata4
 0000000000022fd0 T _swift_getMetatypeMetadata
 000000000001ec50 T _swift_getObjCClassMetadata
 000000000001e6b0 T _swift_getResilientMetadata

include/swift/Runtime/Metadata.h

@@ -2463,27 +2463,6 @@ extern "C" const Metadata *
 swift_getGenericMetadata(GenericMetadata *pattern,
                          const void *arguments);
 
-// Fast entry points for swift_getGenericMetadata with a small number of
-// template arguments.
-extern "C" const Metadata *
-swift_getGenericMetadata1(GenericMetadata *pattern,
-                          const void *arg0);
-extern "C" const Metadata *
-swift_getGenericMetadata2(GenericMetadata *pattern,
-                          const void *arg0,
-                          const void *arg1);
-extern "C" const Metadata *
-swift_getGenericMetadata3(GenericMetadata *pattern,
-                          const void *arg0,
-                          const void *arg1,
-                          const void *arg2);
-extern "C" const Metadata *
-swift_getGenericMetadata4(GenericMetadata *pattern,
-                          const void *arg0,
-                          const void *arg1,
-                          const void *arg2,
-                          const void *arg3);
-
 // Callback to allocate a generic class metadata object.
 extern "C" ClassMetadata *
 swift_allocateGenericClassMetadata(GenericMetadata *pattern,

lib/IRGen/GenDecl.cpp

@@ -2165,12 +2165,37 @@ IRGenModule::getAddrOfTypeMetadataAccessFunction(CanType type,
   return entry;
 }
 
+/// Fetch the type metadata access function for the given generic type.
+llvm::Function *
+IRGenModule::getAddrOfGenericTypeMetadataAccessFunction(
+                                           NominalTypeDecl *nominal,
+                                           ArrayRef<llvm::Type *> genericArgs,
+                                           ForDefinition_t forDefinition) {
+  assert(!genericArgs.empty());
+  assert(nominal->isGenericContext());
+
+  auto type = nominal->getDeclaredType()->getCanonicalType();
+  assert(isa<UnboundGenericType>(type));
+  LinkEntity entity = LinkEntity::forTypeMetadataAccessFunction(type);
+  llvm::Function *&entry = GlobalFuncs[entity];
+  if (entry) {
+    if (forDefinition) updateLinkageForDefinition(*this, entry, entity);
+    return entry;
+  }
+
+  auto fnType = llvm::FunctionType::get(TypeMetadataPtrTy, genericArgs, false);
+  LinkInfo link = LinkInfo::get(*this, entity, forDefinition);
+  entry = link.createFunction(*this, fnType, RuntimeCC, llvm::AttributeSet());
+  return entry;
+}
+
 /// Get or create a type metadata cache variable.  These are an
 /// implementation detail of type metadata access functions.
 llvm::Constant *
 IRGenModule::getAddrOfTypeMetadataLazyCacheVariable(CanType type,
                                               ForDefinition_t forDefinition) {
   assert(!type->hasArchetype() && !type->hasTypeParameter());
+  assert(!type->hasUnboundGenericType());
   LinkEntity entity = LinkEntity::forTypeMetadataLazyCacheVariable(type);
   return getAddrOfLLVMVariable(entity, getPointerAlignment(), forDefinition,
                                TypeMetadataPtrTy, DebugTypeInfo());