Prefer printf format "%#x" over "0x%x".

I exist to serve.

Change-Id: I8e2880b20eefd466da8515d5b6b0c5cb75d56169

2 files changed, 35 insertions, 35 deletions

diff --git a/vm/interp/Interp.cpp b/vm/interp/Interp.cpp
index 32ae3ec6f..57c900bdc 100644
--- a/vm/interp/Interp.cpp
+++ b/vm/interp/Interp.cpp
@@ -278,7 +278,7 @@ static bool dvmBreakpointSetAdd(BreakpointSet* pSet, Method* method,
             LOGV("Class %s verified, adding breakpoint at %p",
                 method->clazz->descriptor, addr);
             if (instructionIsMagicNop(addr)) {
-                LOGV("Refusing to set breakpoint on %04x at %s.%s + 0x%x",
+                LOGV("Refusing to set breakpoint on %04x at %s.%s + %#x",
                     *addr, method->clazz->descriptor, method->name,
                     instrOffset);
             } else {
@@ -317,11 +317,11 @@ static void dvmBreakpointSetRemove(BreakpointSet* pSet, Method* method,
     if (idx < 0) {
         /* breakpoint not found in set -- unexpected */
         if (*(u1*)addr == OP_BREAKPOINT) {
-            LOGE("Unable to restore breakpoint opcode (%s.%s +0x%x)",
+            LOGE("Unable to restore breakpoint opcode (%s.%s +%#x)",
                 method->clazz->descriptor, method->name, instrOffset);
             dvmAbort();
         } else {
-            LOGW("Breakpoint was already restored? (%s.%s +0x%x)",
+            LOGW("Breakpoint was already restored? (%s.%s +%#x)",
                 method->clazz->descriptor, method->name, instrOffset);
         }
     } else {
@@ -375,7 +375,7 @@ static void dvmBreakpointSetFlush(BreakpointSet* pSet, ClassObject* clazz)
             LOGV("Flushing breakpoint at %p for %s",
                 pBreak->addr, clazz->descriptor);
             if (instructionIsMagicNop(pBreak->addr)) {
-                LOGV("Refusing to flush breakpoint on %04x at %s.%s + 0x%x",
+                LOGV("Refusing to flush breakpoint on %04x at %s.%s + %#x",
                     *pBreak->addr, pBreak->method->clazz->descriptor,
                     pBreak->method->name, pBreak->addr - pBreak->method->insns);
             } else {
@@ -1592,26 +1592,26 @@ void dvmCheckInterpStateConsistency()
     handlerTable = self->interpBreak.ctl.curHandlerTable;
     for (thread = gDvm.threadList; thread != NULL; thread = thread->next) {
         if (subMode != thread->interpBreak.ctl.subMode) {
-            LOGD("Warning: subMode mismatch - 0x%x:0x%x, tid[%d]",
+            LOGD("Warning: subMode mismatch - %#x:%#x, tid[%d]",
                 subMode,thread->interpBreak.ctl.subMode,thread->threadId);
          }
         if (breakFlags != thread->interpBreak.ctl.breakFlags) {
-            LOGD("Warning: breakFlags mismatch - 0x%x:0x%x, tid[%d]",
+            LOGD("Warning: breakFlags mismatch - %#x:%#x, tid[%d]",
                 breakFlags,thread->interpBreak.ctl.breakFlags,thread->threadId);
          }
         if (handlerTable != thread->interpBreak.ctl.curHandlerTable) {
-            LOGD("Warning: curHandlerTable mismatch - 0x%x:0x%x, tid[%d]",
+            LOGD("Warning: curHandlerTable mismatch - %#x:%#x, tid[%d]",
                 (int)handlerTable,(int)thread->interpBreak.ctl.curHandlerTable,
                 thread->threadId);
          }
 #if defined(WITH_JIT)
          if (thread->pJitProfTable != gDvmJit.pProfTable) {
-             LOGD("Warning: pJitProfTable mismatch - 0x%x:0x%x, tid[%d]",
+             LOGD("Warning: pJitProfTable mismatch - %#x:%#x, tid[%d]",
                   (int)thread->pJitProfTable,(int)gDvmJit.pProfTable,
                   thread->threadId);
          }
          if (thread->jitThreshold != gDvmJit.threshold) {
-             LOGD("Warning: jitThreshold mismatch - 0x%x:0x%x, tid[%d]",
+             LOGD("Warning: jitThreshold mismatch - %#x:%#x, tid[%d]",
                   (int)thread->jitThreshold,(int)gDvmJit.threshold,
                   thread->threadId);
          }
@@ -1846,13 +1846,13 @@ void dvmCheckBefore(const u2 *pc, u4 *fp, Thread* self)
             if (self->jitResumeDPC != NULL) {
                 if (self->jitResumeDPC == pc) {
                     if (self->jitResumeNPC != NULL) {
-                        LOGD("SS return to trace - pc:0x%x to 0x:%x",
+                        LOGD("SS return to trace - pc:%#x to 0x:%x",
                              (int)pc, (int)self->jitResumeNPC);
                     } else {
-                        LOGD("SS return to interp - pc:0x%x",(int)pc);
+                        LOGD("SS return to interp - pc:%#x",(int)pc);
                     }
                 } else {
-                    LOGD("SS failed to return.  Expected 0x%x, now at 0x%x",
+                    LOGD("SS failed to return.  Expected %#x, now at %#x",
                          (int)self->jitResumeDPC, (int)pc);
                 }
             }
diff --git a/vm/interp/Jit.cpp b/vm/interp/Jit.cpp
index 9632e9723..758956d21 100644
--- a/vm/interp/Jit.cpp
+++ b/vm/interp/Jit.cpp
@@ -74,14 +74,14 @@ void* dvmSelfVerificationSaveState(const u2* pc, u4* fp,
         sizeof(StackSaveArea);
     unsigned postBytes = self->interpSave.method->registersSize*4;
 
-    //LOGD("### selfVerificationSaveState(%d) pc: 0x%x fp: 0x%x",
+    //LOGD("### selfVerificationSaveState(%d) pc: %#x fp: %#x",
     //    self->threadId, (int)pc, (int)fp);
 
     if (shadowSpace->selfVerificationState != kSVSIdle) {
         LOGD("~~~ Save: INCORRECT PREVIOUS STATE(%d): %d",
             self->threadId, shadowSpace->selfVerificationState);
         LOGD("********** SHADOW STATE DUMP **********");
-        LOGD("PC: 0x%x FP: 0x%x", (int)pc, (int)fp);
+        LOGD("PC: %#x FP: %#x", (int)pc, (int)fp);
     }
     shadowSpace->selfVerificationState = kSVSStart;
 
@@ -138,7 +138,7 @@ void* dvmSelfVerificationRestoreState(const u2* pc, u4* fp,
     shadowSpace->endShadowFP = fp;
     shadowSpace->jitExitState = exitState;
 
-    //LOGD("### selfVerificationRestoreState(%d) pc: 0x%x fp: 0x%x endPC: 0x%x",
+    //LOGD("### selfVerificationRestoreState(%d) pc: %#x fp: %#x endPC: %#x",
     //    self->threadId, (int)shadowSpace->startPC, (int)shadowSpace->fp,
     //    (int)pc);
 
@@ -146,10 +146,10 @@ void* dvmSelfVerificationRestoreState(const u2* pc, u4* fp,
         LOGD("~~~ Restore: INCORRECT PREVIOUS STATE(%d): %d",
             self->threadId, shadowSpace->selfVerificationState);
         LOGD("********** SHADOW STATE DUMP **********");
-        LOGD("Dalvik PC: 0x%x endPC: 0x%x", (int)shadowSpace->startPC,
+        LOGD("Dalvik PC: %#x endPC: %#x", (int)shadowSpace->startPC,
             (int)shadowSpace->endPC);
-        LOGD("Interp FP: 0x%x", (int)shadowSpace->fp);
-        LOGD("Shadow FP: 0x%x endFP: 0x%x", (int)shadowSpace->shadowFP,
+        LOGD("Interp FP: %#x", (int)shadowSpace->fp);
+        LOGD("Shadow FP: %#x endFP: %#x", (int)shadowSpace->shadowFP,
             (int)shadowSpace->endShadowFP);
     }
 
@@ -198,15 +198,15 @@ static void selfVerificationDumpState(const u2* pc, Thread* self)
                       (int)self->interpSave.curFrame - localRegs;
     }
     LOGD("********** SHADOW STATE DUMP **********");
-    LOGD("CurrentPC: 0x%x, Offset: 0x%04x", (int)pc,
+    LOGD("CurrentPC: %#x, Offset: 0x%04x", (int)pc,
         (int)(pc - stackSave->method->insns));
     LOGD("Class: %s", shadowSpace->method->clazz->descriptor);
     LOGD("Method: %s", shadowSpace->method->name);
-    LOGD("Dalvik PC: 0x%x endPC: 0x%x", (int)shadowSpace->startPC,
+    LOGD("Dalvik PC: %#x endPC: %#x", (int)shadowSpace->startPC,
         (int)shadowSpace->endPC);
-    LOGD("Interp FP: 0x%x endFP: 0x%x", (int)shadowSpace->fp,
+    LOGD("Interp FP: %#x endFP: %#x", (int)shadowSpace->fp,
         (int)self->interpSave.curFrame);
-    LOGD("Shadow FP: 0x%x endFP: 0x%x", (int)shadowSpace->shadowFP,
+    LOGD("Shadow FP: %#x endFP: %#x", (int)shadowSpace->shadowFP,
         (int)shadowSpace->endShadowFP);
     LOGD("Frame1 Bytes: %d Frame2 Local: %d Bytes: %d", frameBytes,
         localRegs, frameBytes2);
@@ -228,7 +228,7 @@ static void selfVerificationDumpTrace(const u2* pc, Thread* self)
         offset =  (int)((u2*)addr - stackSave->method->insns);
         decInsn = &(shadowSpace->trace[i].decInsn);
         /* Not properly decoding instruction, some registers may be garbage */
-        LOGD("0x%x: (0x%04x) %s",
+        LOGD("%#x: (0x%04x) %s",
             addr, offset, dexGetOpcodeName(decInsn->opcode));
     }
 }
@@ -269,7 +269,7 @@ void dvmCheckSelfVerification(const u2* pc, Thread* self)
     DecodedInstruction decInsn;
     dexDecodeInstruction(pc, &decInsn);
 
-    //LOGD("### DbgIntp(%d): PC: 0x%x endPC: 0x%x state: %d len: %d %s",
+    //LOGD("### DbgIntp(%d): PC: %#x endPC: %#x state: %d len: %d %s",
     //    self->threadId, (int)pc, (int)shadowSpace->endPC, state,
     //    shadowSpace->traceLength, dexGetOpcodeName(decInsn.opcode));
 
@@ -311,12 +311,12 @@ void dvmCheckSelfVerification(const u2* pc, Thread* self)
             LOGD("~~~ DbgIntp(%d): REGISTERS DIVERGENCE!", self->threadId);
             selfVerificationDumpState(pc, self);
             selfVerificationDumpTrace(pc, self);
-            LOGD("*** Interp Registers: addr: 0x%x bytes: %d",
+            LOGD("*** Interp Registers: addr: %#x bytes: %d",
                 (int)shadowSpace->fp, frameBytes);
             selfVerificationPrintRegisters((int*)shadowSpace->fp,
                                            (int*)shadowSpace->shadowFP,
                                            frameBytes/4);
-            LOGD("*** Shadow Registers: addr: 0x%x bytes: %d",
+            LOGD("*** Shadow Registers: addr: %#x bytes: %d",
                 (int)shadowSpace->shadowFP, frameBytes);
             selfVerificationPrintRegisters((int*)shadowSpace->shadowFP,
                                            (int*)shadowSpace->fp,
@@ -345,12 +345,12 @@ void dvmCheckSelfVerification(const u2* pc, Thread* self)
                     self->threadId);
                 selfVerificationDumpState(pc, self);
                 selfVerificationDumpTrace(pc, self);
-                LOGD("*** Interp Registers: addr: 0x%x l: %d bytes: %d",
+                LOGD("*** Interp Registers: addr: %#x l: %d bytes: %d",
                     (int)self->interpSave.curFrame, localRegs, frameBytes2);
                 selfVerificationPrintRegisters((int*)self->interpSave.curFrame,
                                                (int*)shadowSpace->endShadowFP,
                                                (frameBytes2+localRegs)/4);
-                LOGD("*** Shadow Registers: addr: 0x%x l: %d bytes: %d",
+                LOGD("*** Shadow Registers: addr: %#x l: %d bytes: %d",
                     (int)shadowSpace->endShadowFP, localRegs, frameBytes2);
                 selfVerificationPrintRegisters((int*)shadowSpace->endShadowFP,
                                                (int*)self->interpSave.curFrame,
@@ -375,7 +375,7 @@ void dvmCheckSelfVerification(const u2* pc, Thread* self)
                     goto log_and_continue;
                 }
                 LOGD("~~~ DbgIntp(%d): MEMORY DIVERGENCE!", self->threadId);
-                LOGD("Addr: 0x%x Intrp Data: 0x%x Jit Data: 0x%x",
+                LOGD("Addr: %#x Intrp Data: %#x Jit Data: %#x",
                     heapSpacePtr->addr, memData, heapSpacePtr->data);
                 selfVerificationDumpState(pc, self);
                 selfVerificationDumpTrace(pc, self);
@@ -410,7 +410,7 @@ log_and_continue:
     /* If end not been reached, make sure max length not exceeded */
     if (shadowSpace->traceLength >= JIT_MAX_TRACE_LEN) {
         LOGD("~~~ DbgIntp(%d): CONTROL DIVERGENCE!", self->threadId);
-        LOGD("startPC: 0x%x endPC: 0x%x currPC: 0x%x",
+        LOGD("startPC: %#x endPC: %#x currPC: %#x",
             (int)shadowSpace->startPC, (int)shadowSpace->endPC, (int)pc);
         selfVerificationDumpState(pc, self);
         selfVerificationDumpTrace(pc, self);
@@ -664,13 +664,13 @@ void dvmJitDumpTraceDesc(JitTraceDescription *trace)
     const u2* dpcBase;
     int curFrag = 0;
     LOGD("===========================================");
-    LOGD("Trace dump 0x%x, Method %s off 0x%x",(int)trace,
+    LOGD("Trace dump %#x, Method %s off %#x",(int)trace,
          trace->method->name,trace->trace[curFrag].info.frag.startOffset);
     dpcBase = trace->method->insns;
     while (!done) {
         DecodedInstruction decInsn;
         if (trace->trace[curFrag].isCode) {
-            LOGD("Frag[%d]- Insts: %d, start: 0x%x, hint: 0x%x, end: %d",
+            LOGD("Frag[%d]- Insts: %d, start: %#x, hint: %#x, end: %d",
                  curFrag, trace->trace[curFrag].info.frag.numInsts,
                  trace->trace[curFrag].info.frag.startOffset,
                  trace->trace[curFrag].info.frag.hint,
@@ -678,7 +678,7 @@ void dvmJitDumpTraceDesc(JitTraceDescription *trace)
             dpc = dpcBase + trace->trace[curFrag].info.frag.startOffset;
             for (i=0; i<trace->trace[curFrag].info.frag.numInsts; i++) {
                 dexDecodeInstruction(dpc, &decInsn);
-                LOGD("    0x%04x - %s 0x%x",(dpc-dpcBase),
+                LOGD("    0x%04x - %s %#x",(dpc-dpcBase),
                      dexGetOpcodeName(decInsn.opcode),(int)dpc);
                 dpc += dexGetWidthFromOpcode(decInsn.opcode);
             }
@@ -810,7 +810,7 @@ void dvmCheckJit(const u2* pc, Thread* self)
             }
 
 #if defined(SHOW_TRACE)
-            LOGD("TraceGen: adding %s. lpc:0x%x, pc:0x%x",
+            LOGD("TraceGen: adding %s. lpc:%#x, pc:%#x",
                  dexGetOpcodeName(decInsn.opcode), (int)lastPC, (int)pc);
 #endif
             flags = dexGetFlagsFromOpcode(decInsn.opcode);
@@ -1274,7 +1274,7 @@ void dvmJitCheckTraceRequest(Thread* self)
                 /* Turn on trace selection mode */
                 dvmEnableSubMode(self, kSubModeJitTraceBuild);
 #if defined(SHOW_TRACE)
-                LOGD("Starting trace for %s at 0x%x",
+                LOGD("Starting trace for %s at %#x",
                      self->interpSave.method->name, (int)self->interpSave.pc);
 #endif
                 break;