From: Sergey Andreenko Date: Wed, 21 Jun 2017 07:27:08 +0000 (-0700) Subject: Spmi source code cleaning (dotnet/coreclr#12378) X-Git-Tag: submit/tizen/20210909.063632~11030^2~6925^2~376 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=7d155ef6fa4e8b0f85a2a5601d73e41a01f07998;p=platform%2Fupstream%2Fdotnet%2Fruntime.git Spmi source code cleaning (dotnet/coreclr#12378) * fix pointer names in CORINFO_RESOLVED_TOKENin * Remove exceptionCode from Agnostic_CORINFO_RESOLVED_TOKENout The target if to do Agnostic_CORINFO_RESOLVED_TOKEN = Agnostic_CORINFO_RESOLVED_TOKENin + Agnostic_CORINFO_RESOLVED_TOKENout * Agnostic_CORINFO_RESOLVED_TOKEN = Agnostic_CORINFO_RESOLVED_TOKENin + Agnostic_CORINFO_RESOLVED_TOKENout * spmi cleaning for ResolvedToken. It is only the first part of changes. I am trying to delete as many code as I can, because for now it is bad pain to make changes in this files. Commit migrated from https://github.com/dotnet/coreclr/commit/9121670c7a3f927c4a7a4b9711fdc904eeef281c --- diff --git a/src/coreclr/src/ToolBox/superpmi/superpmi-shared/lwmlist.h b/src/coreclr/src/ToolBox/superpmi/superpmi-shared/lwmlist.h index 6e5f016..2ee465d 100644 --- a/src/coreclr/src/ToolBox/superpmi/superpmi-shared/lwmlist.h +++ b/src/coreclr/src/ToolBox/superpmi/superpmi-shared/lwmlist.h @@ -140,9 +140,9 @@ LWM(IsValueClass, DWORDLONG, DWORD) LWM(IsWriteBarrierHelperRequired, DWORDLONG, DWORD) LWM(MergeClasses, DLDL, DWORDLONG) LWM(PInvokeMarshalingRequired, Agnostic_PInvokeMarshalingRequired, DWORD) -LWM(ResolveToken, Agnostic_CORINFO_RESOLVED_TOKENin, Agnostic_CORINFO_RESOLVED_TOKENout) +LWM(ResolveToken, Agnostic_CORINFO_RESOLVED_TOKENin, ResolveTokenValue) LWM(ResolveVirtualMethod, Agnostic_ResolveVirtualMethod, DWORDLONG) -LWM(TryResolveToken, Agnostic_CORINFO_RESOLVED_TOKENin, Agnostic_CORINFO_RESOLVED_TOKENout) +LWM(TryResolveToken, Agnostic_CORINFO_RESOLVED_TOKENin, TryResolveTokenValue) LWM(SatisfiesClassConstraints, DWORDLONG, DWORD) LWM(SatisfiesMethodConstraints, DLDL, DWORD) LWM(ShouldEnforceCallvirtRestriction, DWORDLONG, DWORD) diff --git a/src/coreclr/src/ToolBox/superpmi/superpmi-shared/methodcontext.cpp b/src/coreclr/src/ToolBox/superpmi/superpmi-shared/methodcontext.cpp index 6ee3806..8f6b691 100644 --- a/src/coreclr/src/ToolBox/superpmi/superpmi-shared/methodcontext.cpp +++ b/src/coreclr/src/ToolBox/superpmi/superpmi-shared/methodcontext.cpp @@ -14,6 +14,7 @@ #include "compileresult.h" #include "lightweightmap.h" #include "callutils.h" +#include "spmirecordhelper.h" struct { @@ -1276,64 +1277,46 @@ CorInfoInline MethodContext::repCanInline(CORINFO_METHOD_HANDLE callerHnd, void MethodContext::recResolveToken(CORINFO_RESOLVED_TOKEN* pResolvedToken, DWORD exceptionCode) { if (ResolveToken == nullptr) - ResolveToken = new LightWeightMap(); + ResolveToken = new LightWeightMap(); Agnostic_CORINFO_RESOLVED_TOKENin key; ZeroMemory(&key, sizeof(Agnostic_CORINFO_RESOLVED_TOKENin)); // We use the input structs as a key and use memcmp to // compare.. so we need to zero out padding too - Agnostic_CORINFO_RESOLVED_TOKENout value; - - key.tokenContext = (DWORDLONG)pResolvedToken->tokenContext; - key.tokenScope = (DWORDLONG)pResolvedToken->tokenScope; - key.token = (DWORD)pResolvedToken->token; - key.tokenType = (DWORD)pResolvedToken->tokenType; - - value.hClass = (DWORDLONG)pResolvedToken->hClass; - value.hMethod = (DWORDLONG)pResolvedToken->hMethod; - value.hField = (DWORDLONG)pResolvedToken->hField; - value.pTypeSpec_Index = - (DWORD)ResolveToken->AddBuffer((unsigned char*)pResolvedToken->pTypeSpec, pResolvedToken->cbTypeSpec); - value.cbTypeSpec = (DWORD)pResolvedToken->cbTypeSpec; - value.pMethodSpec_Index = - (DWORD)ResolveToken->AddBuffer((unsigned char*)pResolvedToken->pMethodSpec, pResolvedToken->cbMethodSpec); - value.cbMethodSpec = (DWORD)pResolvedToken->cbMethodSpec; + key = SpmiRecordsHelper::CreateAgnostic_CORINFO_RESOLVED_TOKENin(pResolvedToken); + + ResolveTokenValue value; + value.tokenOut = SpmiRecordsHelper::StoreAgnostic_CORINFO_RESOLVED_TOKENout(pResolvedToken, ResolveToken); value.exceptionCode = (DWORD)exceptionCode; ResolveToken->Add(key, value); DEBUG_REC(dmpResolveToken(key, value)); } -void MethodContext::dmpResolveToken(const Agnostic_CORINFO_RESOLVED_TOKENin& key, - const Agnostic_CORINFO_RESOLVED_TOKENout& value) +void MethodContext::dmpResolveToken(const Agnostic_CORINFO_RESOLVED_TOKENin& key, const ResolveTokenValue& value) { printf("ResolveToken key tc-%016llX ts-%016llX tok-%08X tt-%u", key.tokenContext, key.tokenScope, key.token, key.tokenType); - printf(", value cls-%016llX meth-%016llX fld-%016llX ti-%u ts-%u mi-%u ms-%u excp-%08X", value.hClass, - value.hMethod, value.hField, value.pTypeSpec_Index, value.cbTypeSpec, value.pMethodSpec_Index, - value.cbMethodSpec, value.exceptionCode); + printf(", value cls-%016llX meth-%016llX fld-%016llX ti-%u ts-%u mi-%u ms-%u excp-%08X", value.tokenOut.hClass, + value.tokenOut.hMethod, value.tokenOut.hField, value.tokenOut.pTypeSpec_Index, value.tokenOut.cbTypeSpec, + value.tokenOut.pMethodSpec_Index, value.tokenOut.cbMethodSpec, value.exceptionCode); } void MethodContext::repResolveToken(CORINFO_RESOLVED_TOKEN* pResolvedToken, DWORD* exceptionCode) { Agnostic_CORINFO_RESOLVED_TOKENin key; ZeroMemory(&key, sizeof(Agnostic_CORINFO_RESOLVED_TOKENin)); // We use the input structs as a key and use memcmp to // compare.. so we need to zero out padding too - Agnostic_CORINFO_RESOLVED_TOKENout value; - - key.tokenContext = (DWORDLONG)pResolvedToken->tokenContext; - key.tokenScope = (DWORDLONG)pResolvedToken->tokenScope; - key.token = (DWORD)pResolvedToken->token; - key.tokenType = (DWORD)pResolvedToken->tokenType; + key = SpmiRecordsHelper::CreateAgnostic_CORINFO_RESOLVED_TOKENin(pResolvedToken); AssertCodeMsg(ResolveToken->GetIndex(key) != -1, EXCEPTIONCODE_MC, "Didn't find %x", pResolvedToken->token); - value = ResolveToken->Get(key); + ResolveTokenValue value = ResolveToken->Get(key); - pResolvedToken->hClass = (CORINFO_CLASS_HANDLE)value.hClass; - pResolvedToken->hMethod = (CORINFO_METHOD_HANDLE)value.hMethod; - pResolvedToken->hField = (CORINFO_FIELD_HANDLE)value.hField; - pResolvedToken->pTypeSpec = (PCCOR_SIGNATURE)ResolveToken->GetBuffer(value.pTypeSpec_Index); - pResolvedToken->cbTypeSpec = (ULONG)value.cbTypeSpec; - pResolvedToken->pMethodSpec = (PCCOR_SIGNATURE)ResolveToken->GetBuffer(value.pMethodSpec_Index); - pResolvedToken->cbMethodSpec = (ULONG)value.cbMethodSpec; + pResolvedToken->hClass = (CORINFO_CLASS_HANDLE)value.tokenOut.hClass; + pResolvedToken->hMethod = (CORINFO_METHOD_HANDLE)value.tokenOut.hMethod; + pResolvedToken->hField = (CORINFO_FIELD_HANDLE)value.tokenOut.hField; + pResolvedToken->pTypeSpec = (PCCOR_SIGNATURE)ResolveToken->GetBuffer(value.tokenOut.pTypeSpec_Index); + pResolvedToken->cbTypeSpec = (ULONG)value.tokenOut.cbTypeSpec; + pResolvedToken->pMethodSpec = (PCCOR_SIGNATURE)ResolveToken->GetBuffer(value.tokenOut.pMethodSpec_Index); + pResolvedToken->cbMethodSpec = (ULONG)value.tokenOut.cbMethodSpec; *exceptionCode = (DWORD)value.exceptionCode; DEBUG_REP(dmpResolveToken(key, value)); @@ -1342,75 +1325,49 @@ void MethodContext::repResolveToken(CORINFO_RESOLVED_TOKEN* pResolvedToken, DWOR void MethodContext::recTryResolveToken(CORINFO_RESOLVED_TOKEN* pResolvedToken, bool success) { if (TryResolveToken == nullptr) - TryResolveToken = new LightWeightMap(); + TryResolveToken = new LightWeightMap(); Agnostic_CORINFO_RESOLVED_TOKENin key; ZeroMemory(&key, sizeof(Agnostic_CORINFO_RESOLVED_TOKENin)); // We use the input structs as a key and use memcmp to // compare.. so we need to zero out padding too - Agnostic_CORINFO_RESOLVED_TOKENout value; - - key.tokenContext = (DWORDLONG)pResolvedToken->tokenContext; - key.tokenScope = (DWORDLONG)pResolvedToken->tokenScope; - key.token = (DWORD)pResolvedToken->token; - key.tokenType = (DWORD)pResolvedToken->tokenType; - - value.hClass = (DWORDLONG)pResolvedToken->hClass; - value.hMethod = (DWORDLONG)pResolvedToken->hMethod; - value.hField = (DWORDLONG)pResolvedToken->hField; - value.pTypeSpec_Index = - (DWORD)ResolveToken->AddBuffer((unsigned char*)pResolvedToken->pTypeSpec, pResolvedToken->cbTypeSpec); - value.cbTypeSpec = (DWORD)pResolvedToken->cbTypeSpec; - value.pMethodSpec_Index = - (DWORD)ResolveToken->AddBuffer((unsigned char*)pResolvedToken->pMethodSpec, pResolvedToken->cbMethodSpec); - value.cbMethodSpec = (DWORD)pResolvedToken->cbMethodSpec; - value.exceptionCode = success ? 0 : 1; + key = SpmiRecordsHelper::CreateAgnostic_CORINFO_RESOLVED_TOKENin(pResolvedToken); + + TryResolveTokenValue value; + + value.tokenOut = SpmiRecordsHelper::StoreAgnostic_CORINFO_RESOLVED_TOKENout(pResolvedToken, ResolveToken); + value.success = success ? 0 : 1; TryResolveToken->Add(key, value); DEBUG_REC(dmpTryResolveToken(key, value)); } -void MethodContext::dmpTryResolveToken(const Agnostic_CORINFO_RESOLVED_TOKENin& key, - const Agnostic_CORINFO_RESOLVED_TOKENout& value) +void MethodContext::dmpTryResolveToken(const Agnostic_CORINFO_RESOLVED_TOKENin& key, const TryResolveTokenValue& value) { printf("TryResolveToken key tc-%016llX ts-%016llX tok-%08X tt-%u", key.tokenContext, key.tokenScope, key.token, key.tokenType); - printf(", value cls-%016llX meth-%016llX fld-%016llX ti-%u ts-%u mi-%u ms-%u failed-%u", value.hClass, - value.hMethod, value.hField, value.pTypeSpec_Index, value.cbTypeSpec, value.pMethodSpec_Index, - value.cbMethodSpec, value.exceptionCode); + printf(", value cls-%016llX meth-%016llX fld-%016llX ti-%u ts-%u mi-%u ms-%u failed-%u", value.tokenOut.hClass, + value.tokenOut.hMethod, value.tokenOut.hField, value.tokenOut.pTypeSpec_Index, value.tokenOut.cbTypeSpec, + value.tokenOut.pMethodSpec_Index, value.tokenOut.cbMethodSpec, value.success); } bool MethodContext::repTryResolveToken(CORINFO_RESOLVED_TOKEN* pResolvedToken) { Agnostic_CORINFO_RESOLVED_TOKENin key; ZeroMemory(&key, sizeof(Agnostic_CORINFO_RESOLVED_TOKENin)); // We use the input structs as a key and use memcmp to // compare.. so we need to zero out padding too - Agnostic_CORINFO_RESOLVED_TOKENout value; - key.tokenContext = (DWORDLONG)pResolvedToken->tokenContext; - key.tokenScope = (DWORDLONG)pResolvedToken->tokenScope; - key.token = (DWORD)pResolvedToken->token; - key.tokenType = (DWORD)pResolvedToken->tokenType; + key = SpmiRecordsHelper::CreateAgnostic_CORINFO_RESOLVED_TOKENin(pResolvedToken); - // Best-effort: if the `tryResolveToken` map is missing or the key is not found therein, - // fall back to the `resolveToken` map. - if (TryResolveToken != nullptr && TryResolveToken->GetIndex(key) != -1) - { - value = TryResolveToken->Get(key); - } - else - { - AssertCodeMsg(ResolveToken->GetIndex(key) != -1, EXCEPTIONCODE_MC, "Didn't find %x", pResolvedToken->token); - value = ResolveToken->Get(key); - } + TryResolveTokenValue value = TryResolveToken->Get(key); - pResolvedToken->hClass = (CORINFO_CLASS_HANDLE)value.hClass; - pResolvedToken->hMethod = (CORINFO_METHOD_HANDLE)value.hMethod; - pResolvedToken->hField = (CORINFO_FIELD_HANDLE)value.hField; - pResolvedToken->pTypeSpec = (PCCOR_SIGNATURE)ResolveToken->GetBuffer(value.pTypeSpec_Index); - pResolvedToken->cbTypeSpec = (ULONG)value.cbTypeSpec; - pResolvedToken->pMethodSpec = (PCCOR_SIGNATURE)ResolveToken->GetBuffer(value.pMethodSpec_Index); - pResolvedToken->cbMethodSpec = (ULONG)value.cbMethodSpec; + pResolvedToken->hClass = (CORINFO_CLASS_HANDLE)value.tokenOut.hClass; + pResolvedToken->hMethod = (CORINFO_METHOD_HANDLE)value.tokenOut.hMethod; + pResolvedToken->hField = (CORINFO_FIELD_HANDLE)value.tokenOut.hField; + pResolvedToken->pTypeSpec = (PCCOR_SIGNATURE)ResolveToken->GetBuffer(value.tokenOut.pTypeSpec_Index); + pResolvedToken->cbTypeSpec = (ULONG)value.tokenOut.cbTypeSpec; + pResolvedToken->pMethodSpec = (PCCOR_SIGNATURE)ResolveToken->GetBuffer(value.tokenOut.pMethodSpec_Index); + pResolvedToken->cbMethodSpec = (ULONG)value.tokenOut.cbMethodSpec; DEBUG_REP(dmpTryResolveToken(key, value)); - return (DWORD)value.exceptionCode == 0; + return (DWORD)value.success == 0; } void MethodContext::recGetCallInfo(CORINFO_RESOLVED_TOKEN* pResolvedToken, @@ -1426,57 +1383,32 @@ void MethodContext::recGetCallInfo(CORINFO_RESOLVED_TOKEN* pResolvedToken, Agnostic_GetCallInfo key; ZeroMemory(&key, sizeof(Agnostic_GetCallInfo)); // We use the input structs as a key and use memcmp to compare.. so // we need to zero out padding too - Agnostic_CORINFO_CALL_INFO value; + key.ResolvedToken = SpmiRecordsHelper::StoreAgnostic_CORINFO_RESOLVED_TOKEN(pResolvedToken, GetCallInfo); - key.ResolvedToken.tokenContext = (DWORDLONG)pResolvedToken->tokenContext; - key.ResolvedToken.tokenScope = (DWORDLONG)pResolvedToken->tokenScope; - key.ResolvedToken.token = (DWORD)pResolvedToken->token; - key.ResolvedToken.tokenType = (DWORD)pResolvedToken->tokenType; - key.ResolvedToken.hClass = (DWORDLONG)pResolvedToken->hClass; - key.ResolvedToken.hMethod = (DWORDLONG)pResolvedToken->hMethod; - key.ResolvedToken.hField = (DWORDLONG)pResolvedToken->hField; - key.ResolvedToken.typeSpec_Index = - (DWORD)GetCallInfo->AddBuffer((unsigned char*)pResolvedToken->pTypeSpec, pResolvedToken->cbTypeSpec); - key.ResolvedToken.cbTypeSpec = (DWORD)pResolvedToken->cbTypeSpec; - key.ResolvedToken.methodSpec_Index = - (DWORD)GetCallInfo->AddBuffer((unsigned char*)pResolvedToken->pMethodSpec, pResolvedToken->cbMethodSpec); - key.ResolvedToken.cbMethodSpec = (DWORD)pResolvedToken->cbMethodSpec; if (pConstrainedResolvedToken != nullptr) { - key.ConstrainedResolvedToken.tokenContext = (DWORDLONG)pConstrainedResolvedToken->tokenContext; - key.ConstrainedResolvedToken.tokenScope = (DWORDLONG)pConstrainedResolvedToken->tokenScope; - key.ConstrainedResolvedToken.token = (DWORD)pConstrainedResolvedToken->token; - key.ConstrainedResolvedToken.tokenType = (DWORD)pConstrainedResolvedToken->tokenType; - key.ConstrainedResolvedToken.hClass = (DWORDLONG)pConstrainedResolvedToken->hClass; - key.ConstrainedResolvedToken.hMethod = (DWORDLONG)pConstrainedResolvedToken->hMethod; - key.ConstrainedResolvedToken.hField = (DWORDLONG)pConstrainedResolvedToken->hField; - key.ConstrainedResolvedToken.typeSpec_Index = - (DWORD)GetCallInfo->AddBuffer((unsigned char*)pConstrainedResolvedToken->pTypeSpec, - pConstrainedResolvedToken->cbTypeSpec); - key.ConstrainedResolvedToken.cbTypeSpec = (DWORD)pConstrainedResolvedToken->cbTypeSpec; - key.ConstrainedResolvedToken.methodSpec_Index = - (DWORD)GetCallInfo->AddBuffer((unsigned char*)pConstrainedResolvedToken->pMethodSpec, - pConstrainedResolvedToken->cbMethodSpec); - key.ConstrainedResolvedToken.cbMethodSpec = (DWORD)pConstrainedResolvedToken->cbMethodSpec; + key.ConstrainedResolvedToken = + SpmiRecordsHelper::StoreAgnostic_CORINFO_RESOLVED_TOKEN(pConstrainedResolvedToken, GetCallInfo); } else { - key.ConstrainedResolvedToken.tokenContext = (DWORDLONG)0; - key.ConstrainedResolvedToken.tokenScope = (DWORDLONG)0; - key.ConstrainedResolvedToken.token = (DWORD)0; - key.ConstrainedResolvedToken.tokenType = (DWORD)0; - key.ConstrainedResolvedToken.hClass = (DWORDLONG)0; - key.ConstrainedResolvedToken.hMethod = (DWORDLONG)0; - key.ConstrainedResolvedToken.hField = (DWORDLONG)0; - key.ConstrainedResolvedToken.typeSpec_Index = (DWORD)0; - key.ConstrainedResolvedToken.cbTypeSpec = (DWORD)0; - key.ConstrainedResolvedToken.methodSpec_Index = (DWORD)0; - key.ConstrainedResolvedToken.cbMethodSpec = (DWORD)0; + key.ConstrainedResolvedToken.inValue.tokenContext = (DWORDLONG)0; + key.ConstrainedResolvedToken.inValue.tokenScope = (DWORDLONG)0; + key.ConstrainedResolvedToken.inValue.token = (DWORD)0; + key.ConstrainedResolvedToken.inValue.tokenType = (DWORD)0; + key.ConstrainedResolvedToken.outValue.hClass = (DWORDLONG)0; + key.ConstrainedResolvedToken.outValue.hMethod = (DWORDLONG)0; + key.ConstrainedResolvedToken.outValue.hField = (DWORDLONG)0; + key.ConstrainedResolvedToken.outValue.pTypeSpec_Index = (DWORD)0; + key.ConstrainedResolvedToken.outValue.cbTypeSpec = (DWORD)0; + key.ConstrainedResolvedToken.outValue.pMethodSpec_Index = (DWORD)0; + key.ConstrainedResolvedToken.outValue.cbMethodSpec = (DWORD)0; } key.callerHandle = (DWORDLONG)callerHandle; key.flags = (DWORD)flags; + Agnostic_CORINFO_CALL_INFO value; if (exceptionCode == 0) { value.hMethod = (DWORDLONG)pResult->hMethod; @@ -1610,16 +1542,17 @@ void MethodContext::dmpGetCallInfo(const Agnostic_GetCallInfo& key, const Agnost " rt{tc-%016llX ts-%016llX tok-%08X tt-%u cls-%016llX meth-%016llX fld-%016llX ti-%u ts-%u mi-%u ms-%u}" " crt{tc-%016llX ts-%016llX tok-%08X tt-%u cls-%016llX meth-%016llX fld-%016llX ti-%u ts-%u mi-%u ms-%u}" " ch-%016llX flg-%08X", - key.ResolvedToken.tokenContext, key.ResolvedToken.tokenScope, key.ResolvedToken.token, - key.ResolvedToken.tokenType, key.ResolvedToken.hClass, key.ResolvedToken.hMethod, key.ResolvedToken.hField, - key.ResolvedToken.typeSpec_Index, key.ResolvedToken.cbTypeSpec, key.ResolvedToken.methodSpec_Index, - key.ResolvedToken.cbMethodSpec, key.ConstrainedResolvedToken.tokenContext, - key.ConstrainedResolvedToken.tokenScope, key.ConstrainedResolvedToken.token, - key.ConstrainedResolvedToken.tokenType, key.ConstrainedResolvedToken.hClass, - key.ConstrainedResolvedToken.hMethod, key.ConstrainedResolvedToken.hField, - key.ConstrainedResolvedToken.typeSpec_Index, key.ConstrainedResolvedToken.cbTypeSpec, - key.ConstrainedResolvedToken.methodSpec_Index, key.ConstrainedResolvedToken.cbMethodSpec, key.callerHandle, - key.flags); + key.ResolvedToken.inValue.tokenContext, key.ResolvedToken.inValue.tokenScope, + key.ResolvedToken.inValue.token, key.ResolvedToken.inValue.tokenType, key.ResolvedToken.outValue.hClass, + key.ResolvedToken.outValue.hMethod, key.ResolvedToken.outValue.hField, + key.ResolvedToken.outValue.pTypeSpec_Index, key.ResolvedToken.outValue.cbTypeSpec, + key.ResolvedToken.outValue.pMethodSpec_Index, key.ResolvedToken.outValue.cbMethodSpec, + key.ConstrainedResolvedToken.inValue.tokenContext, key.ConstrainedResolvedToken.inValue.tokenScope, + key.ConstrainedResolvedToken.inValue.token, key.ConstrainedResolvedToken.inValue.tokenType, + key.ConstrainedResolvedToken.outValue.hClass, key.ConstrainedResolvedToken.outValue.hMethod, + key.ConstrainedResolvedToken.outValue.hField, key.ConstrainedResolvedToken.outValue.pTypeSpec_Index, + key.ConstrainedResolvedToken.outValue.cbTypeSpec, key.ConstrainedResolvedToken.outValue.pMethodSpec_Index, + key.ConstrainedResolvedToken.outValue.cbMethodSpec, key.callerHandle, key.flags); printf(", value mth-%016llX, mf-%08X cf-%08X" " sig{flg-%08X na-%u cc-%u ci-%u mc-%u mi-%u args-%016llX scp-%016llX tok-%08X}" " vsig{flg-%08X na-%u cc-%u ci-%u mc-%u mi-%u args-%016llX scp-%016llX tok-%08X}" @@ -1644,59 +1577,35 @@ void MethodContext::repGetCallInfo(CORINFO_RESOLVED_TOKEN* pResolvedToken, Agnostic_GetCallInfo key; ZeroMemory(&key, sizeof(Agnostic_GetCallInfo)); // We use the input structs as a key and use memcmp to compare.. so // we need to zero out padding too - Agnostic_CORINFO_CALL_INFO value; - - key.ResolvedToken.tokenContext = (DWORDLONG)pResolvedToken->tokenContext; - key.ResolvedToken.tokenScope = (DWORDLONG)pResolvedToken->tokenScope; - key.ResolvedToken.token = (DWORD)pResolvedToken->token; - key.ResolvedToken.tokenType = (DWORD)pResolvedToken->tokenType; - key.ResolvedToken.hClass = (DWORDLONG)pResolvedToken->hClass; - key.ResolvedToken.hMethod = (DWORDLONG)pResolvedToken->hMethod; - key.ResolvedToken.hField = (DWORDLONG)pResolvedToken->hField; - key.ResolvedToken.typeSpec_Index = - (DWORD)GetCallInfo->Contains((unsigned char*)pResolvedToken->pTypeSpec, pResolvedToken->cbTypeSpec); - key.ResolvedToken.cbTypeSpec = (DWORD)pResolvedToken->cbTypeSpec; - key.ResolvedToken.methodSpec_Index = - (DWORD)GetCallInfo->Contains((unsigned char*)pResolvedToken->pMethodSpec, pResolvedToken->cbMethodSpec); - key.ResolvedToken.cbMethodSpec = (DWORD)pResolvedToken->cbMethodSpec; + key.ResolvedToken = SpmiRecordsHelper::RestoreAgnostic_CORINFO_RESOLVED_TOKEN(pResolvedToken, GetCallInfo); if (pConstrainedResolvedToken != nullptr) { - key.ConstrainedResolvedToken.tokenContext = (DWORDLONG)pConstrainedResolvedToken->tokenContext; - key.ConstrainedResolvedToken.tokenScope = (DWORDLONG)pConstrainedResolvedToken->tokenScope; - key.ConstrainedResolvedToken.token = (DWORD)pConstrainedResolvedToken->token; - key.ConstrainedResolvedToken.tokenType = (DWORD)pConstrainedResolvedToken->tokenType; - key.ConstrainedResolvedToken.hClass = (DWORDLONG)pConstrainedResolvedToken->hClass; - key.ConstrainedResolvedToken.hMethod = (DWORDLONG)pConstrainedResolvedToken->hMethod; - key.ConstrainedResolvedToken.hField = (DWORDLONG)pConstrainedResolvedToken->hField; - key.ConstrainedResolvedToken.typeSpec_Index = - (DWORD)GetCallInfo->Contains((unsigned char*)pConstrainedResolvedToken->pTypeSpec, - pConstrainedResolvedToken->cbTypeSpec); - key.ConstrainedResolvedToken.cbTypeSpec = (DWORD)pConstrainedResolvedToken->cbTypeSpec; - key.ConstrainedResolvedToken.methodSpec_Index = - (DWORD)GetCallInfo->Contains((unsigned char*)pConstrainedResolvedToken->pMethodSpec, - pConstrainedResolvedToken->cbMethodSpec); - key.ConstrainedResolvedToken.cbMethodSpec = (DWORD)pConstrainedResolvedToken->cbMethodSpec; + key.ConstrainedResolvedToken = + SpmiRecordsHelper::RestoreAgnostic_CORINFO_RESOLVED_TOKEN(pConstrainedResolvedToken, GetCallInfo); } else { - key.ConstrainedResolvedToken.tokenContext = (DWORDLONG)0; - key.ConstrainedResolvedToken.tokenScope = (DWORDLONG)0; - key.ConstrainedResolvedToken.token = (DWORD)0; - key.ConstrainedResolvedToken.tokenType = (DWORD)0; - key.ConstrainedResolvedToken.hClass = (DWORDLONG)0; - key.ConstrainedResolvedToken.hMethod = (DWORDLONG)0; - key.ConstrainedResolvedToken.hField = (DWORDLONG)0; - key.ConstrainedResolvedToken.typeSpec_Index = (DWORD)0; - key.ConstrainedResolvedToken.cbTypeSpec = (DWORD)0; - key.ConstrainedResolvedToken.methodSpec_Index = (DWORD)0; - key.ConstrainedResolvedToken.cbMethodSpec = (DWORD)0; + key.ConstrainedResolvedToken.inValue.tokenContext = (DWORDLONG)0; + key.ConstrainedResolvedToken.inValue.tokenScope = (DWORDLONG)0; + key.ConstrainedResolvedToken.inValue.token = (DWORD)0; + key.ConstrainedResolvedToken.inValue.tokenType = (DWORD)0; + key.ConstrainedResolvedToken.outValue.hClass = (DWORDLONG)0; + key.ConstrainedResolvedToken.outValue.hMethod = (DWORDLONG)0; + key.ConstrainedResolvedToken.outValue.hField = (DWORDLONG)0; + key.ConstrainedResolvedToken.outValue.pTypeSpec_Index = (DWORD)0; + key.ConstrainedResolvedToken.outValue.cbTypeSpec = (DWORD)0; + key.ConstrainedResolvedToken.outValue.pMethodSpec_Index = (DWORD)0; + key.ConstrainedResolvedToken.outValue.cbMethodSpec = (DWORD)0; } key.callerHandle = (DWORDLONG)callerHandle; key.flags = (DWORD)flags; AssertCodeMsg(GetCallInfo->GetIndex(key) != -1, EXCEPTIONCODE_MC, - "Didn't find %08x, %016llx. Probably a missing exception in GetCallInfo", key.ResolvedToken.token, - key.ResolvedToken.hClass); + "Didn't find %08x, %016llx. Probably a missing exception in GetCallInfo", + key.ResolvedToken.inValue.token, key.ResolvedToken.outValue.hClass); + + Agnostic_CORINFO_CALL_INFO value; + value = GetCallInfo->Get(key); pResult->hMethod = (CORINFO_METHOD_HANDLE)value.hMethod; @@ -1812,10 +1721,10 @@ void MethodContext::repGetCallInfoFromMethodHandle(CORINFO_METHOD_HANDLE methodH CORINFO_RESOLVED_TOKEN resolvedToken; DWORD exceptionCode; - resolvedToken.tokenContext = (CORINFO_CONTEXT_HANDLE)key.ResolvedToken.tokenContext; - resolvedToken.tokenScope = (CORINFO_MODULE_HANDLE)key.ResolvedToken.tokenScope; - resolvedToken.token = (mdToken)key.ResolvedToken.token; - resolvedToken.tokenType = (CorInfoTokenKind)key.ResolvedToken.tokenType; + resolvedToken.tokenContext = (CORINFO_CONTEXT_HANDLE)key.ResolvedToken.inValue.tokenContext; + resolvedToken.tokenScope = (CORINFO_MODULE_HANDLE)key.ResolvedToken.inValue.tokenScope; + resolvedToken.token = (mdToken)key.ResolvedToken.inValue.token; + resolvedToken.tokenType = (CorInfoTokenKind)key.ResolvedToken.inValue.tokenType; repResolveToken(&resolvedToken, &exceptionCode); @@ -1826,15 +1735,17 @@ void MethodContext::repGetCallInfoFromMethodHandle(CORINFO_METHOD_HANDLE methodH CORINFO_RESOLVED_TOKEN constrainedResolvedToken; CORINFO_RESOLVED_TOKEN* pConstrainedResolvedToken = nullptr; - if (key.ConstrainedResolvedToken.tokenContext != 0 && key.ConstrainedResolvedToken.tokenScope != 0) + if (key.ConstrainedResolvedToken.inValue.tokenContext != 0 && + key.ConstrainedResolvedToken.inValue.tokenScope != 0) { constrainedResolvedToken.tokenContext = - (CORINFO_CONTEXT_HANDLE)key.ConstrainedResolvedToken.tokenContext; + (CORINFO_CONTEXT_HANDLE)key.ConstrainedResolvedToken.inValue.tokenContext; constrainedResolvedToken.tokenScope = - (CORINFO_MODULE_HANDLE)key.ConstrainedResolvedToken.tokenScope; - constrainedResolvedToken.token = (mdToken)key.ConstrainedResolvedToken.token; - constrainedResolvedToken.tokenType = (CorInfoTokenKind)key.ConstrainedResolvedToken.tokenType; - pConstrainedResolvedToken = &constrainedResolvedToken; + (CORINFO_MODULE_HANDLE)key.ConstrainedResolvedToken.inValue.tokenScope; + constrainedResolvedToken.token = (mdToken)key.ConstrainedResolvedToken.inValue.token; + constrainedResolvedToken.tokenType = + (CorInfoTokenKind)key.ConstrainedResolvedToken.inValue.tokenType; + pConstrainedResolvedToken = &constrainedResolvedToken; repResolveToken(pConstrainedResolvedToken, &exceptionCode); } @@ -3133,26 +3044,26 @@ void MethodContext::recGetNewHelper(CORINFO_RESOLVED_TOKEN* pResolvedToken, ZeroMemory(&key, sizeof(Agnostic_GetNewHelper)); // We use the input structs as a key and use memcmp to compare.. so // we need to zero out padding too - key.ResolvedToken.tokenContext = (DWORDLONG)0; - key.ResolvedToken.tokenScope = (DWORDLONG)0; - key.ResolvedToken.token = (DWORD)0; - key.ResolvedToken.tokenType = (DWORD)0; - key.ResolvedToken.hClass = (DWORDLONG)pResolvedToken->hClass; - key.ResolvedToken.hMethod = (DWORDLONG)0; - key.ResolvedToken.hField = (DWORDLONG)0; - key.ResolvedToken.typeSpec_Index = (DWORD)0; - key.ResolvedToken.cbTypeSpec = (DWORD)0; - key.ResolvedToken.methodSpec_Index = (DWORD)0; - key.ResolvedToken.cbMethodSpec = (DWORD)0; - key.callerHandle = (DWORDLONG)callerHandle; + key.ResolvedToken.inValue.tokenContext = (DWORDLONG)0; + key.ResolvedToken.inValue.tokenScope = (DWORDLONG)0; + key.ResolvedToken.inValue.token = (DWORD)0; + key.ResolvedToken.inValue.tokenType = (DWORD)0; + key.ResolvedToken.outValue.hClass = (DWORDLONG)pResolvedToken->hClass; + key.ResolvedToken.outValue.hMethod = (DWORDLONG)0; + key.ResolvedToken.outValue.hField = (DWORDLONG)0; + key.ResolvedToken.outValue.pTypeSpec_Index = (DWORD)0; + key.ResolvedToken.outValue.cbTypeSpec = (DWORD)0; + key.ResolvedToken.outValue.pMethodSpec_Index = (DWORD)0; + key.ResolvedToken.outValue.cbMethodSpec = (DWORD)0; + key.callerHandle = (DWORDLONG)callerHandle; GetNewHelper->Add(key, (DWORD)result); DEBUG_REC(dmpGetNewHelper(key, (DWORD)result)); } void MethodContext::dmpGetNewHelper(const Agnostic_GetNewHelper& key, DWORD value) { - printf("GetNewHelper key cls-%016llX chan-%016llX, value res-%u", key.ResolvedToken.hClass, key.callerHandle, - value); + printf("GetNewHelper key cls-%016llX chan-%016llX, value res-%u", key.ResolvedToken.outValue.hClass, + key.callerHandle, value); } CorInfoHelpFunc MethodContext::repGetNewHelper(CORINFO_RESOLVED_TOKEN* pResolvedToken, CORINFO_METHOD_HANDLE callerHandle) @@ -3161,23 +3072,23 @@ CorInfoHelpFunc MethodContext::repGetNewHelper(CORINFO_RESOLVED_TOKEN* pResolved ZeroMemory(&key, sizeof(Agnostic_GetNewHelper)); // We use the input structs as a key and use memcmp to compare.. so // we need to zero out padding too - key.ResolvedToken.tokenContext = (DWORDLONG)0; - key.ResolvedToken.tokenScope = (DWORDLONG)0; - key.ResolvedToken.token = (DWORD)0; - key.ResolvedToken.tokenType = (DWORD)0; - key.ResolvedToken.hClass = (DWORDLONG)pResolvedToken->hClass; - key.ResolvedToken.hMethod = (DWORDLONG)0; - key.ResolvedToken.hField = (DWORDLONG)0; - key.ResolvedToken.typeSpec_Index = (DWORD)0; - key.ResolvedToken.cbTypeSpec = (DWORD)0; - key.ResolvedToken.methodSpec_Index = (DWORD)0; - key.ResolvedToken.cbMethodSpec = (DWORD)0; - key.callerHandle = (DWORDLONG)callerHandle; + key.ResolvedToken.inValue.tokenContext = (DWORDLONG)0; + key.ResolvedToken.inValue.tokenScope = (DWORDLONG)0; + key.ResolvedToken.inValue.token = (DWORD)0; + key.ResolvedToken.inValue.tokenType = (DWORD)0; + key.ResolvedToken.outValue.hClass = (DWORDLONG)pResolvedToken->hClass; + key.ResolvedToken.outValue.hMethod = (DWORDLONG)0; + key.ResolvedToken.outValue.hField = (DWORDLONG)0; + key.ResolvedToken.outValue.pTypeSpec_Index = (DWORD)0; + key.ResolvedToken.outValue.cbTypeSpec = (DWORD)0; + key.ResolvedToken.outValue.pMethodSpec_Index = (DWORD)0; + key.ResolvedToken.outValue.cbMethodSpec = (DWORD)0; + key.callerHandle = (DWORDLONG)callerHandle; AssertCodeMsg(GetNewHelper != nullptr, EXCEPTIONCODE_MC, "Didn't find anything for %016llX", - (DWORDLONG)key.ResolvedToken.hClass); + (DWORDLONG)key.ResolvedToken.outValue.hClass); AssertCodeMsg(GetNewHelper->GetIndex(key) != -1, EXCEPTIONCODE_MC, "Didn't find %016llX", - (DWORDLONG)key.ResolvedToken.hClass); + (DWORDLONG)key.ResolvedToken.outValue.hClass); CorInfoHelpFunc value = (CorInfoHelpFunc)GetNewHelper->Get(key); DEBUG_REP(dmpGetNewHelper(key, value)); return value; @@ -3193,23 +3104,10 @@ void MethodContext::recEmbedGenericHandle(CORINFO_RESOLVED_TOKEN* pResolve Agnostic_EmbedGenericHandle key; ZeroMemory(&key, sizeof(Agnostic_EmbedGenericHandle)); // We use the input structs as a key and use memcmp to // compare.. so we need to zero out padding too - Agnostic_CORINFO_GENERICHANDLE_RESULT value; - - key.ResolvedToken.tokenContext = (DWORDLONG)pResolvedToken->tokenContext; - key.ResolvedToken.tokenScope = (DWORDLONG)pResolvedToken->tokenScope; - key.ResolvedToken.token = (DWORD)pResolvedToken->token; - key.ResolvedToken.tokenType = (DWORD)pResolvedToken->tokenType; - key.ResolvedToken.hClass = (DWORDLONG)pResolvedToken->hClass; - key.ResolvedToken.hMethod = (DWORDLONG)pResolvedToken->hMethod; - key.ResolvedToken.hField = (DWORDLONG)pResolvedToken->hField; - key.ResolvedToken.typeSpec_Index = - (DWORD)EmbedGenericHandle->AddBuffer((unsigned char*)pResolvedToken->pTypeSpec, pResolvedToken->cbTypeSpec); - key.ResolvedToken.cbTypeSpec = (DWORD)pResolvedToken->cbTypeSpec; - key.ResolvedToken.methodSpec_Index = - (DWORD)EmbedGenericHandle->AddBuffer((unsigned char*)pResolvedToken->pMethodSpec, pResolvedToken->cbMethodSpec); - key.ResolvedToken.cbMethodSpec = (DWORD)pResolvedToken->cbMethodSpec; - key.fEmbedParent = (DWORD)fEmbedParent; + key.ResolvedToken = SpmiRecordsHelper::StoreAgnostic_CORINFO_RESOLVED_TOKEN(pResolvedToken, EmbedGenericHandle); + key.fEmbedParent = (DWORD)fEmbedParent; + Agnostic_CORINFO_GENERICHANDLE_RESULT value; value.lookup.lookupKind.needsRuntimeLookup = (DWORD)pResult->lookup.lookupKind.needsRuntimeLookup; value.lookup.lookupKind.runtimeLookupKind = (DWORD)pResult->lookup.lookupKind.runtimeLookupKind; if (pResult->lookup.lookupKind.needsRuntimeLookup) @@ -3251,10 +3149,11 @@ void MethodContext::dmpEmbedGenericHandle(const Agnostic_EmbedGenericHandle& { printf("EmbedGenericHandle key rt{tokCon-%016llX tokScp-%016llX tok-%08X tokTyp-%08X cls-%016llX ftn-%016llX " "fld-%016llX tsi-%u cbts-%u msi-%u cbms-%u} emb-%u", - key.ResolvedToken.tokenContext, key.ResolvedToken.tokenScope, key.ResolvedToken.token, - key.ResolvedToken.tokenType, key.ResolvedToken.hClass, key.ResolvedToken.hMethod, key.ResolvedToken.hField, - key.ResolvedToken.typeSpec_Index, key.ResolvedToken.cbTypeSpec, key.ResolvedToken.methodSpec_Index, - key.ResolvedToken.cbMethodSpec, key.fEmbedParent); + key.ResolvedToken.inValue.tokenContext, key.ResolvedToken.inValue.tokenScope, + key.ResolvedToken.inValue.token, key.ResolvedToken.inValue.tokenType, key.ResolvedToken.outValue.hClass, + key.ResolvedToken.outValue.hMethod, key.ResolvedToken.outValue.hField, + key.ResolvedToken.outValue.pTypeSpec_Index, key.ResolvedToken.outValue.cbTypeSpec, + key.ResolvedToken.outValue.pMethodSpec_Index, key.ResolvedToken.outValue.cbMethodSpec, key.fEmbedParent); printf(", value nrl-%u rlk-%u", value.lookup.lookupKind.needsRuntimeLookup, value.lookup.lookupKind.runtimeLookupKind); if (value.lookup.lookupKind.needsRuntimeLookup) @@ -3279,25 +3178,14 @@ void MethodContext::repEmbedGenericHandle(CORINFO_RESOLVED_TOKEN* pResolve Agnostic_EmbedGenericHandle key; ZeroMemory(&key, sizeof(Agnostic_EmbedGenericHandle)); // We use the input structs as a key and use memcmp to // compare.. so we need to zero out padding too - Agnostic_CORINFO_GENERICHANDLE_RESULT value; AssertCodeMsg(EmbedGenericHandle != nullptr, EXCEPTIONCODE_MC, "Encountered an empty LWM while looking for ..."); - key.ResolvedToken.tokenContext = (DWORDLONG)pResolvedToken->tokenContext; - key.ResolvedToken.tokenScope = (DWORDLONG)pResolvedToken->tokenScope; - key.ResolvedToken.token = (DWORD)pResolvedToken->token; - key.ResolvedToken.tokenType = (DWORD)pResolvedToken->tokenType; - key.ResolvedToken.hClass = (DWORDLONG)pResolvedToken->hClass; - key.ResolvedToken.hMethod = (DWORDLONG)pResolvedToken->hMethod; - key.ResolvedToken.hField = (DWORDLONG)pResolvedToken->hField; - key.ResolvedToken.typeSpec_Index = - (DWORD)EmbedGenericHandle->Contains((unsigned char*)pResolvedToken->pTypeSpec, pResolvedToken->cbTypeSpec); - key.ResolvedToken.cbTypeSpec = (DWORD)pResolvedToken->cbTypeSpec; - key.ResolvedToken.methodSpec_Index = - (DWORD)EmbedGenericHandle->Contains((unsigned char*)pResolvedToken->pMethodSpec, pResolvedToken->cbMethodSpec); - key.ResolvedToken.cbMethodSpec = (DWORD)pResolvedToken->cbMethodSpec; - key.fEmbedParent = (DWORD)fEmbedParent; + key.ResolvedToken = SpmiRecordsHelper::RestoreAgnostic_CORINFO_RESOLVED_TOKEN(pResolvedToken, EmbedGenericHandle); + key.fEmbedParent = (DWORD)fEmbedParent; AssertCodeMsg(EmbedGenericHandle->GetIndex(key) != -1, EXCEPTIONCODE_MC, "Didn't find ..."); + + Agnostic_CORINFO_GENERICHANDLE_RESULT value; value = EmbedGenericHandle->Get(key); pResult->lookup.lookupKind.needsRuntimeLookup = value.lookup.lookupKind.needsRuntimeLookup != 0; @@ -3463,23 +3351,24 @@ void MethodContext::recGetTokenTypeAsHandle(CORINFO_RESOLVED_TOKEN* pResolvedTok ZeroMemory(&key, sizeof(Agnostic_CORINFO_RESOLVED_TOKEN)); // We use the input structs as a key and use memcmp to // compare.. so we need to zero out padding too - key.tokenContext = (DWORDLONG)0; - key.tokenScope = (DWORDLONG)0; - key.token = (DWORD)0; - key.tokenType = (DWORD)0; - key.hClass = (DWORDLONG)0; - key.hMethod = (DWORDLONG)pResolvedToken->hMethod; - key.hField = (DWORDLONG)pResolvedToken->hField; - key.typeSpec_Index = (DWORD)0; - key.cbTypeSpec = (DWORD)0; - key.methodSpec_Index = (DWORD)0; - key.cbMethodSpec = (DWORD)0; + key.inValue.tokenContext = (DWORDLONG)0; + key.inValue.tokenScope = (DWORDLONG)0; + key.inValue.token = (DWORD)0; + key.inValue.tokenType = (DWORD)0; + key.outValue.hClass = (DWORDLONG)0; + key.outValue.hMethod = (DWORDLONG)pResolvedToken->hMethod; + key.outValue.hField = (DWORDLONG)pResolvedToken->hField; + key.outValue.pTypeSpec_Index = (DWORD)0; + key.outValue.cbTypeSpec = (DWORD)0; + key.outValue.pMethodSpec_Index = (DWORD)0; + key.outValue.cbMethodSpec = (DWORD)0; GetTokenTypeAsHandle->Add(key, (DWORDLONG)result); } void MethodContext::dmpGetTokenTypeAsHandle(const Agnostic_CORINFO_RESOLVED_TOKEN& key, DWORDLONG value) { - printf("GetTokenTypeAsHandle key ftn-%016llX fld-%016llX, value cls-%016llX", key.hMethod, key.hField, value); + printf("GetTokenTypeAsHandle key ftn-%016llX fld-%016llX, value cls-%016llX", key.outValue.hMethod, + key.outValue.hField, value); } CORINFO_CLASS_HANDLE MethodContext::repGetTokenTypeAsHandle(CORINFO_RESOLVED_TOKEN* pResolvedToken) { @@ -3487,17 +3376,17 @@ CORINFO_CLASS_HANDLE MethodContext::repGetTokenTypeAsHandle(CORINFO_RESOLVED_TOK ZeroMemory(&key, sizeof(Agnostic_CORINFO_RESOLVED_TOKEN)); // We use the input structs as a key and use memcmp to // compare.. so we need to zero out padding too - key.tokenContext = (DWORDLONG)0; - key.tokenScope = (DWORDLONG)0; - key.token = (DWORD)0; - key.tokenType = (DWORD)0; - key.hClass = (DWORDLONG)0; - key.hMethod = (DWORDLONG)pResolvedToken->hMethod; - key.hField = (DWORDLONG)pResolvedToken->hField; - key.typeSpec_Index = (DWORD)0; - key.cbTypeSpec = (DWORD)0; - key.methodSpec_Index = (DWORD)0; - key.cbMethodSpec = (DWORD)0; + key.inValue.tokenContext = (DWORDLONG)0; + key.inValue.tokenScope = (DWORDLONG)0; + key.inValue.token = (DWORD)0; + key.inValue.tokenType = (DWORD)0; + key.outValue.hClass = (DWORDLONG)0; + key.outValue.hMethod = (DWORDLONG)pResolvedToken->hMethod; + key.outValue.hField = (DWORDLONG)pResolvedToken->hField; + key.outValue.pTypeSpec_Index = (DWORD)0; + key.outValue.cbTypeSpec = (DWORD)0; + key.outValue.pMethodSpec_Index = (DWORD)0; + key.outValue.cbMethodSpec = (DWORD)0; CORINFO_CLASS_HANDLE value = (CORINFO_CLASS_HANDLE)GetTokenTypeAsHandle->Get(key); return value; @@ -3513,24 +3402,11 @@ void MethodContext::recGetFieldInfo(CORINFO_RESOLVED_TOKEN* pResolvedToken, Agnostic_GetFieldInfo key; ZeroMemory(&key, sizeof(Agnostic_GetFieldInfo)); // Since dd has nested structs, and we use memcmp to compare, we // need to zero out the padding bytes too - Agnostic_CORINFO_FIELD_INFO value; - - key.ResolvedToken.tokenContext = (DWORDLONG)pResolvedToken->tokenContext; - key.ResolvedToken.tokenScope = (DWORDLONG)pResolvedToken->tokenScope; - key.ResolvedToken.token = (DWORD)pResolvedToken->token; - key.ResolvedToken.tokenType = (DWORD)pResolvedToken->tokenType; - key.ResolvedToken.hClass = (DWORDLONG)pResolvedToken->hClass; - key.ResolvedToken.hMethod = (DWORDLONG)pResolvedToken->hMethod; - key.ResolvedToken.hField = (DWORDLONG)pResolvedToken->hField; - key.ResolvedToken.typeSpec_Index = - (DWORD)GetFieldInfo->AddBuffer((unsigned char*)pResolvedToken->pTypeSpec, pResolvedToken->cbTypeSpec); - key.ResolvedToken.cbTypeSpec = (DWORD)pResolvedToken->cbTypeSpec; - key.ResolvedToken.methodSpec_Index = - (DWORD)GetFieldInfo->AddBuffer((unsigned char*)pResolvedToken->pMethodSpec, pResolvedToken->cbMethodSpec); - key.ResolvedToken.cbMethodSpec = (DWORD)pResolvedToken->cbMethodSpec; - key.callerHandle = (DWORDLONG)callerHandle; - key.flags = (DWORD)flags; + key.ResolvedToken = SpmiRecordsHelper::StoreAgnostic_CORINFO_RESOLVED_TOKEN(pResolvedToken, GetFieldInfo); + key.callerHandle = (DWORDLONG)callerHandle; + key.flags = (DWORD)flags; + Agnostic_CORINFO_FIELD_INFO value; value.fieldAccessor = (DWORD)pResult->fieldAccessor; value.fieldFlags = (DWORD)pResult->fieldFlags; value.helper = (DWORD)pResult->helper; @@ -3552,10 +3428,11 @@ void MethodContext::dmpGetFieldInfo(const Agnostic_GetFieldInfo& key, const Agno { printf("GetFieldInfo key ch-%016llX flg-%08X rt{tc-%016llX ts-%016llX tok-%08X tt-%u cls-%016llX meth-%016llX " "fld-%016llX tsi-%u cbts-%u msi-%u cbms-%u}", - key.callerHandle, key.flags, key.ResolvedToken.tokenContext, key.ResolvedToken.tokenScope, - key.ResolvedToken.token, key.ResolvedToken.tokenType, key.ResolvedToken.hClass, key.ResolvedToken.hMethod, - key.ResolvedToken.hField, key.ResolvedToken.typeSpec_Index, key.ResolvedToken.cbTypeSpec, - key.ResolvedToken.methodSpec_Index, key.ResolvedToken.cbMethodSpec); + key.callerHandle, key.flags, key.ResolvedToken.inValue.tokenContext, key.ResolvedToken.inValue.tokenScope, + key.ResolvedToken.inValue.token, key.ResolvedToken.inValue.tokenType, key.ResolvedToken.outValue.hClass, + key.ResolvedToken.outValue.hMethod, key.ResolvedToken.outValue.hField, + key.ResolvedToken.outValue.pTypeSpec_Index, key.ResolvedToken.outValue.cbTypeSpec, + key.ResolvedToken.outValue.pMethodSpec_Index, key.ResolvedToken.outValue.cbMethodSpec); printf(", value fa-%u fflg-%08X hlp-%u off-%u fT-%u(%s) sT-%016llX aa-%u hnum-%u na-%u {", value.fieldAccessor, value.fieldFlags, value.helper, value.offset, value.fieldType, toString((CorInfoType)value.fieldType), @@ -3593,27 +3470,14 @@ void MethodContext::repGetFieldInfo(CORINFO_RESOLVED_TOKEN* pResolvedToken, CORINFO_ACCESS_FLAGS flags, CORINFO_FIELD_INFO* pResult) { + AssertCodeMsg(GetFieldInfo != nullptr, EXCEPTIONCODE_MC, "Didn't find %x", pResolvedToken->token); + Agnostic_GetFieldInfo key; ZeroMemory(&key, sizeof(Agnostic_GetFieldInfo)); // Since dd has nested structs, and we use memcmp to compare, we // need to zero out the padding bytes too - Agnostic_CORINFO_FIELD_INFO value; - - AssertCodeMsg(GetFieldInfo != nullptr, EXCEPTIONCODE_MC, "Didn't find %x", pResolvedToken->token); - key.ResolvedToken.tokenContext = (DWORDLONG)pResolvedToken->tokenContext; - key.ResolvedToken.tokenScope = (DWORDLONG)pResolvedToken->tokenScope; - key.ResolvedToken.token = (DWORD)pResolvedToken->token; - key.ResolvedToken.tokenType = (DWORD)pResolvedToken->tokenType; - key.ResolvedToken.hClass = (DWORDLONG)pResolvedToken->hClass; - key.ResolvedToken.hMethod = (DWORDLONG)pResolvedToken->hMethod; - key.ResolvedToken.hField = (DWORDLONG)pResolvedToken->hField; - key.ResolvedToken.typeSpec_Index = - (DWORD)GetFieldInfo->Contains((unsigned char*)pResolvedToken->pTypeSpec, pResolvedToken->cbTypeSpec); - key.ResolvedToken.cbTypeSpec = (DWORD)pResolvedToken->cbTypeSpec; - key.ResolvedToken.methodSpec_Index = - (DWORD)GetFieldInfo->Contains((unsigned char*)pResolvedToken->pMethodSpec, pResolvedToken->cbMethodSpec); - key.ResolvedToken.cbMethodSpec = (DWORD)pResolvedToken->cbMethodSpec; - key.callerHandle = (DWORDLONG)callerHandle; - key.flags = (DWORD)flags; + key.ResolvedToken = SpmiRecordsHelper::RestoreAgnostic_CORINFO_RESOLVED_TOKEN(pResolvedToken, GetFieldInfo); + key.callerHandle = (DWORDLONG)callerHandle; + key.flags = (DWORD)flags; DWORD origFlag = key.flags; @@ -3651,7 +3515,7 @@ void MethodContext::repGetFieldInfo(CORINFO_RESOLVED_TOKEN* pResolvedToken, #endif } - value = GetFieldInfo->Get(key); + Agnostic_CORINFO_FIELD_INFO value = GetFieldInfo->Get(key); pResult->fieldAccessor = (CORINFO_FIELD_ACCESSOR)value.fieldAccessor; pResult->fieldFlags = (unsigned)value.fieldFlags; @@ -3893,24 +3757,10 @@ void MethodContext::recCanAccessClass(CORINFO_RESOLVED_TOKEN* pResolvedToke Agnostic_CanAccessClassIn key; ZeroMemory(&key, sizeof(Agnostic_CanAccessClassIn)); // We use the input structs as a key and use memcmp to // compare.. so we need to zero out padding too + key.ResolvedToken = SpmiRecordsHelper::StoreAgnostic_CORINFO_RESOLVED_TOKEN(pResolvedToken, CanAccessClass); + key.callerHandle = (DWORDLONG)callerHandle; Agnostic_CanAccessClassOut value; - - key.ResolvedToken.tokenContext = (DWORDLONG)pResolvedToken->tokenContext; - key.ResolvedToken.tokenScope = (DWORDLONG)pResolvedToken->tokenScope; - key.ResolvedToken.token = (DWORD)pResolvedToken->token; - key.ResolvedToken.tokenType = (DWORD)pResolvedToken->tokenType; - key.ResolvedToken.hClass = (DWORDLONG)pResolvedToken->hClass; - key.ResolvedToken.hMethod = (DWORDLONG)pResolvedToken->hMethod; - key.ResolvedToken.hField = (DWORDLONG)pResolvedToken->hField; - key.ResolvedToken.typeSpec_Index = - (DWORD)CanAccessClass->AddBuffer((unsigned char*)pResolvedToken->pTypeSpec, pResolvedToken->cbTypeSpec); - key.ResolvedToken.cbTypeSpec = (DWORD)pResolvedToken->cbTypeSpec; - key.ResolvedToken.methodSpec_Index = - (DWORD)CanAccessClass->AddBuffer((unsigned char*)pResolvedToken->pMethodSpec, pResolvedToken->cbMethodSpec); - key.ResolvedToken.cbMethodSpec = (DWORD)pResolvedToken->cbMethodSpec; - key.callerHandle = (DWORDLONG)callerHandle; - value.AccessHelper.helperNum = (DWORD)pAccessHelper->helperNum; value.AccessHelper.numArgs = (DWORD)pAccessHelper->numArgs; for (int i = 0; i < CORINFO_ACCESS_ALLOWED_MAX_ARGS; i++) @@ -3927,10 +3777,11 @@ void MethodContext::dmpCanAccessClass(const Agnostic_CanAccessClassIn& key, cons { printf("CanAccessClass key tc-%016llX ts-%016llX tok-%08X tt-%u cls-%016llX meth-%016llX fld-%016llX ti-%u ts-%u " "mi-%u ms-%u", - key.ResolvedToken.tokenContext, key.ResolvedToken.tokenScope, key.ResolvedToken.token, - key.ResolvedToken.tokenType, key.ResolvedToken.hClass, key.ResolvedToken.hMethod, key.ResolvedToken.hField, - key.ResolvedToken.typeSpec_Index, key.ResolvedToken.cbTypeSpec, key.ResolvedToken.methodSpec_Index, - key.ResolvedToken.cbMethodSpec); + key.ResolvedToken.inValue.tokenContext, key.ResolvedToken.inValue.tokenScope, + key.ResolvedToken.inValue.token, key.ResolvedToken.inValue.tokenType, key.ResolvedToken.outValue.hClass, + key.ResolvedToken.outValue.hMethod, key.ResolvedToken.outValue.hField, + key.ResolvedToken.outValue.pTypeSpec_Index, key.ResolvedToken.outValue.cbTypeSpec, + key.ResolvedToken.outValue.pMethodSpec_Index, key.ResolvedToken.outValue.cbMethodSpec); printf(", value hnum-%u na-%u {", value.AccessHelper.helperNum, value.AccessHelper.numArgs); for (int i = 0; i < CORINFO_ACCESS_ALLOWED_MAX_ARGS; i++) { @@ -3942,31 +3793,18 @@ CorInfoIsAccessAllowedResult MethodContext::repCanAccessClass(CORINFO_RESOLVED_T CORINFO_METHOD_HANDLE callerHandle, CORINFO_HELPER_DESC* pAccessHelper) { + AssertCodeMsg(CanAccessClass != nullptr, EXCEPTIONCODE_MC, "Didn't find anything for %016llX", + (DWORDLONG)pResolvedToken->hClass); + Agnostic_CanAccessClassIn key; ZeroMemory(&key, sizeof(Agnostic_CanAccessClassIn)); // We use the input structs as a key and use memcmp to // compare.. so we need to zero out padding too - Agnostic_CanAccessClassOut value; - - AssertCodeMsg(CanAccessClass != nullptr, EXCEPTIONCODE_MC, "Didn't find anything for %016llX", - (DWORDLONG)pResolvedToken->hClass); - key.ResolvedToken.tokenContext = (DWORDLONG)pResolvedToken->tokenContext; - key.ResolvedToken.tokenScope = (DWORDLONG)pResolvedToken->tokenScope; - key.ResolvedToken.token = (DWORD)pResolvedToken->token; - key.ResolvedToken.tokenType = (DWORD)pResolvedToken->tokenType; - key.ResolvedToken.hClass = (DWORDLONG)pResolvedToken->hClass; - key.ResolvedToken.hMethod = (DWORDLONG)pResolvedToken->hMethod; - key.ResolvedToken.hField = (DWORDLONG)pResolvedToken->hField; - key.ResolvedToken.typeSpec_Index = - (DWORD)CanAccessClass->Contains((unsigned char*)pResolvedToken->pTypeSpec, pResolvedToken->cbTypeSpec); - key.ResolvedToken.cbTypeSpec = (DWORD)pResolvedToken->cbTypeSpec; - key.ResolvedToken.methodSpec_Index = - (DWORD)CanAccessClass->Contains((unsigned char*)pResolvedToken->pMethodSpec, pResolvedToken->cbMethodSpec); - key.ResolvedToken.cbMethodSpec = (DWORD)pResolvedToken->cbMethodSpec; - key.callerHandle = (DWORDLONG)callerHandle; + key.ResolvedToken = SpmiRecordsHelper::RestoreAgnostic_CORINFO_RESOLVED_TOKEN(pResolvedToken, CanAccessClass); + key.callerHandle = (DWORDLONG)callerHandle; AssertCodeMsg(CanAccessClass->GetIndex(key) != -1, EXCEPTIONCODE_MC, "Didn't find %016llX", (DWORDLONG)pResolvedToken->hClass); - value = CanAccessClass->Get(key); + Agnostic_CanAccessClassOut value = CanAccessClass->Get(key); pAccessHelper->helperNum = (CorInfoHelpFunc)value.AccessHelper.helperNum; pAccessHelper->numArgs = (unsigned)value.AccessHelper.numArgs; @@ -3989,24 +3827,25 @@ void MethodContext::recGetCastingHelper(CORINFO_RESOLVED_TOKEN* pResolvedToken, ZeroMemory(&key, sizeof(Agnostic_GetCastingHelper)); // We use the input structs as a key and use memcmp to // compare.. so we need to zero out padding too - key.ResolvedToken.tokenContext = (DWORDLONG)0; - key.ResolvedToken.tokenScope = (DWORDLONG)0; - key.ResolvedToken.token = (DWORD)0; - key.ResolvedToken.tokenType = (DWORD)0; - key.ResolvedToken.hClass = (DWORDLONG)pResolvedToken->hClass; - key.ResolvedToken.hMethod = (DWORDLONG)0; - key.ResolvedToken.hField = (DWORDLONG)0; - key.ResolvedToken.typeSpec_Index = (DWORD)0; - key.ResolvedToken.cbTypeSpec = (DWORD)0; - key.ResolvedToken.methodSpec_Index = (DWORD)0; - key.ResolvedToken.cbMethodSpec = (DWORD)0; - key.fThrowing = (DWORD)fThrowing; + key.ResolvedToken.inValue.tokenContext = (DWORDLONG)0; + key.ResolvedToken.inValue.tokenScope = (DWORDLONG)0; + key.ResolvedToken.inValue.token = (DWORD)0; + key.ResolvedToken.inValue.tokenType = (DWORD)0; + key.ResolvedToken.outValue.hClass = (DWORDLONG)pResolvedToken->hClass; + key.ResolvedToken.outValue.hMethod = (DWORDLONG)0; + key.ResolvedToken.outValue.hField = (DWORDLONG)0; + key.ResolvedToken.outValue.pTypeSpec_Index = (DWORD)0; + key.ResolvedToken.outValue.cbTypeSpec = (DWORD)0; + key.ResolvedToken.outValue.pMethodSpec_Index = (DWORD)0; + key.ResolvedToken.outValue.cbMethodSpec = (DWORD)0; + key.fThrowing = (DWORD)fThrowing; GetCastingHelper->Add(key, (DWORD)result); } void MethodContext::dmpGetCastingHelper(const Agnostic_GetCastingHelper& key, DWORD value) { - printf("GetCastingHelper key cls-%016llX, thw-%u, value res-%u", key.ResolvedToken.hClass, key.fThrowing, value); + printf("GetCastingHelper key cls-%016llX, thw-%u, value res-%u", key.ResolvedToken.outValue.hClass, key.fThrowing, + value); } CorInfoHelpFunc MethodContext::repGetCastingHelper(CORINFO_RESOLVED_TOKEN* pResolvedToken, bool fThrowing) { @@ -4014,18 +3853,18 @@ CorInfoHelpFunc MethodContext::repGetCastingHelper(CORINFO_RESOLVED_TOKEN* pReso ZeroMemory(&key, sizeof(Agnostic_GetCastingHelper)); // We use the input structs as a key and use memcmp to // compare.. so we need to zero out padding too - key.ResolvedToken.tokenContext = (DWORDLONG)0; - key.ResolvedToken.tokenScope = (DWORDLONG)0; - key.ResolvedToken.token = (DWORD)0; - key.ResolvedToken.tokenType = (DWORD)0; - key.ResolvedToken.hClass = (DWORDLONG)pResolvedToken->hClass; - key.ResolvedToken.hMethod = (DWORDLONG)0; - key.ResolvedToken.hField = (DWORDLONG)0; - key.ResolvedToken.typeSpec_Index = (DWORD)0; - key.ResolvedToken.cbTypeSpec = (DWORD)0; - key.ResolvedToken.methodSpec_Index = (DWORD)0; - key.ResolvedToken.cbMethodSpec = (DWORD)0; - key.fThrowing = (DWORD)fThrowing; + key.ResolvedToken.inValue.tokenContext = (DWORDLONG)0; + key.ResolvedToken.inValue.tokenScope = (DWORDLONG)0; + key.ResolvedToken.inValue.token = (DWORD)0; + key.ResolvedToken.inValue.tokenType = (DWORD)0; + key.ResolvedToken.outValue.hClass = (DWORDLONG)pResolvedToken->hClass; + key.ResolvedToken.outValue.hMethod = (DWORDLONG)0; + key.ResolvedToken.outValue.hField = (DWORDLONG)0; + key.ResolvedToken.outValue.pTypeSpec_Index = (DWORD)0; + key.ResolvedToken.outValue.cbTypeSpec = (DWORD)0; + key.ResolvedToken.outValue.pMethodSpec_Index = (DWORD)0; + key.ResolvedToken.outValue.cbMethodSpec = (DWORD)0; + key.fThrowing = (DWORD)fThrowing; CorInfoHelpFunc value = (CorInfoHelpFunc)GetCastingHelper->Get(key); return value; diff --git a/src/coreclr/src/ToolBox/superpmi/superpmi-shared/methodcontext.h b/src/coreclr/src/ToolBox/superpmi/superpmi-shared/methodcontext.h index 14e6b5a..0e01a37 100644 --- a/src/coreclr/src/ToolBox/superpmi/superpmi-shared/methodcontext.h +++ b/src/coreclr/src/ToolBox/superpmi/superpmi-shared/methodcontext.h @@ -105,7 +105,6 @@ public: DWORD cbTypeSpec; DWORD pMethodSpec_Index; DWORD cbMethodSpec; - DWORD exceptionCode; }; struct Agnostic_GetArgType { @@ -161,17 +160,9 @@ public: }; struct Agnostic_CORINFO_RESOLVED_TOKEN { - DWORDLONG tokenContext; - DWORDLONG tokenScope; - DWORD token; - DWORD tokenType; - DWORDLONG hClass; - DWORDLONG hMethod; - DWORDLONG hField; - DWORD typeSpec_Index; - DWORD cbTypeSpec; - DWORD methodSpec_Index; - DWORD cbMethodSpec; + Agnostic_CORINFO_RESOLVED_TOKENin inValue; + + Agnostic_CORINFO_RESOLVED_TOKENout outValue; }; struct Agnostic_GetFieldInfo { @@ -450,6 +441,18 @@ public: DWORDLONG ownerType; }; + struct ResolveTokenValue + { + Agnostic_CORINFO_RESOLVED_TOKENout tokenOut; + DWORD exceptionCode; + }; + + struct TryResolveTokenValue + { + Agnostic_CORINFO_RESOLVED_TOKENout tokenOut; + DWORD success; + }; + #pragma pack(pop) MethodContext(); @@ -559,12 +562,11 @@ public: DWORD* exceptionCode); void recResolveToken(CORINFO_RESOLVED_TOKEN* pResolvedToken, DWORD exceptionCode); - void dmpResolveToken(const Agnostic_CORINFO_RESOLVED_TOKENin& key, const Agnostic_CORINFO_RESOLVED_TOKENout& value); + void dmpResolveToken(const Agnostic_CORINFO_RESOLVED_TOKENin& key, const ResolveTokenValue& value); void repResolveToken(CORINFO_RESOLVED_TOKEN* pResolvedToken, DWORD* exceptionCode); void recTryResolveToken(CORINFO_RESOLVED_TOKEN* pResolvedToken, bool success); - void dmpTryResolveToken(const Agnostic_CORINFO_RESOLVED_TOKENin& key, - const Agnostic_CORINFO_RESOLVED_TOKENout& value); + void dmpTryResolveToken(const Agnostic_CORINFO_RESOLVED_TOKENin& key, const TryResolveTokenValue& value); bool repTryResolveToken(CORINFO_RESOLVED_TOKEN* pResolvedToken); void recGetCallInfo(CORINFO_RESOLVED_TOKEN* pResolvedToken, diff --git a/src/coreclr/src/ToolBox/superpmi/superpmi-shared/spmirecordhelper.h b/src/coreclr/src/ToolBox/superpmi/superpmi-shared/spmirecordhelper.h new file mode 100644 index 0000000..4578608 --- /dev/null +++ b/src/coreclr/src/ToolBox/superpmi/superpmi-shared/spmirecordhelper.h @@ -0,0 +1,107 @@ +// +// Copyright (c) Microsoft. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. +// + +//---------------------------------------------------------- +// SpmiRecordHelper.h - Helpers to copy data between agnostic/non-agnostic types and dump them. +//---------------------------------------------------------- + +#include "methodcontext.h" + +class SpmiRecordsHelper +{ +public: + static MethodContext::Agnostic_CORINFO_RESOLVED_TOKENin CreateAgnostic_CORINFO_RESOLVED_TOKENin + (CORINFO_RESOLVED_TOKEN* pResolvedToken); + + static MethodContext::Agnostic_CORINFO_RESOLVED_TOKENout CreateAgnostic_CORINFO_RESOLVED_TOKENout_without_buffers + (CORINFO_RESOLVED_TOKEN* pResolvedToken); + + template + static MethodContext::Agnostic_CORINFO_RESOLVED_TOKENout StoreAgnostic_CORINFO_RESOLVED_TOKENout + (CORINFO_RESOLVED_TOKEN* pResolvedToken, LightWeightMap* buffers); + + template + static MethodContext::Agnostic_CORINFO_RESOLVED_TOKENout RestoreAgnostic_CORINFO_RESOLVED_TOKENout + (CORINFO_RESOLVED_TOKEN* pResolvedToken, LightWeightMap* buffers); + + template + static MethodContext::Agnostic_CORINFO_RESOLVED_TOKEN StoreAgnostic_CORINFO_RESOLVED_TOKEN + (CORINFO_RESOLVED_TOKEN* pResolvedToken, LightWeightMap* buffers); + + template + static MethodContext::Agnostic_CORINFO_RESOLVED_TOKEN RestoreAgnostic_CORINFO_RESOLVED_TOKEN + (CORINFO_RESOLVED_TOKEN* pResolvedToken, LightWeightMap* buffers); +}; + +inline MethodContext::Agnostic_CORINFO_RESOLVED_TOKENin SpmiRecordsHelper::CreateAgnostic_CORINFO_RESOLVED_TOKENin(CORINFO_RESOLVED_TOKEN * pResolvedToken) +{ + MethodContext::Agnostic_CORINFO_RESOLVED_TOKENin tokenIn; + ZeroMemory(&tokenIn, sizeof(tokenIn)); + tokenIn.tokenContext = (DWORDLONG)pResolvedToken->tokenContext; + tokenIn.tokenScope = (DWORDLONG)pResolvedToken->tokenScope; + tokenIn.token = (DWORD)pResolvedToken->token; + tokenIn.tokenType = (DWORD)pResolvedToken->tokenType; + return tokenIn; +} + +inline MethodContext::Agnostic_CORINFO_RESOLVED_TOKENout SpmiRecordsHelper::CreateAgnostic_CORINFO_RESOLVED_TOKENout_without_buffers(CORINFO_RESOLVED_TOKEN * pResolvedToken) +{ + MethodContext::Agnostic_CORINFO_RESOLVED_TOKENout tokenOut; + ZeroMemory(&tokenOut, sizeof(tokenOut)); + tokenOut.hClass = (DWORDLONG)pResolvedToken->hClass; + tokenOut.hMethod = (DWORDLONG)pResolvedToken->hMethod; + tokenOut.hField = (DWORDLONG)pResolvedToken->hField; + + tokenOut.cbTypeSpec = (DWORD)pResolvedToken->cbTypeSpec; + tokenOut.cbMethodSpec = (DWORD)pResolvedToken->cbMethodSpec; + + tokenOut.pTypeSpec_Index = -1; + tokenOut.pMethodSpec_Index = -1; + + return tokenOut; +} + +template +inline MethodContext::Agnostic_CORINFO_RESOLVED_TOKENout SpmiRecordsHelper::StoreAgnostic_CORINFO_RESOLVED_TOKENout(CORINFO_RESOLVED_TOKEN * pResolvedToken, LightWeightMap* buffers) +{ + MethodContext::Agnostic_CORINFO_RESOLVED_TOKENout tokenOut(CreateAgnostic_CORINFO_RESOLVED_TOKENout_without_buffers(pResolvedToken)); + + tokenOut.pTypeSpec_Index = + (DWORD)buffers->AddBuffer((unsigned char*)pResolvedToken->pTypeSpec, pResolvedToken->cbTypeSpec); + tokenOut.pMethodSpec_Index = + (DWORD)buffers->AddBuffer((unsigned char*)pResolvedToken->pMethodSpec, pResolvedToken->cbMethodSpec); + + return tokenOut; +} + +template +inline MethodContext::Agnostic_CORINFO_RESOLVED_TOKENout SpmiRecordsHelper::RestoreAgnostic_CORINFO_RESOLVED_TOKENout(CORINFO_RESOLVED_TOKEN * pResolvedToken, LightWeightMap* buffers) +{ + MethodContext::Agnostic_CORINFO_RESOLVED_TOKENout tokenOut(CreateAgnostic_CORINFO_RESOLVED_TOKENout_without_buffers(pResolvedToken)); + tokenOut.pTypeSpec_Index = + (DWORD)buffers->Contains((unsigned char*)pResolvedToken->pTypeSpec, pResolvedToken->cbTypeSpec); + tokenOut.pMethodSpec_Index = + (DWORD)buffers->Contains((unsigned char*)pResolvedToken->pMethodSpec, pResolvedToken->cbMethodSpec); + return tokenOut; +} + +template +inline MethodContext::Agnostic_CORINFO_RESOLVED_TOKEN SpmiRecordsHelper::StoreAgnostic_CORINFO_RESOLVED_TOKEN(CORINFO_RESOLVED_TOKEN * pResolvedToken, LightWeightMap* buffers) +{ + MethodContext::Agnostic_CORINFO_RESOLVED_TOKEN token; + token.inValue = CreateAgnostic_CORINFO_RESOLVED_TOKENin(pResolvedToken); + token.outValue = StoreAgnostic_CORINFO_RESOLVED_TOKENout(pResolvedToken, buffers); + return token; +} + +template +inline MethodContext::Agnostic_CORINFO_RESOLVED_TOKEN SpmiRecordsHelper::RestoreAgnostic_CORINFO_RESOLVED_TOKEN(CORINFO_RESOLVED_TOKEN * pResolvedToken, LightWeightMap* buffers) +{ + MethodContext::Agnostic_CORINFO_RESOLVED_TOKEN token; + ZeroMemory(&token, sizeof(token)); + token.inValue = CreateAgnostic_CORINFO_RESOLVED_TOKENin(pResolvedToken); + token.outValue = RestoreAgnostic_CORINFO_RESOLVED_TOKENout(pResolvedToken, buffers); + return token; +}