Fix implicit conversions, rename reserved works, enable -Wc++-compat.
Change-Id: I06292964a6882ea2d0c17c5c962db95e46b01543
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");