diff options
Diffstat (limited to 'src/ToolBox/superpmi/superpmi-shim-collector')
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, ¶m) - { - 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, + ¶m){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, ¶m) - { - 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, + ¶m){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, ¶m) - { - 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, + ¶m){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, ¶m) - { - 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, + ¶m){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, ¶m) - { - 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, + ¶m){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, ¶m) - { - 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, + ¶m){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; |