Get rid of the HeapRefTable type.
This was a needless alias for a ReferenceTable.
Change-Id: I3450c4a731d06da0954e6d8b441e731a06ded321
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++;
