reduce size of Array!T from 32 to 16 bytes (#23404)

- allocates a maximum of uint.max entries
- overlaps single entry with pointer to array

Author: rainers

compiler/include/dmd/root/array.h

@@ -14,27 +14,32 @@
 template <typename TYPE>
 struct Array
 {
-    d_size_t length;
+    uint32_t length;
 
   private:
-    DArray<TYPE> data;
+    uint32_t allocated;
     #define SMALLARRAYCAP       1
-    TYPE smallarray[SMALLARRAYCAP];    // inline storage for small arrays
+    union
+    {
+        TYPE smallarray[SMALLARRAYCAP];    // inline storage for small arrays
+        TYPE* _ptr;
+    };
+    TYPE* data() { return allocated <= SMALLARRAYCAP ? smallarray : _ptr; }
+    const TYPE* data() const { return allocated <= SMALLARRAYCAP ? smallarray : _ptr; }
 
     Array(const Array&);
 
   public:
     Array()
     {
-        data.ptr = nullptr;
         length = 0;
-        data.length = 0;
+        allocated = SMALLARRAYCAP;
     }
 
     ~Array()
     {
-        if (data.ptr != &smallarray[0])
-            mem.xfree(data.ptr);
+        if (allocated > SMALLARRAYCAP)
+            mem.xfree(_ptr);
     }
 
     char *toChars() const
@@ -43,7 +48,7 @@ struct Array
         d_size_t len = 2;
         for (d_size_t u = 0; u < length; u++)
         {
-            buf[u] = ((TYPE)data.ptr[u])->toChars();
+            buf[u] = (data()[u])->toChars();
             len += strlen(buf[u]) + 1;
         }
         char *str = (char *)mem.xmalloc(len);
@@ -67,7 +72,7 @@ struct Array
     void push(TYPE ptr)
     {
         reserve(1);
-        data.ptr[length++] = ptr;
+        data()[length++] = ptr;
     }
 
     void append(Array *a)
@@ -77,67 +82,67 @@ struct Array
 
     void reserve(d_size_t nentries)
     {
-        //printf("Array::reserve: length = %d, data.length = %d, nentries = %d\n", (int)length, (int)data.length, (int)nentries);
-        if (data.length - length < nentries)
+        //printf("Array::reserve: length = %d, allocated = %d, nentries = %d\n", (int)length, (int)allocated, (int)nentries);
+        if (allocated - length < nentries)
         {
-            if (data.length == 0)
+            if (allocated == 0)
             {
                 // Not properly initialized, someone memset it to zero
                 if (nentries <= SMALLARRAYCAP)
                 {
-                    data.length = SMALLARRAYCAP;
-                    data.ptr = SMALLARRAYCAP ? &smallarray[0] : nullptr;
+                    allocated = SMALLARRAYCAP;
                 }
                 else
                 {
-                    data.length = nentries;
-                    data.ptr = (TYPE *)mem.xmalloc(data.length * sizeof(TYPE));
+                    allocated = nentries;
+                    _ptr = (TYPE *)mem.xmalloc(allocated * sizeof(TYPE));
                 }
             }
-            else if (data.length == SMALLARRAYCAP)
+            else if (allocated <= SMALLARRAYCAP)
             {
-                data.length = length + nentries;
-                data.ptr = (TYPE *)mem.xmalloc(data.length * sizeof(TYPE));
-                memcpy(data.ptr, &smallarray[0], length * sizeof(TYPE));
+                allocated = length + nentries;
+                TYPE* p = (TYPE *)mem.xmalloc(allocated * sizeof(TYPE));
+                memcpy(p, &smallarray[0], length * sizeof(TYPE));
+                _ptr = p;
             }
             else
             {
                 /* Increase size by 1.5x to avoid excessive memory fragmentation
                  */
-                d_size_t increment = length / 2;
+                auto increment = length / 2;
                 if (nentries > increment)       // if 1.5 is not enough
-                    increment = nentries;
-                data.length = length + increment;
-                data.ptr = (TYPE *)mem.xrealloc(data.ptr, data.length * sizeof(TYPE));
+                    increment = (uint32_t)nentries;
+                allocated = length + increment;
+                _ptr = (TYPE *)mem.xrealloc(_ptr, allocated * sizeof(TYPE));
             }
         }
     }
 
     void remove(d_size_t i)
     {
         if (length - i - 1)
-            memmove(data.ptr + i, data.ptr + i + 1, (length - i - 1) * sizeof(TYPE));
+            memmove(data() + i, data() + i + 1, (length - i - 1) * sizeof(TYPE));
         length--;
     }
 
     void insert(d_size_t index, Array *a)
     {
         if (a)
         {
-            d_size_t d = a->length;
+            auto d = a->length;
             reserve(d);
             if (length != index)
-                memmove(data.ptr + index + d, data.ptr + index, (length - index) * sizeof(TYPE));
-            memcpy(data.ptr + index, a->data.ptr, d * sizeof(TYPE));
+                memmove(data() + index + d, data() + index, (length - index) * sizeof(TYPE));
+            memcpy(data() + index, a->data(), d * sizeof(TYPE));
             length += d;
         }
     }
 
     void insert(d_size_t index, TYPE ptr)
     {
         reserve(1);
-        memmove(data.ptr + index + 1, data.ptr + index, (length - index) * sizeof(TYPE));
-        data.ptr[index] = ptr;
+        memmove(data() + index + 1, data() + index, (length - index) * sizeof(TYPE));
+        data()[index] = ptr;
         length++;
     }
 
@@ -154,7 +159,7 @@ struct Array
     {
         for (d_size_t i = 0; i < length; i++)
         {
-            if (data.ptr[i] == ptr)
+            if (data()[i] == ptr)
                 return i;
         }
         return SIZE_MAX;
@@ -170,37 +175,37 @@ struct Array
 #ifdef DEBUG
         assert(index < length);
 #endif
-        return data.ptr[index];
+        return data()[index];
     }
 
     TYPE *tdata()
     {
-        return data.ptr;
+        return data();
     }
 
     Array *copy()
     {
         Array *a = new Array();
         a->setDim(length);
-        memcpy(a->data.ptr, data.ptr, length * sizeof(TYPE));
+        memcpy(a->data(), data(), length * sizeof(TYPE));
         return a;
     }
 
     void shift(TYPE ptr)
     {
         reserve(1);
-        memmove(data.ptr + 1, data.ptr, length * sizeof(TYPE));
-        data.ptr[0] = ptr;
+        memmove(data() + 1, data(), length * sizeof(TYPE));
+        data()[0] = ptr;
         length++;
     }
 
     void zero()
     {
-        memset(data.ptr, 0, length * sizeof(TYPE));
+        memset(data(), 0, length * sizeof(TYPE));
     }
 
     TYPE pop()
     {
-        return data.ptr[--length];
+        return data()[--length];
     }
 };

compiler/src/dmd/dinterpret.d

@@ -6903,7 +6903,7 @@ private Expression interpret_aaDel(UnionExp* pue, InterState* istate, Expression
     AssocArrayLiteralExp aae = agg.isAssocArrayLiteralExp();
     Expressions* keysx = aae.keys;
     Expressions* valuesx = aae.values;
-    size_t removed = 0;
+    uint removed = 0;
     foreach (j, evalue; *valuesx)
     {
         Expression ekey = (*keysx)[j];

compiler/src/dmd/doc.d

@@ -5083,7 +5083,7 @@ void highlightCode(Scope* sc, Dsymbols* a, ref OutBuffer buf, size_t offset)
 
                 // build the template parameters
                 Array!(size_t) paramLens;
-                paramLens.reserve(td.parameters.length);
+                paramLens.setDim(td.parameters.length);
 
                 OutBuffer parametersBuf;
                 HdrGenState hgs;