Rename (IF_)LOGD(_IF) to (IF_)ALOGD(_IF) DO NOT MERGE

See https://android-git.corp.google.com/g/156016

Bug: 5449033
Change-Id: Ic663376d1ad6a6cb14bf81405ad9afd247cf2f60

8 files changed, 87 insertions, 87 deletions

diff --git a/vm/compiler/Compiler.cpp b/vm/compiler/Compiler.cpp
index c08d42dfb..6e3402116 100644
--- a/vm/compiler/Compiler.cpp
+++ b/vm/compiler/Compiler.cpp
@@ -185,7 +185,7 @@ bool dvmCompilerSetupCodeCache(void)
     gDvmJit.pageSizeMask = getpagesize() - 1;
 
     /* This can be found through "dalvik-jit-code-cache" in /proc/<pid>/maps */
-    // LOGD("Code cache starts at %p", gDvmJit.codeCache);
+    // ALOGD("Code cache starts at %p", gDvmJit.codeCache);
 
     /* Copy the template code into the beginning of the code cache */
     int templateSize = (intptr_t) dmvCompilerTemplateEnd -
@@ -227,7 +227,7 @@ static void crawlDalvikStack(Thread *thread, bool print)
     int stackLevel = 0;
 
     if (print) {
-        LOGD("Crawling tid %d (%s / %p %s)", thread->systemTid,
+        ALOGD("Crawling tid %d (%s / %p %s)", thread->systemTid,
              dvmGetThreadStatusStr(thread->status),
              thread->inJitCodeCache,
              thread->inJitCodeCache ? "jit" : "interp");
@@ -238,11 +238,11 @@ static void crawlDalvikStack(Thread *thread, bool print)
 
         if (print) {
             if (dvmIsBreakFrame((u4*)fp)) {
-                LOGD("  #%d: break frame (%p)",
+                ALOGD("  #%d: break frame (%p)",
                      stackLevel, saveArea->returnAddr);
             }
             else {
-                LOGD("  #%d: %s.%s%s (%p)",
+                ALOGD("  #%d: %s.%s%s (%p)",
                      stackLevel,
                      saveArea->method->clazz->descriptor,
                      saveArea->method->name,
@@ -287,7 +287,7 @@ static void resetCodeCache(void)
     dvmUnlockThreadList();
 
     if (inJit) {
-        LOGD("JIT code cache reset delayed (%d bytes %d/%d)",
+        ALOGD("JIT code cache reset delayed (%d bytes %d/%d)",
              gDvmJit.codeCacheByteUsed, gDvmJit.numCodeCacheReset,
              ++gDvmJit.numCodeCacheResetDelayed);
         return;
@@ -348,7 +348,7 @@ static void resetCodeCache(void)
 
     dvmUnlockMutex(&gDvmJit.compilerLock);
 
-    LOGD("JIT code cache reset in %lld ms (%d bytes %d/%d)",
+    ALOGD("JIT code cache reset in %lld ms (%d bytes %d/%d)",
          (dvmGetRelativeTimeUsec() - startTime) / 1000,
          byteUsed, ++gDvmJit.numCodeCacheReset,
          gDvmJit.numCodeCacheResetDelayed);
@@ -612,7 +612,7 @@ static void *compilerThreadStart(void *arg)
             pthread_cond_wait(&gDvmJit.compilerQueueActivity,
                               &gDvmJit.compilerLock);
             dvmUnlockMutex(&gDvmJit.compilerLock);
-            LOGD("JIT started for system_server");
+            ALOGD("JIT started for system_server");
         } else {
             dvmLockMutex(&gDvmJit.compilerLock);
             /*
@@ -680,7 +680,7 @@ static void *compilerThreadStart(void *arg)
                     gDvmJit.codeCacheFull |= resizeFail;
                 }
                 if (gDvmJit.haltCompilerThread) {
-                    LOGD("Compiler shutdown in progress - discarding request");
+                    ALOGD("Compiler shutdown in progress - discarding request");
                 } else if (!gDvmJit.codeCacheFull) {
                     jmp_buf jmpBuf;
                     work.bailPtr = &jmpBuf;
@@ -726,7 +726,7 @@ static void *compilerThreadStart(void *arg)
     dvmChangeStatus(NULL, THREAD_RUNNING);
 
     if (gDvm.verboseShutdown)
-        LOGD("Compiler thread shutting down");
+        ALOGD("Compiler thread shutting down");
     return NULL;
 }
 
@@ -781,7 +781,7 @@ void dvmCompilerShutdown(void)
         if (pthread_join(gDvmJit.compilerHandle, &threadReturn) != 0)
             LOGW("Compiler thread join failed");
         else if (gDvm.verboseShutdown)
-            LOGD("Compiler thread has shut down");
+            ALOGD("Compiler thread has shut down");
     }
 
     /* Break loops within the translation cache */
diff --git a/vm/compiler/Frontend.cpp b/vm/compiler/Frontend.cpp
index 24ec6c7f6..735311883 100644
--- a/vm/compiler/Frontend.cpp
+++ b/vm/compiler/Frontend.cpp
@@ -49,7 +49,7 @@ static inline int parseInsn(const u2 *codePtr, DecodedInstruction *decInsn,
     dexDecodeInstruction(codePtr, decInsn);
     if (printMe) {
         char *decodedString = dvmCompilerGetDalvikDisassembly(decInsn, NULL);
-        LOGD("%p: %#06x %s", codePtr, opcode, decodedString);
+        ALOGD("%p: %#06x %s", codePtr, opcode, decodedString);
     }
     return dexGetWidthFromOpcode(opcode);
 }
@@ -403,7 +403,7 @@ static bool filterMethodByCallGraph(Thread *thread, const char *curMethodName)
                                (HashCompareFunc) strcmp, false) !=
                 NULL;
             if (found) {
-                LOGD("Method %s (--> %s) found on the JIT %s list",
+                ALOGD("Method %s (--> %s) found on the JIT %s list",
                      method->name, curMethodName,
                      gDvmJit.includeSelectedMethod ? "white" : "black");
                 return true;
@@ -1321,7 +1321,7 @@ bool dvmCompileMethod(const Method *method, JitTranslationInfo *info)
             dvmCompilerAssembleLIR(&cUnit, info);
             cUnit.assemblerRetries++;
             if (cUnit.printMe && cUnit.assemblerStatus != kSuccess)
-                LOGD("Assembler abort #%d on %d",cUnit.assemblerRetries,
+                ALOGD("Assembler abort #%d on %d",cUnit.assemblerRetries,
                       cUnit.assemblerStatus);
         } while (cUnit.assemblerStatus == kRetryAll);
 
@@ -1534,7 +1534,7 @@ static bool compileLoop(CompilationUnit *cUnit, unsigned int startOffset,
     /* Loop contains never executed blocks / heavy instructions */
     if (cUnit->quitLoopMode) {
         if (cUnit->printMe || gDvmJit.receivedSIGUSR2) {
-            LOGD("Loop trace @ offset %04x aborted due to unresolved code info",
+            ALOGD("Loop trace @ offset %04x aborted due to unresolved code info",
                  cUnit->entryBlock->startOffset);
         }
         goto bail;
@@ -1545,7 +1545,7 @@ static bool compileLoop(CompilationUnit *cUnit, unsigned int startOffset,
         dvmCompilerAssembleLIR(cUnit, info);
         cUnit->assemblerRetries++;
         if (cUnit->printMe && cUnit->assemblerStatus != kSuccess)
-            LOGD("Assembler abort #%d on %d", cUnit->assemblerRetries,
+            ALOGD("Assembler abort #%d on %d", cUnit->assemblerRetries,
                   cUnit->assemblerStatus);
     } while (cUnit->assemblerStatus == kRetryAll);
 
@@ -1555,7 +1555,7 @@ static bool compileLoop(CompilationUnit *cUnit, unsigned int startOffset,
     }
 
     if (cUnit->printMe || gDvmJit.receivedSIGUSR2) {
-        LOGD("Loop trace @ offset %04x", cUnit->entryBlock->startOffset);
+        ALOGD("Loop trace @ offset %04x", cUnit->entryBlock->startOffset);
         dvmCompilerCodegenDump(cUnit);
     }
 
@@ -1745,7 +1745,7 @@ bool dvmCompileTrace(JitTraceDescription *desc, int numMaxInsts,
     curBB = entryCodeBB;
 
     if (cUnit.printMe) {
-        LOGD("--------\nCompiler: Building trace for %s, offset %#x",
+        ALOGD("--------\nCompiler: Building trace for %s, offset %#x",
              desc->method->name, curOffset);
     }
 
@@ -2013,7 +2013,7 @@ bool dvmCompileTrace(JitTraceDescription *desc, int numMaxInsts,
     if (cUnit.printMe) {
         char* signature =
             dexProtoCopyMethodDescriptor(&desc->method->prototype);
-        LOGD("TRACEINFO (%d): 0x%08x %s%s.%s %#x %d of %d, %d blocks",
+        ALOGD("TRACEINFO (%d): 0x%08x %s%s.%s %#x %d of %d, %d blocks",
             compilationId,
             (intptr_t) desc->method->insns,
             desc->method->clazz->descriptor,
@@ -2060,14 +2060,14 @@ bool dvmCompileTrace(JitTraceDescription *desc, int numMaxInsts,
         dvmCompilerAssembleLIR(&cUnit, info);
         cUnit.assemblerRetries++;
         if (cUnit.printMe && cUnit.assemblerStatus != kSuccess)
-            LOGD("Assembler abort #%d on %d",cUnit.assemblerRetries,
+            ALOGD("Assembler abort #%d on %d",cUnit.assemblerRetries,
                   cUnit.assemblerStatus);
     } while (cUnit.assemblerStatus == kRetryAll);
 
     if (cUnit.printMe) {
-        LOGD("Trace Dalvik PC: %p", startCodePtr);
+        ALOGD("Trace Dalvik PC: %p", startCodePtr);
         dvmCompilerCodegenDump(&cUnit);
-        LOGD("End %s%s, %d Dalvik instructions",
+        ALOGD("End %s%s, %d Dalvik instructions",
              desc->method->clazz->descriptor, desc->method->name,
              cUnit.numInsts);
     }
diff --git a/vm/compiler/Utility.cpp b/vm/compiler/Utility.cpp
index b69faba89..b2bff8108 100644
--- a/vm/compiler/Utility.cpp
+++ b/vm/compiler/Utility.cpp
@@ -172,10 +172,10 @@ void dvmCompilerDumpCompilationUnit(CompilationUnit *cUnit)
         "Exception Handling",
     };
 
-    LOGD("Compiling %s %s", cUnit->method->clazz->descriptor,
+    ALOGD("Compiling %s %s", cUnit->method->clazz->descriptor,
          cUnit->method->name);
-    LOGD("%d insns", dvmGetMethodInsnsSize(cUnit->method));
-    LOGD("%d blocks in total", cUnit->numBlocks);
+    ALOGD("%d insns", dvmGetMethodInsnsSize(cUnit->method));
+    ALOGD("%d blocks in total", cUnit->numBlocks);
     GrowableListIterator iterator;
 
     dvmGrowableListIteratorInit(&cUnit->blockList, &iterator);
@@ -183,18 +183,18 @@ void dvmCompilerDumpCompilationUnit(CompilationUnit *cUnit)
     while (true) {
         bb = (BasicBlock *) dvmGrowableListIteratorNext(&iterator);
         if (bb == NULL) break;
-        LOGD("Block %d (%s) (insn %04x - %04x%s)",
+        ALOGD("Block %d (%s) (insn %04x - %04x%s)",
              bb->id,
              blockTypeNames[bb->blockType],
              bb->startOffset,
              bb->lastMIRInsn ? bb->lastMIRInsn->offset : bb->startOffset,
              bb->lastMIRInsn ? "" : " empty");
         if (bb->taken) {
-            LOGD("  Taken branch: block %d (%04x)",
+            ALOGD("  Taken branch: block %d (%04x)",
                  bb->taken->id, bb->taken->startOffset);
         }
         if (bb->fallThrough) {
-            LOGD("  Fallthrough : block %d (%04x)",
+            ALOGD("  Fallthrough : block %d (%04x)",
                  bb->fallThrough->id, bb->fallThrough->startOffset);
         }
     }
@@ -220,7 +220,7 @@ static int dumpMethodStats(void *compilerMethodStats, void *totalMethodStats)
 
     /* If over 3/4 of the Dalvik code is compiled, print something */
     if (methodStats->compiledDalvikSize >= limit) {
-        LOGD("Method stats: %s%s, %d/%d (compiled/total Dalvik), %d (native)",
+        ALOGD("Method stats: %s%s, %d/%d (compiled/total Dalvik), %d (native)",
              methodStats->method->clazz->descriptor,
              methodStats->method->name,
              methodStats->compiledDalvikSize,
@@ -240,20 +240,20 @@ void dvmCompilerDumpStats(void)
     CompilerMethodStats totalMethodStats;
 
     memset(&totalMethodStats, 0, sizeof(CompilerMethodStats));
-    LOGD("%d compilations using %d + %d bytes",
+    ALOGD("%d compilations using %d + %d bytes",
          gDvmJit.numCompilations,
          gDvmJit.templateSize,
          gDvmJit.codeCacheByteUsed - gDvmJit.templateSize);
-    LOGD("Compiler arena uses %d blocks (%d bytes each)",
+    ALOGD("Compiler arena uses %d blocks (%d bytes each)",
          numArenaBlocks, ARENA_DEFAULT_SIZE);
-    LOGD("Compiler work queue length is %d/%d", gDvmJit.compilerQueueLength,
+    ALOGD("Compiler work queue length is %d/%d", gDvmJit.compilerQueueLength,
          gDvmJit.compilerMaxQueued);
     dvmJitStats();
     dvmCompilerArchDump();
     if (gDvmJit.methodStatsTable) {
         dvmHashForeach(gDvmJit.methodStatsTable, dumpMethodStats,
                        &totalMethodStats);
-        LOGD("Code size stats: %d/%d (compiled/total Dalvik), %d (native)",
+        ALOGD("Code size stats: %d/%d (compiled/total Dalvik), %d (native)",
              totalMethodStats.compiledDalvikSize,
              totalMethodStats.dalvikSize,
              totalMethodStats.nativeSize);
diff --git a/vm/compiler/codegen/arm/ArchUtility.cpp b/vm/compiler/codegen/arm/ArchUtility.cpp
index 0bbb87588..e6075e833 100644
--- a/vm/compiler/codegen/arm/ArchUtility.cpp
+++ b/vm/compiler/codegen/arm/ArchUtility.cpp
@@ -281,7 +281,7 @@ void dvmDumpResourceMask(LIR *lir, u8 mask, const char *prefix)
         }
     }
     if (buf[0]) {
-        LOGD("%s: %s", prefix, buf);
+        ALOGD("%s: %s", prefix, buf);
     }
 }
 
@@ -304,69 +304,69 @@ void dvmDumpLIRInsn(LIR *arg, unsigned char *baseAddr)
     /* Handle pseudo-ops individually, and all regular insns as a group */
     switch(lir->opcode) {
         case kArmChainingCellBottom:
-            LOGD("-------- end of chaining cells (0x%04x)", offset);
+            ALOGD("-------- end of chaining cells (0x%04x)", offset);
             break;
         case kArmPseudoBarrier:
-            LOGD("-------- BARRIER");
+            ALOGD("-------- BARRIER");
             break;
         case kArmPseudoExtended:
-            LOGD("-------- %s", (char *) dest);
+            ALOGD("-------- %s", (char *) dest);
             break;
         case kArmPseudoSSARep:
             DUMP_SSA_REP(LOGD("-------- %s", (char *) dest));
             break;
         case kArmPseudoChainingCellBackwardBranch:
-            LOGD("L%p:", lir);
-            LOGD("-------- chaining cell (backward branch): 0x%04x", dest);
+            ALOGD("L%p:", lir);
+            ALOGD("-------- chaining cell (backward branch): 0x%04x", dest);
             break;
         case kArmPseudoChainingCellNormal:
-            LOGD("L%p:", lir);
-            LOGD("-------- chaining cell (normal): 0x%04x", dest);
+            ALOGD("L%p:", lir);
+            ALOGD("-------- chaining cell (normal): 0x%04x", dest);
             break;
         case kArmPseudoChainingCellHot:
-            LOGD("L%p:", lir);
-            LOGD("-------- chaining cell (hot): 0x%04x", dest);
+            ALOGD("L%p:", lir);
+            ALOGD("-------- chaining cell (hot): 0x%04x", dest);
             break;
         case kArmPseudoChainingCellInvokePredicted:
-            LOGD("L%p:", lir);
-            LOGD("-------- chaining cell (predicted): %s%s",
+            ALOGD("L%p:", lir);
+            ALOGD("-------- chaining cell (predicted): %s%s",
                  dest ? ((Method *) dest)->clazz->descriptor : "",
                  dest ? ((Method *) dest)->name : "N/A");
             break;
         case kArmPseudoChainingCellInvokeSingleton:
-            LOGD("L%p:", lir);
-            LOGD("-------- chaining cell (invoke singleton): %s%s/%p",
+            ALOGD("L%p:", lir);
+            ALOGD("-------- chaining cell (invoke singleton): %s%s/%p",
                  ((Method *)dest)->clazz->descriptor,
                  ((Method *)dest)->name,
                  ((Method *)dest)->insns);
             break;
         case kArmPseudoEntryBlock:
-            LOGD("-------- entry offset: 0x%04x", dest);
+            ALOGD("-------- entry offset: 0x%04x", dest);
             break;
         case kArmPseudoDalvikByteCodeBoundary:
-            LOGD("-------- dalvik offset: 0x%04x @ %s", dest,
+            ALOGD("-------- dalvik offset: 0x%04x @ %s", dest,
                  (char *) lir->operands[1]);
             break;
         case kArmPseudoExitBlock:
-            LOGD("-------- exit offset: 0x%04x", dest);
+            ALOGD("-------- exit offset: 0x%04x", dest);
             break;
         case kArmPseudoPseudoAlign4:
-            LOGD("%p (%04x): .align4", baseAddr + offset, offset);
+            ALOGD("%p (%04x): .align4", baseAddr + offset, offset);
             break;
         case kArmPseudoPCReconstructionCell:
-            LOGD("L%p:", lir);
-            LOGD("-------- reconstruct dalvik PC : 0x%04x @ +0x%04x", dest,
+            ALOGD("L%p:", lir);
+            ALOGD("-------- reconstruct dalvik PC : 0x%04x @ +0x%04x", dest,
                  lir->operands[1]);
             break;
         case kArmPseudoPCReconstructionBlockLabel:
             /* Do nothing */
             break;
         case kArmPseudoEHBlockLabel:
-            LOGD("Exception_Handling:");
+            ALOGD("Exception_Handling:");
             break;
         case kArmPseudoTargetLabel:
         case kArmPseudoNormalBlockLabel:
-            LOGD("L%p:", lir);
+            ALOGD("L%p:", lir);
             break;
         default:
             if (lir->flags.isNop && !dumpNop) {
@@ -376,7 +376,7 @@ void dvmDumpLIRInsn(LIR *arg, unsigned char *baseAddr)
                             baseAddr, 256);
             buildInsnString(EncodingMap[lir->opcode].fmt, lir, buf, baseAddr,
                             256);
-            LOGD("%p (%04x): %-8s%s%s",
+            ALOGD("%p (%04x): %-8s%s%s",
                  baseAddr + offset, offset, opName, buf,
                  lir->flags.isNop ? "(nop)" : "");
             break;
@@ -395,25 +395,25 @@ void dvmDumpLIRInsn(LIR *arg, unsigned char *baseAddr)
 /* Dump instructions and constant pool contents */
 void dvmCompilerCodegenDump(CompilationUnit *cUnit)
 {
-    LOGD("Dumping LIR insns");
+    ALOGD("Dumping LIR insns");
     LIR *lirInsn;
     ArmLIR *armLIR;
 
-    LOGD("installed code is at %p", cUnit->baseAddr);
-    LOGD("total size is %d bytes", cUnit->totalSize);
+    ALOGD("installed code is at %p", cUnit->baseAddr);
+    ALOGD("total size is %d bytes", cUnit->totalSize);
     for (lirInsn = cUnit->firstLIRInsn; lirInsn; lirInsn = lirInsn->next) {
         dvmDumpLIRInsn(lirInsn, (unsigned char *) cUnit->baseAddr);
     }
     for (lirInsn = cUnit->classPointerList; lirInsn; lirInsn = lirInsn->next) {
         armLIR = (ArmLIR *) lirInsn;
-        LOGD("%p (%04x): .class (%s)",
+        ALOGD("%p (%04x): .class (%s)",
              (char*)cUnit->baseAddr + armLIR->generic.offset,
              armLIR->generic.offset,
              ((CallsiteInfo *) armLIR->operands[0])->classDescriptor);
     }
     for (lirInsn = cUnit->literalList; lirInsn; lirInsn = lirInsn->next) {
         armLIR = (ArmLIR *) lirInsn;
-        LOGD("%p (%04x): .word (%#x)",
+        ALOGD("%p (%04x): .word (%#x)",
              (char*)cUnit->baseAddr + armLIR->generic.offset,
              armLIR->generic.offset,
              armLIR->operands[0]);
diff --git a/vm/compiler/codegen/arm/Assemble.cpp b/vm/compiler/codegen/arm/Assemble.cpp
index 312e7c1c0..09d2bc18b 100644
--- a/vm/compiler/codegen/arm/Assemble.cpp
+++ b/vm/compiler/codegen/arm/Assemble.cpp
@@ -963,14 +963,14 @@ static AssemblerStatus assembleInstructions(CompilationUnit *cUnit,
             }
             if ((lir->opcode == kThumb2LdrPcRel12) && (delta > 4091)) {
                 if (cUnit->printMe) {
-                    LOGD("kThumb2LdrPcRel12@%x: delta=%d", lir->generic.offset,
+                    ALOGD("kThumb2LdrPcRel12@%x: delta=%d", lir->generic.offset,
                          delta);
                     dvmCompilerCodegenDump(cUnit);
                 }
                 return kRetryHalve;
             } else if (delta > 1020) {
                 if (cUnit->printMe) {
-                    LOGD("kThumbLdrPcRel@%x: delta=%d", lir->generic.offset,
+                    ALOGD("kThumbLdrPcRel@%x: delta=%d", lir->generic.offset,
                          delta);
                     dvmCompilerCodegenDump(cUnit);
                 }
@@ -1006,7 +1006,7 @@ static AssemblerStatus assembleInstructions(CompilationUnit *cUnit,
                 lir->generic.target = 0;
                 dvmCompilerSetupResourceMasks(lir);
                 if (cUnit->printMe) {
-                    LOGD("kThumb2Cbnz/kThumb2Cbz@%x: delta=%d",
+                    ALOGD("kThumb2Cbnz/kThumb2Cbz@%x: delta=%d",
                          lir->generic.offset, delta);
                     dvmCompilerCodegenDump(cUnit);
                 }
@@ -1022,7 +1022,7 @@ static AssemblerStatus assembleInstructions(CompilationUnit *cUnit,
             int delta = target - pc;
             if ((lir->opcode == kThumbBCond) && (delta > 254 || delta < -256)) {
                 if (cUnit->printMe) {
-                    LOGD("kThumbBCond@%x: delta=%d", lir->generic.offset,
+                    ALOGD("kThumbBCond@%x: delta=%d", lir->generic.offset,
                          delta);
                     dvmCompilerCodegenDump(cUnit);
                 }
@@ -1335,7 +1335,7 @@ static void matchSignatureBreakpoint(const CompilationUnit *cUnit,
                 }
             }
             if (j == gDvmJit.signatureBreakpointSize) {
-                LOGD("Signature match starting from offset %#x (%d words)",
+                ALOGD("Signature match starting from offset %#x (%d words)",
                      i*4, gDvmJit.signatureBreakpointSize);
                 int descSize = getTraceDescriptionSize(cUnit->traceDesc);
                 JitTraceDescription *newCopy =
@@ -1604,7 +1604,7 @@ void* dvmJitChain(void* tgtAddr, u4* branchAddr)
         gDvmJit.translationChains++;
 
         COMPILER_TRACE_CHAINING(
-            LOGD("Jit Runtime: chaining %#x to %#x",
+            ALOGD("Jit Runtime: chaining %#x to %#x",
                  (int) branchAddr, (int) tgtAddr & -2));
 
         /*
@@ -1783,7 +1783,7 @@ const Method *dvmJitToPatchPredictedChain(const Method *method,
     if ((tgtAddr == 0) ||
         ((void*)tgtAddr == dvmCompilerGetInterpretTemplate())) {
         COMPILER_TRACE_CHAINING(
-            LOGD("Jit Runtime: predicted chain %p to method %s%s delayed",
+            ALOGD("Jit Runtime: predicted chain %p to method %s%s delayed",
                  cell, method->clazz->descriptor, method->name));
         goto done;
     }
@@ -1835,7 +1835,7 @@ void dvmCompilerPatchInlineCache(void)
 
     UNPROTECT_CODE_CACHE(gDvmJit.codeCache, gDvmJit.codeCacheByteUsed);
 
-    //LOGD("Number of IC patch work orders: %d", gDvmJit.compilerICPatchIndex);
+    //ALOGD("Number of IC patch work orders: %d", gDvmJit.compilerICPatchIndex);
 
     /* Initialize the min/max address range */
     minAddr = (PredictedChainingCell *)
@@ -1855,7 +1855,7 @@ void dvmCompilerPatchInlineCache(void)
         cellContent->clazz = clazz;
 
         COMPILER_TRACE_CHAINING(
-            LOGD("Jit Runtime: predicted chain %p from %s to %s (%s) "
+            ALOGD("Jit Runtime: predicted chain %p from %s to %s (%s) "
                  "patched",
                  cellAddr,
                  cellAddr->clazz->descriptor,
@@ -1943,7 +1943,7 @@ static u4* unchainSingle(JitEntry *trace)
                     dvmAbort();  // dvmAbort OK here - can't safely recover
             }
             COMPILER_TRACE_CHAINING(
-                LOGD("Jit Runtime: unchaining %#x", (int)pChainCells));
+                ALOGD("Jit Runtime: unchaining %#x", (int)pChainCells));
             pChainCells += elemSize;  /* Advance by a fixed number of words */
         }
     }
@@ -2015,12 +2015,12 @@ static int dumpTraceProfile(JitEntry *p, bool silent, bool reset,
 
     if (p->codeAddress == NULL) {
         if (!silent)
-            LOGD("TRACEPROFILE NULL");
+            ALOGD("TRACEPROFILE NULL");
         return 0;
     }
     if (p->codeAddress == dvmCompilerGetInterpretTemplate()) {
         if (!silent)
-            LOGD("TRACEPROFILE INTERPRET_ONLY");
+            ALOGD("TRACEPROFILE INTERPRET_ONLY");
         return 0;
     }
     JitTraceCounter_t count = getProfileCount(p);
@@ -2049,7 +2049,7 @@ static int dumpTraceProfile(JitEntry *p, bool silent, bool reset,
                        method->accessFlags,
                        addrToLineCb, NULL, &addrToLine);
 
-    LOGD("TRACEPROFILE 0x%08x % 10d %5.2f%% [%#x(+%d), %d] %s%s;%s",
+    ALOGD("TRACEPROFILE 0x%08x % 10d %5.2f%% [%#x(+%d), %d] %s%s;%s",
          (int) getTraceBase(p),
          count,
          ((float ) count) / sum * 100.0,
@@ -2074,7 +2074,7 @@ static int dumpTraceProfile(JitEntry *p, bool silent, bool reset,
             desc->trace[idx+JIT_TRACE_CUR_METHOD-1].info.meta;
         char *methodDesc = dexProtoCopyMethodDescriptor(&method->prototype);
         /* Print the callee info in the trace */
-        LOGD("    -> %s%s;%s", method->clazz->descriptor, method->name,
+        ALOGD("    -> %s%s;%s", method->clazz->descriptor, method->name,
              methodDesc);
     }
 
@@ -2147,7 +2147,7 @@ void dvmCompilerSortAndPrintTraceProfiles()
         sum = 1;
     }
 
-    LOGD("JIT: Average execution count -> %d",(int)(sum / numTraces));
+    ALOGD("JIT: Average execution count -> %d",(int)(sum / numTraces));
 
     /* Dump the sorted entries. The count of each trace will be reset to 0. */
     for (i=0; i < gDvmJit.jitTableSize; i++) {
@@ -2423,7 +2423,7 @@ static int selfVerificationLoad(int addr, int size)
             dvmAbort();
     }
 
-    //LOGD("*** HEAP LOAD: Addr: %#x Data: %#x Size: %d", addr, data, size);
+    //ALOGD("*** HEAP LOAD: Addr: %#x Data: %#x Size: %d", addr, data, size);
     return data;
 }
 
@@ -2447,7 +2447,7 @@ static s8 selfVerificationLoadDoubleword(int addr)
         }
     }
 
-    //LOGD("*** HEAP LOAD DOUBLEWORD: Addr: %#x Data: %#x Data2: %#x",
+    //ALOGD("*** HEAP LOAD DOUBLEWORD: Addr: %#x Data: %#x Data2: %#x",
     //    addr, data, data2);
     return (((s8) data2) << 32) | data;
 }
@@ -2467,7 +2467,7 @@ static void selfVerificationStore(int addr, int data, int size)
     int maskedAddr = addr & 0xFFFFFFFC;
     int alignment = addr & 0x3;
 
-    //LOGD("*** HEAP STORE: Addr: %#x Data: %#x Size: %d", addr, data, size);
+    //ALOGD("*** HEAP STORE: Addr: %#x Data: %#x Size: %d", addr, data, size);
 
     for (heapSpacePtr = shadowSpace->heapSpace;
          heapSpacePtr != shadowSpace->heapSpaceTail; heapSpacePtr++) {
@@ -2515,7 +2515,7 @@ static void selfVerificationStoreDoubleword(int addr, s8 double_data)
     int data2 = double_data >> 32;
     bool store1 = false, store2 = false;
 
-    //LOGD("*** HEAP STORE DOUBLEWORD: Addr: %#x Data: %#x, Data2: %#x",
+    //ALOGD("*** HEAP STORE DOUBLEWORD: Addr: %#x Data: %#x, Data2: %#x",
     //    addr, data, data2);
 
     for (heapSpacePtr = shadowSpace->heapSpace;
@@ -2628,7 +2628,7 @@ void dvmSelfVerificationMemOpDecode(int lr, int* sp)
 
     if ((insn & kMemOp2) == kMemOp2) {
         insn = (insn << 16) | (insn >> 16);
-        //LOGD("*** THUMB2 - Addr: %#x Insn: %#x", lr, insn);
+        //ALOGD("*** THUMB2 - Addr: %#x Insn: %#x", lr, insn);
 
         int opcode12 = (insn >> 20) & 0xFFF;
         int opcode4 = (insn >> 8) & 0xF;
@@ -2753,7 +2753,7 @@ void dvmSelfVerificationMemOpDecode(int lr, int* sp)
         // Handle the decoded mem op accordingly
         if (store) {
             if (size == kSVVariable) {
-                LOGD("*** THUMB2 STMIA CURRENTLY UNUSED (AND UNTESTED)");
+                ALOGD("*** THUMB2 STMIA CURRENTLY UNUSED (AND UNTESTED)");
                 int i;
                 int regList = insn & 0xFFFF;
                 for (i = 0; i < 16; i++) {
@@ -2774,7 +2774,7 @@ void dvmSelfVerificationMemOpDecode(int lr, int* sp)
             }
         } else {
             if (size == kSVVariable) {
-                LOGD("*** THUMB2 LDMIA CURRENTLY UNUSED (AND UNTESTED)");
+                ALOGD("*** THUMB2 LDMIA CURRENTLY UNUSED (AND UNTESTED)");
                 int i;
                 int regList = insn & 0xFFFF;
                 for (i = 0; i < 16; i++) {
@@ -2795,7 +2795,7 @@ void dvmSelfVerificationMemOpDecode(int lr, int* sp)
             }
         }
     } else {
-        //LOGD("*** THUMB - Addr: %#x Insn: %#x", lr, insn);
+        //ALOGD("*** THUMB - Addr: %#x Insn: %#x", lr, insn);
 
         // Update the link register
         selfVerificationMemRegStore(sp, old_lr+2, 13);
diff --git a/vm/compiler/codegen/arm/CodegenDriver.cpp b/vm/compiler/codegen/arm/CodegenDriver.cpp
index 85ecb7892..ef0f0432a 100644
--- a/vm/compiler/codegen/arm/CodegenDriver.cpp
+++ b/vm/compiler/codegen/arm/CodegenDriver.cpp
@@ -2548,7 +2548,7 @@ static bool handleFmt22c_Fmt52c(CompilationUnit *cUnit, MIR *mir)
              */
             if (classPtr == NULL) {
                 BAIL_LOOP_COMPILATION();
-                LOGD("null clazz in OP_INSTANCE_OF, single-stepping");
+                ALOGD("null clazz in OP_INSTANCE_OF, single-stepping");
                 genInterpSingleStep(cUnit, mir);
                 break;
             }
@@ -4758,7 +4758,7 @@ void dvmCompilerArchDump(void)
         }
     }
     if (strlen(buf)) {
-        LOGD("dalvik.vm.jit.op = %s", buf);
+        ALOGD("dalvik.vm.jit.op = %s", buf);
     }
 }
 
diff --git a/vm/compiler/codegen/arm/LocalOptimizations.cpp b/vm/compiler/codegen/arm/LocalOptimizations.cpp
index b89437e19..98848c775 100644
--- a/vm/compiler/codegen/arm/LocalOptimizations.cpp
+++ b/vm/compiler/codegen/arm/LocalOptimizations.cpp
@@ -45,7 +45,7 @@ static inline bool isDalvikRegisterClobbered(ArmLIR *lir1, ArmLIR *lir2)
 static void dumpDependentInsnPair(ArmLIR *thisLIR, ArmLIR *checkLIR,
                                   const char *optimization)
 {
-    LOGD("************ %s ************", optimization);
+    ALOGD("************ %s ************", optimization);
     dvmDumpLIRInsn((LIR *) thisLIR, 0);
     dvmDumpLIRInsn((LIR *) checkLIR, 0);
 }
diff --git a/vm/compiler/codegen/x86/CodegenDriver.cpp b/vm/compiler/codegen/x86/CodegenDriver.cpp
index a5ef56afb..789d4317e 100644
--- a/vm/compiler/codegen/x86/CodegenDriver.cpp
+++ b/vm/compiler/codegen/x86/CodegenDriver.cpp
@@ -287,7 +287,7 @@ void dvmCompilerArchDump(void)
         }
     }
     if (strlen(buf)) {
-        LOGD("dalvik.vm.jit.op = %s", buf);
+        ALOGD("dalvik.vm.jit.op = %s", buf);
     }
 }