HRESULT CLR_RT_StackFrame::Push( CLR_RT_Thread* th, const CLR_RT_MethodDef_Instance& callInst, CLR_INT32 extraBlocks )
{
NATIVE_PROFILE_CLR_CORE();
TINYCLR_HEADER();
CLR_RT_StackFrame* stack;
CLR_RT_StackFrame* caller;
CLR_RT_Assembly* assm;
const CLR_RECORD_METHODDEF* md;
const CLR_RT_MethodDef_Instance* callInstPtr = &callInst;
CLR_UINT32 sizeLocals;
CLR_UINT32 sizeEvalStack;
#if defined(PLATFORM_WINDOWS)
if(s_CLR_RT_fTrace_SimulateSpeed > c_CLR_RT_Trace_None)
{
CLR_PROF_Handler::SuspendTime();
HAL_Windows_FastSleep( g_HAL_Configuration_Windows.TicksPerMethodCall );
CLR_PROF_Handler::ResumeTime();
}
#endif
assm = callInstPtr->m_assm;
md = callInstPtr->m_target;
sizeLocals = md->numLocals;
sizeEvalStack = md->lengthEvalStack + CLR_RT_StackFrame::c_OverheadForNewObjOrInteropMethod;
//--//
caller = th->CurrentFrame();
//--//
//
// Allocate memory for the runtime state.
//
{
CLR_UINT32 memorySize = sizeLocals + sizeEvalStack;
if(extraBlocks > 0 ) memorySize += extraBlocks;
if(memorySize < c_MinimumStack) memorySize = c_MinimumStack;
memorySize += CONVERTFROMSIZETOHEAPBLOCKS(offsetof(CLR_RT_StackFrame,m_extension));
stack = EVENTCACHE_EXTRACT_NODE_AS_BLOCKS(g_CLR_RT_EventCache,CLR_RT_StackFrame,DATATYPE_STACK_FRAME,0,memorySize);
CHECK_ALLOCATION(stack);
}
//--//
{ //
stack->m_owningSubThread = th->CurrentSubThread(); // CLR_RT_SubThread* m_owningSubThread; // EVENT HEAP - NO RELOCATION -
stack->m_owningThread = th; // CLR_RT_Thread* m_owningThread; // EVENT HEAP - NO RELOCATION -
// CLR_UINT32 m_flags;
//
stack->m_call = *callInstPtr; // CLR_RT_MethodDef_Instance m_call;
//
// CLR_RT_MethodHandler m_nativeMethod;
// CLR_PMETADATA m_IPstart; // ANY HEAP - DO RELOCATION -
// CLR_PMETADATA m_IP; // ANY HEAP - DO RELOCATION -
//
stack->m_locals = stack->m_extension; // CLR_RT_HeapBlock* m_locals; // EVENT HEAP - NO RELOCATION -
stack->m_evalStack = stack->m_extension + sizeLocals; // CLR_RT_HeapBlock* m_evalStack; // EVENT HEAP - NO RELOCATION -
stack->m_evalStackPos = stack->m_evalStack; // CLR_RT_HeapBlock* m_evalStackPos; // EVENT HEAP - NO RELOCATION -
stack->m_evalStackEnd = stack->m_evalStack + sizeEvalStack; // CLR_RT_HeapBlock* m_evalStackEnd; // EVENT HEAP - NO RELOCATION -
stack->m_arguments = NULL; // CLR_RT_HeapBlock* m_arguments; // EVENT HEAP - NO RELOCATION -
//
// union
// {
stack->m_customState = 0; // CLR_UINT32 m_customState;
// void* m_customPointer;
// };
//
#if defined(TINYCLR_PROFILE_NEW_CALLS)
stack->m_callchain.Enter( stack ); // CLR_PROF_CounterCallChain m_callchain;
#endif
//
// CLR_RT_HeapBlock m_extension[1];
//
#if defined(ENABLE_NATIVE_PROFILER)
stack->m_fNativeProfiled = stack->m_owningThread->m_fNativeProfiled;
#endif
CLR_RT_MethodHandler impl;
#if defined(TINYCLR_APPDOMAINS)
stack->m_appDomain = g_CLR_RT_ExecutionEngine.GetCurrentAppDomain();
#endif
if(md->flags & CLR_RECORD_METHODDEF::MD_DelegateInvoke) // Special case for delegate calls.
{
stack->m_nativeMethod = (CLR_RT_MethodHandler)CLR_RT_Thread::Execute_DelegateInvoke;
stack->m_flags = CLR_RT_StackFrame::c_MethodKind_Native;
stack->m_IPstart = NULL;
}
else if(assm->m_nativeCode && (impl = assm->m_nativeCode[ stack->m_call.Method() ]) != NULL)
{
stack->m_nativeMethod = impl;
stack->m_flags = CLR_RT_StackFrame::c_MethodKind_Native;
stack->m_IPstart = NULL;
stack->m_IP = NULL;
}
#if defined(TINYCLR_JITTER)
else if(assm->m_jittedCode && (impl = assm->m_jittedCode[ stack->m_call.Method() ]) != NULL)
{
stack->m_nativeMethod = (CLR_RT_MethodHandler)(size_t)g_thunkTable.m_address__Internal_Initialize;
stack->m_flags = CLR_RT_StackFrame::c_MethodKind_Jitted;
stack->m_IPstart = (CLR_PMETADATA)impl;
if(md->flags & CLR_RECORD_METHODDEF::MD_HasExceptionHandlers)
{
CLR_UINT32 numEh = *(CLR_UINT32*)stack->m_IPstart;
stack->m_IP = stack->m_IPstart + sizeof(CLR_UINT32) + numEh * sizeof(CLR_RT_ExceptionHandler);
}
else
{
stack->m_IP = stack->m_IPstart;
}
}
#endif
else
{
stack->m_nativeMethod = (CLR_RT_MethodHandler)CLR_RT_Thread::Execute_IL;
if(md->RVA == CLR_EmptyIndex) TINYCLR_SET_AND_LEAVE(CLR_E_NOT_SUPPORTED);
stack->m_flags = CLR_RT_StackFrame::c_MethodKind_Interpreted;
stack->m_IPstart = assm->GetByteCode( md->RVA );
stack->m_IP = stack->m_IPstart;
}
#if defined(ENABLE_NATIVE_PROFILER)
if(stack->m_owningThread->m_fNativeProfiled == false && md->flags & CLR_RECORD_METHODDEF::MD_NativeProfiled)
{
stack->m_flags |= CLR_RT_StackFrame::c_NativeProfiled;
stack->m_owningThread->m_fNativeProfiled = true;
}
#endif
//--//
th->m_stackFrames.LinkAtBack( stack );
#if defined(TINYCLR_PROFILE_NEW_CALLS)
g_CLR_PRF_Profiler.RecordFunctionCall( th, callInst );
#endif
}
if(md->numLocals)
{
g_CLR_RT_ExecutionEngine.InitializeLocals( stack->m_locals, assm, md );
}
{
CLR_UINT32 flags = md->flags & (md->MD_Synchronized | md->MD_GloballySynchronized);
if(flags)
{
if(flags & md->MD_Synchronized ) stack->m_flags |= c_NeedToSynchronize;
if(flags & md->MD_GloballySynchronized) stack->m_flags |= c_NeedToSynchronizeGlobally;
}
}
#if defined(TINYCLR_ENABLE_SOURCELEVELDEBUGGING)
stack->m_depth = stack->Caller()->Prev() ? stack->Caller()->m_depth + 1 : 0;
if(g_CLR_RT_ExecutionEngine.m_breakpointsNum)
{
if(stack->m_call.DebuggingInfo().HasBreakpoint())
{
stack->m_flags |= CLR_RT_StackFrame::c_HasBreakpoint;
}
if(stack->m_owningThread->m_fHasJMCStepper || (stack->m_flags & c_HasBreakpoint) || (caller->Prev() != NULL && (caller->m_flags & c_HasBreakpoint)))
{
g_CLR_RT_ExecutionEngine.Breakpoint_StackFrame_Push( stack, CLR_DBG_Commands::Debugging_Execution_BreakpointDef::c_DEPTH_STEP_CALL );
}
}
#endif
//--//
#if defined(TINYCLR_JITTER)
if(s_CLR_RT_fJitter_Enabled && (stack->m_flags & CLR_RT_StackFrame::c_MethodKind_Mask) == CLR_RT_StackFrame::c_MethodKind_Interpreted)
{
CLR_RT_ExecutionEngine::ExecutionConstraint_Suspend();
g_CLR_RT_ExecutionEngine.Compile( stack->m_call, CLR_RT_ExecutionEngine::c_Compile_ARM );
CLR_RT_ExecutionEngine::ExecutionConstraint_Resume();
if(assm->m_jittedCode)
{
CLR_PMETADATA ipStart = (CLR_PMETADATA)assm->m_jittedCode[ stack->m_call.Method() ];
if(ipStart != NULL)
{
stack->m_nativeMethod = (CLR_RT_MethodHandler)(size_t)g_thunkTable.m_address__Internal_Initialize;
stack->m_IPstart = ipStart;
if(md->flags & CLR_RECORD_METHODDEF::MD_HasExceptionHandlers)
{
CLR_UINT32 numEh = *(CLR_UINT32*)ipStart;
stack->m_IP = ipStart + sizeof(CLR_UINT32) + numEh * sizeof(CLR_RT_ExceptionHandler);
}
else
{
stack->m_IP = ipStart;
}
stack->m_flags &= ~CLR_RT_StackFrame::c_MethodKind_Mask;
stack->m_flags |= CLR_RT_StackFrame::c_MethodKind_Jitted;
}
}
}
#endif
if(caller->Prev() != NULL && caller->m_nativeMethod == stack->m_nativeMethod)
{
if(stack->m_flags & CLR_RT_StackFrame::c_ProcessSynchronize)
{
stack->m_flags |= CLR_RT_StackFrame::c_CallerIsCompatibleForRet;
}
else
{
stack->m_flags |= CLR_RT_StackFrame::c_CallerIsCompatibleForCall | CLR_RT_StackFrame::c_CallerIsCompatibleForRet;
}
}
//
// If the arguments are in the caller's stack frame (var == 0), let's link the two.
//
if(extraBlocks < 0)
{
#if defined(PLATFORM_WINDOWS) || (defined(PLATFORM_WINCE) && defined(_DEBUG))
if(caller->m_evalStackPos > caller->m_evalStackEnd)
{
TINYCLR_SET_AND_LEAVE(CLR_E_STACK_OVERFLOW);
}
#endif
//
// Everything is set up correctly, pop the operands.
//
stack->m_arguments = &caller->m_evalStackPos[ -md->numArgs ];
caller->m_evalStackPos = stack->m_arguments;
#if defined(PLATFORM_WINDOWS) || (defined(PLATFORM_WINCE) && defined(_DEBUG))
if(stack->m_arguments < caller->m_evalStack)
{
TINYCLR_SET_AND_LEAVE(CLR_E_STACK_UNDERFLOW);
}
#endif
}
else
{
stack->m_arguments = stack->m_evalStackEnd;
}
TINYCLR_CLEANUP();
TINYCLR_CLEANUP_END();
}
bool CLR_RT_StackFrame::PushInline( CLR_PMETADATA& ip, CLR_RT_Assembly*& assm, CLR_RT_HeapBlock*& evalPos, CLR_RT_MethodDef_Instance& calleeInst, CLR_RT_HeapBlock* pThis)
{
const CLR_RECORD_METHODDEF* md = calleeInst.m_target;
if( (m_inlineFrame != NULL) || // We can only support one inline at a time per stack call
(m_evalStackEnd - evalPos) <= (md->numArgs + md->numLocals + md->lengthEvalStack + 2) || // We must have enough space on the current stack for the inline method
(m_nativeMethod != (CLR_RT_MethodHandler)CLR_RT_Thread::Execute_IL) || // We only support IL inlining
(md->flags & ~CLR_RECORD_METHODDEF::MD_HasExceptionHandlers) >= CLR_RECORD_METHODDEF::MD_Constructor || // Do not try to inline constructors, etc because they require special processing
(0 != (md->flags & CLR_RECORD_METHODDEF::MD_Static)) || // Static methods also requires special processing
(calleeInst.m_assm->m_nativeCode != NULL && (calleeInst.m_assm->m_nativeCode[ calleeInst.Method() ] != NULL)) || // Make sure the callee is not an internal method
(md->RVA == CLR_EmptyIndex) || // Make sure we have a valid IP address for the method
!g_CLR_RT_EventCache.GetInlineFrameBuffer(&m_inlineFrame)) // Make sure we have an extra slot in the inline cache
{
return false;
}
CLR_PMETADATA ipTmp = calleeInst.m_assm->GetByteCode( md->RVA );
#if defined(PLATFORM_WINDOWS)
if(s_CLR_RT_fTrace_SimulateSpeed > c_CLR_RT_Trace_None)
{
CLR_PROF_Handler::SuspendTime();
HAL_Windows_FastSleep( g_HAL_Configuration_Windows.TicksPerMethodCall );
CLR_PROF_Handler::ResumeTime();
}
#endif
// make backup
m_inlineFrame->m_frame.m_IP = ip;
m_inlineFrame->m_frame.m_IPStart = m_IPstart;
m_inlineFrame->m_frame.m_locals = m_locals;
m_inlineFrame->m_frame.m_args = m_arguments;
m_inlineFrame->m_frame.m_call = m_call;
m_inlineFrame->m_frame.m_evalStack = m_evalStack;
m_inlineFrame->m_frame.m_evalPos = pThis;
// increment the evalPos pointer so that we don't corrupt the real stack
evalPos++;
assm = calleeInst.m_assm;
ip = ipTmp;
m_arguments = pThis;
m_locals = &m_evalStackEnd[-md->numLocals];
m_call = calleeInst;
m_evalStackEnd = m_locals;
m_evalStack = evalPos;
m_evalStackPos = evalPos + 1;
m_IPstart = ip;
m_IP = ip;
if(md->numLocals)
{
g_CLR_RT_ExecutionEngine.InitializeLocals( m_locals, calleeInst.m_assm, md );
}
m_flags |= CLR_RT_StackFrame::c_MethodKind_Inlined;
if(md->retVal != DATATYPE_VOID)
{
m_flags |= CLR_RT_StackFrame::c_InlineMethodHasReturnValue;
}
#if defined(TINYCLR_ENABLE_SOURCELEVELDEBUGGING)
m_depth++;
if(g_CLR_RT_ExecutionEngine.m_breakpointsNum)
{
if(m_call.DebuggingInfo().HasBreakpoint())
{
m_flags |= CLR_RT_StackFrame::c_HasBreakpoint;
}
if(m_owningThread->m_fHasJMCStepper || (m_flags & CLR_RT_StackFrame::c_HasBreakpoint))
{
g_CLR_RT_ExecutionEngine.Breakpoint_StackFrame_Push( this, CLR_DBG_Commands::Debugging_Execution_BreakpointDef::c_DEPTH_STEP_CALL );
}
}
#endif
return true;
}
