Permalink
Fetching contributors…
Cannot retrieve contributors at this time
413 lines (315 sloc) 12.4 KB
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
// FCALL.CPP
//
//
#include "common.h"
#include "vars.hpp"
#include "fcall.h"
#include "excep.h"
#include "frames.h"
#include "gms.h"
#include "ecall.h"
#include "eeconfig.h"
NOINLINE LPVOID __FCThrow(LPVOID __me, RuntimeExceptionKind reKind, UINT resID, LPCWSTR arg1, LPCWSTR arg2, LPCWSTR arg3)
{
STATIC_CONTRACT_THROWS;
// This isn't strictly true... But the guarentee that we make here is
// that we won't trigger without having setup a frame.
// STATIC_CONTRACT_TRIGGER
STATIC_CONTRACT_GC_NOTRIGGER;
STATIC_CONTRACT_SO_TOLERANT; // function probes before it does any work
// side effect the compiler can't remove
if (FC_NO_TAILCALL != 1)
return (LPVOID)(SIZE_T)(FC_NO_TAILCALL + 1);
FC_CAN_TRIGGER_GC();
INCONTRACT(FCallCheck __fCallCheck(__FILE__, __LINE__));
FC_GC_POLL_NOT_NEEDED();
HELPER_METHOD_FRAME_BEGIN_RET_ATTRIB_NOPOLL(Frame::FRAME_ATTR_CAPTURE_DEPTH_2);
// Now, we can construct & throw.
// In V1, throwing an ExecutionEngineException actually never really threw anything... its was the same as a
// fatal error in the runtime, and we will most probably would have ripped the process down. Starting in
// Whidbey, this behavior has changed a lot. Its not really legal to try to throw an
// ExecutionEngineExcpetion with this function.
_ASSERTE((reKind != kExecutionEngineException) ||
!"Don't throw kExecutionEngineException from here. Go to EEPolicy directly, or throw something better.");
if (resID == 0)
{
// If we have an string to add use NonLocalized otherwise just throw the exception.
if (arg1)
COMPlusThrowNonLocalized(reKind, arg1); //COMPlusThrow(reKind,arg1);
else
COMPlusThrow(reKind);
}
else
COMPlusThrow(reKind, resID, arg1, arg2, arg3);
HELPER_METHOD_FRAME_END();
FC_CAN_TRIGGER_GC_END();
_ASSERTE(!"Throw returned");
return NULL;
}
NOINLINE LPVOID __FCThrowArgument(LPVOID __me, RuntimeExceptionKind reKind, LPCWSTR argName, LPCWSTR resourceName)
{
STATIC_CONTRACT_THROWS;
// This isn't strictly true... But the guarentee that we make here is
// that we won't trigger without having setup a frame.
// STATIC_CONTRACT_TRIGGER
STATIC_CONTRACT_GC_NOTRIGGER;
STATIC_CONTRACT_SO_TOLERANT; // function probes before it does any work
// side effect the compiler can't remove
if (FC_NO_TAILCALL != 1)
return (LPVOID)(SIZE_T)(FC_NO_TAILCALL + 1);
FC_CAN_TRIGGER_GC();
INCONTRACT(FCallCheck __fCallCheck(__FILE__, __LINE__));
FC_GC_POLL_NOT_NEEDED(); // throws always open up for GC
HELPER_METHOD_FRAME_BEGIN_RET_ATTRIB_NOPOLL(Frame::FRAME_ATTR_CAPTURE_DEPTH_2);
switch (reKind) {
case kArgumentNullException:
if (resourceName) {
COMPlusThrowArgumentNull(argName, resourceName);
} else {
COMPlusThrowArgumentNull(argName);
}
break;
case kArgumentOutOfRangeException:
COMPlusThrowArgumentOutOfRange(argName, resourceName);
break;
case kArgumentException:
COMPlusThrowArgumentException(argName, resourceName);
break;
default:
// If you see this assert, add a case for your exception kind above.
_ASSERTE(argName == NULL);
COMPlusThrow(reKind, resourceName);
}
HELPER_METHOD_FRAME_END();
FC_CAN_TRIGGER_GC_END();
_ASSERTE(!"Throw returned");
return NULL;
}
/**************************************************************************************/
/* erect a frame in the FCALL and then poll the GC, objToProtect will be protected
during the poll and the updated object returned. */
NOINLINE Object* FC_GCPoll(void* __me, Object* objToProtect)
{
CONTRACTL {
THROWS;
// This isn't strictly true... But the guarentee that we make here is
// that we won't trigger without having setup a frame.
UNCHECKED(GC_NOTRIGGER);
SO_TOLERANT; // function probes before it does any work
} CONTRACTL_END;
FC_CAN_TRIGGER_GC();
INCONTRACT(FCallCheck __fCallCheck(__FILE__, __LINE__));
Thread *thread = GetThread();
if (thread->CatchAtSafePointOpportunistic()) // Does someone want this thread stopped?
{
HELPER_METHOD_FRAME_BEGIN_RET_ATTRIB_1(Frame::FRAME_ATTR_CAPTURE_DEPTH_2, objToProtect);
#ifdef _DEBUG
BOOL GCOnTransition = FALSE;
if (g_pConfig->FastGCStressLevel()) {
GCOnTransition = GC_ON_TRANSITIONS (FALSE);
}
#endif
CommonTripThread();
#ifdef _DEBUG
if (g_pConfig->FastGCStressLevel()) {
GC_ON_TRANSITIONS (GCOnTransition);
}
#endif
HELPER_METHOD_FRAME_END();
}
FC_CAN_TRIGGER_GC_END();
return objToProtect;
}
#ifdef _DEBUG
unsigned FcallTimeHist[11];
#endif
#ifdef ENABLE_CONTRACTS
/**************************************************************************************/
#if defined(_TARGET_X86_) && defined(ENABLE_PERF_COUNTERS)
static __int64 getCycleCount() {
LIMITED_METHOD_CONTRACT;
return GET_CYCLE_COUNT();
}
#else
static __int64 getCycleCount() { LIMITED_METHOD_CONTRACT; return(0); }
#endif
/**************************************************************************************/
// No contract here: The contract destructor restores the thread contract state to what it was
// soon after constructing the contract. This would have the effect of reverting the contract
// state change made by the call to BeginForbidGC.
DEBUG_NOINLINE ForbidGC::ForbidGC(const char *szFile, int lineNum)
{
SCAN_SCOPE_BEGIN;
STATIC_CONTRACT_GC_NOTRIGGER;
STATIC_CONTRACT_MODE_COOPERATIVE;
m_pThread = GetThread();
m_pThread->BeginForbidGC(szFile, lineNum);
}
/**************************************************************************************/
// No contract here: The contract destructor restores the thread contract state to what it was
// soon after constructing the contract. This would have the effect of reverting the contract
// state change made by the call to BeginForbidGC.
DEBUG_NOINLINE ForbidGC::~ForbidGC()
{
SCAN_SCOPE_END;
// IF EH happens, this is still called, in which case
// we should not bother
if (m_pThread->RawGCNoTrigger())
m_pThread->EndNoTriggerGC();
}
/**************************************************************************************/
DEBUG_NOINLINE FCallCheck::FCallCheck(const char *szFile, int lineNum) : ForbidGC(szFile, lineNum)
{
SCAN_SCOPE_BEGIN;
STATIC_CONTRACT_GC_NOTRIGGER;
STATIC_CONTRACT_MODE_COOPERATIVE;
#ifdef _DEBUG
unbreakableLockCount = m_pThread->GetUnbreakableLockCount();
#endif
didGCPoll = false;
notNeeded = false;
startTicks = getCycleCount();
}
/**************************************************************************************/
DEBUG_NOINLINE FCallCheck::~FCallCheck()
{
SCAN_SCOPE_END;
// Confirm that we don't starve the GC or thread-abort.
// Basically every control flow path through an FCALL must
// to a poll. If you hit the assert below, you can fix it by
//
// If you erect a HELPER_METHOD_FRAME, you can
//
// Call HELPER_METHOD_POLL()
// or use HELPER_METHOD_FRAME_END_POLL
//
// If you don't have a helper frame you can used
//
// FC_GC_POLL_AND_RETURN_OBJREF or
// FC_GC_POLL or
// FC_GC_POLL_RET
//
// Note that these must be at GC safe points. In particular
// all object references that are NOT protected will be trashed.
// There is a special poll called FC_GC_POLL_NOT_NEEDED
// which says the code path is short enough that a GC poll is not need
// you should not use this in most cases.
_ASSERTE(unbreakableLockCount == m_pThread->GetUnbreakableLockCount() ||
(!m_pThread->HasUnbreakableLock() && !m_pThread->HasThreadStateNC(Thread::TSNC_OwnsSpinLock)));
if (notNeeded) {
/*<TODO> TODO, we want to actually measure the time to make certain we are not too far off
unsigned delta = unsigned(getCycleCount() - startTicks);
</TODO>*/
}
else if (!didGCPoll) {
// <TODO>TODO turn this on!!! _ASSERTE(!"FCALL without a GC poll in it somewhere!");</TODO>
}
}
#if defined(_TARGET_AMD64_)
FCallTransitionState::FCallTransitionState ()
{
WRAPPER_NO_CONTRACT;
m_pThread = GetThread();
_ASSERTE(m_pThread);
m_pPreviousHelperMethodFrameCallerList = m_pThread->m_pHelperMethodFrameCallerList;
m_pThread->m_pHelperMethodFrameCallerList = NULL;
}
FCallTransitionState::~FCallTransitionState ()
{
WRAPPER_NO_CONTRACT;
m_pThread->m_pHelperMethodFrameCallerList = m_pPreviousHelperMethodFrameCallerList;
}
PermitHelperMethodFrameState::PermitHelperMethodFrameState ()
{
WRAPPER_NO_CONTRACT;
m_pThread = GetThread();
_ASSERTE(m_pThread);
CONSISTENCY_CHECK_MSG((HelperMethodFrameCallerList*)-1 != m_pThread->m_pHelperMethodFrameCallerList,
"fcall entry point is missing a FCALL_TRANSITION_BEGIN or a FCIMPL\n");
m_ListEntry.pCaller = m_pThread->m_pHelperMethodFrameCallerList;
m_pThread->m_pHelperMethodFrameCallerList = &m_ListEntry;
}
PermitHelperMethodFrameState::~PermitHelperMethodFrameState ()
{
WRAPPER_NO_CONTRACT;
m_pThread->m_pHelperMethodFrameCallerList = m_ListEntry.pCaller;
}
VOID PermitHelperMethodFrameState::CheckHelperMethodFramePermitted ()
{
CONTRACTL {
NOTHROW;
GC_NOTRIGGER;
DEBUG_ONLY;
} CONTRACTL_END;
//
// Get current context and unwind to caller
//
CONTEXT ctx;
ClrCaptureContext(&ctx);
Thread::VirtualUnwindCallFrame(&ctx);
//
// Make sure each unmanaged frame used PERMIT_HELPER_METHOD_FRAME_BEGIN.
// If we hit NULL before we reach managed code, then the caller of the
// fcall was not managed.
//
Thread *pThread = GetThread();
_ASSERTE(pThread);
HelperMethodFrameCallerList *pList = pThread->m_pHelperMethodFrameCallerList;
PCODE CurrentIP;
TADDR CurrentSP;
do
{
CurrentSP = GetSP(&ctx);
CurrentIP = GetIP(&ctx);
Thread::VirtualUnwindCallFrame(&ctx);
TADDR CallerSP = GetSP(&ctx);
unsigned nAssociatedListEntries = 0;
while ( (SIZE_T)pList >= (SIZE_T)CurrentSP
&& (SIZE_T)pList < (SIZE_T)CallerSP)
{
nAssociatedListEntries++;
pList = pList->pCaller;
}
if (!nAssociatedListEntries)
{
char szFunction[cchMaxAssertStackLevelStringLen];
GetStringFromAddr((DWORD_PTR)CurrentIP, szFunction);
CONSISTENCY_CHECK_MSGF(false, ("Unmanaged caller %s at sp %p/ip %p is missing a "
"PERMIT_HELPER_METHOD_FRAME_BEGIN, or this function "
"is calling an fcall entry point that is missing a "
"FCALL_TRANSITION_BEGIN or a FCIMPL\n", szFunction, CurrentSP, CurrentIP));
}
}
while (pList && !ExecutionManager::IsManagedCode(GetIP(&ctx)));
//
// We should have exhausted the list. If not, the list was not reset at
// the transition from managed code.
//
if (pList)
{
char szFunction[cchMaxAssertStackLevelStringLen];
GetStringFromAddr((DWORD_PTR)CurrentIP, szFunction);
CONSISTENCY_CHECK_MSGF(false, ("fcall entry point %s at sp %p/ip %p is missing a "
"FCALL_TRANSITION_BEGIN or a FCIMPL\n", szFunction, CurrentSP, CurrentIP));
}
}
CompletedFCallTransitionState::CompletedFCallTransitionState ()
{
WRAPPER_NO_CONTRACT;
Thread *pThread = GetThread();
_ASSERTE(pThread);
m_pLastHelperMethodFrameCallerList = pThread->m_pHelperMethodFrameCallerList;
pThread->m_pHelperMethodFrameCallerList = (HelperMethodFrameCallerList*)-1;
}
CompletedFCallTransitionState::~CompletedFCallTransitionState ()
{
WRAPPER_NO_CONTRACT;
Thread *pThread = GetThread();
_ASSERTE(pThread);
pThread->m_pHelperMethodFrameCallerList = m_pLastHelperMethodFrameCallerList;
}
#endif // _TARGET_AMD64_
#endif // ENABLE_CONTRACTS