HRESULT CCodeCoverage::CuckooSupportCompilation(
AssemblyID assemblyId,
mdToken functionToken,
ModuleID moduleId)
{
// early escape if token is not one we want
if ((m_cuckooCriticalToken != functionToken) && (m_cuckooSafeToken != functionToken))
return S_OK;
auto assemblyName = GetAssemblyName(assemblyId);
// check that we have the right module
if (MSCORLIB_NAME == assemblyName || DNCORLIB_NAME == assemblyName)
{
if (m_cuckooCriticalToken == functionToken)
{
COM_FAIL_MSG_RETURN_ERROR(AddCriticalCuckooBody(moduleId),
_T(" ::JITCompilationStarted(...) => AddCriticalCuckooBody => 0x%X"));
}
if (m_cuckooSafeToken == functionToken)
{
COM_FAIL_MSG_RETURN_ERROR(AddSafeCuckooBody(moduleId),
_T(" ::JITCompilationStarted(...) => AddSafeCuckooBody => 0x%X"));
}
}
return S_OK;
}
/// <summary>Handle <c>ICorProfilerCallback::ModuleAttachedToAssembly</c></summary>
/// <remarks>Inform the host that we have a new module attached and that it may be
/// of interest</remarks>
HRESULT STDMETHODCALLTYPE CCodeCoverage::ModuleAttachedToAssembly(
/* [in] */ ModuleID moduleId,
/* [in] */ AssemblyID assemblyId)
{
std::wstring modulePath = GetModulePath(moduleId);
std::wstring assemblyName = GetAssemblyName(assemblyId);
ATLTRACE(_T("::ModuleAttachedToAssembly(%X => %s, %X => %s)"),
moduleId, W2CT(modulePath.c_str()),
assemblyId, W2CT(assemblyName.c_str()));
m_allowModules[modulePath] = m_host.TrackAssembly((LPWSTR)modulePath.c_str(), (LPWSTR)assemblyName.c_str());
m_allowModulesAssemblyMap[modulePath] = assemblyName;
return S_OK;
}
/// <summary>Handle <c>ICorProfilerCallback::ModuleAttachedToAssembly</c></summary>
/// <remarks>Inform the host that we have a new module attached and that it may be
/// of interest</remarks>
HRESULT STDMETHODCALLTYPE CCodeCoverage::ModuleAttachedToAssembly(
/* [in] */ ModuleID moduleId,
/* [in] */ AssemblyID assemblyId)
{
if (m_chainedProfiler != NULL)
m_chainedProfiler->ModuleAttachedToAssembly(moduleId, assemblyId);
FakesModulesAttachedToAssembly(moduleId, assemblyId);
std::wstring modulePath = GetModulePath(moduleId);
std::wstring assemblyName = GetAssemblyName(assemblyId);
/*ATLTRACE(_T("::ModuleAttachedToAssembly(...) => (%X => %s, %X => %s)"),
moduleId, W2CT(modulePath.c_str()),
assemblyId, W2CT(assemblyName.c_str()));*/
m_allowModules[modulePath] = m_host.TrackAssembly((LPWSTR)modulePath.c_str(), (LPWSTR)assemblyName.c_str());
m_allowModulesAssemblyMap[modulePath] = assemblyName;
return S_OK;
}
/// <summary>Handle <c>ICorProfilerCallback::JITCompilationStarted</c></summary>
/// <remarks>The 'workhorse' </remarks>
HRESULT STDMETHODCALLTYPE CCodeCoverage::JITCompilationStarted(
/* [in] */ FunctionID functionId,
/* [in] */ BOOL fIsSafeToBlock)
{
std::wstring modulePath;
mdToken functionToken;
ModuleID moduleId;
AssemblyID assemblyId;
if (GetTokenAndModule(functionId, functionToken, moduleId, modulePath, &assemblyId))
{
// add the bodies for our cuckoo methods when required
if (MSCORLIB_NAME == GetAssemblyName(assemblyId))
{
if (m_cuckooCriticalToken == functionToken)
{
COM_FAIL_RETURNMSG(AddCriticalCuckooBody(moduleId),
_T(" ::JITCompilationStarted => AddCriticalCuckooBody(0x%x)"));
}
if (m_cuckooSafeToken == functionToken)
{
COM_FAIL_RETURNMSG(AddSafeCuckooBody(moduleId),
_T(" ::JITCompilationStarted => AddSafeCuckooBody(0x%x)"));
}
}
if (!m_allowModules[modulePath]) return S_OK;
ATLTRACE(_T("::JITCompilationStarted(%X, %d, (%X)%s)"), functionId, functionToken, moduleId, W2CT(modulePath.c_str()));
std::vector<SequencePoint> seqPoints;
std::vector<BranchPoint> brPoints;
mdMethodDef injectedVisitedMethod = RegisterSafeCuckooMethod(moduleId);
if (m_host.GetPoints(functionToken, (LPWSTR)modulePath.c_str(),
(LPWSTR)m_allowModulesAssemblyMap[modulePath].c_str(), seqPoints, brPoints))
{
if (seqPoints.size()==0) return S_OK;
LPCBYTE pMethodHeader = NULL;
ULONG iMethodSize = 0;
COM_FAIL_RETURNMSG(m_profilerInfo2->GetILFunctionBody(moduleId, functionToken, &pMethodHeader, &iMethodSize),
_T(" ::JITCompilationStarted => GetILFunctionBody(0x%x)"));
IMAGE_COR_ILMETHOD* pMethod = (IMAGE_COR_ILMETHOD*)pMethodHeader;
CoverageInstrumentation instumentedMethod(pMethod);
instumentedMethod.IncrementStackSize(2);
ATLTRACE(_T("::JITCompilationStarted => Instrumenting..."));
//seqPoints.clear();
//brPoints.clear();
instumentedMethod.AddSequenceCoverage(injectedVisitedMethod, seqPoints);
instumentedMethod.AddBranchCoverage(injectedVisitedMethod, brPoints);
instumentedMethod.DumpIL();
CComPtr<IMethodMalloc> methodMalloc;
COM_FAIL_RETURNMSG(m_profilerInfo2->GetILFunctionBodyAllocator(moduleId, &methodMalloc),
_T(" ::JITCompilationStarted => GetILFunctionBodyAllocator(0x%x)"));
IMAGE_COR_ILMETHOD* pNewMethod = (IMAGE_COR_ILMETHOD*)methodMalloc->Alloc(instumentedMethod.GetMethodSize());
instumentedMethod.WriteMethod(pNewMethod);
COM_FAIL_RETURNMSG(m_profilerInfo2->SetILFunctionBody(moduleId, functionToken, (LPCBYTE) pNewMethod),
_T(" ::JITCompilationStarted => SetILFunctionBody(0x%x)"));
ULONG mapSize = instumentedMethod.GetILMapSize();
COR_IL_MAP * pMap = (COR_IL_MAP *)CoTaskMemAlloc(mapSize * sizeof(COR_IL_MAP));
instumentedMethod.PopulateILMap(mapSize, pMap);
COM_FAIL_RETURNMSG(m_profilerInfo2->SetILInstrumentedCodeMap(functionId, TRUE, mapSize, pMap),
_T(" ::JITCompilationStarted => SetILInstrumentedCodeMap(0x%x)"));
// only do this for .NET4 and above as there are issues with earlier runtimes (Access Violations)
if (m_runtimeVersion.usMajorVersion >= 4)
CoTaskMemFree(pMap);
}
}
return S_OK;
}
HRESULT _stdcall DllRegisterServer()
{
#if _DEBUG
// attach point
MessageBoxW(nullptr, L"Attach this process if you debug.", L"Check", MB_OK);
#endif
HRESULT hr = SetupRegisterServer(CLSID_AudioMixDownFilter, NAME_AudioMixDownFilter, GetAssemblyName(g_hInst));
assert(SUCCEEDED(hr));
{
::Microsoft::WRL::ComPtr<IFilterMapper2> filterMapper2;
hr = CoCreateInstance(CLSID_FilterMapper2, nullptr, CLSCTX_INPROC_SERVER, IID_IFilterMapper2, reinterpret_cast<void**>(filterMapper2.GetAddressOf()));
if (SUCCEEDED(hr))
{
hr = filterMapper2->RegisterFilter(
CLSID_AudioMixDownFilter,
NAME_AudioMixDownFilter,
nullptr,
nullptr,
nullptr,
®istrationFilter);
}
}
CoUninitialize();
return hr;
}
