Reflection: Preliminary C API entry points for class instance layout

slavapestov · slavapestov · commit 7a9a4dca83c3 · 2016-04-27T23:15:08.000-07:00
Tested by manually running swift-reflection-test, no automated
tests yet, but coming soon.
diff --git a/include/swift/Reflection/ReflectionContext.h b/include/swift/Reflection/ReflectionContext.h
@@ -67,10 +67,29 @@ class ReflectionContext
 
   /// Return a description of the layout of a heap object having the given
   /// metadata as its isa pointer.
-  const TypeInfo *getTypeInfo(StoredPointer MetadataAddress) {
-    // This is wrong...
+  const TypeInfo *getInstanceTypeInfo(StoredPointer MetadataAddress) {
+    // FIXME: Add caching
+    auto &TC = getBuilder().getTypeConverter();
+
     auto TR = readTypeFromMetadata(MetadataAddress);
-    return getTypeInfo(TR);
+    if (TR == nullptr)
+      return nullptr;
+
+    auto kind = this->readKindFromMetadata(MetadataAddress);
+    if (!kind.first)
+      return nullptr;
+
+    switch (kind.second) {
+    case MetadataKind::Class: {
+      auto start = this->readInstanceStartFromClassMetadata(MetadataAddress);
+      if (!start.first)
+        return nullptr;
+      auto *TI = TC.getInstanceTypeInfo(TR, start.second);
+      return TI;
+    }
+    default:
+      return nullptr;
+    }
   }
 
   /// Return a description of the layout of a value with the given type.
diff --git a/include/swift/Reflection/TypeLowering.h b/include/swift/Reflection/TypeLowering.h
@@ -51,6 +51,10 @@ enum class RecordKind : unsigned {
 
   // An existential metatype.
   ExistentialMetatype,
+
+  // A class instance layout, consisting of the stored properties of
+  // one class, excluding superclasses.
+  ClassInstance,
 };
 
 enum class ReferenceCounting : unsigned {
@@ -167,8 +171,17 @@ class TypeConverter {
 
   TypeRefBuilder &getBuilder() { return Builder; }
 
+  /// Returns layout information for a value of the given type.
+  /// For a class, this returns the lowering of the reference value.
   const TypeInfo *getTypeInfo(const TypeRef *TR);
 
+  /// Returns layout information for an instance of the given
+  /// class.
+  ///
+  /// Not cached.
+  const TypeInfo *getInstanceTypeInfo(const TypeRef *TR,
+                                      unsigned InstanceStart);
+
   /* Not really public */
   const ReferenceTypeInfo *
   getReferenceTypeInfo(ReferenceKind Kind,
diff --git a/include/swift/Remote/MetadataReader.h b/include/swift/Remote/MetadataReader.h
@@ -465,6 +465,29 @@ class MetadataReader {
     return {true, meta->getKind()};
   }
 
+  /// Given a remote pointer to class metadata, attempt to discover its class
+  /// instance start offset.
+  std::pair<bool, unsigned>
+  readInstanceStartFromClassMetadata(StoredPointer MetadataAddress) {
+    auto meta = readMetadata(MetadataAddress);
+    if (!meta)
+      return {false, 0};
+
+    auto address = readAddressOfNominalTypeDescriptor(meta);
+    if (!address)
+      return {false, 0};
+
+    auto descriptor = readNominalTypeDescriptor(address);
+    if (!descriptor)
+      return {false, 0};
+
+    if (descriptor->Class.NumFields == 0)
+      return {true, sizeof(StoredPointer)};
+
+    // return {true, meta->getFieldOffsets()[0]};
+    return {true, sizeof(StoredPointer)};
+  }
+
   /// Given a remote pointer to metadata, attempt to turn it into a type.
   BuiltType readTypeFromMetadata(StoredPointer MetadataAddress) {
     auto Cached = TypeCache.find(MetadataAddress);
diff --git a/include/swift/SwiftRemoteMirror/SwiftRemoteMirror.h b/include/swift/SwiftRemoteMirror/SwiftRemoteMirror.h
@@ -62,18 +62,32 @@ swift_reflection_addReflectionInfo(SwiftReflectionContextRef ContextRef,
 /// NULL if one can't be constructed.
 swift_typeref_t
 swift_reflection_typeRefForMetadata(SwiftReflectionContextRef ContextRef,
-                                    uintptr_t metadata);
+                                    uintptr_t Metadata);
 
-/// Returns a structure describing the overall layout of a typeref.
+/// Returns a structure describing the layout of a value of a typeref.
+/// For classes, this returns the reference value itself.
 swift_typeinfo_t
 swift_reflection_infoForTypeRef(SwiftReflectionContextRef ContextRef,
                                 swift_typeref_t OpaqueTypeRef);
 
-/// Returns the information about a child by index.
+/// Returns the information about a child field of a value by index.
 swift_childinfo_t
-swift_reflection_infoForField(SwiftReflectionContextRef ContextRef,
-                              swift_typeref_t OpaqueTypeRef,
-                              unsigned Index);
+swift_reflection_childOfTypeRef(SwiftReflectionContextRef ContextRef,
+                                swift_typeref_t OpaqueTypeRef,
+                                unsigned Index);
+
+/// Returns a structure describing the layout of a class instance
+/// from the isa pointer of a class.
+swift_typeinfo_t
+swift_reflection_infoForMetadata(SwiftReflectionContextRef ContextRef,
+                                 uintptr_t Metadata);
+
+/// Returns the information about a child field of a class instance
+/// by index.
+swift_childinfo_t
+swift_reflection_childOfMetadata(SwiftReflectionContextRef ContextRef,
+                                 uintptr_t Metadata,
+                                 unsigned Index);
 
 /// Returns a fully instantiated typeref for a generic argument by index.
 unsigned
@@ -83,6 +97,7 @@ swift_reflection_genericArgumentCountOfTypeRef(swift_typeref_t OpaqueTypeRef);
 swift_typeref_t
 swift_reflection_genericArgumentOfTypeRef(swift_typeref_t OpaqueTypeRef,
                                           unsigned Index);
+
 #ifdef __cplusplus
 } // extern "C"
 #endif
diff --git a/include/swift/SwiftRemoteMirror/SwiftRemoteMirrorTypes.h b/include/swift/SwiftRemoteMirror/SwiftRemoteMirrorTypes.h
@@ -54,6 +54,7 @@ typedef enum swift_layout_kind_t {
   SWIFT_EXISTENTIAL,
   SWIFT_CLASS_EXISTENTIAL,
   SWIFT_EXISTENTIAL_METATYPE,
+  SWIFT_CLASS_INSTANCE,
 
   // References to other objects in the heap.
   SWIFT_STRONG_REFERENCE,
diff --git a/stdlib/public/Reflection/TypeLowering.cpp b/stdlib/public/Reflection/TypeLowering.cpp
@@ -119,6 +119,9 @@ class PrintTypeInfo {
       case RecordKind::ExistentialMetatype:
         printHeader("existential_metatype");
         break;
+      case RecordKind::ClassInstance:
+        printHeader("class_instance");
+        break;
       }
       printBasic(TI);
       printFields(RecordTI);
@@ -197,6 +200,25 @@ class RecordTypeInfoBuilder {
     : TC(TC), Size(0), Alignment(1), Stride(0), NumExtraInhabitants(0),
       Kind(Kind), Invalid(false) {}
 
+  unsigned addField(unsigned fieldSize, unsigned fieldAlignment) {
+    // Align the current size appropriately
+    Size = ((Size + fieldAlignment - 1) & ~(fieldAlignment - 1));
+
+    // Record the offset
+    unsigned offset = Size;
+
+    // Update the aggregate size
+    Size += fieldSize;
+
+    // Update the aggregate alignment
+    Alignment = std::max(Alignment, fieldAlignment);
+
+    // Re-calculate the stride
+    Stride = ((Size + Alignment - 1) & ~(Alignment - 1));
+
+    return offset;
+  }
+
   void addField(const std::string &Name, const TypeRef *TR) {
     const TypeInfo *TI = TC.getTypeInfo(TR);
     if (TI == nullptr) {
@@ -213,20 +235,8 @@ class RecordTypeInfoBuilder {
     unsigned fieldSize = TI->getSize();
     unsigned fieldAlignment = TI->getAlignment();
 
-    // Align the current size appropriately
-    Size = ((Size + fieldAlignment - 1) & ~(fieldAlignment - 1));
-
-    // Add the field at the aligned offset
-    Fields.push_back({Name, Size, TR, *TI});
-
-    // Update the aggregate size
-    Size += fieldSize;
-
-    // Update the aggregate alignment
-    Alignment = std::max(Alignment, fieldAlignment);
-
-    // Re-calculate the stride
-    Stride = ((Size + Alignment - 1) & ~(Alignment - 1));
+    unsigned fieldOffset = addField(fieldSize, fieldAlignment);
+    Fields.push_back({Name, fieldOffset, TR, *TI});
   }
 
   const RecordTypeInfo *build() {
@@ -859,3 +869,35 @@ const TypeInfo *TypeConverter::getTypeInfo(const TypeRef *TR) {
 
   return TI;
 }
+
+const TypeInfo *TypeConverter::getInstanceTypeInfo(const TypeRef *TR,
+                                                   unsigned InstanceStart) {
+  const FieldDescriptor *FD = getBuilder().getFieldTypeInfo(TR);
+  if (FD == nullptr)
+    return nullptr;
+
+  switch (FD->Kind) {
+  case FieldDescriptorKind::Class: {
+    // Lower the class's fields using substitutions from the
+    // TypeRef to make field types concrete.
+    RecordTypeInfoBuilder builder(*this, RecordKind::ClassInstance);
+    auto *ReferenceTI = getTypeInfo(getNativeObjectTypeRef());
+    if (ReferenceTI == nullptr)
+      return nullptr;
+
+    // Start layout from the given instance start offset.
+    builder.addField(InstanceStart, ReferenceTI->getAlignment());
+
+    for (auto Field : getBuilder().getFieldTypeRefs(TR, FD))
+      builder.addField(Field.first, Field.second);
+    return builder.build();
+  }
+  case FieldDescriptorKind::Struct:
+  case FieldDescriptorKind::Enum:
+  case FieldDescriptorKind::ObjCProtocol:
+  case FieldDescriptorKind::ClassProtocol:
+  case FieldDescriptorKind::Protocol:
+    // Invalid field descriptor.
+    return nullptr;
+  }
+}
diff --git a/stdlib/public/SwiftRemoteMirror/SwiftRemoteMirror.cpp b/stdlib/public/SwiftRemoteMirror/SwiftRemoteMirror.cpp
@@ -120,6 +120,8 @@ swift_layout_kind_t getTypeInfoKind(const TypeInfo &TI) {
       return SWIFT_CLASS_EXISTENTIAL;
     case RecordKind::ExistentialMetatype:
       return SWIFT_EXISTENTIAL_METATYPE;
+    case RecordKind::ClassInstance:
+      return SWIFT_CLASS_INSTANCE;
     }
   }
   case TypeInfoKind::Reference: {
@@ -138,13 +140,7 @@ swift_layout_kind_t getTypeInfoKind(const TypeInfo &TI) {
   }
 }
 
-swift_typeinfo_t
-swift_reflection_infoForTypeRef(SwiftReflectionContextRef ContextRef,
-                                swift_typeref_t OpaqueTypeRef) {
-  auto Context = reinterpret_cast<NativeReflectionContext *>(ContextRef);
-  auto TR = reinterpret_cast<const TypeRef *>(OpaqueTypeRef);
-  auto TI = Context->getTypeInfo(TR);
-
+static swift_typeinfo_t convertTypeInfo(const TypeInfo *TI) {
   if (TI == nullptr) {
     return {
       SWIFT_UNKNOWN,
@@ -168,14 +164,8 @@ swift_reflection_infoForTypeRef(SwiftReflectionContextRef ContextRef,
   };
 }
 
-swift_childinfo_t
-swift_reflection_infoForChild(SwiftReflectionContextRef ContextRef,
-                              swift_typeref_t OpaqueTypeRef,
-                              unsigned Index) {
-  auto Context = reinterpret_cast<NativeReflectionContext *>(ContextRef);
-  auto TR = reinterpret_cast<const TypeRef *>(OpaqueTypeRef);
-
-  auto *RecordTI = cast<RecordTypeInfo>(Context->getTypeInfo(TR));
+static swift_childinfo_t convertChild(const TypeInfo *TI, unsigned Index) {
+  auto *RecordTI = cast<RecordTypeInfo>(TI);
   auto FieldInfo = RecordTI->getFields()[Index];
 
   return {
@@ -185,3 +175,39 @@ swift_reflection_infoForChild(SwiftReflectionContextRef ContextRef,
     reinterpret_cast<swift_typeref_t>(FieldInfo.TR),
   };
 }
+
+swift_typeinfo_t
+swift_reflection_infoForTypeRef(SwiftReflectionContextRef ContextRef,
+                                swift_typeref_t OpaqueTypeRef) {
+  auto Context = reinterpret_cast<NativeReflectionContext *>(ContextRef);
+  auto TR = reinterpret_cast<const TypeRef *>(OpaqueTypeRef);
+  auto TI = Context->getTypeInfo(TR);
+  return convertTypeInfo(TI);
+}
+
+swift_childinfo_t
+swift_reflection_childOfTypeRef(SwiftReflectionContextRef ContextRef,
+                                swift_typeref_t OpaqueTypeRef,
+                                unsigned Index) {
+  auto Context = reinterpret_cast<NativeReflectionContext *>(ContextRef);
+  auto TR = reinterpret_cast<const TypeRef *>(OpaqueTypeRef);
+  auto *TI = Context->getTypeInfo(TR);
+  return convertChild(TI, Index);
+}
+
+swift_typeinfo_t
+swift_reflection_infoForMetadata(SwiftReflectionContextRef ContextRef,
+                                 uintptr_t Metadata) {
+  auto Context = reinterpret_cast<NativeReflectionContext *>(ContextRef);
+  auto *TI = Context->getInstanceTypeInfo(Metadata);
+  return convertTypeInfo(TI);
+}
+
+swift_childinfo_t
+swift_reflection_childOfMetadata(SwiftReflectionContextRef ContextRef,
+                                 uintptr_t Metadata,
+                                 unsigned Index) {
+  auto Context = reinterpret_cast<NativeReflectionContext *>(ContextRef);
+  auto *TI = Context->getInstanceTypeInfo(Metadata);
+  return convertChild(TI, Index);
+}
diff --git a/tools/swift-reflection-test/swift-reflection-test.cpp b/tools/swift-reflection-test/swift-reflection-test.cpp
@@ -56,6 +56,8 @@ struct RemoteReflectionInfo {
   const StoredPointer StartAddress;
   const StoredSize TotalSize;
 
+  /// Return the lowest start address, excluding sections with a zero start
+  /// address, which denotes the section is missing.
   static StoredPointer getStartAddress(std::vector<Section<Runtime>> &&elts) {
     StoredPointer Start = 0;
     for (auto elt : elts) {
@@ -69,6 +71,7 @@ struct RemoteReflectionInfo {
     return Start;
   }
 
+  /// Return the largest end address.
   static StoredPointer getEndAddress(std::vector<Section<Runtime>> &&elts) {
     StoredPointer End = 0;
     for (auto elt : elts) {
@@ -367,7 +370,7 @@ static int doDumpHeapInstance(std::string BinaryFilename) {
       auto TR = RC.readTypeFromMetadata(isa);
       TR->dump(std::cout, 0);
 
-      auto TI = RC.getTypeInfo(isa);
+      auto TI = RC.getInstanceTypeInfo(isa);
       if (TI != nullptr)
         TI->dump();
     }
