Add a dumper/verifier for OpaqueExistentialContainers (i.e. Any) in c++.

The dumper method dumps:

1. The container's metadata pointer.
2. A pointer to the container's value.
3. Whether or not said value is stored inline in the container.

This provides a general overview that can be used even when working with SIL
code in the debugger by grabbing a pointer to swift Anys and then calling the
c++ any method upon them.

The verifier is intended to be used in conjunction with ASAN for maximum
effect to catch use-after-frees of existential boxes.

While implementing this I refactored some code from ExistentialTypeMetadata into
methods on OpaqueExistentialContainer. ExistentialTypeMetadata just calls these
methods now instead of implementing the code inline.

Author: gottesmm

include/swift/Runtime/ExistentialContainer.h

@@ -0,0 +1,102 @@
+//===--- ExistentialContainer.h -------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2018 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_RUNTIME_EXISTENTIALCONTAINER_H
+#define SWIFT_RUNTIME_EXISTENTIALCONTAINER_H
+
+#include "swift/Runtime/Metadata.h"
+
+namespace swift {
+
+/// The basic layout of an opaque (non-class-bounded) existential type.
+template <typename Runtime>
+struct TargetOpaqueExistentialContainer {
+  ValueBuffer Buffer;
+  const TargetMetadata<Runtime> *Type;
+  // const void *WitnessTables[];
+
+  const TargetWitnessTable<Runtime> **getWitnessTables() {
+    return reinterpret_cast<const TargetWitnessTable<Runtime> **>(this + 1);
+  }
+
+  const TargetWitnessTable<Runtime> *const *getWitnessTables() const {
+    return reinterpret_cast<const TargetWitnessTable<Runtime> *const *>(this +
+                                                                        1);
+  }
+
+  void copyTypeInto(swift::TargetOpaqueExistentialContainer<Runtime> *dest,
+                    unsigned numTables) const {
+    dest->Type = Type;
+    for (unsigned i = 0; i != numTables; ++i)
+      dest->getWitnessTables()[i] = getWitnessTables()[i];
+  }
+
+  /// Return true if this opaque existential container contains a value that is
+  /// stored inline in the container. Returns false if the value is stored out
+  /// of line.
+  bool isValueInline() const;
+
+  /// Project out a pointer to the value stored in the container.
+  ///
+  /// *NOTE* If the container contains the value inline, then this will return a
+  /// pointer inside the container itself. Otherwise, it will return a pointer
+  /// to out of line memory.
+  const OpaqueValue *projectValue() const;
+
+  /// Cleans up an existential container instance whose value is uninitialized.
+  void deinit();
+
+#ifndef NDEBUG
+  /// Verify invariants of the container.
+  ///
+  /// We verify that:
+  ///
+  /// 1. The container itself is in live memory.
+  /// 2. If we have an out of line value, that the value is in live memory.
+  ///
+  /// The intention is that this is used in combination with ASAN or Guard
+  /// Malloc to catch use-after-frees.
+  void verify() const LLVM_ATTRIBUTE_USED;
+
+  /// Dump information about this specific box and its contents. Only intended
+  /// for use in the debugger.
+  LLVM_ATTRIBUTE_DEPRECATED(void dump() const LLVM_ATTRIBUTE_USED,
+                            "Only meant for use in the debugger");
+#endif
+};
+using OpaqueExistentialContainer = TargetOpaqueExistentialContainer<InProcess>;
+
+/// The basic layout of a class-bounded existential type.
+template <typename ContainedValue>
+struct ClassExistentialContainerImpl {
+  ContainedValue Value;
+
+  const WitnessTable **getWitnessTables() {
+    return reinterpret_cast<const WitnessTable **>(this + 1);
+  }
+  const WitnessTable *const *getWitnessTables() const {
+    return reinterpret_cast<const WitnessTable *const *>(this + 1);
+  }
+
+  void copyTypeInto(ClassExistentialContainerImpl *dest,
+                    unsigned numTables) const {
+    for (unsigned i = 0; i != numTables; ++i)
+      dest->getWitnessTables()[i] = getWitnessTables()[i];
+  }
+};
+using ClassExistentialContainer = ClassExistentialContainerImpl<void *>;
+using WeakClassExistentialContainer =
+    ClassExistentialContainerImpl<WeakReference>;
+
+} // end swift namespace
+
+#endif

include/swift/Runtime/Metadata.h

@@ -1895,54 +1895,6 @@ struct TargetWitnessTable {
 
 using WitnessTable = TargetWitnessTable<InProcess>;
 
-/// The basic layout of an opaque (non-class-bounded) existential type.
-template <typename Runtime>
-struct TargetOpaqueExistentialContainer {
-  ValueBuffer Buffer;
-  const TargetMetadata<Runtime> *Type;
-  // const void *WitnessTables[];
-
-  const TargetWitnessTable<Runtime> **getWitnessTables() {
-    return reinterpret_cast<const TargetWitnessTable<Runtime> **>(this + 1);
-  }
-
-  const TargetWitnessTable<Runtime> * const *getWitnessTables() const {
-    return reinterpret_cast<const TargetWitnessTable<Runtime> * const *>(
-                                                                      this + 1);
-  }
-
-  void copyTypeInto(swift::TargetOpaqueExistentialContainer<Runtime> *dest,
-                    unsigned numTables) const {
-    dest->Type = Type;
-    for (unsigned i = 0; i != numTables; ++i)
-      dest->getWitnessTables()[i] = getWitnessTables()[i];
-  }
-};
-using OpaqueExistentialContainer
-  = TargetOpaqueExistentialContainer<InProcess>;
-
-/// The basic layout of a class-bounded existential type.
-template <typename ContainedValue>
-struct ClassExistentialContainerImpl {
-  ContainedValue Value;
-
-  const WitnessTable **getWitnessTables() {
-    return reinterpret_cast<const WitnessTable**>(this + 1);
-  }
-  const WitnessTable * const *getWitnessTables() const {
-    return reinterpret_cast<const WitnessTable* const *>(this + 1);
-  }
-
-  void copyTypeInto(ClassExistentialContainerImpl *dest,
-                    unsigned numTables) const {
-    for (unsigned i = 0; i != numTables; ++i)
-      dest->getWitnessTables()[i] = getWitnessTables()[i];
-  }
-};
-using ClassExistentialContainer = ClassExistentialContainerImpl<void *>;
-using WeakClassExistentialContainer =
-  ClassExistentialContainerImpl<WeakReference>;
-
 /// The possible physical representations of existential types.
 enum class ExistentialTypeRepresentation {
   /// The type uses an opaque existential representation.
@@ -1985,6 +1937,7 @@ struct TargetExistentialTypeMetadata : public TargetMetadata<Runtime> {
   OpaqueValue *projectValue(OpaqueValue *container) const {
     return const_cast<OpaqueValue *>(projectValue((const OpaqueValue*)container));
   }
+
   /// Get the dynamic type from an existential container of the type described
   /// by this metadata.
   const TargetMetadata<Runtime> *

include/swift/Runtime/Reflection.h

@@ -14,6 +14,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "swift/Runtime/ExistentialContainer.h"
 #include "swift/Runtime/Metadata.h"
 #include <cstdlib>
 

stdlib/public/runtime/CMakeLists.txt

@@ -48,6 +48,7 @@ set(swift_runtime_sources
     Errors.cpp
     ErrorDefaultImpls.cpp
     Exclusivity.cpp
+    ExistentialContainer.cpp
     Heap.cpp
     HeapObject.cpp
     ImageInspectionMachO.cpp

stdlib/public/runtime/Casting.cpp

@@ -14,26 +14,27 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "swift/Runtime/Casting.h"
+#include "../SwiftShims/RuntimeShims.h"
+#include "ErrorObject.h"
+#include "ExistentialMetadataImpl.h"
+#include "Private.h"
+#include "SwiftHashableSupport.h"
+#include "stddef.h"
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/Lazy.h"
 #include "swift/Demangling/Demangler.h"
-#include "swift/Runtime/Casting.h"
 #include "swift/Runtime/Config.h"
+#include "swift/Runtime/Debug.h"
 #include "swift/Runtime/Enum.h"
+#include "swift/Runtime/ExistentialContainer.h"
 #include "swift/Runtime/HeapObject.h"
 #include "swift/Runtime/Metadata.h"
 #include "swift/Runtime/Mutex.h"
 #include "swift/Runtime/Unreachable.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/PointerIntPair.h"
 #include "llvm/Support/Compiler.h"
-#include "swift/Runtime/Debug.h"
-#include "ErrorObject.h"
-#include "ExistentialMetadataImpl.h"
-#include "Private.h"
-#include "SwiftHashableSupport.h"
-#include "../SwiftShims/RuntimeShims.h"
-#include "stddef.h"
 #if SWIFT_OBJC_INTEROP
 #include "swift/Runtime/ObjCBridge.h"
 #include "SwiftValue.h"

stdlib/public/runtime/ExistentialContainer.cpp

@@ -0,0 +1,83 @@
+//===--- ExistentialContainer.cpp -----------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2018 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#include "swift/Runtime/ExistentialContainer.h"
+#include "swift/Runtime/HeapObject.h"
+
+using namespace swift;
+
+//===----------------------------------------------------------------------===//
+//                 OpaqueExistentialContainer Implementation
+//===----------------------------------------------------------------------===//
+
+template <>
+bool OpaqueExistentialContainer::isValueInline() const {
+  return Type->getValueWitnesses()->isValueInline();
+}
+
+template <>
+const OpaqueValue *OpaqueExistentialContainer::projectValue() const {
+  auto *vwt = Type->getValueWitnesses();
+
+  if (vwt->isValueInline())
+    return reinterpret_cast<const OpaqueValue *>(&Buffer);
+
+  // Compute the byte offset of the object in the box.
+  unsigned alignMask = vwt->getAlignmentMask();
+  unsigned byteOffset = (sizeof(HeapObject) + alignMask) & ~alignMask;
+  auto *bytePtr = reinterpret_cast<const char *>(
+      *reinterpret_cast<HeapObject *const *const>(&Buffer));
+  return reinterpret_cast<const OpaqueValue *>(bytePtr + byteOffset);
+}
+
+template <>
+void OpaqueExistentialContainer::deinit() {
+  auto *vwt = Type->getValueWitnesses();
+  if (vwt->isValueInline()) {
+    return;
+  }
+
+  unsigned alignMask = vwt->getAlignmentMask();
+  unsigned size = vwt->size;
+  swift_deallocObject(*reinterpret_cast<HeapObject **>(&Buffer), size,
+                      alignMask);
+}
+
+#ifndef NDEBUG
+
+// *NOTE* This routine performs unused memory reads on purpose to try to catch
+// use-after-frees in conjunction with ASAN or Guard Malloc.
+template <>
+void OpaqueExistentialContainer::verify() const {
+  // We do not actually care about value. We just want to see if the
+  // memory is valid or not. So convert to a uint8_t and try to
+  // memcpy into firstByte. We use volatile to just ensure that this
+  // does not get dead code eliminated.
+  uint8_t firstByte;
+  memcpy(&firstByte, projectValue(), 1);
+  volatile uint8_t firstVolatileByte = firstByte;
+  (void)firstVolatileByte;
+}
+
+/// Dump information about this specific container and its contents.
+template <>
+void OpaqueExistentialContainer::dump() const {
+  // Quickly verify to make sure we are well formed.
+  verify();
+
+  printf("TargetOpaqueExistentialContainer.\n");
+  printf("Metadata Pointer: %p.\n", Type);
+  printf("Value Pointer: %p.\n", projectValue());
+  printf("Is Value Stored Inline: %s.\n", isValueInline() ? "true" : "false");
+}
+
+#endif

stdlib/public/runtime/ExistentialMetadataImpl.h

@@ -19,6 +19,7 @@
 #define SWIFT_RUNTIME_EXISTENTIALMETADATAIMPL_H
 
 #include "MetadataImpl.h"
+#include "swift/Runtime/ExistentialContainer.h"
 
 namespace swift {
 namespace metadataimpl {

stdlib/public/runtime/Metadata.cpp

@@ -21,6 +21,7 @@
 #include "swift/Basic/Range.h"
 #include "swift/Demangling/Demangler.h"
 #include "swift/Runtime/Casting.h"
+#include "swift/Runtime/ExistentialContainer.h"
 #include "swift/Runtime/HeapObject.h"
 #include "swift/Runtime/Mutex.h"
 #include "swift/Strings.h"
@@ -2240,15 +2241,12 @@ ExistentialTypeMetadata::mayTakeValue(const OpaqueValue *container) const {
   case ExistentialTypeRepresentation::Class:
     return true;
   // Opaque existential containers uniquely own their contained value.
-  case ExistentialTypeRepresentation::Opaque:
-  {
+  case ExistentialTypeRepresentation::Opaque: {
     // We can't take from a shared existential box without checking uniqueness.
     auto *opaque =
         reinterpret_cast<const OpaqueExistentialContainer *>(container);
-    auto *vwt = opaque->Type->getValueWitnesses();
-    return vwt->isValueInline();
+    return opaque->isValueInline();
   }
-    
   // References to boxed existential containers may be shared.
   case ExistentialTypeRepresentation::Error: {
     // We can only take the value if the box is a bridged NSError, in which case
@@ -2275,13 +2273,7 @@ const {
 
   case ExistentialTypeRepresentation::Opaque: {
     auto *opaque = reinterpret_cast<OpaqueExistentialContainer *>(container);
-    auto *vwt = opaque->Type->getValueWitnesses();
-    if (!vwt->isValueInline()) {
-      unsigned alignMask = vwt->getAlignmentMask();
-      unsigned size = vwt->size;
-      swift_deallocObject(*reinterpret_cast<HeapObject **>(&opaque->Buffer),
-                          size, alignMask);
-    }
+    opaque->deinit();
     break;
   }
 
@@ -2303,18 +2295,7 @@ ExistentialTypeMetadata::projectValue(const OpaqueValue *container) const {
   case ExistentialTypeRepresentation::Opaque: {
     auto *opaqueContainer =
       reinterpret_cast<const OpaqueExistentialContainer*>(container);
-    auto *type = opaqueContainer->Type;
-    auto *vwt = type->getValueWitnesses();
-
-    if (vwt->isValueInline())
-      return reinterpret_cast<const OpaqueValue *>(&opaqueContainer->Buffer);
-
-    unsigned alignMask = vwt->getAlignmentMask();
-    // Compute the byte offset of the object in the box.
-    unsigned byteOffset = (sizeof(HeapObject) + alignMask) & ~alignMask;
-    auto *bytePtr = reinterpret_cast<const char *>(
-        *reinterpret_cast<HeapObject *const *const>(&opaqueContainer->Buffer));
-    return reinterpret_cast<const OpaqueValue *>(bytePtr + byteOffset);
+    return opaqueContainer->projectValue();
   }
   case ExistentialTypeRepresentation::Error: {
     const SwiftError *errorBox