diff --git a/vm/AllocTracker.c b/vm/AllocTracker.c
index d371fd1..8e2c325 100644
--- a/vm/AllocTracker.c
+++ b/vm/AllocTracker.c
@@ -155,7 +155,7 @@
         const StackSaveArea* saveArea = SAVEAREA_FROM_FP(fp);
         const Method* method = saveArea->method;
 
-        if (!dvmIsBreakFrame(fp)) {
+        if (!dvmIsBreakFrame((u4*) fp)) {
             pRec->stackElem[stackDepth].method = method;
             if (dvmIsNativeMethod(method)) {
                 pRec->stackElem[stackDepth].pc = 0;
diff --git a/vm/CheckJni.c b/vm/CheckJni.c
index f8815fb..1ff763a 100644
--- a/vm/CheckJni.c
+++ b/vm/CheckJni.c
@@ -1056,7 +1056,7 @@
     uLong adler = 0;
     if (!modOkay) {
         adler = adler32(0L, Z_NULL, 0);
-        adler = adler32(adler, buf, len);
+        adler = adler32(adler, (const Bytef*)buf, len);
         *(uLong*)newBuf = adler;
     }
 
@@ -1142,7 +1142,7 @@
      */
     if (!modOkay) {
         uLong adler = adler32(0L, Z_NULL, 0);
-        adler = adler32(adler, dataBuf, len);
+        adler = adler32(adler, (const Bytef*)dataBuf, len);
         if (pExtra->adler != adler) {
             LOGE("JNI: buffer modified (0x%08lx vs 0x%08lx) at addr %p",
                 pExtra->adler, adler, dataBuf);
@@ -1804,7 +1804,7 @@
         CHECK_EXIT(env);                                                    \
         return _retok;                                                      \
     }
-CALL_VIRTUAL(jobject, Object, Object* result, result=, result, 'L');
+CALL_VIRTUAL(jobject, Object, Object* result, result=(Object*), result, 'L');
 CALL_VIRTUAL(jboolean, Boolean, jboolean result, result=, result, 'Z');
 CALL_VIRTUAL(jbyte, Byte, jbyte result, result=, result, 'B');
 CALL_VIRTUAL(jchar, Char, jchar result, result=, result, 'C');
@@ -1870,7 +1870,7 @@
         CHECK_EXIT(env);                                                    \
         return _retok;                                                      \
     }
-CALL_NONVIRTUAL(jobject, Object, Object* result, result=, result, 'L');
+CALL_NONVIRTUAL(jobject, Object, Object* result, result=(Object*), result, 'L');
 CALL_NONVIRTUAL(jboolean, Boolean, jboolean result, result=, result, 'Z');
 CALL_NONVIRTUAL(jbyte, Byte, jbyte result, result=, result, 'B');
 CALL_NONVIRTUAL(jchar, Char, jchar result, result=, result, 'C');
@@ -1933,7 +1933,7 @@
         CHECK_EXIT(env);                                                    \
         return _retok;                                                      \
     }
-CALL_STATIC(jobject, Object, Object* result, result=, result, 'L');
+CALL_STATIC(jobject, Object, Object* result, result=(Object*), result, 'L');
 CALL_STATIC(jboolean, Boolean, jboolean result, result=, result, 'Z');
 CALL_STATIC(jbyte, Byte, jbyte result, result=, result, 'B');
 CALL_STATIC(jchar, Char, jchar result, result=, result, 'C');
@@ -1973,7 +1973,7 @@
     result = BASE_ENV(env)->GetStringChars(env, string, isCopy);
     if (((JNIEnvExt*)env)->forceDataCopy && result != NULL) {
         // TODO: fix for indirect
-        int len = dvmStringLen(string) * 2;
+        int len = dvmStringLen((StringObject*) string) * 2;
         result = (const jchar*) createGuardedCopy(result, len, false);
         if (isCopy != NULL)
             *isCopy = JNI_TRUE;
@@ -2029,7 +2029,7 @@
     result = BASE_ENV(env)->GetStringUTFChars(env, string, isCopy);
     if (((JNIEnvExt*)env)->forceDataCopy && result != NULL) {
         // TODO: fix for indirect
-        int len = dvmStringUtf8ByteLen(string) + 1;
+        int len = dvmStringUtf8ByteLen((StringObject*) string) + 1;
         result = (const char*) createGuardedCopy(result, len, false);
         if (isCopy != NULL)
             *isCopy = JNI_TRUE;
@@ -2296,7 +2296,7 @@
     result = BASE_ENV(env)->GetStringCritical(env, string, isCopy);
     if (((JNIEnvExt*)env)->forceDataCopy && result != NULL) {
         // TODO: fix for indirect
-        int len = dvmStringLen(string) * 2;
+        int len = dvmStringLen((StringObject*) string) * 2;
         result = (const jchar*) createGuardedCopy(result, len, false);
         if (isCopy != NULL)
             *isCopy = JNI_TRUE;
diff --git a/vm/Debugger.c b/vm/Debugger.c
index d5215ca..98bd86d 100644
--- a/vm/Debugger.c
+++ b/vm/Debugger.c
@@ -355,9 +355,9 @@
 {
     return (FrameId)(u4) frame;
 }
-static void* frameIdToFrame(FrameId id)
+static u4* frameIdToFrame(FrameId id)
 {
-    return (void*)(u4) id;
+    return (u4*)(u4) id;
 }
 
 
@@ -581,7 +581,8 @@
 
     dvmHashTableLock(gDvm.loadedClasses);
     *pNumClasses = dvmHashTableNumEntries(gDvm.loadedClasses);
-    pRefType = *pClassRefBuf = malloc(sizeof(RefTypeId) * *pNumClasses);
+    pRefType = *pClassRefBuf =
+        (RefTypeId*)malloc(sizeof(RefTypeId) * *pNumClasses);
 
     if (dvmHashForeach(gDvm.loadedClasses, copyRefType, &pRefType) != 0) {
         LOGW("Warning: problem getting class list\n");
@@ -615,7 +616,7 @@
 
     /* over-allocate the return buffer */
     maxClasses = dvmHashTableNumEntries(gDvm.loadedClasses);
-    *pClassRefBuf = malloc(sizeof(RefTypeId) * maxClasses);
+    *pClassRefBuf = (RefTypeId*)malloc(sizeof(RefTypeId) * maxClasses);
 
     /*
      * Run through the list, looking for matches.
@@ -2137,7 +2138,7 @@
 
     framePtr = thread->curFrame;
     while (framePtr != NULL) {
-        if (!dvmIsBreakFrame(framePtr))
+        if (!dvmIsBreakFrame((u4*)framePtr))
             count++;
 
         framePtr = SAVEAREA_FROM_FP(framePtr)->prevFrame;
@@ -2173,7 +2174,7 @@
         const StackSaveArea* saveArea = SAVEAREA_FROM_FP(framePtr);
         const Method* method = saveArea->method;
 
-        if (!dvmIsBreakFrame(framePtr)) {
+        if (!dvmIsBreakFrame((u4*)framePtr)) {
             if (count == num) {
                 *pFrameId = frameToFrameId(framePtr);
                 if (dvmIsInterfaceClass(method->clazz))
@@ -2553,7 +2554,7 @@
     }
 
     /* need this for InstanceOnly filters */
-    Object* thisObj = getThisObject(throwFp);
+    Object* thisObj = getThisObject((u4*)throwFp);
 
     /*
      * Hand the event to the JDWP exception handler.  Note we're using the
@@ -2826,8 +2827,10 @@
     *pResultTag = targetThread->invokeReq.resultTag;
     if (isTagPrimitive(targetThread->invokeReq.resultTag))
         *pResultValue = targetThread->invokeReq.resultValue.j;
-    else
-        *pResultValue = objectToObjectId(targetThread->invokeReq.resultValue.l);
+    else {
+        Object* tmpObj = (Object*)targetThread->invokeReq.resultValue.l;
+        *pResultValue = objectToObjectId(tmpObj);
+    }
     *pExceptObj = targetThread->invokeReq.exceptObj;
     err = targetThread->invokeReq.err;
 
@@ -2908,7 +2911,7 @@
         pReq->resultValue.j = 0; /*0xadadadad;*/
     } else if (pReq->resultTag == JT_OBJECT) {
         /* if no exception thrown, examine object result more closely */
-        u1 newTag = resultTagFromObject(pReq->resultValue.l);
+        u1 newTag = resultTagFromObject((Object*)pReq->resultValue.l);
         if (newTag != pReq->resultTag) {
             LOGVV("  JDWP promoted result from %d to %d\n",
                 pReq->resultTag, newTag);
@@ -2924,7 +2927,7 @@
          * We can't use the "tracked allocation" mechanism here because
          * the object is going to be handed off to a different thread.
          */
-        (void) objectToObjectId(pReq->resultValue.l);
+        (void) objectToObjectId((Object*)pReq->resultValue.l);
     }
 
     if (oldExcept != NULL) {
@@ -2978,7 +2981,7 @@
     u4 insnsSize = dvmGetMethodInsnsSize(method);
     AddressSetContext context;
 
-    result = calloc(1, sizeof(AddressSet) + (insnsSize/8) + 1);
+    result = (AddressSet*)calloc(1, sizeof(AddressSet) + (insnsSize/8) + 1);
     result->setSize = insnsSize;
 
     memset(&context, 0, sizeof(context));
diff --git a/vm/Dvm.mk b/vm/Dvm.mk
index 554ba70..140372d 100644
--- a/vm/Dvm.mk
+++ b/vm/Dvm.mk
@@ -26,7 +26,7 @@
 #
 LOCAL_CFLAGS += -fstrict-aliasing -Wstrict-aliasing=2 -fno-align-jumps
 #LOCAL_CFLAGS += -DUSE_INDIRECT_REF
-LOCAL_CFLAGS += -Wall -Wextra -Wno-unused-parameter
+LOCAL_CFLAGS += -Wall -Wextra -Wno-unused-parameter -Wc++-compat
 LOCAL_CFLAGS += -DARCH_VARIANT=\"$(dvm_arch_variant)\"
 
 #
diff --git a/vm/DvmDex.c b/vm/DvmDex.c
index 94422b3..500bf42 100644
--- a/vm/DvmDex.c
+++ b/vm/DvmDex.c
@@ -121,7 +121,7 @@
         goto bail;
     }
 
-    pDexFile = dexFileParse(memMap.addr, memMap.length, parseFlags);
+    pDexFile = dexFileParse((u1*)memMap.addr, memMap.length, parseFlags);
     if (pDexFile == NULL) {
         LOGE("DEX parse failed\n");
         sysReleaseShmem(&memMap);
@@ -164,7 +164,7 @@
         parseFlags |= kDexParseVerifyChecksum;
     */
 
-    pDexFile = dexFileParse(addr, len, parseFlags);
+    pDexFile = dexFileParse((u1*)addr, len, parseFlags);
     if (pDexFile == NULL) {
         LOGE("DEX parse failed\n");
         goto bail;
diff --git a/vm/Exception.c b/vm/Exception.c
index b4b7160..deb399e 100644
--- a/vm/Exception.c
+++ b/vm/Exception.c
@@ -897,7 +897,7 @@
          * if this was a native method.
          */
         assert(saveArea->prevFrame != NULL);
-        if (dvmIsBreakFrame(saveArea->prevFrame)) {
+        if (dvmIsBreakFrame((u4*)saveArea->prevFrame)) {
             if (!scanOnly)
                 break;      // bail with catchAddr == -1
 
@@ -914,7 +914,7 @@
             saveArea = SAVEAREA_FROM_FP(fp);
             fp = saveArea->prevFrame;           // this may be a good one
             while (fp != NULL) {
-                if (!dvmIsBreakFrame(fp)) {
+                if (!dvmIsBreakFrame((u4*)fp)) {
                     saveArea = SAVEAREA_FROM_FP(fp);
                     if (!dvmIsNativeMethod(saveArea->method))
                         break;
@@ -1001,7 +1001,7 @@
         const StackSaveArea* saveArea = SAVEAREA_FROM_FP(fp);
         const Method* method = saveArea->method;
 
-        if (dvmIsBreakFrame(fp))
+        if (dvmIsBreakFrame((u4*)fp))
             break;
         if (!dvmInstanceof(method->clazz, gDvm.classJavaLangThrowable))
             break;
@@ -1018,7 +1018,7 @@
     while (fp != NULL) {
         const StackSaveArea* saveArea = SAVEAREA_FROM_FP(fp);
 
-        if (!dvmIsBreakFrame(fp))
+        if (!dvmIsBreakFrame((u4*)fp))
             stackDepth++;
 
         assert(fp != saveArea->prevFrame);
@@ -1059,7 +1059,7 @@
         const StackSaveArea* saveArea = SAVEAREA_FROM_FP(fp);
         const Method* method = saveArea->method;
 
-        if (!dvmIsBreakFrame(fp)) {
+        if (!dvmIsBreakFrame((u4*)fp)) {
             //LOGD("EXCEP keeping %s.%s\n", method->clazz->descriptor,
             //         method->name);
 
diff --git a/vm/IndirectRefTable.c b/vm/IndirectRefTable.c
index dadd03f..f940653 100644
--- a/vm/IndirectRefTable.c
+++ b/vm/IndirectRefTable.c
@@ -299,7 +299,7 @@
         updateSlotRemove(pRef, idx);
 
 #ifndef NDEBUG
-        pRef->table[idx] = (IndirectRef) 0xd3d3d3d3;
+        pRef->table[idx] = (Object*)0xd3d3d3d3;
 #endif
 
         int numHoles =
diff --git a/vm/IndirectRefTable.h b/vm/IndirectRefTable.h
index 6a4db04..f5157cb 100644
--- a/vm/IndirectRefTable.h
+++ b/vm/IndirectRefTable.h
@@ -236,7 +236,7 @@
  */
 INLINE IndirectRefKind dvmGetIndirectRefType(IndirectRef iref)
 {
-    return (u4) iref & 0x03;
+    return (IndirectRefKind)((u4) iref & 0x03);
 }
 
 /*
diff --git a/vm/Intern.c b/vm/Intern.c
index f91cc35..8f84528 100644
--- a/vm/Intern.c
+++ b/vm/Intern.c
@@ -63,7 +63,7 @@
         /*
          * Check the literal table for a match.
          */
-        StringObject* literal = dvmHashTableLookup(gDvm.literalStrings,
+        StringObject* literal = (StringObject*)dvmHashTableLookup(gDvm.literalStrings,
                                                    hash, strObj,
                                                    dvmHashcmpStrings,
                                                    false);
@@ -77,7 +77,7 @@
              * There is no match in the literal table, check the
              * interned string table.
              */
-            StringObject* interned = dvmHashTableLookup(gDvm.internedStrings,
+            StringObject* interned = (StringObject*)dvmHashTableLookup(gDvm.internedStrings,
                                                         hash, strObj,
                                                         dvmHashcmpStrings,
                                                         false);
@@ -87,7 +87,7 @@
                  * matching string to the literal table.
                  */
                 dvmHashTableRemove(gDvm.internedStrings, hash, interned);
-                found = dvmHashTableLookup(gDvm.literalStrings,
+                found = (StringObject*)dvmHashTableLookup(gDvm.literalStrings,
                                            hash, interned,
                                            dvmHashcmpStrings,
                                            true);
@@ -97,7 +97,7 @@
                  * No match in the literal table or the interned
                  * table.  Insert into the literal table.
                  */
-                found = dvmHashTableLookup(gDvm.literalStrings,
+                found = (StringObject*)dvmHashTableLookup(gDvm.literalStrings,
                                            hash, strObj,
                                            dvmHashcmpStrings,
                                            true);
@@ -108,7 +108,7 @@
         /*
          * Check the literal table for a match.
          */
-        found = dvmHashTableLookup(gDvm.literalStrings,
+        found = (StringObject*)dvmHashTableLookup(gDvm.literalStrings,
                                    hash, strObj,
                                    dvmHashcmpStrings,
                                    false);
@@ -117,7 +117,7 @@
              * No match was found in the literal table.  Insert into
              * the intern table.
              */
-            found = dvmHashTableLookup(gDvm.internedStrings,
+            found = (StringObject*)dvmHashTableLookup(gDvm.internedStrings,
                                        hash, strObj,
                                        dvmHashcmpStrings,
                                        true);
@@ -163,8 +163,8 @@
     }
     dvmLockMutex(&gDvm.internLock);
     hash = dvmComputeStringHash(strObj);
-    found = dvmHashTableLookup(gDvm.internedStrings, hash, (void*)strObj,
-                               dvmHashcmpStrings, false);
+    found = (StringObject*)dvmHashTableLookup(gDvm.internedStrings, hash,
+                               (StringObject*)strObj, dvmHashcmpStrings, false);
     dvmUnlockMutex(&gDvm.internLock);
     return found == strObj;
 }
diff --git a/vm/JarFile.c b/vm/JarFile.c
index 39eb8d1..9197876 100644
--- a/vm/JarFile.c
+++ b/vm/JarFile.c
@@ -49,7 +49,7 @@
     size_t bufLen = fileNameLen + suffixLen + 1;
     int fd = -1;
 
-    buf = malloc(bufLen);
+    buf = (char*)malloc(bufLen);
     if (buf == NULL) {
         errno = ENOMEM;
         return -1;
diff --git a/vm/Jni.c b/vm/Jni.c
index f2ee2ae..3f4a4fc 100644
--- a/vm/Jni.c
+++ b/vm/Jni.c
@@ -844,7 +844,7 @@
     }
 #else
     if (!dvmRemoveFromReferenceTable(&gDvm.jniGlobalRefTable,
-            gDvm.jniGlobalRefTable.table, jobj))
+            gDvm.jniGlobalRefTable.table, (Object*)jobj))
     {
         LOGW("JNI: DeleteGlobalRef(%p) failed to find entry (valid=%d)\n",
             jobj, dvmIsValidObject((Object*) jobj));
@@ -1056,7 +1056,7 @@
     u4* fp;
     int i;
 
-    fp = self->curFrame;
+    fp = (u4*)self->curFrame;
     while (1) {
         /*
          * Back up over JNI PushLocalFrame frames.  This works because the
@@ -1069,7 +1069,7 @@
         meth = saveArea->method;
         if (meth != SAVEAREA_FROM_FP(saveArea->prevFrame)->method)
             break;
-        fp = saveArea->prevFrame;
+        fp = (u4*)saveArea->prevFrame;
     }
 
     LOGVV("+++ scanning %d args in %s (%s)\n",
@@ -1149,6 +1149,7 @@
         return (jobjectRefType) dvmGetIndirectRefType(jobj);
     }
 #else
+    Object* obj = dvmDecodeIndirectRef(env, jobj);
     ReferenceTable* pRefTable = getLocalRefTable(env);
     Thread* self = dvmThreadSelf();
 
@@ -1157,23 +1158,24 @@
     }
 
     /* check args */
-    if (findInArgList(self, jobj)) {
-        //LOGI("--- REF found %p on stack\n", jobj);
+    if (findInArgList(self, obj)) {
+        //LOGI("--- REF found %p on stack", obj);
         return JNILocalRefType;
     }
 
     /* check locals */
-    if (dvmFindInReferenceTable(pRefTable, pRefTable->table, jobj) != NULL) {
-        //LOGI("--- REF found %p in locals\n", jobj);
+    if (dvmFindInReferenceTable(pRefTable, pRefTable->table,
+            obj) != NULL) {
+        //LOGI("--- REF found %p in locals", obj);
         return JNILocalRefType;
     }
 
     /* check globals */
     dvmLockMutex(&gDvm.jniGlobalRefLock);
     if (dvmFindInReferenceTable(&gDvm.jniGlobalRefTable,
-            gDvm.jniGlobalRefTable.table, jobj))
+            gDvm.jniGlobalRefTable.table, obj))
     {
-        //LOGI("--- REF found %p in globals\n", jobj);
+        //LOGI("--- REF found %p in globals", obj);
         dvmUnlockMutex(&gDvm.jniGlobalRefLock);
         return JNIGlobalRefType;
     }
@@ -1324,7 +1326,7 @@
     DalvikBridgeFunc bridge = shouldTrace(method)
         ? dvmTraceCallJNIMethod
         : dvmSelectJNIBridge(method);
-    dvmSetNativeFunc(method, bridge, func);
+    dvmSetNativeFunc(method, bridge, (const u2*)func);
 }
 
 /*
@@ -1630,7 +1632,7 @@
     assert(method->insns != NULL);
 
     COMPUTE_STACK_SUM(self);
-    dvmPlatformInvoke(env, staticMethodClass,
+    dvmPlatformInvoke(env, (ClassObject*)staticMethodClass,
         method->jniArgInfo, method->insSize, modArgs, method->shorty,
         (void*)method->insns, pResult);
     CHECK_STACK_SUM(self);
@@ -1727,7 +1729,7 @@
     ANDROID_MEMBAR_FULL();      /* guarantee ordering on method->insns */
 
     COMPUTE_STACK_SUM(self);
-    dvmPlatformInvoke(self->jniEnv, staticMethodClass,
+    dvmPlatformInvoke(self->jniEnv, (ClassObject*)staticMethodClass,
         method->jniArgInfo, method->insSize, args, method->shorty,
         (void*)method->insns, pResult);
     CHECK_STACK_SUM(self);
@@ -2522,7 +2524,7 @@
 /*
  * Set a static field.
  */
-#define SET_STATIC_TYPE_FIELD(_ctype, _jname, _isref)                       \
+#define SET_STATIC_TYPE_FIELD(_ctype, _ctype2, _jname, _isref)              \
     static void SetStatic##_jname##Field(JNIEnv* env, jclass jclazz,        \
         jfieldID fieldID, _ctype value)                                     \
     {                                                                       \
@@ -2535,7 +2537,7 @@
                     dvmDecodeIndirectRef(env, (jobject)(u4)value);          \
                 dvmSetStaticFieldObjectVolatile(sfield, valObj);            \
             } else {                                                        \
-                dvmSetStaticField##_jname##Volatile(sfield, value);         \
+                dvmSetStaticField##_jname##Volatile(sfield, (_ctype2)value);\
             }                                                               \
         } else {                                                            \
             if (_isref) {                                                   \
@@ -2543,20 +2545,20 @@
                     dvmDecodeIndirectRef(env, (jobject)(u4)value);          \
                 dvmSetStaticFieldObject(sfield, valObj);                    \
             } else {                                                        \
-                dvmSetStaticField##_jname(sfield, value);                   \
+                dvmSetStaticField##_jname(sfield, (_ctype2)value);          \
             }                                                               \
         }                                                                   \
         JNI_EXIT();                                                         \
     }
-SET_STATIC_TYPE_FIELD(jobject, Object, true);
-SET_STATIC_TYPE_FIELD(jboolean, Boolean, false);
-SET_STATIC_TYPE_FIELD(jbyte, Byte, false);
-SET_STATIC_TYPE_FIELD(jchar, Char, false);
-SET_STATIC_TYPE_FIELD(jshort, Short, false);
-SET_STATIC_TYPE_FIELD(jint, Int, false);
-SET_STATIC_TYPE_FIELD(jlong, Long, false);
-SET_STATIC_TYPE_FIELD(jfloat, Float, false);
-SET_STATIC_TYPE_FIELD(jdouble, Double, false);
+SET_STATIC_TYPE_FIELD(jobject, Object*, Object, true);
+SET_STATIC_TYPE_FIELD(jboolean, bool, Boolean, false);
+SET_STATIC_TYPE_FIELD(jbyte, s1, Byte, false);
+SET_STATIC_TYPE_FIELD(jchar, u2, Char, false);
+SET_STATIC_TYPE_FIELD(jshort, s2, Short, false);
+SET_STATIC_TYPE_FIELD(jint, s4, Int, false);
+SET_STATIC_TYPE_FIELD(jlong, s8, Long, false);
+SET_STATIC_TYPE_FIELD(jfloat, float, Float, false);
+SET_STATIC_TYPE_FIELD(jdouble, double, Double, false);
 
 /*
  * Get an instance field.
@@ -2604,7 +2606,7 @@
 /*
  * Set an instance field.
  */
-#define SET_TYPE_FIELD(_ctype, _jname, _isref)                              \
+#define SET_TYPE_FIELD(_ctype, _ctype2, _jname, _isref)                     \
     static void Set##_jname##Field(JNIEnv* env, jobject jobj,               \
         jfieldID fieldID, _ctype value)                                     \
     {                                                                       \
@@ -2618,7 +2620,7 @@
                 dvmSetFieldObjectVolatile(obj, field->byteOffset, valObj);  \
             } else {                                                        \
                 dvmSetField##_jname##Volatile(obj,                          \
-                    field->byteOffset, value);                              \
+                    field->byteOffset, (_ctype2)value);                     \
             }                                                               \
         } else {                                                            \
             if (_isref) {                                                   \
@@ -2626,20 +2628,21 @@
                     dvmDecodeIndirectRef(env, (jobject)(u4)value);          \
                 dvmSetFieldObject(obj, field->byteOffset, valObj);          \
             } else {                                                        \
-                dvmSetField##_jname(obj, field->byteOffset, value);         \
+                dvmSetField##_jname(obj,                                    \
+                    field->byteOffset, (_ctype2)value);                     \
             }                                                               \
         }                                                                   \
         JNI_EXIT();                                                         \
     }
-SET_TYPE_FIELD(jobject, Object, true);
-SET_TYPE_FIELD(jboolean, Boolean, false);
-SET_TYPE_FIELD(jbyte, Byte, false);
-SET_TYPE_FIELD(jchar, Char, false);
-SET_TYPE_FIELD(jshort, Short, false);
-SET_TYPE_FIELD(jint, Int, false);
-SET_TYPE_FIELD(jlong, Long, false);
-SET_TYPE_FIELD(jfloat, Float, false);
-SET_TYPE_FIELD(jdouble, Double, false);
+SET_TYPE_FIELD(jobject, Object*, Object, true);
+SET_TYPE_FIELD(jboolean, bool, Boolean, false);
+SET_TYPE_FIELD(jbyte, s1, Byte, false);
+SET_TYPE_FIELD(jchar, u2, Char, false);
+SET_TYPE_FIELD(jshort, s2, Short, false);
+SET_TYPE_FIELD(jint, s4, Int, false);
+SET_TYPE_FIELD(jlong, s8, Long, false);
+SET_TYPE_FIELD(jfloat, float, Float, false);
+SET_TYPE_FIELD(jdouble, double, Double, false);
 
 /*
  * Make a virtual method call.
@@ -2665,7 +2668,7 @@
         dvmCallMethodV(_self, meth, obj, true, &result, args);              \
         va_end(args);                                                       \
         if (_isref && !dvmCheckException(_self))                            \
-            result.l = addLocalReference(env, result.l);                    \
+            result.l = addLocalReference(env, (Object*)result.l);           \
         JNI_EXIT();                                                         \
         return _retok;                                                      \
     }                                                                       \
@@ -2683,7 +2686,7 @@
         }                                                                   \
         dvmCallMethodV(_self, meth, obj, true, &result, args);              \
         if (_isref && !dvmCheckException(_self))                            \
-            result.l = addLocalReference(env, result.l);                    \
+            result.l = addLocalReference(env, (Object*)result.l);           \
         JNI_EXIT();                                                         \
         return _retok;                                                      \
     }                                                                       \
@@ -2701,7 +2704,7 @@
         }                                                                   \
         dvmCallMethodA(_self, meth, obj, true, &result, args);              \
         if (_isref && !dvmCheckException(_self))                            \
-            result.l = addLocalReference(env, result.l);                    \
+            result.l = addLocalReference(env, (Object*)result.l);           \
         JNI_EXIT();                                                         \
         return _retok;                                                      \
     }
@@ -2742,7 +2745,7 @@
         va_start(args, methodID);                                           \
         dvmCallMethodV(_self, meth, obj, true, &result, args);              \
         if (_isref && !dvmCheckException(_self))                            \
-            result.l = addLocalReference(env, result.l);                    \
+            result.l = addLocalReference(env, (Object*)result.l);           \
         va_end(args);                                                       \
         JNI_EXIT();                                                         \
         return _retok;                                                      \
@@ -2763,7 +2766,7 @@
         }                                                                   \
         dvmCallMethodV(_self, meth, obj, true, &result, args);              \
         if (_isref && !dvmCheckException(_self))                            \
-            result.l = addLocalReference(env, result.l);                    \
+            result.l = addLocalReference(env, (Object*)result.l);           \
         JNI_EXIT();                                                         \
         return _retok;                                                      \
     }                                                                       \
@@ -2783,7 +2786,7 @@
         }                                                                   \
         dvmCallMethodA(_self, meth, obj, true, &result, args);              \
         if (_isref && !dvmCheckException(_self))                            \
-            result.l = addLocalReference(env, result.l);                    \
+            result.l = addLocalReference(env, (Object*)result.l);           \
         JNI_EXIT();                                                         \
         return _retok;                                                      \
     }
@@ -2814,7 +2817,7 @@
         dvmCallMethodV(_self, (Method*)methodID, NULL, true, &result, args);\
         va_end(args);                                                       \
         if (_isref && !dvmCheckException(_self))                            \
-            result.l = addLocalReference(env, result.l);                    \
+            result.l = addLocalReference(env, (Object*)result.l);           \
         JNI_EXIT();                                                         \
         return _retok;                                                      \
     }                                                                       \
@@ -2826,7 +2829,7 @@
         JValue result;                                                      \
         dvmCallMethodV(_self, (Method*)methodID, NULL, true, &result, args);\
         if (_isref && !dvmCheckException(_self))                            \
-            result.l = addLocalReference(env, result.l);                    \
+            result.l = addLocalReference(env, (Object*)result.l);           \
         JNI_EXIT();                                                         \
         return _retok;                                                      \
     }                                                                       \
@@ -2838,7 +2841,7 @@
         JValue result;                                                      \
         dvmCallMethodA(_self, (Method*)methodID, NULL, true, &result, args);\
         if (_isref && !dvmCheckException(_self))                            \
-            result.l = addLocalReference(env, result.l);                    \
+            result.l = addLocalReference(env, (Object*)result.l);           \
         JNI_EXIT();                                                         \
         return _retok;                                                      \
     }
@@ -4283,11 +4286,12 @@
             fprintf(stderr, "ERROR: arg %d string was null\n", i);
             goto bail;
         } else if (strcmp(optStr, "vfprintf") == 0) {
-            gDvm.vfprintfHook = args->options[i].extraInfo;
+            gDvm.vfprintfHook =
+                (int (*)(FILE *, const char*, va_list))args->options[i].extraInfo;
         } else if (strcmp(optStr, "exit") == 0) {
-            gDvm.exitHook = args->options[i].extraInfo;
+            gDvm.exitHook = (void (*)(int)) args->options[i].extraInfo;
         } else if (strcmp(optStr, "abort") == 0) {
-            gDvm.abortHook = args->options[i].extraInfo;
+            gDvm.abortHook = (void (*)(void))args->options[i].extraInfo;
         } else if (strcmp(optStr, "-Xcheck:jni") == 0) {
             checkJni = true;
         } else if (strncmp(optStr, "-Xjniopts:", 10) == 0) {
diff --git a/vm/LinearAlloc.c b/vm/LinearAlloc.c
index 65db79e..559bbc5 100644
--- a/vm/LinearAlloc.c
+++ b/vm/LinearAlloc.c
@@ -139,7 +139,7 @@
         return NULL;
     }
 
-    pHdr->mapAddr = mmap(NULL, pHdr->mapLength, PROT_READ | PROT_WRITE,
+    pHdr->mapAddr = (char*)mmap(NULL, pHdr->mapLength, PROT_READ | PROT_WRITE,
         MAP_PRIVATE, fd, 0);
     if (pHdr->mapAddr == MAP_FAILED) {
         LOGE("LinearAlloc mmap(%d) failed: %s\n", pHdr->mapLength,
@@ -202,7 +202,7 @@
     if (ENFORCE_READ_ONLY) {
         /* allocate the per-page ref count */
         int numPages = (pHdr->mapLength+SYSTEM_PAGE_SIZE-1) / SYSTEM_PAGE_SIZE;
-        pHdr->writeRefCount = calloc(numPages, sizeof(short));
+        pHdr->writeRefCount = (short*)calloc(numPages, sizeof(short));
         if (pHdr->writeRefCount == NULL) {
             free(pHdr);
             return NULL;
diff --git a/vm/Misc.c b/vm/Misc.c
index 564d415..b7404fd 100644
--- a/vm/Misc.c
+++ b/vm/Misc.c
@@ -50,7 +50,7 @@
     size_t length, HexDumpMode mode)
 {
     static const char gHexDigit[] = "0123456789abcdef";
-    const unsigned char* addr = vaddr;
+    const unsigned char* addr = (const unsigned char*)vaddr;
     char out[77];           /* exact fit */
     unsigned int offset;    /* offset to show while printing */
     char* hex;
@@ -259,7 +259,7 @@
     if (!pBits->expandable)
         return -1;
 
-    pBits->storage = realloc(pBits->storage,
+    pBits->storage = (u4*)realloc(pBits->storage,
                     (pBits->storageSize + kBitVectorGrowth) * sizeof(u4));
     memset(&pBits->storage[pBits->storageSize], 0x00,
         kBitVectorGrowth * sizeof(u4));
@@ -283,7 +283,7 @@
         /* Round up to word boundaries for "num+1" bits */
         int newSize = (num + 1 + 31) >> 5;
         assert(newSize > pBits->storageSize);
-        pBits->storage = realloc(pBits->storage, newSize * sizeof(u4));
+        pBits->storage = (u4*)realloc(pBits->storage, newSize * sizeof(u4));
         memset(&pBits->storage[pBits->storageSize], 0x00,
             (newSize - pBits->storageSize) * sizeof(u4));
         pBits->storageSize = newSize;
@@ -444,7 +444,7 @@
     }
 
     // Allocate enough space.
-    char* result = malloc(resultLength + 1);
+    char* result = (char*)malloc(resultLength + 1);
     if (result == NULL) {
         return NULL;
     }
@@ -488,7 +488,7 @@
         str++; /* Skip the 'L'. */
     }
 
-    newStr = malloc(at + 1); /* Add one for the '\0'. */
+    newStr = (char*)malloc(at + 1); /* Add one for the '\0'. */
     if (newStr == NULL)
         return NULL;
 
@@ -522,7 +522,7 @@
         wrapElSemi = 1;
     }
 
-    newStr = at = malloc(length + 1); /* + 1 for the '\0' */
+    newStr = at = (char*)malloc(length + 1); /* + 1 for the '\0' */
 
     if (newStr == NULL) {
         return NULL;
@@ -557,7 +557,7 @@
 {
     if (str[0] == 'L') {
         size_t length = strlen(str) - 1;
-        char* newStr = malloc(length);
+        char* newStr = (char*)malloc(length);
 
         if (newStr == NULL) {
             return NULL;
@@ -579,7 +579,7 @@
 {
     if (str[0] != '[') {
         size_t length = strlen(str);
-        char* descriptor = malloc(length + 3);
+        char* descriptor = (char*)malloc(length + 3);
 
         if (descriptor == NULL) {
             return NULL;
diff --git a/vm/Native.c b/vm/Native.c
index 8436e7f..52af108 100644
--- a/vm/Native.c
+++ b/vm/Native.c
@@ -200,7 +200,7 @@
 
     ent = dvmHashTableLookup(gDvm.nativeLibs, hash, (void*)pathName,
                 hashcmpNameStr, false);
-    return ent;
+    return (SharedLib*)ent;
 }
 
 /*
@@ -218,8 +218,8 @@
      * our own pointer back.  If somebody beat us to the punch, we'll get
      * their pointer back instead.
      */
-    return dvmHashTableLookup(gDvm.nativeLibs, hash, pLib, hashcmpSharedLib,
-                true);
+    return (SharedLib*)dvmHashTableLookup(gDvm.nativeLibs, hash, pLib,
+                hashcmpSharedLib, true);
 }
 
 /*
@@ -426,7 +426,7 @@
              * top of the stack is around Runtime.loadLibrary().  (See
              * the comments in the JNI FindClass function.)
              */
-            OnLoadFunc func = vonLoad;
+            OnLoadFunc func = (OnLoadFunc)vonLoad;
             Object* prevOverride = self->classLoaderOverride;
 
             self->classLoaderOverride = classLoader;
@@ -558,7 +558,7 @@
 
     *pLen = 4 + descriptorLength + strlen(methodName);
 
-    result = malloc(*pLen +1);
+    result = (char*)malloc(*pLen +1);
     if (result == NULL)
         return NULL;
 
diff --git a/vm/PointerSet.c b/vm/PointerSet.c
index 1d2e814..862f733 100644
--- a/vm/PointerSet.c
+++ b/vm/PointerSet.c
@@ -54,10 +54,10 @@
  */
 PointerSet* dvmPointerSetAlloc(int initialSize)
 {
-    PointerSet* pSet = calloc(1, sizeof(PointerSet));
+    PointerSet* pSet = (PointerSet*)calloc(1, sizeof(PointerSet));
     if (pSet != NULL) {
         if (initialSize > 0) {
-            pSet->list = malloc(sizeof(const void*) * initialSize);
+            pSet->list = (const void**)malloc(sizeof(void*) * initialSize);
             if (pSet->list == NULL) {
                 free(pSet);
                 return NULL;
@@ -131,7 +131,7 @@
         else
             pSet->alloc *= 2;
         LOGVV("expanding %p to %d\n", pSet, pSet->alloc);
-        newList = realloc(pSet->list, pSet->alloc * sizeof(const void*));
+        newList = (const void**)realloc(pSet->list, pSet->alloc * sizeof(void*));
         if (newList == NULL) {
             LOGE("Failed expanding ptr set (alloc=%d)\n", pSet->alloc);
             dvmAbort();
diff --git a/vm/Thread.c b/vm/Thread.c
index dd87483..cd9b9d3 100644
--- a/vm/Thread.c
+++ b/vm/Thread.c
@@ -954,7 +954,7 @@
     }
     memset(stackBottom, 0xc5, interpStackSize);     // stop valgrind complaints
 #else
-    stackBottom = mmap(NULL, interpStackSize, PROT_READ | PROT_WRITE,
+    stackBottom = (u1*) mmap(NULL, interpStackSize, PROT_READ | PROT_WRITE,
         MAP_PRIVATE | MAP_ANON, -1, 0);
     if (stackBottom == MAP_FAILED) {
 #if defined(WITH_SELF_VERIFICATION)
@@ -2197,7 +2197,7 @@
 
         if (curDepth == 1) {
             /* not expecting a lingering break frame; just look at curFrame */
-            assert(!dvmIsBreakFrame(self->curFrame));
+            assert(!dvmIsBreakFrame((u4*)self->curFrame));
             StackSaveArea* ssa = SAVEAREA_FROM_FP(self->curFrame);
             if (dvmIsNativeMethod(ssa->method))
                 topIsNative = true;
diff --git a/vm/alloc/Alloc.c b/vm/alloc/Alloc.c
index 25be305..3d4c38e 100644
--- a/vm/alloc/Alloc.c
+++ b/vm/alloc/Alloc.c
@@ -181,7 +181,7 @@
     }
 
     /* allocate on GC heap; memory is zeroed out */
-    newObj = dvmMalloc(clazz->objectSize, flags);
+    newObj = (Object*)dvmMalloc(clazz->objectSize, flags);
     if (newObj != NULL) {
         DVM_OBJECT_INIT(newObj, clazz);
 #if WITH_HPROF_STACK
@@ -224,7 +224,7 @@
         size = obj->clazz->objectSize;
     }
 
-    copy = dvmMalloc(size, flags);
+    copy = (Object*)dvmMalloc(size, flags);
     if (copy == NULL)
         return NULL;
 #if WITH_HPROF_STACK
@@ -312,8 +312,8 @@
 
 static void countInstancesOfClassCallback(void *ptr, void *arg)
 {
-    CountContext *ctx = arg;
-    const Object *obj = ptr;
+    CountContext *ctx = (CountContext *)arg;
+    const Object *obj = (const Object *)ptr;
 
     assert(ctx != NULL);
     if (obj->clazz == ctx->clazz) {
@@ -333,8 +333,8 @@
 
 static void countAssignableInstancesOfClassCallback(void *ptr, void *arg)
 {
-    CountContext *ctx = arg;
-    const Object *obj = ptr;
+    CountContext *ctx = (CountContext *)arg;
+    const Object *obj = (const Object *)ptr;
 
     assert(ctx != NULL);
     if (dvmInstanceof(obj->clazz, ctx->clazz)) {
diff --git a/vm/alloc/CardTable.c b/vm/alloc/CardTable.c
index fcfe49c..ac8e440 100644
--- a/vm/alloc/CardTable.c
+++ b/vm/alloc/CardTable.c
@@ -64,7 +64,7 @@
     if (allocBase == NULL) {
         return false;
     }
-    gcHeap->cardTableBase = allocBase;
+    gcHeap->cardTableBase = (u1*)allocBase;
     gcHeap->cardTableLength = length;
     /* All zeros is the correct initial value; all clean. */
     assert(GC_CARD_CLEAN == 0);
@@ -171,7 +171,7 @@
         return;
     }
     assert(dvmIsValidObject(obj));
-    ctx = arg;
+    ctx = (WhiteReferenceCounter *)arg;
     if (dvmHeapBitmapIsObjectBitSet(ctx->markBits, obj)) {
         return;
     }
@@ -193,7 +193,7 @@
         return;
     }
     assert(dvmIsValidObject(obj));
-    ctx = arg;
+    ctx = (WhiteReferenceCounter*)arg;
     if (dvmHeapBitmapIsObjectBitSet(ctx->markBits, obj)) {
         return;
     }
@@ -214,14 +214,14 @@
 
 static void dumpReferencesCallback(void *ptr, void *arg)
 {
-    Object *obj = arg;
+    Object *obj = (Object *)arg;
     if (ptr == obj) {
         return;
     }
-    dvmVisitObject(dumpReferencesVisitor, ptr, &obj);
+    dvmVisitObject(dumpReferencesVisitor, (Object *)ptr, &obj);
     if (obj == NULL) {
         LOGD("Found %p in the heap @ %p", arg, ptr);
-        dvmDumpObject(ptr);
+        dvmDumpObject((Object *)ptr);
     }
 }
 
@@ -311,8 +311,8 @@
  */
 static void verifyCardTableCallback(void *ptr, void *arg)
 {
-    Object *obj = ptr;
-    WhiteReferenceCounter ctx = { arg, 0 };
+    Object *obj = (Object *)ptr;
+    WhiteReferenceCounter ctx = { (HeapBitmap *)arg, 0 };
 
     dvmVisitObject(countWhiteReferenceVisitor, obj, &ctx);
     if (ctx.whiteRefs == 0) {
diff --git a/vm/alloc/DdmHeap.c b/vm/alloc/DdmHeap.c
index 4cb5cae..48b822e 100644
--- a/vm/alloc/DdmHeap.c
+++ b/vm/alloc/DdmHeap.c
@@ -273,7 +273,7 @@
          */
         state = HPSG_STATE(SOLIDITY_FREE, 0);
     } else {
-        const Object *obj = userptr;
+        const Object *obj = (const Object *)userptr;
         /* If we're looking at the native heap, we'll just return
          * (SOLIDITY_HARD, KIND_NATIVE) for all allocated chunks
          */
diff --git a/vm/alloc/Heap.c b/vm/alloc/Heap.c
index 7e47e73..3ede125 100644
--- a/vm/alloc/Heap.c
+++ b/vm/alloc/Heap.c
@@ -458,7 +458,7 @@
          * internal tracking list.
          */
         if ((flags & ALLOC_DONT_TRACK) == 0) {
-            dvmAddTrackedAlloc(ptr, NULL);
+            dvmAddTrackedAlloc((Object*)ptr, NULL);
         }
     } else {
         /*
diff --git a/vm/alloc/HeapBitmap.c b/vm/alloc/HeapBitmap.c
index b3a2bb1..7304cd6 100644
--- a/vm/alloc/HeapBitmap.c
+++ b/vm/alloc/HeapBitmap.c
@@ -39,7 +39,7 @@
         LOGE("Could not mmap %zd-byte ashmem region '%s'", bitsLen, name);
         return false;
     }
-    hb->bits = bits;
+    hb->bits = (unsigned long *)bits;
     hb->bitsLen = hb->allocLen = bitsLen;
     hb->base = (uintptr_t)base;
     hb->max = hb->base - 1;
diff --git a/vm/alloc/HeapSource.c b/vm/alloc/HeapSource.c
index ed58d50..9ebda9b 100644
--- a/vm/alloc/HeapSource.c
+++ b/vm/alloc/HeapSource.c
@@ -549,14 +549,14 @@
 
     /* Allocate a descriptor from the heap we just created.
      */
-    gcHeap = mspace_malloc(msp, sizeof(*gcHeap));
+    gcHeap = (GcHeap *)mspace_malloc(msp, sizeof(*gcHeap));
     if (gcHeap == NULL) {
         LOGE_HEAP("Can't allocate heap descriptor\n");
         goto fail;
     }
     memset(gcHeap, 0, sizeof(*gcHeap));
 
-    hs = mspace_malloc(msp, sizeof(*hs));
+    hs = (HeapSource *)mspace_malloc(msp, sizeof(*hs));
     if (hs == NULL) {
         LOGE_HEAP("Can't allocate heap source\n");
         goto fail;
@@ -572,7 +572,7 @@
     hs->numHeaps = 0;
     hs->sawZygote = gDvm.zygote;
     hs->hasGcThread = false;
-    hs->heapBase = base;
+    hs->heapBase = (char *)base;
     hs->heapLength = length;
     if (!addNewHeap(hs, msp, absoluteMaxSize)) {
         LOGE_HEAP("Can't add initial heap\n");
@@ -994,7 +994,7 @@
     heap = ptr2heap(gHs, *ptrs);
     numBytes = 0;
     if (heap != NULL) {
-        mspace *msp = heap->msp;
+        mspace msp = heap->msp;
         // Calling mspace_free on shared heaps disrupts sharing too
         // much. For heap[0] -- the 'active heap' -- we call
         // mspace_free, but on the other heaps we only do some
diff --git a/vm/alloc/HeapTable.c b/vm/alloc/HeapTable.c
index 72cf791..0eab8a5 100644
--- a/vm/alloc/HeapTable.c
+++ b/vm/alloc/HeapTable.c
@@ -88,7 +88,7 @@
 
     /* Allocate a new table.
      */
-    table = calloc(1, sizeof(LargeHeapRefTable));
+    table = (LargeHeapRefTable *)calloc(1, sizeof(LargeHeapRefTable));
     if (table == NULL) {
         LOGE_HEAP("Can't allocate a new large ref table\n");
         return false;
@@ -123,7 +123,7 @@
 
     /* Allocate a node.
      */
-    table = calloc(1, sizeof(LargeHeapRefTable));
+    table = (LargeHeapRefTable *)calloc(1, sizeof(LargeHeapRefTable));
     if (table == NULL) {
         LOGE_HEAP("Can't allocate a new large ref table\n");
         return false;
diff --git a/vm/alloc/MarkSweep.c b/vm/alloc/MarkSweep.c
index 750256c..fe8550d 100644
--- a/vm/alloc/MarkSweep.c
+++ b/vm/alloc/MarkSweep.c
@@ -108,7 +108,7 @@
         return false;
     }
     ctx->finger = NULL;
-    ctx->immuneLimit = dvmHeapSourceGetImmuneLimit(mode);
+    ctx->immuneLimit = (char*)dvmHeapSourceGetImmuneLimit(mode);
     return true;
 }
 
@@ -160,12 +160,14 @@
 static void rootMarkObjectVisitor(void *addr, RootType type, u4 thread, void *arg)
 {
     Object *obj;
+    GcMarkContext *ctx;
 
     assert(addr != NULL);
     assert(arg != NULL);
     obj = *(Object **)addr;
+    ctx = (GcMarkContext *)arg;
     if (obj != NULL) {
-        markObjectNonNull(obj, arg, false);
+        markObjectNonNull(obj, ctx, false);
     }
 }
 
@@ -210,12 +212,14 @@
 static void markObjectVisitor(void *addr, RootType type, u4 thread, void *arg)
 {
     Object *obj;
+    GcMarkContext *ctx;
 
     assert(addr != NULL);
     assert(arg != NULL);
     obj = *(Object **)addr;
+    ctx = (GcMarkContext *)arg;
     if (obj != NULL) {
-        markObjectNonNull(obj, arg, true);
+        markObjectNonNull(obj, ctx, true);
     }
 }
 
@@ -254,7 +258,8 @@
             int i;
             for (i = 0; i < clazz->ifieldRefCount; ++i, ++field) {
                 void *addr = BYTE_OFFSET((Object *)obj, field->byteOffset);
-                markObject(((JValue *)addr)->l, ctx);
+                Object *ref = (Object *)((JValue *)addr)->l;
+                markObject(ref, ctx);
             }
         }
     }
@@ -272,7 +277,8 @@
     for (i = 0; i < clazz->sfieldCount; ++i) {
         char ch = clazz->sfields[i].field.signature[0];
         if (ch == '[' || ch == 'L') {
-            markObject(clazz->sfields[i].value.l, ctx);
+            Object *obj = (Object *)clazz->sfields[i].value.l;
+            markObject(obj, ctx);
         }
     }
 }
@@ -624,7 +630,7 @@
         if (*card != GC_CARD_DIRTY) {
             return card;
         }
-        const u1 *ptr = prevAddr ? prevAddr : dvmAddrFromCard(card);
+        const u1 *ptr = prevAddr ? prevAddr : (u1*)dvmAddrFromCard(card);
         const u1 *limit = ptr + GC_CARD_SIZE;
         while (ptr < limit) {
             Object *obj = nextGrayObject(ptr, limit, markBits);
@@ -683,9 +689,9 @@
  */
 static void scanBitmapCallback(void *addr, void *finger, void *arg)
 {
-    GcMarkContext *ctx = arg;
+    GcMarkContext *ctx = (GcMarkContext *)arg;
     ctx->finger = (void *)finger;
-    scanObject(addr, ctx);
+    scanObject((Object *)addr, ctx);
 }
 
 /* Given bitmaps with the root set marked, find and mark all
@@ -1020,7 +1026,7 @@
 
 static void sweepBitmapCallback(size_t numPtrs, void **ptrs, void *arg)
 {
-    SweepContext *ctx = arg;
+    SweepContext *ctx = (SweepContext *)arg;
 
     if (ctx->isConcurrent) {
         dvmLockHeap();
diff --git a/vm/alloc/Verify.c b/vm/alloc/Verify.c
index 5ce692c..9cc5c80 100644
--- a/vm/alloc/Verify.c
+++ b/vm/alloc/Verify.c
@@ -31,14 +31,14 @@
 
 static void dumpReferencesCallback(void *ptr, void *arg)
 {
-    Object *obj = arg;
+    Object *obj = (Object *)arg;
     if (ptr == obj) {
         return;
     }
-    dvmVisitObject(dumpReferencesVisitor, ptr, &obj);
+    dvmVisitObject(dumpReferencesVisitor, (Object *)ptr, &obj);
     if (obj == NULL) {
         LOGD("Found %p in the heap @ %p", arg, ptr);
-        dvmDumpObject(ptr);
+        dvmDumpObject((Object *)ptr);
     }
 }
 
@@ -79,7 +79,7 @@
         isValid = dvmIsValidObject(obj);
     }
     if (!isValid) {
-        Object **parent = arg;
+        Object **parent = (Object **)arg;
         if (*parent != NULL) {
             LOGE("Verify of object %p failed", *parent);
             dvmDumpObject(*parent);
@@ -108,7 +108,7 @@
  */
 static void verifyBitmapCallback(void *ptr, void *arg)
 {
-    dvmVerifyObject(ptr);
+    dvmVerifyObject((Object *)ptr);
 }
 
 /*
diff --git a/vm/alloc/Visit.c b/vm/alloc/Visit.c
index a317955..6229d51 100644
--- a/vm/alloc/Visit.c
+++ b/vm/alloc/Visit.c
@@ -110,7 +110,7 @@
     assert(thread != NULL);
     threadId = thread->threadId;
     fp = (u4 *)thread->curFrame;
-    for (; fp != NULL; fp = saveArea->prevFrame) {
+    for (; fp != NULL; fp = (u4 *)saveArea->prevFrame) {
         Method *method;
         saveArea = SAVEAREA_FROM_FP(fp);
         method = (Method *)saveArea->method;
diff --git a/vm/alloc/VisitInlines.h b/vm/alloc/VisitInlines.h
index 959567e..7f90678 100644
--- a/vm/alloc/VisitInlines.h
+++ b/vm/alloc/VisitInlines.h
@@ -30,7 +30,7 @@
         while (refOffsets != 0) {
             size_t rshift = CLZ(refOffsets);
             size_t offset = CLASS_OFFSET_FROM_CLZ(rshift);
-            Object **ref = BYTE_OFFSET(obj, offset);
+            Object **ref = (Object **)BYTE_OFFSET(obj, offset);
             (*visitor)(ref, arg);
             refOffsets &= ~(CLASS_HIGH_BIT >> rshift);
         }
@@ -41,7 +41,7 @@
             int i;
             for (i = 0; i < clazz->ifieldRefCount; ++i, ++field) {
                 size_t offset = field->byteOffset;
-                Object **ref = BYTE_OFFSET(obj, offset);
+                Object **ref = (Object **)BYTE_OFFSET(obj, offset);
                 (*visitor)(ref, arg);
             }
         }
@@ -152,7 +152,7 @@
     assert(obj->clazz != NULL);
     visitDataObject(visitor, obj, arg);
     size_t offset = gDvm.offJavaLangRefReference_referent;
-    Object **ref = BYTE_OFFSET(obj, offset);
+    Object **ref = (Object **)BYTE_OFFSET(obj, offset);
     (*visitor)(ref, arg);
 }
 
diff --git a/vm/analysis/CodeVerify.c b/vm/analysis/CodeVerify.c
index 8bb0da0..3d9d270 100644
--- a/vm/analysis/CodeVerify.c
+++ b/vm/analysis/CodeVerify.c
@@ -427,7 +427,7 @@
      */
     int size = offsetof(UninitInstanceMap, map) +
                 newInstanceCount * sizeof(uninitMap->map[0]);
-    uninitMap = calloc(1, size);
+    uninitMap = (UninitInstanceMap*)calloc(1, size);
     if (uninitMap == NULL)
         return NULL;
     uninitMap->numEntries = newInstanceCount;
@@ -3068,7 +3068,7 @@
     /*
      * Populate the sparse register line table.
      */
-    u1* storage = regTable->lineAlloc;
+    u1* storage = (u1*)regTable->lineAlloc;
     for (i = 0; i < insnsSize; i++) {
         bool interesting;
 
diff --git a/vm/analysis/DexPrepare.c b/vm/analysis/DexPrepare.c
index 4a17123..fee31e5 100644
--- a/vm/analysis/DexPrepare.c
+++ b/vm/analysis/DexPrepare.c
@@ -342,7 +342,7 @@
             LOGW("ANDROID_ROOT not set, defaulting to /system\n");
             androidRoot = "/system";
         }
-        execFile = malloc(strlen(androidRoot) + strlen(kDexOptBin) + 1);
+        execFile = (char*)malloc(strlen(androidRoot) + strlen(kDexOptBin) + 1);
         strcpy(execFile, androidRoot);
         strcat(execFile, kDexOptBin);
 
@@ -1287,7 +1287,7 @@
 
     bufLen += 4*4 + numDeps * (4+kSHA1DigestLen);
 
-    buf = malloc(bufLen);
+    buf = (u1*)malloc(bufLen);
 
     set4LE(buf+0, modWhen);
     set4LE(buf+4, crc);
diff --git a/vm/analysis/Optimize.c b/vm/analysis/Optimize.c
index 1ed47af..f37dd75 100644
--- a/vm/analysis/Optimize.c
+++ b/vm/analysis/Optimize.c
@@ -66,7 +66,7 @@
     /*
      * Allocate for optimism: one slot per entry, plus an end-of-list marker.
      */
-    table = calloc(count + 1, sizeof(InlineSub));
+    table = (InlineSub*)calloc(count + 1, sizeof(InlineSub));
 
     tableIndex = 0;
     for (i = 0; i < count; i++) {
diff --git a/vm/analysis/RegisterMap.c b/vm/analysis/RegisterMap.c
index 2499a4b..8725ec0 100644
--- a/vm/analysis/RegisterMap.c
+++ b/vm/analysis/RegisterMap.c
@@ -870,7 +870,7 @@
  */
 const RegisterMap* dvmRegisterMapGetNext(const void** pPtr)
 {
-    const RegisterMap* pMap = *pPtr;
+    const RegisterMap* pMap = (const RegisterMap*) *pPtr;
 
     *pPtr = /*align32*/(((u1*) pMap) + computeRegisterMapSize(pMap));
     LOGVV("getNext: %p -> %p (f=0x%x w=%d e=%d)\n",
diff --git a/vm/analysis/RegisterMap.h b/vm/analysis/RegisterMap.h
index 7897d45..886d0b0 100644
--- a/vm/analysis/RegisterMap.h
+++ b/vm/analysis/RegisterMap.h
@@ -67,7 +67,7 @@
  * Get the format.
  */
 INLINE RegisterMapFormat dvmRegisterMapGetFormat(const RegisterMap* pMap) {
-    return pMap->format & ~(kRegMapFormatOnHeap);
+    return (RegisterMapFormat)(pMap->format & ~(kRegMapFormatOnHeap));
 }
 
 /*
diff --git a/vm/compiler/Compiler.c b/vm/compiler/Compiler.c
index 1ac6e97..8dd8adc 100644
--- a/vm/compiler/Compiler.c
+++ b/vm/compiler/Compiler.c
@@ -209,7 +209,7 @@
         saveArea = SAVEAREA_FROM_FP(fp);
 
         if (print) {
-            if (dvmIsBreakFrame(fp)) {
+            if (dvmIsBreakFrame((u4*)fp)) {
                 LOGD("  #%d: break frame (%p)",
                      stackLevel, saveArea->returnAddr);
             }
diff --git a/vm/compiler/Dataflow.c b/vm/compiler/Dataflow.c
index 82f52b9..da1bf24 100644
--- a/vm/compiler/Dataflow.c
+++ b/vm/compiler/Dataflow.c
@@ -862,7 +862,7 @@
         }
     }
     int length = strlen(buffer) + 1;
-    ret = dvmCompilerNew(length, false);
+    ret = (char *)dvmCompilerNew(length, false);
     memcpy(ret, buffer, length);
     return ret;
 }
@@ -904,7 +904,7 @@
     }
 
     int length = strlen(buffer) + 1;
-    ret = dvmCompilerNew(length, false);
+    ret = (char *)dvmCompilerNew(length, false);
     memcpy(ret, buffer, length);
     return ret;
 }
@@ -1015,7 +1015,7 @@
     int i;
 
     mir->ssaRep->numUses = numUses;
-    mir->ssaRep->uses = dvmCompilerNew(sizeof(int) * numUses, false);
+    mir->ssaRep->uses = (int *)dvmCompilerNew(sizeof(int) * numUses, false);
 
     for (i = 0; i < numUses; i++) {
         handleSSAUse(cUnit, mir->ssaRep->uses, dInsn->arg[i], i);
@@ -1030,7 +1030,7 @@
     int i;
 
     mir->ssaRep->numUses = numUses;
-    mir->ssaRep->uses = dvmCompilerNew(sizeof(int) * numUses, false);
+    mir->ssaRep->uses = (int *)dvmCompilerNew(sizeof(int) * numUses, false);
 
     for (i = 0; i < numUses; i++) {
         handleSSAUse(cUnit, mir->ssaRep->uses, dInsn->vC+i, i);
@@ -1047,7 +1047,8 @@
     }
 
     for (mir = bb->firstMIRInsn; mir; mir = mir->next) {
-        mir->ssaRep = dvmCompilerNew(sizeof(SSARepresentation), true);
+        mir->ssaRep = (struct SSARepresentation *)
+            dvmCompilerNew(sizeof(SSARepresentation), true);
 
         int dfAttributes =
             dvmCompilerDataFlowAttributes[mir->dalvikInsn.opcode];
@@ -1084,8 +1085,10 @@
 
         if (numUses) {
             mir->ssaRep->numUses = numUses;
-            mir->ssaRep->uses = dvmCompilerNew(sizeof(int) * numUses, false);
-            mir->ssaRep->fpUse = dvmCompilerNew(sizeof(bool) * numUses, false);
+            mir->ssaRep->uses = (int *)dvmCompilerNew(sizeof(int) * numUses,
+                                                      false);
+            mir->ssaRep->fpUse = (bool *)dvmCompilerNew(sizeof(bool) * numUses,
+                                                false);
         }
 
         int numDefs = 0;
@@ -1099,8 +1102,10 @@
 
         if (numDefs) {
             mir->ssaRep->numDefs = numDefs;
-            mir->ssaRep->defs = dvmCompilerNew(sizeof(int) * numDefs, false);
-            mir->ssaRep->fpDef = dvmCompilerNew(sizeof(bool) * numDefs, false);
+            mir->ssaRep->defs = (int *)dvmCompilerNew(sizeof(int) * numDefs,
+                                                      false);
+            mir->ssaRep->fpDef = (bool *)dvmCompilerNew(sizeof(bool) * numDefs,
+                                                        false);
         }
 
         DecodedInstruction *dInsn = &mir->dalvikInsn;
@@ -1146,7 +1151,8 @@
     }
 
     bb->dataFlowInfo->dalvikToSSAMap =
-        dvmCompilerNew(sizeof(int) * cUnit->method->registersSize, false);
+        (int *)dvmCompilerNew(sizeof(int) * cUnit->method->registersSize,
+                              false);
 
     /* Take a snapshot of Dalvik->SSA mapping at the end of each block */
     memcpy(bb->dataFlowInfo->dalvikToSSAMap, cUnit->dalvikToSSAMap,
@@ -1299,7 +1305,7 @@
                 }
                 if (deltaIsConstant) {
                     dvmSetBit(isIndVarV, mir->ssaRep->uses[0]);
-                    InductionVariableInfo *ivInfo =
+                    InductionVariableInfo *ivInfo = (InductionVariableInfo *)
                         dvmCompilerNew(sizeof(InductionVariableInfo),
                                        false);
 
@@ -1372,13 +1378,13 @@
             if (cIsConstant) {
                 unsigned int i;
                 dvmSetBit(isIndVarV, mir->ssaRep->defs[0]);
-                InductionVariableInfo *ivInfo =
+                InductionVariableInfo *ivInfo = (InductionVariableInfo *)
                     dvmCompilerNew(sizeof(InductionVariableInfo),
                                    false);
                 InductionVariableInfo *ivInfoOld = NULL ;
 
                 for (i = 0; i < ivList->numUsed; i++) {
-                    ivInfoOld = ivList->elemList[i];
+                    ivInfoOld = (InductionVariableInfo *) ivList->elemList[i];
                     if (ivInfoOld->ssaReg == mir->ssaRep->uses[0]) break;
                 }
 
@@ -1402,7 +1408,8 @@
     int i;
     int numDalvikReg = cUnit->method->registersSize;
 
-    cUnit->ssaToDalvikMap = dvmCompilerNew(sizeof(GrowableList), false);
+    cUnit->ssaToDalvikMap = (GrowableList *)dvmCompilerNew(sizeof(GrowableList),
+                                                           false);
     dvmInitGrowableList(cUnit->ssaToDalvikMap, numDalvikReg);
 
     /*
@@ -1426,7 +1433,8 @@
      * while the high 16 bit is the current subscript. The original Dalvik
      * register N is mapped to SSA register N with subscript 0.
      */
-    cUnit->dalvikToSSAMap = dvmCompilerNew(sizeof(int) * numDalvikReg, false);
+    cUnit->dalvikToSSAMap = (int *)dvmCompilerNew(sizeof(int) * numDalvikReg,
+                                                  false);
     for (i = 0; i < numDalvikReg; i++) {
         cUnit->dalvikToSSAMap[i] = i;
     }
@@ -1438,7 +1446,9 @@
         BasicBlock *bb = cUnit->blockList[i];
         if (bb->blockType == kDalvikByteCode ||
             bb->blockType == kTraceEntryBlock) {
-            bb->dataFlowInfo = dvmCompilerNew(sizeof(BasicBlockDataFlow), true);
+            bb->dataFlowInfo = (BasicBlockDataFlow *)
+                dvmCompilerNew(sizeof(BasicBlockDataFlow),
+                               true);
         }
     }
 }
diff --git a/vm/compiler/Frontend.c b/vm/compiler/Frontend.c
index a44c489..76783ae 100644
--- a/vm/compiler/Frontend.c
+++ b/vm/compiler/Frontend.c
@@ -277,10 +277,11 @@
 
     /* For lookup only */
     dummyMethodEntry.method = method;
-    realMethodEntry = dvmHashTableLookup(gDvmJit.methodStatsTable, hashValue,
-                                         &dummyMethodEntry,
-                                         (HashCompareFunc) compareMethod,
-                                         false);
+    realMethodEntry =
+        (CompilerMethodStats *) dvmHashTableLookup(gDvmJit.methodStatsTable, hashValue,
+                                                   &dummyMethodEntry,
+                                                   (HashCompareFunc) compareMethod,
+                                                   false);
 
     /* This method has never been analyzed before - create an entry */
     if (realMethodEntry == NULL) {
@@ -463,7 +464,7 @@
     if (gDvmJit.methodTable) {
         int len = strlen(desc->method->clazz->descriptor) +
                   strlen(desc->method->name) + 1;
-        char *fullSignature = dvmCompilerNew(len, true);
+        char *fullSignature = (char *)dvmCompilerNew(len, true);
         strcpy(fullSignature, desc->method->clazz->descriptor);
         strcat(fullSignature, desc->method->name);
 
@@ -558,7 +559,7 @@
     while (1) {
         MIR *insn;
         int width;
-        insn = dvmCompilerNew(sizeof(MIR), true);
+        insn = (MIR *)dvmCompilerNew(sizeof(MIR), true);
         insn->offset = curOffset;
         width = parseInsn(codePtr, &insn->dalvikInsn, cUnit.printMe);
 
@@ -574,9 +575,9 @@
         if (flags & kInstrInvoke) {
             assert(numInsts == 1);
             CallsiteInfo *callsiteInfo =
-                dvmCompilerNew(sizeof(CallsiteInfo), true);
-            callsiteInfo->clazz = currRun[1].meta;
-            callsiteInfo->method = currRun[2].meta;
+                (CallsiteInfo *)dvmCompilerNew(sizeof(CallsiteInfo), true);
+            callsiteInfo->clazz = (ClassObject *)currRun[1].meta;
+            callsiteInfo->method = (Method *)currRun[2].meta;
             insn->meta.callsiteInfo = callsiteInfo;
         }
 
@@ -867,7 +868,7 @@
     cUnit.traceDesc = desc;
     cUnit.numBlocks = numBlocks;
     blockList = cUnit.blockList =
-        dvmCompilerNew(sizeof(BasicBlock *) * numBlocks, true);
+        (BasicBlock **)dvmCompilerNew(sizeof(BasicBlock *) * numBlocks, true);
 
     int i;
 
@@ -968,7 +969,7 @@
     switch (insn->opcode) {
         case OP_NEW_INSTANCE:
         case OP_CHECK_CAST: {
-            ClassObject *classPtr = (void*)
+            ClassObject *classPtr = (ClassObject *)(void*)
               (method->clazz->pDvmDex->pResClasses[insn->vB]);
 
             /* Class hasn't been initialized yet */
@@ -1091,7 +1092,7 @@
      * basic block. Identify block boundaries at the mean time.
      */
     while (codePtr < codeEnd) {
-        MIR *insn = dvmCompilerNew(sizeof(MIR), true);
+        MIR *insn = (MIR *)dvmCompilerNew(sizeof(MIR), true);
         insn->offset = curOffset;
         int width = parseInsn(codePtr, &insn->dalvikInsn, false);
         bool isInvoke = false;
@@ -1151,7 +1152,7 @@
     }
 
     BasicBlock **blockList;
-    blockList = cUnit->blockList =
+    blockList = cUnit->blockList = (BasicBlock **)
         dvmCompilerNew(sizeof(BasicBlock *) * (numBlocks + numInvokeTargets),
                        true);
 
diff --git a/vm/compiler/InlineTransformation.c b/vm/compiler/InlineTransformation.c
index 0b1330f..d9a6eea 100644
--- a/vm/compiler/InlineTransformation.c
+++ b/vm/compiler/InlineTransformation.c
@@ -43,7 +43,7 @@
 {
     BasicBlock *moveResultBB = invokeBB->fallThrough;
     MIR *moveResultMIR = moveResultBB->firstMIRInsn;
-    MIR *newGetterMIR = dvmCompilerNew(sizeof(MIR), true);
+    MIR *newGetterMIR = (MIR *)dvmCompilerNew(sizeof(MIR), true);
     DecodedInstruction getterInsn;
 
     dexDecodeInstruction(calleeMethod->insns, &getterInsn);
@@ -100,7 +100,7 @@
     dvmCompilerInsertMIRAfter(invokeBB, invokeMIR, newGetterMIR);
 
     if (isPredicted) {
-        MIR *invokeMIRSlow = dvmCompilerNew(sizeof(MIR), true);
+        MIR *invokeMIRSlow = (MIR *)dvmCompilerNew(sizeof(MIR), true);
         *invokeMIRSlow = *invokeMIR;
         invokeMIR->dalvikInsn.opcode = kMirOpCheckInlinePrediction;
 
@@ -134,7 +134,7 @@
                          bool isPredicted,
                          bool isRange)
 {
-    MIR *newSetterMIR = dvmCompilerNew(sizeof(MIR), true);
+    MIR *newSetterMIR = (MIR *)dvmCompilerNew(sizeof(MIR), true);
     DecodedInstruction setterInsn;
 
     dexDecodeInstruction(calleeMethod->insns, &setterInsn);
@@ -179,7 +179,7 @@
     dvmCompilerInsertMIRAfter(invokeBB, invokeMIR, newSetterMIR);
 
     if (isPredicted) {
-        MIR *invokeMIRSlow = dvmCompilerNew(sizeof(MIR), true);
+        MIR *invokeMIRSlow = (MIR *)dvmCompilerNew(sizeof(MIR), true);
         *invokeMIRSlow = *invokeMIR;
         invokeMIR->dalvikInsn.opcode = kMirOpCheckInlinePrediction;
 
@@ -246,7 +246,7 @@
                                      MIR *invokeMIR,
                                      BasicBlock *invokeBB)
 {
-    MIR *invokeMIRSlow = dvmCompilerNew(sizeof(MIR), true);
+    MIR *invokeMIRSlow = (MIR *)dvmCompilerNew(sizeof(MIR), true);
     *invokeMIRSlow = *invokeMIR;
     invokeMIR->dalvikInsn.opcode = kMirOpCheckInlinePrediction;
 
diff --git a/vm/compiler/IntermediateRep.c b/vm/compiler/IntermediateRep.c
index 825a690..2988900 100644
--- a/vm/compiler/IntermediateRep.c
+++ b/vm/compiler/IntermediateRep.c
@@ -20,7 +20,7 @@
 /* Allocate a new basic block */
 BasicBlock *dvmCompilerNewBB(BBType blockType)
 {
-    BasicBlock *bb = dvmCompilerNew(sizeof(BasicBlock), true);
+    BasicBlock *bb = (BasicBlock *)dvmCompilerNew(sizeof(BasicBlock), true);
     bb->blockType = blockType;
     return bb;
 }
diff --git a/vm/compiler/Loop.c b/vm/compiler/Loop.c
index 031464c..32d9b09 100644
--- a/vm/compiler/Loop.c
+++ b/vm/compiler/Loop.c
@@ -57,7 +57,7 @@
         if (!dvmIsBitSet(phiV, i)) {
             continue;
         }
-        MIR *phi = dvmCompilerNew(sizeof(MIR), true);
+        MIR *phi = (MIR *)dvmCompilerNew(sizeof(MIR), true);
         phi->dalvikInsn.opcode = kMirOpPhi;
         phi->dalvikInsn.vA = i;
         dvmCompilerPrependMIR(loopBody, phi);
@@ -76,7 +76,7 @@
         int dalvikReg = mir->dalvikInsn.vA;
 
         mir->ssaRep->numUses = 2;
-        mir->ssaRep->uses = dvmCompilerNew(sizeof(int) * 2, false);
+        mir->ssaRep->uses = (int *)dvmCompilerNew(sizeof(int) * 2, false);
         mir->ssaRep->uses[0] =
             DECODE_REG(entry->dataFlowInfo->dalvikToSSAMap[dalvikReg]);
         mir->ssaRep->uses[1] =
@@ -283,7 +283,8 @@
             }
             if (arrayAccessInfo == NULL) {
                 arrayAccessInfo =
-                    dvmCompilerNew(sizeof(ArrayAccessInfo), false);
+                    (ArrayAccessInfo *)dvmCompilerNew(sizeof(ArrayAccessInfo),
+                                                      false);
                 arrayAccessInfo->ivReg = ivInfo->basicSSAReg;
                 arrayAccessInfo->arrayReg = arrayReg;
                 arrayAccessInfo->maxC = (ivInfo->c > 0) ? ivInfo->c : 0;
@@ -402,7 +403,7 @@
         idxReg = DECODE_REG(
             dvmConvertSSARegToDalvik(cUnit, arrayAccessInfo->ivReg));
 
-        MIR *rangeCheckMIR = dvmCompilerNew(sizeof(MIR), true);
+        MIR *rangeCheckMIR = (MIR *)dvmCompilerNew(sizeof(MIR), true);
         rangeCheckMIR->dalvikInsn.opcode = (loopAnalysis->isCountUpLoop) ?
             kMirOpNullNRangeUpCheck : kMirOpNullNRangeDownCheck;
         rangeCheckMIR->dalvikInsn.vA = arrayReg;
@@ -422,7 +423,7 @@
 
     if (loopAnalysis->arrayAccessInfo->numUsed != 0) {
         if (loopAnalysis->isCountUpLoop) {
-            MIR *boundCheckMIR = dvmCompilerNew(sizeof(MIR), true);
+            MIR *boundCheckMIR = (MIR *)dvmCompilerNew(sizeof(MIR), true);
             boundCheckMIR->dalvikInsn.opcode = kMirOpLowerBound;
             boundCheckMIR->dalvikInsn.vA = idxReg;
             boundCheckMIR->dalvikInsn.vB = globalMinC;
@@ -430,7 +431,7 @@
         } else {
             if (loopAnalysis->loopBranchOpcode == OP_IF_LT ||
                 loopAnalysis->loopBranchOpcode == OP_IF_LE) {
-                MIR *boundCheckMIR = dvmCompilerNew(sizeof(MIR), true);
+                MIR *boundCheckMIR = (MIR *)dvmCompilerNew(sizeof(MIR), true);
                 boundCheckMIR->dalvikInsn.opcode = kMirOpLowerBound;
                 boundCheckMIR->dalvikInsn.vA = loopAnalysis->endConditionReg;
                 boundCheckMIR->dalvikInsn.vB = globalMinC;
@@ -447,14 +448,14 @@
             } else if (loopAnalysis->loopBranchOpcode == OP_IF_LTZ) {
                 /* Array index will fall below 0 */
                 if (globalMinC < 0) {
-                    MIR *boundCheckMIR = dvmCompilerNew(sizeof(MIR), true);
+                    MIR *boundCheckMIR = (MIR *)dvmCompilerNew(sizeof(MIR), true);
                     boundCheckMIR->dalvikInsn.opcode = kMirOpPunt;
                     dvmCompilerAppendMIR(entry, boundCheckMIR);
                 }
             } else if (loopAnalysis->loopBranchOpcode == OP_IF_LEZ) {
                 /* Array index will fall below 0 */
                 if (globalMinC < -1) {
-                    MIR *boundCheckMIR = dvmCompilerNew(sizeof(MIR), true);
+                    MIR *boundCheckMIR = (MIR *)dvmCompilerNew(sizeof(MIR), true);
                     boundCheckMIR->dalvikInsn.opcode = kMirOpPunt;
                     dvmCompilerAppendMIR(entry, boundCheckMIR);
                 }
@@ -473,7 +474,8 @@
  */
 bool dvmCompilerLoopOpt(CompilationUnit *cUnit)
 {
-    LoopAnalysis *loopAnalysis = dvmCompilerNew(sizeof(LoopAnalysis), true);
+    LoopAnalysis *loopAnalysis =
+        (LoopAnalysis *)dvmCompilerNew(sizeof(LoopAnalysis), true);
 
     assert(cUnit->blockList[0]->blockType == kTraceEntryBlock);
     assert(cUnit->blockList[2]->blockType == kDalvikByteCode);
@@ -494,14 +496,16 @@
 
     /* Constant propagation */
     cUnit->isConstantV = dvmAllocBitVector(cUnit->numSSARegs, false);
-    cUnit->constantValues = dvmCompilerNew(sizeof(int) * cUnit->numSSARegs,
-                                           true);
+    cUnit->constantValues =
+        (int *)dvmCompilerNew(sizeof(int) * cUnit->numSSARegs,
+                              true);
     dvmCompilerDataFlowAnalysisDispatcher(cUnit,
                                           dvmCompilerDoConstantPropagation);
     DEBUG_LOOP(dumpConstants(cUnit);)
 
     /* Find induction variables - basic and dependent */
-    loopAnalysis->ivList = dvmCompilerNew(sizeof(GrowableList), true);
+    loopAnalysis->ivList =
+        (GrowableList *)dvmCompilerNew(sizeof(GrowableList), true);
     dvmInitGrowableList(loopAnalysis->ivList, 4);
     loopAnalysis->isIndVarV = dvmAllocBitVector(cUnit->numSSARegs, false);
     dvmCompilerDataFlowAnalysisDispatcher(cUnit,
@@ -512,7 +516,8 @@
     if (!isLoopOptimizable(cUnit))
         return false;
 
-    loopAnalysis->arrayAccessInfo = dvmCompilerNew(sizeof(GrowableList), true);
+    loopAnalysis->arrayAccessInfo =
+        (GrowableList *)dvmCompilerNew(sizeof(GrowableList), true);
     dvmInitGrowableList(loopAnalysis->arrayAccessInfo, 4);
     loopAnalysis->bodyIsClean = doLoopBodyCodeMotion(cUnit);
     DEBUG_LOOP(dumpHoistedChecks(cUnit);)
diff --git a/vm/compiler/Ralloc.c b/vm/compiler/Ralloc.c
index 744bc32..0dd67b7 100644
--- a/vm/compiler/Ralloc.c
+++ b/vm/compiler/Ralloc.c
@@ -150,7 +150,7 @@
         }
     } else {
         // Compute live ranges
-        ranges = dvmCompilerNew(cUnit->numSSARegs * sizeof(*ranges), true);
+        ranges = (LiveRange *)dvmCompilerNew(cUnit->numSSARegs * sizeof(*ranges), true);
         for (i=0; i < cUnit->numSSARegs; i++)
             ranges[i].active = false;
         seqNum = computeLiveRange(ranges, cUnit->blockList[i], seqNum);
diff --git a/vm/compiler/Utility.c b/vm/compiler/Utility.c
index daeb893..4b942ef 100644
--- a/vm/compiler/Utility.c
+++ b/vm/compiler/Utility.c
@@ -117,7 +117,7 @@
     void *newArray = dvmCompilerNew(sizeof(void *) * newLength, true);
     memcpy(newArray, gList->elemList, sizeof(void *) * gList->numAllocated);
     gList->numAllocated = newLength;
-    gList->elemList = newArray;
+    gList->elemList = (void **)newArray;
 }
 
 /* Insert a new element into the growable list */
@@ -280,7 +280,7 @@
         /* Round up to word boundaries for "num+1" bits */
         int newSize = (num + 1 + 31) >> 5;
         assert(newSize > pBits->storageSize);
-        u4 *newStorage = dvmCompilerNew(newSize * sizeof(u4), false);
+        u4 *newStorage = (u4*)dvmCompilerNew(newSize * sizeof(u4), false);
         memcpy(newStorage, pBits->storage, pBits->storageSize * sizeof(u4));
         memset(&newStorage[pBits->storageSize], 0,
                (newSize - pBits->storageSize) * sizeof(u4));
diff --git a/vm/compiler/codegen/arm/ArchUtility.c b/vm/compiler/codegen/arm/ArchUtility.c
index 0b76eb5..8682c1a 100644
--- a/vm/compiler/codegen/arm/ArchUtility.c
+++ b/vm/compiler/codegen/arm/ArchUtility.c
@@ -375,7 +375,7 @@
     LOGD("installed code is at %p\n", cUnit->baseAddr);
     LOGD("total size is %d bytes\n", cUnit->totalSize);
     for (lirInsn = cUnit->firstLIRInsn; lirInsn; lirInsn = lirInsn->next) {
-        dvmDumpLIRInsn(lirInsn, cUnit->baseAddr);
+        dvmDumpLIRInsn(lirInsn, (unsigned char *) cUnit->baseAddr);
     }
     for (lirInsn = cUnit->wordList; lirInsn; lirInsn = lirInsn->next) {
         armLIR = (ArmLIR *) lirInsn;
diff --git a/vm/compiler/codegen/arm/Assemble.c b/vm/compiler/codegen/arm/Assemble.c
index 42a8d37..16e8e15 100644
--- a/vm/compiler/codegen/arm/Assemble.c
+++ b/vm/compiler/codegen/arm/Assemble.c
@@ -973,7 +973,8 @@
             int delta = target - pc;
             if (delta > 126 || delta < 0) {
                 /* Convert to cmp rx,#0 / b[eq/ne] tgt pair */
-                ArmLIR *newInst = dvmCompilerNew(sizeof(ArmLIR), true);
+                ArmLIR *newInst =
+                    (ArmLIR *)dvmCompilerNew(sizeof(ArmLIR), true);
                 /* Make new branch instruction and insert after */
                 newInst->opcode = kThumbBCond;
                 newInst->operands[0] = 0;
@@ -1280,7 +1281,7 @@
     }
 
     /* Allocate enough space for the code block */
-    cUnit->codeBuffer = dvmCompilerNew(chainCellOffset, true);
+    cUnit->codeBuffer = (unsigned char *)dvmCompilerNew(chainCellOffset, true);
     if (cUnit->codeBuffer == NULL) {
         LOGE("Code buffer allocation failure\n");
         cUnit->baseAddr = NULL;
@@ -1487,7 +1488,7 @@
          * will bring the uninitialized chaining cell to life.
          */
         android_atomic_release_store((int32_t)newContent->clazz,
-            (void*) &cellAddr->clazz);
+            (volatile int32_t *)(void *)&cellAddr->clazz);
         cacheflush((intptr_t) cellAddr, (intptr_t) (cellAddr+1), 0);
         UPDATE_CODE_CACHE_PATCHES();
 
@@ -1583,7 +1584,7 @@
          * trigger immediate patching and will continue to fail to match with
          * a real clazz pointer.
          */
-        cell->clazz = (void *) PREDICTED_CHAIN_FAKE_CLAZZ;
+        cell->clazz = (ClassObject *) PREDICTED_CHAIN_FAKE_CLAZZ;
 
         UPDATE_CODE_CACHE_PATCHES();
         PROTECT_CODE_CACHE(cell, sizeof(*cell));
@@ -1912,7 +1913,7 @@
      * be a meta info field (only used by callsite info for now).
      */
     if (!desc->trace[idx].frag.isCode) {
-        const Method *method = desc->trace[idx+1].meta;
+        const Method *method = (const Method *)desc->trace[idx+1].meta;
         char *methodDesc = dexProtoCopyMethodDescriptor(&method->prototype);
         /* Print the callee info in the trace */
         LOGD("    -> %s%s;%s", method->clazz->descriptor, method->name,
@@ -1964,8 +1965,8 @@
 /* qsort callback function */
 static int sortTraceProfileCount(const void *entry1, const void *entry2)
 {
-    const JitEntry *jitEntry1 = entry1;
-    const JitEntry *jitEntry2 = entry2;
+    const JitEntry *jitEntry1 = (const JitEntry *)entry1;
+    const JitEntry *jitEntry2 = (const JitEntry *)entry2;
 
     int count1 = getProfileCount(jitEntry1);
     int count2 = getProfileCount(jitEntry2);
@@ -1984,7 +1985,7 @@
     dvmLockMutex(&gDvmJit.tableLock);
 
     /* Sort the entries by descending order */
-    sortedEntries = malloc(sizeof(JitEntry) * gDvmJit.jitTableSize);
+    sortedEntries = (JitEntry *)malloc(sizeof(JitEntry) * gDvmJit.jitTableSize);
     if (sortedEntries == NULL)
         goto done;
     memcpy(sortedEntries, gDvmJit.pJitEntryTable,
diff --git a/vm/compiler/codegen/arm/CodegenCommon.c b/vm/compiler/codegen/arm/CodegenCommon.c
index 4a20579..6558f67 100644
--- a/vm/compiler/codegen/arm/CodegenCommon.c
+++ b/vm/compiler/codegen/arm/CodegenCommon.c
@@ -204,7 +204,7 @@
  */
 static ArmLIR *newLIR0(CompilationUnit *cUnit, ArmOpcode opcode)
 {
-    ArmLIR *insn = dvmCompilerNew(sizeof(ArmLIR), true);
+    ArmLIR *insn = (ArmLIR *) dvmCompilerNew(sizeof(ArmLIR), true);
     assert(isPseudoOpcode(opcode) || (EncodingMap[opcode].flags & NO_OPERAND));
     insn->opcode = opcode;
     setupResourceMasks(insn);
@@ -215,7 +215,7 @@
 static ArmLIR *newLIR1(CompilationUnit *cUnit, ArmOpcode opcode,
                            int dest)
 {
-    ArmLIR *insn = dvmCompilerNew(sizeof(ArmLIR), true);
+    ArmLIR *insn = (ArmLIR *) dvmCompilerNew(sizeof(ArmLIR), true);
     assert(isPseudoOpcode(opcode) || (EncodingMap[opcode].flags & IS_UNARY_OP));
     insn->opcode = opcode;
     insn->operands[0] = dest;
@@ -227,7 +227,7 @@
 static ArmLIR *newLIR2(CompilationUnit *cUnit, ArmOpcode opcode,
                            int dest, int src1)
 {
-    ArmLIR *insn = dvmCompilerNew(sizeof(ArmLIR), true);
+    ArmLIR *insn = (ArmLIR *) dvmCompilerNew(sizeof(ArmLIR), true);
     assert(isPseudoOpcode(opcode) ||
            (EncodingMap[opcode].flags & IS_BINARY_OP));
     insn->opcode = opcode;
@@ -241,7 +241,7 @@
 static ArmLIR *newLIR3(CompilationUnit *cUnit, ArmOpcode opcode,
                            int dest, int src1, int src2)
 {
-    ArmLIR *insn = dvmCompilerNew(sizeof(ArmLIR), true);
+    ArmLIR *insn = (ArmLIR *) dvmCompilerNew(sizeof(ArmLIR), true);
     if (!(EncodingMap[opcode].flags & IS_TERTIARY_OP)) {
         LOGE("Bad LIR3: %s[%d]",EncodingMap[opcode].name,opcode);
     }
@@ -260,7 +260,7 @@
 static ArmLIR *newLIR4(CompilationUnit *cUnit, ArmOpcode opcode,
                            int dest, int src1, int src2, int info)
 {
-    ArmLIR *insn = dvmCompilerNew(sizeof(ArmLIR), true);
+    ArmLIR *insn = (ArmLIR *) dvmCompilerNew(sizeof(ArmLIR), true);
     assert(isPseudoOpcode(opcode) ||
            (EncodingMap[opcode].flags & IS_QUAD_OP));
     insn->opcode = opcode;
@@ -321,7 +321,7 @@
 {
     /* Add the constant to the literal pool */
     if (!inPlace) {
-        ArmLIR *newValue = dvmCompilerNew(sizeof(ArmLIR), true);
+        ArmLIR *newValue = (ArmLIR *) dvmCompilerNew(sizeof(ArmLIR), true);
         newValue->operands[0] = value;
         newValue->generic.next = cUnit->wordList;
         cUnit->wordList = (LIR *) newValue;
@@ -371,7 +371,7 @@
     /* Set up the place holder to reconstruct this Dalvik PC */
     if (pcrLabel == NULL) {
         int dPC = (int) (cUnit->method->insns + dOffset);
-        pcrLabel = dvmCompilerNew(sizeof(ArmLIR), true);
+        pcrLabel = (ArmLIR *) dvmCompilerNew(sizeof(ArmLIR), true);
         pcrLabel->opcode = kArmPseudoPCReconstructionCell;
         pcrLabel->operands[0] = dPC;
         pcrLabel->operands[1] = dOffset;
diff --git a/vm/compiler/codegen/arm/CodegenDriver.c b/vm/compiler/codegen/arm/CodegenDriver.c
index 98236b6..2a53592 100644
--- a/vm/compiler/codegen/arm/CodegenDriver.c
+++ b/vm/compiler/codegen/arm/CodegenDriver.c
@@ -205,7 +205,7 @@
 static void selfVerificationBranchInsert(LIR *currentLIR, ArmOpcode opcode,
                           int dest, int src1)
 {
-     ArmLIR *insn = dvmCompilerNew(sizeof(ArmLIR), true);
+     ArmLIR *insn = (ArmLIR *) dvmCompilerNew(sizeof(ArmLIR), true);
      insn->opcode = opcode;
      insn->operands[0] = dest;
      insn->operands[1] = src1;
@@ -912,7 +912,7 @@
     /* Insert branch, but defer setting of target */
     ArmLIR *branch = genUnconditionalBranch(cUnit, NULL);
     /* Set up the place holder to reconstruct this Dalvik PC */
-    ArmLIR *pcrLabel = dvmCompilerNew(sizeof(ArmLIR), true);
+    ArmLIR *pcrLabel = (ArmLIR *) dvmCompilerNew(sizeof(ArmLIR), true);
     pcrLabel->opcode = kArmPseudoPCReconstructionCell;
     pcrLabel->operands[0] = dPC;
     pcrLabel->operands[1] = mir->offset;
@@ -1156,7 +1156,7 @@
      */
     if (pcrLabel == NULL) {
         int dPC = (int) (cUnit->method->insns + mir->offset);
-        pcrLabel = dvmCompilerNew(sizeof(ArmLIR), true);
+        pcrLabel = (ArmLIR *) dvmCompilerNew(sizeof(ArmLIR), true);
         pcrLabel->opcode = kArmPseudoPCReconstructionCell;
         pcrLabel->operands[0] = dPC;
         pcrLabel->operands[1] = mir->offset;
@@ -1481,7 +1481,7 @@
 
             isVolatile = (mir->dalvikInsn.opcode == OP_SGET_VOLATILE) ||
                          (mir->dalvikInsn.opcode == OP_SGET_OBJECT_VOLATILE) ||
-                         dvmIsVolatileField(fieldPtr);
+                         dvmIsVolatileField((Field *) fieldPtr);
 
             rlDest = dvmCompilerGetDest(cUnit, mir, 0);
             rlResult = dvmCompilerEvalLoc(cUnit, rlDest, kAnyReg, true);
@@ -1541,7 +1541,7 @@
 
             isVolatile = (mir->dalvikInsn.opcode == OP_SPUT_VOLATILE) ||
                          (mir->dalvikInsn.opcode == OP_SPUT_OBJECT_VOLATILE) ||
-                         dvmIsVolatileField(fieldPtr);
+                         dvmIsVolatileField((Field *) fieldPtr);
 
             isSputObject = (mir->dalvikInsn.opcode == OP_SPUT_OBJECT) ||
                            (mir->dalvikInsn.opcode == OP_SPUT_OBJECT_VOLATILE);
@@ -1600,7 +1600,7 @@
              * Obey the calling convention and don't mess with the register
              * usage.
              */
-            ClassObject *classPtr = (void*)
+            ClassObject *classPtr = (ClassObject *)
               (cUnit->method->clazz->pDvmDex->pResClasses[mir->dalvikInsn.vB]);
 
             if (classPtr == NULL) {
@@ -3008,7 +3008,7 @@
              */
             if (pcrLabel == NULL) {
                 int dPC = (int) (cUnit->method->insns + mir->offset);
-                pcrLabel = dvmCompilerNew(sizeof(ArmLIR), true);
+                pcrLabel = (ArmLIR *) dvmCompilerNew(sizeof(ArmLIR), true);
                 pcrLabel->opcode = kArmPseudoPCReconstructionCell;
                 pcrLabel->operands[0] = dPC;
                 pcrLabel->operands[1] = mir->offset;
@@ -3832,8 +3832,8 @@
 static void handleExtendedMIR(CompilationUnit *cUnit, MIR *mir)
 {
     int opOffset = mir->dalvikInsn.opcode - kMirOpFirst;
-    char *msg = dvmCompilerNew(strlen(extendedMIROpNames[opOffset]) + 1,
-                               false);
+    char *msg = (char *)dvmCompilerNew(strlen(extendedMIROpNames[opOffset]) + 1,
+                                        false);
     strcpy(msg, extendedMIROpNames[opOffset]);
     newLIR1(cUnit, kArmPseudoExtended, (int) msg);
 
@@ -3880,7 +3880,7 @@
                                 ArmLIR *bodyLabel)
 {
     /* Set up the place holder to reconstruct this Dalvik PC */
-    ArmLIR *pcrLabel = dvmCompilerNew(sizeof(ArmLIR), true);
+    ArmLIR *pcrLabel = (ArmLIR *) dvmCompilerNew(sizeof(ArmLIR), true);
     pcrLabel->opcode = kArmPseudoPCReconstructionCell;
     pcrLabel->operands[0] =
         (int) (cUnit->method->insns + entry->startOffset);
@@ -3892,13 +3892,13 @@
      * Next, create two branches - one branch over to the loop body and the
      * other branch to the PCR cell to punt.
      */
-    ArmLIR *branchToBody = dvmCompilerNew(sizeof(ArmLIR), true);
+    ArmLIR *branchToBody = (ArmLIR *) dvmCompilerNew(sizeof(ArmLIR), true);
     branchToBody->opcode = kThumbBUncond;
     branchToBody->generic.target = (LIR *) bodyLabel;
     setupResourceMasks(branchToBody);
     cUnit->loopAnalysis->branchToBody = (LIR *) branchToBody;
 
-    ArmLIR *branchToPCR = dvmCompilerNew(sizeof(ArmLIR), true);
+    ArmLIR *branchToPCR = (ArmLIR *) dvmCompilerNew(sizeof(ArmLIR), true);
     branchToPCR->opcode = kThumbBUncond;
     branchToPCR->generic.target = (LIR *) pcrLabel;
     setupResourceMasks(branchToPCR);
@@ -3928,7 +3928,7 @@
 {
     /* Used to hold the labels of each block */
     ArmLIR *labelList =
-        dvmCompilerNew(sizeof(ArmLIR) * cUnit->numBlocks, true);
+        (ArmLIR *) dvmCompilerNew(sizeof(ArmLIR) * cUnit->numBlocks, true);
     GrowableList chainingListByType[kChainingCellGap];
     int i;
 
@@ -4345,6 +4345,7 @@
 /* Accept the work and start compiling */
 bool dvmCompilerDoWork(CompilerWorkOrder *work)
 {
+    JitTraceDescription *desc;
     bool res;
 
     if (gDvmJit.codeCacheFull) {
@@ -4354,14 +4355,16 @@
     switch (work->kind) {
         case kWorkOrderTrace:
             /* Start compilation with maximally allowed trace length */
-            res = dvmCompileTrace(work->info, JIT_MAX_TRACE_LEN, &work->result,
+            desc = (JitTraceDescription *)work->info;
+            res = dvmCompileTrace(desc, JIT_MAX_TRACE_LEN, &work->result,
                                   work->bailPtr, 0 /* no hints */);
             break;
         case kWorkOrderTraceDebug: {
             bool oldPrintMe = gDvmJit.printMe;
             gDvmJit.printMe = true;
             /* Start compilation with maximally allowed trace length */
-            res = dvmCompileTrace(work->info, JIT_MAX_TRACE_LEN, &work->result,
+            desc = (JitTraceDescription *)work->info;
+            res = dvmCompileTrace(desc, JIT_MAX_TRACE_LEN, &work->result,
                                   work->bailPtr, 0 /* no hints */);
             gDvmJit.printMe = oldPrintMe;
             break;
diff --git a/vm/compiler/codegen/arm/LocalOptimizations.c b/vm/compiler/codegen/arm/LocalOptimizations.c
index 33e1e41..d91734f 100644
--- a/vm/compiler/codegen/arm/LocalOptimizations.c
+++ b/vm/compiler/codegen/arm/LocalOptimizations.c
@@ -147,7 +147,7 @@
                         /* The store can be sunk for at least one cycle */
                         if (sinkDistance != 0) {
                             ArmLIR *newStoreLIR =
-                                dvmCompilerNew(sizeof(ArmLIR), true);
+                                (ArmLIR *)dvmCompilerNew(sizeof(ArmLIR), true);
                             *newStoreLIR = *thisLIR;
                             newStoreLIR->age = cUnit->optRound;
                             /*
@@ -369,7 +369,7 @@
                         /* The load can be hoisted for at least one cycle */
                         if (hoistDistance != 0) {
                             ArmLIR *newLoadLIR =
-                                dvmCompilerNew(sizeof(ArmLIR), true);
+                                (ArmLIR *)dvmCompilerNew(sizeof(ArmLIR), true);
                             *newLoadLIR = *thisLIR;
                             newLoadLIR->age = cUnit->optRound;
                             /*
@@ -473,7 +473,7 @@
                     /* The store can be hoisted for at least one cycle */
                     if (hoistDistance != 0) {
                         ArmLIR *newLoadLIR =
-                            dvmCompilerNew(sizeof(ArmLIR), true);
+                            (ArmLIR *)dvmCompilerNew(sizeof(ArmLIR), true);
                         *newLoadLIR = *thisLIR;
                         newLoadLIR->age = cUnit->optRound;
                         /*
diff --git a/vm/compiler/codegen/arm/Thumb2/Factory.c b/vm/compiler/codegen/arm/Thumb2/Factory.c
index 141c925..f50edfe 100644
--- a/vm/compiler/codegen/arm/Thumb2/Factory.c
+++ b/vm/compiler/codegen/arm/Thumb2/Factory.c
@@ -60,7 +60,7 @@
     if (dataTarget == NULL) {
         dataTarget = addWordData(cUnit, value, false);
     }
-    ArmLIR *loadPcRel = dvmCompilerNew(sizeof(ArmLIR), true);
+    ArmLIR *loadPcRel = (ArmLIR *) dvmCompilerNew(sizeof(ArmLIR), true);
     loadPcRel->opcode = kThumb2Vldrs;
     loadPcRel->generic.target = (LIR *) dataTarget;
     loadPcRel->operands[0] = rDest;
@@ -170,7 +170,7 @@
     if (dataTarget == NULL) {
         dataTarget = addWordData(cUnit, value, false);
     }
-    ArmLIR *loadPcRel = dvmCompilerNew(sizeof(ArmLIR), true);
+    ArmLIR *loadPcRel = (ArmLIR *) dvmCompilerNew(sizeof(ArmLIR), true);
     loadPcRel->opcode = kThumb2LdrPcRel12;
     loadPcRel->generic.target = (LIR *) dataTarget;
     loadPcRel->operands[0] = rDest;
@@ -1121,7 +1121,7 @@
 
 static ArmLIR *fpRegCopy(CompilationUnit *cUnit, int rDest, int rSrc)
 {
-    ArmLIR* res = dvmCompilerNew(sizeof(ArmLIR), true);
+    ArmLIR* res = (ArmLIR *) dvmCompilerNew(sizeof(ArmLIR), true);
     res->operands[0] = rDest;
     res->operands[1] = rSrc;
     if (rDest == rSrc) {
@@ -1151,7 +1151,7 @@
     ArmOpcode opcode;
     if (FPREG(rDest) || FPREG(rSrc))
         return fpRegCopy(cUnit, rDest, rSrc);
-    res = dvmCompilerNew(sizeof(ArmLIR), true);
+    res = (ArmLIR *) dvmCompilerNew(sizeof(ArmLIR), true);
     if (LOWREG(rDest) && LOWREG(rSrc))
         opcode = kThumbMovRR;
     else if (!LOWREG(rDest) && !LOWREG(rSrc))
diff --git a/vm/compiler/codegen/arm/Thumb2/Gen.c b/vm/compiler/codegen/arm/Thumb2/Gen.c
index 825b271..8d12d77 100644
--- a/vm/compiler/codegen/arm/Thumb2/Gen.c
+++ b/vm/compiler/codegen/arm/Thumb2/Gen.c
@@ -89,13 +89,13 @@
 {
     int numTemps = sizeof(coreTemps)/sizeof(int);
     int numFPTemps = sizeof(fpTemps)/sizeof(int);
-    RegisterPool *pool = dvmCompilerNew(sizeof(*pool), true);
+    RegisterPool *pool = (RegisterPool *)dvmCompilerNew(sizeof(*pool), true);
     cUnit->regPool = pool;
     pool->numCoreTemps = numTemps;
-    pool->coreTemps =
+    pool->coreTemps = (RegisterInfo *)
             dvmCompilerNew(numTemps * sizeof(*cUnit->regPool->coreTemps), true);
     pool->numFPTemps = numFPTemps;
-    pool->FPTemps =
+    pool->FPTemps = (RegisterInfo *)
             dvmCompilerNew(numFPTemps * sizeof(*cUnit->regPool->FPTemps), true);
     pool->numCoreRegs = 0;
     pool->coreRegs = NULL;
diff --git a/vm/hprof/Hprof.c b/vm/hprof/Hprof.c
index e42bd10..44547a1 100644
--- a/vm/hprof/Hprof.c
+++ b/vm/hprof/Hprof.c
@@ -45,7 +45,7 @@
     hprofStartup_Stack();
 #endif
 
-    hprof_context_t *ctx = malloc(sizeof(*ctx));
+    hprof_context_t *ctx = (hprof_context_t *)malloc(sizeof(*ctx));
     if (ctx == NULL) {
         LOGE("hprof: can't allocate context.\n");
         return NULL;
@@ -72,7 +72,7 @@
      * Create a new context struct for the start of the file.  We
      * heap-allocate it so we can share the "free" function.
      */
-    hprof_context_t *headCtx = malloc(sizeof(*headCtx));
+    hprof_context_t *headCtx = (hprof_context_t *)malloc(sizeof(*headCtx));
     if (headCtx == NULL) {
         LOGE("hprof: can't allocate context.\n");
         hprofFreeContext(tailCtx);
@@ -212,10 +212,10 @@
 
     assert(arg != NULL);
     assert(type < NELEM(xlate));
-    ctx = arg;
+    ctx = (hprof_context_t *)arg;
     ctx->gcScanState = xlate[type];
     ctx->gcThreadSerialNumber = threadId;
-    hprofMarkRootObject(ctx, addr, 0);
+    hprofMarkRootObject(ctx, (Object *)addr, 0);
     ctx->gcScanState = 0;
     ctx->gcThreadSerialNumber = 0;
 }
@@ -230,8 +230,8 @@
 
     assert(ptr != NULL);
     assert(arg != NULL);
-    obj = ptr;
-    ctx = arg;
+    obj = (Object *)ptr;
+    ctx = (hprof_context_t *)arg;
     hprofDumpHeapObject(ctx, obj);
 }
 
diff --git a/vm/hprof/HprofOutput.c b/vm/hprof/HprofOutput.c
index 25512b2..b84b298 100644
--- a/vm/hprof/HprofOutput.c
+++ b/vm/hprof/HprofOutput.c
@@ -85,7 +85,7 @@
     ctx->fd = fd;
 
     ctx->curRec.allocLen = 128;
-    ctx->curRec.body = malloc(ctx->curRec.allocLen);
+    ctx->curRec.body = (unsigned char *)malloc(ctx->curRec.allocLen);
 //xxx check for/return an error
 
     if (writeHeader) {
@@ -194,7 +194,7 @@
         if (newAllocLen < minSize) {
             newAllocLen = rec->allocLen + nmore + nmore/2;
         }
-        newBody = realloc(rec->body, newAllocLen);
+        newBody = (unsigned char *)realloc(rec->body, newAllocLen);
         if (newBody != NULL) {
             rec->body = newBody;
             rec->allocLen = newAllocLen;
diff --git a/vm/interp/Interp.c b/vm/interp/Interp.c
index 988ad2b..1dde646 100644
--- a/vm/interp/Interp.c
+++ b/vm/interp/Interp.c
@@ -228,7 +228,7 @@
             LOGV("+++ increasing breakpoint set size to %d\n", newSize);
 
             /* pSet->breakpoints will be NULL on first entry */
-            newVec = realloc(pSet->breakpoints, newSize * sizeof(Breakpoint));
+            newVec = (Breakpoint*)realloc(pSet->breakpoints, newSize * sizeof(Breakpoint));
             if (newVec == NULL)
                 return false;
 
@@ -528,7 +528,7 @@
         saveArea = SAVEAREA_FROM_FP(fp);
         method = saveArea->method;
 
-        if (!dvmIsBreakFrame(fp) && !dvmIsNativeMethod(method))
+        if (!dvmIsBreakFrame((u4*)fp) && !dvmIsNativeMethod(method))
             break;
         prevFp = fp;
     }
@@ -545,7 +545,7 @@
          */
         LOGV("##### init step while in native method\n");
         fp = prevFp;
-        assert(!dvmIsBreakFrame(fp));
+        assert(!dvmIsBreakFrame((u4*)fp));
         assert(dvmIsNativeMethod(SAVEAREA_FROM_FP(fp)->method));
         saveArea = SAVEAREA_FROM_FP(fp);
     }
diff --git a/vm/interp/Jit.c b/vm/interp/Jit.c
index 3fafe6d..8eb9856 100644
--- a/vm/interp/Jit.c
+++ b/vm/interp/Jit.c
@@ -114,7 +114,7 @@
 
     // Create a copy of the InterpState
     memcpy(&(shadowSpace->interpState), interpState, sizeof(InterpState));
-    shadowSpace->interpState.fp = shadowSpace->shadowFP;
+    shadowSpace->interpState.fp = (u4*)shadowSpace->shadowFP;
     shadowSpace->interpState.interpStackEnd = (u1*)shadowSpace->registerSpace;
 
     // Create a copy of the stack
@@ -140,7 +140,7 @@
     Thread *self = dvmThreadSelf();
     ShadowSpace *shadowSpace = self->shadowSpace;
     // Official InterpState structure
-    InterpState *realGlue = shadowSpace->glue;
+    InterpState *realGlue = (InterpState*)shadowSpace->glue;
     shadowSpace->endPC = pc;
     shadowSpace->endShadowFP = fp;
     shadowSpace->jitExitState = exitState;
diff --git a/vm/interp/Stack.c b/vm/interp/Stack.c
index 9d8f719..eaa2712 100644
--- a/vm/interp/Stack.c
+++ b/vm/interp/Stack.c
@@ -100,7 +100,7 @@
     memset(stackPtr - (method->outsSize*4), 0xaf, stackReq);
 #endif
 #ifdef EASY_GDB
-    breakSaveBlock->prevSave = FP_FROM_SAVEAREA(self->curFrame);
+    breakSaveBlock->prevSave = (StackSaveArea*)FP_FROM_SAVEAREA(self->curFrame);
     saveBlock->prevSave = breakSaveBlock;
 #endif
 
@@ -176,8 +176,10 @@
 #ifdef EASY_GDB
     if (self->curFrame == NULL)
         breakSaveBlock->prevSave = NULL;
-    else
-        breakSaveBlock->prevSave = FP_FROM_SAVEAREA(self->curFrame);
+    else {
+        void* fp = FP_FROM_SAVEAREA(self->curFrame);
+        breakSaveBlock->prevSave = (StackSaveArea*)fp;
+    }
     saveBlock->prevSave = breakSaveBlock;
 #endif
 
@@ -245,7 +247,7 @@
     memset(stackPtr, 0xaf, stackReq);
 #endif
 #ifdef EASY_GDB
-    saveBlock->prevSave = FP_FROM_SAVEAREA(self->curFrame);
+    saveBlock->prevSave = (StackSaveArea*)FP_FROM_SAVEAREA(self->curFrame);
 #endif
 
     saveBlock->prevFrame = self->curFrame;
@@ -276,13 +278,13 @@
 {
     StackSaveArea* saveBlock = SAVEAREA_FROM_FP(self->curFrame);
 
-    assert(!dvmIsBreakFrame(self->curFrame));
+    assert(!dvmIsBreakFrame((u4*)self->curFrame));
     if (saveBlock->method != SAVEAREA_FROM_FP(saveBlock->prevFrame)->method) {
         /*
          * The previous frame doesn't have the same method pointer -- we've
          * been asked to pop too much.
          */
-        assert(dvmIsBreakFrame(saveBlock->prevFrame) ||
+        assert(dvmIsBreakFrame((u4*)saveBlock->prevFrame) ||
                !dvmIsNativeMethod(
                        SAVEAREA_FROM_FP(saveBlock->prevFrame)->method));
         return false;
@@ -314,7 +316,7 @@
         return false;
 
     saveBlock = SAVEAREA_FROM_FP(self->curFrame);
-    assert(!dvmIsBreakFrame(self->curFrame));
+    assert(!dvmIsBreakFrame((u4*)self->curFrame));
 
     /*
      * Remove everything up to the break frame.  If this was a call into
@@ -523,7 +525,7 @@
          * Because we leave no space for local variables, "curFrame" points
          * directly at the method arguments.
          */
-        (*method->nativeFunc)(self->curFrame, pResult, method, self);
+        (*method->nativeFunc)((u4*)self->curFrame, pResult, method, self);
         TRACE_METHOD_EXIT(self, method);
     } else {
         dvmInterpret(self, method, pResult);
@@ -627,7 +629,7 @@
          * Because we leave no space for local variables, "curFrame" points
          * directly at the method arguments.
          */
-        (*method->nativeFunc)(self->curFrame, pResult, method, self);
+        (*method->nativeFunc)((u4*)self->curFrame, pResult, method, self);
         TRACE_METHOD_EXIT(self, method);
     } else {
         dvmInterpret(self, method, pResult);
@@ -737,7 +739,7 @@
          * Because we leave no space for local variables, "curFrame" points
          * directly at the method arguments.
          */
-        (*method->nativeFunc)(self->curFrame, &retval, method, self);
+        (*method->nativeFunc)((u4*)self->curFrame, &retval, method, self);
         TRACE_METHOD_EXIT(self, method);
     } else {
         dvmInterpret(self, method, &retval);
@@ -848,7 +850,7 @@
     int count = 0;
 
     for ( ; fp != NULL; fp = SAVEAREA_FROM_FP(fp)->prevFrame) {
-        if (!dvmIsBreakFrame(fp))
+        if (!dvmIsBreakFrame((u4*)fp))
             count++;
     }
 
@@ -884,7 +886,7 @@
     StackSaveArea* saveArea;
 
 retry:
-    if (dvmIsBreakFrame(caller)) {
+    if (dvmIsBreakFrame((u4*)caller)) {
         /* pop up one more */
         caller = SAVEAREA_FROM_FP(caller)->prevFrame;
         if (caller == NULL)
@@ -934,7 +936,7 @@
     void* callerCaller;
 
     /* at the top? */
-    if (dvmIsBreakFrame(caller) && SAVEAREA_FROM_FP(caller)->prevFrame == NULL)
+    if (dvmIsBreakFrame((u4*)caller) && SAVEAREA_FROM_FP(caller)->prevFrame == NULL)
         return NULL;
 
     /* go one more */
@@ -957,7 +959,7 @@
     int i;
 
     /* at the top? */
-    if (dvmIsBreakFrame(caller) && SAVEAREA_FROM_FP(caller)->prevFrame == NULL)
+    if (dvmIsBreakFrame((u4*)caller) && SAVEAREA_FROM_FP(caller)->prevFrame == NULL)
         return NULL;
 
     /* Walk up two frames if possible. */
@@ -994,7 +996,7 @@
         return false;
 
     for (idx = 0; fp != NULL; fp = SAVEAREA_FROM_FP(fp)->prevFrame) {
-        if (!dvmIsBreakFrame(fp))
+        if (!dvmIsBreakFrame((u4*)fp))
             array[idx++] = SAVEAREA_FROM_FP(fp)->method;
     }
     assert(idx == depth);
@@ -1109,7 +1111,7 @@
 {
     void* framePtr = thread->curFrame;
 
-    if (framePtr == NULL || dvmIsBreakFrame(framePtr))
+    if (framePtr == NULL || dvmIsBreakFrame((u4*)framePtr))
         return false;
 
     const StackSaveArea* saveArea = SAVEAREA_FROM_FP(framePtr);
@@ -1203,7 +1205,7 @@
      * The "currentPc" is updated whenever we execute an instruction that
      * might throw an exception.  Show it here.
      */
-    if (framePtr != NULL && !dvmIsBreakFrame(framePtr)) {
+    if (framePtr != NULL && !dvmIsBreakFrame((u4*)framePtr)) {
         saveArea = SAVEAREA_FROM_FP(framePtr);
 
         if (saveArea->xtra.currentPc != NULL)
@@ -1214,7 +1216,7 @@
         saveArea = SAVEAREA_FROM_FP(framePtr);
         method = saveArea->method;
 
-        if (dvmIsBreakFrame(framePtr)) {
+        if (dvmIsBreakFrame((u4*)framePtr)) {
             //dvmPrintDebugMessage(target, "  (break frame)\n");
         } else {
             int relPc;
diff --git a/vm/jdwp/ExpandBuf.c b/vm/jdwp/ExpandBuf.c
index ade239c..cb3386b 100644
--- a/vm/jdwp/ExpandBuf.c
+++ b/vm/jdwp/ExpandBuf.c
@@ -93,7 +93,7 @@
     while (pBuf->curLen + newCount > pBuf->maxLen)
         pBuf->maxLen *= 2;
 
-    newPtr = realloc(pBuf->storage, pBuf->maxLen);
+    newPtr = (u1*) realloc(pBuf->storage, pBuf->maxLen);
     if (newPtr == NULL) {
         LOGE("realloc(%d) failed\n", pBuf->maxLen);
         abort();
diff --git a/vm/jdwp/JdwpAdb.c b/vm/jdwp/JdwpAdb.c
index c3a1a72..e73814d 100644
--- a/vm/jdwp/JdwpAdb.c
+++ b/vm/jdwp/JdwpAdb.c
@@ -92,7 +92,7 @@
 static JdwpNetState*
 adbStateAlloc(void)
 {
-    JdwpNetState*   netState = calloc(sizeof(*netState),1);
+    JdwpNetState* netState = (JdwpNetState*) calloc(sizeof(*netState),1);
 
     netState->controlSock = -1;
     netState->clientSock  = -1;
diff --git a/vm/mterp/c/gotoTargets.c b/vm/mterp/c/gotoTargets.c
index 0db6fb7..224a1e1 100644
--- a/vm/mterp/c/gotoTargets.c
+++ b/vm/mterp/c/gotoTargets.c
@@ -551,7 +551,7 @@
 #endif
 
         /* back up to previous frame and see if we hit a break */
-        fp = saveArea->prevFrame;
+        fp = (u4*)saveArea->prevFrame;
         assert(fp != NULL);
         if (dvmIsBreakFrame(fp)) {
             /* bail without popping the method frame from stack */
@@ -663,7 +663,7 @@
          * the "catch" blocks.
          */
         catchRelPc = dvmFindCatchBlock(self, pc - curMethod->insns,
-                    exception, false, (void*)&fp);
+                    exception, false, (void**)(void*)&fp);
 
         /*
          * Restore the stack bounds after an overflow.  This isn't going to
@@ -896,7 +896,7 @@
             curMethod = methodToCall;
             methodClassDex = curMethod->clazz->pDvmDex;
             pc = methodToCall->insns;
-            fp = self->curFrame = newFp;
+            self->curFrame = fp = newFp;
 #ifdef EASY_GDB
             debugSaveArea = SAVEAREA_FROM_FP(newFp);
 #endif
diff --git a/vm/mterp/out/InterpC-portdbg.c b/vm/mterp/out/InterpC-portdbg.c
index bf1825c..160af9e 100644
--- a/vm/mterp/out/InterpC-portdbg.c
+++ b/vm/mterp/out/InterpC-portdbg.c
@@ -3956,7 +3956,7 @@
 #endif
 
         /* back up to previous frame and see if we hit a break */
-        fp = saveArea->prevFrame;
+        fp = (u4*)saveArea->prevFrame;
         assert(fp != NULL);
         if (dvmIsBreakFrame(fp)) {
             /* bail without popping the method frame from stack */
@@ -4068,7 +4068,7 @@
          * the "catch" blocks.
          */
         catchRelPc = dvmFindCatchBlock(self, pc - curMethod->insns,
-                    exception, false, (void*)&fp);
+                    exception, false, (void**)(void*)&fp);
 
         /*
          * Restore the stack bounds after an overflow.  This isn't going to
@@ -4301,7 +4301,7 @@
             curMethod = methodToCall;
             methodClassDex = curMethod->clazz->pDvmDex;
             pc = methodToCall->insns;
-            fp = self->curFrame = newFp;
+            self->curFrame = fp = newFp;
 #ifdef EASY_GDB
             debugSaveArea = SAVEAREA_FROM_FP(newFp);
 #endif
diff --git a/vm/mterp/out/InterpC-portstd.c b/vm/mterp/out/InterpC-portstd.c
index 9abe3c4..a7ea0b3 100644
--- a/vm/mterp/out/InterpC-portstd.c
+++ b/vm/mterp/out/InterpC-portstd.c
@@ -3706,7 +3706,7 @@
 #endif
 
         /* back up to previous frame and see if we hit a break */
-        fp = saveArea->prevFrame;
+        fp = (u4*)saveArea->prevFrame;
         assert(fp != NULL);
         if (dvmIsBreakFrame(fp)) {
             /* bail without popping the method frame from stack */
@@ -3818,7 +3818,7 @@
          * the "catch" blocks.
          */
         catchRelPc = dvmFindCatchBlock(self, pc - curMethod->insns,
-                    exception, false, (void*)&fp);
+                    exception, false, (void**)(void*)&fp);
 
         /*
          * Restore the stack bounds after an overflow.  This isn't going to
@@ -4051,7 +4051,7 @@
             curMethod = methodToCall;
             methodClassDex = curMethod->clazz->pDvmDex;
             pc = methodToCall->insns;
-            fp = self->curFrame = newFp;
+            self->curFrame = fp = newFp;
 #ifdef EASY_GDB
             debugSaveArea = SAVEAREA_FROM_FP(newFp);
 #endif
diff --git a/vm/native/dalvik_system_Zygote.c b/vm/native/dalvik_system_Zygote.c
index bcc2313..947eb92 100644
--- a/vm/native/dalvik_system_Zygote.c
+++ b/vm/native/dalvik_system_Zygote.c
@@ -167,7 +167,7 @@
     }
 
     /* just in case gid_t and u4 are different... */
-    gids = alloca(sizeof(gid_t) * gidArray->length);
+    gids = (gid_t *)alloca(sizeof(gid_t) * gidArray->length);
     contents = (s4 *)gidArray->contents;
 
     for (i = 0 ; i < gidArray->length ; i++) {
diff --git a/vm/native/java_lang_reflect_Field.c b/vm/native/java_lang_reflect_Field.c
index 9a0986e..52d6248 100644
--- a/vm/native/java_lang_reflect_Field.c
+++ b/vm/native/java_lang_reflect_Field.c
@@ -288,7 +288,7 @@
         switch (sfield->field.signature[0]) {
         case 'L':
         case '[':
-            dvmSetStaticFieldObject(sfield, value->l);
+            dvmSetStaticFieldObject(sfield, (Object*)value->l);
             break;
         default:
             /* just copy the whole thing */
@@ -324,7 +324,7 @@
             break;
         case 'L':
         case '[':
-            dvmSetStaticFieldObjectVolatile(sfield, value->l);
+            dvmSetStaticFieldObjectVolatile(sfield, (Object*)value->l);
             break;
         default:
             LOGE("Unhandled field signature '%s'\n", sfield->field.signature);
@@ -369,7 +369,7 @@
             break;
         case 'L':
         case '[':
-            dvmSetFieldObject(obj, ifield->byteOffset, value->l);
+            dvmSetFieldObject(obj, ifield->byteOffset, (Object *)value->l);
             break;
         default:
             LOGE("Unhandled field signature '%s'\n", ifield->field.signature);
@@ -413,7 +413,7 @@
             break;
         case 'L':
         case '[':
-            dvmSetFieldObjectVolatile(obj, ifield->byteOffset, value->l);
+            dvmSetFieldObjectVolatile(obj, ifield->byteOffset, (Object*)value->l);
             break;
         default:
             LOGE("Unhandled field signature '%s'\n", ifield->field.signature);
diff --git a/vm/oo/Array.c b/vm/oo/Array.c
index bc57a5a..ca95488 100644
--- a/vm/oo/Array.c
+++ b/vm/oo/Array.c
@@ -59,7 +59,7 @@
     /* Note that we assume that the Array class does not
      * override finalize().
      */
-    newArray = dvmMalloc(size, allocFlags);
+    newArray = (ArrayObject*)dvmMalloc(size, allocFlags);
     if (newArray != NULL) {
         DVM_OBJECT_INIT(&newArray->obj, arrayClass);
         newArray->length = length;
@@ -719,7 +719,7 @@
         case PRIM_BOOLEAN:
         case PRIM_BYTE:
             {
-                u1* tmp = dst;
+                u1* tmp = (u1*)dst;
                 *tmp++ = result.b;
                 dst = tmp;
             }
@@ -727,7 +727,7 @@
         case PRIM_CHAR:
         case PRIM_SHORT:
             {
-                u2* tmp = dst;
+                u2* tmp = (u2*)dst;
                 *tmp++ = result.s;
                 dst = tmp;
             }
@@ -735,7 +735,7 @@
         case PRIM_FLOAT:
         case PRIM_INT:
             {
-                u4* tmp = dst;
+                u4* tmp = (u4*)dst;
                 *tmp++ = result.i;
                 dst = tmp;
             }
@@ -743,7 +743,7 @@
         case PRIM_DOUBLE:
         case PRIM_LONG:
             {
-                u8* tmp = dst;
+                u8* tmp = (u8*)dst;
                 *tmp++ = result.j;
                 dst = tmp;
             }
diff --git a/vm/oo/Class.c b/vm/oo/Class.c
index 6e16adc..2f2aae6 100644
--- a/vm/oo/Class.c
+++ b/vm/oo/Class.c
@@ -224,66 +224,66 @@
 static void linearAllocTests()
 {
     char* fiddle;
-    int try = 1;
+    int test = 1;
 
-    switch (try) {
+    switch (test) {
     case 0:
-        fiddle = dvmLinearAlloc(NULL, 3200-28);
-        dvmLinearReadOnly(NULL, fiddle);
+        fiddle = (char*)dvmLinearAlloc(NULL, 3200-28);
+        dvmLinearReadOnly(NULL, (char*)fiddle);
         break;
     case 1:
-        fiddle = dvmLinearAlloc(NULL, 3200-24);
-        dvmLinearReadOnly(NULL, fiddle);
+        fiddle = (char*)dvmLinearAlloc(NULL, 3200-24);
+        dvmLinearReadOnly(NULL, (char*)fiddle);
         break;
     case 2:
-        fiddle = dvmLinearAlloc(NULL, 3200-20);
-        dvmLinearReadOnly(NULL, fiddle);
+        fiddle = (char*)dvmLinearAlloc(NULL, 3200-20);
+        dvmLinearReadOnly(NULL, (char*)fiddle);
         break;
     case 3:
-        fiddle = dvmLinearAlloc(NULL, 3200-16);
-        dvmLinearReadOnly(NULL, fiddle);
+        fiddle = (char*)dvmLinearAlloc(NULL, 3200-16);
+        dvmLinearReadOnly(NULL, (char*)fiddle);
         break;
     case 4:
-        fiddle = dvmLinearAlloc(NULL, 3200-12);
-        dvmLinearReadOnly(NULL, fiddle);
+        fiddle = (char*)dvmLinearAlloc(NULL, 3200-12);
+        dvmLinearReadOnly(NULL, (char*)fiddle);
         break;
     }
-    fiddle = dvmLinearAlloc(NULL, 896);
-    dvmLinearReadOnly(NULL, fiddle);
-    fiddle = dvmLinearAlloc(NULL, 20);      // watch addr of this alloc
-    dvmLinearReadOnly(NULL, fiddle);
+    fiddle = (char*)dvmLinearAlloc(NULL, 896);
+    dvmLinearReadOnly(NULL, (char*)fiddle);
+    fiddle = (char*)dvmLinearAlloc(NULL, 20);      // watch addr of this alloc
+    dvmLinearReadOnly(NULL, (char*)fiddle);
 
-    fiddle = dvmLinearAlloc(NULL, 1);
+    fiddle = (char*)dvmLinearAlloc(NULL, 1);
     fiddle[0] = 'q';
     dvmLinearReadOnly(NULL, fiddle);
-    fiddle = dvmLinearAlloc(NULL, 4096);
+    fiddle = (char*)dvmLinearAlloc(NULL, 4096);
     fiddle[0] = 'x';
     fiddle[4095] = 'y';
     dvmLinearReadOnly(NULL, fiddle);
     dvmLinearFree(NULL, fiddle);
-    fiddle = dvmLinearAlloc(NULL, 0);
+    fiddle = (char*)dvmLinearAlloc(NULL, 0);
     dvmLinearReadOnly(NULL, fiddle);
-    fiddle = dvmLinearRealloc(NULL, fiddle, 12);
+    fiddle = (char*)dvmLinearRealloc(NULL, fiddle, 12);
     fiddle[11] = 'z';
+    dvmLinearReadOnly(NULL, (char*)fiddle);
+    fiddle = (char*)dvmLinearRealloc(NULL, fiddle, 5);
     dvmLinearReadOnly(NULL, fiddle);
-    fiddle = dvmLinearRealloc(NULL, fiddle, 5);
-    dvmLinearReadOnly(NULL, fiddle);
-    fiddle = dvmLinearAlloc(NULL, 17001);
+    fiddle = (char*)dvmLinearAlloc(NULL, 17001);
     fiddle[0] = 'x';
     fiddle[17000] = 'y';
-    dvmLinearReadOnly(NULL, fiddle);
+    dvmLinearReadOnly(NULL, (char*)fiddle);
 
-    char* str = dvmLinearStrdup(NULL, "This is a test!");
+    char* str = (char*)dvmLinearStrdup(NULL, "This is a test!");
     LOGI("GOT: '%s'\n", str);
 
     /* try to check the bounds; allocator may round allocation size up */
-    fiddle = dvmLinearAlloc(NULL, 12);
+    fiddle = (char*)dvmLinearAlloc(NULL, 12);
     LOGI("Should be 1: %d\n", dvmLinearAllocContains(fiddle, 12));
     LOGI("Should be 0: %d\n", dvmLinearAllocContains(fiddle, 13));
     LOGI("Should be 0: %d\n", dvmLinearAllocContains(fiddle - 128*1024, 1));
 
     dvmLinearAllocDump(NULL);
-    dvmLinearFree(NULL, str);
+    dvmLinearFree(NULL, (char*)str);
 }
 
 static size_t classObjectSize(size_t sfieldCount)
@@ -337,7 +337,7 @@
      * If it's NULL, we just fall back to the InitiatingLoaderList in the
      * ClassObject, so it's not fatal to fail this allocation.
      */
-    gDvm.initiatingLoaderList =
+    gDvm.initiatingLoaderList = (InitiatingLoaderList*)
         calloc(ZYGOTE_CLASS_CUTOFF, sizeof(InitiatingLoaderList));
 
     gDvm.classJavaLangClass = (ClassObject*) dvmMalloc(
@@ -1059,7 +1059,7 @@
      * here, but this is an extremely rare case, and it's simpler to have
      * the wait-for-class code centralized.
      */
-    if (found != NULL && !unprepOkay && !dvmIsClassLinked(found)) {
+    if (found && !unprepOkay && !dvmIsClassLinked((ClassObject*)found)) {
         LOGV("Ignoring not-yet-ready %s, using slow path\n",
             ((ClassObject*)found)->descriptor);
         found = NULL;
@@ -2478,7 +2478,7 @@
              */
             assert(sizeof(*interfaceIdxArray) == sizeof(*clazz->interfaces));
             size_t len = clazz->interfaceCount * sizeof(*interfaceIdxArray);
-            interfaceIdxArray = malloc(len);
+            interfaceIdxArray = (u4*)malloc(len);
             if (interfaceIdxArray == NULL) {
                 LOGW("Unable to allocate memory to link %s", clazz->descriptor);
                 goto bail;
@@ -2890,8 +2890,8 @@
         if (actualCount < maxCount) {
             assert(clazz->vtable != NULL);
             dvmLinearReadOnly(clazz->classLoader, clazz->vtable);
-            clazz->vtable = dvmLinearRealloc(clazz->classLoader, clazz->vtable,
-                sizeof(*(clazz->vtable)) * actualCount);
+            clazz->vtable = (Method **)dvmLinearRealloc(clazz->classLoader,
+                clazz->vtable, sizeof(*(clazz->vtable)) * actualCount);
             if (clazz->vtable == NULL) {
                 LOGE("vtable realloc failed\n");
                 goto bail;
@@ -3200,11 +3200,13 @@
                 if (mirandaCount == mirandaAlloc) {
                     mirandaAlloc += 8;
                     if (mirandaList == NULL) {
-                        mirandaList = dvmLinearAlloc(clazz->classLoader,
+                        mirandaList = (Method**)dvmLinearAlloc(
+                                        clazz->classLoader,
                                         mirandaAlloc * sizeof(Method*));
                     } else {
                         dvmLinearReadOnly(clazz->classLoader, mirandaList);
-                        mirandaList = dvmLinearRealloc(clazz->classLoader,
+                        mirandaList = (Method**)dvmLinearRealloc(
+                                clazz->classLoader,
                                 mirandaList, mirandaAlloc * sizeof(Method*));
                     }
                     assert(mirandaList != NULL);    // mem failed + we leaked
@@ -3882,8 +3884,8 @@
              * All's well, so store the value.
              */
             if (isObj) {
-                dvmSetStaticFieldObject(sfield, value.value.l);
-                dvmReleaseTrackedAlloc(value.value.l, self);
+                dvmSetStaticFieldObject(sfield, (Object*)value.value.l);
+                dvmReleaseTrackedAlloc((Object*)value.value.l, self);
             } else {
                 /*
                  * Note: This always stores the full width of a
@@ -4569,7 +4571,7 @@
         /* update both, ensuring that "insns" is observed first */
         method->insns = insns;
         android_atomic_release_store((int32_t) func,
-            (void*) &method->nativeFunc);
+            (volatile int32_t*)(void*) &method->nativeFunc);
     } else {
         /* only update nativeFunc */
         method->nativeFunc = func;
@@ -4613,7 +4615,7 @@
  */
 static int findClassCallback(void* vclazz, void* arg)
 {
-    ClassObject* clazz = vclazz;
+    ClassObject* clazz = (ClassObject*)vclazz;
     const char* descriptor = (const char*) arg;
 
     if (strcmp(clazz->descriptor, descriptor) == 0)
diff --git a/vm/oo/ObjectInlines.h b/vm/oo/ObjectInlines.h
index 23a72b2..6bf93ce 100644
--- a/vm/oo/ObjectInlines.h
+++ b/vm/oo/ObjectInlines.h
@@ -26,7 +26,7 @@
  */
 INLINE void dvmSetObjectArrayElement(const ArrayObject* obj, int index,
                                      Object* val) {
-    ((Object **)(obj)->contents)[index] = val;
+    ((Object **)(void *)(obj)->contents)[index] = val;
     if (val != NULL) {
         dvmWriteBarrierArray(obj, index, index + 1);
     }
@@ -76,7 +76,7 @@
     return ((JValue*)BYTE_OFFSET(obj, offset))->d;
 }
 INLINE Object* dvmGetFieldObject(const Object* obj, int offset) {
-    return ((JValue*)BYTE_OFFSET(obj, offset))->l;
+    return (Object*)((JValue*)BYTE_OFFSET(obj, offset))->l;
 }
 INLINE bool dvmGetFieldBooleanVolatile(const Object* obj, int offset) {
     s4* ptr = &((JValue*)BYTE_OFFSET(obj, offset))->i;
@@ -105,14 +105,14 @@
     return alias.fval;
 }
 INLINE s8 dvmGetFieldLongVolatile(const Object* obj, int offset) {
-    const s8* addr = BYTE_OFFSET(obj, offset);
+    const s8* addr = (const s8*)BYTE_OFFSET(obj, offset);
     s8 val = dvmQuasiAtomicRead64(addr);
     ANDROID_MEMBAR_FULL();
     return val;
 }
 INLINE double dvmGetFieldDoubleVolatile(const Object* obj, int offset) {
     union { s8 lval; double dval; } alias;
-    const s8* addr = BYTE_OFFSET(obj, offset);
+    const s8* addr = (const s8*)BYTE_OFFSET(obj, offset);
     alias.lval = dvmQuasiAtomicRead64(addr);
     ANDROID_MEMBAR_FULL();
     return alias.dval;
@@ -147,7 +147,7 @@
     ((JValue*)BYTE_OFFSET(obj, offset))->d = val;
 }
 INLINE void dvmSetFieldObject(Object* obj, int offset, Object* val) {
-    JValue* lhs = BYTE_OFFSET(obj, offset);
+    JValue* lhs = (JValue*)BYTE_OFFSET(obj, offset);
     lhs->l = val;
     if (val != NULL) {
         dvmWriteBarrierField(obj, &lhs->l);
@@ -175,7 +175,7 @@
     dvmSetFieldIntVolatile(obj, offset, alias.ival);
 }
 INLINE void dvmSetFieldLongVolatile(Object* obj, int offset, s8 val) {
-    s8* addr = BYTE_OFFSET(obj, offset);
+    s8* addr = (s8*)BYTE_OFFSET(obj, offset);
     ANDROID_MEMBAR_FULL();
     dvmQuasiAtomicSwap64(val, addr);
 }
@@ -224,7 +224,7 @@
     return sfield->value.d;
 }
 INLINE Object* dvmGetStaticFieldObject(const StaticField* sfield) {
-    return sfield->value.l;
+    return (Object*)sfield->value.l;
 }
 INLINE bool dvmGetStaticFieldBooleanVolatile(const StaticField* sfield) {
     const s4* ptr = &(sfield->value.i);
diff --git a/vm/reflect/Annotation.c b/vm/reflect/Annotation.c
index aad73c8..54d92a2 100644
--- a/vm/reflect/Annotation.c
+++ b/vm/reflect/Annotation.c
@@ -527,7 +527,7 @@
                 return false;
             } else {
                 assert(sfield->field.clazz->descriptor[0] == 'L');
-                elemObj = sfield->value.l;
+                elemObj = (Object*)sfield->value.l;
                 setObject = true;
                 dvmAddTrackedAlloc(elemObj, self);      // balance the Release
             }
@@ -562,7 +562,7 @@
                     dvmReleaseTrackedAlloc((Object*)newArray, self);
                     return false;
                 }
-                Object* obj = avalue.value.l;
+                Object* obj = (Object*)avalue.value.l;
                 dvmSetObjectArrayElement(newArray, count, obj);
                 dvmReleaseTrackedAlloc(obj, self);
             }
@@ -725,7 +725,7 @@
         LOGW("Failed processing annotation value\n");
         goto bail;
     }
-    valueObj = avalue.value.l;
+    valueObj = (Object*)avalue.value.l;
 
     /* new member to hold the element */
     newMember =
@@ -868,7 +868,7 @@
         goto bail;
     }
 
-    newAnno = result.l;
+    newAnno = (Object*)result.l;
 
 bail:
     dvmReleaseTrackedAlloc((Object*) elementArray, NULL);
@@ -1162,7 +1162,7 @@
         return GAV_FAILED;
     }
 
-    return avalue.value.l;
+    return (Object*)avalue.value.l;
 }
 
 
@@ -1806,7 +1806,7 @@
 
     /* convert the return type, if necessary */
     ClassObject* methodReturn = dvmGetBoxedReturnType(method);
-    Object* obj = avalue.value.l;
+    Object* obj = (Object*)avalue.value.l;
     obj = convertReturnType(obj, methodReturn);
 
     return obj;
diff --git a/vm/reflect/Proxy.c b/vm/reflect/Proxy.c
index ce72d99..33e5ad6 100644
--- a/vm/reflect/Proxy.c
+++ b/vm/reflect/Proxy.c
@@ -726,7 +726,7 @@
 
     /* grab a local copy to work on */
     for (i = 0; i < mixLen; i++) {
-        mixSet[i] = dvmPointerSetGetEntry(throws, i);
+        mixSet[i] = (ClassObject*)dvmPointerSetGetEntry(throws, i);
     }
 
     for (i = 0; i < mixLen; i++) {
@@ -1044,7 +1044,7 @@
         }
         pResult->l = NULL;
     } else {
-        if (!dvmUnboxPrimitive(invokeResult.l, returnType, pResult)) {
+        if (!dvmUnboxPrimitive((Object*)invokeResult.l, returnType, pResult)) {
             dvmThrowExceptionWithClassMessage("Ljava/lang/ClassCastException;",
                 ((Object*)invokeResult.l)->clazz->descriptor);
             goto bail;
diff --git a/vm/reflect/Reflect.c b/vm/reflect/Reflect.c
index 2a7c740..c490b43 100644
--- a/vm/reflect/Reflect.c
+++ b/vm/reflect/Reflect.c
@@ -1043,7 +1043,7 @@
     if (typeIndex == PRIM_NOT) {
         /* add to tracking table so return value is always in table */
         if (value.l != NULL)
-            dvmAddTrackedAlloc(value.l, NULL);
+            dvmAddTrackedAlloc((Object*)value.l, NULL);
         return (DataObject*) value.l;
     }
 
diff --git a/vm/test/TestHash.c b/vm/test/TestHash.c
index 26de141..431e62a 100644
--- a/vm/test/TestHash.c
+++ b/vm/test/TestHash.c
@@ -142,10 +142,10 @@
 
     /* two entries, same hash, different values */
     char* str1;
-    str1 = dvmHashTableLookup(pTab, hash, strdup("one"),
+    str1 = (char*) dvmHashTableLookup(pTab, hash, strdup("one"),
             (HashCompareFunc) strcmp, true);
     assert(str1 != NULL);
-    str = dvmHashTableLookup(pTab, hash, strdup("two"),
+    str = (const char*) dvmHashTableLookup(pTab, hash, strdup("two"),
             (HashCompareFunc) strcmp, true);
 
     /* remove the first one */
@@ -167,10 +167,12 @@
     }
 
     /* see if we can find them */
-    str = dvmHashTableLookup(pTab, hash, "one", (HashCompareFunc) strcmp,false);
+    str = (const char*) dvmHashTableLookup(pTab, hash, "one",
+            (HashCompareFunc) strcmp,false);
     if (str != NULL)
         LOGE("TestHash deleted entry has returned!");
-    str = dvmHashTableLookup(pTab, hash, "two", (HashCompareFunc) strcmp,false);
+    str = (const char*) dvmHashTableLookup(pTab, hash, "two",
+            (HashCompareFunc) strcmp,false);
     if (str == NULL)
         LOGE("TestHash entry vanished\n");