void Runtime::Debugger::EvaluateReference(Reference* &reference, MemoryContext context) {
StackMethod* method = cur_frame->method;
//
// instance reference
//
if(context != LOCL) {
if(ref_mem && ref_klass) {
// check reference name
bool found;
StackDclr dclr_value;
if(context == INST) {
found = ref_klass->GetInstanceDeclaration(reference->GetVariableName(), dclr_value);
}
else {
found = ref_klass->GetClassDeclaration(reference->GetVariableName(), dclr_value);
}
// set reference
if(found) {
reference->SetDeclaration(dclr_value);
switch(dclr_value.type) {
case CHAR_PARM:
case INT_PARM:
reference->SetIntValue(ref_mem[dclr_value.id]);
break;
case FUNC_PARM:
reference->SetIntValue(ref_mem[dclr_value.id]);
reference->SetIntValue2(ref_mem[dclr_value.id + 1]);
break;
case FLOAT_PARM: {
FLOAT_VALUE value;
memcpy(&value, &ref_mem[dclr_value.id], sizeof(FLOAT_VALUE));
reference->SetFloatValue(value);
}
break;
case OBJ_PARM:
EvaluateInstanceReference(reference, dclr_value.id);
break;
case BYTE_ARY_PARM:
EvaluateByteReference(reference, dclr_value.id);
break;
case CHAR_ARY_PARM:
EvaluateCharReference(reference, dclr_value.id);
break;
case INT_ARY_PARM:
EvaluateIntFloatReference(reference, dclr_value.id, false);
break;
case OBJ_ARY_PARM:
EvaluateIntFloatReference(reference, dclr_value.id, false);
break;
case FLOAT_ARY_PARM:
EvaluateIntFloatReference(reference, dclr_value.id, true);
break;
}
}
else {
wcout << L"unknown variable (or no debug information available)." << endl;
is_error = true;
}
}
else {
wcout << L"unable to find reference." << endl;
is_error = true;
}
}
//
// method reference
//
else {
ref_mem = cur_frame->mem;
if(ref_mem) {
StackDclr dclr_value;
// process explicit '@self' reference
if(reference->IsSelf()) {
dclr_value.name = L"@self";
dclr_value.type = OBJ_PARM;
reference->SetDeclaration(dclr_value);
EvaluateInstanceReference(reference, 0);
}
// process method reference
else {
// check reference name
bool found = method->GetLocalDeclaration(reference->GetVariableName(), dclr_value);
reference->SetDeclaration(dclr_value);
if(found) {
if(method->HasAndOr()) {
dclr_value.id++;
}
switch(dclr_value.type) {
case CHAR_PARM:
case INT_PARM:
reference->SetIntValue(ref_mem[dclr_value.id + 1]);
break;
case FUNC_PARM:
reference->SetIntValue(ref_mem[dclr_value.id + 1]);
reference->SetIntValue2(ref_mem[dclr_value.id + 2]);
break;
case FLOAT_PARM: {
FLOAT_VALUE value;
memcpy(&value, &ref_mem[dclr_value.id + 1], sizeof(FLOAT_VALUE));
reference->SetFloatValue(value);
}
break;
case OBJ_PARM:
EvaluateInstanceReference(reference, dclr_value.id + 1);
break;
case BYTE_ARY_PARM:
EvaluateByteReference(reference, dclr_value.id + 1);
break;
case CHAR_ARY_PARM:
EvaluateCharReference(reference, dclr_value.id + 1);
break;
case INT_ARY_PARM:
EvaluateIntFloatReference(reference, dclr_value.id + 1, false);
break;
case OBJ_ARY_PARM:
EvaluateIntFloatReference(reference, dclr_value.id + 1, false);
break;
case FLOAT_ARY_PARM:
EvaluateIntFloatReference(reference, dclr_value.id + 1, true);
break;
}
}
else {
// class for class reference
StackClass* klass = cur_program->GetClass(reference->GetVariableName());
if(klass) {
dclr_value.name = klass->GetName();
dclr_value.type = OBJ_PARM;
reference->SetDeclaration(dclr_value);
EvaluateClassReference(reference, klass, 0);
}
else {
// process implicit '@self' reference
Reference* next_reference = TreeFactory::Instance()->MakeReference();
next_reference->SetReference(reference);
reference = next_reference;
// set declaration
dclr_value.name = L"@self";
dclr_value.type = OBJ_PARM;
reference->SetDeclaration(dclr_value);
EvaluateInstanceReference(reference, 0);
}
}
}
}
else {
wcout << L"unable to de-reference empty frame." << endl;
is_error = true;
}
}
}
uintptr_t WINAPI MemoryManager::CheckPdaRoots(void* arg)
{
#ifndef _GC_SERIAL
EnterCriticalSection(&pda_frame_cs);
#endif
#ifdef _DEBUG
wcout << L"----- PDA frames(s): num=" << pda_frames.size()
<< L"; thread=" << GetCurrentThread()<< L" -----" << endl;
wcout << L"memory types:" << endl;
#endif
set<StackFrame**, StackFrame**>::iterator iter;
for(iter = pda_frames.begin(); iter != pda_frames.end(); ++iter) {
StackFrame** frame = *iter;
StackMethod* mthd = (*frame)->method;
long* mem = (*frame)->mem;
#ifdef _DEBUG
wcout << L"\t===== PDA method: name=" << mthd->GetName() << L", addr="
<< mthd << L", num=" << mthd->GetNumberDeclarations() << L" =====" << endl;
#endif
// mark self
CheckObject((long*)(*mem), true, 1);
if(mthd->HasAndOr()) {
mem += 2;
}
else {
mem++;
}
// mark rest of memory
CheckMemory(mem, mthd->GetDeclarations(), mthd->GetNumberDeclarations(), 0);
}
#ifndef _GC_SERIAL
LeaveCriticalSection(&pda_frame_cs);
#endif
#ifndef GC_SERIAL
EnterCriticalSection(&pda_monitor_cs);
#endif
#ifdef _DEBUG
wcout << L"----- PDA method root(s): num=" << pda_monitors.size()
<< L"; thread=" << GetCurrentThread()<< L" -----" << endl;
wcout << L"memory types:" << endl;
#endif
// look at pda methods
unordered_map<StackFrameMonitor*, StackFrameMonitor*>::iterator pda_iter;
for(pda_iter = pda_monitors.begin(); pda_iter != pda_monitors.end(); ++pda_iter) {
// gather stack frames
StackFrameMonitor* monitor = pda_iter->first;
long call_stack_pos = *(monitor->call_stack_pos);
if (call_stack_pos > 0) {
StackFrame** call_stack = monitor->call_stack;
StackFrame* cur_frame = *(monitor->cur_frame);
// copy frames locally
vector<StackFrame*> frames;
frames.push_back(cur_frame);
while (--call_stack_pos > -1) {
frames.push_back(call_stack[call_stack_pos]);
}
for (size_t i = 0; i < frames.size(); ++i) {
StackMethod* mthd = frames[i]->method;
long* mem = frames[i]->mem;
#ifdef _DEBUG
wcout << L"\t===== PDA method: name=" << mthd->GetName() << L", addr="
<< mthd << L", num=" << mthd->GetNumberDeclarations() << L" =====" << endl;
#endif
// mark self
CheckObject((long*)(*mem), true, 1);
if (mthd->HasAndOr()) {
mem += 2;
}
else {
mem++;
}
// mark rest of memory
CheckMemory(mem, mthd->GetDeclarations(), mthd->GetNumberDeclarations(), 0);
}
}
}
#ifndef GC_SERIAL
LeaveCriticalSection(&pda_monitor_cs);
#endif
return 0;
}
