Hang closure capture descriptors from their heap metadata

Now we can discern the types of values in heap boxes at runtime!
Closure reference captures are a common way of creating reference
cycles, so this provides some basic infrastructure for detecting those
someday.

A closure capture descriptor has the following:

- The number of captures.
- The number of sources of metadata reachable from the closure.
  This is important for substituting generics at runtime since we
  can't know precisely what will get captured until we observe a
  closure.
- The number of types in the NecessaryBindings structure.
  This is a holding tank in a closure for sources of metadata that
  can't be gotten from the captured values themselves.
- The metadata source map, a list of pairs, for each
  source of metadata for every generic argument needed to perform
  substitution at runtime.
  Key: The typeref for the generic parameter visible from the closure
  in the Swift source.
  Value: The metadata source, which describes how to crawl the heap from
  the closure to get to the metadata for that generic argument.
- A list of typerefs for the captured values themselves.

Follow-up: IRGen tests for various capture scenarios, which will include
MetadataSource encoding tests.

rdar://problem/24989531

Author: bitjammer

include/swift/Reflection/MetadataSource.h

@@ -165,19 +165,6 @@ class MetadataSource {
     return A.template createParent(Child);
   }
 
-  template <typename Allocator>
-  static const MetadataSource*
-  decodeImpossible(Allocator &A,
-                   std::string::const_iterator &it,
-                   const std::string::const_iterator &end) {
-    // Decode the impossible. Create the impossible.
-    if (it == end || *it != 'I')
-      return nullptr;
-
-    ++it;
-    return A.template createImpossible();
-  }
-
   template <typename Allocator>
   static const MetadataSource *decode(Allocator &A,
                                       std::string::const_iterator &it,
@@ -195,8 +182,6 @@ class MetadataSource {
         return decodeGenericArgument(A, it, end);
       case 'P':
         return decodeParent(A, it, end);
-      case 'I':
-        return decodeImpossible(A, it, end);
       default:
         return nullptr;
     }
@@ -211,7 +196,6 @@ class MetadataSource {
 
   void dump() const;
   void dump(std::ostream &OS, unsigned Indent = 0) const;
-  std::string encode() const;
   template <typename Allocator>
   static const MetadataSource *decode(Allocator &A, const std::string &str) {
     auto begin = str.begin();
@@ -347,18 +331,9 @@ class ParentMetadataSource final : public MetadataSource {
   const MetadataSource *getChild() const {
     return Child;
   }
-};
-
-class ImpossibleMetadataSource final : public MetadataSource {
-  static const ImpossibleMetadataSource *Singleton;
-public:
-  ImpossibleMetadataSource()
-    : MetadataSource(MetadataSourceKind::Impossible) {}
-
-  static const ImpossibleMetadataSource *get();
 
   static bool classof(const MetadataSource *MS) {
-    return MS->getKind() == MetadataSourceKind::Impossible;
+    return MS->getKind() == MetadataSourceKind::Parent;
   }
 };
 

include/swift/Reflection/MetadataSourceBuilder.h

@@ -62,11 +62,6 @@ class MetadataSourceBuilder {
   createParent(const MetadataSource *Child) {
     return ParentMetadataSource::create(*this, Child);
   }
-
-  const ImpossibleMetadataSource *
-  createImpossible() {
-    return ImpossibleMetadataSource::get();
-  }
 };
 
 } // end namespace reflection

include/swift/Reflection/MetadataSources.def

@@ -21,4 +21,3 @@ METADATA_SOURCE(ReferenceCapture, MetadataSource)
 METADATA_SOURCE(MetadataCapture, MetadataSource)
 METADATA_SOURCE(GenericArgument, MetadataSource)
 METADATA_SOURCE(Parent, MetadataSource)
-METADATA_SOURCE(Impossible, MetadataSource)

lib/IRGen/GenFunc.cpp

@@ -1077,6 +1077,7 @@ static llvm::Function *emitPartialApplicationForwarder(IRGenModule &IGM,
 /// Emit a partial application thunk for a function pointer applied to a partial
 /// set of argument values.
 void irgen::emitFunctionPartialApplication(IRGenFunction &IGF,
+                                           SILFunction &SILFn,
                                            llvm::Value *fnPtr,
                                            llvm::Value *fnContext,
                                            Explosion &args,
@@ -1287,14 +1288,17 @@ void irgen::emitFunctionPartialApplication(IRGenFunction &IGF,
   HeapLayout layout(IGF.IGM, LayoutStrategy::Optimal, argValTypes, argTypeInfos,
                     /*typeToFill*/ nullptr,
                     std::move(bindings));
+
+  auto Descriptor = IGF.IGM.getAddrOfCaptureDescriptor(SILFn, layout);
+
   llvm::Value *data;
   if (layout.isKnownEmpty()) {
     data = IGF.IGM.RefCountedNull;
   } else {
     // Allocate a new object.
     HeapNonFixedOffsets offsets(IGF, layout);
 
-    data = IGF.emitUnmanagedAlloc(layout, "closure", &offsets);
+    data = IGF.emitUnmanagedAlloc(layout, "closure", Descriptor, &offsets);
     Address dataAddr = layout.emitCastTo(IGF, data);
 
 

lib/IRGen/GenFunc.h

@@ -48,6 +48,7 @@ namespace irgen {
   /// Emit a partial application thunk for a function pointer applied to a
   /// partial set of argument values.
   void emitFunctionPartialApplication(IRGenFunction &IGF,
+                                      SILFunction &SILFn,
                                       llvm::Value *fnPtr,
                                       llvm::Value *fnContext,
                                       Explosion &args,

lib/IRGen/GenHeap.cpp

@@ -250,6 +250,7 @@ llvm::Constant *HeapLayout::createSizeFn(IRGenModule &IGM) const {
 static llvm::Constant *buildPrivateMetadata(IRGenModule &IGM,
                                             const HeapLayout &layout,
                                             llvm::Constant *dtorFn,
+                                            llvm::Constant *captureDescriptor,
                                             MetadataKind kind) {
   // Build the fields of the private metadata.
   SmallVector<llvm::Constant*, 4> fields;
@@ -268,6 +269,8 @@ static llvm::Constant *buildPrivateMetadata(IRGenModule &IGM,
     offset = Size(0);
   fields.push_back(llvm::ConstantInt::get(IGM.Int32Ty, offset.getValue()));
 
+  fields.push_back(captureDescriptor);
+
   llvm::Constant *init =
     llvm::ConstantStruct::get(IGM.FullBoxMetadataStructTy, fields);
 
@@ -285,17 +288,21 @@ static llvm::Constant *buildPrivateMetadata(IRGenModule &IGM,
       /*Ty=*/nullptr, var, indices);
 }
 
-llvm::Constant *HeapLayout::getPrivateMetadata(IRGenModule &IGM) const {
+llvm::Constant *
+HeapLayout::getPrivateMetadata(IRGenModule &IGM,
+                               llvm::Constant *captureDescriptor) const {
   if (!privateMetadata)
     privateMetadata = buildPrivateMetadata(IGM, *this, createDtorFn(IGM, *this),
+                                           captureDescriptor,
                                            MetadataKind::HeapLocalVariable);
   return privateMetadata;
 }
 
 llvm::Value *IRGenFunction::emitUnmanagedAlloc(const HeapLayout &layout,
                                                const llvm::Twine &name,
+                                           llvm::Constant *captureDescriptor,
                                            const HeapNonFixedOffsets *offsets) {
-  llvm::Value *metadata = layout.getPrivateMetadata(IGM);
+  llvm::Value *metadata = layout.getPrivateMetadata(IGM, captureDescriptor);
   llvm::Value *size, *alignMask;
   if (offsets) {
     size = offsets->getSize();
@@ -1466,7 +1473,11 @@ class FixedBoxTypeInfoBase : public BoxTypeInfo {
   allocate(IRGenFunction &IGF, SILType boxedType, const llvm::Twine &name)
   const override {
     // Allocate a new object using the layout.
-    llvm::Value *allocation = IGF.emitUnmanagedAlloc(layout, name);
+
+    auto nullCaptureDescriptor
+      = llvm::ConstantPointerNull::get(IGF.IGM.CaptureDescriptorPtrTy);
+    llvm::Value *allocation = IGF.emitUnmanagedAlloc(layout, name,
+                                                     nullCaptureDescriptor);
     Address rawAddr = project(IGF, allocation, boxedType);
     return {rawAddr, allocation};
   }

lib/IRGen/GenHeap.h

@@ -67,7 +67,8 @@ class HeapLayout : public StructLayout {
 
   /// As a convenience, build a metadata object with internal linkage
   /// consisting solely of the standard heap metadata.
-  llvm::Constant *getPrivateMetadata(IRGenModule &IGM) const;
+  llvm::Constant *getPrivateMetadata(IRGenModule &IGM,
+                                     llvm::Constant *captureDescriptor) const;
 };
 
 class HeapNonFixedOffsets : public NonFixedOffsetsImpl {

lib/IRGen/GenObjC.cpp

@@ -938,7 +938,13 @@ void irgen::emitObjCPartialApplication(IRGenFunction &IGF,
   auto *selfTypeInfo = &IGF.getTypeInfo(selfType);
   HeapLayout layout(IGF.IGM, LayoutStrategy::Optimal,
                     selfType, selfTypeInfo);
-  llvm::Value *data = IGF.emitUnmanagedAlloc(layout, "closure");
+
+  // FIXME: Either emit a descriptor for this or create a metadata kind
+  // that indicates its trivial layout.
+  auto Descriptor
+    = llvm::ConstantPointerNull::get(IGF.IGM.CaptureDescriptorPtrTy);
+  llvm::Value *data = IGF.emitUnmanagedAlloc(layout, "closure",
+                                             Descriptor);
   // FIXME: non-fixed offsets
   NonFixedOffsets offsets = None;
   Address dataAddr = layout.emitCastTo(IGF, data);

lib/IRGen/GenObjC.h

@@ -27,6 +27,7 @@ namespace swift {
   class CanType;
   class FuncDecl;
   struct SILDeclRef;
+  class SILFunction;
   class SILType;
   class Substitution;