HRESULT Library_spot_net_native_Microsoft_SPOT_Net_NetworkInformation_NetworkInterface::IPAddressFromString___STATIC__U4__STRING( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_NETWORK(); TINYCLR_HEADER(); LPCSTR szName = stack.Arg0().RecoverString(); struct SOCK_addrinfo hints; struct SOCK_addrinfo* addr = NULL; struct SOCK_sockaddr_in* addr_in; int ret; memset( &hints, 0, sizeof(hints) ); ret = SOCK_getaddrinfo( szName, NULL, &hints, &addr ); // getaddrinfo returns a winsock error code rather than SOCK_SOCKET_ERROR, so pass this on to the exception handling if(ret != 0 || addr == NULL || addr->ai_family != SOCK_AF_INET) { TINYCLR_SET_AND_LEAVE(CLR_E_FAIL); } _ASSERTE(addr->ai_addr != NULL); _ASSERTE(addr->ai_addrlen >= sizeof(SOCK_sockaddr_in)); addr_in = (struct SOCK_sockaddr_in*)addr->ai_addr; stack.PushValue().SetInteger( (CLR_UINT32)addr_in->sin_addr.S_un.S_addr ); TINYCLR_CLEANUP(); if( addr ) SOCK_freeaddrinfo( addr ); TINYCLR_CLEANUP_END(); }
HRESULT CLR_RT_XmlState_InValue::ProcessEndWhitespace( CLR_RT_XmlState* st, CLR_UINT8*& buffer, bool& isDone ) { TINYCLR_HEADER(); _ASSERTE(isDone == true); CLR_RT_XmlState_InValue* state = &st->InValue; CLR_RT_HeapBlock* xmlSpace; CLR_RT_XmlSpace xmlSpaceValue; TINYCLR_CHECK_HRESULT(state->reader->GetXmlSpaces()->Peek( xmlSpace )); // note that xmlSpace is boxed _ASSERTE( xmlSpace->DataType() == DATATYPE_VALUETYPE ); xmlSpaceValue = (CLR_RT_XmlSpace)xmlSpace[ 1 ].NumericByRef().s4; if(xmlSpaceValue == XmlSpace_Preserve || !(state->settings & XmlSettings_IgnoreWhitespace)) { TINYCLR_SET_AND_LEAVE(PrepReturn( st, buffer, 0, (xmlSpaceValue == XmlSpace_Preserve) ? XmlNodeType_SignificantWhitespace : XmlNodeType_Whitespace )); } TINYCLR_CLEANUP(); // regardless of result, we'll set up the next state. note that it's not possible to get XML_E_NEED_MORE_DATA here CLR_RT_XmlState_NewTag::Setup( st ); TINYCLR_CLEANUP_END(); }
HRESULT CLR_RT_HeapBlock_I2CXAction::CreateInstance( CLR_RT_HeapBlock& owner, CLR_RT_HeapBlock& xActionRef ) { NATIVE_PROFILE_CLR_I2C(); TINYCLR_HEADER(); CLR_RT_HeapBlock_I2CXAction* xAction = NULL; xAction = EVENTCACHE_EXTRACT_NODE(g_CLR_RT_EventCache,CLR_RT_HeapBlock_I2CXAction,DATATYPE_I2C_XACTION); CHECK_ALLOCATION(xAction); { CLR_RT_ProtectFromGC gc( *xAction ); xAction->Initialize(); xAction->m_HalXAction = NULL; xAction->m_HalXActionUnits = NULL; xAction->m_dataBuffers = NULL; xAction->m_xActionUnits = 0; m_i2cPorts.LinkAtBack( xAction ); TINYCLR_CHECK_HRESULT(CLR_RT_ObjectToEvent_Source::CreateInstance( xAction, owner, xActionRef )); } TINYCLR_CLEANUP(); if(FAILED(hr)) { if(xAction) xAction->ReleaseWhenDeadEx(); } TINYCLR_CLEANUP_END(); }
HRESULT CLR_RT_XmlState_InName::ProcessNameParts( CLR_RT_XmlState_InName* state, CLR_UINT32& nameLen, CLR_UINT16 stopsAt ) { TINYCLR_HEADER(); CLR_UINT8* buffer = state->buffer; CLR_UINT8* bufferEnd = state->bufferEnd; CLR_UINT32 len = nameLen; while(!(c_XmlCharType[ *buffer ] & stopsAt)) { CLR_INT32 count = ProcessNCNameChar( buffer, bufferEnd - buffer, len == 0 ); if(count > 0) { len += count; buffer += count; if(buffer == bufferEnd) TINYCLR_SET_AND_LEAVE(XML_E_NEED_MORE_DATA); } else { TINYCLR_SET_AND_LEAVE((count == 0) ? XML_E_NEED_MORE_DATA : XML_E_BAD_NAME_CHAR); } } if(len == 0) TINYCLR_SET_AND_LEAVE(XML_E_EMPTY_NAME); TINYCLR_CLEANUP(); nameLen = len; state->buffer = buffer; TINYCLR_CLEANUP_END(); }
HRESULT Library_corlib_native_System_Reflection_Assembly::Load___STATIC__SystemReflectionAssembly__SZARRAY_U1( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_HeapBlock_Array* array = NULL; CLR_RT_Assembly* assm = NULL; CLR_RT_HeapBlock& top = stack.PushValueAndClear(); CLR_RT_HeapBlock* hbObj; CLR_RECORD_ASSEMBLY* header; array = stack.Arg0().DereferenceArray(); FAULT_ON_NULL(array); header = (CLR_RECORD_ASSEMBLY*)array->GetFirstElement(); TINYCLR_CHECK_HRESULT(CLR_RT_Assembly::VerifyEndian(header)); if(header->GoodAssembly()) { // // Sorry, you'll have to reboot to load this assembly. // if(header->flags & CLR_RECORD_ASSEMBLY::c_Flags_NeedReboot) { TINYCLR_SET_AND_LEAVE(CLR_E_BUSY); } TINYCLR_CHECK_HRESULT(CLR_RT_Assembly::CreateInstance( header, assm )); assm->m_pFile = array; g_CLR_RT_TypeSystem.Link( assm ); TINYCLR_CHECK_HRESULT(g_CLR_RT_TypeSystem.ResolveAll ()); TINYCLR_CHECK_HRESULT(g_CLR_RT_TypeSystem.PrepareForExecution()); } if(assm) { CLR_RT_Assembly_Index idx; idx.Set( assm->m_idx ); TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.NewObjectFromIndex(top, g_CLR_RT_WellKnownTypes.m_Assembly)); hbObj = top.Dereference(); hbObj->SetReflection( idx ); } TINYCLR_CLEANUP(); if(FAILED(hr)) { if(assm) { assm->DestroyInstance(); } } TINYCLR_CLEANUP_END(); }
HRESULT Library_corlib_native_System_Reflection_Assembly::LoadInternal___STATIC__SystemReflectionAssembly__STRING__BOOLEAN__I4__I4__I4__I4( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); #if defined(TINYCLR_APPDOMAINS) CLR_RT_AppDomain* appDomain = g_CLR_RT_ExecutionEngine.GetCurrentAppDomain(); #endif CLR_RT_HeapBlock* pArgs = &stack.Arg0(); CLR_RT_Assembly* assembly; LPCSTR szAssembly; CLR_RT_Assembly_Index idx; bool fVersion; CLR_INT16 maj, min, build, rev; CLR_RT_HeapBlock& top = stack.PushValueAndClear(); szAssembly = pArgs[ 0 ].RecoverString(); FAULT_ON_NULL(szAssembly ); fVersion = pArgs[ 1 ].NumericByRef().u1 != 0; maj = pArgs[ 2 ].NumericByRef().s4; min = pArgs[ 3 ].NumericByRef().s4; build = pArgs[ 4 ].NumericByRef().s4; rev = pArgs[ 5 ].NumericByRef().s4; if(fVersion && (maj < 0 || min < 0 || build < 0 || rev < 0)) { TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_PARAMETER); } if(fVersion) { CLR_RECORD_VERSION ver; ver.iMajorVersion = (CLR_UINT16)maj; ver.iMinorVersion = (CLR_UINT16)min; ver.iBuildNumber = (CLR_UINT16)build; ver.iRevisionNumber = (CLR_UINT16)rev; assembly = g_CLR_RT_TypeSystem.FindAssembly( szAssembly, &ver, true ); FAULT_ON_NULL_HR(assembly, CLR_E_INVALID_PARAMETER); } else { assembly = g_CLR_RT_TypeSystem.FindAssembly( szAssembly, NULL, false ); FAULT_ON_NULL_HR(assembly, CLR_E_INVALID_PARAMETER); } #if defined(TINYCLR_APPDOMAINS) TINYCLR_CHECK_HRESULT(appDomain->LoadAssembly( assembly )); #endif idx.Set( assembly->m_idx ); top.SetReflection( idx ); TINYCLR_CLEANUP(); //Avoid exception handling in common case. Just return NULL on failure. //Managed code decides to throw the exception or not. hr = S_OK; TINYCLR_CLEANUP_END(); }
HRESULT Library_spot_native_Microsoft_SPOT_Reflection::GetAssemblyInfo___STATIC__BOOLEAN__SZARRAY_U1__MicrosoftSPOTReflectionAssemblyInfo( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_HeapBlock_Array* array = NULL; CLR_RT_Assembly* assm = NULL; CLR_RECORD_ASSEMBLY* header; array = stack.Arg0().DereferenceArray(); FAULT_ON_NULL(array); header = (CLR_RECORD_ASSEMBLY*)array->GetFirstElement(); if(header->GoodAssembly()) { CLR_RT_HeapBlock* dst = stack.Arg1().Dereference(); FAULT_ON_NULL(dst); TINYCLR_CHECK_HRESULT(CLR_RT_Assembly::CreateInstance( header, assm )); TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_String::CreateInstance( dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyInfo::FIELD__m_name ], assm->m_szName )); { CLR_RT_HeapBlock& refs = dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyInfo::FIELD__m_refs ]; CLR_UINT32 numRef = assm->m_pTablesSize[ TBL_AssemblyRef ]; TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_Array::CreateInstance( refs, numRef, g_CLR_RT_WellKnownTypes.m_UInt32 )); { const CLR_RECORD_ASSEMBLYREF* ar = assm->GetAssemblyRef( 0 ); CLR_UINT32* dst = (CLR_UINT32*)refs.DereferenceArray()->GetFirstElement(); while(numRef--) { *dst++ = assm->ComputeAssemblyHash( ar++ ); } } } dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyInfo::FIELD__m_flags ].SetInteger( assm->m_header->flags , DATATYPE_U4 ); dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyInfo::FIELD__m_size ].SetInteger( ROUNDTOMULTIPLE(assm->m_header->TotalSize(), CLR_INT32), DATATYPE_I4 ); dst[ Library_spot_native_Microsoft_SPOT_Reflection__AssemblyInfo::FIELD__m_hash ].SetInteger( assm->ComputeAssemblyHash() , DATATYPE_U4 ); stack.SetResult_Boolean( true ); } else { stack.SetResult_Boolean( false ); } TINYCLR_CLEANUP(); if(assm) { assm->DestroyInstance(); } TINYCLR_CLEANUP_END(); }
HRESULT CLR_HW_Hardware::TransferAllInterruptsToApplicationQueue() { NATIVE_PROFILE_CLR_HARDWARE(); TINYCLR_HEADER(); while(true) { HalInterruptRecord* rec; { GLOBAL_LOCK(irq1); rec = m_interruptData.m_HalQueue.Peek(); } if(rec == NULL) break; CLR_RT_ApplicationInterrupt* queueRec = (CLR_RT_ApplicationInterrupt*)CLR_RT_Memory::Allocate_And_Erase( sizeof(CLR_RT_ApplicationInterrupt), CLR_RT_HeapBlock::HB_CompactOnFailure ); CHECK_ALLOCATION(queueRec); queueRec->m_interruptPortInterrupt.m_data1 = rec->m_data1; queueRec->m_interruptPortInterrupt.m_data2 = rec->m_data2; queueRec->m_interruptPortInterrupt.m_data3 = rec->m_data3; queueRec->m_interruptPortInterrupt.m_time = rec->m_time; queueRec->m_interruptPortInterrupt.m_context = (CLR_RT_HeapBlock_NativeEventDispatcher*)rec->m_context; m_interruptData.m_applicationQueue.LinkAtBack( queueRec ); ++m_interruptData.m_queuedInterrupts; { GLOBAL_LOCK(irq2); m_interruptData.m_HalQueue.Pop(); } } if(m_interruptData.m_queuedInterrupts == 0) { TINYCLR_SET_AND_LEAVE(CLR_E_NO_INTERRUPT); } TINYCLR_CLEANUP(); if(CLR_E_OUT_OF_MEMORY == hr) { // if there is no memory left discard all interrupts to avoid getting into a death spiral of OOM exceptions { GLOBAL_LOCK(irq3); while(!m_interruptData.m_HalQueue.IsEmpty()) { m_interruptData.m_HalQueue.Pop(); } } } TINYCLR_CLEANUP_END(); }
HRESULT Library_spot_Time_native_Microsoft_SPOT_Time_TimeService::Update___STATIC__MicrosoftSPOTTimeTimeServiceStatus__U4__U4( CLR_RT_StackFrame& stack ) { TINYCLR_HEADER(); CLR_RT_HeapBlock* managedStatus = NULL; UINT32 serverIP = stack.Arg0().NumericByRef().u4; UINT32 tolerance = stack.Arg1().NumericByRef().u4; TimeService_Status status; hr = TimeService_Update( serverIP, tolerance, &status ); if(hr == CLR_E_RESCHEDULE) { TINYCLR_LEAVE(); } else { CLR_RT_HeapBlock& top = stack.PushValueAndClear(); TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.NewObjectFromIndex( top, g_CLR_RT_WellKnownTypes.m_TimeServiceStatus )); managedStatus = top.Dereference(); managedStatus[ ManagedStatus::FIELD__Flags ].SetInteger( status.Flags ); managedStatus[ ManagedStatus::FIELD__SyncSourceServer ].SetInteger( status.ServerIP ); managedStatus[ ManagedStatus::FIELD__SyncTimeOffset ].SetInteger( status.SyncOffset ); managedStatus[ ManagedStatus::FIELD__TimeUTC ].SetInteger( status.CurrentTimeUTC ); } TINYCLR_CLEANUP(); // we are not throwing any exception, we are instead communicating the result through the TimeServiceStatus object we return // if the operation did not completed, we need to reschedule this call though switch(hr) { case CLR_E_RESCHEDULE: break; case CLR_E_TIMEOUT: case CLR_E_FAIL: default: // swallow error hr = S_OK; break; } TINYCLR_CLEANUP_END(); }
HRESULT CLR_RT_HeapBlock_XmlReader::Read() { TINYCLR_HEADER(); CLR_RT_XmlState* state = GetState(); state->State.bufferStart = GetBuffer(); state->State.buffer = state->State.bufferStart + GetOffset(); state->State.bufferEnd = state->State.buffer + GetLength(); state->State.reader = this; if(state->State.initFn) { state->State.initFn( state ); } while(true) { TINYCLR_CHECK_HRESULT(state->State.stateFn( state )); } TINYCLR_CLEANUP(); if(hr == XML_E_NEED_MORE_DATA) { if(state->State.cleanUpFn) { state->State.cleanUpFn( state ); } else { state->State.ShiftBuffer( state->State.buffer ); } // if after buffer adjustment, there's no room for new data, then we know that // we've exceeded one of the system constraints (either the length of name or // attribute value is over buffer size) if(state->State.bufferEnd - state->State.bufferStart == XmlBufferSize) { hr = XML_E_LIMIT_EXCEEDED; } } SetOffset( state->State.buffer - state->State.bufferStart ); SetLength( state->State.bufferEnd - state->State.buffer ); TINYCLR_CLEANUP_END(); }
HRESULT Library_corlib_native_System_AppDomain::Unload___STATIC__VOID__SystemAppDomain( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_AppDomain* appDomainSav; CLR_RT_AppDomain* appDomain; CLR_RT_HeapBlock hbTimeout; CLR_INT64* timeout; bool fRes; TINYCLR_CHECK_HRESULT(GetAppDomain( stack.ThisRef(), appDomain, appDomainSav, false )); hbTimeout.SetInteger( 5 * 1000 ); if(stack.m_customState == 0) { //Attempt to unload the AppDomain only once TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.UnloadAppDomain( appDomain, stack.m_owningThread )); } TINYCLR_CHECK_HRESULT(stack.SetupTimeout( hbTimeout, timeout )); fRes = true; while(fRes) { //Check to make sure this AppDomain is the one that caused the event to fire if(appDomain->m_state == CLR_RT_AppDomain::AppDomainState_Unloaded) break; _ASSERTE(CLR_EE_IS(UnloadingAppDomain)); TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.WaitEvents( stack.m_owningThread, *timeout, CLR_RT_ExecutionEngine::c_Event_AppDomain, fRes )); } if(!fRes) TINYCLR_SET_AND_LEAVE(CLR_E_TIMEOUT); appDomain->DestroyInstance(); stack.PopValue(); TINYCLR_CLEANUP(); g_CLR_RT_ExecutionEngine.SetCurrentAppDomain( appDomainSav ); TINYCLR_CLEANUP_END(); }
HRESULT Library_windows_devices_native_Windows_Devices_Gpio_GpioPin::InitNative___BOOLEAN__I4( CLR_RT_StackFrame& stack ) { TINYCLR_HEADER(); GPIO_PIN portId = GPIO_PIN_NONE; bool pinAllocated = false; CLR_RT_HeapBlock* pThis = stack.This(); FAULT_ON_NULL(pThis); portId = stack.Arg1().NumericByRef().u4; // Ensure the pin exists. if (::CPU_GPIO_Attributes( portId ) == 0) { TINYCLR_SET_AND_LEAVE(S_OK); } // Reserve the pin. If this fails, it's already in use. pinAllocated = !!::CPU_GPIO_ReservePin( portId, TRUE ); if (!pinAllocated) { TINYCLR_SET_AND_LEAVE(S_OK); } // Initialize the default drive mode. if (!::CPU_GPIO_EnableInputPin2( portId, false, NULL, NULL, GPIO_INT_NONE, RESISTOR_DISABLED )) { TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_OPERATION); } pThis[ FIELD__m_pinNumber ].NumericByRef().u4 = portId; TINYCLR_CLEANUP(); if (FAILED(hr)) { if (pinAllocated) { ::CPU_GPIO_ReservePin( portId, FALSE ); } } stack.SetResult_Boolean( pinAllocated ); TINYCLR_CLEANUP_END(); }
HRESULT Library_corlib_native_System_AppDomain::GetAssemblies___SZARRAY_SystemReflectionAssembly( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_AppDomain* appDomainSav = NULL; CLR_RT_AppDomain* appDomain; TINYCLR_CHECK_HRESULT(GetAppDomain( stack.ThisRef(), appDomain, appDomainSav, true )); TINYCLR_CHECK_HRESULT(appDomain->GetAssemblies( stack.PushValueAndClear() )); TINYCLR_CLEANUP(); g_CLR_RT_ExecutionEngine.SetCurrentAppDomain( appDomainSav ); TINYCLR_CLEANUP_END(); }
HRESULT CLR_HW_Hardware::SpawnDispatcher() { NATIVE_PROFILE_CLR_HARDWARE(); TINYCLR_HEADER(); CLR_RT_ApplicationInterrupt* interrupt; CLR_RT_HeapBlock_NativeEventDispatcher* ioPort; CLR_RT_HeapBlock_NativeEventDispatcher ::InterruptPortInterrupt *interruptData; // if reboot is in progress, just bail out if(CLR_EE_DBG_IS( RebootPending )) { return S_OK; } interrupt = (CLR_RT_ApplicationInterrupt*)m_interruptData.m_applicationQueue.FirstValidNode(); if((interrupt == NULL) || !g_CLR_RT_ExecutionEngine.EnsureSystemThread( g_CLR_RT_ExecutionEngine.m_interruptThread, ThreadPriority::System_Highest )) { return S_OK; } interrupt->Unlink(); interruptData = &interrupt->m_interruptPortInterrupt; ioPort = interruptData->m_context; CLR_RT_ProtectFromGC gc1 ( *ioPort ); TINYCLR_SET_AND_LEAVE(ioPort->StartDispatch( interrupt, g_CLR_RT_ExecutionEngine.m_interruptThread )); TINYCLR_CLEANUP(); if(FAILED(hr)) { ioPort->ThreadTerminationCallback( interrupt ); } --m_interruptData.m_queuedInterrupts; TINYCLR_CLEANUP_END(); }
HRESULT CLR_RT_HeapBlock_I2CXAction::AllocateXAction( CLR_UINT32 numXActionUnits ) { NATIVE_PROFILE_CLR_I2C(); TINYCLR_HEADER(); CLR_UINT32 index; if(IsPending()) { TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_OPERATION); } m_xActionUnits = numXActionUnits; // allocate memory for the transaction m_HalXAction = (I2C_HAL_XACTION*)CLR_RT_Memory::Allocate_And_Erase( sizeof(I2C_HAL_XACTION) ); CHECK_ALLOCATION(m_HalXAction); ((HAL_CONTINUATION*)m_HalXAction)->Initialize(); ::I2C_XAction_SetState( m_HalXAction, I2C_HAL_XACTION::c_Status_Idle ); // initialize pointers to data buffers m_dataBuffers = (I2C_WORD**)CLR_RT_Memory::Allocate_And_Erase( sizeof(I2C_WORD*) * numXActionUnits ); CHECK_ALLOCATION(m_dataBuffers); // allocate memory for the transaction units m_HalXActionUnits = (I2C_HAL_XACTION_UNIT**)CLR_RT_Memory::Allocate_And_Erase( sizeof(I2C_HAL_XACTION_UNIT*) * numXActionUnits ); CHECK_ALLOCATION(m_HalXActionUnits); for(index = 0; index < numXActionUnits; ++index) { m_HalXActionUnits[ index ] = (I2C_HAL_XACTION_UNIT*)CLR_RT_Memory::Allocate_And_Erase( sizeof(I2C_HAL_XACTION_UNIT) ); CHECK_ALLOCATION(m_HalXActionUnits[ index ]); } TINYCLR_CLEANUP(); if(FAILED(hr)) { ReleaseBuffers(); } TINYCLR_CLEANUP_END(); }
HRESULT Library_corlib_native_System_AppDomain::CreateDomain___STATIC__SystemAppDomain__STRING( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_AppDomain* appDomain = NULL; CLR_RT_HeapBlock& pArgs = stack.Arg0(); CLR_RT_HeapBlock res; res.SetObjectReference( NULL ); CLR_RT_ProtectFromGC gc( res ); LPCSTR szName; szName = pArgs.RecoverString(); FAULT_ON_NULL(szName); TINYCLR_CHECK_HRESULT(CLR_RT_AppDomain::CreateInstance( szName, appDomain )); //load mscorlib TINYCLR_CHECK_HRESULT(appDomain->LoadAssembly( g_CLR_RT_TypeSystem.m_assemblyMscorlib )); //load Native TINYCLR_CHECK_HRESULT(appDomain->LoadAssembly( g_CLR_RT_TypeSystem.m_assemblyNative )); TINYCLR_CHECK_HRESULT(appDomain->GetManagedObject( res )); //Marshal the new AD to the calling AD. TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.GetCurrentAppDomain()->MarshalObject( res, res, appDomain )); stack.PushValueAndAssign( res ); TINYCLR_CLEANUP(); if(FAILED(hr)) { if(appDomain) { appDomain->DestroyInstance(); } } TINYCLR_CLEANUP_END(); }
HRESULT Library_spot_native_Microsoft_SPOT_Messaging_EndPoint::ReplyRaw___VOID__MicrosoftSPOTMessagingMessage__SZARRAY_U1( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_MESSAGING(); TINYCLR_HEADER(); CLR_RT_HeapBlock* pThis; CLR_RT_HeapBlock* pMsg; CLR_RT_HeapBlock_Array* pData; CLR_RT_HeapBlock_EndPoint* ep; CLR_Messaging_Commands::Messaging_Reply* rpc = NULL; CLR_UINT32 len; pThis = stack.This() ; FAULT_ON_NULL(pThis); pMsg = stack.Arg1().Dereference() ; FAULT_ON_NULL(pMsg ); pData = stack.Arg2().DereferenceArray(); FAULT_ON_NULL(pData); TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_EndPoint::ExtractInstance( pThis[ FIELD__m_handle ], ep )); len = sizeof(CLR_RT_HeapBlock_EndPoint::Address) + pData->m_numOfElements; rpc = (CLR_Messaging_Commands::Messaging_Reply*)CLR_RT_Memory::Allocate( len ); CHECK_ALLOCATION(rpc); rpc->m_addr.m_seq = pMsg[ Library_spot_native_Microsoft_SPOT_Messaging_Message::FIELD__m_seq ].NumericByRefConst ().u4; rpc->m_addr.m_to = ep->m_addr; rpc->m_addr.m_from.m_type = pMsg[ Library_spot_native_Microsoft_SPOT_Messaging_Message::FIELD__m_selector ].ReflectionDataConst().GetTypeHash(); rpc->m_addr.m_from.m_id = pMsg[ Library_spot_native_Microsoft_SPOT_Messaging_Message::FIELD__m_id ].NumericByRefConst ().u4; memcpy( rpc->m_data, pData->GetFirstElement(), pData->m_numOfElements ); CLR_EE_MSG_EVENT_RPC(CLR_Messaging_Commands::c_Messaging_Reply,len,rpc,WP_Flags::c_NonCritical); TINYCLR_CLEANUP(); if(rpc) { CLR_RT_Memory::Release( rpc ); } TINYCLR_CLEANUP_END(); }
HRESULT CLR_RT_HeapBlock_Timer::CreateInstance( CLR_UINT32 flags, CLR_RT_HeapBlock& owner, CLR_RT_HeapBlock& tmRef ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_HeapBlock_Timer* timer = NULL; // // Create a request and stop the calling thread. // timer = EVENTCACHE_EXTRACT_NODE(g_CLR_RT_EventCache,CLR_RT_HeapBlock_Timer,DATATYPE_TIMER_HEAD); CHECK_ALLOCATION(timer); { CLR_RT_ProtectFromGC gc( *timer ); timer->Initialize(); timer->m_flags = flags; timer->m_timeExpire = TIMEOUT_INFINITE; timer->m_timeFrequency = TIMEOUT_INFINITE; timer->m_timeLastExpiration = 0; timer->m_ticksLastExpiration = 0; g_CLR_RT_ExecutionEngine.m_timers.LinkAtBack( timer ); TINYCLR_SET_AND_LEAVE(CLR_RT_ObjectToEvent_Source::CreateInstance( timer, owner, tmRef )); } TINYCLR_CLEANUP(); if(FAILED(hr)) { if(timer) timer->ReleaseWhenDead(); } TINYCLR_CLEANUP_END(); }
HRESULT CLR_GFX_Bitmap::CreateInstanceGif( CLR_RT_HeapBlock& ref, const CLR_UINT8* data, const CLR_UINT32 size ) { NATIVE_PROFILE_CLR_GRAPHICS(); TINYCLR_HEADER(); GifDecoder* decoder; CLR_GFX_Bitmap* bitmap = NULL; CLR_GFX_BitmapDescription bm; // Allocate the decoder decoder = (GifDecoder*)CLR_RT_Memory::Allocate( sizeof(GifDecoder) ); CHECK_ALLOCATION(decoder); // Initialize the decompression engine TINYCLR_CHECK_HRESULT( decoder->GifInitDecompress( data, size ) ); // At this point decoder would have all the correct output dimension info, so we initialized the CLR_GFX_BitmapDescription // with that information, note that we currently only support decompression into the native bpp if(bm.BitmapDescription_Initialize( decoder->header.LogicScreenWidth, decoder->header.LogicScreenHeight, CLR_GFX_BitmapDescription::c_NativeBpp ) == false) { // if the resulting bitmap doesn't match our constraints, stop the decompression TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_PARAMETER); } // Allocate the memory that the decompressed bitmap would need TINYCLR_CHECK_HRESULT(CLR_GFX_Bitmap::CreateInstance( ref, bm )); TINYCLR_CHECK_HRESULT(CLR_GFX_Bitmap::GetInstanceFromHeapBlock (ref, bitmap)); TINYCLR_CHECK_HRESULT(decoder->GifStartDecompress( bitmap )); TINYCLR_CLEANUP(); if (decoder) CLR_RT_Memory::Release( decoder ); TINYCLR_CLEANUP_END(); }
HRESULT CLR_RT_XmlState_InXmlDeclaration::Process( CLR_RT_XmlState* st ) { TINYCLR_HEADER(); CLR_RT_XmlState_InXmlDeclaration* state = &st->InXmlDeclaration; CLR_UINT8* buffer = state->buffer; CLR_UINT8* bufferEnd = state->bufferEnd; while(c_XmlCharType[ *buffer ] & XmlCharType_Space) { if(++buffer == bufferEnd) TINYCLR_SET_AND_LEAVE(XML_E_NEED_MORE_DATA); } if(*buffer == '?') { if((bufferEnd - buffer) >= 2) { if(buffer[ 1 ] == '>') { buffer += 2; CLR_RT_HeapBlock_XmlReader* reader = state->reader; CLR_RT_HeapBlock_ArrayList* attributes = reader->GetAttributes(); CLR_UINT32 attributeCount = attributes->GetSize(); CLR_RT_HeapBlock_String* empty = CLR_RT_HeapBlock_String::GetStringEmpty(); if(attributeCount == 0) { TINYCLR_SET_AND_LEAVE(XML_E_INVALID_XML_DECL); } // Verify version, encoding & standalone attributes CLR_UINT32 xmlDeclState = 0; // <?xml (0) version='1.0' (1) encoding='__' (2) standalone='__' (3) ?> CLR_UINT32 i = 0; do { CLR_RT_HeapBlock_XmlAttribute* attribute; LPCSTR name; LPCSTR value; attributes->GetItem( i++, (CLR_RT_HeapBlock*&)attribute ); name = attribute->GetName()->StringText(); value = attribute->GetValue()->StringText(); if((xmlDeclState == 0) && (hal_strncmp_s( name, "version", 8 ) == 0) && (hal_strncmp_s( value, "1.0", 4 ) == 0)) { xmlDeclState = 1; } else if((xmlDeclState == 1) && (hal_strncmp_s( name, "encoding", 9 ) == 0) && (hal_stricmp( value, "utf-8" ) == 0)) { xmlDeclState = 2; } else if((xmlDeclState == 1 || xmlDeclState == 2) && (hal_strncmp_s( name, "standalone", 11 ) == 0) && (hal_strncmp_s( value, "no", 3 ) == 0 || hal_strncmp_s( value, "yes", 4 ) == 0)) { xmlDeclState = 3; } else { TINYCLR_SET_AND_LEAVE(XML_E_INVALID_XML_DECL); } attribute->SetNamespaceURI( empty ); } while(--attributeCount != 0); state->docState = XmlDocState_DoneWithXmlDeclaration; reader->SetNodeType( XmlNodeType_XmlDeclaration ); CLR_RT_XmlState_BetweenElements::Setup( (CLR_RT_XmlState*)state, true ); TINYCLR_SET_AND_LEAVE(XML_S_RETURN_TO_MANAGED_CODE); } else { TINYCLR_SET_AND_LEAVE(XML_E_INVALID_XML_DECL); } } else { TINYCLR_SET_AND_LEAVE(XML_E_NEED_MORE_DATA); } } else // start of "attribute" { CLR_RT_XmlState_InName::Setup( st, buffer, XmlnameType_XmlDeclAttribute ); } TINYCLR_CLEANUP(); state->buffer = buffer; TINYCLR_CLEANUP_END(); }
HRESULT Library_spot_net_native_Microsoft_SPOT_Net_SocketNative::getaddrinfo___STATIC__VOID__STRING__BYREF_STRING__BYREF_SZARRAY_SZARRAY_U1( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_NETWORK(); TINYCLR_HEADER(); LPCSTR szName = stack.Arg0().RecoverString(); struct SOCK_addrinfo hints; struct SOCK_addrinfo* addr = NULL; struct SOCK_addrinfo* addrT; CLR_UINT32 cAddresses = 0; CLR_RT_HeapBlock* pAddress; CLR_INT32 timeout_ms = 30000; CLR_RT_HeapBlock hbTimeout; CLR_INT32 ret; bool fRes = true; CLR_INT64* timeout; hbTimeout.SetInteger( timeout_ms ); TINYCLR_CHECK_HRESULT(stack.SetupTimeout( hbTimeout, timeout )); do { memset( &hints, 0, sizeof(hints) ); ret = SOCK_getaddrinfo( szName, NULL, &hints, &addr ); if(ret == SOCK_SOCKET_ERROR) { if(SOCK_getlasterror() == SOCK_EWOULDBLOCK) { // non-blocking - allow other threads to run while we wait for handle activity TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.WaitEvents( stack.m_owningThread, *timeout, CLR_RT_ExecutionEngine::c_Event_Socket, fRes )); } else { break; } } else { break; } } while(fRes); // timeout expired if(!fRes) { ret = SOCK_SOCKET_ERROR; ThrowError( stack, SOCK_ETIMEDOUT ); TINYCLR_SET_AND_LEAVE( CLR_E_PROCESS_EXCEPTION ); } // getaddrinfo returns a winsock error code rather than SOCK_SOCKET_ERROR, so pass this on to the exception handling if(ret != 0) { ThrowError( stack, ret ); TINYCLR_SET_AND_LEAVE(CLR_E_PROCESS_EXCEPTION); } { CLR_RT_HeapBlock hbCanonicalName; CLR_RT_HeapBlock hbAddresses; hbCanonicalName.SetObjectReference( NULL ); CLR_RT_ProtectFromGC gc( hbCanonicalName ); hbAddresses.SetObjectReference( NULL ); CLR_RT_ProtectFromGC gc2( hbAddresses ); for(int pass = 0; pass < 2; pass++) { cAddresses = 0; for(addrT = addr; addrT != NULL; addrT = addrT->ai_next) { if(pass == 1) { if(addrT->ai_canonname && addrT->ai_canonname[ 0 ]) { //allocate return string TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_String::CreateInstance( hbCanonicalName, addrT->ai_canonname )); TINYCLR_CHECK_HRESULT(hbCanonicalName.StoreToReference( stack.Arg1(), 0 )); } //allocate address and store into array pAddress = (CLR_RT_HeapBlock*)hbAddresses.DereferenceArray()->GetElement( cAddresses ); TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_Array::CreateInstance( *pAddress, (CLR_UINT32)addrT->ai_addrlen, g_CLR_RT_WellKnownTypes.m_UInt8 )); //copy address. memcpy( pAddress->DereferenceArray()->GetFirstElement(), addrT->ai_addr, addrT->ai_addrlen ); } cAddresses++; } if(pass == 0) { //allocate array of byte arrays CLR_RT_ReflectionDef_Index idx; idx.m_kind = REFLECTION_TYPE; idx.m_levels = 2; idx.m_data.m_type.m_data = g_CLR_RT_WellKnownTypes.m_UInt8.m_data; TINYCLR_CHECK_HRESULT(CLR_RT_HeapBlock_Array::CreateInstance( hbAddresses, cAddresses, idx )); TINYCLR_CHECK_HRESULT(hbAddresses.StoreToReference( stack.Arg2(), 0 )); } } } stack.PopValue(); // Timeout TINYCLR_CLEANUP(); if( addr ) SOCK_freeaddrinfo( addr ); TINYCLR_CLEANUP_END(); }
HRESULT CLR_RT_ExecutionEngine::Compile( const CLR_RT_MethodDef_Index& md, CLR_UINT32 flags ) { TINYCLR_HEADER(); MethodCompiler mc; #if !defined(BUILD_RTM) CLR_UINT64 stats_start; #endif #if defined(PLATFORM_WINDOWS) g_CLR_RT_ArmEmulator.InitializeExternalCalls(); #endif //////////////////////////////////////////////////////////////////////////// // // Create thunk table. // if(g_thunkTable.m_address__Internal_Initialize == 0) { TINYCLR_CHECK_HRESULT(mc.Initialize( NULL, (CLR_UINT32)(size_t)m_jitter_current )); TINYCLR_CHECK_HRESULT(mc.CreateThunks( &g_thunkTable )); if(s_CLR_RT_fJitter_Enabled) { size_t len = mc.m_Arm_Opcodes.Size() * sizeof(CLR_UINT32); FLASH_WORD* src = (FLASH_WORD*)&mc.m_Arm_Opcodes[ 0 ]; FLASH_WORD* dst = m_jitter_current; FLASH_WORD* end = CLR_RT_Persistence_Manager::Bank::IncrementPointer( dst, (CLR_UINT32)len ); //--// CODECOVERAGE_REGISTERTHUNK(Internal_Initialize ); CODECOVERAGE_REGISTERTHUNK(Internal_Restart ); CODECOVERAGE_REGISTERTHUNK(Internal_Error ); CODECOVERAGE_REGISTERTHUNK(Internal_ErrorNoFlush ); CODECOVERAGE_REGISTERTHUNK(Internal_ReturnFromMethod ); CODECOVERAGE_REGISTERTHUNK(CLR_RT_HeapBlock__Compare_Values ); CODECOVERAGE_REGISTERTHUNK(CLR_RT_HeapBlock__NumericMul ); CODECOVERAGE_REGISTERTHUNK(CLR_RT_HeapBlock__NumericDiv ); CODECOVERAGE_REGISTERTHUNK(CLR_RT_HeapBlock__NumericDivUn ); CODECOVERAGE_REGISTERTHUNK(CLR_RT_HeapBlock__NumericRem ); CODECOVERAGE_REGISTERTHUNK(CLR_RT_HeapBlock__NumericRemUn ); CODECOVERAGE_REGISTERTHUNK(CLR_RT_HeapBlock__NumericShl ); CODECOVERAGE_REGISTERTHUNK(CLR_RT_HeapBlock__NumericShr ); CODECOVERAGE_REGISTERTHUNK(CLR_RT_HeapBlock__NumericShrUn ); CODECOVERAGE_REGISTERTHUNK(CLR_RT_HeapBlock__InitObject ); CODECOVERAGE_REGISTERTHUNK(CLR_RT_HeapBlock__Convert ); CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__HandleBoxing ); CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__HandleIsInst ); CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__HandleCasting ); CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__CopyValueType ); CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__CloneValueType ); CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__LoadFunction ); CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__LoadString ); CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__NewArray ); CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__Call ); CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__CallVirtual ); CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__NewObject ); CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__NewDelegate ); CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__AccessStaticField); CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__Throw ); CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__Rethrow ); CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__Leave ); CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__EndFinally ); CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__LoadIndirect ); CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__StoreIndirect ); CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__LoadObject ); CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__CopyObject ); CODECOVERAGE_REGISTERTHUNK(MethodCompilerHelpers__StoreObject ); //--// if(end < m_jitter_end) { ::Flash_ChipReadOnly( FALSE ); while(dst < end) { ::Flash_WriteToSector( Flash_FindSector(dst), dst++, sizeof(FLASH_WORD), (byte *)src ); src ++; } ::Flash_ChipReadOnly( TRUE ); if(memcmp( m_jitter_current, &mc.m_Arm_Opcodes[ 0 ], len ) == 0) { m_jitter_current = dst; } else { CLR_Debug::Printf( "Jitter: failed to write thunk table!\r\n" ); } } else { CLR_Debug::Printf( "Jitter: no space for thunk table!\r\n" ); } } #if defined(PLATFORM_WINDOWS) else { size_t len = mc.m_Arm_Opcodes.Size() * sizeof(CLR_UINT32); m_jitter_current = CLR_RT_Persistence_Manager::Bank::IncrementPointer( m_jitter_current, (CLR_UINT32)len ); } #endif mc.Release(); } //////////////////////////////////////////////////////////////////////////// #if !defined(BUILD_RTM) if(s_CLR_RT_fJitter_Trace_Compile >= c_CLR_RT_Trace_Info) { CLR_Debug::Printf( "\r\n\r\nJitting " ); CLR_RT_DUMP::METHOD( md ); CLR_Debug::Printf( "\r\n" ); stats_start = Time_CurrentTicks(); } #endif TINYCLR_CHECK_HRESULT(mc.Initialize( &md, (CLR_UINT32)(size_t)m_jitter_current )); mc.ReferToThunks( &g_thunkTable ); //////////////////////////////////////////////////////////////////////////// if(mc.m_mdInst.m_target->RVA == CLR_EmptyIndex) { // // Native implementation. Nothing to do. // } else { TINYCLR_CHECK_HRESULT(mc.ParseArguments()); TINYCLR_CHECK_HRESULT(mc.ParseLocals ()); TINYCLR_CHECK_HRESULT(mc.ParseByteCode ()); TINYCLR_CHECK_HRESULT(mc.ParseEvalStack()); TINYCLR_CHECK_HRESULT(mc.GenerateCode()); #if !defined(BUILD_RTM) if(s_CLR_RT_fJitter_Trace_Compile >= c_CLR_RT_Trace_Verbose) { int milliSec = ((int)::Time_TicksToTime( Time_CurrentTicks() - stats_start ) + CLR_RT_Time::c_TickUnits - 1) / CLR_RT_Time::c_TickUnits; CLR_Debug::Printf( "Compile time: %dmsec\r\n", milliSec ); } #endif if(s_CLR_RT_fJitter_Enabled) { CLR_RT_Assembly* assm = mc.m_mdInst.m_assm; if(assm->m_jittedCode == NULL) { CLR_UINT32 size = assm->m_pTablesSize[ TBL_MethodDef ] * sizeof(CLR_RT_MethodHandler); assm->m_jittedCode = (CLR_RT_MethodHandler*)CLR_RT_Memory::Allocate_And_Erase( size ); } if(assm->m_jittedCode) { size_t len = mc.m_Arm_Opcodes.Size() * sizeof(CLR_UINT32); FLASH_WORD* src = (FLASH_WORD*)&mc.m_Arm_Opcodes[ 0 ]; FLASH_WORD* dst = m_jitter_current; FLASH_WORD* end = CLR_RT_Persistence_Manager::Bank::IncrementPointer( dst, (CLR_UINT32)len ); CodeCoverage::Register( dst, md ); if(end < m_jitter_end) { ::Flash_ChipReadOnly( FALSE ); while(dst < end) { Flash_WriteToSector( Flash_FindSector(dst), dst++, sizeof(FLASH_WORD),(byte *) src ); src ++; } ::Flash_ChipReadOnly( TRUE ); if(memcmp( m_jitter_current, &mc.m_Arm_Opcodes[ 0 ], len ) == 0) { assm->m_jittedCode[ mc.m_mdInst.Method() ] = (CLR_RT_MethodHandler)m_jitter_current; m_jitter_current = dst; } else { CLR_Debug::Printf( "Jitter: failed to write method!\r\n" ); } } else { CLR_Debug::Printf( "Jitter: no space for method!\r\n" ); } } else { CLR_Debug::Printf( "Jitter: cannot allocate method table!\r\n" ); } } #if defined(PLATFORM_WINDOWS) else { size_t len = mc.m_Arm_Opcodes.Size() * sizeof(CLR_UINT32); m_jitter_current = CLR_RT_Persistence_Manager::Bank::IncrementPointer( m_jitter_current, (CLR_UINT32)len ); } #endif } //////////////////////////////////////////////////////////////////////////// TINYCLR_CLEANUP(); mc.Release(); TINYCLR_CLEANUP_END(); }
HRESULT CLR_RT_XmlState_InStartElement::Process( CLR_RT_XmlState* st ) { TINYCLR_HEADER(); CLR_RT_XmlState_InStartElement* state = &st->InStartElement; CLR_UINT8* buffer = state->buffer; CLR_UINT8* bufferEnd = state->bufferEnd; CLR_UINT8 c; while(c_XmlCharType[ *buffer ] & XmlCharType_Space) { if(++buffer == bufferEnd) TINYCLR_SET_AND_LEAVE(XML_E_NEED_MORE_DATA); } c = *buffer; if(c == '>') { buffer++; TINYCLR_SET_AND_LEAVE(PrepReturn( state, false )); } else if(c == '/') { if((bufferEnd - buffer) >= 2) { if(*(buffer + 1) == '>') { buffer += 2; CLR_RT_HeapBlock_XmlReader* reader = state->reader; if(reader->GetXmlNodes()->GetSize() == 1) { reader->SetIsDone( true ); state->docState = XmlDocState_DoneWithMainDocument; } TINYCLR_SET_AND_LEAVE(PrepReturn( state, true )); } else { TINYCLR_SET_AND_LEAVE(XML_E_UNEXPECTED_TOKEN); } } else { TINYCLR_SET_AND_LEAVE(XML_E_NEED_MORE_DATA); } } else // start of attribute { CLR_RT_XmlState_InName::Setup( st, buffer, XmlNameType_Attribute ); } TINYCLR_CLEANUP(); state->buffer = buffer; TINYCLR_CLEANUP_END(); }
HRESULT CLR_RT_XmlState_InValue::Process( CLR_RT_XmlState* st ) { TINYCLR_HEADER(); CLR_RT_XmlState_InValue* state = &st->InValue; CLR_UINT8* buffer = state->buffer; CLR_UINT8* bufferEnd = state->bufferEnd; CLR_UINT8* value = state->value; bool processOnly = state->processOnly; CLR_UINT16 normalCharType = state->normalCharType; CLR_UINT8 endValueChar = state->endValueChar; while(true) { while(c_XmlCharType[ *buffer ] & normalCharType) { if(++buffer == bufferEnd) TINYCLR_SET_AND_LEAVE(XML_E_NEED_MORE_DATA); } if(*buffer == '\r') { if(bufferEnd - buffer >= 2) { if(buffer[ 1 ] == '\n') { if(!processOnly) { state->shiftHelper.SetNextCarRet( buffer - value, (CLR_UINT8*)buffer ); } buffer += 2; } else { *((LPSTR)buffer) = '\n'; buffer++; continue; } } else { TINYCLR_SET_AND_LEAVE(XML_E_NEED_MORE_DATA); } } else if(*buffer == endValueChar) { bool isDone = true; hr = state->endFn( st, buffer, isDone ); if(isDone) TINYCLR_LEAVE(); } else if(*buffer == '&') { CLR_INT32 count = CLR_RT_XmlCharRef::ParseCharRef( (LPSTR)buffer, bufferEnd - buffer, buffer - state->value, &state->shiftHelper ); if(count > 0) { buffer += count; } else { TINYCLR_SET_AND_LEAVE((count == 0) ? XML_E_NEED_MORE_DATA : XML_E_BAD_OR_UNSUPPORTED_ENTITY); } } else { bool isDone = true; hr = state->othersFn( st, buffer, isDone ); if(isDone) TINYCLR_LEAVE(); } if(buffer == bufferEnd) TINYCLR_SET_AND_LEAVE(XML_E_NEED_MORE_DATA); } TINYCLR_CLEANUP(); state->buffer = buffer; TINYCLR_CLEANUP_END(); }
HRESULT Library_corlib_native_System_AppDomain::LoadInternal___SystemReflectionAssembly__STRING__BOOLEAN__I4__I4__I4__I4( CLR_RT_StackFrame& stack ) { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); CLR_RT_HeapBlock* pArgs = &(stack.Arg1()); CLR_RT_AppDomain* appDomainSav; CLR_RT_AppDomain* appDomain; CLR_RT_Assembly* assembly; CLR_RT_Assembly_Index idx; bool fVersion; CLR_INT16 maj, min, build, rev; LPCSTR szAssembly; TINYCLR_CHECK_HRESULT(GetAppDomain( stack.ThisRef(), appDomain, appDomainSav, true )); szAssembly = pArgs[ 0 ].RecoverString(); FAULT_ON_NULL(szAssembly); fVersion = pArgs[ 1 ].NumericByRef().u8 != 0; maj = pArgs[ 2 ].NumericByRef().s4; min = pArgs[ 3 ].NumericByRef().s4; build = pArgs[ 4 ].NumericByRef().s4; rev = pArgs[ 5 ].NumericByRef().s4; if(fVersion && (maj == -1 || min == -1 || build == -1 || rev == -1)) { TINYCLR_SET_AND_LEAVE(CLR_E_INVALID_PARAMETER); } if(fVersion) { CLR_RECORD_VERSION ver; ver.iMajorVersion = (CLR_UINT16) maj; ver.iMinorVersion = (CLR_UINT16) min; ver.iBuildNumber = (CLR_UINT16) build; ver.iRevisionNumber = (CLR_UINT16) rev; assembly = g_CLR_RT_TypeSystem.FindAssembly( szAssembly, &ver, true ); FAULT_ON_NULL_HR(assembly, CLR_E_INVALID_PARAMETER); } else { assembly = g_CLR_RT_TypeSystem.FindAssembly( szAssembly, NULL, false ); FAULT_ON_NULL_HR(assembly, CLR_E_INVALID_PARAMETER); } TINYCLR_CHECK_HRESULT(appDomain->LoadAssembly( assembly )); { CLR_RT_HeapBlock& top = stack.PushValue(); CLR_RT_HeapBlock* hbObj; idx.Set( assembly->m_idx ); TINYCLR_CHECK_HRESULT(g_CLR_RT_ExecutionEngine.NewObjectFromIndex(top, g_CLR_RT_WellKnownTypes.m_Assembly)); hbObj = top.Dereference(); hbObj->SetReflection( idx ); } TINYCLR_CLEANUP(); g_CLR_RT_ExecutionEngine.SetCurrentAppDomain( appDomainSav ); TINYCLR_CLEANUP_END(); }
HRESULT CLR_RT_StackFrame::PopAppDomainTransition() { NATIVE_PROFILE_CLR_CORE(); TINYCLR_HEADER(); bool fException = false; CLR_RT_HeapBlock exception; CLR_RT_StackFrame* caller = this->Caller(); exception.SetObjectReference( NULL ); if(m_flags & CLR_RT_StackFrame::c_AppDomainInjectException) { //this is the last frame on the thread in a doomed AppDomain //Convert the current ThreadAbortException into an AppDomainUnloaded exception _ASSERTE(m_owningThread->m_flags & CLR_RT_Thread::TH_F_Aborted); _ASSERTE(m_owningThread->m_flags & CLR_RT_Thread::TH_F_ContainsDoomedAppDomain); _ASSERTE(m_owningThread->m_currentException.Dereference() != NULL); _ASSERTE(m_owningThread->m_currentException.Dereference()->ObjectCls().m_data == g_CLR_RT_WellKnownTypes.m_ThreadAbortException.m_data); _ASSERTE(!m_appDomain->IsLoaded()); m_owningThread->m_flags &= ~(CLR_RT_Thread::TH_F_Aborted | CLR_RT_Thread::TH_F_ContainsDoomedAppDomain); hr = CLR_E_APPDOMAIN_EXITED; } else if(m_owningThread->m_currentException.Dereference() == NULL) { _ASSERTE((m_flags & CLR_RT_StackFrame::c_AppDomainInjectException) == 0); //Normal return. No exception is in flight if(m_flags & CLR_RT_StackFrame::c_AppDomainMethodInvoke) { // For dynamic invoke, // we do not marshal byRef parameters back to the calling AppDomain // The caller is a native method (MethodBase::Invoke), and does not have the args on it's eval stack. } else { int cArgs = m_call.m_target->numArgs; //First marshal the ref parameters TINYCLR_CHECK_HRESULT(caller->m_appDomain->MarshalParameters( &caller->m_evalStackPos[ -cArgs ], m_arguments, cArgs, true )); //Now, pop the caller's arguments off the eval stack caller->m_evalStackPos -= cArgs; } // Now, push the return, if any. if(m_call.m_target->retVal != DATATYPE_VOID) { CLR_RT_HeapBlock& dst = caller->PushValueAndClear(); CLR_RT_HeapBlock& src = this ->TopValue (); TINYCLR_CHECK_HRESULT(caller->m_appDomain->MarshalObject( src, dst )); dst.Promote(); } } else //Exception { //Normal exceptions must be marshaled to the caller's AppDomain TINYCLR_CHECK_HRESULT(caller->m_appDomain->MarshalObject( m_owningThread->m_currentException, exception )); fException = true; } TINYCLR_CLEANUP(); if(FAILED(hr) || fException) { if(FAILED(hr)) { (void)Library_corlib_native_System_Exception::CreateInstance( exception, hr, caller ); } m_owningThread->m_currentException.Assign( exception ); } (void)g_CLR_RT_ExecutionEngine.SetCurrentAppDomain( caller->m_appDomain ); TINYCLR_CLEANUP_END(); }
HRESULT Library_spot_net_security_native_Microsoft_SPOT_Net_Security_SslNative::InitHelper( CLR_RT_StackFrame& stack, bool isServer ) { NATIVE_PROFILE_CLR_NETWORK(); TINYCLR_HEADER(); CLR_INT32 sslContext = -1; CLR_INT32 sslMode = stack.Arg0().NumericByRef().s4; CLR_INT32 sslVerify = stack.Arg1().NumericByRef().s4; CLR_RT_HeapBlock *hbCert = stack.Arg2().Dereference(); CLR_RT_HeapBlock_Array* arrCA = stack.Arg3().DereferenceArray(); CLR_RT_HeapBlock_Array* arrCert = NULL; CLR_UINT8* sslCert = NULL; int result; int i; bool isFirstCall = false; LPCSTR szPwd = ""; if(!g_SSL_SeedData.Initialized) { BOOL fOK = FALSE; isFirstCall = true; #if !defined(_WIN32) && !defined(WIN32) && !defined(_WIN32_WCE) int i; if(!HAL_CONFIG_BLOCK::ApplyConfig( g_SSL_SeedData.Config.GetDriverName(), &g_SSL_SeedData.Config, sizeof(g_SSL_SeedData.Config) )) { return CLR_E_NOT_SUPPORTED; } // validate the security key (make sure it isn't all 0x00 or all 0xFF for(i=1; i<sizeof(g_SSL_SeedData.Config.SslSeedKey) && !fOK; i++) { if( g_SSL_SeedData.Config.SslSeedKey[ i ] != 0 && g_SSL_SeedData.Config.SslSeedKey[ i ] != 0xFF && g_SSL_SeedData.Config.SslSeedKey[ i-1 ] != g_SSL_SeedData.Config.SslSeedKey[ i ]) { fOK = TRUE; } } if(!fOK) { return CLR_E_NOT_SUPPORTED; } #endif g_SSL_SeedData.m_completion.Initialize(); g_SSL_SeedData.m_completion.InitializeForUserMode( UpdateSslSeedValue, NULL ); g_SSL_SeedData.Initialized = TRUE; } if(hbCert != NULL) { arrCert = hbCert[ Library_spot_native_System_Security_Cryptography_X509Certificates_X509Certificate::FIELD__m_certificate ].DereferenceArray(); //FAULT_ON_NULL(arrCert); // If arrCert == NULL then the certificate is an X509Certificate2 which uses a certificate handle if(arrCert == NULL) { arrCert = hbCert[ Library_spot_native_System_Security_Cryptography_X509Certificates_X509Certificate::FIELD__m_handle ].DereferenceArray(); FAULT_ON_NULL(arrCert); // pass the certificate handle as the cert data parameter sslCert = arrCert->GetFirstElement(); arrCert = hbCert[ Library_spot_native_System_Security_Cryptography_X509Certificates_X509Certificate::FIELD__m_sessionHandle ].DereferenceArray(); FAULT_ON_NULL(arrCert); // pass the session handle as the ssl context parameter sslContext = *(INT32*)arrCert->GetFirstElement(); // the certificate has already been loaded so just pass an empty string szPwd = ""; } else { arrCert->Pin(); sslCert = arrCert->GetFirstElement(); CLR_RT_HeapBlock *hbPwd = hbCert[ Library_spot_native_System_Security_Cryptography_X509Certificates_X509Certificate::FIELD__m_password ].Dereference();// FAULT_ON_NULL(hbPwd); szPwd = hbPwd->StringText(); } } SSL_RegisterTimeCallback( Time_GetDateTime ); if(isServer) { result = (SSL_ServerInit( sslMode, sslVerify, (const char*)sslCert, sslCert == NULL ? 0 : arrCert->m_numOfElements, szPwd, sslContext ) ? 0 : -1); } else { result = (SSL_ClientInit( sslMode, sslVerify, (const char*)sslCert, sslCert == NULL ? 0 : arrCert->m_numOfElements, szPwd, sslContext ) ? 0 : -1); } TINYCLR_CHECK_HRESULT(ThrowOnError( stack, result )); if(isFirstCall) { GenerateNewSslSeed(); } if(arrCA != NULL) { for(i=0; i<(int)arrCA->m_numOfElements; i++) { hbCert = (CLR_RT_HeapBlock*)arrCA->GetElement( i ); FAULT_ON_NULL(hbCert); hbCert = hbCert->Dereference(); FAULT_ON_NULL(hbCert); arrCert = hbCert[ Library_spot_native_System_Security_Cryptography_X509Certificates_X509Certificate::FIELD__m_certificate ].DereferenceArray(); //FAULT_ON_NULL(arrCert); // If arrCert == NULL then the certificate is an X509Certificate2 which uses a certificate handle if(arrCert == NULL) { CLR_INT32 sessionCtx = 0; arrCert = hbCert[ Library_spot_native_System_Security_Cryptography_X509Certificates_X509Certificate::FIELD__m_handle ].DereferenceArray(); FAULT_ON_NULL(arrCert); sslCert = arrCert->GetFirstElement(); arrCert = hbCert[ Library_spot_native_System_Security_Cryptography_X509Certificates_X509Certificate::FIELD__m_sessionHandle ].DereferenceArray(); FAULT_ON_NULL(arrCert); sessionCtx = *(INT32*)arrCert->GetFirstElement(); // pass the session handle down as the password paramter and the certificate handle as the data parameter result = (SSL_AddCertificateAuthority( sslContext, (const char*)sslCert, arrCert->m_numOfElements, (LPCSTR)&sessionCtx ) ? 0 : -1); TINYCLR_CHECK_HRESULT(ThrowOnError( stack, result )); } else { arrCert->Pin(); sslCert = arrCert->GetFirstElement(); CLR_RT_HeapBlock *hbPwd = hbCert[ Library_spot_native_System_Security_Cryptography_X509Certificates_X509Certificate::FIELD__m_password ].Dereference(); FAULT_ON_NULL(hbPwd); LPCSTR szCAPwd = hbPwd->StringText(); result = (SSL_AddCertificateAuthority( sslContext, (const char*)sslCert, arrCert->m_numOfElements, szCAPwd ) ? 0 : -1); TINYCLR_CHECK_HRESULT(ThrowOnError( stack, result )); } } } stack.SetResult_I4( sslContext ); TINYCLR_CLEANUP(); if(FAILED(hr) && (sslContext != -1)) { SSL_ExitContext( sslContext ); } TINYCLR_CLEANUP_END(); }
HRESULT CLR_GFX_Bitmap::CreateInstanceJpeg( CLR_RT_HeapBlock& ref, const CLR_UINT8* data, const CLR_UINT32 size ) { NATIVE_PROFILE_CLR_GRAPHICS(); TINYCLR_HEADER(); jpeg_decompress_struct cinfo; CLR_GFX_Bitmap* bitmap = NULL; CreateInstanceJpegHelperParam param; GFX_Rect rect; param.curBuffer = NULL; // Set up the error handling JPEGErrorManager errorManager; cinfo.err = jpeg_std_error( &errorManager.pub ); errorManager.pub.error_exit = JPEGErrorHandler; #if 0 if(setjmp( (long long *)errorManager.setjmpBuffer )) #else if(setjmp(errorManager.setjmpBuffer )) #endif { if (cinfo.err->msg_code == JERR_OUT_OF_MEMORY) { TINYCLR_SET_AND_LEAVE( CLR_E_OUT_OF_MEMORY ); } else { TINYCLR_SET_AND_LEAVE( CLR_E_FAIL ); } } // Create the decompression engine jpeg_create_decompress( &cinfo ); jpeg_byte_array_src ( &cinfo, (UINT8*)data, size ); jpeg_read_header ( &cinfo, TRUE ); // Set output to 16bit 5-6-5 RGB format // We can add support for other bit-depth in the future cinfo.out_color_space = JCS_RGB; cinfo.do_fancy_upsampling = FALSE; jpeg_start_decompress( &cinfo ); // At this point cinfo would have all the correct output dimension info CLR_GFX_BitmapDescription bm; if(bm.BitmapDescription_Initialize( cinfo.output_width, cinfo.output_height, CLR_GFX_BitmapDescription::c_NativeBpp ) == false) { // if the resulting bitmap doesn't match our constraints, stop the decompression TINYCLR_SET_AND_LEAVE( CLR_E_INVALID_PARAMETER ); } // Allocate the memory that the decompressed bitmap would need TINYCLR_CHECK_HRESULT(CLR_GFX_Bitmap::CreateInstance( ref, bm )); TINYCLR_CHECK_HRESULT(CLR_GFX_Bitmap::GetInstanceFromHeapBlock (ref, bitmap)); // Do the actual decompression rect.left = 0; rect.top = 0; rect.right = cinfo.output_width - 1; rect.bottom = cinfo.output_height - 1; param.curBuffer = (CLR_UINT8*)CLR_RT_Memory::Allocate( cinfo.output_width * 3 ); CHECK_ALLOCATION(param.curBuffer); param.buffer = (JSAMPARRAY)&(param.curBuffer); param.cinfo = &cinfo; bitmap->SetPixelsHelper( rect, PAL_GFX_Bitmap::c_SetPixelsConfig_NoClip | PAL_GFX_Bitmap::c_SetPixelsConfig_NoClipChecks, &CreateInstanceJpegHelper, ¶m ); TINYCLR_CLEANUP(); if (param.curBuffer) CLR_RT_Memory::Release( param.curBuffer ); jpeg_destroy_decompress( &cinfo ); TINYCLR_CLEANUP_END(); }
HRESULT Cmd_ConvertFont( CLR_RT_ParseOptions::ParameterList* params = NULL ) { TINYCLR_HEADER(); LPCWSTR szFileIn = PARAM_EXTRACT_STRING(params, 0); LPCWSTR szFileOut = PARAM_EXTRACT_STRING(params, 1); CLR_GFX_FontBuilder fb; CLR_GFX_Font* font = NULL; CLR_RT_Buffer buf; CLR_RT_Buffer bufT; CLR_UINT8* ptr; CLR_UINT32 size; TinyResourcesFileHeader fileHeader; TinyResourcesResourceHeader resource; TINYCLR_CHECK_HRESULT(fb.Initialize()); buf.clear(); TINYCLR_CHECK_HRESULT(CLR_RT_FileStore::LoadFile( szFileIn, buf )); #if FNT_SUPPORT if(StringEndsWithSuffix( szFileIn, L".fntdef" )) { TINYCLR_CHECK_HRESULT(fb.LoadFromScript( buf )); } else { TINYCLR_CHECK_HRESULT(fb.LoadFromFNT( buf, 0, 255, 0 )); } #else TINYCLR_CHECK_HRESULT(fb.LoadFromScript( buf )); #endif TINYCLR_CHECK_HRESULT(fb.GenerateFont( font )); TINYCLR_CHECK_HRESULT(font->SaveToBuffer( bufT )); /*.tinyresources format */ fileHeader.magicNumber = TinyResourcesFileHeader::MAGIC_NUMBER; fileHeader.version = CLR_RECORD_RESOURCE_FILE::CURRENT_VERSION; fileHeader.sizeOfHeader = sizeof(fileHeader); fileHeader.sizeOfResourceHeader = sizeof(resource); fileHeader.numberOfResources = 1; resource.id = 0; resource.kind = CLR_RECORD_RESOURCE::RESOURCE_Font; resource.pad = 0; resource.size = (CLR_UINT32)bufT.size(); buf.clear(); size = fileHeader.sizeOfHeader; size += fileHeader.numberOfResources*fileHeader.sizeOfResourceHeader; size += (CLR_UINT32)bufT.size(); buf.resize(size); ptr = &buf[ 0 ]; //write file header memcpy(ptr, &fileHeader, fileHeader.sizeOfHeader ); ptr += fileHeader.sizeOfHeader; //write resource header memcpy(ptr, &resource , fileHeader.sizeOfResourceHeader); ptr += fileHeader.sizeOfResourceHeader; //write resource data memcpy(ptr, &bufT[0] , bufT.size() ); ptr += bufT.size(); TINYCLR_CHECK_HRESULT(CLR_RT_FileStore::SaveFile( szFileOut, buf )); TINYCLR_CLEANUP(); if(font) { free(font); } TINYCLR_CLEANUP_END(); }
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(); }