/**
* Calls static initializer if necessary before
* dispatching with dispatch_special().
* @param retAddr Return bytecode address.
* @param btAddr Backtrack bytecode address (in case
* static initializer is executed).
*/
void dispatch_special_checked (byte classIndex, byte methodIndex,
byte *retAddr, byte *btAddr)
{
ClassRecord *classRecord;
MethodRecord *methodRecord;
#if DEBUG_METHODS
printf ("dispatch_special_checked: %d, %d, %d, %d\n",
classIndex, methodIndex, (int) retAddr, (int) btAddr);
#endif
// If we need to run the initializer then the real method will get called
// later, when we re-run the current instruction.
classRecord = get_class_record (classIndex);
if (!is_initialized_idx (classIndex))
if (dispatch_static_initializer (classRecord, btAddr) != EXEC_CONTINUE)
return;
methodRecord = get_method_record (classRecord, methodIndex);
if(dispatch_special (methodRecord, retAddr))
{
if (is_synchronized(methodRecord))
{
if (!is_static(methodRecord))
{
Object *ref = (Object *)curLocalsBase[0];
current_stackframe()->monitor = ref;
enter_monitor (currentThread, ref);
}
else
{
Object *ref = (Object *)classRecord;
current_stackframe()->monitor = ref;
enter_monitor (currentThread, ref);
}
}
}
}
void dispatch_virtual (Object *ref, int signature, byte *retAddr)
{
ClassRecord *classRecord;
MethodRecord *methodRecord;
int classIndex;
#if DEBUG_METHODS
printf("dispatch_virtual %d\n", signature);
#endif
if (ref == JNULL)
{
throw_new_exception (JAVA_LANG_NULLPOINTEREXCEPTION);
return;
}
// When calling methods on arrays, we use the methods for the Object class...
classIndex = get_class_index(ref);
LABEL_METHODLOOKUP:
classRecord = get_class_record (classIndex);
methodRecord = find_method (classRecord, signature);
if (methodRecord == null)
{
#if SAFE
if (classIndex == JAVA_LANG_OBJECT)
{
throw_new_exception (JAVA_LANG_NOSUCHMETHODERROR);
return;
}
#endif
classIndex = classRecord->parentClass;
goto LABEL_METHODLOOKUP;
}
if (dispatch_special (methodRecord, retAddr))
{
if (is_synchronized(methodRecord))
{
current_stackframe()->monitor = ref;
enter_monitor (currentThread, ref);
}
}
}
void dispatch_virtual (Object *ref, TWOBYTES signature, byte *retAddr)
{
MethodRecord *auxMethodRecord;
byte auxByte;
#if DEBUG_METHODS
printf("dispatch_virtual %d\n", signature);
#endif
if (ref == JNULL)
{
throw_exception (nullPointerException);
return;
}
auxByte = get_class_index(ref);
LABEL_METHODLOOKUP:
tempClassRecord = get_class_record (auxByte);
auxMethodRecord = find_method (tempClassRecord, signature);
if (auxMethodRecord == null)
{
#if SAFE
if (auxByte == JAVA_LANG_OBJECT)
{
throw_exception (noSuchMethodError);
return;
}
#endif
auxByte = tempClassRecord->parentClass;
goto LABEL_METHODLOOKUP;
}
if (dispatch_special (auxMethodRecord, retAddr))
{
if (is_synchronized(auxMethodRecord))
{
current_stackframe()->monitor = ref;
enter_monitor (currentThread, ref);
}
}
}
/**
* Exceute the static initializer if required. Note that the ret address used
* here is set such that the current instruction will be re-started when the
* initialization completes.
* @return An indication of how the VM should proceed
*/
int dispatch_static_initializer (ClassRecord *aRec, byte *retAddr)
{
int state = get_init_state(aRec);
ClassRecord *init = aRec;
ClassRecord *super = get_class_record(init->parentClass);
MethodRecord *method;
// Are we needed?
if (state & C_INITIALIZED) return EXEC_CONTINUE;
// We need to initialize all of the super classes first. So we find the
// highest one that has not been initialized and deal with that. This code
// will then be called again and we will init the next highest and so on
// until all of the classes in the chain are done.
for(;;)
{
// find first super class that has not been initialized
while (init != super && (get_init_state(super) & C_INITIALIZED) == 0)
{
init = super;
super = get_class_record(init->parentClass);
}
// Do we have an initilizer if so we have found our class
if (has_clinit (init)) break;
// no initializer so mark as now initialized
set_init_state (init, C_INITIALIZED);
// If we are at the start of the list we are done
if (init == aRec) return EXEC_CONTINUE;
// Otherwise go do it all again
init = aRec;
}
state = get_init_state(init);
// are we already initializing ?
if (state & C_INITIALIZING)
{
// Is it this thread that is doing the init?
if (get_sync(init)->threadId == currentThread->threadId)
return EXEC_CONTINUE;
// No so we must retry the current instruction
curPc = retAddr;
sleep_thread(1);
schedule_request(REQUEST_SWITCH_THREAD);
return EXEC_RETRY;
}
#if DEBUG_METHODS
printf ("dispatch_static_initializer: has clinit: %d, %d\n",
(int) aRec, (int) retAddr);
#endif
// Static initializer is always the first method
method = get_method_table(init);
if ((byte *)method == get_binary_base() || method->signatureId != _6clinit_7_4_5V)
{
throw_new_exception (JAVA_LANG_NOSUCHMETHODERROR);
return EXEC_EXCEPTION;
}
// Can we run it?
if (!dispatch_special (method, retAddr))
return EXEC_RETRY;
// Mark for next time
set_init_state(init, C_INITIALIZING);
// and claim the monitor
current_stackframe()->monitor = (Object *)init;
enter_monitor (currentThread, (Object *)init);
return EXEC_RUN;
}
