Runtime: use SmallVector instead of std::vector to avoid memory allocations in most cases.

This dramatically reduces the number of needed malloc calls.
Unfortunately I had to add the implementation of SmallVectorBase::grow_pod to the runtime, as we don't link LLVM. This is a bad hack, but better than re-inventing a new SmallVector implementation.

SR-10028
rdar://problem/48575729

Author: eeckstein

include/swift/Demangling/TypeDecoder.h

@@ -315,7 +315,7 @@ class TypeDecoder {
       if (Node->getNumChildren() < 2)
         return BuiltType();
 
-      std::vector<BuiltType> args;
+      SmallVector<BuiltType, 8> args;
 
       const auto &genericArgs = Node->getChild(1);
       assert(genericArgs->getKind() == NodeKind::TypeList);
@@ -427,7 +427,7 @@ class TypeDecoder {
         return BuiltType();
 
       // Find the protocol list.
-      std::vector<BuiltProtocolDecl> Protocols;
+      SmallVector<BuiltProtocolDecl, 8> Protocols;
       auto TypeList = Node->getChild(0);
       if (TypeList->getKind() == NodeKind::ProtocolList &&
           TypeList->getNumChildren() >= 1) {
@@ -514,7 +514,7 @@ class TypeDecoder {
         return BuiltType();
 
       bool hasParamFlags = false;
-      std::vector<FunctionParam<BuiltType>> parameters;
+      SmallVector<FunctionParam<BuiltType>, 8> parameters;
       if (!decodeMangledFunctionInputType(Node->getChild(isThrow ? 1 : 0),
                                           parameters, hasParamFlags))
         return BuiltType();
@@ -531,9 +531,9 @@ class TypeDecoder {
     }
     case NodeKind::ImplFunctionType: {
       auto calleeConvention = ImplParameterConvention::Direct_Unowned;
-      std::vector<ImplFunctionParam<BuiltType>> parameters;
-      std::vector<ImplFunctionResult<BuiltType>> results;
-      std::vector<ImplFunctionResult<BuiltType>> errorResults;
+      SmallVector<ImplFunctionParam<BuiltType>, 8> parameters;
+      SmallVector<ImplFunctionResult<BuiltType>, 8> results;
+      SmallVector<ImplFunctionResult<BuiltType>, 8> errorResults;
       ImplFunctionTypeFlags flags;
 
       for (unsigned i = 0; i < Node->getNumChildren(); i++) {
@@ -611,7 +611,7 @@ class TypeDecoder {
       return decodeMangledType(Node->getChild(0));
 
     case NodeKind::Tuple: {
-      std::vector<BuiltType> elements;
+      SmallVector<BuiltType, 8> elements;
       std::string labels;
       bool variadic = false;
       for (auto &element : *Node) {
@@ -785,7 +785,7 @@ class TypeDecoder {
 private:
   template <typename T>
   bool decodeImplFunctionPart(Demangle::NodePointer node,
-                              std::vector<T> &results) {
+                              SmallVectorImpl<T> &results) {
     if (node->getNumChildren() != 2)
       return true;
 
@@ -871,7 +871,7 @@ class TypeDecoder {
 
   bool decodeMangledFunctionInputType(
       Demangle::NodePointer node,
-      std::vector<FunctionParam<BuiltType>> &params,
+      SmallVectorImpl<FunctionParam<BuiltType>> &params,
       bool &hasParamFlags) {
     // Look through a couple of sugar nodes.
     if (node->getKind() == NodeKind::Type ||

include/swift/Reflection/TypeRefBuilder.h

@@ -274,21 +274,21 @@ class TypeRefBuilder {
 
   const BoundGenericTypeRef *
   createBoundGenericType(const Optional<std::string> &mangledName,
-                         const std::vector<const TypeRef *> &args,
+                         ArrayRef<const TypeRef *> args,
                          const TypeRef *parent) {
     return BoundGenericTypeRef::create(*this, *mangledName, args, parent);
   }
 
   const TupleTypeRef *
-  createTupleType(const std::vector<const TypeRef *> &elements,
+  createTupleType(ArrayRef<const TypeRef *> elements,
                   std::string &&labels, bool isVariadic) {
     // FIXME: Add uniqueness checks in TupleTypeRef::Profile and
     // unittests/Reflection/TypeRef.cpp if using labels for identity.
     return TupleTypeRef::create(*this, elements, isVariadic);
   }
 
   const FunctionTypeRef *createFunctionType(
-      const std::vector<remote::FunctionParam<const TypeRef *>> &params,
+      ArrayRef<remote::FunctionParam<const TypeRef *>> params,
       const TypeRef *result, FunctionTypeFlags flags) {
     return FunctionTypeRef::create(*this, params, result, flags);
   }
@@ -406,7 +406,7 @@ class TypeRefBuilder {
 
   const ObjCClassTypeRef *
   createBoundGenericObjCClassType(const std::string &name,
-                                  std::vector<const TypeRef *> &args) {
+                                  ArrayRef<const TypeRef *> args) {
     // Remote reflection just ignores generic arguments for Objective-C
     // lightweight generic types, since they don't affect layout.
     return createObjCClassType(name);

stdlib/public/Reflection/CMakeLists.txt

@@ -3,6 +3,7 @@ set(swiftReflection_SOURCES
   TypeLowering.cpp
   TypeRef.cpp
   TypeRefBuilder.cpp
+  "${SWIFT_SOURCE_DIR}/stdlib/public/runtime/LLVMSupport.cpp"
   "${SWIFT_SOURCE_DIR}/lib/Demangling/Context.cpp"
   "${SWIFT_SOURCE_DIR}/lib/Demangling/OldDemangler.cpp"
   "${SWIFT_SOURCE_DIR}/lib/Demangling/Demangler.cpp"
@@ -21,7 +22,7 @@ endif(LLVM_ENABLE_ASSERTIONS)
 if(SWIFT_BUILD_STDLIB)
   add_swift_target_library(swiftReflection STATIC TARGET_LIBRARY
     ${swiftReflection_SOURCES}
-    C_COMPILE_FLAGS ${SWIFT_RUNTIME_CXX_FLAGS}
+    C_COMPILE_FLAGS ${SWIFT_RUNTIME_CXX_FLAGS} -DswiftCore_EXPORTS
     LINK_FLAGS ${SWIFT_RUNTIME_LINK_FLAGS}
     INSTALL_IN_COMPONENT dev)
 endif()

stdlib/public/runtime/Demangle.cpp

@@ -33,7 +33,7 @@ swift::_buildDemanglingForContext(const ContextDescriptor *context,
   NodePointer node = nullptr;
 
   // Walk up the context tree.
-  std::vector<const ContextDescriptor *> descriptorPath;
+  SmallVector<const ContextDescriptor *, 8> descriptorPath;
   {
     const ContextDescriptor *parent = context;
     while (parent) {
@@ -283,11 +283,11 @@ _buildDemanglingForNominalType(const Metadata *type, Demangle::Demangler &Dem) {
 
   // Gather the complete set of generic arguments that must be written to
   // form this type.
-  std::vector<const Metadata *> allGenericArgs;
+  SmallVector<const Metadata *, 8> allGenericArgs;
   gatherWrittenGenericArgs(type, description, allGenericArgs, Dem);
 
   // Demangle the generic arguments.
-  std::vector<NodePointer> demangledGenerics;
+  SmallVector<NodePointer, 8> demangledGenerics;
   for (auto genericArg : allGenericArgs) {
     // When there is no generic argument, put in a placeholder.
     if (!genericArg) {
@@ -468,7 +468,7 @@ swift::_swift_buildDemanglingForMetadata(const Metadata *type,
       break;
     }
 
-    std::vector<std::pair<NodePointer, bool>> inputs;
+    SmallVector<std::pair<NodePointer, bool>, 8> inputs;
     for (unsigned i = 0, e = func->getNumParameters(); i < e; ++i) {
       auto param = func->getParameter(i);
       auto flags = func->getParameterFlags(i);

stdlib/public/runtime/LLVMSupport.cpp

@@ -10,12 +10,15 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/ADT/SmallVector.h"
+
 // ADT uses report_bad_alloc_error to report an error when it can't allocate
 // elements for a data structure. The swift runtime uses ADT without linking
 // against libSupport, so here we provide a stub to make sure we don't fail
 // to link.
 #if defined(swiftCore_EXPORTS)
 namespace llvm {
+
 #if defined(_WIN32)
 extern void report_bad_alloc_error(const char *Reason, bool GenCrashDiag);
 void _report_bad_alloc_error(const char *Reason, bool GenCrashDiag) {}
@@ -28,6 +31,42 @@ void _report_bad_alloc_error(const char *Reason, bool GenCrashDiag) {}
 void __attribute__((__weak__, __visibility__("hidden")))
 report_bad_alloc_error(const char *Reason, bool GenCrashDiag) {}
 #endif
-} // end namespace llvm
+
+// The same for SmallVector: provide the grow_pod implementation (the only
+// SmallVector function which is not inlined) as we don't link LLVM.
+// TODO: This is a hack. This implementaiton is copied from LLVM and has to stay
+// in sync with it.
+
+/// grow_pod - This is an implementation of the grow() method which only works
+/// on POD-like datatypes and is out of line to reduce code duplication.
+void
+#if !defined(_WIN32)
+__attribute__((__weak__, __visibility__("hidden")))
 #endif
+llvm::SmallVectorBase::grow_pod(void *FirstEl, size_t MinCapacity,
+                                size_t TSize) {
+  // Ensure we can fit the new capacity in 32 bits.
+  if (MinCapacity > UINT32_MAX)
+    report_bad_alloc_error("SmallVector capacity overflow during allocation");
 
+  size_t NewCapacity = 2 * capacity() + 1; // Always grow.
+  NewCapacity =
+    std::min(std::max(NewCapacity, MinCapacity), size_t(UINT32_MAX));
+
+  void *NewElts;
+  if (BeginX == FirstEl) {
+    NewElts = safe_malloc(NewCapacity * TSize);
+
+    // Copy the elements over.  No need to run dtors on PODs.
+    memcpy(NewElts, this->BeginX, size() * TSize);
+  } else {
+    // If this wasn't grown from the inline copy, grow the allocated space.
+    NewElts = safe_realloc(this->BeginX, NewCapacity * TSize);
+  }
+
+  this->BeginX = NewElts;
+  this->Capacity = NewCapacity;
+}
+
+} // end namespace llvm
+#endif // defined(swiftCore_EXPORTS)

stdlib/public/runtime/MetadataLookup.cpp

@@ -821,7 +821,7 @@ Optional<unsigned> swift::_depthIndexToFlatIndex(
 /// \returns true if the innermost descriptor is generic.
 bool swift::_gatherGenericParameterCounts(
                                  const ContextDescriptor *descriptor,
-                                 std::vector<unsigned> &genericParamCounts,
+                                 SmallVectorImpl<unsigned> &genericParamCounts,
                                  Demangler &BorrowFrom) {
   // If we have an extension descriptor, extract the extended type and use
   // that.
@@ -1027,7 +1027,7 @@ class DecodedMetadataBuilder {
 
     // Figure out the various levels of generic parameters we have in
     // this type.
-    std::vector<unsigned> genericParamCounts;
+    SmallVector<unsigned, 8> genericParamCounts;
     (void)_gatherGenericParameterCounts(typeDecl, genericParamCounts, demangler);
     unsigned numTotalGenericParams =
         genericParamCounts.empty() ? 0 : genericParamCounts.back();
@@ -1041,13 +1041,13 @@ class DecodedMetadataBuilder {
       return BuiltType();
     }
 
-    std::vector<const void *> allGenericArgsVec;
+    SmallVector<const void *, 8> allGenericArgsVec;
 
     // If there are generic parameters at any level, check the generic
     // requirements and fill in the generic arguments vector.
     if (!genericParamCounts.empty()) {
       // Compute the set of generic arguments "as written".
-      std::vector<const Metadata *> allGenericArgs;
+      SmallVector<const Metadata *, 8> allGenericArgs;
 
       // If we have a parent, gather it's generic arguments "as written".
       if (parent) {
@@ -1159,8 +1159,8 @@ class DecodedMetadataBuilder {
   BuiltType createFunctionType(
                            ArrayRef<Demangle::FunctionParam<BuiltType>> params,
                            BuiltType result, FunctionTypeFlags flags) const {
-    std::vector<BuiltType> paramTypes;
-    std::vector<uint32_t> paramFlags;
+    SmallVector<BuiltType, 8> paramTypes;
+    SmallVector<uint32_t, 8> paramFlags;
 
     // Fill in the parameters.
     paramTypes.reserve(params.size());
@@ -1625,7 +1625,7 @@ demangleToGenericParamRef(StringRef typeName) {
 void swift::gatherWrittenGenericArgs(
                              const Metadata *metadata,
                              const TypeContextDescriptor *description,
-                             std::vector<const Metadata *> &allGenericArgs,
+                             SmallVectorImpl<const Metadata *> &allGenericArgs,
                              Demangler &BorrowFrom) {
   auto generics = description->getGenericContext();
   if (!generics)
@@ -1679,7 +1679,7 @@ void swift::gatherWrittenGenericArgs(
   // canonicalized away. Use same-type requirements to reconstitute them.
 
   // Retrieve the mapping information needed for depth/index -> flat index.
-  std::vector<unsigned> genericParamCounts;
+  SmallVector<unsigned, 8> genericParamCounts;
   (void)_gatherGenericParameterCounts(description, genericParamCounts,
                                       BorrowFrom);
 

stdlib/public/runtime/Private.h

@@ -278,7 +278,7 @@ class TypeInfo {
 
     /// Information about the generic context descriptors that make up \c
     /// descriptor, from the outermost to the innermost.
-    mutable std::vector<PathElement> descriptorPath;
+    mutable llvm::SmallVector<PathElement, 8> descriptorPath;
 
     /// The number of key generic parameters.
     mutable unsigned numKeyGenericParameters = 0;
@@ -356,10 +356,10 @@ class TypeInfo {
   /// Use with \c _getTypeByMangledName to decode potentially-generic types.
   class SWIFT_RUNTIME_LIBRARY_VISIBILITY SubstGenericParametersFromWrittenArgs {
     /// The complete set of generic arguments.
-    const std::vector<const Metadata *> &allGenericArgs;
+    const SmallVectorImpl<const Metadata *> &allGenericArgs;
 
     /// The counts of generic parameters at each level.
-    const std::vector<unsigned> &genericParamCounts;
+    const SmallVectorImpl<unsigned> &genericParamCounts;
 
   public:
     /// Initialize a new function object to handle substitutions. Both
@@ -373,8 +373,8 @@ class TypeInfo {
     /// \param genericParamCounts The count of generic parameters at each
     /// generic level, typically gathered by _gatherGenericParameterCounts.
     explicit SubstGenericParametersFromWrittenArgs(
-        const std::vector<const Metadata *> &allGenericArgs,
-        const std::vector<unsigned> &genericParamCounts)
+        const SmallVectorImpl<const Metadata *> &allGenericArgs,
+        const SmallVectorImpl<unsigned> &genericParamCounts)
       : allGenericArgs(allGenericArgs), genericParamCounts(genericParamCounts) {
     }
 
@@ -386,7 +386,7 @@ class TypeInfo {
   ///
   /// \returns true if the innermost descriptor is generic.
   bool _gatherGenericParameterCounts(const ContextDescriptor *descriptor,
-                                     std::vector<unsigned> &genericParamCounts,
+                                     llvm::SmallVectorImpl<unsigned> &genericParamCounts,
                                      Demangler &BorrowFrom);
 
   /// Map depth/index to a flat index.
@@ -407,7 +407,7 @@ class TypeInfo {
   /// \returns true if an error occurred, false otherwise.
   bool _checkGenericRequirements(
                     llvm::ArrayRef<GenericRequirementDescriptor> requirements,
-                    std::vector<const void *> &extraArguments,
+                    llvm::SmallVectorImpl<const void *> &extraArguments,
                     SubstGenericParameterFn substGenericParam,
                     SubstDependentWitnessTableFn substWitnessTable);
 
@@ -452,7 +452,7 @@ class TypeInfo {
   /// \endcode
   void gatherWrittenGenericArgs(const Metadata *metadata,
                                 const TypeContextDescriptor *description,
-                                std::vector<const Metadata *> &allGenericArgs,
+                                llvm::SmallVectorImpl<const Metadata *> &allGenericArgs,
                                 Demangler &BorrowFrom);
 
   Demangle::NodePointer

stdlib/public/runtime/ProtocolConformance.cpp

@@ -162,7 +162,7 @@ template<>
 const WitnessTable *
 ProtocolConformanceDescriptor::getWitnessTable(const Metadata *type) const {
   // If needed, check the conditional requirements.
-  std::vector<const void *> conditionalArgs;
+  SmallVector<const void *, 8> conditionalArgs;
   if (hasConditionalRequirements()) {
     SubstGenericParametersFromMetadata substitutions(type);
     bool failed =
@@ -626,7 +626,7 @@ swift::_searchConformancesByMangledTypeName(Demangle::NodePointer node) {
 
 bool swift::_checkGenericRequirements(
                       llvm::ArrayRef<GenericRequirementDescriptor> requirements,
-                      std::vector<const void *> &extraArguments,
+                      SmallVectorImpl<const void *> &extraArguments,
                       SubstGenericParameterFn substGenericParam,
                       SubstDependentWitnessTableFn substWitnessTable) {
   for (const auto &req : requirements) {