summaryrefslogtreecommitdiff
path: root/src/ToolBox/superpmi/superpmi-shim-collector
diff options
context:
space:
mode:
authorJiyoung Yun <jy910.yun@samsung.com>2017-04-27 16:54:50 +0900
committerJiyoung Yun <jy910.yun@samsung.com>2017-04-27 16:54:50 +0900
commit5b975f8233e8c8d17b215372f89ca713b45d6a0b (patch)
tree0267bcc331458a01f4c26fafd28110a72273beb3 /src/ToolBox/superpmi/superpmi-shim-collector
parenta56e30c8d33048216567753d9d3fefc2152af8ac (diff)
downloadcoreclr-5b975f8233e8c8d17b215372f89ca713b45d6a0b.tar.gz
coreclr-5b975f8233e8c8d17b215372f89ca713b45d6a0b.tar.bz2
coreclr-5b975f8233e8c8d17b215372f89ca713b45d6a0b.zip
Imported Upstream version 2.0.0.11599upstream/2.0.0.11599
Diffstat (limited to 'src/ToolBox/superpmi/superpmi-shim-collector')
-rw-r--r--src/ToolBox/superpmi/superpmi-shim-collector/coreclrcallbacks.cpp28
-rw-r--r--src/ToolBox/superpmi/superpmi-shim-collector/coreclrcallbacks.h12
-rw-r--r--src/ToolBox/superpmi/superpmi-shim-collector/icorjitcompiler.cpp44
-rw-r--r--src/ToolBox/superpmi/superpmi-shim-collector/icorjitcompiler.h6
-rw-r--r--src/ToolBox/superpmi/superpmi-shim-collector/icorjitinfo.cpp1316
-rw-r--r--src/ToolBox/superpmi/superpmi-shim-collector/icorjitinfo.h10
-rw-r--r--src/ToolBox/superpmi/superpmi-shim-collector/ieememorymanager.cpp16
-rw-r--r--src/ToolBox/superpmi/superpmi-shim-collector/ieememorymanager.h16
-rw-r--r--src/ToolBox/superpmi/superpmi-shim-collector/iexecutionengine.cpp20
-rw-r--r--src/ToolBox/superpmi/superpmi-shim-collector/iexecutionengine.h17
-rw-r--r--src/ToolBox/superpmi/superpmi-shim-collector/jithost.cpp2
-rw-r--r--src/ToolBox/superpmi/superpmi-shim-collector/jithost.h2
-rw-r--r--src/ToolBox/superpmi/superpmi-shim-collector/superpmi-shim-collector.cpp168
13 files changed, 704 insertions, 953 deletions
diff --git a/src/ToolBox/superpmi/superpmi-shim-collector/coreclrcallbacks.cpp b/src/ToolBox/superpmi/superpmi-shim-collector/coreclrcallbacks.cpp
index 5b764f2fa5..14a55b5d79 100644
--- a/src/ToolBox/superpmi/superpmi-shim-collector/coreclrcallbacks.cpp
+++ b/src/ToolBox/superpmi/superpmi-shim-collector/coreclrcallbacks.cpp
@@ -7,17 +7,14 @@
#include "coreclrcallbacks.h"
#include "iexecutionengine.h"
-typedef LPVOID (__stdcall * pfnEEHeapAllocInProcessHeap)(DWORD dwFlags, SIZE_T dwBytes);
-typedef BOOL (__stdcall * pfnEEHeapFreeInProcessHeap)(DWORD dwFlags, LPVOID lpMem);
-
-CoreClrCallbacks *original_CoreClrCallbacks = nullptr;
+CoreClrCallbacks* original_CoreClrCallbacks = nullptr;
pfnEEHeapAllocInProcessHeap original_EEHeapAllocInProcessHeap = nullptr;
-pfnEEHeapFreeInProcessHeap original_EEHeapFreeInProcessHeap = nullptr;
+pfnEEHeapFreeInProcessHeap original_EEHeapFreeInProcessHeap = nullptr;
-IExecutionEngine* STDMETHODCALLTYPE IEE_t()
+IExecutionEngine* IEE_t()
{
- interceptor_IEE *iee = new interceptor_IEE();
- iee->original_IEE = original_CoreClrCallbacks->m_pfnIEE();
+ interceptor_IEE* iee = new interceptor_IEE();
+ iee->original_IEE = original_CoreClrCallbacks->m_pfnIEE();
return iee;
}
@@ -29,29 +26,29 @@ HRESULT STDMETHODCALLTYPE GetCORSystemDirectory(LPWSTR pbuffer, DWORD cchBuffer,
}
*/
-LPVOID STDMETHODCALLTYPE EEHeapAllocInProcessHeap (DWORD dwFlags, SIZE_T dwBytes)
+LPVOID EEHeapAllocInProcessHeap(DWORD dwFlags, SIZE_T dwBytes)
{
- if(original_EEHeapAllocInProcessHeap == nullptr)
+ if (original_EEHeapAllocInProcessHeap == nullptr)
__debugbreak();
return original_EEHeapAllocInProcessHeap(dwFlags, dwBytes);
}
-BOOL STDMETHODCALLTYPE EEHeapFreeInProcessHeap (DWORD dwFlags, LPVOID lpMem)
+BOOL EEHeapFreeInProcessHeap(DWORD dwFlags, LPVOID lpMem)
{
- if(original_EEHeapFreeInProcessHeap == nullptr)
+ if (original_EEHeapFreeInProcessHeap == nullptr)
__debugbreak();
return original_EEHeapFreeInProcessHeap(dwFlags, lpMem);
}
-void* STDMETHODCALLTYPE GetCLRFunction(LPCSTR functionName)
+void* GetCLRFunction(LPCSTR functionName)
{
- if(strcmp(functionName, "EEHeapAllocInProcessHeap")==0)
+ if (strcmp(functionName, "EEHeapAllocInProcessHeap") == 0)
{
original_EEHeapAllocInProcessHeap =
(pfnEEHeapAllocInProcessHeap)original_CoreClrCallbacks->m_pfnGetCLRFunction("EEHeapAllocInProcessHeap");
return (void*)EEHeapAllocInProcessHeap;
}
- if(strcmp(functionName, "EEHeapFreeInProcessHeap")==0)
+ if (strcmp(functionName, "EEHeapFreeInProcessHeap") == 0)
{
original_EEHeapFreeInProcessHeap =
(pfnEEHeapFreeInProcessHeap)original_CoreClrCallbacks->m_pfnGetCLRFunction("EEHeapFreeInProcessHeap");
@@ -59,4 +56,3 @@ void* STDMETHODCALLTYPE GetCLRFunction(LPCSTR functionName)
}
return original_CoreClrCallbacks->m_pfnGetCLRFunction(functionName);
}
-
diff --git a/src/ToolBox/superpmi/superpmi-shim-collector/coreclrcallbacks.h b/src/ToolBox/superpmi/superpmi-shim-collector/coreclrcallbacks.h
index c8c3e27c66..a5257422cd 100644
--- a/src/ToolBox/superpmi/superpmi-shim-collector/coreclrcallbacks.h
+++ b/src/ToolBox/superpmi/superpmi-shim-collector/coreclrcallbacks.h
@@ -6,14 +6,8 @@
#ifndef _CoreClrCallbacks
#define _CoreClrCallbacks
-#include "runtimedetails.h"
+#include "coreclrcommoncallbacks.h"
-IExecutionEngine* STDMETHODCALLTYPE IEE_t();
-HRESULT STDMETHODCALLTYPE GetCORSystemDirectory(LPWSTR pbuffer, DWORD cchBuffer, DWORD* pdwlength);
-LPVOID STDMETHODCALLTYPE EEHeapAllocInProcessHeap (DWORD dwFlags, SIZE_T dwBytes);
-BOOL STDMETHODCALLTYPE EEHeapFreeInProcessHeap (DWORD dwFlags, LPVOID lpMem);
-void* STDMETHODCALLTYPE GetCLRFunction(LPCSTR functionName);
+extern CoreClrCallbacks* original_CoreClrCallbacks;
-extern CoreClrCallbacks *original_CoreClrCallbacks;
-
-#endif \ No newline at end of file
+#endif
diff --git a/src/ToolBox/superpmi/superpmi-shim-collector/icorjitcompiler.cpp b/src/ToolBox/superpmi/superpmi-shim-collector/icorjitcompiler.cpp
index c5f6d8aac1..eaa6b8cfb7 100644
--- a/src/ToolBox/superpmi/superpmi-shim-collector/icorjitcompiler.cpp
+++ b/src/ToolBox/superpmi/superpmi-shim-collector/icorjitcompiler.cpp
@@ -10,21 +10,20 @@
#include "jithost.h"
#include "superpmi-shim-collector.h"
-#define fatMC //this is nice to have on so ildump works...
-interceptor_IEEMM *current_IEEMM = nullptr; //we want this to live beyond the scope of a single compileMethodCall
-
-CorJitResult __stdcall interceptor_ICJC::compileMethod (
- ICorJitInfo *comp, /* IN */
- struct CORINFO_METHOD_INFO *info, /* IN */
- unsigned /* code:CorJitFlag */ flags, /* IN */
- BYTE **nativeEntry, /* OUT */
- ULONG *nativeSizeOfCode /* OUT */
- )
+#define fatMC // this is nice to have on so ildump works...
+interceptor_IEEMM* current_IEEMM = nullptr; // we want this to live beyond the scope of a single compileMethodCall
+
+CorJitResult __stdcall interceptor_ICJC::compileMethod(ICorJitInfo* comp, /* IN */
+ struct CORINFO_METHOD_INFO* info, /* IN */
+ unsigned /* code:CorJitFlag */ flags, /* IN */
+ BYTE** nativeEntry, /* OUT */
+ ULONG* nativeSizeOfCode /* OUT */
+ )
{
interceptor_ICJI our_ICorJitInfo;
our_ICorJitInfo.original_ICorJitInfo = comp;
- if(current_IEEMM == nullptr)
+ if (current_IEEMM == nullptr)
current_IEEMM = new interceptor_IEEMM();
auto* mc = new MethodContext();
@@ -38,8 +37,8 @@ CorJitResult __stdcall interceptor_ICJC::compileMethod (
our_ICorJitInfo.mc->recCompileMethod(info, flags);
-//force some extra data into our tables..
- //data probably not needed with RyuJIT, but needed in 4.5 and 4.5.1 to help with catching cached values
+ // force some extra data into our tables..
+ //data probably not needed with RyuJIT, but needed in 4.5 and 4.5.1 to help with catching cached values
our_ICorJitInfo.getBuiltinClass(CLASSID_SYSTEM_OBJECT);
our_ICorJitInfo.getBuiltinClass(CLASSID_TYPED_BYREF);
our_ICorJitInfo.getBuiltinClass(CLASSID_TYPE_HANDLE);
@@ -50,7 +49,7 @@ CorJitResult __stdcall interceptor_ICJC::compileMethod (
our_ICorJitInfo.getBuiltinClass(CLASSID_RUNTIME_TYPE);
#ifdef fatMC
- //to build up a fat mc
+ // to build up a fat mc
CORINFO_CLASS_HANDLE ourClass = our_ICorJitInfo.getMethodClass(info->ftn);
our_ICorJitInfo.getClassAttribs(ourClass);
our_ICorJitInfo.getClassName(ourClass);
@@ -64,19 +63,20 @@ CorJitResult __stdcall interceptor_ICJC::compileMethod (
our_ICorJitInfo.mc->recGlobalContext(*g_globalContext);
}
- //Record a simple view of the environment
+ // Record a simple view of the environment
our_ICorJitInfo.mc->recEnvironment();
- CorJitResult temp = original_ICorJitCompiler->compileMethod(&our_ICorJitInfo, info, flags, nativeEntry, nativeSizeOfCode);
+ CorJitResult temp =
+ original_ICorJitCompiler->compileMethod(&our_ICorJitInfo, info, flags, nativeEntry, nativeSizeOfCode);
- if(temp == CORJIT_OK)
+ if (temp == CORJIT_OK)
{
- //capture the results of compilation
- our_ICorJitInfo.mc->cr->recCompileMethod(nativeEntry, nativeSizeOfCode, temp);
+ // capture the results of compilation
+ our_ICorJitInfo.mc->cr->recCompileMethod(nativeEntry, nativeSizeOfCode, temp);
- our_ICorJitInfo.mc->cr->recAllocMemCapture();
- our_ICorJitInfo.mc->cr->recAllocGCInfoCapture();
- our_ICorJitInfo.mc->saveToFile(hFile);
+ our_ICorJitInfo.mc->cr->recAllocMemCapture();
+ our_ICorJitInfo.mc->cr->recAllocGCInfoCapture();
+ our_ICorJitInfo.mc->saveToFile(hFile);
}
delete mc;
diff --git a/src/ToolBox/superpmi/superpmi-shim-collector/icorjitcompiler.h b/src/ToolBox/superpmi/superpmi-shim-collector/icorjitcompiler.h
index 97dbebd9a9..c1f35adc87 100644
--- a/src/ToolBox/superpmi/superpmi-shim-collector/icorjitcompiler.h
+++ b/src/ToolBox/superpmi/superpmi-shim-collector/icorjitcompiler.h
@@ -16,10 +16,10 @@ class interceptor_ICJC : public ICorJitCompiler
public:
// Added to help us track the original icjc and be able to easily indirect to it.
- ICorJitCompiler *original_ICorJitCompiler;
- HANDLE hFile;
+ ICorJitCompiler* original_ICorJitCompiler;
+ HANDLE hFile;
};
-extern interceptor_IEEMM *current_IEEMM; //we want this to live beyond the scope of a single compileMethodCall
+extern interceptor_IEEMM* current_IEEMM; // we want this to live beyond the scope of a single compileMethodCall
#endif
diff --git a/src/ToolBox/superpmi/superpmi-shim-collector/icorjitinfo.cpp b/src/ToolBox/superpmi/superpmi-shim-collector/icorjitinfo.cpp
index 6d64442a21..4741cf1354 100644
--- a/src/ToolBox/superpmi/superpmi-shim-collector/icorjitinfo.cpp
+++ b/src/ToolBox/superpmi/superpmi-shim-collector/icorjitinfo.cpp
@@ -12,16 +12,16 @@
#include "errorhandling.h"
#include "logging.h"
-#define fatMC //this is nice to have on so ildump works...
+#define fatMC // this is nice to have on so ildump works...
-//Stuff on ICorStaticInfo
+// Stuff on ICorStaticInfo
/**********************************************************************************/
//
// ICorMethodInfo
//
/**********************************************************************************/
// return flags (defined above, CORINFO_FLG_PUBLIC ...)
-DWORD interceptor_ICJI::getMethodAttribs (CORINFO_METHOD_HANDLE ftn /* IN */)
+DWORD interceptor_ICJI::getMethodAttribs(CORINFO_METHOD_HANDLE ftn /* IN */)
{
mc->cr->AddCall("getMethodAttribs");
DWORD temp = original_ICorJitInfo->getMethodAttribs(ftn);
@@ -30,8 +30,8 @@ DWORD interceptor_ICJI::getMethodAttribs (CORINFO_METHOD_HANDLE ftn /* IN */)
}
// sets private JIT flags, which can be, retrieved using getAttrib.
-void interceptor_ICJI::setMethodAttribs (CORINFO_METHOD_HANDLE ftn,/* IN */
- CorInfoMethodRuntimeFlags attribs/* IN */)
+void interceptor_ICJI::setMethodAttribs(CORINFO_METHOD_HANDLE ftn, /* IN */
+ CorInfoMethodRuntimeFlags attribs /* IN */)
{
mc->cr->AddCall("setMethodAttribs");
original_ICorJitInfo->setMethodAttribs(ftn, attribs);
@@ -42,61 +42,57 @@ void interceptor_ICJI::setMethodAttribs (CORINFO_METHOD_HANDLE ftn,/* IN */
//
// 'memberParent' is typically only set when verifying. It should be the
// result of calling getMemberParent.
-void interceptor_ICJI::getMethodSig (
- CORINFO_METHOD_HANDLE ftn, /* IN */
- CORINFO_SIG_INFO *sig, /* OUT */
- CORINFO_CLASS_HANDLE memberParent/* IN */
- )
+void interceptor_ICJI::getMethodSig(CORINFO_METHOD_HANDLE ftn, /* IN */
+ CORINFO_SIG_INFO* sig, /* OUT */
+ CORINFO_CLASS_HANDLE memberParent /* IN */
+ )
{
mc->cr->AddCall("getMethodSig");
original_ICorJitInfo->getMethodSig(ftn, sig, memberParent);
mc->recGetMethodSig(ftn, sig, memberParent);
}
- /*********************************************************************
- * Note the following methods can only be used on functions known
- * to be IL. This includes the method being compiled and any method
- * that 'getMethodInfo' returns true for
- *********************************************************************/
- // return information about a method private to the implementation
- // returns false if method is not IL, or is otherwise unavailable.
- // This method is used to fetch data needed to inline functions
- bool interceptor_ICJI::getMethodInfo (
- CORINFO_METHOD_HANDLE ftn, /* IN */
- CORINFO_METHOD_INFO* info /* OUT */
- )
-{
- struct Param : FilterSuperPMIExceptionsParam_CaptureException {
- interceptor_ICJI* pThis;
- CORINFO_METHOD_HANDLE ftn;
- CORINFO_METHOD_INFO* info;
- bool temp;
+/*********************************************************************
+* Note the following methods can only be used on functions known
+* to be IL. This includes the method being compiled and any method
+* that 'getMethodInfo' returns true for
+*********************************************************************/
+// return information about a method private to the implementation
+// returns false if method is not IL, or is otherwise unavailable.
+// This method is used to fetch data needed to inline functions
+bool interceptor_ICJI::getMethodInfo(CORINFO_METHOD_HANDLE ftn, /* IN */
+ CORINFO_METHOD_INFO* info /* OUT */
+ )
+{
+ struct Param : FilterSuperPMIExceptionsParam_CaptureException
+ {
+ interceptor_ICJI* pThis;
+ CORINFO_METHOD_HANDLE ftn;
+ CORINFO_METHOD_INFO* info;
+ bool temp;
} param;
param.pThis = this;
- param.ftn = ftn;
- param.info = info;
- param.temp = false;
+ param.ftn = ftn;
+ param.info = info;
+ param.temp = false;
- PAL_TRY(Param*, pOuterParam, &param)
- {
- PAL_TRY(Param*, pParam, pOuterParam)
- {
- pParam->pThis->mc->cr->AddCall("getMethodInfo");
- pParam->temp = pParam->pThis->original_ICorJitInfo->getMethodInfo(pParam->ftn, pParam->info);
- }
- PAL_EXCEPT_FILTER(FilterSuperPMIExceptions_CaptureExceptionAndContinue)
- {
- }
- PAL_ENDTRY
- }
- PAL_FINALLY
- {
- this->mc->recGetMethodInfo(ftn, info, param.temp, param.exceptionCode);
- }
- PAL_ENDTRY
+ PAL_TRY(Param*, pOuterParam,
+ &param){PAL_TRY(Param*, pParam, pOuterParam){pParam->pThis->mc->cr->AddCall("getMethodInfo");
+ pParam->temp = pParam->pThis->original_ICorJitInfo->getMethodInfo(pParam->ftn, pParam->info);
+}
+PAL_EXCEPT_FILTER(FilterSuperPMIExceptions_CaptureExceptionAndContinue)
+{
+}
+PAL_ENDTRY
+}
+PAL_FINALLY
+{
+ this->mc->recGetMethodInfo(ftn, info, param.temp, param.exceptionCode);
+}
+PAL_ENDTRY
- return param.temp;
- }
+return param.temp;
+}
// Decides if you have any limitations for inlining. If everything's OK, it will return
// INLINE_PASS and will fill out pRestrictions with a mask of restrictions the caller of this
@@ -107,69 +103,65 @@ void interceptor_ICJI::getMethodSig (
//
// The inlined method need not be verified
-CorInfoInline interceptor_ICJI::canInline (
- CORINFO_METHOD_HANDLE callerHnd, /* IN */
- CORINFO_METHOD_HANDLE calleeHnd, /* IN */
- DWORD* pRestrictions /* OUT */
- )
+CorInfoInline interceptor_ICJI::canInline(CORINFO_METHOD_HANDLE callerHnd, /* IN */
+ CORINFO_METHOD_HANDLE calleeHnd, /* IN */
+ DWORD* pRestrictions /* OUT */
+ )
{
- struct Param : FilterSuperPMIExceptionsParam_CaptureException {
- interceptor_ICJI* pThis;
- CORINFO_METHOD_HANDLE callerHnd;
- CORINFO_METHOD_HANDLE calleeHnd;
- DWORD* pRestrictions;
- CorInfoInline temp;
+ struct Param : FilterSuperPMIExceptionsParam_CaptureException
+ {
+ interceptor_ICJI* pThis;
+ CORINFO_METHOD_HANDLE callerHnd;
+ CORINFO_METHOD_HANDLE calleeHnd;
+ DWORD* pRestrictions;
+ CorInfoInline temp;
} param;
- param.pThis = this;
- param.callerHnd = callerHnd;
- param.calleeHnd = calleeHnd;
+ param.pThis = this;
+ param.callerHnd = callerHnd;
+ param.calleeHnd = calleeHnd;
param.pRestrictions = pRestrictions;
- param.temp = INLINE_NEVER;
+ param.temp = INLINE_NEVER;
- PAL_TRY(Param*, pOuterParam, &param)
- {
- PAL_TRY(Param*, pParam, pOuterParam)
- {
- pParam->pThis->mc->cr->AddCall("canInline");
- pParam->temp = pParam->pThis->original_ICorJitInfo->canInline(pParam->callerHnd, pParam->calleeHnd, pParam->pRestrictions);
- }
- PAL_EXCEPT_FILTER(FilterSuperPMIExceptions_CaptureExceptionAndContinue)
- {
- }
- PAL_ENDTRY
- }
- PAL_FINALLY
- {
- this->mc->recCanInline(callerHnd, calleeHnd, pRestrictions, param.temp, param.exceptionCode);
- }
- PAL_ENDTRY
+ PAL_TRY(Param*, pOuterParam,
+ &param){PAL_TRY(Param*, pParam, pOuterParam){pParam->pThis->mc->cr->AddCall("canInline");
+ pParam->temp =
+ pParam->pThis->original_ICorJitInfo->canInline(pParam->callerHnd, pParam->calleeHnd, pParam->pRestrictions);
+}
+PAL_EXCEPT_FILTER(FilterSuperPMIExceptions_CaptureExceptionAndContinue)
+{
+}
+PAL_ENDTRY
+}
+PAL_FINALLY
+{
+ this->mc->recCanInline(callerHnd, calleeHnd, pRestrictions, param.temp, param.exceptionCode);
+}
+PAL_ENDTRY
- return param.temp;
- }
+return param.temp;
+}
// Reports whether or not a method can be inlined, and why. canInline is responsible for reporting all
// inlining results when it returns INLINE_FAIL and INLINE_NEVER. All other results are reported by the
// JIT.
-void interceptor_ICJI::reportInliningDecision (CORINFO_METHOD_HANDLE inlinerHnd,
- CORINFO_METHOD_HANDLE inlineeHnd,
- CorInfoInline inlineResult,
- const char * reason)
+void interceptor_ICJI::reportInliningDecision(CORINFO_METHOD_HANDLE inlinerHnd,
+ CORINFO_METHOD_HANDLE inlineeHnd,
+ CorInfoInline inlineResult,
+ const char* reason)
{
mc->cr->AddCall("reportInliningDecision");
original_ICorJitInfo->reportInliningDecision(inlinerHnd, inlineeHnd, inlineResult, reason);
mc->cr->recReportInliningDecision(inlinerHnd, inlineeHnd, inlineResult, reason);
}
-
// Returns false if the call is across security boundaries thus we cannot tailcall
//
// The callerHnd must be the immediate caller (i.e. when we have a chain of inlined calls)
-bool interceptor_ICJI::canTailCall (
- CORINFO_METHOD_HANDLE callerHnd, /* IN */
- CORINFO_METHOD_HANDLE declaredCalleeHnd, /* IN */
- CORINFO_METHOD_HANDLE exactCalleeHnd, /* IN */
- bool fIsTailPrefix /* IN */
- )
+bool interceptor_ICJI::canTailCall(CORINFO_METHOD_HANDLE callerHnd, /* IN */
+ CORINFO_METHOD_HANDLE declaredCalleeHnd, /* IN */
+ CORINFO_METHOD_HANDLE exactCalleeHnd, /* IN */
+ bool fIsTailPrefix /* IN */
+ )
{
mc->cr->AddCall("canTailCall");
bool temp = original_ICorJitInfo->canTailCall(callerHnd, declaredCalleeHnd, exactCalleeHnd, fIsTailPrefix);
@@ -180,11 +172,11 @@ bool interceptor_ICJI::canTailCall (
// Reports whether or not a method can be tail called, and why.
// canTailCall is responsible for reporting all results when it returns
// false. All other results are reported by the JIT.
-void interceptor_ICJI::reportTailCallDecision (CORINFO_METHOD_HANDLE callerHnd,
- CORINFO_METHOD_HANDLE calleeHnd,
- bool fIsTailPrefix,
- CorInfoTailCall tailCallResult,
- const char * reason)
+void interceptor_ICJI::reportTailCallDecision(CORINFO_METHOD_HANDLE callerHnd,
+ CORINFO_METHOD_HANDLE calleeHnd,
+ bool fIsTailPrefix,
+ CorInfoTailCall tailCallResult,
+ const char* reason)
{
mc->cr->AddCall("reportTailCallDecision");
original_ICorJitInfo->reportTailCallDecision(callerHnd, calleeHnd, fIsTailPrefix, tailCallResult, reason);
@@ -192,11 +184,10 @@ void interceptor_ICJI::reportTailCallDecision (CORINFO_METHOD_HANDLE callerHnd,
}
// get individual exception handler
-void interceptor_ICJI::getEHinfo(
- CORINFO_METHOD_HANDLE ftn, /* IN */
- unsigned EHnumber, /* IN */
- CORINFO_EH_CLAUSE* clause /* OUT */
- )
+void interceptor_ICJI::getEHinfo(CORINFO_METHOD_HANDLE ftn, /* IN */
+ unsigned EHnumber, /* IN */
+ CORINFO_EH_CLAUSE* clause /* OUT */
+ )
{
mc->cr->AddCall("getEHinfo");
original_ICorJitInfo->getEHinfo(ftn, EHnumber, clause);
@@ -204,9 +195,7 @@ void interceptor_ICJI::getEHinfo(
}
// return class it belongs to
-CORINFO_CLASS_HANDLE interceptor_ICJI::getMethodClass (
- CORINFO_METHOD_HANDLE method
- )
+CORINFO_CLASS_HANDLE interceptor_ICJI::getMethodClass(CORINFO_METHOD_HANDLE method)
{
mc->cr->AddCall("getMethodClass");
CORINFO_CLASS_HANDLE temp = original_ICorJitInfo->getMethodClass(method);
@@ -215,9 +204,7 @@ CORINFO_CLASS_HANDLE interceptor_ICJI::getMethodClass (
}
// return module it belongs to
-CORINFO_MODULE_HANDLE interceptor_ICJI::getMethodModule (
- CORINFO_METHOD_HANDLE method
- )
+CORINFO_MODULE_HANDLE interceptor_ICJI::getMethodModule(CORINFO_METHOD_HANDLE method)
{
mc->cr->AddCall("getMethodModule");
return original_ICorJitInfo->getMethodModule(method);
@@ -225,11 +212,10 @@ CORINFO_MODULE_HANDLE interceptor_ICJI::getMethodModule (
// This function returns the offset of the specified method in the
// vtable of it's owning class or interface.
-void interceptor_ICJI::getMethodVTableOffset (
- CORINFO_METHOD_HANDLE method, /* IN */
- unsigned* offsetOfIndirection, /* OUT */
- unsigned* offsetAfterIndirection /* OUT */
- )
+void interceptor_ICJI::getMethodVTableOffset(CORINFO_METHOD_HANDLE method, /* IN */
+ unsigned* offsetOfIndirection, /* OUT */
+ unsigned* offsetAfterIndirection /* OUT */
+ )
{
mc->cr->AddCall("getMethodVTableOffset");
original_ICorJitInfo->getMethodVTableOffset(method, offsetOfIndirection, offsetAfterIndirection);
@@ -238,24 +224,21 @@ void interceptor_ICJI::getMethodVTableOffset (
// Find the virtual method in implementingClass that overrides virtualMethod.
// Return null if devirtualization is not possible.
-CORINFO_METHOD_HANDLE interceptor_ICJI::resolveVirtualMethod(
- CORINFO_METHOD_HANDLE virtualMethod,
- CORINFO_CLASS_HANDLE implementingClass,
- CORINFO_CONTEXT_HANDLE ownerType
- )
+CORINFO_METHOD_HANDLE interceptor_ICJI::resolveVirtualMethod(CORINFO_METHOD_HANDLE virtualMethod,
+ CORINFO_CLASS_HANDLE implementingClass,
+ CORINFO_CONTEXT_HANDLE ownerType)
{
mc->cr->AddCall("resolveVirtualMethod");
- CORINFO_METHOD_HANDLE result = original_ICorJitInfo->resolveVirtualMethod(virtualMethod, implementingClass, ownerType);
+ CORINFO_METHOD_HANDLE result =
+ original_ICorJitInfo->resolveVirtualMethod(virtualMethod, implementingClass, ownerType);
mc->recResolveVirtualMethod(virtualMethod, implementingClass, ownerType, result);
return result;
}
// If a method's attributes have (getMethodAttribs) CORINFO_FLG_INTRINSIC set,
// getIntrinsicID() returns the intrinsic ID.
-CorInfoIntrinsics interceptor_ICJI::getIntrinsicID(
- CORINFO_METHOD_HANDLE method,
- bool* pMustExpand /* OUT */
- )
+CorInfoIntrinsics interceptor_ICJI::getIntrinsicID(CORINFO_METHOD_HANDLE method, bool* pMustExpand /* OUT */
+ )
{
mc->cr->AddCall("getIntrinsicID");
CorInfoIntrinsics temp = original_ICorJitInfo->getIntrinsicID(method, pMustExpand);
@@ -264,9 +247,7 @@ CorInfoIntrinsics interceptor_ICJI::getIntrinsicID(
}
// Is the given module the System.Numerics.Vectors module?
-bool interceptor_ICJI::isInSIMDModule(
- CORINFO_CLASS_HANDLE classHnd
- )
+bool interceptor_ICJI::isInSIMDModule(CORINFO_CLASS_HANDLE classHnd)
{
mc->cr->AddCall("isInSIMDModule");
bool temp = original_ICorJitInfo->isInSIMDModule(classHnd);
@@ -275,9 +256,7 @@ bool interceptor_ICJI::isInSIMDModule(
}
// return the unmanaged calling convention for a PInvoke
-CorInfoUnmanagedCallConv interceptor_ICJI::getUnmanagedCallConv(
- CORINFO_METHOD_HANDLE method
- )
+CorInfoUnmanagedCallConv interceptor_ICJI::getUnmanagedCallConv(CORINFO_METHOD_HANDLE method)
{
mc->cr->AddCall("getUnmanagedCallConv");
CorInfoUnmanagedCallConv temp = original_ICorJitInfo->getUnmanagedCallConv(method);
@@ -287,10 +266,7 @@ CorInfoUnmanagedCallConv interceptor_ICJI::getUnmanagedCallConv(
// return if any marshaling is required for PInvoke methods. Note that
// method == 0 => calli. The call site sig is only needed for the varargs or calli case
-BOOL interceptor_ICJI::pInvokeMarshalingRequired(
- CORINFO_METHOD_HANDLE method,
- CORINFO_SIG_INFO* callSiteSig
- )
+BOOL interceptor_ICJI::pInvokeMarshalingRequired(CORINFO_METHOD_HANDLE method, CORINFO_SIG_INFO* callSiteSig)
{
mc->cr->AddCall("pInvokeMarshalingRequired");
BOOL temp = original_ICorJitInfo->pInvokeMarshalingRequired(method, callSiteSig);
@@ -300,10 +276,8 @@ BOOL interceptor_ICJI::pInvokeMarshalingRequired(
// Check constraints on method type arguments (only).
// The parent class should be checked separately using satisfiesClassConstraints(parent).
-BOOL interceptor_ICJI::satisfiesMethodConstraints(
- CORINFO_CLASS_HANDLE parent, // the exact parent of the method
- CORINFO_METHOD_HANDLE method
- )
+BOOL interceptor_ICJI::satisfiesMethodConstraints(CORINFO_CLASS_HANDLE parent, // the exact parent of the method
+ CORINFO_METHOD_HANDLE method)
{
mc->cr->AddCall("satisfiesMethodConstraints");
BOOL temp = original_ICorJitInfo->satisfiesMethodConstraints(parent, method);
@@ -315,24 +289,22 @@ BOOL interceptor_ICJI::satisfiesMethodConstraints(
// a delegate class, check if the method signature is compatible with the Invoke method of the delegate
// (under the typical instantiation of any free type variables in the memberref signatures).
BOOL interceptor_ICJI::isCompatibleDelegate(
- CORINFO_CLASS_HANDLE objCls, /* type of the delegate target, if any */
- CORINFO_CLASS_HANDLE methodParentCls, /* exact parent of the target method, if any */
- CORINFO_METHOD_HANDLE method, /* (representative) target method, if any */
- CORINFO_CLASS_HANDLE delegateCls, /* exact type of the delegate */
- BOOL *pfIsOpenDelegate /* is the delegate open */
- )
+ CORINFO_CLASS_HANDLE objCls, /* type of the delegate target, if any */
+ CORINFO_CLASS_HANDLE methodParentCls, /* exact parent of the target method, if any */
+ CORINFO_METHOD_HANDLE method, /* (representative) target method, if any */
+ CORINFO_CLASS_HANDLE delegateCls, /* exact type of the delegate */
+ BOOL* pfIsOpenDelegate /* is the delegate open */
+ )
{
mc->cr->AddCall("isCompatibleDelegate");
- BOOL temp = original_ICorJitInfo->isCompatibleDelegate(objCls, methodParentCls, method, delegateCls, pfIsOpenDelegate);
+ BOOL temp =
+ original_ICorJitInfo->isCompatibleDelegate(objCls, methodParentCls, method, delegateCls, pfIsOpenDelegate);
mc->recIsCompatibleDelegate(objCls, methodParentCls, method, delegateCls, pfIsOpenDelegate, temp);
return temp;
}
// Determines whether the delegate creation obeys security transparency rules
-BOOL interceptor_ICJI::isDelegateCreationAllowed (
- CORINFO_CLASS_HANDLE delegateHnd,
- CORINFO_METHOD_HANDLE calleeHnd
- )
+BOOL interceptor_ICJI::isDelegateCreationAllowed(CORINFO_CLASS_HANDLE delegateHnd, CORINFO_METHOD_HANDLE calleeHnd)
{
mc->cr->AddCall("isDelegateCreationAllowed");
BOOL temp = original_ICorJitInfo->isDelegateCreationAllowed(delegateHnd, calleeHnd);
@@ -340,12 +312,11 @@ BOOL interceptor_ICJI::isDelegateCreationAllowed (
return temp;
}
-
// Indicates if the method is an instance of the generic
// method that passes (or has passed) verification
-CorInfoInstantiationVerification interceptor_ICJI::isInstantiationOfVerifiedGeneric (
- CORINFO_METHOD_HANDLE method /* IN */
- )
+CorInfoInstantiationVerification interceptor_ICJI::isInstantiationOfVerifiedGeneric(CORINFO_METHOD_HANDLE method /* IN
+ */
+ )
{
mc->cr->AddCall("isInstantiationOfVerifiedGeneric");
CorInfoInstantiationVerification temp = original_ICorJitInfo->isInstantiationOfVerifiedGeneric(method);
@@ -355,22 +326,20 @@ CorInfoInstantiationVerification interceptor_ICJI::isInstantiationOfVerifiedGene
// Loads the constraints on a typical method definition, detecting cycles;
// for use in verification.
-void interceptor_ICJI::initConstraintsForVerification(
- CORINFO_METHOD_HANDLE method, /* IN */
- BOOL *pfHasCircularClassConstraints, /* OUT */
- BOOL *pfHasCircularMethodConstraint /* OUT */
- )
+void interceptor_ICJI::initConstraintsForVerification(CORINFO_METHOD_HANDLE method, /* IN */
+ BOOL* pfHasCircularClassConstraints, /* OUT */
+ BOOL* pfHasCircularMethodConstraint /* OUT */
+ )
{
mc->cr->AddCall("initConstraintsForVerification");
- original_ICorJitInfo->initConstraintsForVerification(method, pfHasCircularClassConstraints, pfHasCircularMethodConstraint);
+ original_ICorJitInfo->initConstraintsForVerification(method, pfHasCircularClassConstraints,
+ pfHasCircularMethodConstraint);
mc->recInitConstraintsForVerification(method, pfHasCircularClassConstraints, pfHasCircularMethodConstraint);
}
// Returns enum whether the method does not require verification
// Also see ICorModuleInfo::canSkipVerification
-CorInfoCanSkipVerificationResult interceptor_ICJI::canSkipMethodVerification (
- CORINFO_METHOD_HANDLE ftnHandle
- )
+CorInfoCanSkipVerificationResult interceptor_ICJI::canSkipMethodVerification(CORINFO_METHOD_HANDLE ftnHandle)
{
mc->cr->AddCall("canSkipMethodVerification");
CorInfoCanSkipVerificationResult temp = original_ICorJitInfo->canSkipMethodVerification(ftnHandle);
@@ -379,18 +348,14 @@ CorInfoCanSkipVerificationResult interceptor_ICJI::canSkipMethodVerification (
}
// load and restore the method
-void interceptor_ICJI::methodMustBeLoadedBeforeCodeIsRun(
- CORINFO_METHOD_HANDLE method
- )
+void interceptor_ICJI::methodMustBeLoadedBeforeCodeIsRun(CORINFO_METHOD_HANDLE method)
{
mc->cr->AddCall("methodMustBeLoadedBeforeCodeIsRun");
original_ICorJitInfo->methodMustBeLoadedBeforeCodeIsRun(method);
mc->cr->recMethodMustBeLoadedBeforeCodeIsRun(method);
}
-CORINFO_METHOD_HANDLE interceptor_ICJI::mapMethodDeclToMethodImpl(
- CORINFO_METHOD_HANDLE method
- )
+CORINFO_METHOD_HANDLE interceptor_ICJI::mapMethodDeclToMethodImpl(CORINFO_METHOD_HANDLE method)
{
mc->cr->AddCall("mapMethodDeclToMethodImpl");
return original_ICorJitInfo->mapMethodDeclToMethodImpl(method);
@@ -398,10 +363,9 @@ CORINFO_METHOD_HANDLE interceptor_ICJI::mapMethodDeclToMethodImpl(
// Returns the global cookie for the /GS unsafe buffer checks
// The cookie might be a constant value (JIT), or a handle to memory location (Ngen)
-void interceptor_ICJI::getGSCookie(
- GSCookie * pCookieVal, // OUT
- GSCookie ** ppCookieVal // OUT
- )
+void interceptor_ICJI::getGSCookie(GSCookie* pCookieVal, // OUT
+ GSCookie** ppCookieVal // OUT
+ )
{
mc->cr->AddCall("getGSCookie");
original_ICorJitInfo->getGSCookie(pCookieVal, ppCookieVal);
@@ -414,35 +378,33 @@ void interceptor_ICJI::getGSCookie(
//
/**********************************************************************************/
// Resolve metadata token into runtime method handles.
-void interceptor_ICJI::resolveToken(/* IN, OUT */ CORINFO_RESOLVED_TOKEN * pResolvedToken)
+void interceptor_ICJI::resolveToken(/* IN, OUT */ CORINFO_RESOLVED_TOKEN* pResolvedToken)
{
- struct Param : FilterSuperPMIExceptionsParam_CaptureException {
+ struct Param : FilterSuperPMIExceptionsParam_CaptureException
+ {
interceptor_ICJI* pThis;
CORINFO_RESOLVED_TOKEN* pResolvedToken;
} param;
- param.pThis = this;
+ param.pThis = this;
param.pResolvedToken = pResolvedToken;
- PAL_TRY(Param*, pOuterParam, &param)
- {
- PAL_TRY(Param*, pParam, pOuterParam)
- {
- pParam->pThis->mc->cr->AddCall("resolveToken");
- pParam->pThis->original_ICorJitInfo->resolveToken(pParam->pResolvedToken);
- }
- PAL_EXCEPT_FILTER(FilterSuperPMIExceptions_CaptureExceptionAndContinue)
- {
- }
- PAL_ENDTRY
- }
- PAL_FINALLY
- {
- this->mc->recResolveToken(param.pResolvedToken, param.exceptionCode);
- }
- PAL_ENDTRY
+ PAL_TRY(Param*, pOuterParam,
+ &param){PAL_TRY(Param*, pParam, pOuterParam){pParam->pThis->mc->cr->AddCall("resolveToken");
+ pParam->pThis->original_ICorJitInfo->resolveToken(pParam->pResolvedToken);
+}
+PAL_EXCEPT_FILTER(FilterSuperPMIExceptions_CaptureExceptionAndContinue)
+{
+}
+PAL_ENDTRY
+}
+PAL_FINALLY
+{
+ this->mc->recResolveToken(param.pResolvedToken, param.exceptionCode);
+}
+PAL_ENDTRY
}
-bool interceptor_ICJI::tryResolveToken(/* IN, OUT */ CORINFO_RESOLVED_TOKEN * pResolvedToken)
+bool interceptor_ICJI::tryResolveToken(/* IN, OUT */ CORINFO_RESOLVED_TOKEN* pResolvedToken)
{
mc->cr->AddCall("tryResolveToken");
bool success = original_ICorJitInfo->tryResolveToken(pResolvedToken);
@@ -451,12 +413,11 @@ bool interceptor_ICJI::tryResolveToken(/* IN, OUT */ CORINFO_RESOLVED_TOKEN * pR
}
// Signature information about the call sig
-void interceptor_ICJI::findSig (
- CORINFO_MODULE_HANDLE module, /* IN */
- unsigned sigTOK, /* IN */
- CORINFO_CONTEXT_HANDLE context, /* IN */
- CORINFO_SIG_INFO *sig /* OUT */
- )
+void interceptor_ICJI::findSig(CORINFO_MODULE_HANDLE module, /* IN */
+ unsigned sigTOK, /* IN */
+ CORINFO_CONTEXT_HANDLE context, /* IN */
+ CORINFO_SIG_INFO* sig /* OUT */
+ )
{
mc->cr->AddCall("findSig");
original_ICorJitInfo->findSig(module, sigTOK, context, sig);
@@ -466,20 +427,18 @@ void interceptor_ICJI::findSig (
// for Varargs, the signature at the call site may differ from
// the signature at the definition. Thus we need a way of
// fetching the call site information
-void interceptor_ICJI::findCallSiteSig (
- CORINFO_MODULE_HANDLE module, /* IN */
- unsigned methTOK, /* IN */
- CORINFO_CONTEXT_HANDLE context, /* IN */
- CORINFO_SIG_INFO *sig /* OUT */
- )
+void interceptor_ICJI::findCallSiteSig(CORINFO_MODULE_HANDLE module, /* IN */
+ unsigned methTOK, /* IN */
+ CORINFO_CONTEXT_HANDLE context, /* IN */
+ CORINFO_SIG_INFO* sig /* OUT */
+ )
{
mc->cr->AddCall("findCallSiteSig");
original_ICorJitInfo->findCallSiteSig(module, methTOK, context, sig);
mc->recFindCallSiteSig(module, methTOK, context, sig);
}
-CORINFO_CLASS_HANDLE interceptor_ICJI::getTokenTypeAsHandle (
- CORINFO_RESOLVED_TOKEN * pResolvedToken /* IN */)
+CORINFO_CLASS_HANDLE interceptor_ICJI::getTokenTypeAsHandle(CORINFO_RESOLVED_TOKEN* pResolvedToken /* IN */)
{
mc->cr->AddCall("getTokenTypeAsHandle");
CORINFO_CLASS_HANDLE temp = original_ICorJitInfo->getTokenTypeAsHandle(pResolvedToken);
@@ -497,19 +456,17 @@ CORINFO_CLASS_HANDLE interceptor_ICJI::getTokenTypeAsHandle (
//
// Returns enum whether the module does not require verification
// Also see ICorMethodInfo::canSkipMethodVerification();
-CorInfoCanSkipVerificationResult interceptor_ICJI::canSkipVerification (
- CORINFO_MODULE_HANDLE module /* IN */
- )
+CorInfoCanSkipVerificationResult interceptor_ICJI::canSkipVerification(CORINFO_MODULE_HANDLE module /* IN */
+ )
{
mc->cr->AddCall("canSkipVerification");
return original_ICorJitInfo->canSkipVerification(module);
}
// Checks if the given metadata token is valid
-BOOL interceptor_ICJI::isValidToken (
- CORINFO_MODULE_HANDLE module, /* IN */
- unsigned metaTOK /* IN */
- )
+BOOL interceptor_ICJI::isValidToken(CORINFO_MODULE_HANDLE module, /* IN */
+ unsigned metaTOK /* IN */
+ )
{
mc->cr->AddCall("isValidToken");
BOOL result = original_ICorJitInfo->isValidToken(module, metaTOK);
@@ -518,10 +475,9 @@ BOOL interceptor_ICJI::isValidToken (
}
// Checks if the given metadata token is valid StringRef
-BOOL interceptor_ICJI::isValidStringRef (
- CORINFO_MODULE_HANDLE module, /* IN */
- unsigned metaTOK /* IN */
- )
+BOOL interceptor_ICJI::isValidStringRef(CORINFO_MODULE_HANDLE module, /* IN */
+ unsigned metaTOK /* IN */
+ )
{
mc->cr->AddCall("isValidStringRef");
BOOL temp = original_ICorJitInfo->isValidStringRef(module, metaTOK);
@@ -529,9 +485,7 @@ BOOL interceptor_ICJI::isValidStringRef (
return temp;
}
-BOOL interceptor_ICJI::shouldEnforceCallvirtRestriction(
- CORINFO_MODULE_HANDLE scope
- )
+BOOL interceptor_ICJI::shouldEnforceCallvirtRestriction(CORINFO_MODULE_HANDLE scope)
{
mc->cr->AddCall("shouldEnforceCallvirtRestriction");
BOOL temp = original_ICorJitInfo->shouldEnforceCallvirtRestriction(scope);
@@ -547,9 +501,7 @@ BOOL interceptor_ICJI::shouldEnforceCallvirtRestriction(
// If the value class 'cls' is isomorphic to a primitive type it will
// return that type, otherwise it will return CORINFO_TYPE_VALUECLASS
-CorInfoType interceptor_ICJI::asCorInfoType (
- CORINFO_CLASS_HANDLE cls
- )
+CorInfoType interceptor_ICJI::asCorInfoType(CORINFO_CLASS_HANDLE cls)
{
mc->cr->AddCall("asCorInfoType");
CorInfoType temp = original_ICorJitInfo->asCorInfoType(cls);
@@ -558,9 +510,7 @@ CorInfoType interceptor_ICJI::asCorInfoType (
}
// for completeness
-const char* interceptor_ICJI::getClassName (
- CORINFO_CLASS_HANDLE cls
- )
+const char* interceptor_ICJI::getClassName(CORINFO_CLASS_HANDLE cls)
{
mc->cr->AddCall("getClassName");
const char* result = original_ICorJitInfo->getClassName(cls);
@@ -573,23 +523,22 @@ const char* interceptor_ICJI::getClassName (
// If fFullInst=TRUE (regardless of fNamespace and fAssembly), include namespace and assembly for any type parameters
// If fAssembly=TRUE, suffix with a comma and the full assembly qualification
// return size of representation
-int interceptor_ICJI::appendClassName(
- __deref_inout_ecount(*pnBufLen) WCHAR** ppBuf,
- int* pnBufLen,
- CORINFO_CLASS_HANDLE cls,
- BOOL fNamespace,
- BOOL fFullInst,
- BOOL fAssembly
- )
+int interceptor_ICJI::appendClassName(__deref_inout_ecount(*pnBufLen) WCHAR** ppBuf,
+ int* pnBufLen,
+ CORINFO_CLASS_HANDLE cls,
+ BOOL fNamespace,
+ BOOL fFullInst,
+ BOOL fAssembly)
{
mc->cr->AddCall("appendClassName");
WCHAR* pBuf = *ppBuf;
- int nLen = original_ICorJitInfo->appendClassName(ppBuf, pnBufLen, cls, fNamespace, fFullInst, fAssembly);
+ int nLen = original_ICorJitInfo->appendClassName(ppBuf, pnBufLen, cls, fNamespace, fFullInst, fAssembly);
mc->recAppendClassName(cls, fNamespace, fFullInst, fAssembly, pBuf);
return nLen;
}
-// Quick check whether the type is a value class. Returns the same value as getClassAttribs(cls) & CORINFO_FLG_VALUECLASS, except faster.
+// Quick check whether the type is a value class. Returns the same value as getClassAttribs(cls) &
+// CORINFO_FLG_VALUECLASS, except faster.
BOOL interceptor_ICJI::isValueClass(CORINFO_CLASS_HANDLE cls)
{
mc->cr->AddCall("isValueClass");
@@ -609,9 +558,7 @@ BOOL interceptor_ICJI::canInlineTypeCheckWithObjectVTable(CORINFO_CLASS_HANDLE c
}
// return flags (defined above, CORINFO_FLG_PUBLIC ...)
-DWORD interceptor_ICJI::getClassAttribs (
- CORINFO_CLASS_HANDLE cls
- )
+DWORD interceptor_ICJI::getClassAttribs(CORINFO_CLASS_HANDLE cls)
{
mc->cr->AddCall("getClassAttribs");
DWORD temp = original_ICorJitInfo->getClassAttribs(cls);
@@ -633,27 +580,21 @@ BOOL interceptor_ICJI::isStructRequiringStackAllocRetBuf(CORINFO_CLASS_HANDLE cl
return temp;
}
-CORINFO_MODULE_HANDLE interceptor_ICJI::getClassModule (
- CORINFO_CLASS_HANDLE cls
- )
+CORINFO_MODULE_HANDLE interceptor_ICJI::getClassModule(CORINFO_CLASS_HANDLE cls)
{
mc->cr->AddCall("getClassModule");
return original_ICorJitInfo->getClassModule(cls);
}
// Returns the assembly that contains the module "mod".
-CORINFO_ASSEMBLY_HANDLE interceptor_ICJI::getModuleAssembly (
- CORINFO_MODULE_HANDLE mod
- )
+CORINFO_ASSEMBLY_HANDLE interceptor_ICJI::getModuleAssembly(CORINFO_MODULE_HANDLE mod)
{
mc->cr->AddCall("getModuleAssembly");
return original_ICorJitInfo->getModuleAssembly(mod);
}
// Returns the name of the assembly "assem".
-const char* interceptor_ICJI::getAssemblyName (
- CORINFO_ASSEMBLY_HANDLE assem
- )
+const char* interceptor_ICJI::getAssemblyName(CORINFO_ASSEMBLY_HANDLE assem)
{
mc->cr->AddCall("getAssemblyName");
return original_ICorJitInfo->getAssemblyName(assem);
@@ -675,11 +616,9 @@ void interceptor_ICJI::LongLifetimeFree(void* obj)
original_ICorJitInfo->LongLifetimeFree(obj);
}
-size_t interceptor_ICJI::getClassModuleIdForStatics (
- CORINFO_CLASS_HANDLE cls,
- CORINFO_MODULE_HANDLE *pModule,
- void **ppIndirection
- )
+size_t interceptor_ICJI::getClassModuleIdForStatics(CORINFO_CLASS_HANDLE cls,
+ CORINFO_MODULE_HANDLE* pModule,
+ void** ppIndirection)
{
mc->cr->AddCall("getClassModuleIdForStatics");
size_t temp = original_ICorJitInfo->getClassModuleIdForStatics(cls, pModule, ppIndirection);
@@ -688,9 +627,7 @@ size_t interceptor_ICJI::getClassModuleIdForStatics (
}
// return the number of bytes needed by an instance of the class
-unsigned interceptor_ICJI::getClassSize (
- CORINFO_CLASS_HANDLE cls
- )
+unsigned interceptor_ICJI::getClassSize(CORINFO_CLASS_HANDLE cls)
{
mc->cr->AddCall("getClassSize");
unsigned temp = original_ICorJitInfo->getClassSize(cls);
@@ -698,10 +635,7 @@ unsigned interceptor_ICJI::getClassSize (
return temp;
}
-unsigned interceptor_ICJI::getClassAlignmentRequirement (
- CORINFO_CLASS_HANDLE cls,
- BOOL fDoubleAlignHint
- )
+unsigned interceptor_ICJI::getClassAlignmentRequirement(CORINFO_CLASS_HANDLE cls, BOOL fDoubleAlignHint)
{
mc->cr->AddCall("getClassAlignmentRequirement");
unsigned temp = original_ICorJitInfo->getClassAlignmentRequirement(cls, fDoubleAlignHint);
@@ -718,22 +652,20 @@ unsigned interceptor_ICJI::getClassAlignmentRequirement (
// to one of the CorInfoGCType values which is the GC type of
// the i-th machine word of an object of type 'cls'
// returns the number of GC pointers in the array
-unsigned interceptor_ICJI::getClassGClayout (
- CORINFO_CLASS_HANDLE cls, /* IN */
- BYTE *gcPtrs /* OUT */
- )
+unsigned interceptor_ICJI::getClassGClayout(CORINFO_CLASS_HANDLE cls, /* IN */
+ BYTE* gcPtrs /* OUT */
+ )
{
mc->cr->AddCall("getClassGClayout");
unsigned temp = original_ICorJitInfo->getClassGClayout(cls, gcPtrs);
- unsigned len = (getClassSize(cls) + sizeof(void *) - 1)/sizeof(void*);
+ unsigned len = (getClassSize(cls) + sizeof(void*) - 1) / sizeof(void*);
mc->recGetClassGClayout(cls, gcPtrs, len, temp);
return temp;
}
// returns the number of instance fields in a class
-unsigned interceptor_ICJI::getClassNumInstanceFields (
- CORINFO_CLASS_HANDLE cls /* IN */
- )
+unsigned interceptor_ICJI::getClassNumInstanceFields(CORINFO_CLASS_HANDLE cls /* IN */
+ )
{
mc->cr->AddCall("getClassNumInstanceFields");
unsigned temp = original_ICorJitInfo->getClassNumInstanceFields(cls);
@@ -741,10 +673,7 @@ unsigned interceptor_ICJI::getClassNumInstanceFields (
return temp;
}
-CORINFO_FIELD_HANDLE interceptor_ICJI::getFieldInClass(
- CORINFO_CLASS_HANDLE clsHnd,
- INT num
- )
+CORINFO_FIELD_HANDLE interceptor_ICJI::getFieldInClass(CORINFO_CLASS_HANDLE clsHnd, INT num)
{
mc->cr->AddCall("getFieldInClass");
CORINFO_FIELD_HANDLE temp = original_ICorJitInfo->getFieldInClass(clsHnd, num);
@@ -752,11 +681,7 @@ CORINFO_FIELD_HANDLE interceptor_ICJI::getFieldInClass(
return temp;
}
-BOOL interceptor_ICJI::checkMethodModifier(
- CORINFO_METHOD_HANDLE hMethod,
- LPCSTR modifier,
- BOOL fOptional
- )
+BOOL interceptor_ICJI::checkMethodModifier(CORINFO_METHOD_HANDLE hMethod, LPCSTR modifier, BOOL fOptional)
{
mc->cr->AddCall("checkMethodModifier");
BOOL result = original_ICorJitInfo->checkMethodModifier(hMethod, modifier, fOptional);
@@ -765,10 +690,8 @@ BOOL interceptor_ICJI::checkMethodModifier(
}
// returns the "NEW" helper optimized for "newCls."
-CorInfoHelpFunc interceptor_ICJI::getNewHelper(
- CORINFO_RESOLVED_TOKEN * pResolvedToken,
- CORINFO_METHOD_HANDLE callerHandle
- )
+CorInfoHelpFunc interceptor_ICJI::getNewHelper(CORINFO_RESOLVED_TOKEN* pResolvedToken,
+ CORINFO_METHOD_HANDLE callerHandle)
{
mc->cr->AddCall("getNewHelper");
CorInfoHelpFunc temp = original_ICorJitInfo->getNewHelper(pResolvedToken, callerHandle);
@@ -777,9 +700,7 @@ CorInfoHelpFunc interceptor_ICJI::getNewHelper(
}
// returns the newArr (1-Dim array) helper optimized for "arrayCls."
-CorInfoHelpFunc interceptor_ICJI::getNewArrHelper(
- CORINFO_CLASS_HANDLE arrayCls
- )
+CorInfoHelpFunc interceptor_ICJI::getNewArrHelper(CORINFO_CLASS_HANDLE arrayCls)
{
mc->cr->AddCall("getNewArrHelper");
CorInfoHelpFunc temp = original_ICorJitInfo->getNewArrHelper(arrayCls);
@@ -788,10 +709,7 @@ CorInfoHelpFunc interceptor_ICJI::getNewArrHelper(
}
// returns the optimized "IsInstanceOf" or "ChkCast" helper
-CorInfoHelpFunc interceptor_ICJI::getCastingHelper(
- CORINFO_RESOLVED_TOKEN * pResolvedToken,
- bool fThrowing
- )
+CorInfoHelpFunc interceptor_ICJI::getCastingHelper(CORINFO_RESOLVED_TOKEN* pResolvedToken, bool fThrowing)
{
mc->cr->AddCall("getCastingHelper");
CorInfoHelpFunc temp = original_ICorJitInfo->getCastingHelper(pResolvedToken, fThrowing);
@@ -800,9 +718,7 @@ CorInfoHelpFunc interceptor_ICJI::getCastingHelper(
}
// returns helper to trigger static constructor
-CorInfoHelpFunc interceptor_ICJI::getSharedCCtorHelper(
- CORINFO_CLASS_HANDLE clsHnd
- )
+CorInfoHelpFunc interceptor_ICJI::getSharedCCtorHelper(CORINFO_CLASS_HANDLE clsHnd)
{
mc->cr->AddCall("getSharedCCtorHelper");
CorInfoHelpFunc temp = original_ICorJitInfo->getSharedCCtorHelper(clsHnd);
@@ -810,9 +726,7 @@ CorInfoHelpFunc interceptor_ICJI::getSharedCCtorHelper(
return temp;
}
-CorInfoHelpFunc interceptor_ICJI::getSecurityPrologHelper(
- CORINFO_METHOD_HANDLE ftn
- )
+CorInfoHelpFunc interceptor_ICJI::getSecurityPrologHelper(CORINFO_METHOD_HANDLE ftn)
{
mc->cr->AddCall("getSecurityPrologHelper");
CorInfoHelpFunc temp = original_ICorJitInfo->getSecurityPrologHelper(ftn);
@@ -824,9 +738,7 @@ CorInfoHelpFunc interceptor_ICJI::getSecurityPrologHelper(
// a boxed<T> not a boxed Nullable<T>. This call allows the verifier
// to call back to the EE on the 'box' instruction and get the transformed
// type to use for verification.
-CORINFO_CLASS_HANDLE interceptor_ICJI::getTypeForBox(
- CORINFO_CLASS_HANDLE cls
- )
+CORINFO_CLASS_HANDLE interceptor_ICJI::getTypeForBox(CORINFO_CLASS_HANDLE cls)
{
mc->cr->AddCall("getTypeForBox");
CORINFO_CLASS_HANDLE temp = original_ICorJitInfo->getTypeForBox(cls);
@@ -837,9 +749,7 @@ CORINFO_CLASS_HANDLE interceptor_ICJI::getTypeForBox(
// returns the correct box helper for a particular class. Note
// that if this returns CORINFO_HELP_BOX, the JIT can assume
// 'standard' boxing (allocate object and copy), and optimize
-CorInfoHelpFunc interceptor_ICJI::getBoxHelper(
- CORINFO_CLASS_HANDLE cls
- )
+CorInfoHelpFunc interceptor_ICJI::getBoxHelper(CORINFO_CLASS_HANDLE cls)
{
mc->cr->AddCall("getBoxHelper");
CorInfoHelpFunc temp = original_ICorJitInfo->getBoxHelper(cls);
@@ -858,9 +768,7 @@ CorInfoHelpFunc interceptor_ICJI::getBoxHelper(
// (But must be able to always honor the non-copy style helper)
// The EE set 'helperCopies' on return to indicate what kind of
// helper has been created.
-CorInfoHelpFunc interceptor_ICJI::getUnBoxHelper(
- CORINFO_CLASS_HANDLE cls
- )
+CorInfoHelpFunc interceptor_ICJI::getUnBoxHelper(CORINFO_CLASS_HANDLE cls)
{
mc->cr->AddCall("getUnBoxHelper");
CorInfoHelpFunc temp = original_ICorJitInfo->getUnBoxHelper(cls);
@@ -868,12 +776,10 @@ CorInfoHelpFunc interceptor_ICJI::getUnBoxHelper(
return temp;
}
-bool interceptor_ICJI::getReadyToRunHelper(
- CORINFO_RESOLVED_TOKEN * pResolvedToken,
- CORINFO_LOOKUP_KIND * pGenericLookupKind,
- CorInfoHelpFunc id,
- CORINFO_CONST_LOOKUP * pLookup
- )
+bool interceptor_ICJI::getReadyToRunHelper(CORINFO_RESOLVED_TOKEN* pResolvedToken,
+ CORINFO_LOOKUP_KIND* pGenericLookupKind,
+ CorInfoHelpFunc id,
+ CORINFO_CONST_LOOKUP* pLookup)
{
mc->cr->AddCall("getReadyToRunHelper");
bool result = original_ICorJitInfo->getReadyToRunHelper(pResolvedToken, pGenericLookupKind, id, pLookup);
@@ -881,20 +787,16 @@ bool interceptor_ICJI::getReadyToRunHelper(
return result;
}
-void interceptor_ICJI::getReadyToRunDelegateCtorHelper(
- CORINFO_RESOLVED_TOKEN * pTargetMethod,
- CORINFO_CLASS_HANDLE delegateType,
- CORINFO_LOOKUP * pLookup
- )
+void interceptor_ICJI::getReadyToRunDelegateCtorHelper(CORINFO_RESOLVED_TOKEN* pTargetMethod,
+ CORINFO_CLASS_HANDLE delegateType,
+ CORINFO_LOOKUP* pLookup)
{
mc->cr->AddCall("getReadyToRunDelegateCtorHelper");
original_ICorJitInfo->getReadyToRunDelegateCtorHelper(pTargetMethod, delegateType, pLookup);
mc->recGetReadyToRunDelegateCtorHelper(pTargetMethod, delegateType, pLookup);
}
-const char* interceptor_ICJI::getHelperName(
- CorInfoHelpFunc funcNum
- )
+const char* interceptor_ICJI::getHelperName(CorInfoHelpFunc funcNum)
{
mc->cr->AddCall("getHelperName");
const char* temp = original_ICorJitInfo->getHelperName(funcNum);
@@ -908,12 +810,12 @@ const char* interceptor_ICJI::getHelperName(
//
// See code:ICorClassInfo#ClassConstruction.
CorInfoInitClassResult interceptor_ICJI::initClass(
- CORINFO_FIELD_HANDLE field, // Non-nullptr - inquire about cctor trigger before static field access
- // nullptr - inquire about cctor trigger in method prolog
- CORINFO_METHOD_HANDLE method, // Method referencing the field or prolog
- CORINFO_CONTEXT_HANDLE context, // Exact context of method
- BOOL speculative // TRUE means don't actually run it
- )
+ CORINFO_FIELD_HANDLE field, // Non-nullptr - inquire about cctor trigger before static field access
+ // nullptr - inquire about cctor trigger in method prolog
+ CORINFO_METHOD_HANDLE method, // Method referencing the field or prolog
+ CORINFO_CONTEXT_HANDLE context, // Exact context of method
+ BOOL speculative // TRUE means don't actually run it
+ )
{
mc->cr->AddCall("initClass");
CorInfoInitClassResult temp = original_ICorJitInfo->initClass(field, method, context, speculative);
@@ -931,9 +833,7 @@ CorInfoInitClassResult interceptor_ICJI::initClass(
// This is typically used to ensure value types are loaded before zapped
// code that manipulates them is executed, so that the GC can access information
// about those value types.
-void interceptor_ICJI::classMustBeLoadedBeforeCodeIsRun(
- CORINFO_CLASS_HANDLE cls
- )
+void interceptor_ICJI::classMustBeLoadedBeforeCodeIsRun(CORINFO_CLASS_HANDLE cls)
{
mc->cr->AddCall("classMustBeLoadedBeforeCodeIsRun");
original_ICorJitInfo->classMustBeLoadedBeforeCodeIsRun(cls);
@@ -941,9 +841,7 @@ void interceptor_ICJI::classMustBeLoadedBeforeCodeIsRun(
}
// returns the class handle for the special builtin classes
-CORINFO_CLASS_HANDLE interceptor_ICJI::getBuiltinClass (
- CorInfoClassId classId
- )
+CORINFO_CLASS_HANDLE interceptor_ICJI::getBuiltinClass(CorInfoClassId classId)
{
mc->cr->AddCall("getBuiltinClass");
CORINFO_CLASS_HANDLE temp = original_ICorJitInfo->getBuiltinClass(classId);
@@ -952,9 +850,7 @@ CORINFO_CLASS_HANDLE interceptor_ICJI::getBuiltinClass (
}
// "System.Int32" ==> CORINFO_TYPE_INT..
-CorInfoType interceptor_ICJI::getTypeForPrimitiveValueClass(
- CORINFO_CLASS_HANDLE cls
- )
+CorInfoType interceptor_ICJI::getTypeForPrimitiveValueClass(CORINFO_CLASS_HANDLE cls)
{
mc->cr->AddCall("getTypeForPrimitiveValueClass");
CorInfoType temp = original_ICorJitInfo->getTypeForPrimitiveValueClass(cls);
@@ -964,10 +860,9 @@ CorInfoType interceptor_ICJI::getTypeForPrimitiveValueClass(
// TRUE if child is a subtype of parent
// if parent is an interface, then does child implement / extend parent
-BOOL interceptor_ICJI::canCast(
- CORINFO_CLASS_HANDLE child, // subtype (extends parent)
- CORINFO_CLASS_HANDLE parent // base type
- )
+BOOL interceptor_ICJI::canCast(CORINFO_CLASS_HANDLE child, // subtype (extends parent)
+ CORINFO_CLASS_HANDLE parent // base type
+ )
{
mc->cr->AddCall("canCast");
BOOL temp = original_ICorJitInfo->canCast(child, parent);
@@ -976,10 +871,7 @@ BOOL interceptor_ICJI::canCast(
}
// TRUE if cls1 and cls2 are considered equivalent types.
-BOOL interceptor_ICJI::areTypesEquivalent(
- CORINFO_CLASS_HANDLE cls1,
- CORINFO_CLASS_HANDLE cls2
- )
+BOOL interceptor_ICJI::areTypesEquivalent(CORINFO_CLASS_HANDLE cls1, CORINFO_CLASS_HANDLE cls2)
{
mc->cr->AddCall("areTypesEquivalent");
BOOL temp = original_ICorJitInfo->areTypesEquivalent(cls1, cls2);
@@ -988,10 +880,7 @@ BOOL interceptor_ICJI::areTypesEquivalent(
}
// returns is the intersection of cls1 and cls2.
-CORINFO_CLASS_HANDLE interceptor_ICJI::mergeClasses(
- CORINFO_CLASS_HANDLE cls1,
- CORINFO_CLASS_HANDLE cls2
- )
+CORINFO_CLASS_HANDLE interceptor_ICJI::mergeClasses(CORINFO_CLASS_HANDLE cls1, CORINFO_CLASS_HANDLE cls2)
{
mc->cr->AddCall("mergeClasses");
CORINFO_CLASS_HANDLE temp = original_ICorJitInfo->mergeClasses(cls1, cls2);
@@ -1002,9 +891,7 @@ CORINFO_CLASS_HANDLE interceptor_ICJI::mergeClasses(
// Given a class handle, returns the Parent type.
// For COMObjectType, it returns Class Handle of System.Object.
// Returns 0 if System.Object is passed in.
-CORINFO_CLASS_HANDLE interceptor_ICJI::getParentType (
- CORINFO_CLASS_HANDLE cls
- )
+CORINFO_CLASS_HANDLE interceptor_ICJI::getParentType(CORINFO_CLASS_HANDLE cls)
{
mc->cr->AddCall("getParentType");
CORINFO_CLASS_HANDLE temp = original_ICorJitInfo->getParentType(cls);
@@ -1016,10 +903,7 @@ CORINFO_CLASS_HANDLE interceptor_ICJI::getParentType (
// not a primitive type, *clsRet will be set.
// Given an Array of Type Foo, returns Foo.
// Given BYREF Foo, returns Foo
-CorInfoType interceptor_ICJI::getChildType (
- CORINFO_CLASS_HANDLE clsHnd,
- CORINFO_CLASS_HANDLE *clsRet
- )
+CorInfoType interceptor_ICJI::getChildType(CORINFO_CLASS_HANDLE clsHnd, CORINFO_CLASS_HANDLE* clsRet)
{
mc->cr->AddCall("getChildType");
CorInfoType temp = original_ICorJitInfo->getChildType(clsHnd, clsRet);
@@ -1028,21 +912,16 @@ CorInfoType interceptor_ICJI::getChildType (
}
// Check constraints on type arguments of this class and parent classes
-BOOL interceptor_ICJI::satisfiesClassConstraints(
- CORINFO_CLASS_HANDLE cls
- )
+BOOL interceptor_ICJI::satisfiesClassConstraints(CORINFO_CLASS_HANDLE cls)
{
mc->cr->AddCall("satisfiesClassConstraints");
BOOL temp = original_ICorJitInfo->satisfiesClassConstraints(cls);
mc->recSatisfiesClassConstraints(cls, temp);
return temp;
-
}
// Check if this is a single dimensional array type
-BOOL interceptor_ICJI::isSDArray(
- CORINFO_CLASS_HANDLE cls
- )
+BOOL interceptor_ICJI::isSDArray(CORINFO_CLASS_HANDLE cls)
{
mc->cr->AddCall("isSDArray");
BOOL temp = original_ICorJitInfo->isSDArray(cls);
@@ -1051,9 +930,7 @@ BOOL interceptor_ICJI::isSDArray(
}
// Get the numbmer of dimensions in an array
-unsigned interceptor_ICJI::getArrayRank(
- CORINFO_CLASS_HANDLE cls
- )
+unsigned interceptor_ICJI::getArrayRank(CORINFO_CLASS_HANDLE cls)
{
mc->cr->AddCall("getArrayRank");
unsigned result = original_ICorJitInfo->getArrayRank(cls);
@@ -1062,27 +939,25 @@ unsigned interceptor_ICJI::getArrayRank(
}
// Get static field data for an array
-void * interceptor_ICJI::getArrayInitializationData(
- CORINFO_FIELD_HANDLE field,
- DWORD size
- )
+void* interceptor_ICJI::getArrayInitializationData(CORINFO_FIELD_HANDLE field, DWORD size)
{
mc->cr->AddCall("getArrayInitializationData");
- void *temp = original_ICorJitInfo->getArrayInitializationData(field, size);
+ void* temp = original_ICorJitInfo->getArrayInitializationData(field, size);
mc->recGetArrayInitializationData(field, size, temp);
return temp;
}
// Check Visibility rules.
CorInfoIsAccessAllowedResult interceptor_ICJI::canAccessClass(
- CORINFO_RESOLVED_TOKEN * pResolvedToken,
- CORINFO_METHOD_HANDLE callerHandle,
- CORINFO_HELPER_DESC *pAccessHelper /* If canAccessMethod returns something other
- than ALLOWED, then this is filled in. */
- )
+ CORINFO_RESOLVED_TOKEN* pResolvedToken,
+ CORINFO_METHOD_HANDLE callerHandle,
+ CORINFO_HELPER_DESC* pAccessHelper /* If canAccessMethod returns something other
+ than ALLOWED, then this is filled in. */
+ )
{
mc->cr->AddCall("canAccessClass");
- CorInfoIsAccessAllowedResult temp = original_ICorJitInfo->canAccessClass(pResolvedToken, callerHandle, pAccessHelper);
+ CorInfoIsAccessAllowedResult temp =
+ original_ICorJitInfo->canAccessClass(pResolvedToken, callerHandle, pAccessHelper);
mc->recCanAccessClass(pResolvedToken, callerHandle, pAccessHelper, temp);
return temp;
}
@@ -1095,10 +970,9 @@ CorInfoIsAccessAllowedResult interceptor_ICJI::canAccessClass(
// this function is for debugging only. It returns the field name
// and if 'moduleName' is non-null, it sets it to something that will
// says which method (a class name, or a module name)
-const char* interceptor_ICJI::getFieldName (
- CORINFO_FIELD_HANDLE ftn, /* IN */
- const char **moduleName /* OUT */
- )
+const char* interceptor_ICJI::getFieldName(CORINFO_FIELD_HANDLE ftn, /* IN */
+ const char** moduleName /* OUT */
+ )
{
mc->cr->AddCall("getFieldName");
const char* temp = original_ICorJitInfo->getFieldName(ftn, moduleName);
@@ -1107,9 +981,7 @@ const char* interceptor_ICJI::getFieldName (
}
// return class it belongs to
-CORINFO_CLASS_HANDLE interceptor_ICJI::getFieldClass (
- CORINFO_FIELD_HANDLE field
- )
+CORINFO_CLASS_HANDLE interceptor_ICJI::getFieldClass(CORINFO_FIELD_HANDLE field)
{
mc->cr->AddCall("getFieldClass");
CORINFO_CLASS_HANDLE temp = original_ICorJitInfo->getFieldClass(field);
@@ -1123,11 +995,10 @@ CORINFO_CLASS_HANDLE interceptor_ICJI::getFieldClass (
//
// 'memberParent' is typically only set when verifying. It should be the
// result of calling getMemberParent.
-CorInfoType interceptor_ICJI::getFieldType(
- CORINFO_FIELD_HANDLE field,
- CORINFO_CLASS_HANDLE *structType,
- CORINFO_CLASS_HANDLE memberParent/* IN */
- )
+CorInfoType interceptor_ICJI::getFieldType(CORINFO_FIELD_HANDLE field,
+ CORINFO_CLASS_HANDLE* structType,
+ CORINFO_CLASS_HANDLE memberParent /* IN */
+ )
{
mc->cr->AddCall("getFieldType");
CorInfoType temp = original_ICorJitInfo->getFieldType(field, structType, memberParent);
@@ -1136,9 +1007,7 @@ CorInfoType interceptor_ICJI::getFieldType(
}
// return the data member's instance offset
-unsigned interceptor_ICJI::getFieldOffset(
- CORINFO_FIELD_HANDLE field
- )
+unsigned interceptor_ICJI::getFieldOffset(CORINFO_FIELD_HANDLE field)
{
mc->cr->AddCall("getFieldOffset");
unsigned temp = original_ICorJitInfo->getFieldOffset(field);
@@ -1149,8 +1018,7 @@ unsigned interceptor_ICJI::getFieldOffset(
// TODO: jit64 should be switched to the same plan as the i386 jits - use
// getClassGClayout to figure out the need for writebarrier helper, and inline the copying.
// The interpretted value class copy is slow. Once this happens, USE_WRITE_BARRIER_HELPERS
-bool interceptor_ICJI::isWriteBarrierHelperRequired(
- CORINFO_FIELD_HANDLE field)
+bool interceptor_ICJI::isWriteBarrierHelperRequired(CORINFO_FIELD_HANDLE field)
{
mc->cr->AddCall("isWriteBarrierHelperRequired");
bool result = original_ICorJitInfo->isWriteBarrierHelperRequired(field);
@@ -1158,11 +1026,10 @@ bool interceptor_ICJI::isWriteBarrierHelperRequired(
return result;
}
-void interceptor_ICJI::getFieldInfo (CORINFO_RESOLVED_TOKEN * pResolvedToken,
- CORINFO_METHOD_HANDLE callerHandle,
- CORINFO_ACCESS_FLAGS flags,
- CORINFO_FIELD_INFO *pResult
- )
+void interceptor_ICJI::getFieldInfo(CORINFO_RESOLVED_TOKEN* pResolvedToken,
+ CORINFO_METHOD_HANDLE callerHandle,
+ CORINFO_ACCESS_FLAGS flags,
+ CORINFO_FIELD_INFO* pResult)
{
mc->cr->AddCall("getFieldInfo");
original_ICorJitInfo->getFieldInfo(pResolvedToken, callerHandle, flags, pResult);
@@ -1190,13 +1057,13 @@ bool interceptor_ICJI::isFieldStatic(CORINFO_FIELD_HANDLE fldHnd)
// Note that unless CORJIT_FLAG_DEBUG_CODE is specified, this function will
// be used only as a hint and the native compiler should not change its
// code generation.
-void interceptor_ICJI::getBoundaries(
- CORINFO_METHOD_HANDLE ftn, // [IN] method of interest
- unsigned int *cILOffsets, // [OUT] size of pILOffsets
- DWORD **pILOffsets, // [OUT] IL offsets of interest
- // jit MUST free with freeArray!
- ICorDebugInfo::BoundaryTypes *implictBoundaries // [OUT] tell jit, all boundries of this type
- )
+void interceptor_ICJI::getBoundaries(CORINFO_METHOD_HANDLE ftn, // [IN] method of interest
+ unsigned int* cILOffsets, // [OUT] size of pILOffsets
+ DWORD** pILOffsets, // [OUT] IL offsets of interest
+ // jit MUST free with freeArray!
+ ICorDebugInfo::BoundaryTypes* implictBoundaries // [OUT] tell jit, all boundries of
+ // this type
+ )
{
mc->cr->AddCall("getBoundaries");
original_ICorJitInfo->getBoundaries(ftn, cILOffsets, pILOffsets, implictBoundaries);
@@ -1210,16 +1077,16 @@ void interceptor_ICJI::getBoundaries(
// Note that debugger (and profiler) is assuming that all of the
// offsets form a contiguous block of memory, and that the
// OffsetMapping is sorted in order of increasing native offset.
-//Note - Ownership of pMap is transfered with this call. We need to record it before its passed on to the EE.
-void interceptor_ICJI::setBoundaries(
- CORINFO_METHOD_HANDLE ftn, // [IN] method of interest
- ULONG32 cMap, // [IN] size of pMap
- ICorDebugInfo::OffsetMapping *pMap // [IN] map including all points of interest.
- // jit allocated with allocateArray, EE frees
- )
+ //Note - Ownership of pMap is transfered with this call. We need to record it before its passed on to the EE.
+void interceptor_ICJI::setBoundaries(CORINFO_METHOD_HANDLE ftn, // [IN] method of interest
+ ULONG32 cMap, // [IN] size of pMap
+ ICorDebugInfo::OffsetMapping* pMap // [IN] map including all points of interest.
+ // jit allocated with allocateArray, EE
+ // frees
+ )
{
mc->cr->AddCall("setBoundaries");
- mc->cr->recSetBoundaries(ftn, cMap, pMap); //Since the EE frees, we've gotta record before its sent to the EE.
+ mc->cr->recSetBoundaries(ftn, cMap, pMap); // Since the EE frees, we've gotta record before its sent to the EE.
original_ICorJitInfo->setBoundaries(ftn, cMap, pMap);
}
@@ -1231,14 +1098,13 @@ void interceptor_ICJI::setBoundaries(
// Note that unless CORJIT_FLAG_DEBUG_CODE is specified, this function will
// be used only as a hint and the native compiler should not change its
// code generation.
-void interceptor_ICJI::getVars(
- CORINFO_METHOD_HANDLE ftn, // [IN] method of interest
- ULONG32 *cVars, // [OUT] size of 'vars'
- ICorDebugInfo::ILVarInfo **vars, // [OUT] scopes of variables of interest
- // jit MUST free with freeArray!
- bool *extendOthers // [OUT] it TRUE, then assume the scope
- // of unmentioned vars is entire method
- )
+void interceptor_ICJI::getVars(CORINFO_METHOD_HANDLE ftn, // [IN] method of interest
+ ULONG32* cVars, // [OUT] size of 'vars'
+ ICorDebugInfo::ILVarInfo** vars, // [OUT] scopes of variables of interest
+ // jit MUST free with freeArray!
+ bool* extendOthers // [OUT] it TRUE, then assume the scope
+ // of unmentioned vars is entire method
+ )
{
mc->cr->AddCall("getVars");
original_ICorJitInfo->getVars(ftn, cVars, vars, extendOthers);
@@ -1248,16 +1114,16 @@ void interceptor_ICJI::getVars(
// Report back to the EE the location of every variable.
// note that the JIT might split lifetimes into different
// locations etc.
-//Note - Ownership of vars is transfered with this call. We need to record it before its passed on to the EE.
-void interceptor_ICJI::setVars(
- CORINFO_METHOD_HANDLE ftn, // [IN] method of interest
- ULONG32 cVars, // [IN] size of 'vars'
- ICorDebugInfo::NativeVarInfo *vars // [IN] map telling where local vars are stored at what points
- // jit allocated with allocateArray, EE frees
- )
+ //Note - Ownership of vars is transfered with this call. We need to record it before its passed on to the EE.
+void interceptor_ICJI::setVars(CORINFO_METHOD_HANDLE ftn, // [IN] method of interest
+ ULONG32 cVars, // [IN] size of 'vars'
+ ICorDebugInfo::NativeVarInfo* vars // [IN] map telling where local vars are stored at
+ // what points
+ // jit allocated with allocateArray, EE frees
+ )
{
mc->cr->AddCall("setVars");
- mc->cr->recSetVars(ftn, cVars, vars); //Since the EE frees, we've gotta record before its sent to the EE.
+ mc->cr->recSetVars(ftn, cVars, vars); // Since the EE frees, we've gotta record before its sent to the EE.
original_ICorJitInfo->setVars(ftn, cVars, vars);
}
@@ -1265,9 +1131,7 @@ void interceptor_ICJI::setVars(
// Used to allocate memory that needs to handed to the EE.
// For eg, use this to allocated memory for reporting debug info,
// which will be handed to the EE by setVars() and setBoundaries()
-void * interceptor_ICJI::allocateArray(
- ULONG cBytes
- )
+void* interceptor_ICJI::allocateArray(ULONG cBytes)
{
mc->cr->AddCall("allocateArray");
return original_ICorJitInfo->allocateArray(cBytes);
@@ -1277,9 +1141,7 @@ void * interceptor_ICJI::allocateArray(
// For eg, The EE returns memory in getVars() and getBoundaries()
// to the JitCompiler, which the JitCompiler should release using
// freeArray()
-void interceptor_ICJI::freeArray(
- void *array
- )
+void interceptor_ICJI::freeArray(void* array)
{
mc->cr->AddCall("freeArray");
original_ICorJitInfo->freeArray(array);
@@ -1292,9 +1154,8 @@ void interceptor_ICJI::freeArray(
/*********************************************************************************/
// advance the pointer to the argument list.
// a ptr of 0, is special and always means the first argument
-CORINFO_ARG_LIST_HANDLE interceptor_ICJI::getArgNext (
- CORINFO_ARG_LIST_HANDLE args /* IN */
- )
+CORINFO_ARG_LIST_HANDLE interceptor_ICJI::getArgNext(CORINFO_ARG_LIST_HANDLE args /* IN */
+ )
{
mc->cr->AddCall("getArgNext");
CORINFO_ARG_LIST_HANDLE temp = original_ICorJitInfo->getArgNext(args);
@@ -1311,95 +1172,87 @@ CORINFO_ARG_LIST_HANDLE interceptor_ICJI::getArgNext (
// The return value is the type that is used for calling convention purposes
// (Thus if the EE wants a value class to be passed like an int, then it will
// return CORINFO_TYPE_INT
-CorInfoTypeWithMod interceptor_ICJI::getArgType (
- CORINFO_SIG_INFO* sig, /* IN */
- CORINFO_ARG_LIST_HANDLE args, /* IN */
- CORINFO_CLASS_HANDLE *vcTypeRet /* OUT */
- )
+CorInfoTypeWithMod interceptor_ICJI::getArgType(CORINFO_SIG_INFO* sig, /* IN */
+ CORINFO_ARG_LIST_HANDLE args, /* IN */
+ CORINFO_CLASS_HANDLE* vcTypeRet /* OUT */
+ )
{
- struct Param : FilterSuperPMIExceptionsParam_CaptureException {
+ struct Param : FilterSuperPMIExceptionsParam_CaptureException
+ {
interceptor_ICJI* pThis;
CORINFO_SIG_INFO* sig;
CORINFO_ARG_LIST_HANDLE args;
CORINFO_CLASS_HANDLE* vcTypeRet;
CorInfoTypeWithMod temp;
} param;
- param.pThis = this;
- param.sig = sig;
- param.args = args;
+ param.pThis = this;
+ param.sig = sig;
+ param.args = args;
param.vcTypeRet = vcTypeRet;
- param.temp = (CorInfoTypeWithMod)CORINFO_TYPE_UNDEF;
+ param.temp = (CorInfoTypeWithMod)CORINFO_TYPE_UNDEF;
- PAL_TRY(Param*, pOuterParam, &param)
- {
- PAL_TRY(Param*, pParam, pOuterParam)
- {
- pParam->pThis->mc->cr->AddCall("getArgType");
- pParam->temp = pParam->pThis->original_ICorJitInfo->getArgType(pParam->sig, pParam->args, pParam->vcTypeRet);
+ PAL_TRY(Param*, pOuterParam,
+ &param){PAL_TRY(Param*, pParam, pOuterParam){pParam->pThis->mc->cr->AddCall("getArgType");
+ pParam->temp = pParam->pThis->original_ICorJitInfo->getArgType(pParam->sig, pParam->args, pParam->vcTypeRet);
#ifdef fatMC
- CORINFO_CLASS_HANDLE temp3 = pParam->pThis->getArgClass(pParam->sig, pParam->args);
+ CORINFO_CLASS_HANDLE temp3 = pParam->pThis->getArgClass(pParam->sig, pParam->args);
#endif
- }
- PAL_EXCEPT_FILTER(FilterSuperPMIExceptions_CaptureExceptionAndContinue)
- {
- }
- PAL_ENDTRY
- }
- PAL_FINALLY
- {
- this->mc->recGetArgType(sig, args, vcTypeRet, param.temp, param.exceptionCode);
- }
- PAL_ENDTRY
+}
+PAL_EXCEPT_FILTER(FilterSuperPMIExceptions_CaptureExceptionAndContinue)
+{
+}
+PAL_ENDTRY
+}
+PAL_FINALLY
+{
+ this->mc->recGetArgType(sig, args, vcTypeRet, param.temp, param.exceptionCode);
+}
+PAL_ENDTRY
- return param.temp;
- }
+return param.temp;
+}
// If the Arg is a CORINFO_TYPE_CLASS fetch the class handle associated with it
-CORINFO_CLASS_HANDLE interceptor_ICJI::getArgClass (
- CORINFO_SIG_INFO* sig, /* IN */
- CORINFO_ARG_LIST_HANDLE args /* IN */
- )
+CORINFO_CLASS_HANDLE interceptor_ICJI::getArgClass(CORINFO_SIG_INFO* sig, /* IN */
+ CORINFO_ARG_LIST_HANDLE args /* IN */
+ )
{
- struct Param : FilterSuperPMIExceptionsParam_CaptureException {
+ struct Param : FilterSuperPMIExceptionsParam_CaptureException
+ {
interceptor_ICJI* pThis;
CORINFO_SIG_INFO* sig;
CORINFO_ARG_LIST_HANDLE args;
CORINFO_CLASS_HANDLE temp;
} param;
param.pThis = this;
- param.sig = sig;
- param.args = args;
- param.temp = 0;
+ param.sig = sig;
+ param.args = args;
+ param.temp = 0;
- PAL_TRY(Param*, pOuterParam, &param)
- {
- PAL_TRY(Param*, pParam, pOuterParam)
- {
- pParam->pThis->mc->cr->AddCall("getArgClass");
- pParam->temp = pParam->pThis->original_ICorJitInfo->getArgClass(pParam->sig, pParam->args);
- }
- PAL_EXCEPT_FILTER(FilterSuperPMIExceptions_CaptureExceptionAndContinue)
- {
- }
- PAL_ENDTRY
- }
- PAL_FINALLY
- {
- this->mc->recGetArgClass(sig, args, param.temp, param.exceptionCode);
+ PAL_TRY(Param*, pOuterParam,
+ &param){PAL_TRY(Param*, pParam, pOuterParam){pParam->pThis->mc->cr->AddCall("getArgClass");
+ pParam->temp = pParam->pThis->original_ICorJitInfo->getArgClass(pParam->sig, pParam->args);
+}
+PAL_EXCEPT_FILTER(FilterSuperPMIExceptions_CaptureExceptionAndContinue)
+{
+}
+PAL_ENDTRY
+}
+PAL_FINALLY
+{
+ this->mc->recGetArgClass(sig, args, param.temp, param.exceptionCode);
- //to build up a fat mc
- getClassName(param.temp);
- }
- PAL_ENDTRY
+ // to build up a fat mc
+ getClassName(param.temp);
+}
+PAL_ENDTRY
- return param.temp;
- }
+return param.temp;
+}
// Returns type of HFA for valuetype
-CorInfoType interceptor_ICJI::getHFAType (
- CORINFO_CLASS_HANDLE hClass
- )
+CorInfoType interceptor_ICJI::getHFAType(CORINFO_CLASS_HANDLE hClass)
{
mc->cr->AddCall("getHFAType");
CorInfoType temp = original_ICorJitInfo->getHFAType(hClass);
@@ -1413,9 +1266,7 @@ CorInfoType interceptor_ICJI::getHFAType (
* with code EXCEPTION_COMPLUS is caught.
*****************************************************************************/
// Returns the HRESULT of the current exception
-HRESULT interceptor_ICJI::GetErrorHRESULT(
- struct _EXCEPTION_POINTERS *pExceptionPointers
- )
+HRESULT interceptor_ICJI::GetErrorHRESULT(struct _EXCEPTION_POINTERS* pExceptionPointers)
{
mc->cr->AddCall("GetErrorHRESULT");
return original_ICorJitInfo->GetErrorHRESULT(pExceptionPointers);
@@ -1424,10 +1275,7 @@ HRESULT interceptor_ICJI::GetErrorHRESULT(
// Fetches the message of the current exception
// Returns the size of the message (including terminating null). This can be
// greater than bufferLength if the buffer is insufficient.
-ULONG interceptor_ICJI::GetErrorMessage(
- __inout_ecount(bufferLength) LPWSTR buffer,
- ULONG bufferLength
- )
+ULONG interceptor_ICJI::GetErrorMessage(__inout_ecount(bufferLength) LPWSTR buffer, ULONG bufferLength)
{
mc->cr->AddCall("GetErrorMessage");
return original_ICorJitInfo->GetErrorMessage(buffer, bufferLength);
@@ -1438,9 +1286,7 @@ ULONG interceptor_ICJI::GetErrorMessage(
// returns EXCEPTION_CONTINUE_SEARCH if exception must always be handled by the EE
// things like ThreadStoppedException ...
// returns EXCEPTION_CONTINUE_EXECUTION if exception is fixed up by the EE
-int interceptor_ICJI::FilterException(
- struct _EXCEPTION_POINTERS *pExceptionPointers
- )
+int interceptor_ICJI::FilterException(struct _EXCEPTION_POINTERS* pExceptionPointers)
{
mc->cr->AddCall("FilterException");
int temp = original_ICorJitInfo->FilterException(pExceptionPointers);
@@ -1449,26 +1295,22 @@ int interceptor_ICJI::FilterException(
}
// Cleans up internal EE tracking when an exception is caught.
-void interceptor_ICJI::HandleException(
- struct _EXCEPTION_POINTERS *pExceptionPointers
- )
+void interceptor_ICJI::HandleException(struct _EXCEPTION_POINTERS* pExceptionPointers)
{
- //bswHack?
+ // bswHack?
mc->cr->AddCall("HandleException");
original_ICorJitInfo->HandleException(pExceptionPointers);
mc->recHandleException(pExceptionPointers);
}
-void interceptor_ICJI::ThrowExceptionForJitResult(
- HRESULT result)
+void interceptor_ICJI::ThrowExceptionForJitResult(HRESULT result)
{
mc->cr->AddCall("ThrowExceptionForJitResult");
original_ICorJitInfo->ThrowExceptionForJitResult(result);
}
-//Throws an exception defined by the given throw helper.
-void interceptor_ICJI::ThrowExceptionForHelper(
- const CORINFO_HELPER_DESC * throwHelper)
+// Throws an exception defined by the given throw helper.
+void interceptor_ICJI::ThrowExceptionForHelper(const CORINFO_HELPER_DESC* throwHelper)
{
mc->cr->AddCall("ThrowExceptionForHelper");
original_ICorJitInfo->ThrowExceptionForHelper(throwHelper);
@@ -1481,9 +1323,7 @@ void interceptor_ICJI::ThrowExceptionForHelper(
* assuming that all code versions are identical each time.)
*****************************************************************************/
// Return details about EE internal data structures
-void interceptor_ICJI::getEEInfo(
- CORINFO_EE_INFO *pEEInfoOut
- )
+void interceptor_ICJI::getEEInfo(CORINFO_EE_INFO* pEEInfoOut)
{
mc->cr->AddCall("getEEInfo");
original_ICorJitInfo->getEEInfo(pEEInfoOut);
@@ -1493,10 +1333,10 @@ void interceptor_ICJI::getEEInfo(
// Returns name of the JIT timer log
LPCWSTR interceptor_ICJI::getJitTimeLogFilename()
{
- mc->cr->AddCall("getJitTimeLogFilename");
- LPCWSTR temp = original_ICorJitInfo->getJitTimeLogFilename();
- mc->recGetJitTimeLogFilename(temp);
- return temp;
+ mc->cr->AddCall("getJitTimeLogFilename");
+ LPCWSTR temp = original_ICorJitInfo->getJitTimeLogFilename();
+ mc->recGetJitTimeLogFilename(temp);
+ return temp;
}
/*********************************************************************************/
@@ -1506,37 +1346,32 @@ LPCWSTR interceptor_ICJI::getJitTimeLogFilename()
/*********************************************************************************/
// this function is for debugging only. Returns method token.
// Returns mdMethodDefNil for dynamic methods.
-mdMethodDef interceptor_ICJI::getMethodDefFromMethod(
- CORINFO_METHOD_HANDLE hMethod
- )
+mdMethodDef interceptor_ICJI::getMethodDefFromMethod(CORINFO_METHOD_HANDLE hMethod)
{
mc->cr->AddCall("getMethodDefFromMethod");
mdMethodDef result = original_ICorJitInfo->getMethodDefFromMethod(hMethod);
mc->recGetMethodDefFromMethod(hMethod, result);
return result;
-
}
// this function is for debugging only. It returns the method name
// and if 'moduleName' is non-null, it sets it to something that will
// says which method (a class name, or a module name)
-const char* interceptor_ICJI::getMethodName (
- CORINFO_METHOD_HANDLE ftn, /* IN */
- const char **moduleName /* OUT */
- )
+const char* interceptor_ICJI::getMethodName(CORINFO_METHOD_HANDLE ftn, /* IN */
+ const char** moduleName /* OUT */
+ )
{
mc->cr->AddCall("getMethodName");
const char* temp = original_ICorJitInfo->getMethodName(ftn, moduleName);
- mc->recGetMethodName(ftn, (char *)temp, moduleName);
+ mc->recGetMethodName(ftn, (char*)temp, moduleName);
return temp;
}
// this function is for debugging only. It returns a value that
// is will always be the same for a given method. It is used
// to implement the 'jitRange' functionality
-unsigned interceptor_ICJI::getMethodHash (
- CORINFO_METHOD_HANDLE ftn /* IN */
- )
+unsigned interceptor_ICJI::getMethodHash(CORINFO_METHOD_HANDLE ftn /* IN */
+ )
{
mc->cr->AddCall("getMethodHash");
unsigned temp = original_ICorJitInfo->getMethodHash(ftn);
@@ -1545,12 +1380,11 @@ unsigned interceptor_ICJI::getMethodHash (
}
// this function is for debugging only.
-size_t interceptor_ICJI::findNameOfToken (
- CORINFO_MODULE_HANDLE module, /* IN */
- mdToken metaTOK, /* IN */
- __out_ecount (FQNameCapacity) char * szFQName, /* OUT */
- size_t FQNameCapacity /* IN */
- )
+size_t interceptor_ICJI::findNameOfToken(CORINFO_MODULE_HANDLE module, /* IN */
+ mdToken metaTOK, /* IN */
+ __out_ecount(FQNameCapacity) char* szFQName, /* OUT */
+ size_t FQNameCapacity /* IN */
+ )
{
mc->cr->AddCall("findNameOfToken");
size_t result = original_ICorJitInfo->findNameOfToken(module, metaTOK, szFQName, FQNameCapacity);
@@ -1559,20 +1393,18 @@ size_t interceptor_ICJI::findNameOfToken (
}
bool interceptor_ICJI::getSystemVAmd64PassStructInRegisterDescriptor(
- /* IN */ CORINFO_CLASS_HANDLE structHnd,
- /* OUT */ SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR* structPassInRegDescPtr
- )
+ /* IN */ CORINFO_CLASS_HANDLE structHnd,
+ /* OUT */ SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR* structPassInRegDescPtr)
{
mc->cr->AddCall("getSystemVAmd64PassStructInRegisterDescriptor");
- bool result = original_ICorJitInfo->getSystemVAmd64PassStructInRegisterDescriptor(structHnd, structPassInRegDescPtr);
+ bool result =
+ original_ICorJitInfo->getSystemVAmd64PassStructInRegisterDescriptor(structHnd, structPassInRegDescPtr);
mc->recGetSystemVAmd64PassStructInRegisterDescriptor(structHnd, structPassInRegDescPtr, result);
return result;
}
-//Stuff on ICorDynamicInfo
-DWORD interceptor_ICJI::getThreadTLSIndex(
- void **ppIndirection
- )
+// Stuff on ICorDynamicInfo
+DWORD interceptor_ICJI::getThreadTLSIndex(void** ppIndirection)
{
mc->cr->AddCall("getThreadTLSIndex");
DWORD temp = original_ICorJitInfo->getThreadTLSIndex(ppIndirection);
@@ -1580,9 +1412,7 @@ DWORD interceptor_ICJI::getThreadTLSIndex(
return temp;
}
-const void * interceptor_ICJI::getInlinedCallFrameVptr(
- void **ppIndirection
- )
+const void* interceptor_ICJI::getInlinedCallFrameVptr(void** ppIndirection)
{
mc->cr->AddCall("getInlinedCallFrameVptr");
const void* temp = original_ICorJitInfo->getInlinedCallFrameVptr(ppIndirection);
@@ -1590,30 +1420,25 @@ const void * interceptor_ICJI::getInlinedCallFrameVptr(
return temp;
}
-LONG * interceptor_ICJI::getAddrOfCaptureThreadGlobal(
- void **ppIndirection
- )
+LONG* interceptor_ICJI::getAddrOfCaptureThreadGlobal(void** ppIndirection)
{
mc->cr->AddCall("getAddrOfCaptureThreadGlobal");
- LONG * temp = original_ICorJitInfo->getAddrOfCaptureThreadGlobal(ppIndirection);
+ LONG* temp = original_ICorJitInfo->getAddrOfCaptureThreadGlobal(ppIndirection);
mc->recGetAddrOfCaptureThreadGlobal(ppIndirection, temp);
return temp;
}
-SIZE_T* interceptor_ICJI::getAddrModuleDomainID(CORINFO_MODULE_HANDLE module)
+SIZE_T* interceptor_ICJI::getAddrModuleDomainID(CORINFO_MODULE_HANDLE module)
{
mc->cr->AddCall("getAddrModuleDomainID");
return original_ICorJitInfo->getAddrModuleDomainID(module);
}
// return the native entry point to an EE helper (see CorInfoHelpFunc)
-void* interceptor_ICJI::getHelperFtn (
- CorInfoHelpFunc ftnNum,
- void **ppIndirection
- )
+void* interceptor_ICJI::getHelperFtn(CorInfoHelpFunc ftnNum, void** ppIndirection)
{
mc->cr->AddCall("getHelperFtn");
- void *temp = original_ICorJitInfo->getHelperFtn(ftnNum, ppIndirection);
+ void* temp = original_ICorJitInfo->getHelperFtn(ftnNum, ppIndirection);
mc->recGetHelperFtn(ftnNum, ppIndirection, temp);
return temp;
}
@@ -1621,10 +1446,9 @@ void* interceptor_ICJI::getHelperFtn (
// return a callable address of the function (native code). This function
// may return a different value (depending on whether the method has
// been JITed or not.
-void interceptor_ICJI::getFunctionEntryPoint(
- CORINFO_METHOD_HANDLE ftn, /* IN */
- CORINFO_CONST_LOOKUP * pResult, /* OUT */
- CORINFO_ACCESS_FLAGS accessFlags)
+void interceptor_ICJI::getFunctionEntryPoint(CORINFO_METHOD_HANDLE ftn, /* IN */
+ CORINFO_CONST_LOOKUP* pResult, /* OUT */
+ CORINFO_ACCESS_FLAGS accessFlags)
{
mc->cr->AddCall("getFunctionEntryPoint");
original_ICorJitInfo->getFunctionEntryPoint(ftn, pResult, accessFlags);
@@ -1634,9 +1458,7 @@ void interceptor_ICJI::getFunctionEntryPoint(
// return a directly callable address. This can be used similarly to the
// value returned by getFunctionEntryPoint() except that it is
// guaranteed to be multi callable entrypoint.
-void interceptor_ICJI::getFunctionFixedEntryPoint(
- CORINFO_METHOD_HANDLE ftn,
- CORINFO_CONST_LOOKUP * pResult)
+void interceptor_ICJI::getFunctionFixedEntryPoint(CORINFO_METHOD_HANDLE ftn, CORINFO_CONST_LOOKUP* pResult)
{
mc->cr->AddCall("getFunctionFixedEntryPoint");
original_ICorJitInfo->getFunctionFixedEntryPoint(ftn, pResult);
@@ -1644,13 +1466,10 @@ void interceptor_ICJI::getFunctionFixedEntryPoint(
}
// get the synchronization handle that is passed to monXstatic function
-void* interceptor_ICJI::getMethodSync(
- CORINFO_METHOD_HANDLE ftn,
- void **ppIndirection
- )
+void* interceptor_ICJI::getMethodSync(CORINFO_METHOD_HANDLE ftn, void** ppIndirection)
{
mc->cr->AddCall("getMethodSync");
- void *temp = original_ICorJitInfo->getMethodSync(ftn, ppIndirection);
+ void* temp = original_ICorJitInfo->getMethodSync(ftn, ppIndirection);
mc->recGetMethodSync(ftn, ppIndirection, temp);
return temp;
}
@@ -1661,9 +1480,7 @@ void* interceptor_ICJI::getMethodSync(
// get slow lazy string literal helper to use (CORINFO_HELP_STRCNS*).
// Returns CORINFO_HELP_UNDEF if lazy string literal helper cannot be used.
-CorInfoHelpFunc interceptor_ICJI::getLazyStringLiteralHelper(
- CORINFO_MODULE_HANDLE handle
- )
+CorInfoHelpFunc interceptor_ICJI::getLazyStringLiteralHelper(CORINFO_MODULE_HANDLE handle)
{
mc->cr->AddCall("getLazyStringLiteralHelper");
CorInfoHelpFunc temp = original_ICorJitInfo->getLazyStringLiteralHelper(handle);
@@ -1671,10 +1488,7 @@ CorInfoHelpFunc interceptor_ICJI::getLazyStringLiteralHelper(
return temp;
}
-CORINFO_MODULE_HANDLE interceptor_ICJI::embedModuleHandle(
- CORINFO_MODULE_HANDLE handle,
- void **ppIndirection
- )
+CORINFO_MODULE_HANDLE interceptor_ICJI::embedModuleHandle(CORINFO_MODULE_HANDLE handle, void** ppIndirection)
{
mc->cr->AddCall("embedModuleHandle");
CORINFO_MODULE_HANDLE temp = original_ICorJitInfo->embedModuleHandle(handle, ppIndirection);
@@ -1682,10 +1496,7 @@ CORINFO_MODULE_HANDLE interceptor_ICJI::embedModuleHandle(
return temp;
}
-CORINFO_CLASS_HANDLE interceptor_ICJI::embedClassHandle(
- CORINFO_CLASS_HANDLE handle,
- void **ppIndirection
- )
+CORINFO_CLASS_HANDLE interceptor_ICJI::embedClassHandle(CORINFO_CLASS_HANDLE handle, void** ppIndirection)
{
mc->cr->AddCall("embedClassHandle");
CORINFO_CLASS_HANDLE temp = original_ICorJitInfo->embedClassHandle(handle, ppIndirection);
@@ -1693,10 +1504,7 @@ CORINFO_CLASS_HANDLE interceptor_ICJI::embedClassHandle(
return temp;
}
-CORINFO_METHOD_HANDLE interceptor_ICJI::embedMethodHandle(
- CORINFO_METHOD_HANDLE handle,
- void **ppIndirection
- )
+CORINFO_METHOD_HANDLE interceptor_ICJI::embedMethodHandle(CORINFO_METHOD_HANDLE handle, void** ppIndirection)
{
mc->cr->AddCall("embedMethodHandle");
CORINFO_METHOD_HANDLE temp = original_ICorJitInfo->embedMethodHandle(handle, ppIndirection);
@@ -1704,10 +1512,7 @@ CORINFO_METHOD_HANDLE interceptor_ICJI::embedMethodHandle(
return temp;
}
-CORINFO_FIELD_HANDLE interceptor_ICJI::embedFieldHandle(
- CORINFO_FIELD_HANDLE handle,
- void **ppIndirection
- )
+CORINFO_FIELD_HANDLE interceptor_ICJI::embedFieldHandle(CORINFO_FIELD_HANDLE handle, void** ppIndirection)
{
mc->cr->AddCall("embedFieldHandle");
CORINFO_FIELD_HANDLE temp = original_ICorJitInfo->embedFieldHandle(handle, ppIndirection);
@@ -1722,10 +1527,10 @@ CORINFO_FIELD_HANDLE interceptor_ICJI::embedFieldHandle(
// code is shared and the token contains generic parameters)
// then indicate how the handle should be looked up at run-time.
//
-void interceptor_ICJI::embedGenericHandle(
- CORINFO_RESOLVED_TOKEN * pResolvedToken,
- BOOL fEmbedParent, // TRUE - embeds parent type handle of the field/method handle
- CORINFO_GENERICHANDLE_RESULT * pResult)
+void interceptor_ICJI::embedGenericHandle(CORINFO_RESOLVED_TOKEN* pResolvedToken,
+ BOOL fEmbedParent, // TRUE - embeds parent type handle of the field/method
+ // handle
+ CORINFO_GENERICHANDLE_RESULT* pResult)
{
mc->cr->AddCall("embedGenericHandle");
original_ICorJitInfo->embedGenericHandle(pResolvedToken, fEmbedParent, pResult);
@@ -1739,9 +1544,7 @@ void interceptor_ICJI::embedGenericHandle(
// CORINFO_LOOKUP_THISOBJ use vtable pointer of 'this' param
// CORINFO_LOOKUP_CLASSPARAM use vtable hidden param
// CORINFO_LOOKUP_METHODPARAM use enclosing type of method-desc hidden param
-CORINFO_LOOKUP_KIND interceptor_ICJI::getLocationOfThisType(
- CORINFO_METHOD_HANDLE context
- )
+CORINFO_LOOKUP_KIND interceptor_ICJI::getLocationOfThisType(CORINFO_METHOD_HANDLE context)
{
mc->cr->AddCall("getLocationOfThisType");
CORINFO_LOOKUP_KIND temp = original_ICorJitInfo->getLocationOfThisType(context);
@@ -1750,34 +1553,25 @@ CORINFO_LOOKUP_KIND interceptor_ICJI::getLocationOfThisType(
}
// return the unmanaged target *if method has already been prelinked.*
-void* interceptor_ICJI::getPInvokeUnmanagedTarget(
- CORINFO_METHOD_HANDLE method,
- void **ppIndirection
- )
+void* interceptor_ICJI::getPInvokeUnmanagedTarget(CORINFO_METHOD_HANDLE method, void** ppIndirection)
{
mc->cr->AddCall("getPInvokeUnmanagedTarget");
- void *result = original_ICorJitInfo->getPInvokeUnmanagedTarget(method, ppIndirection);
+ void* result = original_ICorJitInfo->getPInvokeUnmanagedTarget(method, ppIndirection);
mc->recGetPInvokeUnmanagedTarget(method, ppIndirection, result);
return result;
}
// return address of fixup area for late-bound PInvoke calls.
-void* interceptor_ICJI::getAddressOfPInvokeFixup(
- CORINFO_METHOD_HANDLE method,
- void **ppIndirection
- )
+void* interceptor_ICJI::getAddressOfPInvokeFixup(CORINFO_METHOD_HANDLE method, void** ppIndirection)
{
mc->cr->AddCall("getAddressOfPInvokeFixup");
- void *temp = original_ICorJitInfo->getAddressOfPInvokeFixup(method, ppIndirection);
+ void* temp = original_ICorJitInfo->getAddressOfPInvokeFixup(method, ppIndirection);
mc->recGetAddressOfPInvokeFixup(method, ppIndirection, temp);
return temp;
}
// return address of fixup area for late-bound PInvoke calls.
-void interceptor_ICJI::getAddressOfPInvokeTarget(
- CORINFO_METHOD_HANDLE method,
- CORINFO_CONST_LOOKUP *pLookup
- )
+void interceptor_ICJI::getAddressOfPInvokeTarget(CORINFO_METHOD_HANDLE method, CORINFO_CONST_LOOKUP* pLookup)
{
mc->cr->AddCall("getAddressOfPInvokeTarget");
original_ICorJitInfo->getAddressOfPInvokeTarget(method, pLookup);
@@ -1786,10 +1580,7 @@ void interceptor_ICJI::getAddressOfPInvokeTarget(
// Generate a cookie based on the signature that would needs to be passed
// to CORINFO_HELP_PINVOKE_CALLI
-LPVOID interceptor_ICJI::GetCookieForPInvokeCalliSig(
- CORINFO_SIG_INFO* szMetaSig,
- void ** ppIndirection
- )
+LPVOID interceptor_ICJI::GetCookieForPInvokeCalliSig(CORINFO_SIG_INFO* szMetaSig, void** ppIndirection)
{
mc->cr->AddCall("GetCookieForPInvokeCalliSig");
LPVOID temp = original_ICorJitInfo->GetCookieForPInvokeCalliSig(szMetaSig, ppIndirection);
@@ -1799,9 +1590,7 @@ LPVOID interceptor_ICJI::GetCookieForPInvokeCalliSig(
// returns true if a VM cookie can be generated for it (might be false due to cross-module
// inlining, in which case the inlining should be aborted)
-bool interceptor_ICJI::canGetCookieForPInvokeCalliSig(
- CORINFO_SIG_INFO* szMetaSig
- )
+bool interceptor_ICJI::canGetCookieForPInvokeCalliSig(CORINFO_SIG_INFO* szMetaSig)
{
mc->cr->AddCall("canGetCookieForPInvokeCalliSig");
bool temp = original_ICorJitInfo->canGetCookieForPInvokeCalliSig(szMetaSig);
@@ -1811,10 +1600,8 @@ bool interceptor_ICJI::canGetCookieForPInvokeCalliSig(
// Gets a handle that is checked to see if the current method is
// included in "JustMyCode"
-CORINFO_JUST_MY_CODE_HANDLE interceptor_ICJI::getJustMyCodeHandle(
- CORINFO_METHOD_HANDLE method,
- CORINFO_JUST_MY_CODE_HANDLE**ppIndirection
- )
+CORINFO_JUST_MY_CODE_HANDLE interceptor_ICJI::getJustMyCodeHandle(CORINFO_METHOD_HANDLE method,
+ CORINFO_JUST_MY_CODE_HANDLE** ppIndirection)
{
mc->cr->AddCall("getJustMyCodeHandle");
CORINFO_JUST_MY_CODE_HANDLE temp = original_ICorJitInfo->getJustMyCodeHandle(method, ppIndirection);
@@ -1825,11 +1612,7 @@ CORINFO_JUST_MY_CODE_HANDLE interceptor_ICJI::getJustMyCodeHandle(
// Gets a method handle that can be used to correlate profiling data.
// This is the IP of a native method, or the address of the descriptor struct
// for IL. Always guaranteed to be unique per process, and not to move. */
-void interceptor_ICJI::GetProfilingHandle(
- BOOL *pbHookFunction,
- void **pProfilerHandle,
- BOOL *pbIndirectedHandles
- )
+void interceptor_ICJI::GetProfilingHandle(BOOL* pbHookFunction, void** pProfilerHandle, BOOL* pbIndirectedHandles)
{
mc->cr->AddCall("GetProfilingHandle");
original_ICorJitInfo->GetProfilingHandle(pbHookFunction, pProfilerHandle, pbIndirectedHandles);
@@ -1838,19 +1621,19 @@ void interceptor_ICJI::GetProfilingHandle(
// Returns instructions on how to make the call. See code:CORINFO_CALL_INFO for possible return values.
void interceptor_ICJI::getCallInfo(
- // Token info
- CORINFO_RESOLVED_TOKEN * pResolvedToken,
- //Generics info
- CORINFO_RESOLVED_TOKEN * pConstrainedResolvedToken,
- //Security info
- CORINFO_METHOD_HANDLE callerHandle,
- //Jit info
- CORINFO_CALLINFO_FLAGS flags,
- //out params
- CORINFO_CALL_INFO *pResult
- )
-{
- struct Param : FilterSuperPMIExceptionsParam_CaptureException {
+ // Token info
+ CORINFO_RESOLVED_TOKEN* pResolvedToken,
+ // Generics info
+ CORINFO_RESOLVED_TOKEN* pConstrainedResolvedToken,
+ // Security info
+ CORINFO_METHOD_HANDLE callerHandle,
+ // Jit info
+ CORINFO_CALLINFO_FLAGS flags,
+ // out params
+ CORINFO_CALL_INFO* pResult)
+{
+ struct Param : FilterSuperPMIExceptionsParam_CaptureException
+ {
interceptor_ICJI* pThis;
CORINFO_RESOLVED_TOKEN* pResolvedToken;
CORINFO_RESOLVED_TOKEN* pConstrainedResolvedToken;
@@ -1858,34 +1641,32 @@ void interceptor_ICJI::getCallInfo(
CORINFO_CALLINFO_FLAGS flags;
CORINFO_CALL_INFO* pResult;
} param;
- param.pThis = this;
- param.pResolvedToken = pResolvedToken;
+ param.pThis = this;
+ param.pResolvedToken = pResolvedToken;
param.pConstrainedResolvedToken = pConstrainedResolvedToken;
- param.callerHandle = callerHandle;
- param.flags = flags;
- param.pResult = pResult;
+ param.callerHandle = callerHandle;
+ param.flags = flags;
+ param.pResult = pResult;
- PAL_TRY(Param*, pOuterParam, &param)
- {
- PAL_TRY(Param*, pParam, pOuterParam)
- {
- pParam->pThis->mc->cr->AddCall("getCallInfo");
- pParam->pThis->original_ICorJitInfo->getCallInfo(pParam->pResolvedToken, pParam->pConstrainedResolvedToken, pParam->callerHandle, pParam->flags, pParam->pResult);
- }
- PAL_EXCEPT_FILTER(FilterSuperPMIExceptions_CaptureExceptionAndContinue)
- {
- }
- PAL_ENDTRY
- }
- PAL_FINALLY
- {
- this->mc->recGetCallInfo(pResolvedToken, pConstrainedResolvedToken, callerHandle, flags, pResult, param.exceptionCode);
- }
- PAL_ENDTRY
- }
+ PAL_TRY(Param*, pOuterParam,
+ &param){PAL_TRY(Param*, pParam, pOuterParam){pParam->pThis->mc->cr->AddCall("getCallInfo");
+ pParam->pThis->original_ICorJitInfo->getCallInfo(pParam->pResolvedToken, pParam->pConstrainedResolvedToken,
+ pParam->callerHandle, pParam->flags, pParam->pResult);
+}
+PAL_EXCEPT_FILTER(FilterSuperPMIExceptions_CaptureExceptionAndContinue)
+{
+}
+PAL_ENDTRY
+}
+PAL_FINALLY
+{
+ this->mc->recGetCallInfo(pResolvedToken, pConstrainedResolvedToken, callerHandle, flags, pResult,
+ param.exceptionCode);
+}
+PAL_ENDTRY
+}
-BOOL interceptor_ICJI::canAccessFamily(CORINFO_METHOD_HANDLE hCaller,
- CORINFO_CLASS_HANDLE hInstanceType)
+BOOL interceptor_ICJI::canAccessFamily(CORINFO_METHOD_HANDLE hCaller, CORINFO_CLASS_HANDLE hInstanceType)
{
mc->cr->AddCall("canAccessFamily");
BOOL temp = original_ICorJitInfo->canAccessFamily(hCaller, hInstanceType);
@@ -1902,10 +1683,7 @@ BOOL interceptor_ICJI::isRIDClassDomainID(CORINFO_CLASS_HANDLE cls)
}
// returns the class's domain ID for accessing shared statics
-unsigned interceptor_ICJI::getClassDomainID (
- CORINFO_CLASS_HANDLE cls,
- void **ppIndirection
- )
+unsigned interceptor_ICJI::getClassDomainID(CORINFO_CLASS_HANDLE cls, void** ppIndirection)
{
mc->cr->AddCall("getClassDomainID");
unsigned temp = original_ICorJitInfo->getClassDomainID(cls, ppIndirection);
@@ -1914,26 +1692,20 @@ unsigned interceptor_ICJI::getClassDomainID (
}
// return the data's address (for static fields only)
-void* interceptor_ICJI::getFieldAddress(
- CORINFO_FIELD_HANDLE field,
- void **ppIndirection
- )
+void* interceptor_ICJI::getFieldAddress(CORINFO_FIELD_HANDLE field, void** ppIndirection)
{
mc->cr->AddCall("getFieldAddress");
- void *temp = original_ICorJitInfo->getFieldAddress(field, ppIndirection);
+ void* temp = original_ICorJitInfo->getFieldAddress(field, ppIndirection);
- //Figure out the element type so we know how much we can load
+ // Figure out the element type so we know how much we can load
CORINFO_CLASS_HANDLE cch;
- CorInfoType cit = getFieldType(field, &cch, NULL);
+ CorInfoType cit = getFieldType(field, &cch, NULL);
mc->recGetFieldAddress(field, ppIndirection, temp, cit);
return temp;
}
// registers a vararg sig & returns a VM cookie for it (which can contain other stuff)
-CORINFO_VARARGS_HANDLE interceptor_ICJI::getVarArgsHandle(
- CORINFO_SIG_INFO *pSig,
- void **ppIndirection
- )
+CORINFO_VARARGS_HANDLE interceptor_ICJI::getVarArgsHandle(CORINFO_SIG_INFO* pSig, void** ppIndirection)
{
mc->cr->AddCall("getVarArgsHandle");
CORINFO_VARARGS_HANDLE temp = original_ICorJitInfo->getVarArgsHandle(pSig, ppIndirection);
@@ -1943,9 +1715,7 @@ CORINFO_VARARGS_HANDLE interceptor_ICJI::getVarArgsHandle(
// returns true if a VM cookie can be generated for it (might be false due to cross-module
// inlining, in which case the inlining should be aborted)
-bool interceptor_ICJI::canGetVarArgsHandle(
- CORINFO_SIG_INFO *pSig
- )
+bool interceptor_ICJI::canGetVarArgsHandle(CORINFO_SIG_INFO* pSig)
{
mc->cr->AddCall("canGetVarArgsHandle");
bool temp = original_ICorJitInfo->canGetVarArgsHandle(pSig);
@@ -1954,11 +1724,7 @@ bool interceptor_ICJI::canGetVarArgsHandle(
}
// Allocate a string literal on the heap and return a handle to it
-InfoAccessType interceptor_ICJI::constructStringLiteral(
- CORINFO_MODULE_HANDLE module,
- mdToken metaTok,
- void **ppValue
- )
+InfoAccessType interceptor_ICJI::constructStringLiteral(CORINFO_MODULE_HANDLE module, mdToken metaTok, void** ppValue)
{
mc->cr->AddCall("constructStringLiteral");
InfoAccessType temp = original_ICorJitInfo->constructStringLiteral(module, metaTok, ppValue);
@@ -1966,7 +1732,7 @@ InfoAccessType interceptor_ICJI::constructStringLiteral(
return temp;
}
-InfoAccessType interceptor_ICJI::emptyStringLiteral(void **ppValue)
+InfoAccessType interceptor_ICJI::emptyStringLiteral(void** ppValue)
{
mc->cr->AddCall("emptyStringLiteral");
InfoAccessType temp = original_ICorJitInfo->emptyStringLiteral(ppValue);
@@ -1977,10 +1743,7 @@ InfoAccessType interceptor_ICJI::emptyStringLiteral(void **ppValue)
// (static fields only) given that 'field' refers to thread local store,
// return the ID (TLS index), which is used to find the begining of the
// TLS data area for the particular DLL 'field' is associated with.
-DWORD interceptor_ICJI::getFieldThreadLocalStoreID (
- CORINFO_FIELD_HANDLE field,
- void **ppIndirection
- )
+DWORD interceptor_ICJI::getFieldThreadLocalStoreID(CORINFO_FIELD_HANDLE field, void** ppIndirection)
{
mc->cr->AddCall("getFieldThreadLocalStoreID");
DWORD temp = original_ICorJitInfo->getFieldThreadLocalStoreID(field, ppIndirection);
@@ -1989,10 +1752,7 @@ DWORD interceptor_ICJI::getFieldThreadLocalStoreID (
}
// Sets another object to intercept calls to "self" and current method being compiled
-void interceptor_ICJI::setOverride(
- ICorDynamicInfo *pOverride,
- CORINFO_METHOD_HANDLE currentMethod
- )
+void interceptor_ICJI::setOverride(ICorDynamicInfo* pOverride, CORINFO_METHOD_HANDLE currentMethod)
{
mc->cr->AddCall("setOverride");
original_ICorJitInfo->setOverride(pOverride, currentMethod);
@@ -2000,21 +1760,16 @@ void interceptor_ICJI::setOverride(
// Adds an active dependency from the context method's module to the given module
// This is internal callback for the EE. JIT should not call it directly.
-void interceptor_ICJI::addActiveDependency(
- CORINFO_MODULE_HANDLE moduleFrom,
- CORINFO_MODULE_HANDLE moduleTo
- )
+void interceptor_ICJI::addActiveDependency(CORINFO_MODULE_HANDLE moduleFrom, CORINFO_MODULE_HANDLE moduleTo)
{
mc->cr->AddCall("addActiveDependency");
original_ICorJitInfo->addActiveDependency(moduleFrom, moduleTo);
}
-CORINFO_METHOD_HANDLE interceptor_ICJI::GetDelegateCtor(
- CORINFO_METHOD_HANDLE methHnd,
- CORINFO_CLASS_HANDLE clsHnd,
- CORINFO_METHOD_HANDLE targetMethodHnd,
- DelegateCtorArgs * pCtorData
- )
+CORINFO_METHOD_HANDLE interceptor_ICJI::GetDelegateCtor(CORINFO_METHOD_HANDLE methHnd,
+ CORINFO_CLASS_HANDLE clsHnd,
+ CORINFO_METHOD_HANDLE targetMethodHnd,
+ DelegateCtorArgs* pCtorData)
{
mc->cr->AddCall("GetDelegateCtor");
CORINFO_METHOD_HANDLE temp = original_ICorJitInfo->GetDelegateCtor(methHnd, clsHnd, targetMethodHnd, pCtorData);
@@ -2022,30 +1777,25 @@ CORINFO_METHOD_HANDLE interceptor_ICJI::GetDelegateCtor(
return temp;
}
-void interceptor_ICJI::MethodCompileComplete(
- CORINFO_METHOD_HANDLE methHnd
- )
+void interceptor_ICJI::MethodCompileComplete(CORINFO_METHOD_HANDLE methHnd)
{
mc->cr->AddCall("MethodCompileComplete");
original_ICorJitInfo->MethodCompileComplete(methHnd);
}
// return a thunk that will copy the arguments for the given signature.
-void* interceptor_ICJI::getTailCallCopyArgsThunk (
- CORINFO_SIG_INFO *pSig,
- CorInfoHelperTailCallSpecialHandling flags
- )
+void* interceptor_ICJI::getTailCallCopyArgsThunk(CORINFO_SIG_INFO* pSig, CorInfoHelperTailCallSpecialHandling flags)
{
mc->cr->AddCall("getTailCallCopyArgsThunk");
- void *result = original_ICorJitInfo->getTailCallCopyArgsThunk(pSig, flags);
+ void* result = original_ICorJitInfo->getTailCallCopyArgsThunk(pSig, flags);
mc->recGetTailCallCopyArgsThunk(pSig, flags, result);
return result;
}
-//Stuff directly on ICorJitInfo
+// Stuff directly on ICorJitInfo
// Returns extended flags for a particular compilation instance.
-DWORD interceptor_ICJI::getJitFlags(CORJIT_FLAGS *jitFlags, DWORD sizeInBytes)
+DWORD interceptor_ICJI::getJitFlags(CORJIT_FLAGS* jitFlags, DWORD sizeInBytes)
{
mc->cr->AddCall("getJitFlags");
DWORD result = original_ICorJitInfo->getJitFlags(jitFlags, sizeInBytes);
@@ -2058,7 +1808,7 @@ DWORD interceptor_ICJI::getJitFlags(CORJIT_FLAGS *jitFlags, DWORD sizeInBytes)
// record the results of the call: when this call gets played back,
// its result will depend on whether or not `function` calls something
// that throws at playback time rather than at capture time.
-bool interceptor_ICJI::runWithErrorTrap(void (*function)(void*), void *param)
+bool interceptor_ICJI::runWithErrorTrap(void (*function)(void*), void* param)
{
mc->cr->AddCall("runWithErrorTrap");
return original_ICorJitInfo->runWithErrorTrap(function, param);
@@ -2068,26 +1818,27 @@ bool interceptor_ICJI::runWithErrorTrap(void (*function)(void*), void *param)
IEEMemoryManager* interceptor_ICJI::getMemoryManager()
{
mc->cr->AddCall("getMemoryManager");
- if(current_IEEMM->original_IEEMM == nullptr)
+ if (current_IEEMM->original_IEEMM == nullptr)
current_IEEMM->original_IEEMM = original_ICorJitInfo->getMemoryManager();
return current_IEEMM;
}
// get a block of memory for the code, readonly data, and read-write data
-void interceptor_ICJI::allocMem (
- ULONG hotCodeSize, /* IN */
- ULONG coldCodeSize, /* IN */
- ULONG roDataSize, /* IN */
- ULONG xcptnsCount, /* IN */
- CorJitAllocMemFlag flag, /* IN */
- void ** hotCodeBlock, /* OUT */
- void ** coldCodeBlock, /* OUT */
- void ** roDataBlock /* OUT */
- )
+void interceptor_ICJI::allocMem(ULONG hotCodeSize, /* IN */
+ ULONG coldCodeSize, /* IN */
+ ULONG roDataSize, /* IN */
+ ULONG xcptnsCount, /* IN */
+ CorJitAllocMemFlag flag, /* IN */
+ void** hotCodeBlock, /* OUT */
+ void** coldCodeBlock, /* OUT */
+ void** roDataBlock /* OUT */
+ )
{
mc->cr->AddCall("allocMem");
- original_ICorJitInfo->allocMem(hotCodeSize, coldCodeSize, roDataSize, xcptnsCount, flag, hotCodeBlock, coldCodeBlock, roDataBlock);
- mc->cr->recAllocMem(hotCodeSize, coldCodeSize, roDataSize, xcptnsCount, flag, hotCodeBlock, coldCodeBlock, roDataBlock);
+ original_ICorJitInfo->allocMem(hotCodeSize, coldCodeSize, roDataSize, xcptnsCount, flag, hotCodeBlock,
+ coldCodeBlock, roDataBlock);
+ mc->cr->recAllocMem(hotCodeSize, coldCodeSize, roDataSize, xcptnsCount, flag, hotCodeBlock, coldCodeBlock,
+ roDataBlock);
}
// Reserve memory for the method/funclet's unwind information.
@@ -2101,11 +1852,10 @@ void interceptor_ICJI::allocMem (
// For prejitted code we split up the unwinding information into
// separate sections .rdata and .pdata.
//
-void interceptor_ICJI::reserveUnwindInfo (
- BOOL isFunclet, /* IN */
- BOOL isColdCode, /* IN */
- ULONG unwindSize /* IN */
- )
+void interceptor_ICJI::reserveUnwindInfo(BOOL isFunclet, /* IN */
+ BOOL isColdCode, /* IN */
+ ULONG unwindSize /* IN */
+ )
{
mc->cr->AddCall("reserveUnwindInfo");
original_ICorJitInfo->reserveUnwindInfo(isFunclet, isColdCode, unwindSize);
@@ -2129,18 +1879,18 @@ void interceptor_ICJI::reserveUnwindInfo (
// pUnwindBlock pointer to unwind info
// funcKind type of funclet (main method code, handler, filter)
//
-void interceptor_ICJI::allocUnwindInfo(
- BYTE * pHotCode, /* IN */
- BYTE * pColdCode, /* IN */
- ULONG startOffset, /* IN */
- ULONG endOffset, /* IN */
- ULONG unwindSize, /* IN */
- BYTE * pUnwindBlock, /* IN */
- CorJitFuncKind funcKind /* IN */
- )
+void interceptor_ICJI::allocUnwindInfo(BYTE* pHotCode, /* IN */
+ BYTE* pColdCode, /* IN */
+ ULONG startOffset, /* IN */
+ ULONG endOffset, /* IN */
+ ULONG unwindSize, /* IN */
+ BYTE* pUnwindBlock, /* IN */
+ CorJitFuncKind funcKind /* IN */
+ )
{
mc->cr->AddCall("allocUnwindInfo");
- original_ICorJitInfo->allocUnwindInfo(pHotCode, pColdCode, startOffset, endOffset, unwindSize, pUnwindBlock, funcKind);
+ original_ICorJitInfo->allocUnwindInfo(pHotCode, pColdCode, startOffset, endOffset, unwindSize, pUnwindBlock,
+ funcKind);
mc->cr->recAllocUnwindInfo(pHotCode, pColdCode, startOffset, endOffset, unwindSize, pUnwindBlock, funcKind);
}
@@ -2148,25 +1898,25 @@ void interceptor_ICJI::allocUnwindInfo(
// (the info for enumerating the GC pointers while crawling the
// stack frame).
// Note that allocMem must be called first
-void *interceptor_ICJI::allocGCInfo(size_t size /* IN */)
+void* interceptor_ICJI::allocGCInfo(size_t size /* IN */)
{
mc->cr->AddCall("allocGCInfo");
- void *temp = original_ICorJitInfo->allocGCInfo(size);
+ void* temp = original_ICorJitInfo->allocGCInfo(size);
mc->cr->recAllocGCInfo(size, temp);
return temp;
}
-//only used on x64
+// only used on x64
void interceptor_ICJI::yieldExecution()
{
- mc->cr->AddCall("yieldExecution"); //Nothing to record
+ mc->cr->AddCall("yieldExecution"); // Nothing to record
original_ICorJitInfo->yieldExecution();
}
// Indicate how many exception handler blocks are to be returned.
// This is guaranteed to be called before any 'setEHinfo' call.
// Note that allocMem must be called before this method can be called.
-void interceptor_ICJI::setEHcount (unsigned cEH /* IN */)
+void interceptor_ICJI::setEHcount(unsigned cEH /* IN */)
{
mc->cr->AddCall("setEHcount");
original_ICorJitInfo->setEHcount(cEH);
@@ -2177,10 +1927,9 @@ void interceptor_ICJI::setEHcount (unsigned cEH /* IN */)
// Handler regions should be lexically contiguous.
// This is because FinallyIsUnwinding() uses lexicality to
// determine if a "finally" clause is executing.
-void interceptor_ICJI::setEHinfo (
- unsigned EHnumber, /* IN */
- const CORINFO_EH_CLAUSE *clause /* IN */
- )
+void interceptor_ICJI::setEHinfo(unsigned EHnumber, /* IN */
+ const CORINFO_EH_CLAUSE* clause /* IN */
+ )
{
mc->cr->AddCall("setEHinfo");
original_ICorJitInfo->setEHinfo(EHnumber, clause);
@@ -2213,10 +1962,8 @@ void interceptor_ICJI::reportFatalError(CorJitResult result)
// allocate a basic block profile buffer where execution counts will be stored
// for jitted basic blocks.
-HRESULT interceptor_ICJI::allocBBProfileBuffer (
- ULONG count, // The number of basic blocks that we have
- ProfileBuffer **profileBuffer
- )
+HRESULT interceptor_ICJI::allocBBProfileBuffer(ULONG count, // The number of basic blocks that we have
+ ProfileBuffer** profileBuffer)
{
mc->cr->AddCall("allocBBProfileBuffer");
HRESULT result = original_ICorJitInfo->allocBBProfileBuffer(count, profileBuffer);
@@ -2226,12 +1973,10 @@ HRESULT interceptor_ICJI::allocBBProfileBuffer (
// get profile information to be used for optimizing the current method. The format
// of the buffer is the same as the format the JIT passes to allocBBProfileBuffer.
-HRESULT interceptor_ICJI::getBBProfileData(
- CORINFO_METHOD_HANDLE ftnHnd,
- ULONG *count, // The number of basic blocks that we have
- ProfileBuffer **profileBuffer,
- ULONG *numRuns
- )
+HRESULT interceptor_ICJI::getBBProfileData(CORINFO_METHOD_HANDLE ftnHnd,
+ ULONG* count, // The number of basic blocks that we have
+ ProfileBuffer** profileBuffer,
+ ULONG* numRuns)
{
mc->cr->AddCall("getBBProfileData");
HRESULT temp = original_ICorJitInfo->getBBProfileData(ftnHnd, count, profileBuffer, numRuns);
@@ -2243,11 +1988,10 @@ HRESULT interceptor_ICJI::getBBProfileData(
// the signature information and method handle the JIT used to lay out the call site. If
// the call site has no signature information (e.g. a helper call) or has no method handle
// (e.g. a CALLI P/Invoke), then null should be passed instead.
-void interceptor_ICJI::recordCallSite(
- ULONG instrOffset, /* IN */
- CORINFO_SIG_INFO * callSig, /* IN */
- CORINFO_METHOD_HANDLE methodHandle /* IN */
- )
+void interceptor_ICJI::recordCallSite(ULONG instrOffset, /* IN */
+ CORINFO_SIG_INFO* callSig, /* IN */
+ CORINFO_METHOD_HANDLE methodHandle /* IN */
+ )
{
mc->cr->AddCall("recordCallSite");
original_ICorJitInfo->recordCallSite(instrOffset, callSig, methodHandle);
@@ -2256,20 +2000,19 @@ void interceptor_ICJI::recordCallSite(
// A relocation is recorded if we are pre-jitting.
// A jump thunk may be inserted if we are jitting
-void interceptor_ICJI::recordRelocation(
- void *location, /* IN */
- void *target, /* IN */
- WORD fRelocType, /* IN */
- WORD slotNum, /* IN */
- INT32 addlDelta /* IN */
- )
+void interceptor_ICJI::recordRelocation(void* location, /* IN */
+ void* target, /* IN */
+ WORD fRelocType, /* IN */
+ WORD slotNum, /* IN */
+ INT32 addlDelta /* IN */
+ )
{
mc->cr->AddCall("recordRelocation");
original_ICorJitInfo->recordRelocation(location, target, fRelocType, slotNum, addlDelta);
mc->cr->recRecordRelocation(location, target, fRelocType, slotNum, addlDelta);
}
-WORD interceptor_ICJI::getRelocTypeHint(void *target)
+WORD interceptor_ICJI::getRelocTypeHint(void* target)
{
mc->cr->AddCall("getRelocTypeHint");
WORD result = original_ICorJitInfo->getRelocTypeHint(target);
@@ -2280,10 +2023,9 @@ WORD interceptor_ICJI::getRelocTypeHint(void *target)
// A callback to identify the range of address known to point to
// compiler-generated native entry points that call back into
// MSIL.
-void interceptor_ICJI::getModuleNativeEntryPointRange(
- void **pStart, /* OUT */
- void **pEnd /* OUT */
- )
+void interceptor_ICJI::getModuleNativeEntryPointRange(void** pStart, /* OUT */
+ void** pEnd /* OUT */
+ )
{
mc->cr->AddCall("getModuleNativeEntryPointRange");
original_ICorJitInfo->getModuleNativeEntryPointRange(pStart, pEnd);
diff --git a/src/ToolBox/superpmi/superpmi-shim-collector/icorjitinfo.h b/src/ToolBox/superpmi/superpmi-shim-collector/icorjitinfo.h
index 08d7643613..b582866a89 100644
--- a/src/ToolBox/superpmi/superpmi-shim-collector/icorjitinfo.h
+++ b/src/ToolBox/superpmi/superpmi-shim-collector/icorjitinfo.h
@@ -16,15 +16,13 @@ class interceptor_ICJI : public ICorJitInfo
#include "icorjitinfoimpl.h"
private:
-
void makeFatMC_ClassHandle(CORINFO_CLASS_HANDLE cls, bool getAttribs);
public:
-
- //Added to help us track the original icji and be able to easily indirect
- //to it. And a simple way to keep one memory manager instance per instance.
- ICorJitInfo *original_ICorJitInfo;
- MethodContext *mc;
+ // Added to help us track the original icji and be able to easily indirect
+ //to it. And a simple way to keep one memory manager instance per instance.
+ ICorJitInfo* original_ICorJitInfo;
+ MethodContext* mc;
};
#endif
diff --git a/src/ToolBox/superpmi/superpmi-shim-collector/ieememorymanager.cpp b/src/ToolBox/superpmi/superpmi-shim-collector/ieememorymanager.cpp
index e0021244cd..3bd9e7e5d4 100644
--- a/src/ToolBox/superpmi/superpmi-shim-collector/ieememorymanager.cpp
+++ b/src/ToolBox/superpmi/superpmi-shim-collector/ieememorymanager.cpp
@@ -10,7 +10,7 @@
//***************************************************************************
// IUnknown methods
//***************************************************************************
-HRESULT STDMETHODCALLTYPE interceptor_IEEMM::QueryInterface(REFIID id, void **pInterface)
+HRESULT STDMETHODCALLTYPE interceptor_IEEMM::QueryInterface(REFIID id, void** pInterface)
{
return original_IEEMM->QueryInterface(id, pInterface);
}
@@ -26,7 +26,10 @@ ULONG STDMETHODCALLTYPE interceptor_IEEMM::Release()
//***************************************************************************
// IEEMemoryManager methods for locking
//***************************************************************************
-LPVOID STDMETHODCALLTYPE interceptor_IEEMM::ClrVirtualAlloc(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect)
+LPVOID STDMETHODCALLTYPE interceptor_IEEMM::ClrVirtualAlloc(LPVOID lpAddress,
+ SIZE_T dwSize,
+ DWORD flAllocationType,
+ DWORD flProtect)
{
return original_IEEMM->ClrVirtualAlloc(lpAddress, dwSize, flAllocationType, flProtect);
}
@@ -34,11 +37,16 @@ BOOL STDMETHODCALLTYPE interceptor_IEEMM::ClrVirtualFree(LPVOID lpAddress, SIZE_
{
return original_IEEMM->ClrVirtualFree(lpAddress, dwSize, dwFreeType);
}
-SIZE_T STDMETHODCALLTYPE interceptor_IEEMM::ClrVirtualQuery(LPCVOID lpAddress, PMEMORY_BASIC_INFORMATION lpBuffer, SIZE_T dwLength)
+SIZE_T STDMETHODCALLTYPE interceptor_IEEMM::ClrVirtualQuery(LPCVOID lpAddress,
+ PMEMORY_BASIC_INFORMATION lpBuffer,
+ SIZE_T dwLength)
{
return original_IEEMM->ClrVirtualQuery(lpAddress, lpBuffer, dwLength);
}
-BOOL STDMETHODCALLTYPE interceptor_IEEMM::ClrVirtualProtect(LPVOID lpAddress, SIZE_T dwSize, DWORD flNewProtect, PDWORD lpflOldProtect)
+BOOL STDMETHODCALLTYPE interceptor_IEEMM::ClrVirtualProtect(LPVOID lpAddress,
+ SIZE_T dwSize,
+ DWORD flNewProtect,
+ PDWORD lpflOldProtect)
{
return original_IEEMM->ClrVirtualProtect(lpAddress, dwSize, flNewProtect, lpflOldProtect);
}
diff --git a/src/ToolBox/superpmi/superpmi-shim-collector/ieememorymanager.h b/src/ToolBox/superpmi/superpmi-shim-collector/ieememorymanager.h
index 4855d383b5..55fb3733a4 100644
--- a/src/ToolBox/superpmi/superpmi-shim-collector/ieememorymanager.h
+++ b/src/ToolBox/superpmi/superpmi-shim-collector/ieememorymanager.h
@@ -11,14 +11,15 @@
class interceptor_IEEMM : public IEEMemoryManager
{
public:
- interceptor_IEEMM()
- : original_IEEMM(nullptr)
- { }
+ interceptor_IEEMM() : original_IEEMM(nullptr)
+ {
+ }
+
private:
//***************************************************************************
// IUnknown methods
//***************************************************************************
- HRESULT STDMETHODCALLTYPE QueryInterface(REFIID id, void **pInterface);
+ HRESULT STDMETHODCALLTYPE QueryInterface(REFIID id, void** pInterface);
ULONG STDMETHODCALLTYPE AddRef();
ULONG STDMETHODCALLTYPE Release();
@@ -28,7 +29,10 @@ private:
LPVOID STDMETHODCALLTYPE ClrVirtualAlloc(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect);
BOOL STDMETHODCALLTYPE ClrVirtualFree(LPVOID lpAddress, SIZE_T dwSize, DWORD dwFreeType);
SIZE_T STDMETHODCALLTYPE ClrVirtualQuery(LPCVOID lpAddress, PMEMORY_BASIC_INFORMATION lpBuffer, SIZE_T dwLength);
- BOOL STDMETHODCALLTYPE ClrVirtualProtect(LPVOID lpAddress, SIZE_T dwSize, DWORD flNewProtect, PDWORD lpflOldProtect);
+ BOOL STDMETHODCALLTYPE ClrVirtualProtect(LPVOID lpAddress,
+ SIZE_T dwSize,
+ DWORD flNewProtect,
+ PDWORD lpflOldProtect);
HANDLE STDMETHODCALLTYPE ClrGetProcessHeap();
HANDLE STDMETHODCALLTYPE ClrHeapCreate(DWORD flOptions, SIZE_T dwInitialSize, SIZE_T dwMaximumSize);
BOOL STDMETHODCALLTYPE ClrHeapDestroy(HANDLE hHeap);
@@ -38,6 +42,6 @@ private:
HANDLE STDMETHODCALLTYPE ClrGetProcessExecutableHeap();
public:
- IEEMemoryManager *original_IEEMM;
+ IEEMemoryManager* original_IEEMM;
};
#endif
diff --git a/src/ToolBox/superpmi/superpmi-shim-collector/iexecutionengine.cpp b/src/ToolBox/superpmi/superpmi-shim-collector/iexecutionengine.cpp
index 6bdde6ec8b..6409e4f24f 100644
--- a/src/ToolBox/superpmi/superpmi-shim-collector/iexecutionengine.cpp
+++ b/src/ToolBox/superpmi/superpmi-shim-collector/iexecutionengine.cpp
@@ -14,7 +14,7 @@
//***************************************************************************
// IUnknown methods
//***************************************************************************
-HRESULT STDMETHODCALLTYPE interceptor_IEE::QueryInterface(REFIID id, void **pInterface)
+HRESULT STDMETHODCALLTYPE interceptor_IEE::QueryInterface(REFIID id, void** pInterface)
{
return original_IEE->QueryInterface(id, pInterface);
}
@@ -31,7 +31,7 @@ ULONG STDMETHODCALLTYPE interceptor_IEE::Release()
// IExecutionEngine methods for TLS
//***************************************************************************
// Associate a callback for cleanup with a TLS slot
-VOID STDMETHODCALLTYPE interceptor_IEE::TLS_AssociateCallback(DWORD slot, PTLS_CALLBACK_FUNCTION callback)
+VOID STDMETHODCALLTYPE interceptor_IEE::TLS_AssociateCallback(DWORD slot, PTLS_CALLBACK_FUNCTION callback)
{
original_IEE->TLS_AssociateCallback(slot, callback);
}
@@ -46,7 +46,7 @@ LPVOID STDMETHODCALLTYPE interceptor_IEE::TLS_GetValue(DWORD slot)
return original_IEE->TLS_GetValue(slot);
}
// Get the value at a slot, return FALSE if TLS info block doesn't exist
-BOOL STDMETHODCALLTYPE interceptor_IEE::TLS_CheckValue(DWORD slot, LPVOID *pValue)
+BOOL STDMETHODCALLTYPE interceptor_IEE::TLS_CheckValue(DWORD slot, LPVOID* pValue)
{
return original_IEE->TLS_CheckValue(slot, pValue);
}
@@ -116,15 +116,21 @@ void STDMETHODCALLTYPE interceptor_IEE::ClrCloseSemaphore(SEMAPHORE_COOKIE semap
{
original_IEE->ClrCloseSemaphore(semaphore);
}
-DWORD STDMETHODCALLTYPE interceptor_IEE::ClrWaitForSemaphore(SEMAPHORE_COOKIE semaphore, DWORD dwMilliseconds, BOOL bAlertable)
+DWORD STDMETHODCALLTYPE interceptor_IEE::ClrWaitForSemaphore(SEMAPHORE_COOKIE semaphore,
+ DWORD dwMilliseconds,
+ BOOL bAlertable)
{
return original_IEE->ClrWaitForSemaphore(semaphore, dwMilliseconds, bAlertable);
}
-BOOL STDMETHODCALLTYPE interceptor_IEE::ClrReleaseSemaphore(SEMAPHORE_COOKIE semaphore, LONG lReleaseCount, LONG *lpPreviousCount)
+BOOL STDMETHODCALLTYPE interceptor_IEE::ClrReleaseSemaphore(SEMAPHORE_COOKIE semaphore,
+ LONG lReleaseCount,
+ LONG* lpPreviousCount)
{
return original_IEE->ClrReleaseSemaphore(semaphore, lReleaseCount, lpPreviousCount);
}
-MUTEX_COOKIE STDMETHODCALLTYPE interceptor_IEE::ClrCreateMutex(LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, LPCTSTR lpName)
+MUTEX_COOKIE STDMETHODCALLTYPE interceptor_IEE::ClrCreateMutex(LPSECURITY_ATTRIBUTES lpMutexAttributes,
+ BOOL bInitialOwner,
+ LPCTSTR lpName)
{
return original_IEE->ClrCreateMutex(lpMutexAttributes, bInitialOwner, lpName);
}
@@ -148,7 +154,7 @@ BOOL STDMETHODCALLTYPE interceptor_IEE::ClrAllocationDisallowed()
{
return original_IEE->ClrAllocationDisallowed();
}
-void STDMETHODCALLTYPE interceptor_IEE::GetLastThrownObjectExceptionFromThread(void **ppvException)
+void STDMETHODCALLTYPE interceptor_IEE::GetLastThrownObjectExceptionFromThread(void** ppvException)
{
original_IEE->GetLastThrownObjectExceptionFromThread(ppvException);
}
diff --git a/src/ToolBox/superpmi/superpmi-shim-collector/iexecutionengine.h b/src/ToolBox/superpmi/superpmi-shim-collector/iexecutionengine.h
index 49c247ff99..69f9679af4 100644
--- a/src/ToolBox/superpmi/superpmi-shim-collector/iexecutionengine.h
+++ b/src/ToolBox/superpmi/superpmi-shim-collector/iexecutionengine.h
@@ -17,7 +17,7 @@ private:
//***************************************************************************
// IUnknown methods
//***************************************************************************
- HRESULT STDMETHODCALLTYPE QueryInterface(REFIID id, void **pInterface);
+ HRESULT STDMETHODCALLTYPE QueryInterface(REFIID id, void** pInterface);
ULONG STDMETHODCALLTYPE AddRef();
ULONG STDMETHODCALLTYPE Release();
@@ -25,13 +25,13 @@ private:
// IExecutionEngine methods for TLS
//***************************************************************************
// Associate a callback for cleanup with a TLS slot
- VOID STDMETHODCALLTYPE TLS_AssociateCallback(DWORD slot, PTLS_CALLBACK_FUNCTION callback);
+ VOID STDMETHODCALLTYPE TLS_AssociateCallback(DWORD slot, PTLS_CALLBACK_FUNCTION callback);
// Get the TLS block for fast Get/Set operations
LPVOID* STDMETHODCALLTYPE TLS_GetDataBlock();
// Get the value at a slot
LPVOID STDMETHODCALLTYPE TLS_GetValue(DWORD slot);
// Get the value at a slot, return FALSE if TLS info block doesn't exist
- BOOL STDMETHODCALLTYPE TLS_CheckValue(DWORD slot, LPVOID *pValue);
+ BOOL STDMETHODCALLTYPE TLS_CheckValue(DWORD slot, LPVOID* pValue);
// Set the value at a slot
VOID STDMETHODCALLTYPE TLS_SetValue(DWORD slot, LPVOID pData);
// Free TLS memory block and make callback
@@ -54,17 +54,20 @@ private:
SEMAPHORE_COOKIE STDMETHODCALLTYPE ClrCreateSemaphore(DWORD dwInitial, DWORD dwMax);
void STDMETHODCALLTYPE ClrCloseSemaphore(SEMAPHORE_COOKIE semaphore);
DWORD STDMETHODCALLTYPE ClrWaitForSemaphore(SEMAPHORE_COOKIE semaphore, DWORD dwMilliseconds, BOOL bAlertable);
- BOOL STDMETHODCALLTYPE ClrReleaseSemaphore(SEMAPHORE_COOKIE semaphore, LONG lReleaseCount, LONG *lpPreviousCount);
- MUTEX_COOKIE STDMETHODCALLTYPE ClrCreateMutex(LPSECURITY_ATTRIBUTES lpMutexAttributes, BOOL bInitialOwner, LPCTSTR lpName);
+ BOOL STDMETHODCALLTYPE ClrReleaseSemaphore(SEMAPHORE_COOKIE semaphore, LONG lReleaseCount, LONG* lpPreviousCount);
+ MUTEX_COOKIE STDMETHODCALLTYPE ClrCreateMutex(LPSECURITY_ATTRIBUTES lpMutexAttributes,
+ BOOL bInitialOwner,
+ LPCTSTR lpName);
void STDMETHODCALLTYPE ClrCloseMutex(MUTEX_COOKIE mutex);
BOOL STDMETHODCALLTYPE ClrReleaseMutex(MUTEX_COOKIE mutex);
DWORD STDMETHODCALLTYPE ClrWaitForMutex(MUTEX_COOKIE mutex, DWORD dwMilliseconds, BOOL bAlertable);
DWORD STDMETHODCALLTYPE ClrSleepEx(DWORD dwMilliseconds, BOOL bAlertable);
BOOL STDMETHODCALLTYPE ClrAllocationDisallowed();
- void STDMETHODCALLTYPE GetLastThrownObjectExceptionFromThread(void **ppvException);
+ void STDMETHODCALLTYPE GetLastThrownObjectExceptionFromThread(void** ppvException);
public:
- IExecutionEngine *original_IEE; //Our extra value that holds a pointer to the original IEE we'll pass calls along to
+ IExecutionEngine* original_IEE; // Our extra value that holds a pointer to the original IEE we'll pass calls along
+ // to
};
#endif \ No newline at end of file
diff --git a/src/ToolBox/superpmi/superpmi-shim-collector/jithost.cpp b/src/ToolBox/superpmi/superpmi-shim-collector/jithost.cpp
index 5e63a76be7..fd5c46aeee 100644
--- a/src/ToolBox/superpmi/superpmi-shim-collector/jithost.cpp
+++ b/src/ToolBox/superpmi/superpmi-shim-collector/jithost.cpp
@@ -47,7 +47,7 @@ int JitHost::getIntConfigValue(const wchar_t* key, int defaultValue)
const wchar_t* JitHost::getStringConfigValue(const wchar_t* key)
{
mc->cr->AddCall("getStringConfigValue");
- const wchar_t *result = wrappedHost->getStringConfigValue(key);
+ const wchar_t* result = wrappedHost->getStringConfigValue(key);
// Don't store null returns, which is the default
if (result != nullptr)
diff --git a/src/ToolBox/superpmi/superpmi-shim-collector/jithost.h b/src/ToolBox/superpmi/superpmi-shim-collector/jithost.h
index 2950a55682..426520ddf1 100644
--- a/src/ToolBox/superpmi/superpmi-shim-collector/jithost.h
+++ b/src/ToolBox/superpmi/superpmi-shim-collector/jithost.h
@@ -16,7 +16,7 @@ public:
#include "icorjithostimpl.h"
private:
- ICorJitHost* wrappedHost;
+ ICorJitHost* wrappedHost;
MethodContext* mc;
};
diff --git a/src/ToolBox/superpmi/superpmi-shim-collector/superpmi-shim-collector.cpp b/src/ToolBox/superpmi/superpmi-shim-collector/superpmi-shim-collector.cpp
index 1a6d73da0a..c8af7a0c26 100644
--- a/src/ToolBox/superpmi/superpmi-shim-collector/superpmi-shim-collector.cpp
+++ b/src/ToolBox/superpmi/superpmi-shim-collector/superpmi-shim-collector.cpp
@@ -16,18 +16,18 @@
#include "spmiutil.h"
#include "jithost.h"
-//Assumptions:
+// Assumptions:
// -We'll never be unloaded - we leak memory and have no facility to unload libraries
// -printf output to console is okay
-HMODULE g_hRealJit = 0; //We leak this currently (could do the proper shutdown in process_detach)
-WCHAR* g_realJitPath = nullptr; //We leak this (could do the proper shutdown in process_detach)
-WCHAR* g_logPath = nullptr; //Again, we leak this one too...
-WCHAR* g_dataFileName = nullptr; //We leak this
-char* g_logFilePath = nullptr; //We *don't* leak this, hooray!
-WCHAR* g_HomeDirectory = nullptr;
-WCHAR* g_DefaultRealJitPath = nullptr;
-MethodContext* g_globalContext = nullptr;
+HMODULE g_hRealJit = 0; // We leak this currently (could do the proper shutdown in process_detach)
+WCHAR* g_realJitPath = nullptr; // We leak this (could do the proper shutdown in process_detach)
+WCHAR* g_logPath = nullptr; // Again, we leak this one too...
+WCHAR* g_dataFileName = nullptr; // We leak this
+char* g_logFilePath = nullptr; // We *don't* leak this, hooray!
+WCHAR* g_HomeDirectory = nullptr;
+WCHAR* g_DefaultRealJitPath = nullptr;
+MethodContext* g_globalContext = nullptr;
void SetDefaultPaths()
{
@@ -38,7 +38,7 @@ void SetDefaultPaths()
if (g_DefaultRealJitPath == nullptr)
{
- size_t len = wcslen(g_HomeDirectory) + 1 + wcslen(DEFAULT_REAL_JIT_NAME_W) + 1;
+ size_t len = wcslen(g_HomeDirectory) + 1 + wcslen(DEFAULT_REAL_JIT_NAME_W) + 1;
g_DefaultRealJitPath = new WCHAR[len];
wcscpy_s(g_DefaultRealJitPath, len, g_HomeDirectory);
wcscat_s(g_DefaultRealJitPath, len, DIRECTORY_SEPARATOR_STR_W);
@@ -64,30 +64,33 @@ void SetLogPath()
void SetLogPathName()
{
- // NOTE: under PAL, we don't get the comand line, so we depend on the random number generator to give us a unique filename.
- WCHAR *OriginalExecutableName = GetCommandLineW();//TODO-Cleanup: not cool to write to the process view of commandline....
- size_t len = wcslen(OriginalExecutableName);
- WCHAR *ExecutableName = new WCHAR[len+1];
- wcscpy_s(ExecutableName, len+1, OriginalExecutableName);
+ // NOTE: under PAL, we don't get the comand line, so we depend on the random number generator to give us a unique
+ // filename.
+ WCHAR* OriginalExecutableName =
+ GetCommandLineW(); // TODO-Cleanup: not cool to write to the process view of commandline....
+ size_t len = wcslen(OriginalExecutableName);
+ WCHAR* ExecutableName = new WCHAR[len + 1];
+ wcscpy_s(ExecutableName, len + 1, OriginalExecutableName);
ExecutableName[len] = W('\0');
- WCHAR *quote1 = NULL;
+ WCHAR* quote1 = NULL;
- //if there are any quotes in filename convert them to spaces.
+ // if there are any quotes in filename convert them to spaces.
while ((quote1 = wcsstr(ExecutableName, W("\""))) != NULL)
*quote1 = W(' ');
- //remove any illegal or annoying characters from file name by converting them to underscores
+ // remove any illegal or annoying characters from file name by converting them to underscores
while ((quote1 = wcspbrk(ExecutableName, W("=<>:\"/\\|?! *.,"))) != NULL)
*quote1 = W('_');
- const WCHAR *DataFileExtension = W(".mc");
- size_t ExecutableNameLength = wcslen(ExecutableName);
- size_t DataFileExtensionLength = wcslen(DataFileExtension);
- size_t logPathLength = wcslen(g_logPath);
+ const WCHAR* DataFileExtension = W(".mc");
+ size_t ExecutableNameLength = wcslen(ExecutableName);
+ size_t DataFileExtensionLength = wcslen(DataFileExtension);
+ size_t logPathLength = wcslen(g_logPath);
size_t dataFileNameLength = logPathLength + 1 + ExecutableNameLength + 1 + DataFileExtensionLength + 1;
- const size_t MaxAcceptablePathLength = MAX_PATH - 20; // subtract 20 to leave buffer, for possible random number addition
+ const size_t MaxAcceptablePathLength =
+ MAX_PATH - 20; // subtract 20 to leave buffer, for possible random number addition
if (dataFileNameLength >= MaxAcceptablePathLength)
{
// The path name is too long; creating the file will fail. This can happen because we use the command line,
@@ -99,17 +102,17 @@ void SetLogPathName()
dataFileNameLength = MaxAcceptablePathLength;
}
- // Always add a random number, just in case the above doesn't give us a unique filename.
+// Always add a random number, just in case the above doesn't give us a unique filename.
#ifdef FEATURE_PAL
- unsigned __int64 randNumber = 0;
- const size_t RandNumberLength = sizeof(randNumber) * 2 + 1; // 16 hex digits + null
- WCHAR RandNumberString[RandNumberLength];
+ unsigned __int64 randNumber = 0;
+ const size_t RandNumberLength = sizeof(randNumber) * 2 + 1; // 16 hex digits + null
+ WCHAR RandNumberString[RandNumberLength];
PAL_Random(/* bStrong */ FALSE, &randNumber, sizeof(randNumber));
swprintf_s(RandNumberString, RandNumberLength, W("%016llX"), randNumber);
-#else // !FEATURE_PAL
- unsigned int randNumber = 0;
+#else // !FEATURE_PAL
+ unsigned int randNumber = 0;
const size_t RandNumberLength = sizeof(randNumber) * 2 + 1; // 8 hex digits + null
- WCHAR RandNumberString[RandNumberLength];
+ WCHAR RandNumberString[RandNumberLength];
rand_s(&randNumber);
swprintf_s(RandNumberString, RandNumberLength, W("%08X"), randNumber);
#endif // !FEATURE_PAL
@@ -117,7 +120,7 @@ void SetLogPathName()
dataFileNameLength += RandNumberLength - 1;
// Construct the full pathname we're going to use.
- g_dataFileName = new WCHAR[dataFileNameLength];
+ g_dataFileName = new WCHAR[dataFileNameLength];
g_dataFileName[0] = 0;
wcsncat_s(g_dataFileName, dataFileNameLength, g_logPath, logPathLength);
wcsncat_s(g_dataFileName, dataFileNameLength, DIRECTORY_SEPARATOR_STR_W, 1);
@@ -141,52 +144,50 @@ void SetLogFilePath()
}
}
-extern "C"
-BOOL
+extern "C" BOOL
#ifndef FEATURE_PAL
-APIENTRY
+ APIENTRY
#endif // !FEATURE_PAL
-DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
+ DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
{
switch (ul_reason_for_call)
{
- case DLL_PROCESS_ATTACH:
+ case DLL_PROCESS_ATTACH:
#ifdef FEATURE_PAL
- if (0 != PAL_InitializeDLL())
- {
- fprintf(stderr, "Error: Fail to PAL_InitializeDLL\n");
- exit(1);
- }
+ if (0 != PAL_InitializeDLL())
+ {
+ fprintf(stderr, "Error: Fail to PAL_InitializeDLL\n");
+ exit(1);
+ }
#endif // FEATURE_PAL
- Logger::Initialize();
- SetLogFilePath();
- Logger::OpenLogFile(g_logFilePath);
- break;
+ Logger::Initialize();
+ SetLogFilePath();
+ Logger::OpenLogFile(g_logFilePath);
+ break;
- case DLL_PROCESS_DETACH:
- Logger::Shutdown();
+ case DLL_PROCESS_DETACH:
+ Logger::Shutdown();
- delete[] g_logFilePath;
- g_logFilePath = nullptr;
+ delete[] g_logFilePath;
+ g_logFilePath = nullptr;
- break;
+ break;
- case DLL_THREAD_ATTACH:
- case DLL_THREAD_DETACH:
- break;
+ case DLL_THREAD_ATTACH:
+ case DLL_THREAD_DETACH:
+ break;
}
return TRUE;
}
// Exported via def file
-extern "C"
-void __stdcall jitStartup(ICorJitHost* host)
+extern "C" void __stdcall jitStartup(ICorJitHost* host)
{
SetDefaultPaths();
SetLibName();
- //Load Library
+ // Load Library
if (g_hRealJit == 0)
{
g_hRealJit = ::LoadLibraryW(g_realJitPath);
@@ -206,55 +207,55 @@ void __stdcall jitStartup(ICorJitHost* host)
}
g_globalContext = new MethodContext();
- g_ourJitHost = new JitHost(host, g_globalContext);
+ g_ourJitHost = new JitHost(host, g_globalContext);
pnjitStartup(g_ourJitHost);
}
-//Exported via def file
-extern "C"
-ICorJitCompiler* __stdcall getJit()
+// Exported via def file
+extern "C" ICorJitCompiler* __stdcall getJit()
{
- DWORD dwRetVal = 0;
- PgetJit pngetJit;
- interceptor_ICJC *pJitInstance = nullptr;
- ICorJitCompiler *tICJI = nullptr;
+ DWORD dwRetVal = 0;
+ PgetJit pngetJit;
+ interceptor_ICJC* pJitInstance = nullptr;
+ ICorJitCompiler* tICJI = nullptr;
SetDefaultPaths();
SetLibName();
SetLogPath();
SetLogPathName();
- //Load Library
- if(g_hRealJit == 0)
+ // Load Library
+ if (g_hRealJit == 0)
{
g_hRealJit = ::LoadLibraryW(g_realJitPath);
- if(g_hRealJit == 0)
+ if (g_hRealJit == 0)
{
LogError("getJit() - LoadLibrary failed to load '%ws' (0x%08x)", g_realJitPath, ::GetLastError());
return nullptr;
}
}
- //get the required entrypoints
+ // get the required entrypoints
pngetJit = (PgetJit)::GetProcAddress(g_hRealJit, "getJit");
- if(pngetJit == 0)
+ if (pngetJit == 0)
{
LogError("getJit() - GetProcAddress 'getJit' failed (0x%08x)", ::GetLastError());
return nullptr;
}
tICJI = pngetJit();
- if(tICJI == nullptr)
+ if (tICJI == nullptr)
{
LogError("getJit() - pngetJit gave us null");
return nullptr;
}
- pJitInstance = new interceptor_ICJC();
+ pJitInstance = new interceptor_ICJC();
pJitInstance->original_ICorJitCompiler = tICJI;
- //create our datafile
- pJitInstance->hFile = CreateFileW(g_dataFileName, GENERIC_READ|GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL|FILE_FLAG_SEQUENTIAL_SCAN, NULL);
+ // create our datafile
+ pJitInstance->hFile = CreateFileW(g_dataFileName, GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
+ FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, NULL);
if (pJitInstance->hFile == INVALID_HANDLE_VALUE)
{
LogError("Couldn't open file '%ws': error %d", g_dataFileName, GetLastError());
@@ -263,42 +264,41 @@ ICorJitCompiler* __stdcall getJit()
return pJitInstance;
}
-//Exported via def file
-extern "C"
-void __stdcall sxsJitStartup(CoreClrCallbacks const & original_cccallbacks)
+// Exported via def file
+extern "C" void __stdcall sxsJitStartup(CoreClrCallbacks const& original_cccallbacks)
{
PsxsJitStartup pnsxsJitStartup;
SetDefaultPaths();
SetLibName();
- //Load Library
- if(g_hRealJit == 0)
+ // Load Library
+ if (g_hRealJit == 0)
{
g_hRealJit = ::LoadLibraryW(g_realJitPath);
- if(g_hRealJit == 0)
+ if (g_hRealJit == 0)
{
LogError("sxsJitStartup() - LoadLibrary failed to load '%ws' (0x%08x)", g_realJitPath, ::GetLastError());
return;
}
}
- //get entry point
+ // get entry point
pnsxsJitStartup = (PsxsJitStartup)::GetProcAddress(g_hRealJit, "sxsJitStartup");
- if(pnsxsJitStartup == 0)
+ if (pnsxsJitStartup == 0)
{
LogError("sxsJitStartup() - GetProcAddress 'sxsJitStartup' failed (0x%08x)", ::GetLastError());
return;
}
- //Setup CoreClrCallbacks and call sxsJitStartup
- original_CoreClrCallbacks = new CoreClrCallbacks();
+ // Setup CoreClrCallbacks and call sxsJitStartup
+ original_CoreClrCallbacks = new CoreClrCallbacks();
original_CoreClrCallbacks->m_hmodCoreCLR = original_cccallbacks.m_hmodCoreCLR;
original_CoreClrCallbacks->m_pfnIEE = original_cccallbacks.m_pfnIEE;
original_CoreClrCallbacks->m_pfnGetCORSystemDirectory = original_cccallbacks.m_pfnGetCORSystemDirectory;
original_CoreClrCallbacks->m_pfnGetCLRFunction = original_cccallbacks.m_pfnGetCLRFunction;
- CoreClrCallbacks *temp = new CoreClrCallbacks();
+ CoreClrCallbacks* temp = new CoreClrCallbacks();
temp->m_hmodCoreCLR = original_cccallbacks.m_hmodCoreCLR;
temp->m_pfnIEE = IEE_t;