Checkpoint

Author: tbkka

include/swift/ABI/Metadata.h

@@ -1562,7 +1562,7 @@ struct TargetEnumMetadata : public TargetValueMetadata<Runtime> {
   using StoredSize = typename Runtime::StoredSize;
   using TargetValueMetadata<Runtime>::TargetValueMetadata;
 
-  const TargetEnumDescriptor<Runtime> *getDescription() const {
+  const swift::TargetEnumDescriptor<Runtime> *getDescription() const {
     return llvm::cast<TargetEnumDescriptor<Runtime>>(this->Description);
   }
 
@@ -1617,6 +1617,14 @@ struct TargetEnumMetadata : public TargetValueMetadata<Runtime> {
     return trailingFlags->isCanonicalStaticSpecialization();
   }
 
+  bool hasSpareBits() const {
+    return getDescription()->hasSpareBits();
+  }
+
+  size_t getEnumSpareBits() const {
+    return getDescription()->getEnumSpareBits();
+  }
+
   const MetadataTrailingFlags *getTrailingFlags() const {
     auto description = getDescription();
     auto flags = description->getFullGenericContextHeader()
@@ -4821,8 +4829,9 @@ class TargetEnumDescriptor final
   size_t getEnumSpareBits() const {
     assert(hasSpareBits());
     auto header = *this->template getTrailingObjects<EnumSpareBitsHeader>();
-    size_t length = header.bytes;
-    EnumSpareBitsChunk *chunks = this->template getTrailingObjects<EnumSpareBitsChunk>();
+    size_t length = header.bytesCount;
+//    EnumSpareBitsChunk *chunks = this->template getTrailingObjects<EnumSpareBitsChunk>();
+    auto chunks = this->template getTrailingObjects<EnumSpareBitsChunk>();
     // TODO: Convert mask data into some sort of SpareBits object
 
     return length;

include/swift/ABI/MetadataValues.h

@@ -1458,7 +1458,11 @@ class TypeContextDescriptorFlags : public FlagSet<uint16_t> {
     Class_HasVTable = 15,
 
     /// Set if the context descriptor includes a spare bit mask
-    Enum_HasSpareBits = 9
+    Enum_HasSpareBits = 9,
+
+    /// Set if this is a "simple" Multi-payload enum that uses
+    /// a trailing tag to discriminate cases (no XIs or spare bits)
+    Enum_SimpleMPE = 10
   };
 
 public:
@@ -1529,6 +1533,9 @@ class TypeContextDescriptorFlags : public FlagSet<uint16_t> {
   FLAGSET_DEFINE_FLAG_ACCESSORS(Enum_HasSpareBits,
                                 enum_hasSpareBits,
                                 enum_setHasSpareBits)
+  FLAGSET_DEFINE_FLAG_ACCESSORS(Enum_SimpleMPE,
+                                enum_simpleMPE,
+                                enum_setSimpleMPE)
 };
 
 /// Extra flags for resilient classes, since we need more than 16 bits of

include/swift/Remote/MetadataReader.h

@@ -32,7 +32,7 @@
 
 #include <vector>
 #include <unordered_map>
-
+#include <iostream>
 #include <inttypes.h>
 
 namespace swift {
@@ -781,9 +781,17 @@ class MetadataReader {
     case MetadataKind::Class:
       return readNominalTypeFromClassMetadata(Meta, skipArtificialSubclasses);
     case MetadataKind::Struct:
-    case MetadataKind::Enum:
     case MetadataKind::Optional:
       return readNominalTypeFromMetadata(Meta);
+    case MetadataKind::Enum: {
+      auto d = readNominalTypeFromMetadata(Meta);
+      auto enumMeta = cast<TargetEnumMetadata<Runtime>>(Meta);
+//      auto hasSpareBits = enumMeta->hasSpareBits();
+      //     auto spareBitsLength = enumMeta->getEnumSpareBits();
+      // 
+      //
+      return d;
+    }
     case MetadataKind::Tuple: {
       auto tupleMeta = cast<TargetTupleTypeMetadata<Runtime>>(Meta);
 
@@ -1020,24 +1028,36 @@ class MetadataReader {
     auto buffer = (uint8_t *)nullptr;
     unsigned available = 0; // Size of data in buffer
 
-    // In the first read, just grab the initial flag value...
-    unsigned sizeEstimate = sizeof(ContextDescriptorFlags);
+    // We get a big perf win by reading more data initially,
+    // but we don't want to overrun a page.  Here's a conservative
+    // guess of how much space is left in the page.
+    unsigned long spaceInPage = 256UL - (address & 0xff);
+
+    // TODO: Some clients (`heap`) map an entire VM region; for
+    // those clients, it would be best to just tell them the
+    // starting remote address and have them tell us the local
+    // address and number of available bytes.  That would always
+    // obtain the entire descriptor with a single `readBytes` call.
+
+    // Initial read:  At least enough to get all the flags.  More if we can.
+    unsigned sizeEstimate = std::max(sizeof(ContextDescriptorFlags), spaceInPage);
     while (available < sizeEstimate) {
       // The first `available` bytes have already been read, so grow
-      // the buffer and read more bytes to fulfill `sizeEstimate`
-      auto newbuffer = (uint8_t *)realloc(buffer, sizeEstimate);
+      // the buffer and read at least enough bytes to fulfill `sizeEstimate`
+      auto newSize = sizeEstimate;
+      auto newbuffer = (uint8_t *)realloc(buffer, newSize);
       if (!newbuffer) {
         free(buffer);
         return nullptr;
       }
       buffer = newbuffer;
       if (!Reader->readBytes(RemoteAddress(address + available),
                              buffer + available,
-                             sizeEstimate - available)) {
+                             newSize - available)) {
         free(buffer);
         return nullptr;
       }
-      available = sizeEstimate;
+      available = newSize;
 
       // Based on the data so far, update our guess of the full descriptor size.
 
@@ -1053,7 +1073,7 @@ class MetadataReader {
         break;
 
       // For types that use trailing objects, ask the trailing object logic to
-      // look at what we have so far and tell us whether we're done or not.
+      // estimate the total size based on what we have so far.
       case ContextDescriptorKind::Extension: {
         sizeEstimate = TargetExtensionContextDescriptor<Runtime>::totalSizeOfPartialObject(buffer, available);
         break;
@@ -1085,13 +1105,26 @@ class MetadataReader {
 
       // We don't know about this kind of context.
       default:
+        free(buffer);
         return nullptr;
       }
     }
 
     // After exiting loop above, `sizeEstimate` is the true size of the
-    // descriptor with all trailing objects and buffer holds at least that much
-    // data.
+    // descriptor with all trailing objects and buffer holds `available` bytes
+    // (which is at least as large as `sizeEstimate`)
+
+    // If we're significantly over-allocated, copy to a more
+    // appropriately-sized buffer.
+    if (sizeEstimate < (available - available / 4)) {
+      auto newbuffer = (uint8_t *)malloc(sizeEstimate);
+      if (newbuffer != nullptr) {
+        memcpy(newbuffer, buffer, sizeEstimate);
+        free(buffer);
+        buffer = newbuffer;
+        available = sizeEstimate;
+      }
+    }
 
     // Insert the final object into the descriptor cache and return it
     OwnedContextDescriptorRef readResult(buffer);

lib/IRGen/GenMeta.cpp

@@ -1518,7 +1518,7 @@ namespace {
 
     bool needsSpareBitMask() const {
       // TODO: Fix this
-      return false;
+      return true;
     }
 
 
@@ -1599,6 +1599,8 @@ namespace {
     void maybeAddSpareBitMask() {
       if (needsSpareBitMask()) {
         // TODO: Add spare bit mask data
+	B.addInt32(4); // Number of bytes in mask
+	B.addInt32(0x11223300); // First 32 bits of mask
       }
     }
   };
@@ -4834,6 +4836,7 @@ namespace {
       if (hasTrailingFlags()) {
         init.addInt64(0);
       }
+      // TODO: Add spare bits if appropriate
       Size structSize = init.getNextOffsetFromGlobal();
 
       auto global = init.finishAndCreateGlobal("", IGM.getPointerAlignment(),