Get typerefs for function type metadata

Author: bitjammer

include/swift/ABI/MetadataValues.h

@@ -448,8 +448,9 @@ enum class FunctionMetadataConvention: uint8_t {
 };
 
 /// Flags in a function type metadata record.
-class FunctionTypeFlags {
-  typedef size_t int_type;
+template <typename Runtime>
+class TargetFunctionTypeFlags {
+  using int_type = typename Runtime::StoredSize;
   enum : int_type {
     NumArgumentsMask = 0x00FFFFFFU,
     ConventionMask   = 0x0F000000U,
@@ -458,22 +459,24 @@ class FunctionTypeFlags {
   };
   int_type Data;
 
-  constexpr FunctionTypeFlags(int_type Data) : Data(Data) {}
+  constexpr TargetFunctionTypeFlags(int_type Data) : Data(Data) {}
 public:
-  constexpr FunctionTypeFlags() : Data(0) {}
+  constexpr TargetFunctionTypeFlags() : Data(0) {}
 
-  constexpr FunctionTypeFlags withNumArguments(unsigned numArguments) const {
-    return FunctionTypeFlags((Data & ~NumArgumentsMask) | numArguments);
+  constexpr TargetFunctionTypeFlags withNumArguments(unsigned numArguments) const {
+    return TargetFunctionTypeFlags((Data & ~NumArgumentsMask) | numArguments);
   }
 
-  constexpr FunctionTypeFlags withConvention(FunctionMetadataConvention c) const {
-    return FunctionTypeFlags((Data & ~ConventionMask)
+  constexpr TargetFunctionTypeFlags<Runtime>
+  withConvention(FunctionMetadataConvention c) const {
+    return TargetFunctionTypeFlags((Data & ~ConventionMask)
                              | (int_type(c) << ConventionShift));
   }
 
-  constexpr FunctionTypeFlags withThrows(bool throws) const {
-    return FunctionTypeFlags((Data & ~ThrowsMask)
-                             | (throws ? ThrowsMask : 0));
+  constexpr TargetFunctionTypeFlags<Runtime>
+  withThrows(bool throws) const {
+    return TargetFunctionTypeFlags<Runtime>((Data & ~ThrowsMask) |
+                                            (throws ? ThrowsMask : 0));
   }
 
   unsigned getNumArguments() const {
@@ -492,17 +495,18 @@ class FunctionTypeFlags {
     return Data;
   }
 
-  static FunctionTypeFlags fromIntValue(int_type Data) {
-    return FunctionTypeFlags(Data);
+  static TargetFunctionTypeFlags<Runtime> fromIntValue(int_type Data) {
+    return TargetFunctionTypeFlags(Data);
   }
 
-  bool operator==(FunctionTypeFlags other) const {
+  bool operator==(TargetFunctionTypeFlags<Runtime> other) const {
     return Data == other.Data;
   }
-  bool operator!=(FunctionTypeFlags other) const {
+  bool operator!=(TargetFunctionTypeFlags<Runtime> other) const {
     return Data != other.Data;
   }
 };
+using FunctionTypeFlags = TargetFunctionTypeFlags<InProcess>;
 
 /// Field types and flags as represented in a nominal type's field/case type
 /// vector.

include/swift/Reflection/ReflectionContext.h

@@ -330,8 +330,27 @@ class ReflectionContext {
     }
     case MetadataKind::Function: {
       auto Function = cast<TargetFunctionTypeMetadata<Runtime>>(Meta.get());
+      StoredPointer FlagsAddress = MetadataAddress +
+        TargetFunctionTypeMetadata<Runtime>::OffsetToFlags;
+      TargetFunctionTypeFlags<Runtime> Flags;
+      if (!Reader.readBytes(FlagsAddress, (uint8_t*)&Flags, sizeof(Flags)))
+        return nullptr;
       TypeRefVector Arguments;
-      llvm_unreachable("todo");
+      StoredPointer ArgumentAddress = MetadataAddress +
+        sizeof(TargetFunctionTypeMetadata<Runtime>);
+      for (StoredPointer i = 0; i < Function->getNumArguments(); ++i,
+           ArgumentAddress += sizeof(StoredPointer)) {
+        StoredPointer FlaggedArgumentAddress;
+        if (!Reader.readInteger(ArgumentAddress, &FlaggedArgumentAddress))
+          return nullptr;
+        // TODO: Use target-agnostic FlaggedPointer to mask this!
+        FlaggedArgumentAddress &= ~((StoredPointer)1);
+        if (auto ArgumentTypeRef = getTypeRef(FlaggedArgumentAddress))
+          Arguments.push_back(ArgumentTypeRef);
+        else
+          return nullptr;
+      }
+
       auto Result = getTypeRef(Function->ResultType);
       return FunctionTypeRef::create(Arguments, Result);
     }

include/swift/Runtime/Metadata.h

@@ -2030,19 +2030,21 @@ using EnumMetadata = TargetEnumMetadata<InProcess>;
 template <typename Runtime>
 struct TargetFunctionTypeMetadata : public TargetMetadata<Runtime> {
   using StoredSize = typename Runtime::StoredSize;
+
+  // TODO: Make this target agnostic
   using Argument = FlaggedPointer<const TargetMetadata<Runtime> *, 0>;
 
-  FunctionTypeFlags Flags;
+  TargetFunctionTypeFlags<Runtime> Flags;
 
   /// The type metadata for the result type.
   ConstTargetMetadataPointer<Runtime, TargetMetadata> ResultType;
 
-  Argument *getArguments() {
-    return reinterpret_cast<Argument *>(this + 1);
+  TargetPointer<Runtime, Argument> getArguments() {
+    return reinterpret_cast<TargetPointer<Runtime, Argument>>(this + 1);
   }
 
-  const Argument *getArguments() const {
-    return reinterpret_cast<const Argument *>(this + 1);
+  TargetPointer<Runtime, const Argument> getArguments() const {
+    return reinterpret_cast<TargetPointer<Runtime, const Argument>>(this + 1);
   }
 
   StoredSize getNumArguments() const {
@@ -2053,6 +2055,8 @@ struct TargetFunctionTypeMetadata : public TargetMetadata<Runtime> {
   }
   bool throws() const { return Flags.throws(); }
 
+  static constexpr StoredSize OffsetToFlags = sizeof(TargetMetadata<Runtime>);
+
   static bool classof(const TargetMetadata<Runtime> *metadata) {
     return metadata->getKind() == MetadataKind::Function;
   }