diff --git a/vm/alloc/HeapTable.c b/vm/alloc/HeapTable.c
index 0eab8a5..6c9034a 100644
--- a/vm/alloc/HeapTable.c
+++ b/vm/alloc/HeapTable.c
@@ -23,27 +23,11 @@
 static const int kLargeHeapRefTableNElems = 1024;
 static const int  kFinalizableRefDefault = 128;
 
-void dvmHeapHeapTableFree(void *ptr)
+bool dvmHeapInitHeapRefTable(ReferenceTable *refs)
 {
-    free(ptr);
-}
-
-#define heapRefTableIsFull(refs) \
-    dvmIsReferenceTableFull(refs)
-
-bool dvmHeapInitHeapRefTable(HeapRefTable *refs)
-{
-    memset(refs, 0, sizeof(*refs));
     return dvmInitReferenceTable(refs, kFinalizableRefDefault, INT_MAX);
 }
 
-/* Frees the array inside the HeapRefTable, not the HeapRefTable itself.
- */
-void dvmHeapFreeHeapRefTable(HeapRefTable *refs)
-{
-    dvmClearReferenceTable(refs);
-}
-
 /*
  * Large, non-contiguous reference tables
  */
@@ -65,7 +49,7 @@
         /* Find an empty slot for this reference.
          */
         prevTable = NULL;
-        while (table != NULL && heapRefTableIsFull(&table->refs)) {
+        while (table != NULL && dvmIsReferenceTableFull(&table->refs)) {
             prevTable = table;
             table = table->next;
         }
@@ -97,7 +81,7 @@
                                kLargeHeapRefTableNElems,
                                INT_MAX)) {
         LOGE_HEAP("Can't initialize a new large ref table\n");
-        dvmHeapHeapTableFree(table);
+        free(table);
         return false;
     }
 
@@ -111,13 +95,13 @@
      */
     assert(table == *tableP);
     assert(table != NULL);
-    assert(!heapRefTableIsFull(&table->refs));
+    assert(!dvmIsReferenceTableFull(&table->refs));
     *table->refs.nextEntry++ = ref;
 
     return true;
 }
 
-bool dvmHeapAddTableToLargeTable(LargeHeapRefTable **tableP, HeapRefTable *refs)
+bool dvmHeapAddTableToLargeTable(LargeHeapRefTable **tableP, ReferenceTable *refs)
 {
     LargeHeapRefTable *table;
 
@@ -144,8 +128,8 @@
 {
     while (table != NULL) {
         LargeHeapRefTable *next = table->next;
-        dvmHeapFreeHeapRefTable(&table->refs);
-        dvmHeapHeapTableFree(table);
+        dvmClearReferenceTable(&table->refs);
+        free(table);
         table = next;
     }
 }
@@ -160,7 +144,7 @@
     obj = NULL;
     table = *pTable;
     if (table != NULL) {
-        HeapRefTable *refs = &table->refs;
+        ReferenceTable *refs = &table->refs;
 
         /* We should never have an empty table node in the list.
          */
@@ -176,7 +160,7 @@
         if (refs->nextEntry == refs->table) {
             *pTable = table->next;
             dvmClearReferenceTable(refs);
-            dvmHeapHeapTableFree(table);
+            free(table);
         }
     }
 
diff --git a/vm/alloc/HeapTable.h b/vm/alloc/HeapTable.h
index 4f6034c..175111d 100644
--- a/vm/alloc/HeapTable.h
+++ b/vm/alloc/HeapTable.h
@@ -18,31 +18,19 @@
 
 #include "ReferenceTable.h"
 
-typedef ReferenceTable HeapRefTable;
-typedef struct LargeHeapRefTable LargeHeapRefTable;
-
 struct LargeHeapRefTable {
-    LargeHeapRefTable *next;
-    HeapRefTable refs;
+    struct LargeHeapRefTable *next;
+    ReferenceTable refs;
 };
 
-bool dvmHeapInitHeapRefTable(HeapRefTable *refs);
-void dvmHeapFreeHeapRefTable(HeapRefTable *refs);
+typedef struct LargeHeapRefTable LargeHeapRefTable;
+
+bool dvmHeapInitHeapRefTable(ReferenceTable *refs);
 void dvmHeapFreeLargeTable(LargeHeapRefTable *table);
-void dvmHeapHeapTableFree(void *ptr);
 bool dvmHeapAddRefToLargeTable(LargeHeapRefTable **tableP, Object *ref);
 void dvmHeapMarkLargeTableRefs(LargeHeapRefTable *table);
 bool dvmHeapAddTableToLargeTable(LargeHeapRefTable **tableP,
-        HeapRefTable *refs);
+        ReferenceTable *refs);
 Object *dvmHeapGetNextObjectFromLargeTable(LargeHeapRefTable **pTable);
 
-#define dvmHeapAddToHeapRefTable(refs, ptr) \
-            dvmAddToReferenceTable((refs), (ptr))
-
-#define dvmHeapNumHeapRefTableEntries(refs) \
-            dvmReferenceTableEntries(refs)
-
-#define dvmHeapRemoveFromHeapRefTable(refs, ptr) \
-            dvmRemoveFromReferenceTable((refs), (refs)->table, (ptr))
-
 #endif  // _DALVIK_ALLOC_HEAP_TABLE
diff --git a/vm/alloc/MarkSweep.c b/vm/alloc/MarkSweep.c
index 4f36d82..c9353aa 100644
--- a/vm/alloc/MarkSweep.c
+++ b/vm/alloc/MarkSweep.c
@@ -853,7 +853,7 @@
  */
 static void scheduleFinalizations(void)
 {
-    HeapRefTable newPendingRefs;
+    ReferenceTable newPendingRefs;
     LargeHeapRefTable *finRefs = gDvm.gcHeap->finalizableRefs;
     Object **ref;
     Object **lastRef;
@@ -890,12 +890,12 @@
         lastRef = finRefs->refs.nextEntry;
         while (ref < lastRef) {
             if (!isMarked(*ref, ctx)) {
-                if (!dvmHeapAddToHeapRefTable(&newPendingRefs, *ref)) {
+                if (!dvmAddToReferenceTable(&newPendingRefs, *ref)) {
                     //TODO: add the current table and allocate
                     //      a new, smaller one.
                     LOGE_GC("scheduleFinalizations(): "
                             "no room for any more pending finalizations: %zd",
-                            dvmHeapNumHeapRefTableEntries(&newPendingRefs));
+                            dvmReferenceTableEntries(&newPendingRefs));
                     dvmAbort();
                 }
                 newPendCount++;