}
void MethodContext::dmpCompileMethod(DWORD key, const Agnostic_CompileMethod& value)
{
- printf("CompileMethod key %u, value ftn-%016llX scp-%016llX ilo-%u ils-%u ms-%u ehc-%u opt-%u rk-%u args-%s locals-%s flg-%08X os-%u",
+ printf("CompileMethod key %u, value ftn-%016" PRIX64 " scp-%016" PRIX64 " ilo-%u ils-%u ms-%u ehc-%u opt-%u rk-%u args-%s locals-%s flg-%08X os-%u",
key, value.info.ftn, value.info.scope, value.info.ILCode_offset, value.info.ILCodeSize, value.info.maxStack,
value.info.EHcount, value.info.options, value.info.regionKind,
SpmiDumpHelper::DumpAgnostic_CORINFO_SIG_INFO(value.info.args, CompileMethod, SigInstHandleMap).c_str(),
}
void MethodContext::dmpGetMethodClass(DWORDLONG key, DWORDLONG value)
{
- printf("GetMethodClass key %016llX, value %016llX", key, value);
+ printf("GetMethodClass key %016" PRIX64 ", value %016" PRIX64 "", key, value);
}
CORINFO_CLASS_HANDLE MethodContext::repGetMethodClass(CORINFO_METHOD_HANDLE methodHandle)
{
DWORDLONG key = CastHandle(methodHandle);
- DWORDLONG value = LookupByKeyOrMiss(GetMethodClass, key, ": key %016llX", key);
+ DWORDLONG value = LookupByKeyOrMiss(GetMethodClass, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetMethodClass(key, value));
CORINFO_CLASS_HANDLE result = (CORINFO_CLASS_HANDLE)value;
return result;
}
void MethodContext::dmpGetMethodModule(DWORDLONG key, DWORDLONG value)
{
- printf("GetMethodModule key %016llX, value %016llX", key, value);
+ printf("GetMethodModule key %016" PRIX64 ", value %016" PRIX64 "", key, value);
}
CORINFO_MODULE_HANDLE MethodContext::repGetMethodModule(CORINFO_METHOD_HANDLE methodHandle)
{
DWORDLONG key = CastHandle(methodHandle);
- DWORDLONG value = LookupByKeyOrMiss(GetMethodModule, key, ": key %016llX", key);
+ DWORDLONG value = LookupByKeyOrMiss(GetMethodModule, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetMethodModule(key, value));
CORINFO_MODULE_HANDLE result = (CORINFO_MODULE_HANDLE)value;
return result;
}
void MethodContext::dmpGetClassAttribs(DWORDLONG key, DWORD value)
{
- printf("GetClassAttribs key %016llX, value %08X (%s)", key, value, SpmiDumpHelper::DumpCorInfoFlag((CorInfoFlag)value).c_str());
+ printf("GetClassAttribs key %016" PRIX64 ", value %08X (%s)", key, value, SpmiDumpHelper::DumpCorInfoFlag((CorInfoFlag)value).c_str());
}
DWORD MethodContext::repGetClassAttribs(CORINFO_CLASS_HANDLE classHandle)
{
DWORDLONG key = CastHandle(classHandle);
- DWORD value = LookupByKeyOrMiss(GetClassAttribs, key, ": key %016llX", key);
+ DWORD value = LookupByKeyOrMiss(GetClassAttribs, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetClassAttribs(key, value));
return value;
}
}
void MethodContext::dmpIsIntrinsic(DWORDLONG key, DWORD value)
{
- printf("IsIntrinsic key ftn-%016llX, value res-%u", key, value);
+ printf("IsIntrinsic key ftn-%016" PRIX64 ", value res-%u", key, value);
}
bool MethodContext::repIsIntrinsic(CORINFO_METHOD_HANDLE ftn)
{
DWORDLONG key = CastHandle(ftn);
- DWORD value = LookupByKeyOrMiss(IsIntrinsic, key, ": key %016llX", key);
+ DWORD value = LookupByKeyOrMiss(IsIntrinsic, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpIsIntrinsic(key, value));
return value != 0;
}
}
void MethodContext::dmpGetMethodAttribs(DWORDLONG key, DWORD value)
{
- printf("GetMethodAttribs key %016llX, value %08X (%s)", key, value, SpmiDumpHelper::DumpCorInfoFlag((CorInfoFlag)value).c_str());
+ printf("GetMethodAttribs key %016" PRIX64 ", value %08X (%s)", key, value, SpmiDumpHelper::DumpCorInfoFlag((CorInfoFlag)value).c_str());
}
DWORD MethodContext::repGetMethodAttribs(CORINFO_METHOD_HANDLE methodHandle)
{
DWORDLONG key = CastHandle(methodHandle);
- DWORD value = LookupByKeyOrMiss(GetMethodAttribs, key, ": key %016llX", key);
+ DWORD value = LookupByKeyOrMiss(GetMethodAttribs, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetMethodAttribs(key, value));
}
void MethodContext::dmpGetClassModule(DWORDLONG key, DWORDLONG value)
{
- printf("GetClassModule cls-%016llX, mod-%016llX", key, value);
+ printf("GetClassModule cls-%016" PRIX64 ", mod-%016" PRIX64 "", key, value);
}
CORINFO_MODULE_HANDLE MethodContext::repGetClassModule(CORINFO_CLASS_HANDLE cls)
{
DWORDLONG key = CastHandle(cls);
- DWORDLONG value = LookupByKeyOrMiss(GetClassModule, key, ": key %016llX", key);
+ DWORDLONG value = LookupByKeyOrMiss(GetClassModule, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetClassModule(key, value));
CORINFO_MODULE_HANDLE result = (CORINFO_MODULE_HANDLE)value;
return result;
}
void MethodContext::dmpGetModuleAssembly(DWORDLONG key, DWORDLONG value)
{
- printf("GetModuleAssembly mod-%016llX, assem-%016llX", key, value);
+ printf("GetModuleAssembly mod-%016" PRIX64 ", assem-%016" PRIX64 "", key, value);
}
CORINFO_ASSEMBLY_HANDLE MethodContext::repGetModuleAssembly(CORINFO_MODULE_HANDLE mod)
{
DWORDLONG key = CastHandle(mod);
- DWORDLONG value = LookupByKeyOrMiss(GetModuleAssembly, key, ": key %016llX", key);
+ DWORDLONG value = LookupByKeyOrMiss(GetModuleAssembly, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetModuleAssembly(key, value));
CORINFO_ASSEMBLY_HANDLE result = (CORINFO_ASSEMBLY_HANDLE)value;
return result;
void MethodContext::dmpGetAssemblyName(DWORDLONG key, DWORD value)
{
const char* assemblyName = (const char*)GetAssemblyName->GetBuffer(value);
- printf("GetAssemblyName assem-%016llX, value-%u '%s'", key, value, assemblyName);
+ printf("GetAssemblyName assem-%016" PRIX64 ", value-%u '%s'", key, value, assemblyName);
GetAssemblyName->Unlock();
}
const char* MethodContext::repGetAssemblyName(CORINFO_ASSEMBLY_HANDLE assem)
void MethodContext::dmpGetVars(DWORDLONG key, const Agnostic_GetVars& value)
{
ICorDebugInfo::ILVarInfo* vars = (ICorDebugInfo::ILVarInfo*)GetVars->GetBuffer(value.vars_offset);
- printf("GetVars key ftn-%016llX, value cVars-%u extendOthers-%u (", key, value.cVars, value.extendOthers);
+ printf("GetVars key ftn-%016" PRIX64 ", value cVars-%u extendOthers-%u (", key, value.cVars, value.extendOthers);
for (unsigned int i = 0; i < value.cVars; i++)
printf("(%u %u %u %u)", i, vars[i].startOffset, vars[i].endOffset, vars[i].varNumber);
printf(")");
}
void MethodContext::dmpGetBoundaries(DWORDLONG key, const Agnostic_GetBoundaries& value)
{
- printf("GetBoundaries key ftn-%016llX, value cnt-%u imp-%u{", key, value.cILOffsets, value.implicitBoundaries);
+ printf("GetBoundaries key ftn-%016" PRIX64 ", value cnt-%u imp-%u{", key, value.cILOffsets, value.implicitBoundaries);
DWORD* bnd = (DWORD*)GetBoundaries->GetBuffer(value.pILOffset_offset);
for (unsigned int i = 0; i < value.cILOffsets; i++)
{
ICorDebugInfo::BoundaryTypes* implicitBoundaries)
{
DWORDLONG key = CastHandle(ftn);
- Agnostic_GetBoundaries value = LookupByKeyOrMiss(GetBoundaries, key, ": key %016llX", key);
+ Agnostic_GetBoundaries value = LookupByKeyOrMiss(GetBoundaries, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetBoundaries(key, value));
}
void MethodContext::dmpInitClass(const Agnostic_InitClass& key, DWORD value)
{
- printf("InitClass key fld-%016llX meth-%016llX con-%016llX, value res-%u", key.field, key.method,
+ printf("InitClass key fld-%016" PRIX64 " meth-%016" PRIX64 " con-%016" PRIX64 ", value res-%u", key.field, key.method,
key.context, value);
}
CorInfoInitClassResult MethodContext::repInitClass(CORINFO_FIELD_HANDLE field,
unsigned char* className = (unsigned char*)GetMethodNameFromMetadata->GetBuffer(value.className);
unsigned char* namespaceName = (unsigned char*)GetMethodNameFromMetadata->GetBuffer(value.namespaceName);
unsigned char* enclosingClassName = (unsigned char*)GetMethodNameFromMetadata->GetBuffer(value.enclosingClassName);
- printf("GetMethodNameFromMetadata key - ftn-%016llX classNonNull-%u namespaceNonNull-%u enclosingClassNonNull-%u, value meth-'%s', "
+ printf("GetMethodNameFromMetadata key - ftn-%016" PRIX64 " classNonNull-%u namespaceNonNull-%u enclosingClassNonNull-%u, value meth-'%s', "
"class-'%s', namespace-'%s' enclosingClass-'%s'",
key.ftn, key.className, key.namespaceName, key.enclosingClassName, methodName, className, namespaceName, enclosingClassName);
GetMethodNameFromMetadata->Unlock();
Agnostic_CORINFO_METHODNAME_TOKENout value = LookupByKeyOrMiss(
GetMethodNameFromMetadata,
key,
- ": ftn-%016llX className-%u namespaceName-%u enclosingClassName-%u",
+ ": ftn-%016" PRIX64 " className-%u namespaceName-%u enclosingClassName-%u",
key.ftn,
key.className,
key.namespaceName,
void MethodContext::dmpGetJitFlags(DWORD key, DD value)
{
CORJIT_FLAGS* jitflags = (CORJIT_FLAGS*)GetJitFlags->GetBuffer(value.A);
- printf("GetJitFlags key %u sizeInBytes-%u jitFlags-%016llX instructionSetFlags-", key, value.B, jitflags->GetFlagsRaw());
+ printf("GetJitFlags key %u sizeInBytes-%u jitFlags-%016" PRIX64 " instructionSetFlags-", key, value.B, jitflags->GetFlagsRaw());
uint64_t *raw = jitflags->GetInstructionSetFlagsRaw();
const int flagsFieldCount = jitflags->GetInstructionFlagsFieldCount();
for (int i = flagsFieldCount - 1; i >= 0; i--)
{
- printf("%016llX", raw[i]);
+ printf("%016" PRIX64 "", raw[i]);
}
GetJitFlags->Unlock();
}
}
void MethodContext::dmpCanInline(DLDL key, const Agnostic_CanInline& value)
{
- printf("CanInline key - callerHnd-%016llX calleeHnd-%016llX, value result-%u exceptionCode-%08X",
+ printf("CanInline key - callerHnd-%016" PRIX64 " calleeHnd-%016" PRIX64 ", value result-%u exceptionCode-%08X",
key.A, key.B, value.result, value.exceptionCode);
}
CorInfoInline MethodContext::repCanInline(CORINFO_METHOD_HANDLE callerHnd,
LogDebug("Sparse - repCanInline saying INLINE_FAIL");
return INLINE_FAIL; // if we have no info, its pretty safe to say we can't inline it.
#else
- LogException(EXCEPTIONCODE_MC, "Didn't find %016llx, %016llx. probably a missing exception in canInline",
+ LogException(EXCEPTIONCODE_MC, "Didn't find %016" PRIx64 ", %016" PRIx64 ". probably a missing exception in canInline",
key.A, key.B);
#endif
}
void MethodContext::dmpGetCallInfo(const Agnostic_GetCallInfo& key, const Agnostic_CORINFO_CALL_INFO& value)
{
- printf("GetCallInfo key rt{%s} crt{%s} ch-%016llX flg-%08X"
- ", value mth-%016llX, mf-%08X (%s) cf-%08X (%s)"
+ printf("GetCallInfo key rt{%s} crt{%s} ch-%016" PRIX64 " flg-%08X"
+ ", value mth-%016" PRIX64 ", mf-%08X (%s) cf-%08X (%s)"
" sig-%s"
" vmf-%08X (%s)"
" vsig-%s"
" tt-%u"
" k-%u (%s)"
" nic-%u (%s)"
- " ch-%016llX"
+ " ch-%016" PRIX64 ""
" ecnrl-%u (%s)"
" stubLookup{%s}"
- " ipl{at-%08X (%s) hnd-%016llX}"
+ " ipl{at-%08X (%s) hnd-%016" PRIX64 "}"
" wdi-%u (%s)"
" excp-%08X",
// input
key.callerHandle = CastHandle(callerHandle);
key.flags = (DWORD)flags;
- Agnostic_CORINFO_CALL_INFO value = LookupByKeyOrMiss(GetCallInfo, key, ": key %08x, %016llx",
+ Agnostic_CORINFO_CALL_INFO value = LookupByKeyOrMiss(GetCallInfo, key, ": key %08x, %016" PRIx64 "",
key.ResolvedToken.inValue.token, key.ResolvedToken.outValue.hClass);
if (value.exceptionCode != 0)
}
// If we reached here, we didn't find a key associated with the given method handle
- LogException(EXCEPTIONCODE_MC, "Didn't find key %016llX.", methodHandle);
+ LogException(EXCEPTIONCODE_MC, "Didn't find key %016" PRIX64 ".", methodHandle);
}
void MethodContext::recExpandRawHandleIntrinsic(CORINFO_RESOLVED_TOKEN* pResolvedToken, CORINFO_GENERICHANDLE_RESULT* pResult)
}
void MethodContext::dmpExpandRawHandleIntrinsic(const Agnostic_CORINFO_RESOLVED_TOKENin& key, const Agnostic_CORINFO_GENERICHANDLE_RESULT& result)
{
- printf("ExpandRawHandleIntrinsic key: %s, value %s cth-%016llx ht-%u",
+ printf("ExpandRawHandleIntrinsic key: %s, value %s cth-%016" PRIx64 " ht-%u",
SpmiDumpHelper::DumpAgnostic_CORINFO_RESOLVED_TOKENin(key).c_str(),
SpmiDumpHelper::DumpAgnostic_CORINFO_LOOKUP(result.lookup).c_str(),
result.compileTimeHandle,
}
void MethodContext::dmpIsIntrinsicType(DWORDLONG key, DWORD value)
{
- printf("IsIntrinsicType key mth-%016llX, value intr-%u", key, value);
+ printf("IsIntrinsicType key mth-%016" PRIX64 ", value intr-%u", key, value);
}
bool MethodContext::repIsIntrinsicType(CORINFO_CLASS_HANDLE cls)
{
DWORDLONG key = CastHandle(cls);
- DWORD value = LookupByKeyOrMiss(IsIntrinsicType, key, ": key %016llX", key);
+ DWORD value = LookupByKeyOrMiss(IsIntrinsicType, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpIsIntrinsicType(key, value));
return value != 0;
}
}
void MethodContext::dmpAsCorInfoType(DWORDLONG key, DWORD value)
{
- printf("AsCorInfoType key cls-%016llX, value cit-%u(%s)", key, value, toString((CorInfoType)value));
+ printf("AsCorInfoType key cls-%016" PRIX64 ", value cit-%u(%s)", key, value, toString((CorInfoType)value));
}
CorInfoType MethodContext::repAsCorInfoType(CORINFO_CLASS_HANDLE cls)
{
DWORDLONG key = CastHandle(cls);
- DWORD value = LookupByKeyOrMiss(AsCorInfoType, key, ": key %016llX", key);
+ DWORD value = LookupByKeyOrMiss(AsCorInfoType, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpAsCorInfoType(key, value));
CorInfoType result = (CorInfoType)value;
return result;
}
void MethodContext::dmpIsValueClass(DWORDLONG key, DWORD value)
{
- printf("IsValueClass key cls-%016llX, value res-%u", key, value);
+ printf("IsValueClass key cls-%016" PRIX64 ", value res-%u", key, value);
}
bool MethodContext::repIsValueClass(CORINFO_CLASS_HANDLE cls)
{
DWORDLONG key = CastHandle(cls);
- DWORD value = LookupByKeyOrMiss(IsValueClass, key, ": key %016llX", key);
+ DWORD value = LookupByKeyOrMiss(IsValueClass, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpIsValueClass(key, value));
return value != 0;
}
}
void MethodContext::dmpGetClassSize(DWORDLONG key, DWORD val)
{
- printf("GetClassSize key %016llX, value %u", key, val);
+ printf("GetClassSize key %016" PRIX64 ", value %u", key, val);
}
unsigned MethodContext::repGetClassSize(CORINFO_CLASS_HANDLE cls)
{
DWORDLONG key = CastHandle(cls);
- DWORD value = LookupByKeyOrMiss(GetClassSize, key, ": key %016llX", key);
+ DWORD value = LookupByKeyOrMiss(GetClassSize, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetClassSize(key, value));
unsigned result = (unsigned)value;
return result;
}
void MethodContext::dmpGetHeapClassSize(DWORDLONG key, DWORD val)
{
- printf("GetHeapClassSize key %016llX, value %u", key, val);
+ printf("GetHeapClassSize key %016" PRIX64 ", value %u", key, val);
}
unsigned MethodContext::repGetHeapClassSize(CORINFO_CLASS_HANDLE cls)
{
DWORDLONG key = CastHandle(cls);
- DWORD value = LookupByKeyOrMiss(GetHeapClassSize, key, ": key %016llX", key);
+ DWORD value = LookupByKeyOrMiss(GetHeapClassSize, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetHeapClassSize(key, value));
unsigned result = (unsigned)value;
return result;
}
void MethodContext::dmpCanAllocateOnStack(DWORDLONG key, DWORD val)
{
- printf("CanAllocateOnStack key %016llX, value %u", key, val);
+ printf("CanAllocateOnStack key %016" PRIX64 ", value %u", key, val);
}
bool MethodContext::repCanAllocateOnStack(CORINFO_CLASS_HANDLE cls)
{
DWORDLONG key = CastHandle(cls);
- DWORD value = LookupByKeyOrMiss(CanAllocateOnStack, key, ": key %016llX", key);
+ DWORD value = LookupByKeyOrMiss(CanAllocateOnStack, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpCanAllocateOnStack(key, value));
return value != 0;
}
}
void MethodContext::dmpGetClassNumInstanceFields(DWORDLONG key, DWORD value)
{
- printf("GetClassNumInstanceFields key cls-%016llX, value res-%u", key, value);
+ printf("GetClassNumInstanceFields key cls-%016" PRIX64 ", value res-%u", key, value);
}
unsigned MethodContext::repGetClassNumInstanceFields(CORINFO_CLASS_HANDLE cls)
{
DWORDLONG key = CastHandle(cls);
- DWORD value = LookupByKeyOrMiss(GetClassNumInstanceFields, key, ": key %016llX", key);
+ DWORD value = LookupByKeyOrMiss(GetClassNumInstanceFields, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetClassNumInstanceFields(key, value));
unsigned result = (unsigned)value;
return result;
}
void MethodContext::dmpGetNewArrHelper(DWORDLONG key, DWORD value)
{
- printf("GetNewArrHelper key cls-%016llX, value res-%u", key, value);
+ printf("GetNewArrHelper key cls-%016" PRIX64 ", value res-%u", key, value);
}
CorInfoHelpFunc MethodContext::repGetNewArrHelper(CORINFO_CLASS_HANDLE arrayCls)
{
DWORDLONG key = CastHandle(arrayCls);
- DWORD value = LookupByKeyOrMiss(GetNewArrHelper, key, ": key %016llX", key);
+ DWORD value = LookupByKeyOrMiss(GetNewArrHelper, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetNewArrHelper(key, value));
CorInfoHelpFunc result = (CorInfoHelpFunc)value;
return result;
}
void MethodContext::dmpGetSharedCCtorHelper(DWORDLONG key, DWORD value)
{
- printf("GetSharedCCtorHelper key cls-%016llX, value res-%u", key, value);
+ printf("GetSharedCCtorHelper key cls-%016" PRIX64 ", value res-%u", key, value);
}
CorInfoHelpFunc MethodContext::repGetSharedCCtorHelper(CORINFO_CLASS_HANDLE clsHnd)
{
DWORDLONG key = CastHandle(clsHnd);
- DWORD value = LookupByKeyOrMiss(GetSharedCCtorHelper, key, ": key %016llX", key);
+ DWORD value = LookupByKeyOrMiss(GetSharedCCtorHelper, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetSharedCCtorHelper(key, value));
CorInfoHelpFunc result = (CorInfoHelpFunc)value;
return result;
}
void MethodContext::dmpGetTypeForBox(DWORDLONG key, DWORDLONG value)
{
- printf("GetTypeForBox key cls-%016llX, value res-%016llX", key, value);
+ printf("GetTypeForBox key cls-%016" PRIX64 ", value res-%016" PRIX64 "", key, value);
}
CORINFO_CLASS_HANDLE MethodContext::repGetTypeForBox(CORINFO_CLASS_HANDLE cls)
{
DWORDLONG key = CastHandle(cls);
- DWORDLONG value = LookupByKeyOrMiss(GetTypeForBox, key, ": key %016llX", key);
+ DWORDLONG value = LookupByKeyOrMiss(GetTypeForBox, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetTypeForBox(key, value));
CORINFO_CLASS_HANDLE result = (CORINFO_CLASS_HANDLE)value;
return result;
}
void MethodContext::dmpGetBoxHelper(DWORDLONG key, DWORD value)
{
- printf("GetBoxHelper key cls-%016llX, value res-%u", key, value);
+ printf("GetBoxHelper key cls-%016" PRIX64 ", value res-%u", key, value);
}
CorInfoHelpFunc MethodContext::repGetBoxHelper(CORINFO_CLASS_HANDLE cls)
{
DWORDLONG key = CastHandle(cls);
- DWORD value = LookupByKeyOrMiss(GetBoxHelper, key, ": key %016llX", key);
+ DWORD value = LookupByKeyOrMiss(GetBoxHelper, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetBoxHelper(key, value));
CorInfoHelpFunc result = (CorInfoHelpFunc)value;
return result;
}
void MethodContext::dmpGetBuiltinClass(DWORD key, DWORDLONG value)
{
- printf("GetBuiltinClass key cls-%08X, value cls-%016llX", key, value);
+ printf("GetBuiltinClass key cls-%08X, value cls-%016" PRIX64 "", key, value);
}
CORINFO_CLASS_HANDLE MethodContext::repGetBuiltinClass(CorInfoClassId classId)
{
}
void MethodContext::dmpGetTypeForPrimitiveValueClass(DWORDLONG key, DWORD value)
{
- printf("GetTypeForPrimitiveValueClass key cls-%016llX, value cit-%u(%s)", key, value, toString((CorInfoType)value));
+ printf("GetTypeForPrimitiveValueClass key cls-%016" PRIX64 ", value cit-%u(%s)", key, value, toString((CorInfoType)value));
}
CorInfoType MethodContext::repGetTypeForPrimitiveValueClass(CORINFO_CLASS_HANDLE cls)
{
DWORDLONG key = CastHandle(cls);
- DWORD value = LookupByKeyOrMiss(GetTypeForPrimitiveValueClass, key, ": key %016llX", key);
+ DWORD value = LookupByKeyOrMiss(GetTypeForPrimitiveValueClass, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetTypeForPrimitiveValueClass(key, value));
CorInfoType result = (CorInfoType)value;
return result;
}
void MethodContext::dmpGetTypeForPrimitiveNumericClass(DWORDLONG key, DWORD value)
{
- printf("GetTypeForPrimitiveNumericClass key cls-%016llX, value cit-%u(%s)", key, value,
+ printf("GetTypeForPrimitiveNumericClass key cls-%016" PRIX64 ", value cit-%u(%s)", key, value,
toString((CorInfoType)value));
}
CorInfoType MethodContext::repGetTypeForPrimitiveNumericClass(CORINFO_CLASS_HANDLE cls)
{
DWORDLONG key = CastHandle(cls);
- DWORD value = LookupByKeyOrMiss(GetTypeForPrimitiveNumericClass, key, ": key %016llX", key);
+ DWORD value = LookupByKeyOrMiss(GetTypeForPrimitiveNumericClass, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetTypeForPrimitiveNumericClass(key, value));
CorInfoType result = (CorInfoType)value;
return result;
}
void MethodContext::dmpGetParentType(DWORDLONG key, DWORDLONG value)
{
- printf("GetParentType key cls-%016llX, value cls-%016llX", key, value);
+ printf("GetParentType key cls-%016" PRIX64 ", value cls-%016" PRIX64 "", key, value);
}
CORINFO_CLASS_HANDLE MethodContext::repGetParentType(CORINFO_CLASS_HANDLE cls)
{
DWORDLONG key = CastHandle(cls);
- DWORDLONG value = LookupByKeyOrMiss(GetParentType, key, ": key %016llX", key);
+ DWORDLONG value = LookupByKeyOrMiss(GetParentType, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetParentType(key, value));
CORINFO_CLASS_HANDLE result = (CORINFO_CLASS_HANDLE)value;
return result;
}
void MethodContext::dmpIsSDArray(DWORDLONG key, DWORD value)
{
- printf("IsSDArray key cls-%016llX, value res-%u", key, value);
+ printf("IsSDArray key cls-%016" PRIX64 ", value res-%u", key, value);
}
bool MethodContext::repIsSDArray(CORINFO_CLASS_HANDLE cls)
{
DWORDLONG key = CastHandle(cls);
- DWORD value = LookupByKeyOrMiss(IsSDArray, key, ": key %016llX", key);
+ DWORD value = LookupByKeyOrMiss(IsSDArray, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpIsSDArray(key, value));
return value != 0;
}
}
void MethodContext::dmpGetFieldClass(DWORDLONG key, DWORDLONG value)
{
- printf("GetFieldClass key %016llX, value %016llX", key, value);
+ printf("GetFieldClass key %016" PRIX64 ", value %016" PRIX64 "", key, value);
}
CORINFO_CLASS_HANDLE MethodContext::repGetFieldClass(CORINFO_FIELD_HANDLE field)
{
DWORDLONG key = CastHandle(field);
- DWORDLONG value = LookupByKeyOrMiss(GetFieldClass, key, ": key %016llX", key);
+ DWORDLONG value = LookupByKeyOrMiss(GetFieldClass, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetFieldClass(key, value));
CORINFO_CLASS_HANDLE result = (CORINFO_CLASS_HANDLE)value;
return result;
}
void MethodContext::dmpGetFieldOffset(DWORDLONG key, DWORD value)
{
- printf("GetFieldOffset key FLD-%016llX, value %08X", key, value);
+ printf("GetFieldOffset key FLD-%016" PRIX64 ", value %08X", key, value);
}
unsigned MethodContext::repGetFieldOffset(CORINFO_FIELD_HANDLE field)
{
DWORDLONG key = CastHandle(field);
- DWORD value = LookupByKeyOrMiss(GetFieldOffset, key, ": key %016llX", key);
+ DWORD value = LookupByKeyOrMiss(GetFieldOffset, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetFieldOffset(key, value));
unsigned result = (unsigned)value;
return result;
}
void MethodContext::dmpGetLazyStringLiteralHelper(DWORDLONG key, DWORD value)
{
- printf("GetLazyStringLiteralHelper key mod-%016llX, value res-%u", key, value);
+ printf("GetLazyStringLiteralHelper key mod-%016" PRIX64 ", value res-%u", key, value);
}
CorInfoHelpFunc MethodContext::repGetLazyStringLiteralHelper(CORINFO_MODULE_HANDLE handle)
{
DWORDLONG key = CastHandle(handle);
- DWORD value = LookupByKeyOrMiss(GetLazyStringLiteralHelper, key, ": key %016llX", key);
+ DWORD value = LookupByKeyOrMiss(GetLazyStringLiteralHelper, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetLazyStringLiteralHelper(key, value));
CorInfoHelpFunc result = (CorInfoHelpFunc)value;
return result;
}
void MethodContext::dmpGetUnBoxHelper(DWORDLONG key, DWORD value)
{
- printf("GetUnBoxHelper key cls-%016llX, value res-%u", key, value);
+ printf("GetUnBoxHelper key cls-%016" PRIX64 ", value res-%u", key, value);
}
CorInfoHelpFunc MethodContext::repGetUnBoxHelper(CORINFO_CLASS_HANDLE cls)
{
DWORDLONG key = CastHandle(cls);
- DWORD value = LookupByKeyOrMiss(GetUnBoxHelper, key, ": key %016llX", key);
+ DWORD value = LookupByKeyOrMiss(GetUnBoxHelper, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetUnBoxHelper(key, value));
CorInfoHelpFunc result = (CorInfoHelpFunc)value;
return result;
}
void MethodContext::dmpGetRuntimeTypePointer(DWORDLONG key, DWORDLONG value)
{
- printf("GetRuntimeTypePointer key cls-%016llX, value res-%016llX", key, value);
+ printf("GetRuntimeTypePointer key cls-%016" PRIX64 ", value res-%016" PRIX64 "", key, value);
}
CORINFO_OBJECT_HANDLE MethodContext::repGetRuntimeTypePointer(CORINFO_CLASS_HANDLE cls)
{
DWORDLONG key = CastHandle(cls);
- DWORDLONG value = LookupByKeyOrMiss(GetRuntimeTypePointer, key, ": key %016llX", key);
+ DWORDLONG value = LookupByKeyOrMiss(GetRuntimeTypePointer, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetRuntimeTypePointer(key, value));
return (CORINFO_OBJECT_HANDLE)value;
}
}
void MethodContext::dmpIsObjectImmutable(DWORDLONG key, DWORD value)
{
- printf("IsObjectImmutable key obj-%016llX, value res-%u", key, value);
+ printf("IsObjectImmutable key obj-%016" PRIX64 ", value res-%u", key, value);
}
bool MethodContext::repIsObjectImmutable(CORINFO_OBJECT_HANDLE objPtr)
{
DWORDLONG key = (DWORDLONG)objPtr;
- DWORD value = LookupByKeyOrMiss(IsObjectImmutable, key, ": key %016llX", key);
+ DWORD value = LookupByKeyOrMiss(IsObjectImmutable, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpIsObjectImmutable(key, value));
return (bool)value;
}
}
void MethodContext::dmpGetStringChar(DLD key, DD value)
{
- printf("IsObjectImmutable key obj-%016llX, index-%u, value res-%u, val-%u", key.A, key.B, value.A, value.B);
+ printf("IsObjectImmutable key obj-%016" PRIX64 ", index-%u, value res-%u, val-%u", key.A, key.B, value.A, value.B);
}
bool MethodContext::repGetStringChar(CORINFO_OBJECT_HANDLE strObj, int index, uint16_t* charValue)
{
key.A = CastHandle(strObj);
key.B = (DWORD)index;
- DD value = LookupByKeyOrMiss(GetStringChar, key, ": key %016llX", key.A);
+ DD value = LookupByKeyOrMiss(GetStringChar, key, ": key %016" PRIX64 "", key.A);
DEBUG_REP(dmpGetStringChar(key, value));
*charValue = (uint16_t)value.B;
}
void MethodContext::dmpGetObjectType(DWORDLONG key, DWORDLONG value)
{
- printf("GetObjectType key obj-%016llX, value res-%016llX", key, value);
+ printf("GetObjectType key obj-%016" PRIX64 ", value res-%016" PRIX64 "", key, value);
}
CORINFO_CLASS_HANDLE MethodContext::repGetObjectType(CORINFO_OBJECT_HANDLE objPtr)
{
DWORDLONG key = (DWORDLONG)objPtr;
- DWORDLONG value = LookupByKeyOrMiss(GetObjectType, key, ": key %016llX", key);
+ DWORDLONG value = LookupByKeyOrMiss(GetObjectType, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetObjectType(key, value));
return (CORINFO_CLASS_HANDLE)value;
}
void MethodContext::dmpGetReadyToRunDelegateCtorHelper(GetReadyToRunDelegateCtorHelper_TOKENIn key,
Agnostic_CORINFO_LOOKUP value)
{
- printf("GetReadyToRunDelegateCtorHelper key: method tk{%s} type-%016llX constraint-%08X",
+ printf("GetReadyToRunDelegateCtorHelper key: method tk{%s} type-%016" PRIX64 " constraint-%08X",
SpmiDumpHelper::DumpAgnostic_CORINFO_RESOLVED_TOKEN(key.TargetMethod).c_str(), key.delegateType, key.targetConstraint);
printf(", value: %s", SpmiDumpHelper::DumpAgnostic_CORINFO_LOOKUP(value).c_str());
}
DLDL oldValue = GetHelperFtn->Get(key);
AssertCodeMsg(oldValue.A == value.A && oldValue.B == oldValue.B, EXCEPTIONCODE_MC,
- "collision! old: %016llX %016llX, new: %016llX %016llX \n", oldValue.A, oldValue.B, value.A,
+ "collision! old: %016" PRIX64 " %016" PRIX64 ", new: %016" PRIX64 " %016" PRIX64 " \n", oldValue.A, oldValue.B, value.A,
value.B);
}
}
void MethodContext::dmpGetHelperFtn(DWORD key, DLDL value)
{
- printf("GetHelperFtn key ftn-%u, value ppi-%016llX res-%016llX", key, value.A, value.B);
+ printf("GetHelperFtn key ftn-%u, value ppi-%016" PRIX64 " res-%016" PRIX64 "", key, value.A, value.B);
}
void* MethodContext::repGetHelperFtn(CorInfoHelpFunc ftnNum, void** ppIndirection)
{
}
void MethodContext::dmpGetJustMyCodeHandle(DWORDLONG key, DLDL value)
{
- printf("GetJustMyCodeHandle key ftn-%016llX, value pp-%016llX, res-%016llX", key, value.A, value.B);
+ printf("GetJustMyCodeHandle key ftn-%016" PRIX64 ", value pp-%016" PRIX64 ", res-%016" PRIX64 "", key, value.A, value.B);
}
CORINFO_JUST_MY_CODE_HANDLE MethodContext::repGetJustMyCodeHandle(CORINFO_METHOD_HANDLE method,
CORINFO_JUST_MY_CODE_HANDLE** ppIndirection)
{
DWORDLONG key = CastHandle(method);
- DLDL value = LookupByKeyOrMiss(GetJustMyCodeHandle, key, ": key %016llX", key);
+ DLDL value = LookupByKeyOrMiss(GetJustMyCodeHandle, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetJustMyCodeHandle(key, value));
}
void MethodContext::dmpGetFunctionEntryPoint(DLD key, DLD value)
{
- printf("GetFunctionEntryPoint key ftn-%016llX af-%08X, value add-%016llX at-%u", key.A, key.B, value.A, value.B);
+ printf("GetFunctionEntryPoint key ftn-%016" PRIX64 " af-%08X, value add-%016" PRIX64 " at-%u", key.A, key.B, value.A, value.B);
}
void MethodContext::repGetFunctionEntryPoint(CORINFO_METHOD_HANDLE ftn,
CORINFO_CONST_LOOKUP* pResult,
pResult->addr = (void*)(CastHandle(ftn) + 0x1c);
return;
#else
- LogException(EXCEPTIONCODE_MC, "Didn't find %016llX, %8x", CastHandle(ftn), accessFlags);
+ LogException(EXCEPTIONCODE_MC, "Didn't find %016" PRIX64 ", %8x", CastHandle(ftn), accessFlags);
#endif
}
if (GetFunctionEntryPoint->GetIndex(key) == -1)
return;
}
#else
- LogException(EXCEPTIONCODE_MC, "Didn't find %016llX, %8x", CastHandle(ftn), accessFlags);
+ LogException(EXCEPTIONCODE_MC, "Didn't find %016" PRIX64 ", %8x", CastHandle(ftn), accessFlags);
#endif
}
}
}
- LogDebug("fndGetFunctionEntryPoint - didn't find value %016llX", value.A);
+ LogDebug("fndGetFunctionEntryPoint - didn't find value %016" PRIX64 "", value.A);
return false;
}
}
void MethodContext::dmpConstructStringLiteral(DLD key, DLD value)
{
- printf("ConstructStringLiteral key mod-%016llX tok-%08X, value pp-%016llX iat-%u", key.A, key.B, value.A, value.B);
+ printf("ConstructStringLiteral key mod-%016" PRIX64 " tok-%08X, value pp-%016" PRIX64 " iat-%u", key.A, key.B, value.A, value.B);
}
InfoAccessType MethodContext::repConstructStringLiteral(CORINFO_MODULE_HANDLE moduleHandle, mdToken metaTok, void** ppValue)
{
key.A = CastHandle(moduleHandle);
key.B = (DWORD)metaTok;
- DLD value = LookupByKeyOrMiss(ConstructStringLiteral, key, ": key %016llX", CastHandle(moduleHandle));
+ DLD value = LookupByKeyOrMiss(ConstructStringLiteral, key, ": key %016" PRIX64 "", CastHandle(moduleHandle));
DEBUG_REP(dmpConstructStringLiteral(key, value));
}
void MethodContext::dmpConvertPInvokeCalliToCall(DLD key, DWORDLONG value)
{
- printf("ConvertPInvokeCalliToCall key mod-%016llX tok-%08X, value %016llX", key.A, key.B, value);
+ printf("ConvertPInvokeCalliToCall key mod-%016" PRIX64 " tok-%08X, value %016" PRIX64 "", key.A, key.B, value);
}
bool MethodContext::repConvertPInvokeCalliToCall(CORINFO_RESOLVED_TOKEN* pResolvedToken, bool fMustConvert)
{
}
void MethodContext::dmpEmptyStringLiteral(DWORD key, DLD value)
{
- printf("EmptyStringLiteral key %u, value pVal-%016llX res-%u", key, value.A, value.B);
+ printf("EmptyStringLiteral key %u, value pVal-%016" PRIX64 " res-%u", key, value.A, value.B);
}
InfoAccessType MethodContext::repEmptyStringLiteral(void** ppValue)
{
void MethodContext::dmpGetArgType(const Agnostic_GetArgType_Key& key, const Agnostic_GetArgType_Value& value)
{
- printf("GetArgType key flg-%08X na-%u %s %s msig-%016llX scp-%016llX arg-%016llX",
+ printf("GetArgType key flg-%08X na-%u %s %s msig-%016" PRIX64 " scp-%016" PRIX64 " arg-%016" PRIX64 "",
key.flags, key.numArgs,
SpmiDumpHelper::DumpAgnostic_CORINFO_SIG_INST_Element("", "cc", "ci", key.sigInst_classInstCount, key.sigInst_classInst_Index, SigInstHandleMap).c_str(),
SpmiDumpHelper::DumpAgnostic_CORINFO_SIG_INST_Element("", "mc", "mi", key.sigInst_methInstCount, key.sigInst_methInst_Index, SigInstHandleMap).c_str(),
key.methodSignature, key.scope, key.args);
- printf(", value result(cit)-%u(%s) vcType-%016llX excp-%08X", value.result, toString((CorInfoTypeWithMod)value.result), value.vcTypeRet, value.exceptionCode);
+ printf(", value result(cit)-%u(%s) vcType-%016" PRIX64 " excp-%08X", value.result, toString((CorInfoTypeWithMod)value.result), value.vcTypeRet, value.exceptionCode);
}
CorInfoTypeWithMod MethodContext::repGetArgType(CORINFO_SIG_INFO* sig,
CORINFO_CLASS_HANDLE* vcTypeRet,
DWORD* exceptionCode)
{
- AssertMapExists(GetArgType, ": key %016llX %016llX", CastHandle(sig->scope), CastHandle(args));
+ AssertMapExists(GetArgType, ": key %016" PRIX64 " %016" PRIX64 "", CastHandle(sig->scope), CastHandle(args));
Agnostic_GetArgType_Key key;
ZeroMemory(&key, sizeof(key)); // Zero key including any struct padding
key.sigInst_classInst_Index = SpmiRecordsHelper::ContainsHandleMap(sig->sigInst.classInstCount, sig->sigInst.classInst, SigInstHandleMap);
key.sigInst_methInst_Index = SpmiRecordsHelper::ContainsHandleMap(sig->sigInst.methInstCount, sig->sigInst.methInst, SigInstHandleMap);
- Agnostic_GetArgType_Value value = LookupByKeyOrMiss(GetArgType, key, ": key %016llX %016llX", key.scope, key.args);
+ Agnostic_GetArgType_Value value = LookupByKeyOrMiss(GetArgType, key, ": key %016" PRIX64 " %016" PRIX64 "", key.scope, key.args);
DEBUG_REP(dmpGetArgType(key, value));
}
void MethodContext::dmpGetExactClasses(DLD key, DLD value)
{
- printf("GetExactClasses key baseType-%016llX, key maxExactCls %u, value exactCls %016llX, value exactClsCount %u",
+ printf("GetExactClasses key baseType-%016" PRIX64 ", key maxExactCls %u, value exactCls %016" PRIX64 ", value exactClsCount %u",
key.A, key.B, value.A, value.B);
}
int MethodContext::repGetExactClasses(CORINFO_CLASS_HANDLE baseType, int maxExactClasses, CORINFO_CLASS_HANDLE* exactClsRet)
key.A = CastHandle(baseType);
key.B = maxExactClasses;
- DLD value = LookupByKeyOrMiss(GetExactClasses, key, ": key %016llX %08X", key.A, key.B);
+ DLD value = LookupByKeyOrMiss(GetExactClasses, key, ": key %016" PRIX64 " %08X", key.A, key.B);
*exactClsRet = (CORINFO_CLASS_HANDLE)value.A;
return value.B;
}
void MethodContext::dmpGetArgNext(DWORDLONG key, DWORDLONG value)
{
- printf("GetArgNext key %016llX, value %016llX", key, value);
+ printf("GetArgNext key %016" PRIX64 ", value %016" PRIX64 "", key, value);
}
CORINFO_ARG_LIST_HANDLE MethodContext::repGetArgNext(CORINFO_ARG_LIST_HANDLE args)
{
DWORDLONG key = CastHandle(args);
- DWORDLONG value = LookupByKeyOrMiss(GetArgNext, key, ": key %016llX", key);
+ DWORDLONG value = LookupByKeyOrMiss(GetArgNext, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetArgNext(key, value));
CORINFO_ARG_LIST_HANDLE result = (CORINFO_ARG_LIST_HANDLE)value;
return result;
}
void MethodContext::dmpGetMethodSig(DLDL key, const Agnostic_CORINFO_SIG_INFO& value)
{
- printf("GetMethodSig key ftn-%016llX prt-%016llX, value-%s", key.A, key.B,
+ printf("GetMethodSig key ftn-%016" PRIX64 " prt-%016" PRIX64 ", value-%s", key.A, key.B,
SpmiDumpHelper::DumpAgnostic_CORINFO_SIG_INFO(value, GetMethodSig, SigInstHandleMap).c_str());
}
void MethodContext::repGetMethodSig(CORINFO_METHOD_HANDLE ftn, CORINFO_SIG_INFO* sig, CORINFO_CLASS_HANDLE memberParent)
key.A = CastHandle(ftn);
key.B = CastHandle(memberParent);
- Agnostic_CORINFO_SIG_INFO value = LookupByKeyOrMiss(GetMethodSig, key, ": key ftn-%016llX prt-%016llX", key.A, key.B);
+ Agnostic_CORINFO_SIG_INFO value = LookupByKeyOrMiss(GetMethodSig, key, ": key ftn-%016" PRIX64 " prt-%016" PRIX64 "", key.A, key.B);
DEBUG_REP(dmpGetMethodSig(key, value));
}
void MethodContext::dmpGetArgClass(const Agnostic_GetArgClass_Key& key, const Agnostic_GetArgClass_Value& value)
{
- printf("GetArgClass key %s %s msig-%016llX scp-%016llX args-%016llX",
+ printf("GetArgClass key %s %s msig-%016" PRIX64 " scp-%016" PRIX64 " args-%016" PRIX64 "",
SpmiDumpHelper::DumpAgnostic_CORINFO_SIG_INST_Element("", "cc", "ci", key.sigInst_classInstCount, key.sigInst_classInst_Index, SigInstHandleMap).c_str(),
SpmiDumpHelper::DumpAgnostic_CORINFO_SIG_INST_Element("", "mc", "mi", key.sigInst_methInstCount, key.sigInst_methInst_Index, SigInstHandleMap).c_str(),
key.methodSignature, key.scope, key.args);
- printf(", value %016llX excp-%08X", value.result, value.exceptionCode);
+ printf(", value %016" PRIX64 " excp-%08X", value.result, value.exceptionCode);
}
CORINFO_CLASS_HANDLE MethodContext::repGetArgClass(CORINFO_SIG_INFO* sig,
CORINFO_ARG_LIST_HANDLE args,
key.sigInst_classInst_Index = SpmiRecordsHelper::ContainsHandleMap(sig->sigInst.classInstCount, sig->sigInst.classInst, SigInstHandleMap);
key.sigInst_methInst_Index = SpmiRecordsHelper::ContainsHandleMap(sig->sigInst.methInstCount, sig->sigInst.methInst, SigInstHandleMap);
- Agnostic_GetArgClass_Value value = LookupByKeyOrMiss(GetArgClass, key, ": key %016llX %016llX", key.scope, key.args);
+ Agnostic_GetArgClass_Value value = LookupByKeyOrMiss(GetArgClass, key, ": key %016" PRIX64 " %016" PRIX64 "", key.scope, key.args);
DEBUG_REP(dmpGetArgClass(key, value));
}
void MethodContext::dmpGetHFAType(DWORDLONG key, DWORD value)
{
- printf("GetHFAType key %016llX, value %u ", key, value);
+ printf("GetHFAType key %016" PRIX64 ", value %u ", key, value);
}
CorInfoHFAElemType MethodContext::repGetHFAType(CORINFO_CLASS_HANDLE clsHnd)
{
DWORDLONG key = CastHandle(clsHnd);
- DWORD value = LookupByKeyOrMiss(GetHFAType, key, ": key %016llX", key);
+ DWORD value = LookupByKeyOrMiss(GetHFAType, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetHFAType(key, value));
return (CorInfoHFAElemType)value;
}
{
if (value.result)
{
- printf("GetMethodInfo key ftn-%016llX, value res-%u ftn-%016llX scp-%016llX ilo-%u ils-%u ms-%u ehc-%u opt-%08X rk-%u args-%s locals-%s excp-%08X",
+ printf("GetMethodInfo key ftn-%016" PRIX64 ", value res-%u ftn-%016" PRIX64 " scp-%016" PRIX64 " ilo-%u ils-%u ms-%u ehc-%u opt-%08X rk-%u args-%s locals-%s excp-%08X",
key, value.result, value.info.ftn, value.info.scope, value.info.ILCode_offset, value.info.ILCodeSize,
value.info.maxStack, value.info.EHcount, value.info.options, value.info.regionKind,
SpmiDumpHelper::DumpAgnostic_CORINFO_SIG_INFO(value.info.args, GetMethodInfo, SigInstHandleMap).c_str(),
}
else
{
- printf("GetMethodInfo key ftn-%016llX, value res-%u excp-%08X",
+ printf("GetMethodInfo key ftn-%016" PRIX64 ", value res-%u excp-%08X",
key, value.result, value.exceptionCode);
}
}
bool MethodContext::repGetMethodInfo(CORINFO_METHOD_HANDLE ftn, CORINFO_METHOD_INFO* info, DWORD* exceptionCode)
{
DWORDLONG key = CastHandle(ftn);
- Agnostic_GetMethodInfo value = LookupByKeyOrMiss(GetMethodInfo, key, ": key %016llX", key);
+ Agnostic_GetMethodInfo value = LookupByKeyOrMiss(GetMethodInfo, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetMethodInfo(key, value));
}
void MethodContext::dmpGetNewHelper(const Agnostic_GetNewHelper& key, DD value)
{
- printf("GetNewHelper key cls-%016llX chan-%016llX, hasSideEffects-%u, value res-%u", key.hClass, key.callerHandle, value.A, value.B);
+ printf("GetNewHelper key cls-%016" PRIX64 " chan-%016" PRIX64 ", hasSideEffects-%u, value res-%u", key.hClass, key.callerHandle, value.A, value.B);
}
CorInfoHelpFunc MethodContext::repGetNewHelper(CORINFO_RESOLVED_TOKEN* pResolvedToken,
CORINFO_METHOD_HANDLE callerHandle,
key.hClass = CastHandle(pResolvedToken->hClass);
key.callerHandle = CastHandle(callerHandle);
- DD value = LookupByKeyOrMiss(GetNewHelper, key, ": key %016llX %016llX", key.hClass, key.callerHandle);
+ DD value = LookupByKeyOrMiss(GetNewHelper, key, ": key %016" PRIX64 " %016" PRIX64 "", key.hClass, key.callerHandle);
DEBUG_REP(dmpGetNewHelper(key, value));
void MethodContext::dmpEmbedGenericHandle(const Agnostic_EmbedGenericHandle& key,
const Agnostic_CORINFO_GENERICHANDLE_RESULT& value)
{
- printf("EmbedGenericHandle key rt{%s} emb-%u, value %s cth-%016llX ht-%u",
+ printf("EmbedGenericHandle key rt{%s} emb-%u, value %s cth-%016" PRIX64 " ht-%u",
SpmiDumpHelper::DumpAgnostic_CORINFO_RESOLVED_TOKEN(key.ResolvedToken).c_str(),
key.fEmbedParent,
SpmiDumpHelper::DumpAgnostic_CORINFO_LOOKUP(value.lookup).c_str(),
}
void MethodContext::dmpGetEHinfo(DLD key, const Agnostic_CORINFO_EH_CLAUSE& value)
{
- printf("GetEHinfo key ftn-%016llX ehn-%u, value flg-%u to-%u tl-%u ho-%u hl-%u ct-%u", key.A, key.B, value.Flags,
+ printf("GetEHinfo key ftn-%016" PRIX64 " ehn-%u, value flg-%u to-%u tl-%u ho-%u hl-%u ct-%u", key.A, key.B, value.Flags,
value.TryOffset, value.TryLength, value.HandlerOffset, value.HandlerLength, value.ClassToken);
}
void MethodContext::repGetEHinfo(CORINFO_METHOD_HANDLE ftn, unsigned EHnumber, CORINFO_EH_CLAUSE* clause)
{
- AssertMapExists(GetEHinfo, ": key %016llX", CastHandle(ftn));
+ AssertMapExists(GetEHinfo, ": key %016" PRIX64 "", CastHandle(ftn));
DLD key;
ZeroMemory(&key, sizeof(key)); // Zero key including any struct padding
key.A = CastHandle(ftn);
key.B = (DWORD)EHnumber;
- Agnostic_CORINFO_EH_CLAUSE value = LookupByKeyOrMiss(GetEHinfo, key, ": key %016llX", CastHandle(ftn));
+ Agnostic_CORINFO_EH_CLAUSE value = LookupByKeyOrMiss(GetEHinfo, key, ": key %016" PRIX64 "", CastHandle(ftn));
DEBUG_REP(dmpGetEHinfo(key, value));
}
void MethodContext::dmpGetMethodVTableOffset(DWORDLONG key, DDD value)
{
- printf("GetMethodVTableOffset key ftn-%016llX, value offi-%u, offa-%u. offr-%d", key, value.A, value.B, value.C);
+ printf("GetMethodVTableOffset key ftn-%016" PRIX64 ", value offi-%u, offa-%u. offr-%d", key, value.A, value.B, value.C);
}
void MethodContext::repGetMethodVTableOffset(CORINFO_METHOD_HANDLE method,
unsigned* offsetOfIndirection,
bool* isRelative)
{
DWORDLONG key = CastHandle(method);
- DDD value = LookupByKeyOrMiss(GetMethodVTableOffset, key, ": key %016llX", key);
+ DDD value = LookupByKeyOrMiss(GetMethodVTableOffset, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetMethodVTableOffset(key, value));
void MethodContext::dmpResolveVirtualMethod(const Agnostic_ResolveVirtualMethodKey& key, const Agnostic_ResolveVirtualMethodResult& result)
{
- printf("ResolveVirtualMethod key virtMethod-%016llX, objClass-%016llX, context-%016llX pResolvedTokenVirtualMethodNonNull-%08X pResolvedTokenVirtualMethod{%s}",
+ printf("ResolveVirtualMethod key virtMethod-%016" PRIX64 ", objClass-%016" PRIX64 ", context-%016" PRIX64 " pResolvedTokenVirtualMethodNonNull-%08X pResolvedTokenVirtualMethod{%s}",
key.virtualMethod,
key.objClass,
key.context,
key.pResolvedTokenVirtualMethodNonNull,
key.pResolvedTokenVirtualMethodNonNull ? SpmiDumpHelper::DumpAgnostic_CORINFO_RESOLVED_TOKEN(key.pResolvedTokenVirtualMethod).c_str() : "???");
- printf(", value returnValue-%s, devirtMethod-%016llX, requiresInstArg-%s, exactContext-%016llX, detail-%d, tokDvMeth{%s}, tokDvUnboxMeth{%s}",
+ printf(", value returnValue-%s, devirtMethod-%016" PRIX64 ", requiresInstArg-%s, exactContext-%016" PRIX64 ", detail-%d, tokDvMeth{%s}, tokDvUnboxMeth{%s}",
result.returnValue ? "true" : "false",
result.devirtualizedMethod,
result.requiresInstMethodTableArg ? "true" : "false",
if (key.pResolvedTokenVirtualMethodNonNull)
key.pResolvedTokenVirtualMethod = SpmiRecordsHelper::StoreAgnostic_CORINFO_RESOLVED_TOKEN(info->pResolvedTokenVirtualMethod, ResolveToken);
- Agnostic_ResolveVirtualMethodResult result = LookupByKeyOrMiss(ResolveVirtualMethod, key, ": %016llX-%016llX-%016llX-%08X", key.virtualMethod, key.objClass, key.context, key.pResolvedTokenVirtualMethodNonNull);
+ Agnostic_ResolveVirtualMethodResult result = LookupByKeyOrMiss(ResolveVirtualMethod, key, ": %016" PRIX64 "-%016" PRIX64 "-%016" PRIX64 "-%08X", key.virtualMethod, key.objClass, key.context, key.pResolvedTokenVirtualMethodNonNull);
DEBUG_REP(dmpResolveVirtualMethod(key, result));
void MethodContext::dmpGetUnboxedEntry(DWORDLONG key, DLD value)
{
- printf("GetUnboxedEntry ftn-%016llX, result-%016llX, requires-inst-%u", key, value.A, value.B);
+ printf("GetUnboxedEntry ftn-%016" PRIX64 ", result-%016" PRIX64 ", requires-inst-%u", key, value.A, value.B);
}
CORINFO_METHOD_HANDLE MethodContext::repGetUnboxedEntry(CORINFO_METHOD_HANDLE ftn, bool* requiresInstMethodTableArg)
{
DWORDLONG key = CastHandle(ftn);
- DLD value = LookupByKeyOrMiss(GetUnboxedEntry, key, ": key %016llX", key);
+ DLD value = LookupByKeyOrMiss(GetUnboxedEntry, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetUnboxedEntry(key, value));
}
void MethodContext::dmpGetDefaultComparerClass(DWORDLONG key, DWORDLONG value)
{
- printf("GetDefaultComparerClass key cls-%016llX, value cls-%016llX", key, value);
+ printf("GetDefaultComparerClass key cls-%016" PRIX64 ", value cls-%016" PRIX64 "", key, value);
}
CORINFO_CLASS_HANDLE MethodContext::repGetDefaultComparerClass(CORINFO_CLASS_HANDLE cls)
{
DWORDLONG key = CastHandle(cls);
- DWORDLONG value = LookupByKeyOrMiss(GetDefaultComparerClass, key, ": key %016llX", key);
+ DWORDLONG value = LookupByKeyOrMiss(GetDefaultComparerClass, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetDefaultComparerClass(key, value));
CORINFO_CLASS_HANDLE result = (CORINFO_CLASS_HANDLE)value;
return result;
}
void MethodContext::dmpGetDefaultEqualityComparerClass(DWORDLONG key, DWORDLONG value)
{
- printf("GetDefaultEqualityComparerClass key cls-%016llX, value cls-%016llX", key, value);
+ printf("GetDefaultEqualityComparerClass key cls-%016" PRIX64 ", value cls-%016" PRIX64 "", key, value);
}
CORINFO_CLASS_HANDLE MethodContext::repGetDefaultEqualityComparerClass(CORINFO_CLASS_HANDLE cls)
{
DWORDLONG key = CastHandle(cls);
- DWORDLONG value = LookupByKeyOrMiss(GetDefaultEqualityComparerClass, key, ": key %016llX", key);
+ DWORDLONG value = LookupByKeyOrMiss(GetDefaultEqualityComparerClass, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetDefaultEqualityComparerClass(key, value));
CORINFO_CLASS_HANDLE result = (CORINFO_CLASS_HANDLE)value;
return result;
}
void MethodContext::dmpGetTokenTypeAsHandle(const GetTokenTypeAsHandleValue& key, DWORDLONG value)
{
- printf("GetTokenTypeAsHandle key ftn-%016llX fld-%016llX, value cls-%016llX", key.hMethod, key.hField, value);
+ printf("GetTokenTypeAsHandle key ftn-%016" PRIX64 " fld-%016" PRIX64 ", value cls-%016" PRIX64 "", key.hMethod, key.hField, value);
}
CORINFO_CLASS_HANDLE MethodContext::repGetTokenTypeAsHandle(CORINFO_RESOLVED_TOKEN* pResolvedToken)
{
}
void MethodContext::dmpGetFieldInfo(const Agnostic_GetFieldInfo& key, const Agnostic_CORINFO_FIELD_INFO& value)
{
- printf("GetFieldInfo key ch-%016llX flg-%08X rt{%s}", key.callerHandle, key.flags,
+ printf("GetFieldInfo key ch-%016" PRIX64 " flg-%08X rt{%s}", key.callerHandle, key.flags,
SpmiDumpHelper::DumpAgnostic_CORINFO_RESOLVED_TOKEN(key.ResolvedToken).c_str());
- printf(", value fa-%u fflg-%08X hlp-%u off-%u fT-%u(%s) sT-%016llX aa-%u hnum-%u na-%u {", value.fieldAccessor,
+ printf(", value fa-%u fflg-%08X hlp-%u off-%u fT-%u(%s) sT-%016" PRIX64 " aa-%u hnum-%u na-%u {", value.fieldAccessor,
value.fieldFlags, value.helper, value.offset, value.fieldType, toString((CorInfoType)value.fieldType),
value.structType, value.accessAllowed, value.accessCalloutHelper.helperNum,
value.accessCalloutHelper.numArgs);
printf("{%u: illegal}", i);
break;
case CORINFO_HELPER_ARG_TYPE_Field:
- printf("{%u: fld-%016llX}", i, value.accessCalloutHelper.args[i].constant);
+ printf("{%u: fld-%016" PRIX64 "}", i, value.accessCalloutHelper.args[i].constant);
break;
case CORINFO_HELPER_ARG_TYPE_Method:
- printf("{%u: mth-%016llX}", i, value.accessCalloutHelper.args[i].constant);
+ printf("{%u: mth-%016" PRIX64 "}", i, value.accessCalloutHelper.args[i].constant);
break;
case CORINFO_HELPER_ARG_TYPE_Class:
- printf("{%u: cls-%016llX}", i, value.accessCalloutHelper.args[i].constant);
+ printf("{%u: cls-%016" PRIX64 "}", i, value.accessCalloutHelper.args[i].constant);
break;
case CORINFO_HELPER_ARG_TYPE_Module:
- printf("{%u: mod-%016llX}", i, value.accessCalloutHelper.args[i].constant);
+ printf("{%u: mod-%016" PRIX64 "}", i, value.accessCalloutHelper.args[i].constant);
break;
case CORINFO_HELPER_ARG_TYPE_Const:
- printf("{%u: const-%016llX}", i, value.accessCalloutHelper.args[i].constant);
+ printf("{%u: const-%016" PRIX64 "}", i, value.accessCalloutHelper.args[i].constant);
break;
}
}
}
void MethodContext::dmpEmbedMethodHandle(DWORDLONG key, DLDL value)
{
- printf("EmbedMethodHandle key ftn-%016llX, value pp-%016llX res-%016llX", key, value.A, value.B);
+ printf("EmbedMethodHandle key ftn-%016" PRIX64 ", value pp-%016" PRIX64 " res-%016" PRIX64 "", key, value.A, value.B);
}
CORINFO_METHOD_HANDLE MethodContext::repEmbedMethodHandle(CORINFO_METHOD_HANDLE handle, void** ppIndirection)
{
DWORDLONG key = CastHandle(handle);
- DLDL value = LookupByKeyOrMiss(EmbedMethodHandle, key, ": key %016llX", key);
+ DLDL value = LookupByKeyOrMiss(EmbedMethodHandle, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpEmbedMethodHandle(key, value));
}
void MethodContext::dmpGetReadonlyStaticFieldValue(DLDDD key, DD value)
{
- printf("GetReadonlyStaticFieldValue key fld-%016llX bufSize-%u, ignoremovable-%u, valOffset-%u result-%u", key.A, key.B, key.C, key.D, value.A);
+ printf("GetReadonlyStaticFieldValue key fld-%016" PRIX64 " bufSize-%u, ignoremovable-%u, valOffset-%u result-%u", key.A, key.B, key.C, key.D, value.A);
GetReadonlyStaticFieldValue->Unlock();
}
bool MethodContext::repGetReadonlyStaticFieldValue(CORINFO_FIELD_HANDLE field, uint8_t* buffer, int bufferSize, int valueOffset, bool ignoreMovableObjects)
key.C = (DWORD)ignoreMovableObjects;
key.D = (DWORD)valueOffset;
- DD value = LookupByKeyOrMiss(GetReadonlyStaticFieldValue, key, ": key %016llX", key.A);
+ DD value = LookupByKeyOrMiss(GetReadonlyStaticFieldValue, key, ": key %016" PRIX64 "", key.A);
DEBUG_REP(dmpGetReadonlyStaticFieldValue(key, value));
if (buffer != nullptr && (bool)value.A)
}
void MethodContext::dmpGetStaticFieldCurrentClass(DWORDLONG key, const Agnostic_GetStaticFieldCurrentClass& value)
{
- printf("GetStaticFieldCurrentClass key fld-%016llX, value clsHnd-%016llX isSpeculative-%u", key, value.classHandle,
+ printf("GetStaticFieldCurrentClass key fld-%016" PRIX64 ", value clsHnd-%016" PRIX64 " isSpeculative-%u", key, value.classHandle,
value.isSpeculative);
}
CORINFO_CLASS_HANDLE MethodContext::repGetStaticFieldCurrentClass(CORINFO_FIELD_HANDLE field, bool* pIsSpeculative)
{
DWORDLONG key = CastHandle(field);
- Agnostic_GetStaticFieldCurrentClass value = LookupByKeyOrMiss(GetStaticFieldCurrentClass, key, ": key %016llX", key);
+ Agnostic_GetStaticFieldCurrentClass value = LookupByKeyOrMiss(GetStaticFieldCurrentClass, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetStaticFieldCurrentClass(key, value));
}
void MethodContext::dmpGetClassGClayout(DWORDLONG key, const Agnostic_GetClassGClayout& value)
{
- printf("GetClassGCLayout key %016llX, value len %u cnt %u {", key, value.len, value.valCount);
+ printf("GetClassGCLayout key %016" PRIX64 ", value len %u cnt %u {", key, value.len, value.valCount);
if (value.gcPtrs_Index != (DWORD)-1)
{
BYTE* ptr = (BYTE*)GetClassGClayout->GetBuffer(value.gcPtrs_Index);
unsigned MethodContext::repGetClassGClayout(CORINFO_CLASS_HANDLE cls, BYTE* gcPtrs)
{
DWORDLONG key = CastHandle(cls);
- Agnostic_GetClassGClayout value = LookupByKeyOrMiss(GetClassGClayout, key, ": key %016llX", key);
+ Agnostic_GetClassGClayout value = LookupByKeyOrMiss(GetClassGClayout, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetClassGClayout(key, value));
}
void MethodContext::dmpGetClassAlignmentRequirement(DLD key, DWORD value)
{
- printf("GetClassAlignmentRequirement key %016llX %u, value %u", key.A, key.B, value);
+ printf("GetClassAlignmentRequirement key %016" PRIX64 " %u, value %u", key.A, key.B, value);
}
unsigned MethodContext::repGetClassAlignmentRequirement(CORINFO_CLASS_HANDLE cls, bool fDoubleAlignHint)
{
key.A = CastHandle(cls);
key.B = (DWORD)fDoubleAlignHint;
- DWORD value = LookupByKeyOrMiss(GetClassAlignmentRequirement, key, ": key %016llX", key.A);
+ DWORD value = LookupByKeyOrMiss(GetClassAlignmentRequirement, key, ": key %016" PRIX64 "", key.A);
DEBUG_REP(dmpGetClassAlignmentRequirement(key, value));
unsigned result = (unsigned)value;
}
void MethodContext::dmpCanAccessClass(const Agnostic_CanAccessClassIn& key, const Agnostic_CanAccessClassOut& value)
{
- printf("CanAccessClass key rt{%s}, callerHandle %016llX\n",
+ printf("CanAccessClass key rt{%s}, callerHandle %016" PRIX64 "\n",
SpmiDumpHelper::DumpAgnostic_CORINFO_RESOLVED_TOKEN(key.ResolvedToken).c_str(), key.callerHandle);
printf(", value hnum-%u na-%u {", value.AccessHelper.helperNum, value.AccessHelper.numArgs);
for (int i = 0; i < CORINFO_ACCESS_ALLOWED_MAX_ARGS; i++)
{
- printf("{%016llX %u}", value.AccessHelper.args[i].constant, value.AccessHelper.args[i].argType);
+ printf("{%016" PRIX64 " %u}", value.AccessHelper.args[i].constant, value.AccessHelper.args[i].argType);
}
printf("} res-%u", value.result);
}
CORINFO_METHOD_HANDLE callerHandle,
CORINFO_HELPER_DESC* pAccessHelper)
{
- AssertMapExists(CanAccessClass, ": key %016llX", CastHandle(pResolvedToken->hClass));
+ AssertMapExists(CanAccessClass, ": key %016" PRIX64 "", CastHandle(pResolvedToken->hClass));
Agnostic_CanAccessClassIn key;
ZeroMemory(&key, sizeof(key)); // Zero key including any struct padding
key.ResolvedToken = SpmiRecordsHelper::RestoreAgnostic_CORINFO_RESOLVED_TOKEN(pResolvedToken, CanAccessClass);
key.callerHandle = CastHandle(callerHandle);
- Agnostic_CanAccessClassOut value = LookupByKeyOrMiss(CanAccessClass, key, ": key %016llX", CastHandle(pResolvedToken->hClass));
+ Agnostic_CanAccessClassOut value = LookupByKeyOrMiss(CanAccessClass, key, ": key %016" PRIX64 "", CastHandle(pResolvedToken->hClass));
DEBUG_REP(dmpCanAccessClass(key, value));
}
void MethodContext::dmpGetCastingHelper(const Agnostic_GetCastingHelper& key, DWORD value)
{
- printf("GetCastingHelper key cls-%016llX, thw-%u, value res-%u", key.hClass, key.fThrowing, value);
+ printf("GetCastingHelper key cls-%016" PRIX64 ", thw-%u, value res-%u", key.hClass, key.fThrowing, value);
}
CorInfoHelpFunc MethodContext::repGetCastingHelper(CORINFO_RESOLVED_TOKEN* pResolvedToken, bool fThrowing)
{
key.hClass = CastHandle(pResolvedToken->hClass);
key.fThrowing = (DWORD)fThrowing;
- DWORD value = LookupByKeyOrMiss(GetCastingHelper, key, ": key %016llX", key.hClass);
+ DWORD value = LookupByKeyOrMiss(GetCastingHelper, key, ": key %016" PRIX64 "", key.hClass);
DEBUG_REP(dmpGetCastingHelper(key, value));
CorInfoHelpFunc result = (CorInfoHelpFunc)value;
}
void MethodContext::dmpEmbedModuleHandle(DWORDLONG key, DLDL value)
{
- printf("EmbedModuleHandle key mod-%016llX, value pp-%016llX res-%016llX", key, value.A, value.B);
+ printf("EmbedModuleHandle key mod-%016" PRIX64 ", value pp-%016" PRIX64 " res-%016" PRIX64 "", key, value.A, value.B);
}
CORINFO_MODULE_HANDLE MethodContext::repEmbedModuleHandle(CORINFO_MODULE_HANDLE handle, void** ppIndirection)
{
DWORDLONG key = CastHandle(handle);
- DLDL value = LookupByKeyOrMiss(EmbedModuleHandle, key, ": key %016llX", key);
+ DLDL value = LookupByKeyOrMiss(EmbedModuleHandle, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpEmbedModuleHandle(key, value));
}
void MethodContext::dmpEmbedClassHandle(DWORDLONG key, DLDL value)
{
- printf("EmbedClassHandle key cls-%016llX, value pp-%016llX res-%016llX", key, value.A, value.B);
+ printf("EmbedClassHandle key cls-%016" PRIX64 ", value pp-%016" PRIX64 " res-%016" PRIX64 "", key, value.A, value.B);
}
CORINFO_CLASS_HANDLE MethodContext::repEmbedClassHandle(CORINFO_CLASS_HANDLE handle, void** ppIndirection)
{
DWORDLONG key = CastHandle(handle);
- DLDL value = LookupByKeyOrMiss(EmbedClassHandle, key, ": key %016llX", key);
+ DLDL value = LookupByKeyOrMiss(EmbedClassHandle, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpEmbedClassHandle(key, value));
}
void MethodContext::dmpPInvokeMarshalingRequired(const MethodOrSigInfoValue& key, DWORD value)
{
- printf("PInvokeMarshalingRequired key mth-%016llX scp-%016llX sig-%s, value res-%u",
+ printf("PInvokeMarshalingRequired key mth-%016" PRIX64 " scp-%016" PRIX64 " sig-%s, value res-%u",
key.method, key.scope,
SpmiDumpHelper::DumpPSig(key.pSig_Index, key.cbSig, PInvokeMarshalingRequired).c_str(),
value);
}
void MethodContext::dmpGetUnmanagedCallConv(const MethodOrSigInfoValue& key, DD value)
{
- printf("GetUnmanagedCallConv key mth-%016llX scp-%016llX sig-%s, value res-%u,%u",
+ printf("GetUnmanagedCallConv key mth-%016" PRIX64 " scp-%016" PRIX64 " sig-%s, value res-%u,%u",
key.method, key.scope,
SpmiDumpHelper::DumpPSig(key.pSig_Index, key.cbSig, GetUnmanagedCallConv).c_str(),
value.A, value.B);
LogDebug("Sparse - repGetUnmanagedCallConv returning CorInfoCallConvExtension::Managed");
return CorInfoCallConvExtension::Managed;
#else
- LogException(EXCEPTIONCODE_MC, "Found a null GetUnmanagedCallConv. Probably missing a fatTrigger for %016llX.",
+ LogException(EXCEPTIONCODE_MC, "Found a null GetUnmanagedCallConv. Probably missing a fatTrigger for %016" PRIX64 ".",
CastHandle(method));
#endif
}
}
void MethodContext::dmpFindSig(const Agnostic_FindSig& key, const Agnostic_CORINFO_SIG_INFO& value)
{
- printf("FindSig key module-%016llX sigTOK-%08X context-%016llX", key.module, key.sigTOK, key.context);
+ printf("FindSig key module-%016" PRIX64 " sigTOK-%08X context-%016" PRIX64 "", key.module, key.sigTOK, key.context);
printf(", value-%s",
SpmiDumpHelper::DumpAgnostic_CORINFO_SIG_INFO(value, FindSig, SigInstHandleMap).c_str());
}
}
void MethodContext::dmpGetGSCookie(DWORD key, DLDL value)
{
- printf("GetGSCookie key 0, value pCookieVal-%016llX ppCookieVal-%016llX", value.A, value.B);
+ printf("GetGSCookie key 0, value pCookieVal-%016" PRIX64 " ppCookieVal-%016" PRIX64 "", value.A, value.B);
}
void MethodContext::repGetGSCookie(GSCookie* pCookieVal, GSCookie** ppCookieVal)
{
}
void MethodContext::dmpGetClassModuleIdForStatics(DWORDLONG key, const Agnostic_GetClassModuleIdForStatics& value)
{
- printf("GetClassModuleIdForStatics key cls-%016llX, value mod-%016llX pp-%016llX res-%016llX", key, value.Module,
+ printf("GetClassModuleIdForStatics key cls-%016" PRIX64 ", value mod-%016" PRIX64 " pp-%016" PRIX64 " res-%016" PRIX64 "", key, value.Module,
value.pIndirection, value.result);
}
size_t MethodContext::repGetClassModuleIdForStatics(CORINFO_CLASS_HANDLE cls,
void** ppIndirection)
{
DWORDLONG key = CastHandle(cls);
- Agnostic_GetClassModuleIdForStatics value = LookupByKeyOrMiss(GetClassModuleIdForStatics, key, ": key %016llX", key);
+ Agnostic_GetClassModuleIdForStatics value = LookupByKeyOrMiss(GetClassModuleIdForStatics, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetClassModuleIdForStatics(key, value));
}
void MethodContext::dmpGetThreadTLSIndex(DWORD key, DLD value)
{
- printf("GetThreadTLSIndex key 0, value ppIndirection-%016llX result-%08X", value.A, value.B);
+ printf("GetThreadTLSIndex key 0, value ppIndirection-%016" PRIX64 " result-%08X", value.A, value.B);
}
DWORD MethodContext::repGetThreadTLSIndex(void** ppIndirection)
{
}
void MethodContext::dmpGetInlinedCallFrameVptr(DWORD key, DLDL value)
{
- printf("GetInlinedCallFrameVptr key 0, value ppIndirection-%016llX result-%016llX", value.A, value.B);
+ printf("GetInlinedCallFrameVptr key 0, value ppIndirection-%016" PRIX64 " result-%016" PRIX64 "", value.A, value.B);
}
const void* MethodContext::repGetInlinedCallFrameVptr(void** ppIndirection)
{
}
void MethodContext::dmpGetAddrOfCaptureThreadGlobal(DWORD key, DLDL value)
{
- printf("GetAddrOfCaptureThreadGlobal key %u, value ppi-%016llX res-%016llX", key, value.A, value.B);
+ printf("GetAddrOfCaptureThreadGlobal key %u, value ppi-%016" PRIX64 " res-%016" PRIX64 "", key, value.A, value.B);
}
int32_t* MethodContext::repGetAddrOfCaptureThreadGlobal(void** ppIndirection)
{
}
void MethodContext::dmpGetClassDomainID(DWORDLONG key, DLD value)
{
- printf("GetClassDomainID key cls-%016llX, value pp-%016llX res-%u", key, value.A, value.B);
+ printf("GetClassDomainID key cls-%016" PRIX64 ", value pp-%016" PRIX64 " res-%u", key, value.A, value.B);
}
unsigned MethodContext::repGetClassDomainID(CORINFO_CLASS_HANDLE cls, void** ppIndirection)
{
DWORDLONG key = CastHandle(cls);
- DLD value = LookupByKeyOrMiss(GetClassDomainID, key, ": key %016llX", key);
+ DLD value = LookupByKeyOrMiss(GetClassDomainID, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetClassDomainID(key, value));
}
void MethodContext::dmpGetLocationOfThisType(DWORDLONG key, const Agnostic_CORINFO_LOOKUP_KIND& value)
{
- printf("GetLocationOfThisType key ftn-%016llX, value %s", key,
+ printf("GetLocationOfThisType key ftn-%016" PRIX64 ", value %s", key,
SpmiDumpHelper::DumpAgnostic_CORINFO_LOOKUP_KIND(value).c_str());
}
void MethodContext::repGetLocationOfThisType(CORINFO_METHOD_HANDLE context, CORINFO_LOOKUP_KIND* pLookupKind)
{
DWORDLONG key = CastHandle(context);
- Agnostic_CORINFO_LOOKUP_KIND value = LookupByKeyOrMiss(GetLocationOfThisType, key, ": key %016llX", key);
+ Agnostic_CORINFO_LOOKUP_KIND value = LookupByKeyOrMiss(GetLocationOfThisType, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetLocationOfThisType(key, value));
*pLookupKind = SpmiRecordsHelper::RestoreCORINFO_LOOKUP_KIND(value);
}
}
void MethodContext::dmpGetDelegateCtor(const Agnostic_GetDelegateCtorIn& key, const Agnostic_GetDelegateCtorOut& value)
{
- printf("GetDelegateCtor key ftn-%016llX cls-%016llX tftn-%016llX, value pm-%016llX a3-%016llX a4-%016llX "
- "a5-%016llX res-%016llX",
+ printf("GetDelegateCtor key ftn-%016" PRIX64 " cls-%016" PRIX64 " tftn-%016" PRIX64 ", value pm-%016" PRIX64 " a3-%016" PRIX64 " a4-%016" PRIX64 " "
+ "a5-%016" PRIX64 " res-%016" PRIX64 "",
key.methHnd, key.clsHnd, key.targetMethodHnd, value.CtorData.pMethod, value.CtorData.pArg3,
value.CtorData.pArg4, value.CtorData.pArg5, value.result);
}
key.clsHnd = CastHandle(clsHnd);
key.targetMethodHnd = CastHandle(targetMethodHnd);
- Agnostic_GetDelegateCtorOut value = LookupByKeyOrMiss(GetDelegateCtor, key, ": key %016llX", key.methHnd);
+ Agnostic_GetDelegateCtorOut value = LookupByKeyOrMiss(GetDelegateCtor, key, ": key %016" PRIX64 "", key.methHnd);
DEBUG_REP(dmpGetDelegateCtor(key, value));
}
void MethodContext::dmpGetFunctionFixedEntryPoint(DWORDLONG key, const Agnostic_CORINFO_CONST_LOOKUP& value)
{
- printf("GetFunctionFixedEntryPoint key ftn-%016llX, value %s", key,
+ printf("GetFunctionFixedEntryPoint key ftn-%016" PRIX64 ", value %s", key,
SpmiDumpHelper::DumpAgnostic_CORINFO_CONST_LOOKUP(value).c_str());
}
void MethodContext::repGetFunctionFixedEntryPoint(CORINFO_METHOD_HANDLE ftn, bool isUnsafeFunctionPointer, CORINFO_CONST_LOOKUP* pResult)
// The isUnsafeFunctionPointer has no impact on the resulting value.
// It helps produce side-effects in the runtime only.
DWORDLONG key = CastHandle(ftn);
- Agnostic_CORINFO_CONST_LOOKUP value = LookupByKeyOrMiss(GetFunctionFixedEntryPoint, key, ": key %016llX", key);
+ Agnostic_CORINFO_CONST_LOOKUP value = LookupByKeyOrMiss(GetFunctionFixedEntryPoint, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetFunctionFixedEntryPoint(key, value));
*pResult = SpmiRecordsHelper::RestoreCORINFO_CONST_LOOKUP(value);
}
}
void MethodContext::dmpGetFieldInClass(DLD key, DWORDLONG value)
{
- printf("GetFieldInClass key cls-%016llX ind-%u, value %016llX", key.A, key.B, value);
+ printf("GetFieldInClass key cls-%016" PRIX64 " ind-%u, value %016" PRIX64 "", key.A, key.B, value);
}
CORINFO_FIELD_HANDLE MethodContext::repGetFieldInClass(CORINFO_CLASS_HANDLE clsHnd, INT num)
{
key.A = CastHandle(clsHnd);
key.B = (DWORD)num;
- DWORDLONG value = LookupByKeyOrMiss(GetFieldInClass, key, ": key %016llX", key.A);
+ DWORDLONG value = LookupByKeyOrMiss(GetFieldInClass, key, ": key %016" PRIX64 "", key.A);
DEBUG_REP(dmpGetFieldInClass(key, value));
CORINFO_FIELD_HANDLE result = (CORINFO_FIELD_HANDLE)value;
}
void MethodContext::dmpGetFieldType(DLDL key, DLD value)
{
- printf("GetFieldType key fld-%016llX cls-%016llX, value ch-%016llX cit-%u(%s)", key.A, key.B, value.A, value.B,
+ printf("GetFieldType key fld-%016" PRIX64 " cls-%016" PRIX64 ", value ch-%016" PRIX64 " cit-%u(%s)", key.A, key.B, value.A, value.B,
toString((CorInfoType)value.B));
}
CorInfoType MethodContext::repGetFieldType(CORINFO_FIELD_HANDLE field,
key.A = CastHandle(field);
key.B = CastHandle(memberParent);
- DLD value = LookupByKeyOrMiss(GetFieldType, key, ": key %016llX", key.A);
+ DLD value = LookupByKeyOrMiss(GetFieldType, key, ": key %016" PRIX64 "", key.A);
DEBUG_REP(dmpGetFieldType(key, value));
}
void MethodContext::dmpCanInlineTypeCheck(DLD key, DWORD value)
{
- printf("CanInlineTypeCheck key cls-%016llX src-%08X, value res-%u", key.A, key.B, value);
+ printf("CanInlineTypeCheck key cls-%016" PRIX64 " src-%08X, value res-%u", key.A, key.B, value);
}
CorInfoInlineTypeCheck MethodContext::repCanInlineTypeCheck(CORINFO_CLASS_HANDLE cls,
CorInfoInlineTypeCheckSource source)
key.A = CastHandle(cls);
key.B = (DWORD)source;
- DWORD value = LookupByKeyOrMiss(CanInlineTypeCheck, key, ": key %016llX", key.A);
+ DWORD value = LookupByKeyOrMiss(CanInlineTypeCheck, key, ": key %016" PRIX64 "", key.A);
DEBUG_REP(dmpCanInlineTypeCheck(key, value));
CorInfoInlineTypeCheck result = (CorInfoInlineTypeCheck)value;
}
void MethodContext::dmpSatisfiesMethodConstraints(DLDL key, DWORD value)
{
- printf("SatisfiesMethodConstraints key cls-%016llX ftn-%016llX, value res-%u", key.A, key.B, value);
+ printf("SatisfiesMethodConstraints key cls-%016" PRIX64 " ftn-%016" PRIX64 ", value res-%u", key.A, key.B, value);
}
bool MethodContext::repSatisfiesMethodConstraints(CORINFO_CLASS_HANDLE parent, CORINFO_METHOD_HANDLE method)
{
}
void MethodContext::dmpIsValidStringRef(DLD key, DWORD value)
{
- printf("IsValidStringRef key mod-%016llX tok-%08X, value res-%u", key.A, key.B, value);
+ printf("IsValidStringRef key mod-%016" PRIX64 " tok-%08X, value res-%u", key.A, key.B, value);
}
bool MethodContext::repIsValidStringRef(CORINFO_MODULE_HANDLE module, unsigned metaTOK)
{
void MethodContext::dmpGetStringLiteral(DLDDD key, DD value)
{
- printf("GetStringLiteral key mod-%016llX tok-%08X, bufSize-%u, startIndex-%u, len-%u", key.A, key.B, key.C, key.D, value.A);
+ printf("GetStringLiteral key mod-%016" PRIX64 " tok-%08X, bufSize-%u, startIndex-%u, len-%u", key.A, key.B, key.C, key.D, value.A);
GetStringLiteral->Unlock();
}
key.C = (DWORD)bufferSize;
key.D = (DWORD)startIndex;
- DD value = LookupByKeyOrMiss(GetStringLiteral, key, ": key handle-%016llX token-%X bufferSize-%d startIndex-%d", key.A, key.B, key.C, key.D);
+ DD value = LookupByKeyOrMiss(GetStringLiteral, key, ": key handle-%016" PRIX64 " token-%X bufferSize-%d startIndex-%d", key.A, key.B, key.C, key.D);
DEBUG_REP(dmpGetStringLiteral(key, value));
int srcBufferLength = (int)value.A;
}
void MethodContext::dmpCanCast(DLDL key, DWORD value)
{
- printf("CanCast key chd-%016llX par-%016llX, value res-%u", key.A, key.B, value);
+ printf("CanCast key chd-%016" PRIX64 " par-%016" PRIX64 ", value res-%u", key.A, key.B, value);
}
bool MethodContext::repCanCast(CORINFO_CLASS_HANDLE child, CORINFO_CLASS_HANDLE parent)
{
key.A = CastHandle(child);
key.B = CastHandle(parent);
- DWORD value = LookupByKeyOrMiss(CanCast, key, ": key %016llX %016llX", key.A, key.B);
+ DWORD value = LookupByKeyOrMiss(CanCast, key, ": key %016" PRIX64 " %016" PRIX64 "", key.A, key.B);
DEBUG_REP(dmpCanCast(key, value));
return value != 0;
}
void MethodContext::dmpGetChildType(DWORDLONG key, DLD value)
{
- printf("GetChildType key cls-%016llX, value clsr-%016llX cit-%u(%s)", key, value.A, value.B,
+ printf("GetChildType key cls-%016" PRIX64 ", value clsr-%016" PRIX64 " cit-%u(%s)", key, value.A, value.B,
toString((CorInfoType)value.B));
}
CorInfoType MethodContext::repGetChildType(CORINFO_CLASS_HANDLE clsHnd, CORINFO_CLASS_HANDLE* clsRet)
{
DWORDLONG key = CastHandle(clsHnd);
- DLD value = LookupByKeyOrMiss(GetChildType, key, ": key %016llX", key);
+ DLD value = LookupByKeyOrMiss(GetChildType, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetChildType(key, value));
}
void MethodContext::dmpGetArrayInitializationData(DLD key, DWORDLONG value)
{
- printf("GetArrayInitializationData key field-%016llX size-%08X, value result-%016llX", key.A, key.B, value);
+ printf("GetArrayInitializationData key field-%016" PRIX64 " size-%08X, value result-%016" PRIX64 "", key.A, key.B, value);
}
void* MethodContext::repGetArrayInitializationData(CORINFO_FIELD_HANDLE field, DWORD size)
{
}
void MethodContext::dmpGetAddressOfPInvokeTarget(DWORDLONG key, DLD value)
{
- printf("GetAddressOfPInvokeTarget key ftn-%016llX, value addr-%016llX at-%u", key, value.A, value.B);
+ printf("GetAddressOfPInvokeTarget key ftn-%016" PRIX64 ", value addr-%016" PRIX64 " at-%u", key, value.A, value.B);
}
void MethodContext::repGetAddressOfPInvokeTarget(CORINFO_METHOD_HANDLE method, CORINFO_CONST_LOOKUP* pLookup)
{
DWORDLONG key = CastHandle(method);
- DLD value = LookupByKeyOrMiss(GetAddressOfPInvokeTarget, key, ": key %016llX", key);
+ DLD value = LookupByKeyOrMiss(GetAddressOfPInvokeTarget, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetAddressOfPInvokeTarget(key, value));
}
void MethodContext::dmpSatisfiesClassConstraints(DWORDLONG key, DWORD value)
{
- printf("SatisfiesClassConstraints key cls-%016llX, value res-%u", key, value);
+ printf("SatisfiesClassConstraints key cls-%016" PRIX64 ", value res-%u", key, value);
}
bool MethodContext::repSatisfiesClassConstraints(CORINFO_CLASS_HANDLE cls)
{
DWORDLONG key = CastHandle(cls);
- DWORD value = LookupByKeyOrMiss(SatisfiesClassConstraints, key, ": key %016llX", key);
+ DWORD value = LookupByKeyOrMiss(SatisfiesClassConstraints, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpSatisfiesClassConstraints(key, value));
return value != 0;
}
}
void MethodContext::dmpGetMethodHash(DWORDLONG key, DWORD value)
{
- printf("GetMethodHash key %016llX, value %u", key, value);
+ printf("GetMethodHash key %016" PRIX64 ", value %u", key, value);
}
unsigned MethodContext::repGetMethodHash(CORINFO_METHOD_HANDLE ftn)
{
}
void MethodContext::dmpCanTailCall(const Agnostic_CanTailCall& key, DWORD value)
{
- printf("CanTailCall key clr-%016llX dcle-%016llX ecle-%016llX pfx-%u, value res-%u", key.callerHnd,
+ printf("CanTailCall key clr-%016" PRIX64 " dcle-%016" PRIX64 " ecle-%016" PRIX64 " pfx-%u, value res-%u", key.callerHnd,
key.declaredCalleeHnd, key.exactCalleeHnd, key.fIsTailPrefix, value);
}
bool MethodContext::repCanTailCall(CORINFO_METHOD_HANDLE callerHnd,
key.exactCalleeHnd = CastHandle(exactCalleeHnd);
key.fIsTailPrefix = (DWORD)fIsTailPrefix;
- DWORD value = LookupByKeyOrMiss(CanTailCall, key, ": key %016llX", key.callerHnd);
+ DWORD value = LookupByKeyOrMiss(CanTailCall, key, ": key %016" PRIX64 "", key.callerHnd);
DEBUG_REP(dmpCanTailCall(key, value));
return value != 0;
}
void MethodContext::dmpIsCompatibleDelegate(const Agnostic_IsCompatibleDelegate& key, DD value)
{
- printf("IsCompatibleDelegate key objCls-%016llX methodParentCls-%016llX method-%016llX delegateCls-%016llX, value "
+ printf("IsCompatibleDelegate key objCls-%016" PRIX64 " methodParentCls-%016" PRIX64 " method-%016" PRIX64 " delegateCls-%016" PRIX64 ", value "
"pfIsOpenDelegate-%08X result-%08X",
key.objCls, key.methodParentCls, key.method, key.delegateCls, value.A, value.B);
}
}
void MethodContext::dmpIsDelegateCreationAllowed(DLDL key, DWORD value)
{
- printf("IsDelegateCreationAllowed key delegateHnd-%016llX calleeHnd-%016llX result-%08X", key.A, key.B, value);
+ printf("IsDelegateCreationAllowed key delegateHnd-%016" PRIX64 " calleeHnd-%016" PRIX64 " result-%08X", key.A, key.B, value);
}
bool MethodContext::repIsDelegateCreationAllowed(CORINFO_CLASS_HANDLE delegateHnd, CORINFO_METHOD_HANDLE calleeHnd)
{
}
void MethodContext::dmpFindCallSiteSig(const Agnostic_FindCallSiteSig& key, const Agnostic_CORINFO_SIG_INFO& value)
{
- printf("dmpFindCallSiteSig key module-%016llX methTok-%08X context-%016llX", key.module, key.methTok, key.context);
+ printf("dmpFindCallSiteSig key module-%016" PRIX64 " methTok-%08X context-%016" PRIX64 "", key.module, key.methTok, key.context);
printf(", value-%s",
SpmiDumpHelper::DumpAgnostic_CORINFO_SIG_INFO(value, FindCallSiteSig, SigInstHandleMap).c_str());
}
}
void MethodContext::dmpGetMethodSync(DWORDLONG key, DLDL value)
{
- printf("GetMethodSync key %016llX, value pp-%016llX res-%016llX", key, value.A, value.B);
+ printf("GetMethodSync key %016" PRIX64 ", value pp-%016" PRIX64 " res-%016" PRIX64 "", key, value.A, value.B);
}
void* MethodContext::repGetMethodSync(CORINFO_METHOD_HANDLE ftn, void** ppIndirection)
{
DWORDLONG key = CastHandle(ftn);
- DLDL value = LookupByKeyOrMiss(GetMethodSync, key, ": key %016llX", key);
+ DLDL value = LookupByKeyOrMiss(GetMethodSync, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetMethodSync(key, value));
}
void MethodContext::dmpGetVarArgsHandle(const GetVarArgsHandleValue& key, DLDL value)
{
- printf("GetVarArgsHandle key sig-%s scope-%016llX token-%08X",
+ printf("GetVarArgsHandle key sig-%s scope-%016" PRIX64 " token-%08X",
SpmiDumpHelper::DumpPSig(key.pSig_Index, key.cbSig, GetVarArgsHandle).c_str(),
key.scope, key.token);
- printf(", value ppIndirection-%016llX result-%016llX", value.A, value.B);
+ printf(", value ppIndirection-%016" PRIX64 " result-%016" PRIX64 "", value.A, value.B);
}
CORINFO_VARARGS_HANDLE MethodContext::repGetVarArgsHandle(CORINFO_SIG_INFO* pSig, void** ppIndirection)
{
}
void MethodContext::dmpCanGetVarArgsHandle(const CanGetVarArgsHandleValue& key, DWORD value)
{
- printf("CanGetVarArgsHandle key scope-%016llX token-%08X, value result-%08X", key.scope, key.token, value);
+ printf("CanGetVarArgsHandle key scope-%016" PRIX64 " token-%08X, value result-%08X", key.scope, key.token, value);
}
bool MethodContext::repCanGetVarArgsHandle(CORINFO_SIG_INFO* pSig)
{
key.scope = CastHandle(pSig->scope);
key.token = (DWORD)pSig->token;
- DWORD value = LookupByKeyOrMiss(CanGetVarArgsHandle, key, ": key %016llX %08X", key.scope, key.token);
+ DWORD value = LookupByKeyOrMiss(CanGetVarArgsHandle, key, ": key %016" PRIX64 " %08X", key.scope, key.token);
DEBUG_REP(dmpCanGetVarArgsHandle(key, value));
return value != 0;
}
void MethodContext::dmpGetFieldThreadLocalStoreID(DWORDLONG key, DLD value)
{
- printf("GetFieldThreadLocalStoreID key field-%016llX, value ppIndirection-%016llX result-%08X", key, value.A,
+ printf("GetFieldThreadLocalStoreID key field-%016" PRIX64 ", value ppIndirection-%016" PRIX64 " result-%08X", key, value.A,
value.B);
}
DWORD MethodContext::repGetFieldThreadLocalStoreID(CORINFO_FIELD_HANDLE field, void** ppIndirection)
{
DWORDLONG key = CastHandle(field);
- DLD value = LookupByKeyOrMiss(GetFieldThreadLocalStoreID, key, ": key %016llX", key);
+ DLD value = LookupByKeyOrMiss(GetFieldThreadLocalStoreID, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetFieldThreadLocalStoreID(key, value));
void MethodContext::dmpAllocPgoInstrumentationBySchema(DWORDLONG key, const Agnostic_AllocPgoInstrumentationBySchema& value)
{
- printf("AllocPgoInstrumentationBySchema key ftn-%016llX, value res-%08X addr-%016llX cnt-%u schema{\n",
+ printf("AllocPgoInstrumentationBySchema key ftn-%016" PRIX64 ", value res-%08X addr-%016" PRIX64 " cnt-%u schema{\n",
key, value.result, value.instrumentationDataAddress, value.countSchemaItems);
if (value.countSchemaItems > 0)
printf("\n");
for (DWORD i = 0; i < value.countSchemaItems; i++)
{
- printf(" %u-{Offset %016llX ILOffset %u Kind %u(0x%x) Count %u Other %u}\n",
+ printf(" %u-{Offset %016" PRIX64 " ILOffset %u Kind %u(0x%x) Count %u Other %u}\n",
i, pBuf[i].Offset, pBuf[i].ILOffset, pBuf[i].InstrumentationKind, pBuf[i].InstrumentationKind, pBuf[i].Count, pBuf[i].Other);
}
AllocPgoInstrumentationBySchema->Unlock();
}
void MethodContext::dmpGetPgoInstrumentationResults(DWORDLONG key, const Agnostic_GetPgoInstrumentationResults& value)
{
- printf("GetPgoInstrumentationResults key ftn-%016llX, value res-%08X schemaCnt-%u profileBufSize-%u source-%u schema{",
+ printf("GetPgoInstrumentationResults key ftn-%016" PRIX64 ", value res-%08X schemaCnt-%u profileBufSize-%u source-%u schema{",
key, value.result, value.countSchemaItems, value.dataByteCount, value.pgoSource);
if (value.countSchemaItems > 0)
printf("\n");
for (DWORD i = 0; i < value.countSchemaItems; i++)
{
- printf(" %u-{Offset %016llX ILOffset %u Kind %u(0x%x) Count %u Other %u Data ",
+ printf(" %u-{Offset %016" PRIX64 " ILOffset %u Kind %u(0x%x) Count %u Other %u Data ",
i, pBuf[i].Offset, pBuf[i].ILOffset, pBuf[i].InstrumentationKind, pBuf[i].InstrumentationKind, pBuf[i].Count, pBuf[i].Other);
switch((ICorJitInfo::PgoInstrumentationKind)pBuf[i].InstrumentationKind)
printf("B %u", *(unsigned*)(pInstrumentationData + pBuf[i].Offset));
break;
case ICorJitInfo::PgoInstrumentationKind::BasicBlockLongCount:
- printf("B %llu", *(uint64_t*)(pInstrumentationData + pBuf[i].Offset));
+ printf("B %" PRIu64 "", *(uint64_t*)(pInstrumentationData + pBuf[i].Offset));
break;
case ICorJitInfo::PgoInstrumentationKind::EdgeIntCount:
printf("E %u", *(unsigned*)(pInstrumentationData + pBuf[i].Offset));
break;
case ICorJitInfo::PgoInstrumentationKind::EdgeLongCount:
- printf("E %llu", *(uint64_t*)(pInstrumentationData + pBuf[i].Offset));
+ printf("E %" PRIu64 "", *(uint64_t*)(pInstrumentationData + pBuf[i].Offset));
break;
case ICorJitInfo::PgoInstrumentationKind::HandleHistogramIntCount:
printf("T %u", *(unsigned*)(pInstrumentationData + pBuf[i].Offset));
break;
case ICorJitInfo::PgoInstrumentationKind::HandleHistogramLongCount:
- printf("T %llu", *(uint64_t*)(pInstrumentationData + pBuf[i].Offset));
+ printf("T %" PRIu64 "", *(uint64_t*)(pInstrumentationData + pBuf[i].Offset));
break;
case ICorJitInfo::PgoInstrumentationKind::HandleHistogramTypes:
case ICorJitInfo::PgoInstrumentationKind::HandleHistogramMethods:
for (unsigned int j = 0; j < pBuf[i].Count; j++)
{
- printf("[%u] %016llX ", j, CastHandle(*(uintptr_t*)(pInstrumentationData + pBuf[i].Offset + j * sizeof(uintptr_t))));
+ printf("[%u] %016" PRIX64 " ", j, CastHandle(*(uintptr_t*)(pInstrumentationData + pBuf[i].Offset + j * sizeof(uintptr_t))));
}
break;
case ICorJitInfo::PgoInstrumentationKind::GetLikelyClass:
case ICorJitInfo::PgoInstrumentationKind::GetLikelyMethod:
{
// (N)umber, (L)ikelihood, (H)andle
- printf("N %u L %u H %016llX", (unsigned)(pBuf[i].Other >> 8), (unsigned)(pBuf[i].Other && 0xFF), CastHandle(*(uintptr_t*)(pInstrumentationData + pBuf[i].Offset)));
+ printf("N %u L %u H %016" PRIX64 "", (unsigned)(pBuf[i].Other >> 8), (unsigned)(pBuf[i].Other && 0xFF), CastHandle(*(uintptr_t*)(pInstrumentationData + pBuf[i].Offset)));
}
break;
default:
ICorJitInfo::PgoSource* pPgoSource)
{
DWORDLONG key = CastHandle(ftnHnd);
- Agnostic_GetPgoInstrumentationResults tempValue = LookupByKeyOrMiss(GetPgoInstrumentationResults, key, ": key %016llX", key);
+ Agnostic_GetPgoInstrumentationResults tempValue = LookupByKeyOrMiss(GetPgoInstrumentationResults, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetPgoInstrumentationResults(key, tempValue));
key.A = CastHandle(cls1);
key.B = CastHandle(cls2);
- DWORDLONG value = LookupByKeyOrMiss(MergeClasses, key, ": key %016llX %016llX", key.A, key.B);
+ DWORDLONG value = LookupByKeyOrMiss(MergeClasses, key, ": key %016" PRIX64 " %016" PRIX64 "", key.A, key.B);
DEBUG_REP(dmpMergeClasses(key, value));
return (CORINFO_CLASS_HANDLE)value;
}
void MethodContext::dmpIsMoreSpecificType(DLDL key, DWORD value)
{
- printf("IsMoreSpecificType key cls1-%016llX cls2-%016llX, value %u", key.A, key.B, value);
+ printf("IsMoreSpecificType key cls1-%016" PRIX64 " cls2-%016" PRIX64 ", value %u", key.A, key.B, value);
}
bool MethodContext::repIsMoreSpecificType(CORINFO_CLASS_HANDLE cls1, CORINFO_CLASS_HANDLE cls2)
{
key.A = CastHandle(cls1);
key.B = CastHandle(cls2);
- DWORD value = LookupByKeyOrMiss(IsMoreSpecificType, key, ": key %016llX %016llX", key.A, key.B);
+ DWORD value = LookupByKeyOrMiss(IsMoreSpecificType, key, ": key %016" PRIX64 " %016" PRIX64 "", key.A, key.B);
DEBUG_REP(dmpIsMoreSpecificType(key, value));
return value != 0;
}
void MethodContext::dmpIsEnum(DWORDLONG key, DLD value)
{
- printf("IsEnum key cls-%016llX, value underlyingType-%016llX result-%u", key, value.A, value.B);
+ printf("IsEnum key cls-%016" PRIX64 ", value underlyingType-%016" PRIX64 " result-%u", key, value.A, value.B);
}
TypeCompareState MethodContext::repIsEnum(CORINFO_CLASS_HANDLE cls, CORINFO_CLASS_HANDLE* underlyingType)
{
DWORDLONG key = CastHandle(cls);
- DLD value = LookupByKeyOrMiss(IsEnum, key, ": key %016llX", key);
+ DLD value = LookupByKeyOrMiss(IsEnum, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpIsEnum(key, value));
if (underlyingType != nullptr)
}
void MethodContext::dmpCanGetCookieForPInvokeCalliSig(const CanGetCookieForPInvokeCalliSigValue& key, DWORD value)
{
- printf("CanGetCookieForPInvokeCalliSig key scope-%016llX token-%08X, value result-%08X", key.scope, key.token,
+ printf("CanGetCookieForPInvokeCalliSig key scope-%016" PRIX64 " token-%08X, value result-%08X", key.scope, key.token,
value);
}
bool MethodContext::repCanGetCookieForPInvokeCalliSig(CORINFO_SIG_INFO* szMetaSig)
}
void MethodContext::dmpCanAccessFamily(DLDL key, DWORD value)
{
- printf("CanAccessFamily key cal-%016llX inst-%016llX, value %u", key.A, key.B, value);
+ printf("CanAccessFamily key cal-%016" PRIX64 " inst-%016" PRIX64 ", value %u", key.A, key.B, value);
}
bool MethodContext::repCanAccessFamily(CORINFO_METHOD_HANDLE hCaller, CORINFO_CLASS_HANDLE hInstanceType)
{
}
void MethodContext::dmpGetProfilingHandle(DWORD key, const Agnostic_GetProfilingHandle& value)
{
- printf("GetProfilingHandle key %u, value bHookFtn-%u profHnd-%016llX bIndHnd-%u", key, value.bHookFunction,
+ printf("GetProfilingHandle key %u, value bHookFtn-%u profHnd-%016" PRIX64 " bIndHnd-%u", key, value.bHookFunction,
value.ProfilerHandle, value.bIndirectedHandles);
}
void MethodContext::repGetProfilingHandle(bool* pbHookFunction, void** pProfilerHandle, bool* pbIndirectedHandles)
CORINFO_FIELD_HANDLE MethodContext::repEmbedFieldHandle(CORINFO_FIELD_HANDLE handle, void** ppIndirection)
{
DWORDLONG key = CastHandle(handle);
- DLDL value = LookupByKeyOrMiss(EmbedFieldHandle, key, ": key %016llX", key);
+ DLDL value = LookupByKeyOrMiss(EmbedFieldHandle, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpEmbedFieldHandle(key, value));
key.A = CastHandle(cls1);
key.B = CastHandle(cls2);
- DWORD value = LookupByKeyOrMiss(AreTypesEquivalent, key, ": key %016llX %016llX", key.A, key.B);
+ DWORD value = LookupByKeyOrMiss(AreTypesEquivalent, key, ": key %016" PRIX64 " %016" PRIX64 "", key.A, key.B);
DEBUG_REP(dmpAreTypesEquivalent(key, value));
return value != 0;
}
void MethodContext::dmpCompareTypesForCast(DLDL key, DWORD value)
{
- printf("CompareTypesForCast key fromClass=%016llX, toClass=%016llx, result=%d", key.A, key.B, value);
+ printf("CompareTypesForCast key fromClass=%016" PRIX64 ", toClass=%016" PRIx64 ", result=%d", key.A, key.B, value);
}
TypeCompareState MethodContext::repCompareTypesForCast(CORINFO_CLASS_HANDLE fromClass, CORINFO_CLASS_HANDLE toClass)
{
key.A = CastHandle(fromClass);
key.B = CastHandle(toClass);
- DWORD value = LookupByKeyOrMiss(CompareTypesForCast, key, ": key %016llX %016llX", key.A, key.B);
+ DWORD value = LookupByKeyOrMiss(CompareTypesForCast, key, ": key %016" PRIX64 " %016" PRIX64 "", key.A, key.B);
DEBUG_REP(dmpCompareTypesForCast(key, value));
TypeCompareState result = (TypeCompareState)value;
}
void MethodContext::dmpCompareTypesForEquality(DLDL key, DWORD value)
{
- printf("CompareTypesForEquality key cls1=%016llX, cls2=%016llx, result=%d", key.A, key.B, value);
+ printf("CompareTypesForEquality key cls1=%016" PRIX64 ", cls2=%016" PRIx64 ", result=%d", key.A, key.B, value);
}
TypeCompareState MethodContext::repCompareTypesForEquality(CORINFO_CLASS_HANDLE cls1, CORINFO_CLASS_HANDLE cls2)
{
key.A = CastHandle(cls1);
key.B = CastHandle(cls2);
- DWORD value = LookupByKeyOrMiss(CompareTypesForEquality, key, ": key %016llX %016llX", key.A, key.B);
+ DWORD value = LookupByKeyOrMiss(CompareTypesForEquality, key, ": key %016" PRIX64 " %016" PRIX64 "", key.A, key.B);
DEBUG_REP(dmpCompareTypesForEquality(key, value));
TypeCompareState result = (TypeCompareState)value;
ZeroMemory(buff, (unsigned int)value.A + 1);
memcpy(buff, FindNameOfToken->GetBuffer(value.B), (unsigned int)value.A);
FindNameOfToken->Unlock();
- printf("FindNameOfToken key mod-%016llX tok-%08X, value '%s'", key.A, key.B, buff);
+ printf("FindNameOfToken key mod-%016" PRIX64 " tok-%08X, value '%s'", key.A, key.B, buff);
delete[] buff;
}
size_t MethodContext::repFindNameOfToken(CORINFO_MODULE_HANDLE module,
key.A = CastHandle(module);
key.B = (DWORD)metaTOK;
- DLD value = LookupByKeyOrMiss(FindNameOfToken, key, ": key %016llX", key.A);
+ DLD value = LookupByKeyOrMiss(FindNameOfToken, key, ": key %016" PRIX64 "", key.A);
DEBUG_REP(dmpFindNameOfToken(key, value));
void MethodContext::dmpGetSystemVAmd64PassStructInRegisterDescriptor(
DWORDLONG key, const Agnostic_GetSystemVAmd64PassStructInRegisterDescriptor& value)
{
- printf("GetSystemVAmd64PassStructInRegisterDescriptor key structHnd-%016llX, value passInReg-%u 8bCount-%u", key,
+ printf("GetSystemVAmd64PassStructInRegisterDescriptor key structHnd-%016" PRIX64 ", value passInReg-%u 8bCount-%u", key,
value.passedInRegisters, value.eightByteCount);
for (int i = 0; i < CLR_SYSTEMV_MAX_EIGHTBYTES_COUNT_TO_PASS_IN_REGISTERS; i++)
{
DWORDLONG key = CastHandle(structHnd);
Agnostic_GetSystemVAmd64PassStructInRegisterDescriptor value;
- value = LookupByKeyOrMiss(GetSystemVAmd64PassStructInRegisterDescriptor, key, ": key %016llX", key);
+ value = LookupByKeyOrMiss(GetSystemVAmd64PassStructInRegisterDescriptor, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetSystemVAmd64PassStructInRegisterDescriptor(key, value));
void MethodContext::dmpGetLoongArch64PassStructInRegisterFlags(DWORDLONG key, DWORD value)
{
- printf("GetLoongArch64PassStructInRegisterFlags key %016llX value-%08X", key, value);
+ printf("GetLoongArch64PassStructInRegisterFlags key %016" PRIX64 " value-%08X", key, value);
}
DWORD MethodContext::repGetLoongArch64PassStructInRegisterFlags(CORINFO_CLASS_HANDLE structHnd)
}
void MethodContext::dmpGetRelocTypeHint(DWORDLONG key, DWORD value)
{
- printf("GetRelocTypeHint key tgt-%016llX, value hint-%u", key, value);
+ printf("GetRelocTypeHint key tgt-%016" PRIX64 ", value hint-%u", key, value);
}
WORD MethodContext::repGetRelocTypeHint(void* target)
{
LogDebug("Sparse - repGetRelocTypeHint yielding fake answer...");
return 65535;
#else
- LogException(EXCEPTIONCODE_MC, "Didn't find %016llX", key);
+ LogException(EXCEPTIONCODE_MC, "Didn't find %016" PRIX64 "", key);
#endif
}
if (GetRelocTypeHint->GetIndex(key) == -1)
LogDebug("Sparse - repGetRelocTypeHint yielding fake answer...");
return 65535;
#else
- LogException(EXCEPTIONCODE_MC, "Didn't find %016llX", key);
+ LogException(EXCEPTIONCODE_MC, "Didn't find %016" PRIX64 "", key);
#endif
}
}
void MethodContext::dmpDoesFieldBelongToClass(DLDL key, bool value)
{
- printf("DoesFieldBelongToClass key fld=%016llX, cls=%016llx, result=%d", key.A, key.B, value);
+ printf("DoesFieldBelongToClass key fld=%016" PRIX64 ", cls=%016" PRIx64 ", result=%d", key.A, key.B, value);
}
bool MethodContext::repDoesFieldBelongToClass(CORINFO_FIELD_HANDLE fld, CORINFO_CLASS_HANDLE cls)
key.A = CastHandle(fld);
key.B = CastHandle(cls);
- DWORD value = LookupByKeyOrMiss(DoesFieldBelongToClass, key, ": key %016llX %016llX", key.A, key.B);
+ DWORD value = LookupByKeyOrMiss(DoesFieldBelongToClass, key, ": key %016" PRIX64 " %016" PRIX64 "", key.A, key.B);
DEBUG_REP(dmpDoesFieldBelongToClass(key, value));
return value != 0;
}
void MethodContext::dmpIsValidToken(DLD key, DWORD value)
{
- printf("IsValidToken key mod-%016llX tok-%08X, value res-%u", key.A, key.B, value);
+ printf("IsValidToken key mod-%016" PRIX64 " tok-%08X, value res-%u", key.A, key.B, value);
}
bool MethodContext::repIsValidToken(CORINFO_MODULE_HANDLE module, unsigned metaTOK)
{
key.A = CastHandle(module);
key.B = (DWORD)metaTOK;
- DWORD value = LookupByKeyOrMiss(IsValidToken, key, ": key %016llX", key.A);
+ DWORD value = LookupByKeyOrMiss(IsValidToken, key, ": key %016" PRIX64 "", key.A);
DEBUG_REP(dmpIsValidToken(key, value));
return value != 0;
{
unsigned char* className = (unsigned char*)GetClassNameFromMetadata->GetBuffer(value.A);
unsigned char* namespaceName = (unsigned char*)GetClassNameFromMetadata->GetBuffer(value.B);
- printf("GetClassNameFromMetadata key - classNonNull-%llu namespaceNonNull-%u, value "
+ printf("GetClassNameFromMetadata key - classNonNull-%" PRIu64 " namespaceNonNull-%u, value "
"class-'%s', namespace-'%s'",
key.A, key.B, className, namespaceName);
GetClassNameFromMetadata->Unlock();
}
void MethodContext::dmpGetTypeInstantiationArgument(DLD key, DWORDLONG value)
{
- printf("GetTypeInstantiationArgument key - classNonNull-%llu, index-%u, value NonNull-%llu", key.A, key.B, value);
+ printf("GetTypeInstantiationArgument key - classNonNull-%" PRIu64 ", index-%u, value NonNull-%" PRIu64 "", key.A, key.B, value);
GetTypeInstantiationArgument->Unlock();
}
CORINFO_CLASS_HANDLE MethodContext::repGetTypeInstantiationArgument(CORINFO_CLASS_HANDLE cls, unsigned index)
DWORDLONG key,
const Agnostic_PrintResult& value)
{
- printf("%s key hnd-%016llX, stringBufferSize-%u, requiredBufferSize-%u", name, key, value.stringBufferSize, value.requiredBufferSize);
+ printf("%s key hnd-%016" PRIX64 ", stringBufferSize-%u, requiredBufferSize-%u", name, key, value.stringBufferSize, value.requiredBufferSize);
buffer->Unlock();
}
size_t bufferSize,
size_t* pRequiredBufferSize)
{
- Agnostic_PrintResult res = LookupByKeyOrMiss(map, handle, ": map %s key %016llx", name, handle);
+ Agnostic_PrintResult res = LookupByKeyOrMiss(map, handle, ": map %s key %016" PRIx64 "", name, handle);
DEBUG_REP(dmpPrint(name, buffer, handle, res));
if (pRequiredBufferSize != nullptr)
{
if (res.requiredBufferSize == UINT_MAX)
{
- LogException(EXCEPTIONCODE_MC, "SuperPMI assertion failed (missing requiredBufferSize for %s key %016llx)", name, handle);
+ LogException(EXCEPTIONCODE_MC, "SuperPMI assertion failed (missing requiredBufferSize for %s key %016" PRIx64 ")", name, handle);
}
*pRequiredBufferSize = res.requiredBufferSize;
bool haveFullBuffer = (res.requiredBufferSize != UINT_MAX) && ((res.stringBufferSize + 1) >= res.requiredBufferSize);
if (!haveFullBuffer && (bufferSize > static_cast<size_t>(res.stringBufferSize) + 1))
{
- LogException(EXCEPTIONCODE_MC, "SuperPMI assertion failed (not enough buffer data for %s key %016llx)", name, handle);
+ LogException(EXCEPTIONCODE_MC, "SuperPMI assertion failed (not enough buffer data for %s key %016" PRIx64 ")", name, handle);
}
size_t bytesWritten = 0;
SpmiDumpHelper::DumpAgnostic_CORINFO_RESOLVED_TOKEN(key.callToken).c_str(),
SpmiDumpHelper::DumpAgnostic_CORINFO_SIG_INFO(key.sig, GetTailCallHelpers, SigInstHandleMap).c_str(),
key.flags);
- printf(", value result-%s flg-%08X hStoreArgs-%016llX hCallTarget-%016llX hDispatcher-%016llX",
+ printf(", value result-%s flg-%08X hStoreArgs-%016" PRIX64 " hCallTarget-%016" PRIX64 " hDispatcher-%016" PRIX64 "",
value.result ? "true" : "false",
value.flags,
value.hStoreArgs,
}
void MethodContext::dmpGetMethodDefFromMethod(DWORDLONG key, DWORD value)
{
- printf("GetMethodDefFromMethod key ftn-%016llX, value res-%u", key, value);
+ printf("GetMethodDefFromMethod key ftn-%016" PRIX64 ", value res-%u", key, value);
}
mdMethodDef MethodContext::repGetMethodDefFromMethod(CORINFO_METHOD_HANDLE hMethod)
{
}
void MethodContext::dmpCheckMethodModifier(const Agnostic_CheckMethodModifier& key, DWORD value)
{
- printf("CheckMethodModifier key, ftn-%016llX mod-'%s' opt-%u, value res-%u", key.hMethod,
+ printf("CheckMethodModifier key, ftn-%016" PRIX64 " mod-'%s' opt-%u, value res-%u", key.hMethod,
(unsigned char*)CheckMethodModifier->GetBuffer(key.modifier), key.fOptional, value);
CheckMethodModifier->Unlock();
}
}
void MethodContext::dmpGetArrayRank(DWORDLONG key, DWORD value)
{
- printf("GetArrayRank key %016llX, value %u", key, value);
+ printf("GetArrayRank key %016" PRIX64 ", value %u", key, value);
}
unsigned MethodContext::repGetArrayRank(CORINFO_CLASS_HANDLE cls)
{
DWORDLONG key = CastHandle(cls);
- DWORD value = LookupByKeyOrMiss(GetArrayRank, key, ": key %016llX", key);
+ DWORD value = LookupByKeyOrMiss(GetArrayRank, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetArrayRank(key, value));
unsigned result = (unsigned)value;
return result;
}
void MethodContext::dmpGetArrayIntrinsicID(DWORDLONG key, DWORD value)
{
- printf("GetArrayIntrinsicID key %016llX, value %u", key, value);
+ printf("GetArrayIntrinsicID key %016" PRIX64 ", value %u", key, value);
}
CorInfoArrayIntrinsic MethodContext::repGetArrayIntrinsicID(CORINFO_METHOD_HANDLE hMethod)
{
DWORDLONG key = CastHandle(hMethod);
- DWORD value = LookupByKeyOrMiss(GetArrayIntrinsicID, key, ": key %016llX", key);
+ DWORD value = LookupByKeyOrMiss(GetArrayIntrinsicID, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetArrayIntrinsicID(key, value));
CorInfoArrayIntrinsic result = (CorInfoArrayIntrinsic)value;
return result;
}
void MethodContext::dmpIsFieldStatic(DWORDLONG key, DWORD value)
{
- printf("IsFieldStatic key %016llX, value %u", key, value);
+ printf("IsFieldStatic key %016" PRIX64 ", value %u", key, value);
}
bool MethodContext::repIsFieldStatic(CORINFO_FIELD_HANDLE fhld)
{
DWORDLONG key = CastHandle(fhld);
- DWORD value = LookupByKeyOrMiss(IsFieldStatic, key, ": key %016llX", key);
+ DWORD value = LookupByKeyOrMiss(IsFieldStatic, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpIsFieldStatic(key, value));
return value != 0;
}
}
void MethodContext::dmpGetArrayOrStringLength(DWORDLONG key, DWORD value)
{
- printf("GetArrayOrStringLength key %016llX, value %u", key, value);
+ printf("GetArrayOrStringLength key %016" PRIX64 ", value %u", key, value);
}
int MethodContext::repGetArrayOrStringLength(CORINFO_OBJECT_HANDLE objHandle)
{
DWORDLONG key = CastHandle(objHandle);
- DWORD value = LookupByKeyOrMiss(GetArrayOrStringLength, key, ": key %016llX", key);
+ DWORD value = LookupByKeyOrMiss(GetArrayOrStringLength, key, ": key %016" PRIX64 "", key);
DEBUG_REP(dmpGetArrayOrStringLength(key, value));
return value != 0;
}
void MethodContext::dmpSigInstHandleMap(DWORD key, DWORDLONG value)
{
- printf("SigInstHandleMap key %u, value %016llX", key, value);
+ printf("SigInstHandleMap key %u, value %016" PRIX64 "", key, value);
}
int MethodContext::dumpMethodIdentityInfoToBuffer(char* buff, int len, bool ignoreMethodName /* = false */, CORINFO_METHOD_INFO* optInfo /* = nullptr */, unsigned optFlags /* = 0 */)
len -= t;
// Add Calling convention information, CorInfoOptions, CorInfoRegionKind, jit flags, and ISA flags.
- t = sprintf_s(buff, len, "CallingConvention: %d, CorInfoOptions: %d, CorInfoRegionKind: %d, JitFlags %016llx, ISA Flags", pInfo->args.callConv,
+ t = sprintf_s(buff, len, "CallingConvention: %d, CorInfoOptions: %d, CorInfoRegionKind: %d, JitFlags %016" PRIx64 ", ISA Flags", pInfo->args.callConv,
pInfo->options, pInfo->regionKind, corJitFlags.GetFlagsRaw());
buff += t;
len -= t;
const int flagsFieldCount = corJitFlags.GetInstructionFlagsFieldCount();
for (int i = flagsFieldCount - 1; i >= 0; i--)
{
- t = sprintf_s(buff, len, " %016llX", raw[i]);
+ t = sprintf_s(buff, len, " %016" PRIX64 "", raw[i]);
buff += t;
len -= t;
}
dumpHashToBuffer(schemaData + minOffset, (int)(maxOffset - minOffset), pgoHash,
MM3_HASH_BUFFER_SIZE);
- t = sprintf_s(buff, len, " Pgo Counters %u, Count %llu, Hash: %s", schemaCount, totalCount, pgoHash);
+ t = sprintf_s(buff, len, " Pgo Counters %u, Count %" PRIu64 ", Hash: %s", schemaCount, totalCount, pgoHash);
buff += t;
len -= t;
}
projects / platform / upstream / dotnet / runtime.git / commitdiff