diff --git a/vm/AllocTracker.c b/vm/AllocTracker.cpp
similarity index 97%
rename from vm/AllocTracker.c
rename to vm/AllocTracker.cpp
index 8e2c325..c65ac4d 100644
--- a/vm/AllocTracker.c
+++ b/vm/AllocTracker.cpp
@@ -184,16 +184,18 @@
 /*
  * Add a new allocation to the set.
  */
-void dvmDoTrackAllocation(ClassObject* clazz, int size)
+void dvmDoTrackAllocation(ClassObject* clazz, size_t size)
 {
-    dvmLockMutex(&gDvm.allocTrackerLock);
-    if (gDvm.allocRecords == NULL)
-        goto bail;
-
     Thread* self = dvmThreadSelf();
     if (self == NULL) {
         LOGW("alloc tracker: no thread\n");
-        goto bail;
+        return;
+    }
+
+    dvmLockMutex(&gDvm.allocTrackerLock);
+    if (gDvm.allocRecords == NULL) {
+        dvmUnlockMutex(&gDvm.allocTrackerLock);
+        return;
     }
 
     /* advance and clip */
@@ -210,7 +212,6 @@
     if (gDvm.allocRecordCount < kNumAllocRecords)
         gDvm.allocRecordCount++;
 
-bail:
     dvmUnlockMutex(&gDvm.allocTrackerLock);
 }
 
@@ -600,8 +601,10 @@
         dvmEnableAllocTracker();
 
     dvmLockMutex(&gDvm.allocTrackerLock);
-    if (gDvm.allocRecords == NULL)
-        goto bail;
+    if (gDvm.allocRecords == NULL) {
+        dvmUnlockMutex(&gDvm.allocTrackerLock);
+        return;
+    }
 
     /*
      * "idx" is the head of the list.  We want to start at the end of the
@@ -618,8 +621,7 @@
             pRec->threadId, pRec->size, pRec->clazz->descriptor);
 
         if (true) {
-            int i;
-            for (i = 0; i < kMaxAllocRecordStackDepth; i++) {
+            for (int i = 0; i < kMaxAllocRecordStackDepth; i++) {
                 if (pRec->stackElem[i].method == NULL)
                     break;
 
@@ -642,7 +644,6 @@
         idx = (idx + 1) & (kNumAllocRecords-1);
     }
 
-bail:
     dvmUnlockMutex(&gDvm.allocTrackerLock);
     if (false) {
         u1* data;
diff --git a/vm/AllocTracker.h b/vm/AllocTracker.h
index b6d668d..fa8ba75 100644
--- a/vm/AllocTracker.h
+++ b/vm/AllocTracker.h
@@ -48,7 +48,7 @@
         if (gDvm.allocRecords != NULL)                                      \
             dvmDoTrackAllocation(_clazz, _size);                            \
     }
-void dvmDoTrackAllocation(ClassObject* clazz, int size);
+void dvmDoTrackAllocation(ClassObject* clazz, size_t size);
 
 /*
  * Generate a DDM packet with all of the tracked allocation data.
diff --git a/vm/Atomic.c b/vm/Atomic.cpp
similarity index 100%
rename from vm/Atomic.c
rename to vm/Atomic.cpp
diff --git a/vm/AtomicCache.c b/vm/AtomicCache.cpp
similarity index 100%
rename from vm/AtomicCache.c
rename to vm/AtomicCache.cpp
diff --git a/vm/BitVector.c b/vm/BitVector.cpp
similarity index 100%
rename from vm/BitVector.c
rename to vm/BitVector.cpp
diff --git a/vm/Ddm.c b/vm/Ddm.cpp
similarity index 98%
rename from vm/Ddm.c
rename to vm/Ddm.cpp
index 1251fe2..23561fd 100644
--- a/vm/Ddm.c
+++ b/vm/Ddm.cpp
@@ -284,7 +284,7 @@
         set4BE(&buf[0x04], stringLen);
 
         /* copy the UTF-16 string, transforming to big-endian */
-        outChars = (u2*) &buf[0x08];
+        outChars = (u2*)(void*)&buf[0x08];
         while (stringLen--)
             set2BE((u1*) (outChars++), *chars++);
     } else {
@@ -320,7 +320,7 @@
 
     set4BE(&buf[0x00], threadId);
     set4BE(&buf[0x04], stringLen);
-    u2* outChars = (u2*) &buf[0x08];
+    u2* outChars = (u2*)(void*)&buf[0x08];
     while (stringLen--)
         set2BE((u1*) (outChars++), *chars++);
 
diff --git a/vm/Debugger.c b/vm/Debugger.cpp
similarity index 97%
rename from vm/Debugger.c
rename to vm/Debugger.cpp
index 0f01647..ebe4149 100644
--- a/vm/Debugger.c
+++ b/vm/Debugger.cpp
@@ -459,7 +459,8 @@
  */
 int dvmDbgThreadRunning(void)
 {
-    return dvmChangeStatus(NULL, THREAD_RUNNING);
+    ThreadStatus oldStatus = dvmChangeStatus(NULL, THREAD_RUNNING);
+    return static_cast<int>(oldStatus);
 }
 
 /*
@@ -467,7 +468,8 @@
  */
 int dvmDbgThreadWaiting(void)
 {
-    return dvmChangeStatus(NULL, THREAD_VMWAIT);
+    ThreadStatus oldStatus = dvmChangeStatus(NULL, THREAD_VMWAIT);
+    return static_cast<int>(oldStatus);
 }
 
 /*
@@ -475,7 +477,9 @@
  */
 int dvmDbgThreadContinuing(int status)
 {
-    return dvmChangeStatus(NULL, status);
+    ThreadStatus newStatus = static_cast<ThreadStatus>(status);
+    ThreadStatus oldStatus = dvmChangeStatus(NULL, newStatus);
+    return static_cast<int>(oldStatus);
 }
 
 /*
@@ -1173,36 +1177,32 @@
 void dvmDbgOutputAllFields(RefTypeId refTypeId, bool withGeneric,
     ExpandBuf* pReply)
 {
-    static const u1 genericSignature[1] = "";
-    ClassObject* clazz;
-    Field* field;
-    u4 declared;
-    int i;
-
-    clazz = refTypeIdToClassObject(refTypeId);
+    ClassObject* clazz = refTypeIdToClassObject(refTypeId);
     assert(clazz != NULL);
 
-    declared = clazz->sfieldCount + clazz->ifieldCount;
+    u4 declared = clazz->sfieldCount + clazz->ifieldCount;
     expandBufAdd4BE(pReply, declared);
 
-    for (i = 0; i < clazz->sfieldCount; i++) {
-        field = (Field*) &clazz->sfields[i];
-
+    for (int i = 0; i < clazz->sfieldCount; i++) {
+        Field* field = &clazz->sfields[i].field;
         expandBufAddFieldId(pReply, fieldToFieldId(field));
         expandBufAddUtf8String(pReply, (const u1*) field->name);
         expandBufAddUtf8String(pReply, (const u1*) field->signature);
-        if (withGeneric)
+        if (withGeneric) {
+            static const u1 genericSignature[1] = "";
             expandBufAddUtf8String(pReply, genericSignature);
+        }
         expandBufAdd4BE(pReply, augmentedAccessFlags(field->accessFlags));
     }
-    for (i = 0; i < clazz->ifieldCount; i++) {
-        field = (Field*) &clazz->ifields[i];
-
+    for (int i = 0; i < clazz->ifieldCount; i++) {
+        Field* field = (Field*)&clazz->ifields[i].field;
         expandBufAddFieldId(pReply, fieldToFieldId(field));
         expandBufAddUtf8String(pReply, (const u1*) field->name);
         expandBufAddUtf8String(pReply, (const u1*) field->signature);
-        if (withGeneric)
+        if (withGeneric) {
+            static const u1 genericSignature[1] = "";
             expandBufAddUtf8String(pReply, genericSignature);
+        }
         expandBufAdd4BE(pReply, augmentedAccessFlags(field->accessFlags));
     }
 }
@@ -2635,21 +2635,17 @@
     u4 options, u1* pResultTag, u8* pResultValue, ObjectId* pExceptObj)
 {
     Object* threadObj = objectIdToObject(threadId);
-    Thread* targetThread;
-    JdwpError err = ERR_NONE;
 
     dvmLockThreadList(NULL);
 
-    targetThread = threadObjToThread(threadObj);
+    Thread* targetThread = threadObjToThread(threadObj);
     if (targetThread == NULL) {
-        err = ERR_INVALID_THREAD;       /* thread does not exist */
         dvmUnlockThreadList();
-        goto bail;
+        return ERR_INVALID_THREAD;       /* thread does not exist */
     }
     if (!targetThread->invokeReq.ready) {
-        err = ERR_INVALID_THREAD;       /* thread not stopped by event */
         dvmUnlockThreadList();
-        goto bail;
+        return ERR_INVALID_THREAD;       /* thread not stopped by event */
     }
 
     /*
@@ -2671,9 +2667,8 @@
              "for method exec\n",
             dvmThreadSelf()->threadId, targetThread->threadId,
             targetThread->interpBreak.ctl.suspendCount);
-        err = ERR_THREAD_SUSPENDED;     /* probably not expected here */
         dvmUnlockThreadList();
-        goto bail;
+        return ERR_THREAD_SUSPENDED;     /* probably not expected here */
     }
 
     /*
@@ -2704,7 +2699,7 @@
      * the invokeReq mutex, although that should never be held for long.
      */
     Thread* self = dvmThreadSelf();
-    int oldStatus = dvmChangeStatus(self, THREAD_VMWAIT);
+    ThreadStatus oldStatus = dvmChangeStatus(self, THREAD_VMWAIT);
 
     LOGV("    Transferring control to event thread\n");
     dvmLockMutex(&targetThread->invokeReq.lock);
@@ -2760,10 +2755,7 @@
         *pResultValue = objectToObjectId(tmpObj);
     }
     *pExceptObj = targetThread->invokeReq.exceptObj;
-    err = targetThread->invokeReq.err;
-
-bail:
-    return err;
+    return targetThread->invokeReq.err;
 }
 
 /*
@@ -2786,7 +2778,7 @@
     Thread* self = dvmThreadSelf();
     const Method* meth;
     Object* oldExcept;
-    int oldStatus;
+    ThreadStatus oldStatus;
 
     /*
      * We can be called while an exception is pending in the VM.  We need
diff --git a/vm/Dvm.mk b/vm/Dvm.mk
index 97a317b..1eb1cef 100644
--- a/vm/Dvm.mk
+++ b/vm/Dvm.mk
@@ -85,37 +85,37 @@
 #LOCAL_CFLAGS += -DWITH_JNI_STACK_CHECK
 
 LOCAL_SRC_FILES := \
-	AllocTracker.c \
-	Atomic.c.arm \
-	AtomicCache.c \
-	BitVector.c.arm \
+	AllocTracker.cpp \
+	Atomic.cpp.arm \
+	AtomicCache.cpp \
+	BitVector.cpp.arm \
 	CheckJni.cpp \
-	Ddm.c \
-	Debugger.c \
-	DvmDex.c \
-	Exception.c \
-	Hash.c \
-	IndirectRefTable.c.arm \
-	Init.c \
-	InitRefs.c \
-	InlineNative.c.arm \
-	Inlines.c \
-	Intern.c \
+	Ddm.cpp \
+	Debugger.cpp \
+	DvmDex.cpp \
+	Exception.cpp \
+	Hash.cpp \
+	IndirectRefTable.cpp.arm \
+	Init.cpp \
+	InitRefs.cpp \
+	InlineNative.cpp.arm \
+	Inlines.cpp \
+	Intern.cpp \
 	Jni.cpp \
-	JarFile.c \
-	LinearAlloc.c \
-	Misc.c \
-	Native.c \
-	PointerSet.c \
-	Profile.c \
-	Properties.c \
-	RawDexFile.c \
-	ReferenceTable.c \
-	SignalCatcher.c \
-	StdioConverter.c \
-	Sync.c \
-	Thread.c \
-	UtfString.c \
+	JarFile.cpp \
+	LinearAlloc.cpp \
+	Misc.cpp \
+	Native.cpp \
+	PointerSet.cpp \
+	Profile.cpp \
+	Properties.cpp \
+	RawDexFile.cpp \
+	ReferenceTable.cpp \
+	SignalCatcher.cpp \
+	StdioConverter.cpp \
+	Sync.cpp \
+	Thread.cpp \
+	UtfString.cpp \
 	alloc/Alloc.cpp \
 	alloc/CardTable.cpp \
 	alloc/HeapBitmap.cpp.arm \
@@ -146,7 +146,7 @@
 	jdwp/JdwpHandler.cpp \
 	jdwp/JdwpMain.cpp \
 	jdwp/JdwpSocket.cpp \
-	mterp/Mterp.c.arm \
+	mterp/Mterp.cpp.arm \
 	mterp/out/InterpC-portable.c.arm \
 	native/InternalNative.cpp \
 	native/dalvik_bytecode_OpcodeInfo.cpp \
@@ -186,9 +186,9 @@
 	reflect/Annotation.cpp \
 	reflect/Proxy.cpp \
 	reflect/Reflect.cpp \
-	test/AtomicTest.c.arm \
-	test/TestHash.c \
-	test/TestIndirectRefTable.c
+	test/AtomicTest.cpp.arm \
+	test/TestHash.cpp \
+	test/TestIndirectRefTable.cpp
 
 WITH_COPYING_GC := $(strip $(WITH_COPYING_GC))
 
diff --git a/vm/DvmDex.c b/vm/DvmDex.cpp
similarity index 100%
rename from vm/DvmDex.c
rename to vm/DvmDex.cpp
diff --git a/vm/Exception.c b/vm/Exception.cpp
similarity index 99%
rename from vm/Exception.c
rename to vm/Exception.cpp
index 740f5a6..281873e 100644
--- a/vm/Exception.c
+++ b/vm/Exception.cpp
@@ -888,7 +888,7 @@
             assert(dvmCheckException(dvmThreadSelf()));
             goto bail;
         }
-        intPtr = (int*) stackData->contents;
+        intPtr = (int*)(void*)stackData->contents;
     } else {
         /* array of ints; first entry is stack depth */
         assert(sizeof(Method*) == sizeof(int));
@@ -950,7 +950,7 @@
 {
     const ArrayObject* stackData = (const ArrayObject*) ostackData;
     size_t stackSize = stackData->length / 2;
-    const int* intVals = (const int*) stackData->contents;
+    const int* intVals = (const int*)(void*)stackData->contents;
     return dvmGetStackTraceRaw(intVals, stackSize);
 }
 
@@ -1189,7 +1189,7 @@
     }
 
     stackSize = stackData->length / 2;
-    intVals = (const int*) stackData->contents;
+    intVals = (const int*)(void*)stackData->contents;
 
     dvmLogRawStackTrace(intVals, stackSize);
 }
diff --git a/vm/Globals.h b/vm/Globals.h
index 163ce99..0415305 100644
--- a/vm/Globals.h
+++ b/vm/Globals.h
@@ -95,7 +95,7 @@
 
     bool        jdwpAllowed;        // debugging allowed for this process?
     bool        jdwpConfigured;     // has debugging info been provided?
-    int         jdwpTransport;
+    JdwpTransportType jdwpTransport;
     bool        jdwpServer;
     char*       jdwpHost;
     int         jdwpPort;
diff --git a/vm/Hash.c b/vm/Hash.cpp
similarity index 100%
rename from vm/Hash.c
rename to vm/Hash.cpp
diff --git a/vm/IndirectRefTable.c b/vm/IndirectRefTable.cpp
similarity index 100%
rename from vm/IndirectRefTable.c
rename to vm/IndirectRefTable.cpp
diff --git a/vm/Init.c b/vm/Init.cpp
similarity index 99%
rename from vm/Init.c
rename to vm/Init.cpp
index a8cf258..9019157 100644
--- a/vm/Init.c
+++ b/vm/Init.cpp
@@ -17,11 +17,7 @@
 /*
  * Dalvik initialization, shutdown, and command-line argument processing.
  */
-#include "Dalvik.h"
-#include "test/Test.h"
-#include "mterp/Mterp.h"
-#include "Hash.h"
-
+#define __STDC_LIMIT_MACROS
 #include <stdlib.h>
 #include <stdio.h>
 #include <signal.h>
@@ -30,6 +26,11 @@
 #include <sys/wait.h>
 #include <unistd.h>
 
+#include "Dalvik.h"
+#include "test/Test.h"
+#include "mterp/Mterp.h"
+#include "Hash.h"
+
 #define kMinHeapStartSize   (1*1024*1024)
 #define kMinHeapSize        (2*1024*1024)
 #define kMaxHeapSize        (1*1024*1024*1024)
@@ -37,7 +38,7 @@
 /*
  * Register VM-agnostic native methods for system classes.
  */
-extern int jniRegisterSystemMethods(JNIEnv* env);
+extern "C" int jniRegisterSystemMethods(JNIEnv* env);
 
 /* fwd */
 static bool registerSystemNatives(JNIEnv* pEnv);
@@ -1332,7 +1333,7 @@
 
 #ifndef NDEBUG
     if (!dvmTestHash())
-        LOGE("dmvTestHash FAILED\n");
+        LOGE("dvmTestHash FAILED\n");
     if (false /*noisy!*/ && !dvmTestIndirectRefTable())
         LOGE("dvmTestIndirectRefTable FAILED\n");
 #endif
diff --git a/vm/InitRefs.c b/vm/InitRefs.cpp
similarity index 100%
rename from vm/InitRefs.c
rename to vm/InitRefs.cpp
diff --git a/vm/InlineNative.c b/vm/InlineNative.cpp
similarity index 97%
rename from vm/InlineNative.c
rename to vm/InlineNative.cpp
index f230c12..cd978aa 100644
--- a/vm/InlineNative.c
+++ b/vm/InlineNative.cpp
@@ -27,7 +27,7 @@
 //#warning "trying memcmp16"
 //#define CHECK_MEMCMP16
 /* "count" is in 16-bit units */
-extern u4 __memcmp16(const u2* s0, const u2* s1, size_t count);
+extern "C" u4 __memcmp16(const u2* s0, const u2* s1, size_t count);
 #endif
 
 /*
@@ -146,7 +146,7 @@
         chars = (ArrayObject*)
             dvmGetFieldObject((Object*) arg0, STRING_FIELDOFF_VALUE);
 
-        pResult->i = ((const u2*) chars->contents)[arg1 + offset];
+        pResult->i = ((const u2*)(void*)chars->contents)[arg1 + offset];
         return true;
     }
 }
@@ -238,8 +238,8 @@
         dvmGetFieldObject((Object*) arg0, STRING_FIELDOFF_VALUE);
     compArray = (ArrayObject*)
         dvmGetFieldObject((Object*) arg1, STRING_FIELDOFF_VALUE);
-    thisChars = ((const u2*) thisArray->contents) + thisOffset;
-    compChars = ((const u2*) compArray->contents) + compOffset;
+    thisChars = ((const u2*)(void*)thisArray->contents) + thisOffset;
+    compChars = ((const u2*)(void*)compArray->contents) + compOffset;
 
 #ifdef HAVE__MEMCMP16
     /*
@@ -359,8 +359,8 @@
         dvmGetFieldObject((Object*) arg0, STRING_FIELDOFF_VALUE);
     compArray = (ArrayObject*)
         dvmGetFieldObject((Object*) arg1, STRING_FIELDOFF_VALUE);
-    thisChars = ((const u2*) thisArray->contents) + thisOffset;
-    compChars = ((const u2*) compArray->contents) + compOffset;
+    thisChars = ((const u2*)(void*)thisArray->contents) + thisOffset;
+    compChars = ((const u2*)(void*)compArray->contents) + compOffset;
 
 #ifdef HAVE__MEMCMP16
     pResult->i = (__memcmp16(thisChars, compChars, thisCount) == 0);
@@ -452,7 +452,7 @@
     /* pull out the basic elements */
     ArrayObject* charArray =
         (ArrayObject*) dvmGetFieldObject(strObj, STRING_FIELDOFF_VALUE);
-    const u2* chars = (const u2*) charArray->contents;
+    const u2* chars = (const u2*)(void*)charArray->contents;
     int offset = dvmGetFieldInt(strObj, STRING_FIELDOFF_OFFSET);
     int count = dvmGetFieldInt(strObj, STRING_FIELDOFF_COUNT);
     //LOGI("String.indexOf(0x%08x, 0x%04x, %d) off=%d count=%d\n",
diff --git a/vm/Inlines.c b/vm/Inlines.cpp
similarity index 100%
rename from vm/Inlines.c
rename to vm/Inlines.cpp
diff --git a/vm/Intern.c b/vm/Intern.cpp
similarity index 100%
rename from vm/Intern.c
rename to vm/Intern.cpp
diff --git a/vm/JarFile.c b/vm/JarFile.cpp
similarity index 99%
rename from vm/JarFile.c
rename to vm/JarFile.cpp
index f26f1d6..0288fef 100644
--- a/vm/JarFile.c
+++ b/vm/JarFile.cpp
@@ -119,7 +119,7 @@
         LOGV("dvmDexCacheStatus: Checking cache for %s\n", fileName);
         cachedName = dexOptGenerateCacheFileName(fileName, kDexInJarName);
         if (cachedName == NULL)
-            return -1;
+            return DEX_CACHE_BAD_ARCHIVE;
 
         fd = dvmOpenCachedDexFile(fileName, cachedName,
                 dexGetZipEntryModTime(&archive, entry),
diff --git a/vm/LinearAlloc.c b/vm/LinearAlloc.cpp
similarity index 100%
rename from vm/LinearAlloc.c
rename to vm/LinearAlloc.cpp
diff --git a/vm/Misc.c b/vm/Misc.cpp
similarity index 100%
rename from vm/Misc.c
rename to vm/Misc.cpp
diff --git a/vm/Misc.h b/vm/Misc.h
index 8981824..c1ab72c 100644
--- a/vm/Misc.h
+++ b/vm/Misc.h
@@ -90,17 +90,19 @@
 #endif
 }
 
+typedef enum {
+    kDebugTargetUnknown = 0,
+    kDebugTargetLog,
+    kDebugTargetFile,
+} DebugTargetKind;
+
 /*
  * We pass one of these around when we want code to be able to write debug
  * info to either the log or to a file (or stdout/stderr).
  */
 typedef struct DebugOutputTarget {
     /* where to? */
-    enum {
-        kDebugTargetUnknown = 0,
-        kDebugTargetLog,
-        kDebugTargetFile,
-    } which;
+    DebugTargetKind which;
 
     /* additional bits */
     union {
diff --git a/vm/Native.c b/vm/Native.cpp
similarity index 97%
rename from vm/Native.c
rename to vm/Native.cpp
index a06bf3c..58963f5 100644
--- a/vm/Native.c
+++ b/vm/Native.cpp
@@ -71,7 +71,6 @@
     const Method* method, Thread* self)
 {
     ClassObject* clazz = method->clazz;
-    void* func;
 
     /*
      * If this is a static method, it could be called before the class
@@ -88,8 +87,8 @@
     }
 
     /* start with our internal-native methods */
-    func = dvmLookupInternalNativeMethod(method);
-    if (func != NULL) {
+    DalvikNativeFunc infunc = dvmLookupInternalNativeMethod(method);
+    if (infunc != NULL) {
         /* resolution always gets the same answer, so no race here */
         IF_LOGVV() {
             char* desc = dexProtoCopyMethodDescriptor(&method->prototype);
@@ -102,14 +101,14 @@
             LOGE("Failing on %s.%s\n", method->clazz->descriptor, method->name);
             dvmAbort();     // harsh, but this is VM-internal problem
         }
-        DalvikBridgeFunc dfunc = (DalvikBridgeFunc) func;
+        DalvikBridgeFunc dfunc = (DalvikBridgeFunc) infunc;
         dvmSetNativeFunc((Method*) method, dfunc, NULL);
         dfunc(args, pResult, method, self);
         return;
     }
 
     /* now scan any DLLs we have loaded for JNI signatures */
-    func = lookupSharedLibMethod(method);
+    void* func = lookupSharedLibMethod(method);
     if (func != NULL) {
         /* found it, point it at the JNI bridge and then call it */
         dvmUseJNIBridge((Method*) method, func);
@@ -580,27 +579,22 @@
  */
 static char* mangleString(const char* str, int len)
 {
-    u2* utf16 = NULL;
-    char* mangle = NULL;
-    int charLen;
-
     //LOGI("mangling '%s' %d\n", str, len);
 
     assert(str[len] == '\0');
 
-    charLen = dvmUtf8Len(str);
-    utf16 = (u2*) malloc(sizeof(u2) * charLen);
+    size_t charLen = dvmUtf8Len(str);
+    u2* utf16 = (u2*) malloc(sizeof(u2) * charLen);
     if (utf16 == NULL)
-        goto bail;
+        return NULL;
 
     dvmConvertUtf8ToUtf16(utf16, str);
 
     /*
      * Compute the length of the mangled string.
      */
-    int i, mangleLen = 0;
-
-    for (i = 0; i < charLen; i++) {
+    size_t mangleLen = 0;
+    for (size_t i = 0; i < charLen; i++) {
         u2 ch = utf16[i];
 
         if (ch == '$' || ch > 127) {
@@ -619,13 +613,14 @@
         }
     }
 
-    char* cp;
+    char* mangle = (char*) malloc(mangleLen +1);
+    if (mangle == NULL) {
+        free(utf16);
+        return NULL;
+    }
 
-    mangle = (char*) malloc(mangleLen +1);
-    if (mangle == NULL)
-        goto bail;
-
-    for (i = 0, cp = mangle; i < charLen; i++) {
+    char* cp = mangle;
+    for (size_t i = 0; i < charLen; i++) {
         u2 ch = utf16[i];
 
         if (ch == '$' || ch > 127) {
@@ -657,7 +652,6 @@
 
     *cp = '\0';
 
-bail:
     free(utf16);
     return mangle;
 }
diff --git a/vm/PointerSet.c b/vm/PointerSet.cpp
similarity index 100%
rename from vm/PointerSet.c
rename to vm/PointerSet.cpp
diff --git a/vm/Profile.c b/vm/Profile.cpp
similarity index 100%
rename from vm/Profile.c
rename to vm/Profile.cpp
diff --git a/vm/Properties.c b/vm/Properties.cpp
similarity index 100%
rename from vm/Properties.c
rename to vm/Properties.cpp
diff --git a/vm/RawDexFile.c b/vm/RawDexFile.cpp
similarity index 100%
rename from vm/RawDexFile.c
rename to vm/RawDexFile.cpp
diff --git a/vm/ReferenceTable.c b/vm/ReferenceTable.cpp
similarity index 100%
rename from vm/ReferenceTable.c
rename to vm/ReferenceTable.cpp
diff --git a/vm/SignalCatcher.c b/vm/SignalCatcher.cpp
similarity index 98%
rename from vm/SignalCatcher.c
rename to vm/SignalCatcher.cpp
index c8f9833..a8fc59d 100644
--- a/vm/SignalCatcher.c
+++ b/vm/SignalCatcher.cpp
@@ -178,7 +178,7 @@
          * We don't know how long it will take to do the disk I/O, so put us
          * into VMWAIT for the duration.
          */
-        int oldStatus = dvmChangeStatus(dvmThreadSelf(), THREAD_VMWAIT);
+        ThreadStatus oldStatus = dvmChangeStatus(dvmThreadSelf(), THREAD_VMWAIT);
 
         /*
          * Open the stack trace output file, creating it if necessary.  It
diff --git a/vm/StdioConverter.c b/vm/StdioConverter.cpp
similarity index 100%
rename from vm/StdioConverter.c
rename to vm/StdioConverter.cpp
diff --git a/vm/Sync.c b/vm/Sync.cpp
similarity index 99%
rename from vm/Sync.c
rename to vm/Sync.cpp
index 73f7d1c..fc6233b 100644
--- a/vm/Sync.c
+++ b/vm/Sync.cpp
@@ -84,7 +84,7 @@
      * Who last acquired this monitor, when lock sampling is enabled.
      * Even when enabled, ownerFileName may be NULL.
      */
-    char*       ownerFileName;
+    const char* ownerFileName;
     u4          ownerLineNumber;
 };
 
@@ -617,7 +617,7 @@
     bool wasInterrupted = false;
     bool timed;
     int ret;
-    char *savedFileName;
+    const char *savedFileName;
     u4 savedLineNumber;
 
     assert(self != NULL);
diff --git a/vm/Thread.c b/vm/Thread.cpp
similarity index 98%
rename from vm/Thread.c
rename to vm/Thread.cpp
index 62f95aa..1754e0d 100644
--- a/vm/Thread.c
+++ b/vm/Thread.cpp
@@ -384,8 +384,7 @@
         self->status = THREAD_VMWAIT;
     } else {
         /* happens during VM shutdown */
-        //LOGW("NULL self in dvmLockThreadList\n");
-        oldStatus = -1;         // shut up gcc
+        oldStatus = THREAD_UNDEFINED;  // shut up gcc
     }
 
     dvmLockMutex(&gDvm.threadListLock);
@@ -1232,16 +1231,10 @@
  */
 bool dvmCreateInterpThread(Object* threadObj, int reqStackSize)
 {
-    pthread_attr_t threadAttr;
-    pthread_t threadHandle;
-    Thread* self;
-    Thread* newThread = NULL;
-    Object* vmThreadObj = NULL;
-    int stackSize;
-
     assert(threadObj != NULL);
 
-    self = dvmThreadSelf();
+    Thread* self = dvmThreadSelf();
+    int stackSize;
     if (reqStackSize == 0)
         stackSize = gDvm.stackSize;
     else if (reqStackSize < kMinStackSize)
@@ -1251,6 +1244,7 @@
     else
         stackSize = reqStackSize;
 
+    pthread_attr_t threadAttr;
     pthread_attr_init(&threadAttr);
     pthread_attr_setdetachstate(&threadAttr, PTHREAD_CREATE_DETACHED);
 
@@ -1258,13 +1252,16 @@
      * To minimize the time spent in the critical section, we allocate the
      * vmThread object here.
      */
-    vmThreadObj = dvmAllocObject(gDvm.classJavaLangVMThread, ALLOC_DEFAULT);
+    Object* vmThreadObj = dvmAllocObject(gDvm.classJavaLangVMThread, ALLOC_DEFAULT);
     if (vmThreadObj == NULL)
-        goto fail;
+        return false;
 
-    newThread = allocThread(stackSize);
-    if (newThread == NULL)
-        goto fail;
+    Thread* newThread = allocThread(stackSize);
+    if (newThread == NULL) {
+        dvmReleaseTrackedAlloc(vmThreadObj, NULL);
+        return false;
+    }
+
     newThread->threadObj = threadObj;
 
     assert(newThread->status == THREAD_INITIALIZING);
@@ -1282,7 +1279,8 @@
         dvmUnlockThreadList();
         dvmThrowIllegalThreadStateException(
             "thread has already been started");
-        goto fail;
+        freeThread(newThread);
+        dvmReleaseTrackedAlloc(vmThreadObj, NULL);
     }
 
     /*
@@ -1302,9 +1300,10 @@
     dvmUnlockThreadList();
 
     ThreadStatus oldStatus = dvmChangeStatus(self, THREAD_VMWAIT);
+    pthread_t threadHandle;
     int cc = pthread_create(&threadHandle, &threadAttr, interpThreadStart,
-            newThread);
-    oldStatus = dvmChangeStatus(self, oldStatus);
+                            newThread);
+    dvmChangeStatus(self, oldStatus);
 
     if (cc != 0) {
         /*
@@ -1721,7 +1720,7 @@
 
     jniArgs.version = JNI_VERSION_1_2;
     jniArgs.name = pArgs->name;
-    jniArgs.group = pArgs->group;
+    jniArgs.group = reinterpret_cast<jobject>(pArgs->group);
 
     setThreadName(pArgs->name);
 
@@ -2096,7 +2095,9 @@
      * parallel with us from here out.  It's important to do this if
      * profiling is enabled, since we can wait indefinitely.
      */
-    android_atomic_release_store(THREAD_VMWAIT, &self->status);
+    volatile void* raw = reinterpret_cast<volatile void*>(&self->status);
+    volatile int32_t* addr = reinterpret_cast<volatile int32_t*>(raw);
+    android_atomic_release_store(THREAD_VMWAIT, addr);
 
     /*
      * If we're doing method trace profiling, we don't want threads to exit,
@@ -2964,7 +2965,9 @@
          * the thread is supposed to be suspended.  This is possibly faster
          * on SMP and slightly more correct, but less convenient.
          */
-        android_atomic_acquire_store(newStatus, &self->status);
+        volatile void* raw = reinterpret_cast<volatile void*>(&self->status);
+        volatile int32_t* addr = reinterpret_cast<volatile int32_t*>(raw);
+        android_atomic_acquire_store(newStatus, addr);
         if (self->interpBreak.ctl.suspendCount != 0) {
             fullSuspendCheck(self);
         }
@@ -2977,7 +2980,9 @@
          * will be observed before the state change.
          */
         assert(newStatus != THREAD_SUSPENDED);
-        android_atomic_release_store(newStatus, &self->status);
+        volatile void* raw = reinterpret_cast<volatile void*>(&self->status);
+        volatile int32_t* addr = reinterpret_cast<volatile int32_t*>(raw);
+        android_atomic_release_store(newStatus, addr);
     }
 
     return oldStatus;
diff --git a/vm/UtfString.c b/vm/UtfString.cpp
similarity index 93%
rename from vm/UtfString.c
rename to vm/UtfString.cpp
index ec35cdf..4b541b1 100644
--- a/vm/UtfString.c
+++ b/vm/UtfString.cpp
@@ -104,9 +104,10 @@
  * (If this needs optimizing, try: mask against 0xa0, shift right 5,
  * get increment {1-3} from table of 8 values.)
  */
-int dvmUtf8Len(const char* utf8Str)
+size_t dvmUtf8Len(const char* utf8Str)
 {
-    int ic, len = 0;
+    size_t len = 0;
+    int ic;
 
     while ((ic = *utf8Str++) != '\0') {
         len++;
@@ -193,7 +194,7 @@
 /*
  * Use the java/lang/String.computeHashCode() algorithm.
  */
-static inline u4 dvmComputeUtf16Hash(const u2* utf16Str, int len)
+static inline u4 computeUtf16Hash(const u2* utf16Str, size_t len)
 {
     u4 hash = 0;
 
@@ -202,6 +203,7 @@
 
     return hash;
 }
+
 u4 dvmComputeStringHash(const StringObject* strObj) {
     ArrayObject* chars = (ArrayObject*) dvmGetFieldObject((Object*) strObj,
                                 STRING_FIELDOFF_VALUE);
@@ -210,7 +212,7 @@
     len = dvmGetFieldInt((Object*) strObj, STRING_FIELDOFF_COUNT);
     offset = dvmGetFieldInt((Object*) strObj, STRING_FIELDOFF_OFFSET);
 
-    return dvmComputeUtf16Hash((u2*) chars->contents + offset, len);
+    return computeUtf16Hash((u2*)(void*)chars->contents + offset, len);
 }
 
 /*
@@ -235,7 +237,7 @@
  * Returns NULL and throws an exception on failure.
  */
 StringObject* dvmCreateStringFromCstrAndLength(const char* utf8Str,
-    u4 utf16Length)
+    size_t utf16Length)
 {
     assert(utf8Str != NULL);
 
@@ -245,9 +247,9 @@
         return NULL;
     }
 
-    dvmConvertUtf8ToUtf16((u2*) chars->contents, utf8Str);
+    dvmConvertUtf8ToUtf16((u2*)(void*)chars->contents, utf8Str);
 
-    u4 hashCode = dvmComputeUtf16Hash((u2*) chars->contents, utf16Length);
+    u4 hashCode = computeUtf16Hash((u2*)(void*)chars->contents, utf16Length);
     dvmSetFieldInt((Object*) newObj, STRING_FIELDOFF_HASHCODE, hashCode);
 
     return newObj;
@@ -269,7 +271,7 @@
 
     if (len > 0) memcpy(chars->contents, unichars, len * sizeof(u2));
 
-    u4 hashCode = dvmComputeUtf16Hash((u2*) chars->contents, len);
+    u4 hashCode = computeUtf16Hash((u2*)(void*)chars->contents, len);
     dvmSetFieldInt((Object*)newObj, STRING_FIELDOFF_HASHCODE, hashCode);
 
     return newObj;
@@ -296,7 +298,7 @@
     offset = dvmGetFieldInt((Object*) jstr, STRING_FIELDOFF_OFFSET);
     chars = (ArrayObject*) dvmGetFieldObject((Object*) jstr,
                                 STRING_FIELDOFF_VALUE);
-    data = (const u2*) chars->contents + offset;
+    data = (const u2*)(void*)chars->contents + offset;
     assert(offset + len <= (int) chars->length);
 
     byteLen = utf16_utf8ByteLen(data, len);
@@ -341,7 +343,7 @@
     offset = dvmGetFieldInt((Object*) jstr, STRING_FIELDOFF_OFFSET);
     chars = (ArrayObject*) dvmGetFieldObject((Object*) jstr,
                                 STRING_FIELDOFF_VALUE);
-    data = (const u2*) chars->contents + offset;
+    data = (const u2*)(void*)chars->contents + offset;
     assert(offset + len <= (int) chars->length);
 
     return utf16_utf8ByteLen(data, len);
@@ -375,7 +377,7 @@
     offset = dvmGetFieldInt((Object*) jstr, STRING_FIELDOFF_OFFSET);
     chars = (ArrayObject*) dvmGetFieldObject((Object*) jstr,
                                 STRING_FIELDOFF_VALUE);
-    return (const u2*) chars->contents + offset;
+    return (const u2*)(void*)chars->contents + offset;
 }
 
 
@@ -413,8 +415,8 @@
     assert(offset1 + len1 <= (int) chars1->length);
     assert(offset2 + len2 <= (int) chars2->length);
 
-    return memcmp((const u2*) chars1->contents + offset1,
-                  (const u2*) chars2->contents + offset2,
+    return memcmp((const u2*)(void*)chars1->contents + offset1,
+                  (const u2*)(void*)chars2->contents + offset2,
                   len1 * sizeof(u2));
 }
 
@@ -437,8 +439,7 @@
     /*
      * Create the individual String objects and add them to the array.
      */
-    size_t i;
-    for (i = 0; i < count; i++) {
+    for (size_t i = 0; i < count; i++) {
         Object* str =
             (Object*) dvmCreateStringFromCstr(strings[i]);
         if (str == NULL) {
diff --git a/vm/UtfString.h b/vm/UtfString.h
index a1ee712..6b9a5e3 100644
--- a/vm/UtfString.h
+++ b/vm/UtfString.h
@@ -93,7 +93,7 @@
  * Compute the number of characters in a "modified UTF-8" string.  This will
  * match the result from strlen() so long as there are no multi-byte chars.
  */
-int dvmUtf8Len(const char* utf8Str);
+size_t dvmUtf8Len(const char* utf8Str);
 
 /*
  * Convert a UTF-8 string to UTF-16.  "utf16Str" must have enough room
diff --git a/vm/jdwp/JdwpAdb.cpp b/vm/jdwp/JdwpAdb.cpp
index e73814d..3376910 100644
--- a/vm/jdwp/JdwpAdb.cpp
+++ b/vm/jdwp/JdwpAdb.cpp
@@ -163,7 +163,7 @@
     cmsg->cmsg_len   = msg.msg_controllen;
     cmsg->cmsg_level = SOL_SOCKET;
     cmsg->cmsg_type  = SCM_RIGHTS;
-    ((int*)CMSG_DATA(cmsg))[0] = -1;
+    ((int*)(void*)CMSG_DATA(cmsg))[0] = -1;
 
     do {
         ret = recvmsg(netState->controlSock, &msg, 0);
@@ -181,7 +181,7 @@
         return -1;
     }
 
-    return ((int*)CMSG_DATA(cmsg))[0];
+    return ((int*)(void*)CMSG_DATA(cmsg))[0];
 }
 
 /*
diff --git a/vm/mterp/Mterp.c b/vm/mterp/Mterp.cpp
similarity index 100%
rename from vm/mterp/Mterp.c
rename to vm/mterp/Mterp.cpp
diff --git a/vm/mterp/common/FindInterface.h b/vm/mterp/common/FindInterface.h
index 021ed65..a640adb 100644
--- a/vm/mterp/common/FindInterface.h
+++ b/vm/mterp/common/FindInterface.h
@@ -17,6 +17,10 @@
 /* common includes */
 #include "Dalvik.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
  * Look up an interface on a class using the cache.
  *
@@ -35,3 +39,7 @@
 
 #undef ATOMIC_CACHE_CALC
 }
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/vm/test/AtomicTest.c b/vm/test/AtomicTest.cpp
similarity index 100%
rename from vm/test/AtomicTest.c
rename to vm/test/AtomicTest.cpp
diff --git a/vm/test/TestHash.c b/vm/test/TestHash.cpp
similarity index 93%
rename from vm/test/TestHash.c
rename to vm/test/TestHash.cpp
index 431e62a..b458028 100644
--- a/vm/test/TestHash.c
+++ b/vm/test/TestHash.cpp
@@ -141,7 +141,7 @@
     hash = 0;
 
     /* two entries, same hash, different values */
-    char* str1;
+    const char* str1;
     str1 = (char*) dvmHashTableLookup(pTab, hash, strdup("one"),
             (HashCompareFunc) strcmp, true);
     assert(str1 != NULL);
@@ -149,10 +149,10 @@
             (HashCompareFunc) strcmp, true);
 
     /* remove the first one */
-    if (!dvmHashTableRemove(pTab, hash, str1))
+    if (!dvmHashTableRemove(pTab, hash, (void*)str1))
         LOGE("TestHash failed to delete item\n");
     else
-        free(str1);     // "Remove" doesn't call the free func
+        free((void*)str1);     // "Remove" doesn't call the free func
 
     /* make sure iterator doesn't included deleted entries */
     int count = 0;
@@ -167,11 +167,11 @@
     }
 
     /* see if we can find them */
-    str = (const char*) dvmHashTableLookup(pTab, hash, "one",
+    str = (const char*) dvmHashTableLookup(pTab, hash, (void*)"one",
             (HashCompareFunc) strcmp,false);
     if (str != NULL)
         LOGE("TestHash deleted entry has returned!");
-    str = (const char*) dvmHashTableLookup(pTab, hash, "two",
+    str = (const char*) dvmHashTableLookup(pTab, hash, (void*)"two",
             (HashCompareFunc) strcmp,false);
     if (str == NULL)
         LOGE("TestHash entry vanished\n");
diff --git a/vm/test/TestIndirectRefTable.c b/vm/test/TestIndirectRefTable.cpp
similarity index 100%
rename from vm/test/TestIndirectRefTable.c
rename to vm/test/TestIndirectRefTable.cpp