Fix implicit conversions, rename reserved works, enable -Wc++-compat.

Change-Id: I06292964a6882ea2d0c17c5c962db95e46b01543

15 files changed, 113 insertions, 93 deletions

diff --git a/vm/compiler/Compiler.c b/vm/compiler/Compiler.c
index 1ac6e9789..8dd8adc36 100644
--- a/vm/compiler/Compiler.c
+++ b/vm/compiler/Compiler.c
@@ -209,7 +209,7 @@ static void crawlDalvikStack(Thread *thread, bool print)
         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 82f52b931..da1bf24f1 100644
--- a/vm/compiler/Dataflow.c
+++ b/vm/compiler/Dataflow.c
@@ -862,7 +862,7 @@ char *dvmCompilerGetDalvikDisassembly(DecodedInstruction *insn,
         }
     }
     int length = strlen(buffer) + 1;
-    ret = dvmCompilerNew(length, false);
+    ret = (char *)dvmCompilerNew(length, false);
     memcpy(ret, buffer, length);
     return ret;
 }
@@ -904,7 +904,7 @@ char *dvmCompilerGetSSAString(CompilationUnit *cUnit, SSARepresentation *ssaRep)
     }
 
     int length = strlen(buffer) + 1;
-    ret = dvmCompilerNew(length, false);
+    ret = (char *)dvmCompilerNew(length, false);
     memcpy(ret, buffer, length);
     return ret;
 }
@@ -1015,7 +1015,7 @@ static void dataFlowSSAFormat35C(CompilationUnit *cUnit, MIR *mir)
     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 @@ static void dataFlowSSAFormat3RC(CompilationUnit *cUnit, MIR *mir)
     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 @@ void dvmCompilerDoSSAConversion(CompilationUnit *cUnit, BasicBlock *bb)
     }
 
     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 @@ void dvmCompilerDoSSAConversion(CompilationUnit *cUnit, BasicBlock *bb)
 
         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 @@ void dvmCompilerDoSSAConversion(CompilationUnit *cUnit, BasicBlock *bb)
 
         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 @@ void dvmCompilerDoSSAConversion(CompilationUnit *cUnit, BasicBlock *bb)
     }
 
     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 @@ void dvmCompilerFindInductionVariables(struct CompilationUnit *cUnit,
                 }
                 if (deltaIsConstant) {
                     dvmSetBit(isIndVarV, mir->ssaRep->uses[0]);
-                    InductionVariableInfo *ivInfo =
+                    InductionVariableInfo *ivInfo = (InductionVariableInfo *)
                         dvmCompilerNew(sizeof(InductionVariableInfo),
                                        false);
 
@@ -1372,13 +1378,13 @@ void dvmCompilerFindInductionVariables(struct CompilationUnit *cUnit,
             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 @@ void dvmInitializeSSAConversion(CompilationUnit *cUnit)
     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 @@ void dvmInitializeSSAConversion(CompilationUnit *cUnit)
      * 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 @@ void dvmInitializeSSAConversion(CompilationUnit *cUnit)
         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 a44c4894e..76783ae92 100644
--- a/vm/compiler/Frontend.c
+++ b/vm/compiler/Frontend.c
@@ -277,10 +277,11 @@ CompilerMethodStats *dvmCompilerAnalyzeMethodBody(const Method *method,
 
     /* 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 @@ bool dvmCompileTrace(JitTraceDescription *desc, int numMaxInsts,
     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 @@ bool dvmCompileTrace(JitTraceDescription *desc, int numMaxInsts,
     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 @@ bool dvmCompileTrace(JitTraceDescription *desc, int numMaxInsts,
         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 @@ bool dvmCompileTrace(JitTraceDescription *desc, int numMaxInsts,
     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 @@ bool dvmCompilerCanIncludeThisInstruction(const Method *method,
     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 @@ bool dvmCompileMethod(CompilationUnit *cUnit, const Method *method,
      * 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 @@ bool dvmCompileMethod(CompilationUnit *cUnit, const Method *method,
     }
 
     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 0b1330f16..d9a6eea82 100644
--- a/vm/compiler/InlineTransformation.c
+++ b/vm/compiler/InlineTransformation.c
@@ -43,7 +43,7 @@ static void inlineGetter(CompilationUnit *cUnit,
 {
     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 @@ static void inlineGetter(CompilationUnit *cUnit,
     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 @@ static void inlineSetter(CompilationUnit *cUnit,
                          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 @@ static void inlineSetter(CompilationUnit *cUnit,
     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 @@ static void inlineEmptyVirtualCallee(CompilationUnit *cUnit,
                                      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 825a69079..29889005b 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 031464c3c..32d9b09fd 100644
--- a/vm/compiler/Loop.c
+++ b/vm/compiler/Loop.c
@@ -57,7 +57,7 @@ static void handlePhiPlacement(CompilationUnit *cUnit)
         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 @@ static void fillPhiNodeContents(CompilationUnit *cUnit)
         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 @@ static void updateRangeCheckInfo(CompilationUnit *cUnit, int arrayReg,
             }
             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 @@ static void genHoistedChecks(CompilationUnit *cUnit)
         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 @@ static void genHoistedChecks(CompilationUnit *cUnit)
 
     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 @@ static void genHoistedChecks(CompilationUnit *cUnit)
         } 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 @@ static void genHoistedChecks(CompilationUnit *cUnit)
             } 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 @@ static void genHoistedChecks(CompilationUnit *cUnit)
  */
 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 @@ bool dvmCompilerLoopOpt(CompilationUnit *cUnit)
 
     /* 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 @@ bool dvmCompilerLoopOpt(CompilationUnit *cUnit)
     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 744bc3262..0dd67b740 100644
--- a/vm/compiler/Ralloc.c
+++ b/vm/compiler/Ralloc.c
@@ -150,7 +150,7 @@ void dvmCompilerRegAlloc(CompilationUnit *cUnit)
         }
     } 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 daeb8937c..4b942ef40 100644
--- a/vm/compiler/Utility.c
+++ b/vm/compiler/Utility.c
@@ -117,7 +117,7 @@ static void expandGrowableList(GrowableList *gList)
     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 @@ bool dvmCompilerSetBit(BitVector *pBits, int num)
         /* 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 0b76eb58b..8682c1a39 100644
--- a/vm/compiler/codegen/arm/ArchUtility.c
+++ b/vm/compiler/codegen/arm/ArchUtility.c
@@ -375,7 +375,7 @@ void dvmCompilerCodegenDump(CompilationUnit *cUnit)
     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 42a8d3740..16e8e155c 100644
--- a/vm/compiler/codegen/arm/Assemble.c
+++ b/vm/compiler/codegen/arm/Assemble.c
@@ -973,7 +973,8 @@ static AssemblerStatus assembleInstructions(CompilationUnit *cUnit,
             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 @@ void dvmCompilerAssembleLIR(CompilationUnit *cUnit, JitTranslationInfo *info)
     }
 
     /* 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 @@ static void inlineCachePatchEnqueue(PredictedChainingCell *cellAddr,
          * 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 @@ const Method *dvmJitToPatchPredictedChain(const Method *method,
          * 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 @@ static int dumpTraceProfile(JitEntry *p, bool silent, bool reset,
      * 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 @@ static inline int getProfileCount(const JitEntry *entry)
 /* 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 @@ void dvmCompilerSortAndPrintTraceProfiles()
     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 4a2057976..6558f67bf 100644
--- a/vm/compiler/codegen/arm/CodegenCommon.c
+++ b/vm/compiler/codegen/arm/CodegenCommon.c
@@ -204,7 +204,7 @@ static void setupResourceMasks(ArmLIR *lir)
  */
 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 *newLIR0(CompilationUnit *cUnit, ArmOpcode opcode)
 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 *newLIR1(CompilationUnit *cUnit, ArmOpcode opcode,
 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 *newLIR2(CompilationUnit *cUnit, ArmOpcode opcode,
 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 *newLIR3(CompilationUnit *cUnit, ArmOpcode opcode,
 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 @@ static ArmLIR *addWordData(CompilationUnit *cUnit, int value, bool inPlace)
 {
     /* 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 @@ static ArmLIR *genCheckCommon(CompilationUnit *cUnit, int dOffset,
     /* 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 98236b6ba..2a535920f 100644
--- a/vm/compiler/codegen/arm/CodegenDriver.c
+++ b/vm/compiler/codegen/arm/CodegenDriver.c
@@ -205,7 +205,7 @@ static bool genConversionPortable(CompilationUnit *cUnit, MIR *mir)
 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 @@ static void genReturnCommon(CompilationUnit *cUnit, MIR *mir)
     /* 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 @@ static void genInvokeVirtualCommon(CompilationUnit *cUnit, MIR *mir,
      */
     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 @@ static bool handleFmt21c_Fmt31c(CompilationUnit *cUnit, MIR *mir)
 
             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 @@ static bool handleFmt21c_Fmt31c(CompilationUnit *cUnit, MIR *mir)
 
             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 @@ static bool handleFmt21c_Fmt31c(CompilationUnit *cUnit, MIR *mir)
              * 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 @@ static bool handleFmt35c_3rc(CompilationUnit *cUnit, MIR *mir, BasicBlock *bb,
              */
             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 genValidationForPredictedInline(CompilationUnit *cUnit, MIR *mir)
 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 @@ static void setupLoopEntryBlock(CompilationUnit *cUnit, BasicBlock *entry,
                                 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 @@ static void setupLoopEntryBlock(CompilationUnit *cUnit, BasicBlock *entry,
      * 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 @@ void dvmCompilerMIR2LIR(CompilationUnit *cUnit)
 {
     /* 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 @@ gen_fallthrough:
 /* Accept the work and start compiling */
 bool dvmCompilerDoWork(CompilerWorkOrder *work)
 {
+    JitTraceDescription *desc;
     bool res;
 
     if (gDvmJit.codeCacheFull) {
@@ -4354,14 +4355,16 @@ bool dvmCompilerDoWork(CompilerWorkOrder *work)
     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 33e1e4188..d91734fcf 100644
--- a/vm/compiler/codegen/arm/LocalOptimizations.c
+++ b/vm/compiler/codegen/arm/LocalOptimizations.c
@@ -147,7 +147,7 @@ static void applyLoadStoreElimination(CompilationUnit *cUnit,
                         /* 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 @@ static void applyLoadHoisting(CompilationUnit *cUnit,
                         /* 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 @@ static void applyLoadHoisting(CompilationUnit *cUnit,
                     /* 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 141c925fa..f50edfe32 100644
--- a/vm/compiler/codegen/arm/Thumb2/Factory.c
+++ b/vm/compiler/codegen/arm/Thumb2/Factory.c
@@ -60,7 +60,7 @@ static ArmLIR *loadFPConstantValue(CompilationUnit *cUnit, int rDest,
     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 @@ static ArmLIR *loadConstantNoClobber(CompilationUnit *cUnit, int rDest,
     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 *genCmpImmBranch(CompilationUnit *cUnit,
 
 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 @@ static ArmLIR* genRegCopyNoInsert(CompilationUnit *cUnit, int rDest, int rSrc)
     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 825b271a7..8d12d7767 100644
--- a/vm/compiler/codegen/arm/Thumb2/Gen.c
+++ b/vm/compiler/codegen/arm/Thumb2/Gen.c
@@ -89,13 +89,13 @@ void dvmCompilerInitializeRegAlloc(CompilationUnit *cUnit)
 {
     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;