diff --git a/dlls/dbghelp/dbghelp_private.h b/dlls/dbghelp/dbghelp_private.h
index a84d91c..8fd3360 100644
--- a/dlls/dbghelp/dbghelp_private.h
+++ b/dlls/dbghelp/dbghelp_private.h
@@ -37,8 +37,7 @@
 
 struct pool /* poor's man */
 {
-    struct pool_arena*  first;
-    unsigned            arena_size;
+    HANDLE heap;
 };
 
 void     pool_init(struct pool* a, unsigned arena_size);
diff --git a/dlls/dbghelp/storage.c b/dlls/dbghelp/storage.c
index e196143..3b1e909 100644
--- a/dlls/dbghelp/storage.c
+++ b/dlls/dbghelp/storage.c
@@ -32,100 +32,24 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp);
 
-struct pool_arena
-{
-    struct pool_arena*  next;
-    char*               current;
-};
-
 void pool_init(struct pool* a, unsigned arena_size)
 {
-    a->arena_size = arena_size;
-    a->first = NULL;
+    a->heap = HeapCreate(0, arena_size, 0);
 }
 
 void pool_destroy(struct pool* pool)
 {
-    struct pool_arena*  arena;
-    struct pool_arena*  next;
-
-#ifdef USE_STATS
-    unsigned    alloc, used, num;
-    
-    for (alloc = used = num = 0, arena = pool->first; arena; arena = arena->next)
-    {
-        alloc += pool->arena_size;
-        used += arena->current - (char*)arena;
-        num++;
-    }
-    FIXME("STATS: pool %p has allocated %u kbytes, used %u kbytes in %u arenas,\n"
-          "\t\t\t\tnon-allocation ratio: %.2f%%\n",
-          pool, alloc >> 10, used >> 10, num, 100.0 - (float)used / (float)alloc * 100.0);
-#endif
-
-    for (arena = pool->first; arena; arena = next)
-    {
-        next = arena->next;
-        HeapFree(GetProcessHeap(), 0, arena);
-    }
-    pool_init(pool, 0);
+    HeapDestroy(pool->heap);
 }
 
 void* pool_alloc(struct pool* pool, unsigned len)
 {
-    struct pool_arena** parena;
-    struct pool_arena*  arena;
-    void*               ret;
-
-    len = (len + 3) & ~3; /* round up size on DWORD boundary */
-    assert(sizeof(struct pool_arena) + len <= pool->arena_size && len);
-
-    for (parena = &pool->first; *parena; parena = &(*parena)->next)
-    {
-        if ((char*)(*parena) + pool->arena_size - (*parena)->current >= len)
-        {
-            ret = (*parena)->current;
-            (*parena)->current += len;
-            return ret;
-        }
-    }
- 
-    arena = HeapAlloc(GetProcessHeap(), 0, pool->arena_size);
-    if (!arena) {FIXME("OOM\n");return NULL;}
-
-    *parena = arena;
-
-    ret = (char*)arena + sizeof(*arena);
-    arena->next = NULL;
-    arena->current = (char*)ret + len;
-    return ret;
-}
-
-static struct pool_arena* pool_is_last(const struct pool* pool, const void* p, unsigned old_size)
-{
-    struct pool_arena*  arena;
-
-    for (arena = pool->first; arena; arena = arena->next)
-    {
-        if (arena->current == (const char*)p + old_size) return arena;
-    }
-    return NULL;
+    return HeapAlloc(pool->heap, 0, len);
 }
 
-static void* pool_realloc(struct pool* pool, void* p, unsigned old_size, unsigned new_size)
+static void* pool_realloc(struct pool* pool, void* p, unsigned len)
 {
-    struct pool_arena*  arena;
-    void*               new;
-
-    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;
+    return HeapReAlloc(pool->heap, 0, p, len);
 }
 
 char* pool_strdup(struct pool* pool, const char* str)
@@ -180,9 +104,14 @@ void* vector_add(struct vector* v, struct pool* pool)
     assert(v->num_elts > ncurr);
     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*));
+        if (v->buckets)
+        {
+            v->buckets = pool_realloc(pool, v->buckets, (v->num_buckets + 1) * sizeof(void*));
+        }
+        else
+        {
+            v->buckets = pool_alloc(pool, (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++];
     }