// Licensed to the .NET Foundation under one or more agreements.

// The .NET Foundation licenses this file to you under the MIT license.

//

//

// ---------------------------------------------------------------------------

// Clrex.cpp

// ---------------------------------------------------------------------------

#include "common.h"

#include "clrex.h"

#include "field.h"

#include "eetoprofinterfacewrapper.inl"

#include "typestring.h"

#include "sigformat.h"

#include "eeconfig.h"

#ifdef FEATURE_EH_FUNCLETS

#include "exceptionhandling.h"

#endif // FEATURE_EH_FUNCLETS

#ifdef FEATURE_COMINTEROP

#include "interoputil.inl"

#endif // FEATURE_COMINTEROP

// ---------------------------------------------------------------------------

// CLRException methods

// ---------------------------------------------------------------------------

CLRException::~CLRException()

{

CONTRACTL

{

GC_NOTRIGGER;

NOTHROW;

MODE_ANY;

if (GetThrowableHandle() == NULL)

{

CANNOT_TAKE_LOCK;

}

else

{

CAN_TAKE_LOCK; // because of DestroyHandle

}

}

CONTRACTL_END;

OBJECTHANDLE throwableHandle = GetThrowableHandle();

if (throwableHandle != NULL)

{

STRESS_LOG1(LF_EH, LL_INFO100, "CLRException::~CLRException destroying throwable: obj = %x\n", GetThrowableHandle());

// clear the handle first, so if we SO on destroying it, we don't have a dangling reference

SetThrowableHandle(NULL);

DestroyHandle(throwableHandle);

}

}

OBJECTREF CLRException::GetThrowable()

{

CONTRACTL

{

GC_TRIGGERS;

NOTHROW;

MODE_COOPERATIVE;

FORBID_FAULT;

}

CONTRACTL_END;

OBJECTREF throwable = NULL;

Thread *pThread = GetThread();

if (pThread->IsRudeAbortInitiated()) {

return GetBestThreadAbortException();

}

if ((IsType(CLRLastThrownObjectException::GetType()) &&

pThread->LastThrownObject() == GetPreallocatedStackOverflowException()))

{

return GetPreallocatedStackOverflowException();

}

OBJECTHANDLE oh = GetThrowableHandle();

if (oh != NULL)

{

return ObjectFromHandle(oh);

}

Exception *pLastException = pThread->m_pCreatingThrowableForException;

if (pLastException != NULL)

{

if (IsSameInstanceType(pLastException))

{

#if defined(_DEBUG)

static int BreakOnExceptionInGetThrowable = -1;

if (BreakOnExceptionInGetThrowable == -1)

{

BreakOnExceptionInGetThrowable = CLRConfig::GetConfigValue(CLRConfig::INTERNAL_BreakOnExceptionInGetThrowable);

}

if (BreakOnExceptionInGetThrowable)

{

_ASSERTE(!"BreakOnExceptionInGetThrowable");

}

LOG((LF_EH, LL_INFO100, "GetThrowable: Exception in GetThrowable, translating to a preallocated exception.\n"));

#endif // _DEBUG

// Look at the type of GET_EXCEPTION() and see if it is OOM or SO.

if (IsPreallocatedOOMException())

{

throwable = GetPreallocatedOutOfMemoryException();

}

else if (GetInstanceType() == EEException::GetType() && GetHR() == COR_E_THREADABORTED)

{

// the only use for thread abort in coreclr is when debugger needs to tear down

// a runaway expression evaluation.

// it would not escalate OOM into another abort, so OOM in low memory case is appropriate.

throwable = GetBestThreadAbortException();

}

else

{

// I am not convinced if this case is actually a fatal error in the runtime.

// There have been two bugs in early 2006 (VSW 575647 and 575650) that came in here,

// both because of OOM and resulted in the ThreadAbort clause above being added since

// we were creating a ThreadAbort throwable that, due to OOM, got us on a path

// which came here. Both were valid execution paths and scenarios and not a fatal condition.

//

// I am tempted to return preallocated OOM from here but my concern is that it *may*

// result in fake OOM exceptions being thrown that could break valid scenarios.

//

// Hence, we return preallocated System.Exception instance. Lossy information is better

// than wrong or no information (or even FailFast).

_ASSERTE (!"Recursion in CLRException::GetThrowable");

// We didn't recognize it, so use the preallocated System.Exception instance.

STRESS_LOG0(LF_EH, LL_INFO100, "CLRException::GetThrowable: Recursion! Translating to preallocated System.Exception.\n");

throwable = GetBestBaseException();

}

}

}

GCPROTECT_BEGIN(throwable);

if (throwable == NULL)

{

class RestoreLastException

{

Thread *m_pThread;

Exception *m_pLastException;

public:

RestoreLastException(Thread *pThread, Exception *pException)

{

m_pThread = pThread;

m_pLastException = m_pThread->m_pCreatingThrowableForException;

m_pThread->m_pCreatingThrowableForException = pException;

}

~RestoreLastException()

{

m_pThread->m_pCreatingThrowableForException = m_pLastException;

}

};

RestoreLastException restore(pThread, this);

EX_TRY

{

FAULT_NOT_FATAL();

throwable = CreateThrowable();

}

EX_CATCH

{

// This code used to be this line:

// throwable = GET_THROWABLE();

// GET_THROWABLE() expands to CLRException::GetThrowable(GET_EXCEPTION()),

// (where GET_EXCEPTION() refers to the exception that was thrown from

// CreateThrowable() and is being caught in this EX_TRY/EX_CATCH.)

// If that exception is the same as the one for which this GetThrowable()

// was called, we're in a recursive situation.

// Since the CreateThrowable() call should return a type from CoreLib,

// there really shouldn't be much opportunity for error. We could be

// out of memory, we could overflow the stack, or the runtime could

// be in a weird state(the thread could be aborted as well).

// Because we've seen a number of recursive death bugs here, just look

// explicitly for OOM and SO, and otherwise use ExecutionEngineException.

// Check whether the exception from CreateThrowable() is the same as the current

// exception. If not, call GetThrowable(), otherwise, settle for a

// preallocated exception.

Exception *pException = GET_EXCEPTION();

if (GetHR() == COR_E_THREADABORTED)

{

// the only use for thread abort in coreclr is when debugger needs to tear down

// a runaway expression evaluation.

// it would not escalate OOM into another abort, so OOM in low memory case is appropriate.

throwable = GetBestThreadAbortException();

}

else

{

throwable = CLRException::GetThrowableFromException(pException);

}

}

EX_END_CATCH(SwallowAllExceptions)

}

{

if (throwable == NULL)

{

STRESS_LOG0(LF_EH, LL_INFO100, "CLRException::GetThrowable: We have failed to track exceptions accurately through the system.\n");

// There's no reason to believe that it is an OOM. A better choice is ExecutionEngineException.

// We have failed to track exceptions accurately through the system. However, it's arguably

// better to give the wrong exception object than it is to rip the process. So let's leave

// it as an Assert for now and convert it to ExecutionEngineException in the next release.

// SQL Stress is hitting the assert. We want to remove it, so that we can see if there are further errors

// masked by the assert.

// _ASSERTE(FALSE);

throwable = GetPreallocatedOutOfMemoryException();

}

EX_TRY

{

SetThrowableHandle(GetAppDomain()->CreateHandle(throwable));

if (m_innerException != NULL && !CLRException::IsPreallocatedExceptionObject(throwable))

{

// Only set inner exception if the exception is not preallocated.

FAULT_NOT_FATAL();

// If inner exception is not empty, then set the managed exception's

// _innerException field properly

OBJECTREF throwableValue = CLRException::GetThrowableFromException(m_innerException);

((EXCEPTIONREF)throwable)->SetInnerException(throwableValue);

}

}

EX_CATCH

{

// No matter... we just don't get to cache the throwable.

}

EX_END_CATCH(SwallowAllExceptions)

}

GCPROTECT_END();

return throwable;

}

HRESULT CLRException::GetHR()

{

CONTRACTL

{

DISABLED(NOTHROW);

GC_TRIGGERS;

MODE_ANY;

}

CONTRACTL_END;

GCX_COOP();

return GetExceptionHResult(GetThrowable());

}

#ifdef FEATURE_COMINTEROP

HRESULT CLRException::SetErrorInfo()

{

CONTRACTL

{

GC_TRIGGERS;

NOTHROW;

MODE_ANY;

}

CONTRACTL_END;

HRESULT hr = S_OK;

IErrorInfo *pErrorInfo = NULL;

// Try to get IErrorInfo

EX_TRY

{

pErrorInfo = GetErrorInfo();

}

EX_CATCH

{

// Since there was an exception getting IErrorInfo get the exception's HR so

// that we return it back to the caller as the new exception.

hr = GET_EXCEPTION()->GetHR();

pErrorInfo = NULL;

LOG((LF_EH, LL_INFO100, "CLRException::SetErrorInfo: caught exception (hr = %08X) while trying to get IErrorInfo\n", hr));

}

EX_END_CATCH(SwallowAllExceptions)

if (!pErrorInfo)

{

// Return the HR to the caller if we dont get IErrorInfo - if the HR is E_NOINTERFACE, then

// there was no IErrorInfo available. If its anything else, it implies we failed to get the

// interface and have the HR corresponding to the exception we took while trying to get IErrorInfo.

return hr;

}

else

{

GCX_PREEMP();

EX_TRY

{

::SetErrorInfo(0, pErrorInfo);

pErrorInfo->Release();

// Success in setting the ErrorInfo on the thread

hr = S_OK;

}

EX_CATCH

{

hr = GET_EXCEPTION()->GetHR();

// Log the failure

LOG((LF_EH, LL_INFO100, "CLRException::SetErrorInfo: caught exception (hr = %08X) while trying to set IErrorInfo\n", hr));

}

EX_END_CATCH(SwallowAllExceptions)

}

return hr;

}

IErrorInfo *CLRException::GetErrorInfo()

{

CONTRACTL

{

GC_TRIGGERS;

THROWS;

MODE_ANY;

}

CONTRACTL_END;

IErrorInfo *pErrorInfo = NULL;

// Attempt to get IErrorInfo only if COM is initialized.

// Not all codepaths expect to have it initialized (e.g. hosting APIs).

if (g_fComStarted)

{

// Get errorinfo only when our SO probe succeeds

{

// Switch to coop mode since GetComIPFromObjectRef requires that

// and we could be here in any mode...

GCX_COOP();

OBJECTREF e = NULL;

GCPROTECT_BEGIN(e);

e = GetThrowable();

if (e != NULL)

{

pErrorInfo = (IErrorInfo *)GetComIPFromObjectRef(&e, IID_IErrorInfo);

}

GCPROTECT_END();

}

}

else

{

// Write to the log incase COM isnt initialized.

LOG((LF_EH, LL_INFO100, "CLRException::GetErrorInfo: exiting since COM is not initialized.\n"));

}

// return the IErrorInfo we got...

return pErrorInfo;

}

#else // FEATURE_COMINTEROP

IErrorInfo *CLRException::GetErrorInfo()

{

LIMITED_METHOD_CONTRACT;

return NULL;

}

HRESULT CLRException::SetErrorInfo()

{

LIMITED_METHOD_CONTRACT;

return S_OK;

}

#endif // FEATURE_COMINTEROP

void CLRException::GetMessage(SString &result)

{

CONTRACTL

{

GC_TRIGGERS;

THROWS;

MODE_ANY;

}

CONTRACTL_END;

GCX_COOP();

OBJECTREF e = GetThrowable();

if (e != NULL)

{

_ASSERTE(IsException(e->GetMethodTable()));

GCPROTECT_BEGIN (e);

STRINGREF message = ((EXCEPTIONREF)e)->GetMessage();

if (!message)

result.Clear();

else

message->GetSString(result);

GCPROTECT_END ();

}

}

OBJECTREF CLRException::GetPreallocatedOutOfMemoryException()

{

WRAPPER_NO_CONTRACT;

_ASSERTE(g_pPreallocatedOutOfMemoryException != NULL);

return ObjectFromHandle(g_pPreallocatedOutOfMemoryException);

}

OBJECTREF CLRException::GetPreallocatedStackOverflowException()

{

WRAPPER_NO_CONTRACT;

_ASSERTE(g_pPreallocatedStackOverflowException != NULL);

return ObjectFromHandle(g_pPreallocatedStackOverflowException);

}

OBJECTREF CLRException::GetPreallocatedExecutionEngineException()

{

WRAPPER_NO_CONTRACT;

_ASSERTE(g_pPreallocatedExecutionEngineException != NULL);

return ObjectFromHandle(g_pPreallocatedExecutionEngineException);

}

OBJECTHANDLE CLRException::GetPreallocatedStackOverflowExceptionHandle()

{

LIMITED_METHOD_CONTRACT;

_ASSERTE(g_pPreallocatedStackOverflowException != NULL);

return g_pPreallocatedStackOverflowException;

}

//

// Returns TRUE if the given object ref is one of the preallocated exception objects.

//

BOOL CLRException::IsPreallocatedExceptionObject(OBJECTREF o)

{

CONTRACTL

{

NOTHROW;

GC_NOTRIGGER;

MODE_COOPERATIVE;

FORBID_FAULT;

}

CONTRACTL_END;

if ((o == ObjectFromHandle(g_pPreallocatedOutOfMemoryException)) ||

(o == ObjectFromHandle(g_pPreallocatedStackOverflowException)) ||

(o == ObjectFromHandle(g_pPreallocatedExecutionEngineException)))

{

return TRUE;

}

return FALSE;

}

//

// Returns TRUE if the given object ref is one of the preallocated exception handles

//

BOOL CLRException::IsPreallocatedExceptionHandle(OBJECTHANDLE h)

{

CONTRACTL

{

NOTHROW;

GC_NOTRIGGER;

MODE_ANY;

FORBID_FAULT;

}

CONTRACTL_END;

if ((h == g_pPreallocatedOutOfMemoryException) ||

(h == g_pPreallocatedStackOverflowException) ||

(h == g_pPreallocatedExecutionEngineException))

{

return TRUE;

}

return FALSE;

}

//

// Returns a preallocated handle to match a preallocated exception object, or NULL if the object isn't one of the

// preallocated exception objects.

//

OBJECTHANDLE CLRException::GetPreallocatedHandleForObject(OBJECTREF o)

{

CONTRACTL

{

NOTHROW;

GC_NOTRIGGER;

MODE_COOPERATIVE;

FORBID_FAULT;

}

CONTRACTL_END;

if (o == ObjectFromHandle(g_pPreallocatedOutOfMemoryException))

{

return g_pPreallocatedOutOfMemoryException;

}

else if (o == ObjectFromHandle(g_pPreallocatedStackOverflowException))

{

return g_pPreallocatedStackOverflowException;

}

else if (o == ObjectFromHandle(g_pPreallocatedExecutionEngineException))

{

return g_pPreallocatedExecutionEngineException;

}

return NULL;

}

// Prefer a new exception if we can make one. If we cannot, then give back the pre-allocated OOM.

OBJECTREF CLRException::GetBestException(HRESULT hr, PTR_MethodTable mt)

{

CONTRACTL

{

NOTHROW;

MODE_COOPERATIVE;

}

CONTRACTL_END;

OBJECTREF retVal = NULL;

EX_TRY

{

FAULT_NOT_FATAL();

EXCEPTIONREF pOutOfMemory = (EXCEPTIONREF)AllocateObject(mt);

pOutOfMemory->SetHResult(hr);

pOutOfMemory->SetXCode(EXCEPTION_COMPLUS);

retVal = pOutOfMemory;

}

EX_CATCH

{

retVal = GetPreallocatedOutOfMemoryException();

}

EX_END_CATCH(SwallowAllExceptions)

_ASSERTE(retVal != NULL);

return retVal;

}

OBJECTREF CLRException::GetBestOutOfMemoryException()

{

CONTRACTL

{

NOTHROW;

MODE_COOPERATIVE;

}

CONTRACTL_END;

return GetBestException(COR_E_OUTOFMEMORY, g_pOutOfMemoryExceptionClass);

}

OBJECTREF CLRException::GetBestBaseException()

{

CONTRACTL

{

NOTHROW;

MODE_COOPERATIVE;

}

CONTRACTL_END;

return GetBestException(COR_E_EXCEPTION, g_pOutOfMemoryExceptionClass);

}

// thread abort is generally not supported in coreclr

// FX is not hardened to handle thread aborts and it may cause corruptions and deadlocks

// the only permitted scenario is when debugger needs to tear down a runaway expression evaluation.

// while unsafe, practically it is better than debuggee termination.

// For the same reasons, in a rare case if ThreadAbortException cannot be obtained,

// throwing OOM could be a good enough substitute that may still work.

OBJECTREF CLRException::GetBestThreadAbortException()

{

CONTRACTL

{

NOTHROW;

MODE_COOPERATIVE;

}

CONTRACTL_END;

return GetBestException(COR_E_THREADABORTED, g_pThreadAbortExceptionClass);

}

// Works on non-CLRExceptions as well

// static function

OBJECTREF CLRException::GetThrowableFromException(Exception *pException)

{

CONTRACTL

{

GC_TRIGGERS;

NOTHROW;

MODE_COOPERATIVE;

}

CONTRACTL_END;

// Can't have a throwable without a Thread.

Thread* pThread = GetThread();

if (NULL == pException)

{

return pThread->LastThrownObject();

}

if (pException->IsType(CLRException::GetType()))

return ((CLRException*)pException)->GetThrowable();

if (pException->IsType(EEException::GetType()))

return ((EEException*)pException)->GetThrowable();

// Note: we are creating a throwable on the fly in this case - so

// multiple calls will return different objects. If we really need identity,

// we could store a throwable handle at the catch site, or store it

// on the thread object.

if (pException->IsType(SEHException::GetType()))

{

SEHException *pSEHException = (SEHException*)pException;

switch (pSEHException->m_exception.ExceptionCode)

{

case EXCEPTION_COMPLUS:

// Note: even though the switch compared the exception code,

// we have to call the official IsComPlusException() routine

// for side-by-side correctness. If that check fails, treat

// as an unrelated unmanaged exception.

if (IsComPlusException(&(pSEHException->m_exception)))

{

return pThread->LastThrownObject();

}

else

{

break;

}

case STATUS_NO_MEMORY:

return GetBestOutOfMemoryException();

case STATUS_STACK_OVERFLOW:

return GetPreallocatedStackOverflowException();

}

DWORD exceptionCode =

MapWin32FaultToCOMPlusException(&pSEHException->m_exception);

EEException e((RuntimeExceptionKind)exceptionCode);

OBJECTREF throwable = e.GetThrowable();

GCPROTECT_BEGIN (throwable);

EX_TRY

{

SCAN_IGNORE_FAULT;

if (throwable != NULL && !CLRException::IsPreallocatedExceptionObject(throwable))

{

_ASSERTE(IsException(throwable->GetMethodTable()));

// set the exception code

((EXCEPTIONREF)throwable)->SetXCode(pSEHException->m_exception.ExceptionCode);

}

}

EX_CATCH

{

}

EX_END_CATCH(SwallowAllExceptions)

GCPROTECT_END ();

return throwable;

}

else

{

// We can enter here for HRException, COMException, DelegatingException

// just to name a few.

OBJECTREF oRetVal = NULL;

GCPROTECT_BEGIN(oRetVal);

{

EX_TRY

{

HRESULT hr = pException->GetHR();

if (hr == E_OUTOFMEMORY || hr == HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY))

{

oRetVal = GetBestOutOfMemoryException();

}

else if (hr == COR_E_STACKOVERFLOW)

{

oRetVal = GetPreallocatedStackOverflowException();

}

else

{

SafeComHolder<IErrorInfo> pErrInfo(pException->GetErrorInfo());

if (pErrInfo != NULL)

{

GetExceptionForHR(hr, pErrInfo, &oRetVal);

}

else

{

SString message;

pException->GetMessage(message);

EEMessageException e(hr, IDS_EE_GENERIC, message);

oRetVal = e.CreateThrowable();

}

}

}

EX_CATCH

{

// We have caught an exception trying to get a Throwable for the pException we

// were given. It is tempting to want to get the Throwable for the new

// exception, but that is dangerous, due to infinitely cascading

// exceptions, leading to a stack overflow.

// If we can see that the exception was OOM, return the preallocated OOM,

// if we can see that it is SO, return the preallocated SO,

// if we can see that it is some other managed exception, return that

// exception, otherwise return the preallocated System.Exception.

Exception *pNewException = GET_EXCEPTION();

if (pNewException->IsPreallocatedOOMException())

{ // It definitely was an OOM

STRESS_LOG0(LF_EH, LL_INFO100, "CLRException::GetThrowableFromException: OOM creating throwable; getting pre-alloc'd OOM.\n");

if (oRetVal == NULL)

oRetVal = GetPreallocatedOutOfMemoryException();

}

else

if (pNewException->IsType(CLRLastThrownObjectException::GetType()) &&

(pThread->LastThrownObject() != NULL))

{

STRESS_LOG0(LF_EH, LL_INFO100, "CLRException::GetThrowableFromException: LTO Exception creating throwable; getting LastThrownObject.\n");

if (oRetVal == NULL)

oRetVal = pThread->LastThrownObject();

}

else

{

// We *could* come here if one of the calls in the EX_TRY above throws an exception (e.g. MissingMethodException if we attempt

// to invoke CreateThrowable for a type that does not have a default constructor) that is neither preallocated OOM nor a

// CLRLastThrownObject type.

//

// Like the comment says above, we cannot afford to get the throwable lest we hit SO. In such a case, runtime is not in a bad shape

// but we dont know what to return as well. A reasonable answer is to return something less appropriate than ripping down process

// or returning an incorrect exception (e.g. OOM) that could break execution paths.

//

// Hence, we return preallocated System.Exception instance.

if (oRetVal == NULL)

{

oRetVal = GetBestBaseException();

STRESS_LOG0(LF_EH, LL_INFO100, "CLRException::GetThrowableFromException: Unknown Exception creating throwable; getting System.Exception.\n");

}

}

}

EX_END_CATCH(SwallowAllExceptions)

}

GCPROTECT_END();

return oRetVal;

}

} // OBJECTREF CLRException::GetThrowableFromException()

OBJECTREF CLRException::GetThrowableFromExceptionRecord(EXCEPTION_RECORD *pExceptionRecord)

{

CONTRACTL

{

GC_NOTRIGGER;

NOTHROW;

MODE_ANY;

}

CONTRACTL_END;

if (IsComPlusException(pExceptionRecord))

{

return GetThread()->LastThrownObject();

}

return NULL;

}

void CLRException::HandlerState::CleanupTry()

{

STATIC_CONTRACT_NOTHROW;

STATIC_CONTRACT_GC_NOTRIGGER;

STATIC_CONTRACT_MODE_ANY;

if (m_pThread != NULL)

{

// If there is no frame to unwind, UnwindFrameChain call is just an expensive NOP

// due to setting up and tear down of EH records. So we avoid it if we can.

if (m_pThread->GetFrame() < m_pFrame)

UnwindFrameChain(m_pThread, m_pFrame);

if (m_fPreemptiveGCDisabled != m_pThread->PreemptiveGCDisabled())

{

if (m_fPreemptiveGCDisabled)

m_pThread->DisablePreemptiveGC();

else

m_pThread->EnablePreemptiveGC();

}

}

// Make sure to call the base class's CleanupTry so it can do whatever it wants to do.

Exception::HandlerState::CleanupTry();

}

void CLRException::HandlerState::SetupCatch(INDEBUG_COMMA(_In_z_ const char * szFile) int lineNum)

{

STATIC_CONTRACT_NOTHROW;

STATIC_CONTRACT_GC_NOTRIGGER;

STATIC_CONTRACT_MODE_ANY;

STATIC_CONTRACT_CANNOT_TAKE_LOCK;

Exception::HandlerState::SetupCatch(INDEBUG_COMMA(szFile) lineNum);

Thread *pThread = NULL;

DWORD exceptionCode = 0;

if (g_fEEStarted)

{

pThread = GetThreadNULLOk();

exceptionCode = GetCurrentExceptionCode();

}

if (!DidCatchCxx())

{

if (exceptionCode == STATUS_STACK_OVERFLOW)

{

// Handle SO exception

//

// We should ensure that a valid Thread object exists before trying to set SO as the LTO.

if (pThread != NULL)

{

// We have a nasty issue with our EX_TRY/EX_CATCH. If EX_CATCH catches SEH exception,

// GET_THROWABLE uses CLRLastThrownObjectException instead, because we don't know

// what exception to use. But for SO, we can use preallocated SO exception.

GCX_COOP();

pThread->SetSOForLastThrownObject();

}

if (exceptionCode == STATUS_STACK_OVERFLOW)

{

// We have called HandleStackOverflow for soft SO through our vectored exception handler.

EEPolicy::HandleStackOverflow();

}

}

}

#ifdef FEATURE_EH_FUNCLETS

if (!DidCatchCxx())

{

// this must be done after the second pass has run, it does not

// reference anything on the stack, so it is safe to run in an

// SEH __except clause as well as a C++ catch clause.

ExceptionTracker::PopTrackers(this);

}

#endif // FEATURE_EH_FUNCLETS

}

#ifdef LOGGING

void CLRException::HandlerState::SucceedCatch()

{

STATIC_CONTRACT_NOTHROW;

STATIC_CONTRACT_GC_NOTRIGGER;

STATIC_CONTRACT_MODE_ANY;

STATIC_CONTRACT_CANNOT_TAKE_LOCK;

LOG((LF_EH, LL_INFO100, "EX_CATCH catch succeeded (CLRException::HandlerState)\n"));

//

// At this point, we don't believe we need to do any unwinding of the ExInfo chain after an EX_CATCH. The chain

// is unwound by CPFH_UnwindFrames1() when it detects that the exception is being caught by an unmanaged

// catcher. EX_CATCH looks just like an unmanaged catcher now, so the unwind is already done by the time we get

// into the catch. That's different than before the big switch to the new exception system, and it effects

// rethrows. Fixing rethrows is a work item for a little later. For now, we're simplying removing the unwind

// from here to avoid the extra unwind, which is harmless in many cases, but is very harmful when a managed

// filter throws an exception.

//

//

Exception::HandlerState::SucceedCatch();

}

#endif

// ---------------------------------------------------------------------------

// EEException methods

// ---------------------------------------------------------------------------

//------------------------------------------------------------------------

// Array that is used to retrieve the right exception for a given HRESULT.

//------------------------------------------------------------------------

struct ExceptionHRInfo

{

int cHRs;

const HRESULT *aHRs;

};

#define DEFINE_EXCEPTION(ns, reKind, bHRformessage, ...) static const HRESULT s_##reKind##HRs[] = { __VA_ARGS__ };

#include "rexcep.h"

static const

ExceptionHRInfo gExceptionHRInfos[] = {

#define DEFINE_EXCEPTION(ns, reKind, bHRformessage, ...) {sizeof(s_##reKind##HRs) / sizeof(HRESULT), s_##reKind##HRs},

#include "rexcep.h"

};

static const

bool gShouldDisplayHR[] =

{

#define DEFINE_EXCEPTION(ns, reKind, bHRformessage, ...) bHRformessage,

#include "rexcep.h"

};

/*static*/

HRESULT EEException::GetHRFromKind(RuntimeExceptionKind reKind)

{

LIMITED_METHOD_CONTRACT;

return gExceptionHRInfos[reKind].aHRs[0];

}

HRESULT EEException::GetHR()

{

LIMITED_METHOD_CONTRACT;

return EEException::GetHRFromKind(m_kind);

}

IErrorInfo *EEException::GetErrorInfo()

{

LIMITED_METHOD_CONTRACT;

return NULL;

}

BOOL EEException::GetThrowableMessage(SString &result)

{

CONTRACTL

{

GC_TRIGGERS;

THROWS;

MODE_ANY;

}

CONTRACTL_END;

// Return a meaningful HR message, if there is one.

HRESULT hr = GetHR();

// If the hr is more interesting than the kind, use that

// for a message.

if (hr != S_OK

&& hr != E_FAIL

&& (gShouldDisplayHR[m_kind]

|| gExceptionHRInfos[m_kind].aHRs[0] != hr))

{

// If it has only one HR, the original message should be good enough

_ASSERTE(gExceptionHRInfos[m_kind].cHRs > 1 ||

gExceptionHRInfos[m_kind].aHRs[0] != hr);

GenerateTopLevelHRExceptionMessage(hr, result);

return TRUE;

}

// No interesting hr - just keep the class default message.

return FALSE;

}

void EEException::GetMessage(SString &result)

{

CONTRACTL

{

GC_TRIGGERS;

THROWS;

MODE_ANY;

}

CONTRACTL_END;

// First look for a specialized message

if (GetThrowableMessage(result))

return;

// Otherwise, report the class's generic message

LPCUTF8 pszExceptionName = CoreLibBinder::GetExceptionName(m_kind);

result.SetUTF8(pszExceptionName);

}