Implement RemoteInspection support for Builtin.FixedArray

Azoy · Azoy · commit c62e851e3833 · 2025-01-08T10:37:17.000-08:00
diff --git a/include/swift/RemoteInspection/TypeLowering.h b/include/swift/RemoteInspection/TypeLowering.h
@@ -117,6 +117,7 @@ enum class TypeInfoKind : unsigned {
   Reference,
   Invalid,
   Enum,
+  Array,
 };
 
 class TypeInfo {
@@ -350,6 +351,24 @@ class ReferenceTypeInfo : public TypeInfo {
   }
 };
 
+/// Array based layouts like Builtin.FixedArray<N, T>
+class ArrayTypeInfo : public TypeInfo {
+  const TypeInfo *ElementTI;
+
+public:
+  explicit ArrayTypeInfo(intptr_t size, const TypeInfo *elementTI);
+
+  bool readExtraInhabitantIndex(remote::MemoryReader &reader,
+                                remote::RemoteAddress address,
+                                int *extraInhabitantIndex) const override;
+
+  BitMask getSpareBits(TypeConverter &TC, bool &hasAddrOnly) const override;
+
+  static bool classof(const TypeInfo *TI) {
+    return TI->getKind() == TypeInfoKind::Array;
+  }
+};
+
 /// This class owns the memory for all TypeInfo instances that it vends.
 class TypeConverter {
   TypeRefBuilder &Builder;
diff --git a/include/swift/RemoteInspection/TypeRef.h b/include/swift/RemoteInspection/TypeRef.h
@@ -1095,6 +1095,67 @@ class SILBoxTypeWithLayoutTypeRef final : public TypeRef {
   }
 };
 
+class IntegerTypeRef final : public TypeRef {
+  intptr_t Value;
+
+  static TypeRefID Profile(const intptr_t &Value) {
+    TypeRefID ID;
+    ID.addInteger((uint64_t)Value);
+    return ID;
+  }
+
+public:
+  IntegerTypeRef(const intptr_t &Value)
+    : TypeRef(TypeRefKind::Integer), Value(Value) {}
+
+  template <typename Allocator>
+  static const IntegerTypeRef *create(Allocator &A, intptr_t Value) {
+    FIND_OR_CREATE_TYPEREF(A, IntegerTypeRef, Value);
+  }
+
+  const intptr_t &getValue() const {
+    return Value;
+  }
+
+  static bool classof(const TypeRef *TR) {
+    return TR->getKind() == TypeRefKind::Integer;
+  }
+};
+
+class BuiltinFixedArrayTypeRef final : public TypeRef {
+  intptr_t Size;
+  const TypeRef *Element;
+
+  static TypeRefID Profile(const intptr_t &Size, const TypeRef *Element) {
+    TypeRefID ID;
+    ID.addInteger((uint64_t)Size);
+    ID.addPointer(Element);
+    return ID;
+  }
+
+public:
+  BuiltinFixedArrayTypeRef(const intptr_t &Size, const TypeRef *Element)
+    : TypeRef(TypeRefKind::BuiltinFixedArray), Size(Size), Element(Element) {}
+
+  template <typename Allocator>
+  static const BuiltinFixedArrayTypeRef *create(Allocator &A, intptr_t Size,
+                                                const TypeRef *Element) {
+    FIND_OR_CREATE_TYPEREF(A, BuiltinFixedArrayTypeRef, Size, Element);
+  }
+
+  const intptr_t &getSize() const {
+    return Size;
+  }
+
+  const TypeRef *getElementType() const {
+    return Element;
+  }
+
+  static bool classof(const TypeRef *TR) {
+    return TR->getKind() == TypeRefKind::BuiltinFixedArray;
+  }
+};
+
 template <typename ImplClass, typename RetTy = void, typename... Args>
 class TypeRefVisitor {
 public:
diff --git a/include/swift/RemoteInspection/TypeRefBuilder.h b/include/swift/RemoteInspection/TypeRefBuilder.h
@@ -929,19 +929,18 @@ class TypeRefBuilder {
   }
 
   const TypeRef *createIntegerType(intptr_t value) {
-    // FIXME: implement
-    return nullptr;
+    return IntegerTypeRef::create(*this, value);
   }
 
   const TypeRef *createNegativeIntegerType(intptr_t value) {
-    // FIXME: implement
-    return nullptr;
+    return IntegerTypeRef::create(*this, value);
   }
 
   const TypeRef *createBuiltinFixedArrayType(const TypeRef *size,
                                              const TypeRef *element) {
-    // FIXME: implement
-    return nullptr;
+    auto integer = cast<IntegerTypeRef>(size);
+    return BuiltinFixedArrayTypeRef::create(*this, integer->getValue(),
+                                            element);
   }
 
   // Construct a bound generic type ref along with the parent type info
diff --git a/include/swift/RemoteInspection/TypeRefs.def b/include/swift/RemoteInspection/TypeRefs.def
@@ -37,5 +37,7 @@ TYPEREF(OpaqueArchetype, TypeRef)
 #include "swift/AST/ReferenceStorage.def"
 TYPEREF(SILBox, TypeRef)
 TYPEREF(SILBoxTypeWithLayout, TypeRef)
+TYPEREF(Integer, TypeRef)
+TYPEREF(BuiltinFixedArray, TypeRef)
 
 #undef TYPEREF
diff --git a/include/swift/SwiftRemoteMirror/SwiftRemoteMirrorTypes.h b/include/swift/SwiftRemoteMirror/SwiftRemoteMirrorTypes.h
@@ -143,6 +143,9 @@ typedef enum swift_layout_kind {
   // swift_reflection_infoForTypeRef().
   SWIFT_CLASS_INSTANCE,
   SWIFT_CLOSURE_CONTEXT,
+
+  // A contiguous list of N Ts, typically for Builtin.FixedArray<N, T>.
+  SWIFT_ARRAY,
 } swift_layout_kind_t;
 
 struct swift_childinfo;
diff --git a/stdlib/public/RemoteInspection/TypeLowering.cpp b/stdlib/public/RemoteInspection/TypeLowering.cpp
@@ -217,6 +217,13 @@ class PrintTypeInfo {
       stream << ")";
       return;
     }
+
+    case TypeInfoKind::Array: {
+      printHeader("array");
+      printBasic(TI);
+      stream << ")";
+      return;
+    }
     }
 
     swift_unreachable("Bad TypeInfo kind");
@@ -475,6 +482,26 @@ BitMask RecordTypeInfo::getSpareBits(TypeConverter &TC, bool &hasAddrOnly) const
   return mask;
 }
 
+ArrayTypeInfo::ArrayTypeInfo(intptr_t size, const TypeInfo *elementTI)
+    : TypeInfo(TypeInfoKind::Array,
+               /* size */ elementTI->getStride() * size,
+               /* alignment */ elementTI->getAlignment(),
+               /* stride */ elementTI->getStride() * size,
+               /* numExtraInhabitants */ elementTI->getNumExtraInhabitants(),
+               /* isBitwiseTakable */ elementTI->isBitwiseTakable()),
+      ElementTI(elementTI) {}
+
+bool ArrayTypeInfo::readExtraInhabitantIndex(
+    remote::MemoryReader &reader, remote::RemoteAddress address,
+    int *extraInhabitantIndex) const {
+  return ElementTI->readExtraInhabitantIndex(reader, address,
+                                             extraInhabitantIndex);
+}
+
+BitMask ArrayTypeInfo::getSpareBits(TypeConverter &TC, bool &hasAddrOnly) const {
+  return ElementTI->getSpareBits(TC, hasAddrOnly);
+}
+
 class UnsupportedEnumTypeInfo: public EnumTypeInfo {
 public:
   UnsupportedEnumTypeInfo(unsigned Size, unsigned Alignment,
@@ -1786,6 +1813,14 @@ class HasFixedSize
   bool visitOpaqueArchetypeTypeRef(const OpaqueArchetypeTypeRef *O) {
     return false;
   }
+
+  bool visitIntegerTypeRef(const IntegerTypeRef *I) {
+    return false;
+  }
+
+  bool visitBuiltinFixedArrayTypeRef(const BuiltinFixedArrayTypeRef *BA) {
+    return visit(BA->getElementType());
+  }
 };
 
 bool TypeConverter::hasFixedSize(const TypeRef *TR) {
@@ -1921,6 +1956,14 @@ class HasSingletonMetatype
   MetatypeRepresentation visitOpaqueArchetypeTypeRef(const OpaqueArchetypeTypeRef *O) {
     return MetatypeRepresentation::Unknown;
   }
+
+  MetatypeRepresentation visitIntegerTypeRef(const IntegerTypeRef *I) {
+    return MetatypeRepresentation::Unknown;
+  }
+
+  MetatypeRepresentation visitBuiltinFixedArrayTypeRef(const BuiltinFixedArrayTypeRef *BA) {
+    return visit(BA->getElementType());
+  }
 };
 
 class EnumTypeInfoBuilder {
@@ -2544,6 +2587,17 @@ class LowerType
     DEBUG_LOG(fprintf(stderr, "Can't lower unresolved opaque archetype TypeRef"));
     return nullptr;
   }
+
+  const TypeInfo *visitIntegerTypeRef(const IntegerTypeRef *I) {
+    DEBUG_LOG(fprintf(stderr, "Can't lower integer TypeRef"));
+    return nullptr;
+  }
+
+  const TypeInfo *visitBuiltinFixedArrayTypeRef(const BuiltinFixedArrayTypeRef *BA) {
+    auto elementTI = visit(BA->getElementType());
+
+    return TC.makeTypeInfo<ArrayTypeInfo>(BA->getSize(), elementTI);
+  }
 };
 
 const TypeInfo *
diff --git a/stdlib/public/RemoteInspection/TypeRef.cpp b/stdlib/public/RemoteInspection/TypeRef.cpp
@@ -395,6 +395,19 @@ class PrintTypeRef : public TypeRefVisitor<PrintTypeRef, void> {
     printHeader("opaque");
     stream << ")";
   }
+
+  void visitIntegerTypeRef(const IntegerTypeRef *I) {
+    printHeader("integer");
+    printField("value", std::to_string(I->getValue()));
+    stream << ")";
+  }
+
+  void visitBuiltinFixedArrayTypeRef(const BuiltinFixedArrayTypeRef *BA) {
+    printHeader("builtin_fixed_array");
+    printField("size", std::to_string(BA->getSize()));
+    printRec(BA->getElementType());
+    stream << ")";
+  }
 };
 
 struct TypeRefIsConcrete
@@ -506,6 +519,14 @@ struct TypeRefIsConcrete
   bool visitSILBoxTypeWithLayoutTypeRef(const SILBoxTypeWithLayoutTypeRef *SB) {
     return true;
   }
+
+  bool visitIntegerTypeRef(const IntegerTypeRef *I) {
+    return true;
+  }
+
+  bool visitBuiltinFixedArrayTypeRef(const BuiltinFixedArrayTypeRef *BA) {
+    return visit(BA->getElementType());
+  }
 };
 
 const OpaqueTypeRef *
@@ -1049,6 +1070,30 @@ class DemanglingForTypeRef
     
     return node;
   }
+
+  Demangle::NodePointer createInteger(intptr_t value) {
+    if (value >= 0) {
+      return Dem.createNode(Node::Kind::Integer, value);
+    } else {
+      return Dem.createNode(Node::Kind::NegativeInteger, value);
+    }
+  }
+
+  Demangle::NodePointer visitIntegerTypeRef(const IntegerTypeRef *I) {
+    return createInteger(I->getValue());
+  }
+
+  Demangle::NodePointer visitBuiltinFixedArrayTypeRef(const BuiltinFixedArrayTypeRef *BA) {
+    auto ba = Dem.createNode(Node::Kind::BuiltinFixedArray);
+
+    auto size = Dem.createNode(Node::Kind::Type);
+    size->addChild(createInteger(BA->getSize()), Dem);
+    ba->addChild(size, Dem);
+
+    ba->addChild(visit(BA->getElementType()), Dem);
+
+    return ba;
+  }
 };
 
 Demangle::NodePointer TypeRef::getDemangling(Demangle::Demangler &Dem) const {
@@ -1277,6 +1322,14 @@ class ThickenMetatype
     return O;
   }
 
+  const TypeRef *visitIntegerTypeRef(const IntegerTypeRef *I) {
+    return I;
+  }
+
+  const TypeRef *visitBuiltinFixedArrayTypeRef(const BuiltinFixedArrayTypeRef *BA) {
+    return BuiltinFixedArrayTypeRef::create(Builder, BA->getSize(),
+                                            visit(BA->getElementType()));
+  }
 };
 
 static const TypeRef *
@@ -1531,6 +1584,15 @@ class TypeRefSubstitution
                                           O->getOrdinal(),
                                           newArgLists);
   }
+
+  const TypeRef *visitIntegerTypeRef(const IntegerTypeRef *I) {
+    return I;
+  }
+
+  const TypeRef *visitBuiltinFixedArrayTypeRef(const BuiltinFixedArrayTypeRef *BA) {
+    return BuiltinFixedArrayTypeRef::create(Builder, BA->getSize(),
+                                            visit(BA->getElementType()));
+  }
 };
 
 const TypeRef *TypeRef::subst(TypeRefBuilder &Builder,
diff --git a/stdlib/public/SwiftRemoteMirror/SwiftRemoteMirror.cpp b/stdlib/public/SwiftRemoteMirror/SwiftRemoteMirror.cpp
@@ -529,6 +529,10 @@ swift_layout_kind_t getTypeInfoKind(const TypeInfo &TI) {
 #include "swift/AST/ReferenceStorage.def"
     }
   }
+
+  case TypeInfoKind::Array: {
+    return SWIFT_ARRAY;
+  }
   }
 
   swift_unreachable("Unhandled TypeInfoKind in switch");
diff --git a/test/Reflection/typeref_lowering.swift b/test/Reflection/typeref_lowering.swift
@@ -1269,3 +1269,12 @@ BD
 
 // CHECK-32:      (builtin Builtin.DefaultActorStorage)
 // CHECK-32-NEXT:    (builtin size=48 alignment=8 stride=48 num_extra_inhabitants=0 bitwise_takable=1)
+
+$1_SiBV
+// CHECK-64:      (builtin_fixed_array size=2
+// CHECK-64-NEXT:   (struct Swift.Int))
+// CHECK-64-NEXT: (array size=16 alignment=8 stride=16 num_extra_inhabitants=0 bitwise_takable=1)
+
+// CHECK-32:      (builtin_fixed_array size=2
+// CHECK-32-NEXT:   (struct Swift.Int))
+// CHECK-32-NEXT: (array size=8 alignment=4 stride=8 num_extra_inhabitants=0 bitwise_takable=1)

Original file line number	Diff line number	Diff line change
`@@ -929,19 +929,18 @@ class TypeRefBuilder {`
`929`	`929`	`}`
`930`	`930`
`931`	`931`	`const TypeRef *createIntegerType(intptr_t value) {`
`932`		`- // FIXME: implement`
`933`		`- return nullptr;`
	`932`	`+ return IntegerTypeRef::create(*this, value);`
`934`	`933`	`}`
`935`	`934`
`936`	`935`	`const TypeRef *createNegativeIntegerType(intptr_t value) {`
`937`		`- // FIXME: implement`
`938`		`- return nullptr;`
	`936`	`+ return IntegerTypeRef::create(*this, value);`
`939`	`937`	`}`
`940`	`938`
`941`	`939`	`const TypeRef createBuiltinFixedArrayType(const TypeRef size,`
`942`	`940`	`const TypeRef *element) {`
`943`		`- // FIXME: implement`
`944`		`- return nullptr;`
	`941`	`+ auto integer = cast<IntegerTypeRef>(size);`
	`942`	`+ return BuiltinFixedArrayTypeRef::create(*this, integer->getValue(),`
	`943`	`+ element);`
`945`	`944`	`}`
`946`	`945`
`947`	`946`	`// Construct a bound generic type ref along with the parent type info`
Original file line number	Diff line number	Diff line change
`@@ -529,6 +529,10 @@ swift_layout_kind_t getTypeInfoKind(const TypeInfo &TI) {`
`529`	`529`	`#include "swift/AST/ReferenceStorage.def"`
`530`	`530`	`}`
`531`	`531`	`}`
	`532`	`+`
	`533`	`+ case TypeInfoKind::Array: {`
	`534`	`+ return SWIFT_ARRAY;`
	`535`	`+ }`
`532`	`536`	`}`
`533`	`537`
`534`	`538`	`swift_unreachable("Unhandled TypeInfoKind in switch");`