void Engine::tick() {
if (!PDRemote_isConnected()) {
//if ((instructions & 127) == 0)
PDRemote_update(0);
return;
}
PDRemote_update(1);
#if 0
if (g_debugger->runState == PDDebugState_stopException) {
for (;;) {
switch (g_debugger->runState) {
case PDDebugState_running:
{
printf("AS: start running\n");
goto go_on; // start running as usually
}
case PDDebugState_trace:
{
printf("trace\n");
step6502(1);
g_debugger->runState = PDDebugState_stopException;
break;
}
default:
break;
}
PDRemote_update(1);
}
}else {
updateDebugger();
}
#endif
}
/*
* Perform some operations at the "top" of the interpreter loop.
* This stuff is required to support debugging and profiling.
*
* Using" __attribute__((noinline))" seems to do more harm than good. This
* is best when inlined due to the large number of parameters, most of
* which are local vars in the main interp loop.
*/
static void checkDebugAndProf(const u2* pc, const u4* fp, Thread* self,
const Method* method, bool* pIsMethodEntry)
{
/* check to see if we've run off end of method */
assert(pc >= method->insns && pc <
method->insns + dvmGetMethodInsnsSize(method));
#if 0
/*
* When we hit a specific method, enable verbose instruction logging.
* Sometimes it's helpful to use the debugger attach as a trigger too.
*/
if (*pIsMethodEntry) {
static const char* cd = "Landroid/test/Arithmetic;";
static const char* mn = "shiftTest2";
static const char* sg = "()V";
if (/*gDvm.debuggerActive &&*/
strcmp(method->clazz->descriptor, cd) == 0 &&
strcmp(method->name, mn) == 0 &&
strcmp(method->shorty, sg) == 0)
{
LOGW("Reached %s.%s, enabling verbose mode\n",
method->clazz->descriptor, method->name);
android_setMinPriority(LOG_TAG"i", ANDROID_LOG_VERBOSE);
dumpRegs(method, fp, true);
}
if (!gDvm.debuggerActive)
*pIsMethodEntry = false;
}
#endif
/*
* If the debugger is attached, check for events. If the profiler is
* enabled, update that too.
*
* This code is executed for every instruction we interpret, so for
* performance we use a couple of #ifdef blocks instead of runtime tests.
*/
#ifdef WITH_PROFILER
/* profiler and probably debugger */
bool isEntry = *pIsMethodEntry;
if (isEntry) {
*pIsMethodEntry = false;
TRACE_METHOD_ENTER(self, method);
}
if (gDvm.debuggerActive) {
updateDebugger(method, pc, fp, isEntry, self);
}
if (gDvm.instructionCountEnableCount != 0) {
/*
* Count up the #of executed instructions. This isn't synchronized
* for thread-safety; if we need that we should make this
* thread-local and merge counts into the global area when threads
* exit (perhaps suspending all other threads GC-style and pulling
* the data out of them).
*/
int inst = *pc & 0xff;
gDvm.executedInstrCounts[inst]++;
}
#else
/* debugger only */
if (gDvm.debuggerActive) {
bool isEntry = *pIsMethodEntry;
updateDebugger(method, pc, fp, isEntry, self);
if (isEntry)
*pIsMethodEntry = false;
}
#endif
}