HRESULT Library_corlib_native_System_Resources_ResourceManager::GetObject___STATIC__OBJECT__SystemResourcesResourceManager__SystemEnum( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_HeapBlock& blkResourceManager = stack.Arg0(); CLR_RT_HeapBlock& blkEnumObj = stack.Arg1(); CLR_RT_HeapBlock* blkVT = blkEnumObj.Dereference(); CLR_RT_HeapBlock* blkEnum = blkVT + 1; CLR_RT_MethodDef_Instance md; if(stack.m_customState == 0) { stack.m_customState = 1; FAULT_ON_NULL(blkVT); if(blkEnum->DataType() != DATATYPE_I2 && blkEnum->DataType() != DATATYPE_U2) TINYCLR_SET_AND_LEAVE( CLR_E_INVALID_PARAMETER ); //call back into ResourceManager.GetObjectFromId(short id); _SIDE_ASSERTE(md.InitializeFromIndex( g_CLR_RT_WellKnownMethods.m_ResourceManager_GetObjectFromId )); TINYCLR_CHECK_HRESULT( stack.MakeCall( md, &blkResourceManager, blkEnum, 1 )); } TINYCLR_NOCLEANUP(); }
HRESULT Library_corlib_native_System_Reflection_ConstructorInfo::Invoke___OBJECT__SZARRAY_OBJECT( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_HeapBlock* thisRef = stack.ThisRef().Dereference(); CLR_RT_MethodDef_Instance md; CLR_RT_HeapBlock_Array* pArray = stack.Arg1().DereferenceArray(); CLR_RT_HeapBlock* args = NULL; int numArgs = 0; if(md.InitializeFromIndex( thisRef->ReflectionDataConst().m_data.m_method ) == false) TINYCLR_SET_AND_LEAVE(CLR_E_NULL_REFERENCE); if(stack.m_customState == 0) { stack.m_customState = 1; if(pArray) { args = (CLR_RT_HeapBlock*)pArray->GetFirstElement(); numArgs = pArray->m_numOfElements; } TINYCLR_CHECK_HRESULT(stack.MakeCall( md, NULL, args, numArgs )); } TINYCLR_NOCLEANUP(); }
void CLR_RT_Assembly::DumpOpcode( CLR_RT_StackFrame* stack, CLR_PMETADATA ip ) { NATIVE_PROFILE_CLR_DIAGNOSTICS(); if(s_CLR_RT_fTrace_Instructions < c_CLR_RT_Trace_Info) return; CLR_RT_MethodDef_Instance inst; if(s_CLR_RT_fTrace_Instructions >= c_CLR_RT_Trace_Verbose) { inst = stack->m_call; } else { inst.Clear(); } DumpOpcodeDirect( inst, ip, stack->m_IPstart, stack->m_owningThread->m_pid ); }
HRESULT Library_corlib_native_System_Resources_ResourceManager::GetObject___STATIC__OBJECT__SystemResourcesResourceManager__SystemEnum__I4__I4( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_HeapBlock& blkResourceManager = stack.Arg0(); CLR_RT_MethodDef_Instance md; if(stack.m_customState == 0) { stack.m_customState = 1; //call back into ResourceManager.GetObjectFromId(short id, int offset, int length); _SIDE_ASSERTE(md.InitializeFromIndex( g_CLR_RT_WellKnownMethods.m_ResourceManager_GetObjectChunkFromId )); TINYCLR_CHECK_HRESULT( stack.MakeCall( md, &blkResourceManager, &stack.Arg1(), 3 )); } TINYCLR_NOCLEANUP(); }
HRESULT CLR_RT_StackFrame::MakeCall( CLR_RT_MethodDef_Instance md, CLR_RT_HeapBlock* obj, CLR_RT_HeapBlock* args, int nArgs ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); const CLR_RECORD_METHODDEF* mdR = md.m_target; bool fStatic =(mdR->flags & CLR_RECORD_METHODDEF::MD_Static) != 0; int numArgs = mdR->numArgs; int argsOffset = 0; CLR_RT_StackFrame* stackSub; CLR_RT_HeapBlock tmp; tmp.SetObjectReference( NULL ); CLR_RT_ProtectFromGC gc(tmp); if(mdR->flags & CLR_RECORD_METHODDEF::MD_Constructor) { CLR_RT_TypeDef_Instance owner; owner.InitializeFromMethod( md ); _ASSERTE(obj == NULL); _SIDE_ASSERTE(owner.InitializeFromMethod( md )); TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.NewObject( tmp, owner )); obj = &tmp; // // Make a copy of the object pointer. // PushValueAndAssign( tmp ); } if(!fStatic) { FAULT_ON_NULL(obj); numArgs--; argsOffset = 1; } if(numArgs != nArgs) TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_PARAMETER); // // In case the invoked method is abstract or virtual, resolve it to the correct method implementation. // if(mdR->flags & (CLR_RECORD_METHODDEF::MD_Abstract | CLR_RECORD_METHODDEF::MD_Virtual)) { CLR_RT_TypeDef_Index cls; CLR_RT_MethodDef_Index mdReal; _ASSERTE(obj); _ASSERTE(!fStatic); TINYCLR_CHECK_HRESULT(CLR_RT_TypeDescriptor::ExtractTypeIndexFromObject( *obj, cls )); if(g_CLR_RT_EventCache.FindVirtualMethod( cls, md, mdReal ) == false) { TINYCLR_SET_AND_LEAVE(CLR_E_WRONG_TYPE); } md.InitializeFromIndex( mdReal ); mdR = md.m_target; } #if defined(TINYCLR_APPDOMAINS) if(!fStatic && obj->IsTransparentProxy()) { TINYCLR_CHECK_HRESULT(CLR_RT_StackFrame::PushAppDomainTransition( m_owningThread, md, obj, args )); stackSub = m_owningThread->CurrentFrame(); stackSub->m_flags |= CLR_RT_StackFrame::c_AppDomainMethodInvoke; } else #endif { TINYCLR_CHECK_HRESULT(CLR_RT_StackFrame::Push( m_owningThread, md, md.m_target->numArgs )); stackSub = m_owningThread->CurrentFrame(); if(!fStatic) { stackSub->m_arguments[ 0 ].Assign( *obj ); } if(numArgs) { memcpy( &stackSub->m_arguments[ argsOffset ], args, sizeof(CLR_RT_HeapBlock) * numArgs ); } } TINYCLR_CHECK_HRESULT(stackSub->FixCall()); TINYCLR_SET_AND_LEAVE(CLR_E_RESTART_EXECUTION); TINYCLR_NOCLEANUP(); }
void CLR_RT_EventCache::VirtualMethodTable::DumpTree() { TreeDiagram_Vector vec; TreeDiagram* tdChild; size_t tot; size_t col; int row; int depth = 0; BuildLevel( vec, (LookupEntry*)m_tree.m_root, depth, 0, tdChild ); tot = vec.size(); if(tot) { std::string nameCLS; std::string nameMD; printf( "Tree:\n\n" ); for(row=0; row<=depth; row++) { TreeDiagram tdActive; for(int j=0; j<4; j++) { for(col=0; col<tot; col++) { TreeDiagram& td = vec[ col ]; LPCSTR sz = " "; if(td.depth == row) { switch(j) { case 0: tdActive = td; sz = "*"; { LookupEntry* other; int res; other = (LookupEntry*)td.node->m_left; if(other) { res = td.node->m_payload.Compare( other->m_payload ); if(res != 1) sz = "#"; } other = (LookupEntry*)td.node->m_right; if(other) { res = td.node->m_payload.Compare( other->m_payload ); if(res != -1) sz = "#"; } } break; case 1: if(td.HasChildren()) sz = "|"; break; case 2: if(td.HasChildren()) sz = "+"; break; } } else if(td.parent != -1 && vec[ td.parent ].depth == row) { switch(j) { case 2: sz = td.parent < col ? "\\" : "/"; break; case 3: sz = "|"; break; } } else if(tdActive.DrawHorizontalBar( col )) { switch(j) { case 2: sz = "-"; break; } } else if(td.parent != -1 && vec[ td.parent ].depth < row && row < td.depth) { sz = "|"; } printf( sz ); } if(j == 0 && tdActive.node) { Payload& pl = tdActive.node->m_payload; CLR_RT_StringMap map; printf( " %08x %4d %4d [%08x %08x] ", (size_t)tdActive.node, tdActive.depthOfLeftChildren, tdActive.depthOfRightChildren, pl.m_mdVirtual.m_data, pl.m_cls.m_data ); CLR_RT_TypeDef_Instance instCLS; instCLS.InitializeFromIndex( pl.m_cls ); CLR_RT_MethodDef_Instance instMD ; instMD .InitializeFromIndex( pl.m_mdVirtual ); if(instCLS.InitializeFromIndex( pl.m_cls ) && instMD .InitializeFromIndex( pl.m_mdVirtual ) ) { instCLS.m_assm->BuildClassName ( instCLS.m_target, nameCLS, false ); instMD .m_assm->BuildMethodName( instMD .m_target, nameMD , map ); printf( " {%4d %s %s}", instMD.Hits(), nameCLS.c_str(), nameMD.c_str() ); } } printf( "\n" ); } } } }
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; }