[common] vector: eliminate double allocation when possible

This commit creates two constructor/destructor pairs for vector:
* vector_alloc/vector_free dynamically allocates the vector itself
* vector_create/vector_destroy uses existing Vector objects

common/include/common/vector.h

@@ -31,9 +31,14 @@ typedef struct Vector
 }
 Vector;
 
-Vector * vector_create(size_t itemSize, size_t capacity);
+// Dynamically allocates the vector
+Vector * vector_alloc(size_t itemSize, size_t capacity);
 void vector_free(Vector * vector);
 
+// Uses existing vector, but dynamically allocates storage
+bool vector_create(Vector * vector, size_t itemSize, size_t capacity);
+void vector_destroy(Vector * vector);
+
 inline static size_t vector_size(Vector * vector)
 {
   return vector->size;

common/src/platform/windows/ivshmem.c

@@ -79,13 +79,13 @@ bool ivshmemInit(struct IVSHMEM * dev)
   PSP_DEVICE_INTERFACE_DETAIL_DATA infData = NULL;
   SP_DEVINFO_DATA                  devInfoData = {0};
   SP_DEVICE_INTERFACE_DATA         devInterfaceData = {0};
+  Vector                           devices;
 
   devInfoSet = SetupDiGetClassDevs(&GUID_DEVINTERFACE_IVSHMEM, NULL, NULL, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
   devInfoData.cbSize      = sizeof(SP_DEVINFO_DATA);
   devInterfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
 
-  Vector * devices = vector_create(sizeof(struct IVSHMEMData), 1);
-  if (!devices)
+  if (!vector_create(&devices, sizeof(struct IVSHMEMData), 1))
   {
     DEBUG_ERROR("Failed to allocate memory");
     return false;
@@ -93,7 +93,7 @@ bool ivshmemInit(struct IVSHMEM * dev)
 
   for (int i = 0; SetupDiEnumDeviceInfo(devInfoSet, i, &devInfoData); ++i)
   {
-    struct IVSHMEMData * device = vector_push(devices, NULL);
+    struct IVSHMEMData * device = vector_push(&devices, NULL);
 
     DWORD bus, addr;
     if (!SetupDiGetDeviceRegistryProperty(devInfoSet, &devInfoData, SPDRP_BUSNUMBER,
@@ -121,10 +121,10 @@ bool ivshmemInit(struct IVSHMEM * dev)
   }
 
   const int shmDevice = option_get_int("os", "shmDevice");
-  qsort(vector_data(devices), vector_size(devices), sizeof(struct IVSHMEMData), ivshmemComparator);
+  qsort(vector_data(&devices), vector_size(&devices), sizeof(struct IVSHMEMData), ivshmemComparator);
 
   struct IVSHMEMData * device;
-  vector_forEachRefIdx(i, device, devices)
+  vector_forEachRefIdx(i, device, &devices)
   {
     DWORD bus = device->busAddr >> 32;
     DWORD addr = device->busAddr & 0xFFFFFFFF;
@@ -132,9 +132,9 @@ bool ivshmemInit(struct IVSHMEM * dev)
       i == shmDevice ? '*' : ' ', bus, addr >> 16, addr & 0xFFFF);
   }
 
-  device = vector_ptrTo(devices, shmDevice);
+  device = vector_ptrTo(&devices, shmDevice);
   memcpy(&devInfoData, &device->devInfoData, sizeof(SP_DEVINFO_DATA));
-  vector_free(devices);
+  vector_destroy(&devices);
 
   if (SetupDiEnumDeviceInterfaces(devInfoSet, &devInfoData, &GUID_DEVINTERFACE_IVSHMEM, 0, &devInterfaceData) == FALSE)
   {

common/src/vector.c

@@ -25,22 +25,16 @@
 #include <stdlib.h>
 #include <string.h>
 
-Vector * vector_create(size_t itemSize, size_t capacity)
+Vector * vector_alloc(size_t itemSize, size_t capacity)
 {
-  Vector * vector = calloc(1, sizeof(Vector));
+  Vector * vector = malloc(sizeof(Vector));
   if (!vector)
     return NULL;
 
-  vector->itemSize = itemSize;
-  vector->capacity = capacity;
-  if (capacity)
+  if (!vector_create(vector, itemSize, capacity))
   {
-    vector->data = malloc(itemSize * capacity);
-    if (!vector->data)
-    {
-      free(vector);
-      return NULL;
-    }
+    free(vector);
+    return NULL;
   }
   return vector;
 }
@@ -49,10 +43,33 @@ void vector_free(Vector * vector)
 {
   if (!vector)
     return;
-  free(vector->data);
+  vector_destroy(vector);
   free(vector);
 }
 
+bool vector_create(Vector * vector, size_t itemSize, size_t capacity)
+{
+  vector->itemSize = itemSize;
+  vector->capacity = capacity;
+  vector->size     = 0;
+  vector->data     = NULL;
+
+  if (capacity)
+  {
+    vector->data = malloc(itemSize * capacity);
+    if (!vector->data)
+      return false;
+  }
+  return true;
+}
+
+void vector_destroy(Vector * vector)
+{
+  free(vector->data);
+  vector->capacity = 0;
+  vector->itemSize = 0;
+}
+
 void * vector_push(Vector * vector, void * item)
 {
   if (vector->size >= vector->capacity)