diff --git a/vm/Debugger.c b/vm/Debugger.c
index 39eb74a..d5215ca 100644
--- a/vm/Debugger.c
+++ b/vm/Debugger.c
@@ -238,32 +238,6 @@
 }
 
 /*
- * (This is a HashForeachFunc callback.)
- */
-static int markRef(void* data, void* arg)
-{
-    UNUSED_PARAMETER(arg);
-
-    //LOGI("dbg mark %p\n", data);
-    dvmMarkObjectNonNull(data);
-    return 0;
-}
-
-/* Mark all of the registered debugger references so the
- * GC doesn't collect them.
- */
-void dvmGcMarkDebuggerRefs()
-{
-    /* dvmDebuggerStartup() may not have been called before the first GC.
-     */
-    if (gDvm.dbgRegistry != NULL) {
-        dvmHashTableLock(gDvm.dbgRegistry);
-        dvmHashForeach(gDvm.dbgRegistry, markRef, NULL);
-        dvmHashTableUnlock(gDvm.dbgRegistry);
-    }
-}
-
-/*
  * Verify that an object has been registered.  If it hasn't, the debugger
  * is asking for something we didn't send it, which means something
  * somewhere is broken.
diff --git a/vm/Intern.c b/vm/Intern.c
index 8bc38b8..f91cc35 100644
--- a/vm/Intern.c
+++ b/vm/Intern.c
@@ -169,27 +169,6 @@
     return found == strObj;
 }
 
-static int markStringObject(void* strObj, void* arg)
-{
-    UNUSED_PARAMETER(arg);
-    dvmMarkObjectNonNull(strObj);
-    return 0;
-}
-
-/*
- * Blacken string references from the literal string table.  The
- * literal table is a root.
- */
-void dvmGcScanInternedStrings()
-{
-    /* It's possible for a GC to happen before dvmStringInternStartup()
-     * is called.
-     */
-    if (gDvm.literalStrings != NULL) {
-        dvmHashForeach(gDvm.literalStrings, markStringObject, NULL);
-    }
-}
-
 /*
  * Clear white references from the intern table.
  */
diff --git a/vm/Jni.c b/vm/Jni.c
index a7d460f..f2ee2ae 100644
--- a/vm/Jni.c
+++ b/vm/Jni.c
@@ -1043,50 +1043,6 @@
     dvmDumpReferenceTable(&gDvm.jniPinRefTable, "JNI pinned array");
 }
 
-/*
- * GC helper function to mark all JNI global references.
- *
- * We're currently handling the "pin" table here too.
- */
-void dvmGcMarkJniGlobalRefs()
-{
-    Object** op;
-
-    dvmLockMutex(&gDvm.jniGlobalRefLock);
-
-#ifdef USE_INDIRECT_REF
-    IndirectRefTable* pRefTable = &gDvm.jniGlobalRefTable;
-    op = pRefTable->table;
-    int numEntries = dvmIndirectRefTableEntries(pRefTable);
-    int i;
-
-    for (i = 0; i < numEntries; i++) {
-        Object* obj = *op;
-        if (obj != NULL)
-            dvmMarkObjectNonNull(obj);
-        op++;
-    }
-#else
-    op = gDvm.jniGlobalRefTable.table;
-    while ((uintptr_t)op < (uintptr_t)gDvm.jniGlobalRefTable.nextEntry) {
-        dvmMarkObjectNonNull(*(op++));
-    }
-#endif
-
-    dvmUnlockMutex(&gDvm.jniGlobalRefLock);
-
-
-    dvmLockMutex(&gDvm.jniPinRefLock);
-
-    op = gDvm.jniPinRefTable.table;
-    while ((uintptr_t)op < (uintptr_t)gDvm.jniPinRefTable.nextEntry) {
-        dvmMarkObjectNonNull(*(op++));
-    }
-
-    dvmUnlockMutex(&gDvm.jniPinRefLock);
-}
-
-
 #ifndef USE_INDIRECT_REF
 /*
  * Determine if "obj" appears in the argument list for the native method.
diff --git a/vm/Thread.c b/vm/Thread.c
index c2e11c8..dd87483 100644
--- a/vm/Thread.c
+++ b/vm/Thread.c
@@ -3911,323 +3911,3 @@
     return NULL;
 }
 #endif /*WITH_MONITOR_TRACKING*/
-
-
-/*
- * GC helper functions
- */
-
-/*
- * Add the contents of the registers from the interpreted call stack.
- */
-static void gcScanInterpStackReferences(Thread *thread)
-{
-    const u4 *framePtr;
-#if WITH_EXTRA_GC_CHECKS > 1
-    bool first = true;
-#endif
-
-    framePtr = (const u4 *)thread->curFrame;
-    while (framePtr != NULL) {
-        const StackSaveArea *saveArea;
-        const Method *method;
-
-        saveArea = SAVEAREA_FROM_FP(framePtr);
-        method = saveArea->method;
-        if (method != NULL) {
-#ifdef COUNT_PRECISE_METHODS
-            /* the GC is running, so no lock required */
-            if (dvmPointerSetAddEntry(gDvm.preciseMethods, method))
-                LOGI("PGC: added %s.%s %p\n",
-                    method->clazz->descriptor, method->name, method);
-#endif
-#if WITH_EXTRA_GC_CHECKS > 1
-            /*
-             * May also want to enable the memset() in the "invokeMethod"
-             * goto target in the portable interpreter.  That sets the stack
-             * to a pattern that makes referring to uninitialized data
-             * very obvious.
-             */
-
-            if (first) {
-                /*
-                 * First frame, isn't native, check the "alternate" saved PC
-                 * as a sanity check.
-                 *
-                 * It seems like we could check the second frame if the first
-                 * is native, since the PCs should be the same.  It turns out
-                 * this doesn't always work.  The problem is that we could
-                 * have calls in the sequence:
-                 *   interp method #2
-                 *   native method
-                 *   interp method #1
-                 *
-                 * and then GC while in the native method after returning
-                 * from interp method #2.  The currentPc on the stack is
-                 * for interp method #1, but thread->currentPc2 is still
-                 * set for the last thing interp method #2 did.
-                 *
-                 * This can also happen in normal execution:
-                 * - sget-object on not-yet-loaded class
-                 * - class init updates currentPc2
-                 * - static field init is handled by parsing annotations;
-                 *   static String init requires creation of a String object,
-                 *   which can cause a GC
-                 *
-                 * Essentially, any pattern that involves executing
-                 * interpreted code and then causes an allocation without
-                 * executing instructions in the original method will hit
-                 * this.  These are rare enough that the test still has
-                 * some value.
-                 */
-                if (saveArea->xtra.currentPc != thread->currentPc2) {
-                    LOGW("PGC: savedPC(%p) != current PC(%p), %s.%s ins=%p\n",
-                        saveArea->xtra.currentPc, thread->currentPc2,
-                        method->clazz->descriptor, method->name, method->insns);
-                    if (saveArea->xtra.currentPc != NULL)
-                        LOGE("  pc inst = 0x%04x\n", *saveArea->xtra.currentPc);
-                    if (thread->currentPc2 != NULL)
-                        LOGE("  pc2 inst = 0x%04x\n", *thread->currentPc2);
-                    dvmDumpThread(thread, false);
-                }
-            } else {
-                /*
-                 * It's unusual, but not impossible, for a non-first frame
-                 * to be at something other than a method invocation.  For
-                 * example, if we do a new-instance on a nonexistent class,
-                 * we'll have a lot of class loader activity on the stack
-                 * above the frame with the "new" operation.  Could also
-                 * happen while we initialize a Throwable when an instruction
-                 * fails.
-                 *
-                 * So there's not much we can do here to verify the PC,
-                 * except to verify that it's a GC point.
-                 */
-            }
-            assert(saveArea->xtra.currentPc != NULL);
-#endif
-
-            const RegisterMap* pMap;
-            const u1* regVector;
-            int i;
-
-            Method* nonConstMethod = (Method*) method;  // quiet gcc
-            pMap = dvmGetExpandedRegisterMap(nonConstMethod);
-            if (pMap != NULL) {
-                /* found map, get registers for this address */
-                int addr = saveArea->xtra.currentPc - method->insns;
-                regVector = dvmRegisterMapGetLine(pMap, addr);
-                if (regVector == NULL) {
-                    LOGW("PGC: map but no entry for %s.%s addr=0x%04x\n",
-                        method->clazz->descriptor, method->name, addr);
-                } else {
-                    LOGV("PGC: found map for %s.%s 0x%04x (t=%d)\n",
-                        method->clazz->descriptor, method->name, addr,
-                        thread->threadId);
-                }
-            } else {
-                /*
-                 * No map found.  If precise GC is disabled this is
-                 * expected -- we don't create pointers to the map data even
-                 * if it's present -- but if it's enabled it means we're
-                 * unexpectedly falling back on a conservative scan, so it's
-                 * worth yelling a little.
-                 */
-                if (gDvm.preciseGc) {
-                    LOGVV("PGC: no map for %s.%s\n",
-                        method->clazz->descriptor, method->name);
-                }
-                regVector = NULL;
-            }
-
-            if (regVector == NULL) {
-                /* conservative scan */
-                for (i = method->registersSize - 1; i >= 0; i--) {
-                    u4 rval = *framePtr++;
-                    if (rval != 0 && (rval & 0x3) == 0) {
-                        dvmMarkIfObject((Object *)rval);
-                    }
-                }
-            } else {
-                /*
-                 * Precise scan.  v0 is at the lowest address on the
-                 * interpreted stack, and is the first bit in the register
-                 * vector, so we can walk through the register map and
-                 * memory in the same direction.
-                 *
-                 * A '1' bit indicates a live reference.
-                 */
-                u2 bits = 1 << 1;
-                for (i = method->registersSize - 1; i >= 0; i--) {
-                    u4 rval = *framePtr++;
-
-                    bits >>= 1;
-                    if (bits == 1) {
-                        /* set bit 9 so we can tell when we're empty */
-                        bits = *regVector++ | 0x0100;
-                        LOGVV("loaded bits: 0x%02x\n", bits & 0xff);
-                    }
-
-                    if (rval != 0 && (bits & 0x01) != 0) {
-                        /*
-                         * Non-null, register marked as live reference.  This
-                         * should always be a valid object.
-                         */
-#if WITH_EXTRA_GC_CHECKS > 0
-                        if ((rval & 0x3) != 0 ||
-                            !dvmIsValidObject((Object*) rval))
-                        {
-                            /* this is very bad */
-                            LOGE("PGC: invalid ref in reg %d: 0x%08x\n",
-                                method->registersSize-1 - i, rval);
-                            LOGE("PGC: %s.%s addr 0x%04x\n",
-                                method->clazz->descriptor, method->name,
-                                saveArea->xtra.currentPc - method->insns);
-                        } else
-#endif
-                        {
-                            dvmMarkObjectNonNull((Object *)rval);
-                        }
-                    } else {
-                        /*
-                         * Null or non-reference, do nothing at all.
-                         */
-#if WITH_EXTRA_GC_CHECKS > 1
-                        if (dvmIsValidObject((Object*) rval)) {
-                            /* this is normal, but we feel chatty */
-                            LOGD("PGC: ignoring valid ref in reg %d: 0x%08x\n",
-                                method->registersSize-1 - i, rval);
-                        }
-#endif
-                    }
-                }
-                dvmReleaseRegisterMapLine(pMap, regVector);
-            }
-        }
-
-#if WITH_EXTRA_GC_CHECKS > 1
-        first = false;
-#endif
-
-        /* Don't fall into an infinite loop if things get corrupted.
-         */
-        assert((uintptr_t)saveArea->prevFrame > (uintptr_t)framePtr ||
-               saveArea->prevFrame == NULL);
-        framePtr = saveArea->prevFrame;
-    }
-}
-
-static void gcScanReferenceTable(ReferenceTable *refTable)
-{
-    Object **op;
-
-    //TODO: these asserts are overkill; turn them off when things stablize.
-    assert(refTable != NULL);
-    assert(refTable->table != NULL);
-    assert(refTable->nextEntry != NULL);
-    assert((uintptr_t)refTable->nextEntry >= (uintptr_t)refTable->table);
-    assert(refTable->nextEntry - refTable->table <= refTable->maxEntries);
-
-    op = refTable->table;
-    while ((uintptr_t)op < (uintptr_t)refTable->nextEntry) {
-        dvmMarkObjectNonNull(*(op++));
-    }
-}
-
-#ifdef USE_INDIRECT_REF
-static void gcScanIndirectRefTable(IndirectRefTable* pRefTable)
-{
-    Object** op = pRefTable->table;
-    int numEntries = dvmIndirectRefTableEntries(pRefTable);
-    int i;
-
-    for (i = 0; i < numEntries; i++) {
-        Object* obj = *op;
-        if (obj != NULL)
-            dvmMarkObjectNonNull(obj);
-        op++;
-    }
-}
-#endif
-
-/*
- * Scan a Thread and mark any objects it references.
- */
-static void gcScanThread(Thread *thread)
-{
-    assert(thread != NULL);
-
-    /*
-     * The target thread must be suspended or in a state where it can't do
-     * any harm (e.g. in Object.wait()).  The only exception is the current
-     * thread, which will still be active and in the "running" state.
-     *
-     * It's possible to encounter a false-positive here because a thread
-     * transitioning to running from (say) vmwait or native will briefly
-     * set their status to running before switching to suspended.  This
-     * is highly unlikely, but does mean that we don't want to abort if
-     * the situation arises.
-     */
-    if (thread->status == THREAD_RUNNING && thread != dvmThreadSelf()) {
-        Thread* self = dvmThreadSelf();
-        LOGW("threadid=%d: Warning: GC scanning a running thread (%d)\n",
-            self->threadId, thread->threadId);
-        dvmDumpThread(thread, true);
-        LOGW("Found by:\n");
-        dvmDumpThread(self, false);
-
-        /* continue anyway */
-    }
-
-    dvmMarkObject(thread->threadObj);   // could be NULL, when constructing
-
-    dvmMarkObject(thread->exception);   // usually NULL
-    gcScanReferenceTable(&thread->internalLocalRefTable);
-
-#ifdef USE_INDIRECT_REF
-    gcScanIndirectRefTable(&thread->jniLocalRefTable);
-#else
-    gcScanReferenceTable(&thread->jniLocalRefTable);
-#endif
-
-    if (thread->jniMonitorRefTable.table != NULL) {
-        gcScanReferenceTable(&thread->jniMonitorRefTable);
-    }
-
-    gcScanInterpStackReferences(thread);
-}
-
-static void gcScanAllThreads()
-{
-    Thread *thread;
-
-    /* Lock the thread list so we can safely use the
-     * next/prev pointers.
-     */
-    dvmLockThreadList(dvmThreadSelf());
-
-    for (thread = gDvm.threadList; thread != NULL;
-            thread = thread->next)
-    {
-        /* We need to scan our own stack, so don't special-case
-         * the current thread.
-         */
-        gcScanThread(thread);
-    }
-
-    dvmUnlockThreadList();
-}
-
-void dvmGcScanRootThreadGroups()
-{
-    /* We scan the VM's list of threads instead of going
-     * through the actual ThreadGroups, but it should be
-     * equivalent.
-     *
-     * This assumes that the ThreadGroup class object is in
-     * the root set, which should always be true;  it's
-     * loaded by the built-in class loader, which is part
-     * of the root set.
-     */
-    gcScanAllThreads();
-}
diff --git a/vm/alloc/Copying.c b/vm/alloc/Copying.c
index 01c238a..0d72bfc 100644
--- a/vm/alloc/Copying.c
+++ b/vm/alloc/Copying.c
@@ -2343,11 +2343,6 @@
     /* do nothing */
 }
 
-void dvmMarkObjectNonNull(const Object *obj)
-{
-    assert(!"implemented");
-}
-
 void dvmMarkDirtyObjects(void)
 {
     assert(!"implemented");
diff --git a/vm/alloc/GC.h b/vm/alloc/GC.h
index c65c807..ce623ea 100644
--- a/vm/alloc/GC.h
+++ b/vm/alloc/GC.h
@@ -38,104 +38,10 @@
  */
 
 /*
- * Mark an object and schedule it to be scanned for
- * references to other objects.
- *
- * @param obj must be a valid object
- */
-void dvmMarkObjectNonNull(const Object *obj);
-
-/*
- * Mark an object and schedule it to be scanned for
- * references to other objects.
- *
- * @param obj must be a valid object or NULL
- */
-#define dvmMarkObject(obj) \
-    do { \
-        Object *DMO_obj_ = (Object *)(obj); \
-        if (DMO_obj_ != NULL) { \
-            dvmMarkObjectNonNull(DMO_obj_); \
-        } \
-    } while (false)
-
-/*
- * If obj points to a valid object, mark it and
- * schedule it to be scanned for references to other
- * objects.
- *
- * @param obj any pointer that may be an Object, or NULL
-TODO: check for alignment, too (would require knowledge of heap chunks)
- */
-#define dvmMarkIfObject(obj) \
-    do { \
-        Object *DMIO_obj_ = (Object *)(obj); \
-        if (DMIO_obj_ != NULL && dvmIsValidObject(DMIO_obj_)) { \
-            dvmMarkObjectNonNull(DMIO_obj_); \
-        } \
-    } while (false)
-
-/*
- * Functions that handle scanning various objects for references.
- */
-
-/*
- * Mark all class objects loaded by the root class loader;
- * most of these are the java.* classes.
- *
- * Currently implemented in Class.c.
- */
-void dvmGcScanRootClassLoader(void);
-
-/*
- * Mark all root ThreadGroup objects, guaranteeing that
- * all live Thread objects will eventually be scanned.
- *
- * NOTE: this is a misnomer, because the current implementation
- * actually only scans the internal list of VM threads, which
- * will mark all VM-reachable Thread objects.  Someone else
- * must scan the root class loader, which will mark java/lang/ThreadGroup.
- * The ThreadGroup class object has static members pointing to
- * the root ThreadGroups, and these will be marked as a side-effect
- * of marking the class object.
- *
- * Currently implemented in Thread.c.
- */
-void dvmGcScanRootThreadGroups(void);
-
-/*
- * Mark all interned string objects.
- *
- * Currently implemented in Intern.c.
- */
-void dvmGcScanInternedStrings(void);
-
-/*
  * Remove any unmarked interned string objects from the table.
  *
  * Currently implemented in Intern.c.
  */
 void dvmGcDetachDeadInternedStrings(int (*isUnmarkedObject)(void *));
 
-/*
- * Mark all primitive class objects.
- *
- * Currently implemented in Array.c.
- */
-void dvmGcScanPrimitiveClasses(void);
-
-/*
- * Mark all JNI global references.
- *
- * Currently implemented in JNI.c.
- */
-void dvmGcMarkJniGlobalRefs(void);
-
-/*
- * Mark all debugger references.
- *
- * Currently implemented in Debugger.c.
- */
-void dvmGcMarkDebuggerRefs(void);
-
 #endif  // _DALVIK_ALLOC_GC
diff --git a/vm/alloc/HeapTable.c b/vm/alloc/HeapTable.c
index e9f2729..72cf791 100644
--- a/vm/alloc/HeapTable.c
+++ b/vm/alloc/HeapTable.c
@@ -182,17 +182,3 @@
 
     return obj;
 }
-
-void dvmHeapMarkLargeTableRefs(LargeHeapRefTable *table)
-{
-    while (table != NULL) {
-        Object **ref, **lastRef;
-
-        ref = table->refs.table;
-        lastRef = table->refs.nextEntry;
-        while (ref < lastRef) {
-            dvmMarkObjectNonNull(*ref++);
-        }
-        table = table->next;
-    }
-}
diff --git a/vm/alloc/MarkSweep.c b/vm/alloc/MarkSweep.c
index ccbb663..750256c 100644
--- a/vm/alloc/MarkSweep.c
+++ b/vm/alloc/MarkSweep.c
@@ -29,15 +29,12 @@
 #define GC_LOG_TAG      LOG_TAG "-gc"
 
 #if LOG_NDEBUG
-#define LOGV_GC(...)    ((void)0)
 #define LOGD_GC(...)    ((void)0)
 #else
-#define LOGV_GC(...)    LOG(LOG_VERBOSE, GC_LOG_TAG, __VA_ARGS__)
 #define LOGD_GC(...)    LOG(LOG_DEBUG, GC_LOG_TAG, __VA_ARGS__)
 #endif
 
 #define LOGE_GC(...)    LOG(LOG_ERROR, GC_LOG_TAG, __VA_ARGS__)
-#define LOG_SCAN(...)   LOGV_GC("SCAN: " __VA_ARGS__)
 
 #define ALIGN_DOWN(x, n) ((size_t)(x) & -(n))
 #define ALIGN_UP(x, n) (((size_t)(x) + (n) - 1) & ~((n) - 1))
@@ -155,19 +152,21 @@
     }
 }
 
-/* If the object hasn't already been marked, mark it and
- * schedule it to be scanned for references.
- *
- * obj may not be NULL.  The macro dvmMarkObject() should
- * be used in situations where a reference may be NULL.
- *
- * This function may only be called when marking the root
- * set.  When recursing, use the internal markObject().
+/*
+ * Callback applied to root references during the initial root
+ * marking.  Visited roots are always marked but are only pushed on
+ * the mark stack if their address is below the finger.
  */
-void dvmMarkObjectNonNull(const Object *obj)
+static void rootMarkObjectVisitor(void *addr, RootType type, u4 thread, void *arg)
 {
-    assert(obj != NULL);
-    markObjectNonNull(obj, &gDvm.gcHeap->markContext, false);
+    Object *obj;
+
+    assert(addr != NULL);
+    assert(arg != NULL);
+    obj = *(Object **)addr;
+    if (obj != NULL) {
+        markObjectNonNull(obj, arg, false);
+    }
 }
 
 /* Mark the set of root objects.
@@ -199,45 +198,14 @@
 void dvmHeapMarkRootSet()
 {
     GcHeap *gcHeap = gDvm.gcHeap;
-
-    LOG_SCAN("immune objects");
     dvmMarkImmuneObjects(gcHeap->markContext.immuneLimit);
-
-    LOG_SCAN("root class loader\n");
-    dvmGcScanRootClassLoader();
-    LOG_SCAN("primitive classes\n");
-    dvmGcScanPrimitiveClasses();
-
-    LOG_SCAN("root thread groups\n");
-    dvmGcScanRootThreadGroups();
-
-    LOG_SCAN("interned strings\n");
-    dvmGcScanInternedStrings();
-
-    LOG_SCAN("JNI global refs\n");
-    dvmGcMarkJniGlobalRefs();
-
-    LOG_SCAN("pending reference operations\n");
-    dvmHeapMarkLargeTableRefs(gcHeap->referenceOperations);
-
-    LOG_SCAN("pending finalizations\n");
-    dvmHeapMarkLargeTableRefs(gcHeap->pendingFinalizationRefs);
-
-    LOG_SCAN("debugger refs\n");
-    dvmGcMarkDebuggerRefs();
-
-    /* Mark any special objects we have sitting around.
-     */
-    LOG_SCAN("special objects\n");
-    dvmMarkObjectNonNull(gDvm.outOfMemoryObj);
-    dvmMarkObjectNonNull(gDvm.internalErrorObj);
-    dvmMarkObjectNonNull(gDvm.noClassDefFoundErrorObj);
-//TODO: scan object references sitting in gDvm;  use pointer begin & end
+    dvmVisitRoots(rootMarkObjectVisitor, &gcHeap->markContext);
 }
 
 /*
- * Callback applied to root references.  If the root location contains
- * a white reference it is pushed on the mark stack and grayed.
+ * Callback applied to root references during root remarking.  If the
+ * root location contains a white reference it is pushed on the mark
+ * stack and grayed.
  */
 static void markObjectVisitor(void *addr, RootType type, u4 thread, void *arg)
 {
@@ -262,16 +230,6 @@
 }
 
 /*
- * Nothing past this point is allowed to use dvmMarkObject() or
- * dvmMarkObjectNonNull(), which are for root-marking only.
- * Scanning/recursion must use markObject(), which takes the finger
- * into account.
- */
-#undef dvmMarkObject
-#define dvmMarkObject __dont_use_dvmMarkObject__
-#define dvmMarkObjectNonNull __dont_use_dvmMarkObjectNonNull__
-
-/*
  * Scans instance fields.
  */
 static void scanFields(const Object *obj, GcMarkContext *ctx)
@@ -751,8 +709,6 @@
      * left on the mark stack.
      */
     processMarkStack(ctx);
-
-    LOG_SCAN("done with marked objects\n");
 }
 
 void dvmHeapReScanMarkedObjects(void)
diff --git a/vm/alloc/Visit.c b/vm/alloc/Visit.c
index 697cc3f..a317955 100644
--- a/vm/alloc/Visit.c
+++ b/vm/alloc/Visit.c
@@ -97,7 +97,8 @@
 }
 
 /*
- * Visits all stack slots. TODO: visit native methods.
+ * Visits all stack slots except those belonging to native method
+ * arguments.
  */
 static void visitThreadStack(RootVisitor *visitor, Thread *thread, void *arg)
 {
@@ -154,6 +155,17 @@
                         /*
                          * Register is marked as live, it's a valid root.
                          */
+#if WITH_EXTRA_GC_CHECKS
+                        if (fp[i] != 0 && !dvmIsValidObject((Object *)fp[i])) {
+                            /* this is very bad */
+                            LOGE("PGC: invalid ref in reg %d: %#x",
+                                 method->registersSize - 1 - i, fp[i]);
+                            LOGE("PGC: %s.%s addr %#x",
+                                 method->clazz->descriptor, method->name,
+                                 saveArea->xtra.currentPc - method->insns);
+                            continue;
+                        }
+#endif
                         (*visitor)(&fp[i], threadId, ROOT_JAVA_FRAME, arg);
                     }
                 }
@@ -216,10 +228,15 @@
     if (gDvm.dbgRegistry != NULL) {
         visitHashTable(visitor, gDvm.dbgRegistry, ROOT_DEBUGGER, arg);
     }
-    visitHashTable(visitor, gDvm.internedStrings, ROOT_INTERNED_STRING, arg);
-    visitHashTable(visitor, gDvm.literalStrings, ROOT_INTERNED_STRING, arg);
+    if (gDvm.literalStrings != NULL) {
+        visitHashTable(visitor, gDvm.literalStrings, ROOT_INTERNED_STRING, arg);
+    }
+    dvmLockMutex(&gDvm.jniGlobalRefLock);
     visitReferenceTable(visitor, &gDvm.jniGlobalRefTable, 0, ROOT_JNI_GLOBAL, arg);
+    dvmUnlockMutex(&gDvm.jniGlobalRefLock);
+    dvmLockMutex(&gDvm.jniPinRefLock);
     visitReferenceTable(visitor, &gDvm.jniPinRefTable, 0, ROOT_VM_INTERNAL, arg);
+    dvmUnlockMutex(&gDvm.jniPinRefLock);
     visitLargeHeapRefTable(visitor, gDvm.gcHeap->referenceOperations, ROOT_REFERENCE_CLEANUP, arg);
     visitLargeHeapRefTable(visitor, gDvm.gcHeap->pendingFinalizationRefs, ROOT_FINALIZING, arg);
     visitThreads(visitor, arg);
diff --git a/vm/oo/Array.c b/vm/oo/Array.c
index 3b1c652..bc57a5a 100644
--- a/vm/oo/Array.c
+++ b/vm/oo/Array.c
@@ -799,16 +799,3 @@
     size += array->length * dvmArrayClassElementWidth(array->obj.clazz);
     return size;
 }
-
-/*
- * Add all primitive classes to the root set of objects.
-TODO: do these belong to the root class loader?
- */
-void dvmGcScanPrimitiveClasses()
-{
-    int i;
-
-    for (i = 0; i < PRIM_MAX; i++) {
-        dvmMarkObject((Object *)gDvm.primitiveClass[i]);    // may be NULL
-    }
-}
diff --git a/vm/oo/Class.c b/vm/oo/Class.c
index c6b169f..6e16adc 100644
--- a/vm/oo/Class.c
+++ b/vm/oo/Class.c
@@ -4884,34 +4884,6 @@
 }
 #endif
 
-
-/*
- * Mark all classes associated with the built-in loader.
- */
-static int markClassObject(void *clazz, void *arg)
-{
-    UNUSED_PARAMETER(arg);
-
-    dvmMarkObjectNonNull((Object *)clazz);
-    return 0;
-}
-
-/*
- * The garbage collector calls this to mark the class objects for all
- * loaded classes.
- */
-void dvmGcScanRootClassLoader()
-{
-    /* dvmClassStartup() may not have been called before the first GC.
-     */
-    if (gDvm.loadedClasses != NULL) {
-        dvmHashTableLock(gDvm.loadedClasses);
-        dvmHashForeach(gDvm.loadedClasses, markClassObject, NULL);
-        dvmHashTableUnlock(gDvm.loadedClasses);
-    }
-}
-
-
 /*
  * ===========================================================================
  *      Method Prototypes and Descriptors