Reimplement TargetFunctionTypeMetadata using TrailingObjects

The layout is the same, but this eliminates the handwritten address
computations.

Author: DougGregor

include/swift/ABI/Metadata.h

@@ -1459,21 +1459,70 @@ struct TargetEnumMetadata : public TargetValueMetadata<Runtime> {
 };
 using EnumMetadata = TargetEnumMetadata<InProcess>;
 
+template <typename Runtime>
+struct TargetFunctionGlobalActorMetadata {
+  ConstTargetMetadataPointer<Runtime, swift::TargetMetadata> GlobalActorType;
+};
+
 /// The structure of function type metadata.
 template <typename Runtime>
-struct TargetFunctionTypeMetadata : public TargetMetadata<Runtime> {
+struct TargetFunctionTypeMetadata : public TargetMetadata<Runtime>,
+  swift::ABI::TrailingObjects<
+    TargetFunctionTypeMetadata<Runtime>,
+    ConstTargetMetadataPointer<Runtime, swift::TargetMetadata>,
+    ParameterFlags,
+    TargetFunctionMetadataDifferentiabilityKind<typename Runtime::StoredSize>,
+    TargetFunctionGlobalActorMetadata<Runtime>> {
   using StoredSize = typename Runtime::StoredSize;
   using Parameter = ConstTargetMetadataPointer<Runtime, swift::TargetMetadata>;
 
+private:
+  using TrailingObjects =
+      swift::ABI::TrailingObjects<
+        TargetFunctionTypeMetadata<Runtime>,
+        Parameter,
+        ParameterFlags,
+        TargetFunctionMetadataDifferentiabilityKind<StoredSize>,
+        TargetFunctionGlobalActorMetadata<Runtime>>;
+  friend TrailingObjects;
+
+  template<typename T>
+  using OverloadToken = typename TrailingObjects::template OverloadToken<T>;
+
+public:
   TargetFunctionTypeFlags<StoredSize> Flags;
 
   /// The type metadata for the result type.
   ConstTargetMetadataPointer<Runtime, swift::TargetMetadata> ResultType;
 
-  Parameter *getParameters() { return reinterpret_cast<Parameter *>(this + 1); }
+private:
+  size_t numTrailingObjects(OverloadToken<Parameter>) const {
+    return getNumParameters();
+  }
+
+  size_t numTrailingObjects(OverloadToken<ParameterFlags>) const {
+    return hasParameterFlags() ? getNumParameters() : 0;
+  }
+
+  size_t numTrailingObjects(
+      OverloadToken<TargetFunctionMetadataDifferentiabilityKind<StoredSize>>
+  ) const {
+    return isDifferentiable() ? 1 : 0;
+  }
+
+  size_t numTrailingObjects(
+      OverloadToken<TargetFunctionGlobalActorMetadata<Runtime>>
+  ) const {
+    return hasGlobalActor() ? 1 : 0;
+  }
+
+public:
+  Parameter *getParameters() { 
+    return this->template getTrailingObjects<Parameter>();
+  }
 
   const Parameter *getParameters() const {
-    return reinterpret_cast<const Parameter *>(this + 1);
+    return this->template getTrailingObjects<Parameter>();
   }
 
   Parameter getParameter(unsigned index) const {
@@ -1483,8 +1532,7 @@ struct TargetFunctionTypeMetadata : public TargetMetadata<Runtime> {
 
   ParameterFlags getParameterFlags(unsigned index) const {
     assert(index < getNumParameters());
-    auto flags = hasParameterFlags() ? getParameterFlags()[index] : 0;
-    return ParameterFlags::fromIntValue(flags);
+    return hasParameterFlags() ? getParameterFlags()[index] : ParameterFlags();
   }
 
   StoredSize getNumParameters() const {
@@ -1507,32 +1555,24 @@ struct TargetFunctionTypeMetadata : public TargetMetadata<Runtime> {
     return metadata->getKind() == MetadataKind::Function;
   }
 
-  uint32_t *getParameterFlags() {
-    return reinterpret_cast<uint32_t *>(getParameters() + getNumParameters());
+  ParameterFlags *getParameterFlags() {
+    return this->template getTrailingObjects<ParameterFlags>();
   }
 
-  const uint32_t *getParameterFlags() const {
-    return reinterpret_cast<const uint32_t *>(getParameters() +
-                                              getNumParameters());
+  const ParameterFlags *getParameterFlags() const {
+    return this->template getTrailingObjects<ParameterFlags>();
   }
 
   TargetFunctionMetadataDifferentiabilityKind<StoredSize> *
   getDifferentiabilityKindAddress() {
     assert(isDifferentiable());
-    void *previousEndAddr = hasParameterFlags()
-        ? reinterpret_cast<void *>(getParameterFlags() + getNumParameters())
-        : reinterpret_cast<void *>(getParameters() + getNumParameters());
-    return reinterpret_cast<
-        TargetFunctionMetadataDifferentiabilityKind<StoredSize> *>(
-        llvm::alignAddr(previousEndAddr,
-                        llvm::Align(alignof(typename Runtime::StoredPointer))));
+    return this->template getTrailingObjects<TargetFunctionMetadataDifferentiabilityKind<StoredSize>>();
   }
 
   TargetFunctionMetadataDifferentiabilityKind<StoredSize>
   getDifferentiabilityKind() const {
     if (isDifferentiable()) {
-      return *const_cast<TargetFunctionTypeMetadata<Runtime> *>(this)
-          ->getDifferentiabilityKindAddress();
+      return *(this->template getTrailingObjects<TargetFunctionMetadataDifferentiabilityKind<StoredSize>>());
     }
     return TargetFunctionMetadataDifferentiabilityKind<StoredSize>
         ::NonDifferentiable;
@@ -1541,26 +1581,18 @@ struct TargetFunctionTypeMetadata : public TargetMetadata<Runtime> {
   ConstTargetMetadataPointer<Runtime, swift::TargetMetadata> *
   getGlobalActorAddr() {
     assert(hasGlobalActor());
-    
-    void *endAddr =
-        isDifferentiable()
-          ? reinterpret_cast<void *>(getDifferentiabilityKindAddress() + 1) :
-        hasParameterFlags()
-          ? reinterpret_cast<void *>(getParameterFlags() + getNumParameters()) :
-        reinterpret_cast<void *>(getParameters() + getNumParameters());
-    return reinterpret_cast<
-        ConstTargetMetadataPointer<Runtime, swift::TargetMetadata> *>(
-          llvm::alignAddr(
-              endAddr, llvm::Align(alignof(typename Runtime::StoredPointer))));
+    auto globalActorAddr =
+      this->template getTrailingObjects<TargetFunctionGlobalActorMetadata<Runtime>>();
+    return &globalActorAddr->GlobalActorType;
   }
 
   ConstTargetMetadataPointer<Runtime, swift::TargetMetadata>
   getGlobalActor() const {
     if (!hasGlobalActor())
       return ConstTargetMetadataPointer<Runtime, swift::TargetMetadata>();
-
-    return *const_cast<TargetFunctionTypeMetadata<Runtime> *>(this)
-      ->getGlobalActorAddr();
+    auto globalActorAddr =
+      this->template getTrailingObjects<TargetFunctionGlobalActorMetadata<Runtime>>();
+    return globalActorAddr->GlobalActorType;
   }
 };
 using FunctionTypeMetadata = TargetFunctionTypeMetadata<InProcess>;

stdlib/public/runtime/Metadata.cpp

@@ -1354,7 +1354,7 @@ class FunctionCacheEntry {
     const FunctionTypeFlags Flags;
     const FunctionMetadataDifferentiabilityKind DifferentiabilityKind;
     const Metadata *const *Parameters;
-    const uint32_t *ParameterFlags;
+    const ::ParameterFlags *ParameterFlags;
     const Metadata *Result;
     const Metadata *GlobalActor;
 
@@ -1370,14 +1370,13 @@ class FunctionCacheEntry {
     }
     const Metadata *getResult() const { return Result; }
 
-    const uint32_t *getParameterFlags() const {
+    const ::ParameterFlags *getParameterFlags() const {
       return ParameterFlags;
     }
 
     ::ParameterFlags getParameterFlags(unsigned index) const {
       assert(index < Flags.getNumParameters());
-      auto flags = Flags.hasParameterFlags() ? ParameterFlags[index] : 0;
-      return ParameterFlags::fromIntValue(flags);
+      return Flags.hasParameterFlags() ? ParameterFlags[index] : ::ParameterFlags();
     }
 
     const Metadata *getGlobalActor() const { return GlobalActor; }
@@ -1509,7 +1508,7 @@ swift::swift_getFunctionTypeMetadata(FunctionTypeFlags flags,
             "'swift_getFunctionTypeMetadataGlobalActor'");
   FunctionCacheEntry::Key key = {
     flags, FunctionMetadataDifferentiabilityKind::NonDifferentiable, parameters,
-    parameterFlags, result, nullptr
+    reinterpret_cast<const ParameterFlags *>(parameterFlags), result, nullptr
   };
   return &FunctionTypes.getOrInsert(key).first->Data;
 }
@@ -1525,7 +1524,8 @@ swift::swift_getFunctionTypeMetadataDifferentiable(
   assert(flags.isDifferentiable());
   assert(diffKind.isDifferentiable());
   FunctionCacheEntry::Key key = {
-    flags, diffKind, parameters, parameterFlags, result, nullptr
+    flags, diffKind, parameters,
+    reinterpret_cast<const ParameterFlags *>(parameterFlags), result, nullptr
   };
   return &FunctionTypes.getOrInsert(key).first->Data;
 }
@@ -1537,7 +1537,8 @@ swift::swift_getFunctionTypeMetadataGlobalActor(
     const Metadata *result, const Metadata *globalActor) {
   assert(flags.hasGlobalActor());
   FunctionCacheEntry::Key key = {
-    flags, diffKind, parameters, parameterFlags, result, globalActor
+    flags, diffKind, parameters,
+    reinterpret_cast<const ParameterFlags *>(parameterFlags), result, globalActor
   };
   return &FunctionTypes.getOrInsert(key).first->Data;
 }
@@ -1595,7 +1596,7 @@ FunctionCacheEntry::FunctionCacheEntry(const Key &key) {
   for (unsigned i = 0; i < numParameters; ++i) {
     Data.getParameters()[i] = key.getParameter(i);
     if (flags.hasParameterFlags())
-      Data.getParameterFlags()[i] = key.getParameterFlags(i).getIntValue();
+      Data.getParameterFlags()[i] = key.getParameterFlags(i);
   }
 }