diff --git a/dlls/dbghelp/dbghelp_private.h b/dlls/dbghelp/dbghelp_private.h
index a84d91c..61b4e48 100644
--- a/dlls/dbghelp/dbghelp_private.h
+++ b/dlls/dbghelp/dbghelp_private.h
@@ -39,6 +39,8 @@ struct pool /* poor's man */
 {
     struct pool_arena*  first;
     unsigned            arena_size;
+    void**              reallocs;
+    unsigned            realloc_size;
 };
 
 void     pool_init(struct pool* a, unsigned arena_size);
diff --git a/dlls/dbghelp/storage.c b/dlls/dbghelp/storage.c
index c3ccaf5..a9f6f44 100644
--- a/dlls/dbghelp/storage.c
+++ b/dlls/dbghelp/storage.c
@@ -42,12 +42,15 @@ void pool_init(struct pool* a, unsigned arena_size)
 {
     a->arena_size = arena_size;
     a->first = NULL;
+    a->reallocs = NULL;
+    a->realloc_size = 0;
 }
 
 void pool_destroy(struct pool* pool)
 {
     struct pool_arena*  arena;
     struct pool_arena*  next;
+    unsigned            i;
 
 #ifdef USE_STATS
     unsigned    alloc, used, num;
@@ -68,6 +71,11 @@ void pool_destroy(struct pool* pool)
         next = arena->next;
         HeapFree(GetProcessHeap(), 0, arena);
     }
+    for (i=0; i<pool->realloc_size; i++)
+    {
+        HeapFree(GetProcessHeap(), 0, pool->reallocs[i]);
+    }
+    if (pool->reallocs) HeapFree(GetProcessHeap(), 0, pool->reallocs);
     pool_init(pool, 0);
 }
 
@@ -99,31 +107,39 @@ void* pool_alloc(struct pool* pool, unsigned len)
     return ret;
 }
 
-static struct pool_arena* pool_is_last(const struct pool* pool, const void* p, unsigned old_size)
+static void* pool_realloc(struct pool* pool, void* p, unsigned new_size)
 {
-    struct pool_arena*  arena;
+    void* ret;
 
-    for (arena = pool->first; arena; arena = arena->next)
+    if (p)
     {
-        if (arena->current == (const char*)p + old_size) return arena;
+        ret = HeapReAlloc(GetProcessHeap(), 0, p, new_size);
+        if (ret != p)
+        {
+            /* ReAlloc moved the memory, replace the cached pointer */
+            unsigned    i;
+            for (i=0; i<pool->realloc_size; i++)
+            {
+                if (pool->reallocs[i] == p)
+                {
+                    pool->reallocs[i] = ret;
+                    break;
+                }
+            }
+        }
+        return ret;
     }
-    return NULL;
-}
 
-static void* pool_realloc(struct pool* pool, void* p, unsigned old_size, unsigned new_size)
-{
-    struct pool_arena*  arena;
-    void*               new;
+    ret = HeapAlloc(GetProcessHeap(), 0, new_size);
+    if (!pool->reallocs)
+        pool->reallocs = HeapAlloc(GetProcessHeap(), 0, sizeof(void*));
+    else
+        pool->reallocs = HeapReAlloc(GetProcessHeap(), 0, pool->reallocs, (pool->realloc_size+1)*sizeof(void*));
 
-    if ((arena = pool_is_last(pool, p, old_size)) && 
-        (char*)p + new_size <= (char*)arena + pool->arena_size)
-    {
-        arena->current = (char*)p + new_size;
-        return p;
-    }
-    if ((new = pool_alloc(pool, new_size)) && old_size)
-        memcpy(new, p, min(old_size, new_size));
-    return new;
+    pool->reallocs[pool->realloc_size] = ret;
+    pool->realloc_size++;
+
+    return ret;
 }
 
 char* pool_strdup(struct pool* pool, const char* str)
@@ -179,7 +195,6 @@ void* vector_add(struct vector* v, struct pool* pool)
     if (ncurr == (v->num_buckets << v->shift))
     {
         v->buckets = pool_realloc(pool, v->buckets,
-                                  v->num_buckets * sizeof(void*),
                                   (v->num_buckets + 1) * sizeof(void*));
         v->buckets[v->num_buckets] = pool_alloc(pool, v->elt_size << v->shift);
         return v->buckets[v->num_buckets++];