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; }