[scudo] Make Vector() constexpr

[cryptoad]

Summary

A Vector that doesn't require an initial reserve() (eg: with a
default, or small enough capacity) can have a constant initializer.

This changes the code in a few places to make that possible:

• mark a few other functions as constexpr
• do without any reinterpret_cast
• allow to skip reserve from init

compiler-rt/lib/scudo/standalone/vector.h

 #include <string.h>
 
 namespace scudo {
 
 // A low-level vector based on map. May incur a significant memory overhead for
 // small vectors. The current implementation supports only POD types.
 template <typename T> class VectorNoCtor {
 public:
-  void init(uptr InitialCapacity = 0) {
-    Data = reinterpret_cast<T *>(&LocalData[0]);
+  constexpr void init(uptr InitialCapacity = 0) {
+    Data = &LocalData[0];
     CapacityBytes = sizeof(LocalData);
+    if (InitialCapacity > capacity())
       reserve(InitialCapacity);
   }
   void destroy() {
-    if (Data != reinterpret_cast<T *>(&LocalData[0]))
+    if (Data != &LocalData[0])
       unmap(Data, CapacityBytes);
   }
   T &operator[](uptr I) {
     DCHECK_LT(I, Size);
     return Data[I];
   }
   const T &operator[](uptr I) const {
     DCHECK_LT(I, Size);
public:
   }
   void pop_back() {
     DCHECK_GT(Size, 0);
     Size--;
   }
   uptr size() const { return Size; }
   const T *data() const { return Data; }
   T *data() { return Data; }
-  uptr capacity() const { return CapacityBytes / sizeof(T); }
+  constexpr uptr capacity() const { return CapacityBytes / sizeof(T); }
   void reserve(uptr NewSize) {
     // Never downsize internal buffer.
     if (NewSize > capacity())
       reallocate(NewSize);
   }
   void resize(uptr NewSize) {
     if (NewSize > Size) {
       reserve(NewSize);
T *NewData =
         reinterpret_cast<T *>(map(nullptr, NewCapacity, "scudo:vector"));
     memcpy(NewData, Data, Size * sizeof(T));
     destroy();
     Data = NewData;
     CapacityBytes = NewCapacity;
   }
 
   T *Data = nullptr;
-  u8 LocalData[256] = {};
+  T LocalData[256 / sizeof(T)] = {};
   uptr CapacityBytes = 0;
   uptr Size = 0;
 };
 
 template <typename T> class Vector : public VectorNoCtor<T> {
 public:
-  Vector() { VectorNoCtor<T>::init(); }
+  constexpr Vector() { VectorNoCtor<T>::init(); }
   explicit Vector(uptr Count) {
     VectorNoCtor<T>::init(Count);
     this->resize(Count);
   }
   ~Vector() { VectorNoCtor<T>::destroy(); }
   // Disallow copies and moves.
   Vector(const Vector &) = delete;
   Vector &operator=(const Vector &) = delete;
   Vector(Vector &&) = delete;
   Vector &operator=(Vector &&) = delete;
 };
 
 } // namespace scudo
 
 #endif // SCUDO_VECTOR_H_