[RemoteAST] Fix metadata reader to properly read function metadata

Author: xedin

include/swift/Remote/MetadataReader.h

@@ -798,38 +798,22 @@ class MetadataReader {
     }
     case MetadataKind::Function: {
       auto Function = cast<TargetFunctionTypeMetadata<Runtime>>(Meta);
-      auto numParameters = Function->getNumParameters();
+      auto *const parameters = Function->getParameters();
 
       std::vector<FunctionParam<BuiltType>> Parameters;
-      StoredPointer ArgumentAddress = MetadataAddress +
-        sizeof(TargetFunctionTypeMetadata<Runtime>);
-      StoredPointer ParameterFlagsAddress =
-                    ArgumentAddress + (numParameters * sizeof(StoredPointer));
-
-      for (unsigned i = 0; i < numParameters; ++i,
-           ArgumentAddress += sizeof(StoredPointer),
-           ParameterFlagsAddress += sizeof(uint32_t)) {
+      for (unsigned i = 0, n = Function->getNumParameters(); i != n; ++i) {
         StoredPointer ParamMetadata;
-        if (!Reader->readInteger(RemoteAddress(ArgumentAddress),
-                                 &ParamMetadata))
+        if (!Reader->readInteger(RemoteAddress(parameters + i), &ParamMetadata))
           return BuiltType();
 
-        if (auto ParamTypeRef = readTypeFromMetadata(ParamMetadata)) {
-          FunctionParam<BuiltType> Param;
-          Param.setType(ParamTypeRef);
-
-          if (Function->hasParameterFlags()) {
-            uint32_t ParameterFlags;
-            if (!Reader->readInteger(RemoteAddress(ParameterFlagsAddress),
-                                     &ParameterFlags))
-              return BuiltType();
-              Param.setFlags(ParameterFlags::fromIntValue(ParameterFlags));
-          }
-
-          Parameters.push_back(std::move(Param));
-        } else {
+        auto ParamTypeRef = readTypeFromMetadata(ParamMetadata);
+        if (!ParamTypeRef)
           return BuiltType();
-        }
+
+        FunctionParam<BuiltType> Param;
+        Param.setType(ParamTypeRef);
+        Param.setFlags(Function->getParameterFlags(i));
+        Parameters.push_back(std::move(Param));
       }
 
       auto Result = readTypeFromMetadata(Function->ResultType);
@@ -1203,8 +1187,24 @@ class MetadataReader {
         return _readMetadata<TargetExistentialMetatypeMetadata>(address);
       case MetadataKind::ForeignClass:
         return _readMetadata<TargetForeignClassMetadata>(address);
-      case MetadataKind::Function:
-        return _readMetadata<TargetFunctionTypeMetadata>(address);
+      case MetadataKind::Function: {
+        StoredSize flagsValue;
+        auto flagsAddr =
+            address + TargetFunctionTypeMetadata<Runtime>::OffsetToFlags;
+        if (!Reader->readInteger(RemoteAddress(flagsAddr), &flagsValue))
+          return nullptr;
+
+        auto flags =
+            TargetFunctionTypeFlags<StoredSize>::fromIntValue(flagsValue);
+
+        auto totalSize = sizeof(TargetFunctionTypeMetadata<Runtime>) +
+                         flags.getNumParameters() * sizeof(StoredPointer);
+
+        if (flags.hasParameterFlags())
+          totalSize += flags.getNumParameters() * sizeof(uint32_t);
+
+        return _readMetadata(address, totalSize);
+      }
       case MetadataKind::HeapGenericLocalVariable:
         return _readMetadata<TargetGenericBoxHeapMetadata>(address);
       case MetadataKind::HeapLocalVariable:

include/swift/Runtime/Metadata.h

@@ -1752,22 +1752,10 @@ struct TargetFunctionTypeMetadata : public TargetMetadata<Runtime> {
   /// The type metadata for the result type.
   ConstTargetMetadataPointer<Runtime, swift::TargetMetadata> ResultType;
 
-  TargetPointer<Runtime, Parameter> getParameters() {
-    return reinterpret_cast<TargetPointer<Runtime, Parameter>>(this + 1);
-  }
-
-  TargetPointer<Runtime, const Parameter> getParameters() const {
-    return reinterpret_cast<TargetPointer<Runtime, const Parameter>>(this + 1);
-  }
-
-  TargetPointer<Runtime, uint32_t> getParameterFlags() {
-    return reinterpret_cast<TargetPointer<Runtime, uint32_t>>(
-                  reinterpret_cast<Parameter *>(this + 1) + getNumParameters());
-  }
+  Parameter *getParameters() { return reinterpret_cast<Parameter *>(this + 1); }
 
-  TargetPointer<Runtime, const uint32_t> getParameterFlags() const {
-    return reinterpret_cast<TargetPointer<Runtime, const uint32_t>>(
-            reinterpret_cast<const Parameter *>(this + 1) + getNumParameters());
+  const Parameter *getParameters() const {
+    return reinterpret_cast<const Parameter *>(this + 1);
   }
 
   ParameterFlags getParameterFlags(unsigned index) const {
@@ -1790,6 +1778,15 @@ struct TargetFunctionTypeMetadata : public TargetMetadata<Runtime> {
   static bool classof(const TargetMetadata<Runtime> *metadata) {
     return metadata->getKind() == MetadataKind::Function;
   }
+
+  uint32_t *getParameterFlags() {
+    return reinterpret_cast<uint32_t *>(getParameters() + getNumParameters());
+  }
+
+  const uint32_t *getParameterFlags() const {
+    return reinterpret_cast<const uint32_t *>(getParameters() +
+                                              getNumParameters());
+  }
 };
 using FunctionTypeMetadata = TargetFunctionTypeMetadata<InProcess>;