// When the EE loads the System.Numerics.Vectors assembly, it asks the JIT what length (in bytes) of
// SIMD vector it supports as an intrinsic type. Zero means that the JIT does not support SIMD
// intrinsics, so the EE should use the default size (i.e. the size of the IL implementation).
+#if COR_JIT_EE_VERSION > 460
+ unsigned getMaxIntrinsicSIMDVectorLength(CORJIT_FLAGS cpuCompileFlags); /* { return 0; } */
+#else
unsigned getMaxIntrinsicSIMDVectorLength(DWORD cpuCompileFlags); /* { return 0; } */
+#endif
// IL obfuscators sometimes interpose on the EE-JIT interface. This function allows the VM to
// tell the JIT to use a particular ICorJitCompiler to implement the methods of this interface,
// in the code are. The native compiler will ensure that these places
// have a corresponding break point in native code.
//
- // Note that unless CORJIT_FLG_DEBUG_CODE is specified, this function will
+ // Note that unless CORJIT_FLAG_DEBUG_CODE is specified, this function will
// be used only as a hint and the native compiler should not change its
// code generation.
void getBoundaries(
// under debugging, the JIT needs to keep them live over their
// entire scope so that they can be inspected.
//
- // Note that unless CORJIT_FLG_DEBUG_CODE is specified, this function will
+ // Note that unless CORJIT_FLAG_DEBUG_CODE is specified, this function will
// be used only as a hint and the native compiler should not change its
// code generation.
void getVars(
void MethodContext::dmpCompileMethod(DWORD key, const Agnostic_CompileMethod& value)
{
printf("CompiledMethod key %u, value ftn-%016llX scp-%016llX ilo-%u ils-%u ms-%u ehc-%u opt-%u rk-%u "
- "args{cc-%u rc-%016llX rts-%016llX rt-%u(%s) flg-%08X nA-%u cc-%u ci-%u mc-%u mi-%u arg-%016llX cb-%u pSig-%u scp-%016llX tok-%08X} "
+ "args{cc-%u rc-%016llX rts-%016llX rt-%u(%s) flg-%08X nA-%u cc-%u ci-%u mc-%u mi-%u arg-%016llX cb-%u pSig-%u scp-%016llX tok-%08X} "
"locals{cc-%u rc-%016llX rts-%016llX rt-%u(%s) flg-%08X nA-%u cc-%u ci-%u mc-%u mi-%u arg-%016llX cb-%u pSig-%u scp-%016llX tok-%08X} "
"flg-%08X",
key,
}
void MethodContext::dmpGetJitFlags(DWORD key, DD value)
{
- CORJIT_FLAGS *flags = (CORJIT_FLAGS*)GetJitFlags->GetBuffer(value.A);
- printf("GetJitFlags key %u sizeInBytes-%u corJitFlags-%08X corJitFlags2-%08X", key, value.B, flags->corJitFlags, flags->corJitFlags2);
+ CORJIT_FLAGS *jitflags = (CORJIT_FLAGS*)GetJitFlags->GetBuffer(value.A);
+ printf("GetJitFlags key %u sizeInBytes-%u jitFlags-%016llX", key, value.B, jitflags->GetFlagsRaw());
GetJitFlags->Unlock();
}
DWORD MethodContext::repGetJitFlags(CORJIT_FLAGS *jitFlags, DWORD sizeInBytes)
original_ICorJitCompiler->getVersionIdentifier(versionIdentifier);
}
-unsigned interceptor_ICJC::getMaxIntrinsicSIMDVectorLength(DWORD cpuCompileFlags)
+unsigned interceptor_ICJC::getMaxIntrinsicSIMDVectorLength(CORJIT_FLAGS cpuCompileFlags)
{
return original_ICorJitCompiler->getMaxIntrinsicSIMDVectorLength(cpuCompileFlags);
}
// in the code are. The native compiler will ensure that these places
// have a corresponding break point in native code.
//
-// Note that unless CORJIT_FLG_DEBUG_CODE is specified, this function will
+// Note that unless CORJIT_FLAG_DEBUG_CODE is specified, this function will
// be used only as a hint and the native compiler should not change its
// code generation.
void interceptor_ICJI::getBoundaries(
// under debugging, the JIT needs to keep them live over their
// entire scope so that they can be inspected.
//
-// Note that unless CORJIT_FLG_DEBUG_CODE is specified, this function will
+// Note that unless CORJIT_FLAG_DEBUG_CODE is specified, this function will
// be used only as a hint and the native compiler should not change its
// code generation.
void interceptor_ICJI::getVars(
original_ICorJitCompiler->getVersionIdentifier(versionIdentifier);
}
-unsigned interceptor_ICJC::getMaxIntrinsicSIMDVectorLength(DWORD cpuCompileFlags)
+unsigned interceptor_ICJC::getMaxIntrinsicSIMDVectorLength(CORJIT_FLAGS cpuCompileFlags)
{
mcs->AddCall("getMaxIntrinsicSIMDVectorLength");
return original_ICorJitCompiler->getMaxIntrinsicSIMDVectorLength(cpuCompileFlags);
// in the code are. The native compiler will ensure that these places
// have a corresponding break point in native code.
//
-// Note that unless CORJIT_FLG_DEBUG_CODE is specified, this function will
+// Note that unless CORJIT_FLAG_DEBUG_CODE is specified, this function will
// be used only as a hint and the native compiler should not change its
// code generation.
void interceptor_ICJI::getBoundaries(
// under debugging, the JIT needs to keep them live over their
// entire scope so that they can be inspected.
//
-// Note that unless CORJIT_FLG_DEBUG_CODE is specified, this function will
+// Note that unless CORJIT_FLAG_DEBUG_CODE is specified, this function will
// be used only as a hint and the native compiler should not change its
// code generation.
void interceptor_ICJI::getVars(
original_ICorJitCompiler->getVersionIdentifier(versionIdentifier);
}
-unsigned interceptor_ICJC::getMaxIntrinsicSIMDVectorLength(DWORD cpuCompileFlags)
+unsigned interceptor_ICJC::getMaxIntrinsicSIMDVectorLength(CORJIT_FLAGS cpuCompileFlags)
{
return original_ICorJitCompiler->getMaxIntrinsicSIMDVectorLength(cpuCompileFlags);
}
// in the code are. The native compiler will ensure that these places
// have a corresponding break point in native code.
//
-// Note that unless CORJIT_FLG_DEBUG_CODE is specified, this function will
+// Note that unless CORJIT_FLAG_DEBUG_CODE is specified, this function will
// be used only as a hint and the native compiler should not change its
// code generation.
void interceptor_ICJI::getBoundaries(
// under debugging, the JIT needs to keep them live over their
// entire scope so that they can be inspected.
//
-// Note that unless CORJIT_FLG_DEBUG_CODE is specified, this function will
+// Note that unless CORJIT_FLAG_DEBUG_CODE is specified, this function will
// be used only as a hint and the native compiler should not change its
// code generation.
void interceptor_ICJI::getVars(
// in the code are. The native compiler will ensure that these places
// have a corresponding break point in native code.
//
-// Note that unless CORJIT_FLG_DEBUG_CODE is specified, this function will
+// Note that unless CORJIT_FLAG_DEBUG_CODE is specified, this function will
// be used only as a hint and the native compiler should not change its
// code generation.
void MyICJI::getBoundaries(
// under debugging, the JIT needs to keep them live over their
// entire scope so that they can be inspected.
//
-// Note that unless CORJIT_FLG_DEBUG_CODE is specified, this function will
+// Note that unless CORJIT_FLAG_DEBUG_CODE is specified, this function will
// be used only as a hint and the native compiler should not change its
// code generation.
void MyICJI::getVars(
class ICorCompilePreloader
{
public:
- typedef void (__stdcall *CORCOMPILE_CompileStubCallback)(LPVOID pContext, CORINFO_METHOD_HANDLE hStub, DWORD dwJitFlags);
+ typedef void (__stdcall *CORCOMPILE_CompileStubCallback)(LPVOID pContext, CORINFO_METHOD_HANDLE hStub, CORJIT_FLAGS jitFlags);
//
// Map methods are available after Serialize() is called
// Get the compilation flags that are shared between JIT and NGen
virtual HRESULT GetBaseJitFlags(
IN CORINFO_METHOD_HANDLE hMethod,
- OUT DWORD *pFlags) = 0;
+ OUT CORJIT_FLAGS *pFlags) = 0;
// needed for stubs to obtain the number of bytes to copy into the native image
// return the beginning of the stub and the size to copy (in bytes)
/*****************************************************************************/
// This function determines the compile flags to use for a generic intatiation
// since only the open instantiation can be verified.
-// See the comment associated with CORJIT_FLG_SKIP_VERIFICATION for details.
+// See the comment associated with CORJIT_FLAG_SKIP_VERIFICATION for details.
//
// On return:
// if *raiseVerificationException=TRUE, the caller should raise a VerificationException.
// if *unverifiableGenericCode=TRUE, the method is a generic instantiation with
// unverifiable code
-CorJitFlag GetCompileFlagsIfGenericInstantiation(
+CORJIT_FLAGS GetCompileFlagsIfGenericInstantiation(
CORINFO_METHOD_HANDLE method,
- CorJitFlag compileFlags,
+ CORJIT_FLAGS compileFlags,
ICorJitInfo * pCorJitInfo,
BOOL * raiseVerificationException,
BOOL * unverifiableGenericCode);
#if COR_JIT_EE_VERSION > 460
// Update this one
-SELECTANY const GUID JITEEVersionIdentifier = { /* 8d588c98-4cef-4e6d-9792-08e1f5ab88c5 */
- 0x8d588c98,
- 0x4cef,
- 0x4e6d,
- {0x97, 0x92, 0x08, 0xe1, 0xf5, 0xab, 0x88, 0xc5}
+SELECTANY const GUID JITEEVersionIdentifier = { /* 4bd06266-8ef7-4172-bec6-d3149fde7859 */
+ 0x4bd06266,
+ 0x8ef7,
+ 0x4172,
+ {0xbe, 0xc6, 0xd3, 0x14, 0x9f, 0xde, 0x78, 0x59}
};
#else
// in the code are. The native compiler will ensure that these places
// have a corresponding break point in native code.
//
- // Note that unless CORJIT_FLG_DEBUG_CODE is specified, this function will
+ // Note that unless CORJIT_FLAG_DEBUG_CODE is specified, this function will
// be used only as a hint and the native compiler should not change its
// code generation.
virtual void getBoundaries(
// under debugging, the JIT needs to keep them live over their
// entire scope so that they can be inspected.
//
- // Note that unless CORJIT_FLG_DEBUG_CODE is specified, this function will
+ // Note that unless CORJIT_FLAG_DEBUG_CODE is specified, this function will
// be used only as a hint and the native compiler should not change its
// code generation.
virtual void getVars(
};
+#if COR_JIT_EE_VERSION <= 460
+
/* values for flags in compileMethod */
enum CorJitFlag
CORJIT_FLG_ALIGN_LOOPS = 0x20000000, // add NOPs before loops to align them at 16 byte boundaries
CORJIT_FLG_PUBLISH_SECRET_PARAM= 0x40000000, // JIT must place stub secret param into local 0. (used by IL stubs)
CORJIT_FLG_GCPOLL_INLINE = 0x80000000, // JIT must inline calls to GCPoll when possible
-
-#if COR_JIT_EE_VERSION > 460
- CORJIT_FLG_CALL_GETJITFLAGS = 0xffffffff, // Indicates that the JIT should retrieve flags in the form of a
- // pointer to a CORJIT_FLAGS value via ICorJitInfo::getJitFlags().
-#endif
};
enum CorJitFlag2
{
CORJIT_FLG2_SAMPLING_JIT_BACKGROUND = 0x00000001, // JIT is being invoked as a result of stack sampling for hot methods in the background
-#if COR_JIT_EE_VERSION > 460
- CORJIT_FLG2_USE_PINVOKE_HELPERS = 0x00000002, // The JIT should use the PINVOKE_{BEGIN,END} helpers instead of emitting inline transitions
- CORJIT_FLG2_REVERSE_PINVOKE = 0x00000004, // The JIT should insert REVERSE_PINVOKE_{ENTER,EXIT} helpers into method prolog/epilog
- CORJIT_FLG2_DESKTOP_QUIRKS = 0x00000008, // The JIT should generate desktop-quirk-compatible code
-#endif
};
struct CORJIT_FLAGS
unsigned corJitFlags2; // Values are from CorJitFlag2
};
+#endif // COR_JIT_EE_VERSION <= 460
+
+#if COR_JIT_EE_VERSION > 460
+
+class CORJIT_FLAGS
+{
+public:
+
+ enum CorJitFlag
+ {
+ CORJIT_FLAG_CALL_GETJITFLAGS = 0xffffffff, // Indicates that the JIT should retrieve flags in the form of a
+ // pointer to a CORJIT_FLAGS value via ICorJitInfo::getJitFlags().
+ CORJIT_FLAG_SPEED_OPT = 0,
+ CORJIT_FLAG_SIZE_OPT = 1,
+ CORJIT_FLAG_DEBUG_CODE = 2, // generate "debuggable" code (no code-mangling optimizations)
+ CORJIT_FLAG_DEBUG_EnC = 3, // We are in Edit-n-Continue mode
+ CORJIT_FLAG_DEBUG_INFO = 4, // generate line and local-var info
+ CORJIT_FLAG_MIN_OPT = 5, // disable all jit optimizations (not necesarily debuggable code)
+ CORJIT_FLAG_GCPOLL_CALLS = 6, // Emit calls to JIT_POLLGC for thread suspension.
+ CORJIT_FLAG_MCJIT_BACKGROUND = 7, // Calling from multicore JIT background thread, do not call JitComplete
+
+ #if defined(_TARGET_X86_)
+
+ CORJIT_FLAG_PINVOKE_RESTORE_ESP = 8, // Restore ESP after returning from inlined PInvoke
+ CORJIT_FLAG_TARGET_P4 = 9,
+ CORJIT_FLAG_USE_FCOMI = 10, // Generated code may use fcomi(p) instruction
+ CORJIT_FLAG_USE_CMOV = 11, // Generated code may use cmov instruction
+ CORJIT_FLAG_USE_SSE2 = 12, // Generated code may use SSE-2 instructions
+
+ #else // !defined(_TARGET_X86_)
+
+ CORJIT_FLAG_UNUSED1 = 8,
+ CORJIT_FLAG_UNUSED2 = 9,
+ CORJIT_FLAG_UNUSED3 = 10,
+ CORJIT_FLAG_UNUSED4 = 11,
+ CORJIT_FLAG_UNUSED5 = 12,
+
+ #endif // !defined(_TARGET_X86_)
+
+ #if defined(_TARGET_X86_) || defined(_TARGET_AMD64_)
+
+ CORJIT_FLAG_USE_SSE3_4 = 13,
+ CORJIT_FLAG_USE_AVX = 14,
+ CORJIT_FLAG_USE_AVX2 = 15,
+ CORJIT_FLAG_USE_AVX_512 = 16,
+ CORJIT_FLAG_FEATURE_SIMD = 17,
+
+ #else // !defined(_TARGET_X86_) && !defined(_TARGET_AMD64_)
+
+ CORJIT_FLAG_UNUSED6 = 13,
+ CORJIT_FLAG_UNUSED7 = 14,
+ CORJIT_FLAG_UNUSED8 = 15,
+ CORJIT_FLAG_UNUSED9 = 16,
+ CORJIT_FLAG_UNUSED10 = 17,
+
+ #endif // !defined(_TARGET_X86_) && !defined(_TARGET_AMD64_)
+
+ CORJIT_FLAG_MAKEFINALCODE = 18, // Use the final code generator, i.e., not the interpreter.
+ CORJIT_FLAG_READYTORUN = 19, // Use version-resilient code generation
+ CORJIT_FLAG_PROF_ENTERLEAVE = 20, // Instrument prologues/epilogues
+ CORJIT_FLAG_PROF_REJIT_NOPS = 21, // Insert NOPs to ensure code is re-jitable
+ CORJIT_FLAG_PROF_NO_PINVOKE_INLINE = 22, // Disables PInvoke inlining
+ CORJIT_FLAG_SKIP_VERIFICATION = 23, // (lazy) skip verification - determined without doing a full resolve. See comment below
+ CORJIT_FLAG_PREJIT = 24, // jit or prejit is the execution engine.
+ CORJIT_FLAG_RELOC = 25, // Generate relocatable code
+ CORJIT_FLAG_IMPORT_ONLY = 26, // Only import the function
+ CORJIT_FLAG_IL_STUB = 27, // method is an IL stub
+ CORJIT_FLAG_PROCSPLIT = 28, // JIT should separate code into hot and cold sections
+ CORJIT_FLAG_BBINSTR = 29, // Collect basic block profile information
+ CORJIT_FLAG_BBOPT = 30, // Optimize method based on profile information
+ CORJIT_FLAG_FRAMED = 31, // All methods have an EBP frame
+ CORJIT_FLAG_ALIGN_LOOPS = 32, // add NOPs before loops to align them at 16 byte boundaries
+ CORJIT_FLAG_PUBLISH_SECRET_PARAM = 33, // JIT must place stub secret param into local 0. (used by IL stubs)
+ CORJIT_FLAG_GCPOLL_INLINE = 34, // JIT must inline calls to GCPoll when possible
+ CORJIT_FLAG_SAMPLING_JIT_BACKGROUND = 35, // JIT is being invoked as a result of stack sampling for hot methods in the background
+ CORJIT_FLAG_USE_PINVOKE_HELPERS = 36, // The JIT should use the PINVOKE_{BEGIN,END} helpers instead of emitting inline transitions
+ CORJIT_FLAG_REVERSE_PINVOKE = 37, // The JIT should insert REVERSE_PINVOKE_{ENTER,EXIT} helpers into method prolog/epilog
+ CORJIT_FLAG_DESKTOP_QUIRKS = 38, // The JIT should generate desktop-quirk-compatible code
+ };
+
+ CORJIT_FLAGS()
+ : corJitFlags(0)
+ {
+ // empty
+ }
+
+ // Convenience constructor to set exactly one flag.
+ CORJIT_FLAGS(CorJitFlag flag)
+ : corJitFlags(0)
+ {
+ Set(flag);
+ }
+
+ CORJIT_FLAGS(const CORJIT_FLAGS& other)
+ {
+ corJitFlags = other.corJitFlags;
+ }
+
+ void Reset()
+ {
+ corJitFlags = 0;
+ }
+
+ void Set(CorJitFlag flag)
+ {
+ corJitFlags |= 1ULL << (unsigned __int64)flag;
+ }
+
+ void Clear(CorJitFlag flag)
+ {
+ corJitFlags &= ~(1ULL << (unsigned __int64)flag);
+ }
+
+ bool IsSet(CorJitFlag flag) const
+ {
+ return (corJitFlags & (1ULL << (unsigned __int64)flag)) != 0;
+ }
+
+ void Add(const CORJIT_FLAGS& other)
+ {
+ corJitFlags |= other.corJitFlags;
+ }
+
+ void Remove(const CORJIT_FLAGS& other)
+ {
+ corJitFlags &= ~other.corJitFlags;
+ }
+
+ bool IsEmpty() const
+ {
+ return corJitFlags == 0;
+ }
+
+ // DO NOT USE THIS FUNCTION! (except in very restricted special cases)
+ unsigned __int64 GetFlagsRaw()
+ {
+ return corJitFlags;
+ }
+
+private:
+
+ unsigned __int64 corJitFlags;
+};
+
+#endif // COR_JIT_EE_VERSION > 460
+
/*****************************************************************************
-Here is how CORJIT_FLG_SKIP_VERIFICATION should be interepreted.
+Here is how CORJIT_FLAG_SKIP_VERIFICATION should be interepreted.
Note that even if any method is inlined, it need not be verified.
-if (CORJIT_FLG_SKIP_VERIFICATION is passed in to ICorJitCompiler::compileMethod())
+if (CORJIT_FLAG_SKIP_VERIFICATION is passed in to ICorJitCompiler::compileMethod())
{
No verification needs to be done.
Just compile the method, generating unverifiable code if necessary
case INSTVER_GENERIC_PASSED_VERIFICATION:
{
- This cannot ever happen because the VM would pass in CORJIT_FLG_SKIP_VERIFICATION.
+ This cannot ever happen because the VM would pass in CORJIT_FLAG_SKIP_VERIFICATION.
}
case INSTVER_GENERIC_FAILED_VERIFICATION:
case CORINFO_VERIFICATION_CAN_SKIP:
{
- This cannot ever happen because the CLR would pass in CORJIT_FLG_SKIP_VERIFICATION.
+ This cannot ever happen because the CLR would pass in CORJIT_FLAG_SKIP_VERIFICATION.
}
case CORINFO_VERIFICATION_RUNTIME_CHECK:
// When the EE loads the System.Numerics.Vectors assembly, it asks the JIT what length (in bytes) of
// SIMD vector it supports as an intrinsic type. Zero means that the JIT does not support SIMD
// intrinsics, so the EE should use the default size (i.e. the size of the IL implementation).
+#if COR_JIT_EE_VERSION > 460
+ virtual unsigned getMaxIntrinsicSIMDVectorLength(CORJIT_FLAGS cpuCompileFlags) { return 0; }
+#else
virtual unsigned getMaxIntrinsicSIMDVectorLength(DWORD cpuCompileFlags) { return 0; }
+#endif
// IL obfuscators sometimes interpose on the EE-JIT interface. This function allows the VM to
// tell the JIT to use a particular ICorJitCompiler to implement the methods of this interface,
bool m_fNGenLastRetry; // This is retry of the compilation
- unsigned m_compilerFlags;
+ CORJIT_FLAGS m_compilerFlags;
bool m_legacyMode; // true if the zapper was invoked using legacy mode
#if defined(DEBUG)
,
(compiler->compCodeOpt() != Compiler::SMALL_CODE) &&
- !(compiler->opts.eeFlags & CORJIT_FLG_PREJIT)
+ !compiler->opts.jitFlags->IsSet(JitFlags::JIT_FLAG_PREJIT)
#endif
#ifdef LEGACY_BACKEND
,
assert(compiler->compGeneratingProlog);
#ifdef _TARGET_XARCH_
- if (!(compiler->opts.eeFlags & CORJIT_FLG_PROF_REJIT_NOPS))
+ if (!compiler->opts.jitFlags->IsSet(JitFlags::JIT_FLAG_PROF_REJIT_NOPS))
{
return;
}
// harmless "inc" instruction (does not interfere with the exception
// object).
- if ((compiler->opts.eeFlags & CORJIT_FLG_BBINSTR) && (stmt == block->bbTreeList) &&
+ if (compiler->opts.jitFlags->IsSet(JitFlags::JIT_FLAG_BBINSTR) && (stmt == block->bbTreeList) &&
(block->bbCatchTyp && handlerGetsXcptnObj(block->bbCatchTyp)))
{
nonVarPtrRegs &= ~RBM_EXCEPTION_OBJECT;
#if defined(_TARGET_X86_)
if (call->gtFlags & GTF_CALL_UNMANAGED)
{
- if ((compiler->opts.eeFlags & CORJIT_FLG_PINVOKE_RESTORE_ESP) ||
+ if (compiler->opts.jitFlags->IsSet(JitFlags::JIT_FLAG_PINVOKE_RESTORE_ESP) ||
compiler->compStressCompile(Compiler::STRESS_PINVOKE_RESTORE_ESP, 50))
{
// P/Invoke signature mismatch resilience - restore ESP to pre-call value. We would ideally
void Compiler::compSetProcessor()
{
- unsigned compileFlags = opts.eeFlags;
+ const JitFlags& jitFlags = *opts.jitFlags;
#if defined(_TARGET_ARM_)
info.genCPU = CPU_ARM;
#elif defined(_TARGET_AMD64_)
info.genCPU = CPU_X64;
#elif defined(_TARGET_X86_)
- if (compileFlags & CORJIT_FLG_TARGET_P4)
+ if (jitFlags.IsSet(JitFlags::JIT_FLAG_TARGET_P4))
info.genCPU = CPU_X86_PENTIUM_4;
else
info.genCPU = CPU_X86;
// COMPlus_EnableAVX can be used to disable using AVX if available on a target machine.
// Note that FEATURE_AVX_SUPPORT is not enabled for ctpjit
opts.compCanUseAVX = false;
- if (((compileFlags & CORJIT_FLG_PREJIT) == 0) && ((compileFlags & CORJIT_FLG_USE_AVX2) != 0))
+ if (!jitFlags.IsSet(JitFlags::JIT_FLAG_PREJIT) && jitFlags.IsSet(JitFlags::JIT_FLAG_USE_AVX2))
{
if (JitConfig.EnableAVX() != 0)
{
#endif //_TARGET_AMD64_
#ifdef _TARGET_X86_
- opts.compUseFCOMI = ((opts.eeFlags & CORJIT_FLG_USE_FCOMI) != 0);
- opts.compUseCMOV = ((opts.eeFlags & CORJIT_FLG_USE_CMOV) != 0);
- opts.compCanUseSSE2 = ((opts.eeFlags & CORJIT_FLG_USE_SSE2) != 0);
+ opts.compUseFCOMI = jitFlags.IsSet(JitFlags::JIT_FLAG_USE_FCOMI);
+ opts.compUseCMOV = jitFlags.IsSet(JitFlags::JIT_FLAG_USE_CMOV);
+ opts.compCanUseSSE2 = jitFlags.IsSet(JitFlags::JIT_FLAG_USE_SSE2);
#ifdef DEBUG
if (opts.compUseFCOMI)
return result;
}
-void Compiler::compInitOptions(CORJIT_FLAGS* jitFlags)
+void Compiler::compInitOptions(JitFlags* jitFlags)
{
#ifdef UNIX_AMD64_ABI
opts.compNeedToAlignFrame = false;
#endif // UNIX_AMD64_ABI
memset(&opts, 0, sizeof(opts));
- unsigned compileFlags = jitFlags->corJitFlags;
-
if (compIsForInlining())
{
- assert((compileFlags & CORJIT_FLG_LOST_WHEN_INLINING) == 0);
- assert(compileFlags & CORJIT_FLG_SKIP_VERIFICATION);
+ // The following flags are lost when inlining. (They are removed in
+ // Compiler::fgInvokeInlineeCompiler().)
+ assert(!jitFlags->IsSet(JitFlags::JIT_FLAG_BBOPT));
+ assert(!jitFlags->IsSet(JitFlags::JIT_FLAG_BBINSTR));
+ assert(!jitFlags->IsSet(JitFlags::JIT_FLAG_PROF_ENTERLEAVE));
+ assert(!jitFlags->IsSet(JitFlags::JIT_FLAG_DEBUG_EnC));
+ assert(!jitFlags->IsSet(JitFlags::JIT_FLAG_DEBUG_INFO));
+
+ assert(jitFlags->IsSet(JitFlags::JIT_FLAG_SKIP_VERIFICATION));
}
opts.jitFlags = jitFlags;
- opts.eeFlags = compileFlags;
opts.compFlags = CLFLG_MAXOPT; // Default value is for full optimization
- if (opts.eeFlags & (CORJIT_FLG_DEBUG_CODE | CORJIT_FLG_MIN_OPT))
+ if (jitFlags->IsSet(JitFlags::JIT_FLAG_DEBUG_CODE) || jitFlags->IsSet(JitFlags::JIT_FLAG_MIN_OPT))
{
opts.compFlags = CLFLG_MINOPT;
}
// Don't optimize .cctors (except prejit) or if we're an inlinee
- else if (!(opts.eeFlags & CORJIT_FLG_PREJIT) && ((info.compFlags & FLG_CCTOR) == FLG_CCTOR) && !compIsForInlining())
+ else if (!jitFlags->IsSet(JitFlags::JIT_FLAG_PREJIT) && ((info.compFlags & FLG_CCTOR) == FLG_CCTOR) &&
+ !compIsForInlining())
{
opts.compFlags = CLFLG_MINOPT;
}
// If the EE sets SIZE_OPT or if we are compiling a Class constructor
// we will optimize for code size at the expense of speed
//
- if ((opts.eeFlags & CORJIT_FLG_SIZE_OPT) || ((info.compFlags & FLG_CCTOR) == FLG_CCTOR))
+ if (jitFlags->IsSet(JitFlags::JIT_FLAG_SIZE_OPT) || ((info.compFlags & FLG_CCTOR) == FLG_CCTOR))
{
opts.compCodeOpt = SMALL_CODE;
}
//
// If the EE sets SPEED_OPT we will optimize for speed at the expense of code size
//
- else if (opts.eeFlags & CORJIT_FLG_SPEED_OPT)
+ else if (jitFlags->IsSet(JitFlags::JIT_FLAG_SPEED_OPT))
{
opts.compCodeOpt = FAST_CODE;
- assert((opts.eeFlags & CORJIT_FLG_SIZE_OPT) == 0);
+ assert(!jitFlags->IsSet(JitFlags::JIT_FLAG_SIZE_OPT));
}
//-------------------------------------------------------------------------
- opts.compDbgCode = (opts.eeFlags & CORJIT_FLG_DEBUG_CODE) != 0;
- opts.compDbgInfo = (opts.eeFlags & CORJIT_FLG_DEBUG_INFO) != 0;
- opts.compDbgEnC = (opts.eeFlags & CORJIT_FLG_DEBUG_EnC) != 0;
+ opts.compDbgCode = jitFlags->IsSet(JitFlags::JIT_FLAG_DEBUG_CODE);
+ opts.compDbgInfo = jitFlags->IsSet(JitFlags::JIT_FLAG_DEBUG_INFO);
+ opts.compDbgEnC = jitFlags->IsSet(JitFlags::JIT_FLAG_DEBUG_EnC);
+
#if REGEN_SHORTCUTS || REGEN_CALLPAT
// We never want to have debugging enabled when regenerating GC encoding patterns
opts.compDbgCode = false;
#ifdef DEBUG
const JitConfigValues::MethodSet* pfAltJit;
- if (opts.eeFlags & CORJIT_FLG_PREJIT)
+ if (jitFlags->IsSet(JitFlags::JIT_FLAG_PREJIT))
{
pfAltJit = &JitConfig.AltJitNgen();
}
#else // !DEBUG
const char* altJitVal;
- if (opts.eeFlags & CORJIT_FLG_PREJIT)
+ if (jitFlags->IsSet(JitFlags::JIT_FLAG_PREJIT))
{
altJitVal = JitConfig.AltJitNgen().list();
}
//
if (!compIsForInlining())
{
- if (opts.eeFlags & CORJIT_FLG_PREJIT)
+ if (jitFlags->IsSet(JitFlags::JIT_FLAG_PREJIT))
{
if (JitConfig.NgenDump().contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args))
{
#ifdef FEATURE_SIMD
#ifdef _TARGET_AMD64_
// Minimum bar for availing SIMD benefits is SSE2 on AMD64.
- featureSIMD = ((opts.eeFlags & CORJIT_FLG_FEATURE_SIMD) != 0);
+ featureSIMD = jitFlags->IsSet(JitFlags::JIT_FLAG_FEATURE_SIMD);
#endif // _TARGET_AMD64_
#endif // FEATURE_SIMD
//
if (!altJitConfig || opts.altJit)
{
- if (opts.eeFlags & CORJIT_FLG_PREJIT)
+ if (jitFlags->IsSet(JitFlags::JIT_FLAG_PREJIT))
{
if ((JitConfig.NgenOrder() & 1) == 1)
{
#endif
#ifdef PROFILING_SUPPORTED
- opts.compNoPInvokeInlineCB = (opts.eeFlags & CORJIT_FLG_PROF_NO_PINVOKE_INLINE) ? true : false;
+ opts.compNoPInvokeInlineCB = jitFlags->IsSet(JitFlags::JIT_FLAG_PROF_NO_PINVOKE_INLINE);
// Cache the profiler handle
- if (opts.eeFlags & CORJIT_FLG_PROF_ENTERLEAVE)
+ if (jitFlags->IsSet(JitFlags::JIT_FLAG_PROF_ENTERLEAVE))
{
BOOL hookNeeded;
BOOL indirected;
}
#endif
- opts.compMustInlinePInvokeCalli = (opts.eeFlags & CORJIT_FLG_IL_STUB) ? true : false;
+ opts.compMustInlinePInvokeCalli = jitFlags->IsSet(JitFlags::JIT_FLAG_IL_STUB);
opts.compScopeInfo = opts.compDbgInfo;
//-------------------------------------------------------------------------
#if RELOC_SUPPORT
- opts.compReloc = (opts.eeFlags & CORJIT_FLG_RELOC) ? true : false;
+ opts.compReloc = jitFlags->IsSet(JitFlags::JIT_FLAG_RELOC);
#endif
#ifdef DEBUG
#endif
#endif // DEBUG
- opts.compProcedureSplitting = (opts.eeFlags & CORJIT_FLG_PROCSPLIT) ? true : false;
+ opts.compProcedureSplitting = jitFlags->IsSet(JitFlags::JIT_FLAG_PROCSPLIT);
#ifdef _TARGET_ARM64_
// TODO-ARM64-NYI: enable hot/cold splitting
fgProfileBuffer = nullptr;
fgProfileData_ILSizeMismatch = false;
fgNumProfileRuns = 0;
- if (opts.eeFlags & CORJIT_FLG_BBOPT)
+ if (jitFlags->IsSet(JitFlags::JIT_FLAG_BBOPT))
{
assert(!compIsForInlining());
HRESULT hr;
printf("OPTIONS: compProcedureSplitting = %s\n", dspBool(opts.compProcedureSplitting));
printf("OPTIONS: compProcedureSplittingEH = %s\n", dspBool(opts.compProcedureSplittingEH));
- if ((opts.eeFlags & CORJIT_FLG_BBOPT) && fgHaveProfileData())
+ if (jitFlags->IsSet(JitFlags::JIT_FLAG_BBOPT) && fgHaveProfileData())
{
printf("OPTIONS: using real profile data\n");
}
printf("OPTIONS: discarded IBC profile data due to mismatch in ILSize\n");
}
- if (opts.eeFlags & CORJIT_FLG_PREJIT)
+ if (jitFlags->IsSet(JitFlags::JIT_FLAG_PREJIT))
{
printf("OPTIONS: Jit invoked for ngen\n");
}
#endif
opts.compGCPollType = GCPOLL_NONE;
- if (opts.eeFlags & CORJIT_FLG_GCPOLL_CALLS)
+ if (jitFlags->IsSet(JitFlags::JIT_FLAG_GCPOLL_CALLS))
{
opts.compGCPollType = GCPOLL_CALL;
}
- else if (opts.eeFlags & CORJIT_FLG_GCPOLL_INLINE)
+ else if (jitFlags->IsSet(JitFlags::JIT_FLAG_GCPOLL_INLINE))
{
// make sure that the EE didn't set both flags.
assert(opts.compGCPollType == GCPOLL_NONE);
void Compiler::compSetOptimizationLevel()
{
- unsigned compileFlags;
bool theMinOptsValue;
unsigned jitMinOpts;
- compileFlags = opts.eeFlags;
-
if (compIsForInlining())
{
theMinOptsValue = impInlineInfo->InlinerCompiler->opts.MinOpts();
}
// For PREJIT we never drop down to MinOpts
// unless unless CLFLG_MINOPT is set
- else if (!(compileFlags & CORJIT_FLG_PREJIT))
+ else if (!opts.jitFlags->IsSet(JitFlags::JIT_FLAG_PREJIT))
{
if ((unsigned)JitConfig.JitMinOptsCodeSize() < info.compILCodeSize)
{
// Retail check if we should force Minopts due to the complexity of the method
// For PREJIT we never drop down to MinOpts
// unless unless CLFLG_MINOPT is set
- if (!theMinOptsValue && !(compileFlags & CORJIT_FLG_PREJIT) &&
+ if (!theMinOptsValue && !opts.jitFlags->IsSet(JitFlags::JIT_FLAG_PREJIT) &&
((DEFAULT_MIN_OPTS_CODE_SIZE < info.compILCodeSize) || (DEFAULT_MIN_OPTS_INSTR_COUNT < opts.instrCount) ||
(DEFAULT_MIN_OPTS_BB_COUNT < fgBBcount) || (DEFAULT_MIN_OPTS_LV_NUM_COUNT < lvaCount) ||
(DEFAULT_MIN_OPTS_LV_REF_COUNT < opts.lvRefCount)))
}
#if !defined(_TARGET_AMD64_)
- // The VM sets CORJIT_FLG_FRAMED for two reasons: (1) the COMPlus_JitFramed variable is set, or
+ // The VM sets JitFlags::JIT_FLAG_FRAMED for two reasons: (1) the COMPlus_JitFramed variable is set, or
// (2) the function is marked "noinline". The reason for #2 is that people mark functions
// noinline to ensure the show up on in a stack walk. But for AMD64, we don't need a frame
// pointer for the frame to show up in stack walk.
- if (compileFlags & CORJIT_FLG_FRAMED)
+ if (opts.jitFlags->IsSet(JitFlags::JIT_FLAG_FRAMED))
codeGen->setFrameRequired(true);
#endif
- if (compileFlags & CORJIT_FLG_RELOC)
+ if (opts.jitFlags->IsSet(JitFlags::JIT_FLAG_RELOC))
{
codeGen->genAlignLoops = false; // loop alignment not supported for prejitted code
- // The zapper doesn't set CORJIT_FLG_ALIGN_LOOPS, and there is
+ // The zapper doesn't set JitFlags::JIT_FLAG_ALIGN_LOOPS, and there is
// no reason for it to set it as the JIT doesn't currently support loop alignment
// for prejitted images. (The JIT doesn't know the final address of the code, hence
// it can't align code based on unknown addresses.)
- assert((compileFlags & CORJIT_FLG_ALIGN_LOOPS) == 0);
+ assert(!opts.jitFlags->IsSet(JitFlags::JIT_FLAG_ALIGN_LOOPS));
}
else
{
- codeGen->genAlignLoops = (compileFlags & CORJIT_FLG_ALIGN_LOOPS) != 0;
+ codeGen->genAlignLoops = opts.jitFlags->IsSet(JitFlags::JIT_FLAG_ALIGN_LOOPS);
}
}
// For an overview of the structure of the JIT, see:
// https://github.com/dotnet/coreclr/blob/master/Documentation/botr/ryujit-overview.md
//
-void Compiler::compCompile(void** methodCodePtr, ULONG* methodCodeSize, CORJIT_FLAGS* compileFlags)
+void Compiler::compCompile(void** methodCodePtr, ULONG* methodCodeSize, JitFlags* compileFlags)
{
if (compIsForInlining())
{
fgRemoveEH();
#endif // !FEATURE_EH
- if (compileFlags->corJitFlags & CORJIT_FLG_BBINSTR)
+ if (compileFlags->IsSet(JitFlags::JIT_FLAG_BBINSTR))
{
fgInstrumentMethod();
}
CORINFO_METHOD_INFO* methodInfo,
void** methodCodePtr,
ULONG* methodCodeSize,
- CORJIT_FLAGS* compileFlags)
+ JitFlags* compileFlags)
{
#ifdef FEATURE_JIT_METHOD_PERF
static bool checkedForJitTimeLog = false;
// Set this before the first 'BADCODE'
// Skip verification where possible
- tiVerificationNeeded = (compileFlags->corJitFlags & CORJIT_FLG_SKIP_VERIFICATION) == 0;
+ tiVerificationNeeded = !compileFlags->IsSet(JitFlags::JIT_FLAG_SKIP_VERIFICATION);
assert(!compIsForInlining() || !tiVerificationNeeded); // Inlinees must have been verified.
case CORINFO_VERIFICATION_CAN_SKIP:
// The VM should first verify the open instantiation. If unverifiable code
- // is detected, it should pass in CORJIT_FLG_SKIP_VERIFICATION.
- assert(!"The VM should have used CORJIT_FLG_SKIP_VERIFICATION");
+ // is detected, it should pass in JitFlags::JIT_FLAG_SKIP_VERIFICATION.
+ assert(!"The VM should have used JitFlags::JIT_FLAG_SKIP_VERIFICATION");
tiVerificationNeeded = false;
break;
CORINFO_METHOD_INFO* methodInfo;
void** methodCodePtr;
ULONG* methodCodeSize;
- CORJIT_FLAGS* compileFlags;
+ JitFlags* compileFlags;
CorInfoInstantiationVerification instVerInfo;
int result;
mdMethodDef currentMethodToken = info.compCompHnd->getMethodDefFromMethod(info.compMethodHnd);
unsigned profCallCount = 0;
- if (((opts.eeFlags & CORJIT_FLG_BBOPT) != 0) && fgHaveProfileData())
+ if (opts.jitFlags->IsSet(JitFlags::JIT_FLAG_BBOPT) && fgHaveProfileData())
{
assert(fgProfileBuffer[0].ILOffset == 0);
profCallCount = fgProfileBuffer[0].ExecutionCount;
// For ngen the int3 or breakpoint instruction will be right at the
// start of the ngen method and we will stop when we execute it.
//
- if ((opts.eeFlags & CORJIT_FLG_PREJIT) == 0)
+ if (!opts.jitFlags->IsSet(JitFlags::JIT_FLAG_PREJIT))
{
if (compJitHaltMethod())
{
CORINFO_METHOD_INFO* methodInfo,
void** methodCodePtr,
ULONG* methodCodeSize,
- CORJIT_FLAGS* compileFlags,
+ JitFlags* compileFlags,
CorInfoInstantiationVerification instVerInfo)
{
CORINFO_METHOD_HANDLE methodHnd = info.compMethodHnd;
info.compIsContextful = (info.compClassAttr & CORINFO_FLG_CONTEXTFUL) != 0;
- info.compPublishStubParam = (opts.eeFlags & CORJIT_FLG_PUBLISH_SECRET_PARAM) != 0;
+ info.compPublishStubParam = opts.jitFlags->IsSet(JitFlags::JIT_FLAG_PUBLISH_SECRET_PARAM);
switch (methodInfo->args.getCallConv())
{
const bool forceInline = !!(info.compFlags & CORINFO_FLG_FORCEINLINE);
- if (!compIsForInlining() && (opts.eeFlags & CORJIT_FLG_PREJIT))
+ if (!compIsForInlining() && opts.jitFlags->IsSet(JitFlags::JIT_FLAG_PREJIT))
{
// We're prejitting the root method. We also will analyze it as
// a potential inline candidate.
CORINFO_METHOD_INFO* methodInfo,
void** methodCodePtr,
ULONG* methodCodeSize,
- CORJIT_FLAGS* compileFlags,
+ JitFlags* compileFlags,
void* inlineInfoPtr)
{
//
CORINFO_METHOD_INFO* methodInfo;
void** methodCodePtr;
ULONG* methodCodeSize;
- CORJIT_FLAGS* compileFlags;
+ JitFlags* compileFlags;
InlineInfo* inlineInfo;
#if MEASURE_CLRAPI_CALLS
WrapICorJitInfo* wrapCLR;
jitFallbackCompile = true;
// Update the flags for 'safer' code generation.
- compileFlags->corJitFlags |= CORJIT_FLG_MIN_OPT;
- compileFlags->corJitFlags &= ~(CORJIT_FLG_SIZE_OPT | CORJIT_FLG_SPEED_OPT);
+ compileFlags->Set(JitFlags::JIT_FLAG_MIN_OPT);
+ compileFlags->Clear(JitFlags::JIT_FLAG_SIZE_OPT);
+ compileFlags->Clear(JitFlags::JIT_FLAG_SPEED_OPT);
goto START;
}
struct Options
{
- CORJIT_FLAGS* jitFlags; // all flags passed from the EE
- unsigned eeFlags; // CorJitFlag flags passed from the EE
- unsigned compFlags; // method attributes
+ JitFlags* jitFlags; // all flags passed from the EE
+ unsigned compFlags; // method attributes
codeOptimize compCodeOpt; // what type of code optimizations
#ifdef FEATURE_READYTORUN_COMPILER
inline bool IsReadyToRun()
{
- return (eeFlags & CORJIT_FLG_READYTORUN) != 0;
+ return jitFlags->IsSet(JitFlags::JIT_FLAG_READYTORUN);
}
#else
inline bool IsReadyToRun()
inline bool ShouldUsePInvokeHelpers()
{
#if COR_JIT_EE_VERSION > 460
- return (jitFlags->corJitFlags2 & CORJIT_FLG2_USE_PINVOKE_HELPERS) != 0;
+ return jitFlags->IsSet(JitFlags::JIT_FLAG_USE_PINVOKE_HELPERS);
#else
return false;
#endif
inline bool IsReversePInvoke()
{
#if COR_JIT_EE_VERSION > 460
- return (jitFlags->corJitFlags2 & CORJIT_FLG2_REVERSE_PINVOKE) != 0;
+ return jitFlags->IsSet(JitFlags::JIT_FLAG_REVERSE_PINVOKE);
#else
return false;
#endif
inline bool IsJit32Compat()
{
#if defined(_TARGET_X86_) && COR_JIT_EE_VERSION > 460
- return (jitFlags->corJitFlags2 & CORJIT_FLG2_DESKTOP_QUIRKS) != 0;
+ return jitFlags->IsSet(JitFlags::JIT_FLAG_DESKTOP_QUIRKS);
#else
return false;
#endif
inline bool IsJit64Compat()
{
#if defined(_TARGET_AMD64_) && COR_JIT_EE_VERSION > 460
- return (jitFlags->corJitFlags2 & CORJIT_FLG2_DESKTOP_QUIRKS) != 0;
+ return jitFlags->IsSet(JitFlags::JIT_FLAG_DESKTOP_QUIRKS);
#elif defined(_TARGET_AMD64_) && !defined(FEATURE_CORECLR)
return true;
#else
CORINFO_METHOD_INFO* methodInfo,
void** methodCodePtr,
ULONG* methodCodeSize,
- CORJIT_FLAGS* compileFlags);
+ JitFlags* compileFlags);
void compCompileFinish();
int compCompileHelper(CORINFO_MODULE_HANDLE classPtr,
COMP_HANDLE compHnd,
CORINFO_METHOD_INFO* methodInfo,
void** methodCodePtr,
ULONG* methodCodeSize,
- CORJIT_FLAGS* compileFlags,
+ JitFlags* compileFlags,
CorInfoInstantiationVerification instVerInfo);
ArenaAllocator* compGetAllocator();
protected:
size_t compMaxUncheckedOffsetForNullObject;
- void compInitOptions(CORJIT_FLAGS* compileFlags);
+ void compInitOptions(JitFlags* compileFlags);
void compSetProcessor();
void compInitDebuggingInfo();
#ifdef _TARGET_ARMARCH_
bool compRsvdRegCheck(FrameLayoutState curState);
#endif
- void compCompile(void** methodCodePtr, ULONG* methodCodeSize, CORJIT_FLAGS* compileFlags);
+ void compCompile(void** methodCodePtr, ULONG* methodCodeSize, JitFlags* compileFlags);
#ifdef PROFILING_SUPPORTED
// Data required for generating profiler Enter/Leave/TailCall hooks
return compProfilerHookNeeded
// IL stubs are excluded by VM and we need to do the same even running
// under a complus env hook to generate profiler hooks
- || (opts.compJitELTHookEnabled && !(opts.eeFlags & CORJIT_FLG_IL_STUB));
+ || (opts.compJitELTHookEnabled && !opts.jitFlags->IsSet(JitFlags::JIT_FLAG_IL_STUB));
#else // !PROFILING_SUPPORTED
return false;
#endif // !PROFILING_SUPPORTED
inline bool Compiler::compIsForImportOnly()
{
- return ((opts.eeFlags & CORJIT_FLG_IMPORT_ONLY) != 0);
+ return opts.jitFlags->IsSet(JitFlags::JIT_FLAG_IMPORT_ONLY);
}
/*****************************************************************************
return g_realJitCompiler->compileMethod(compHnd, methodInfo, flags, entryAddress, nativeSizeOfCode);
}
- CORJIT_FLAGS jitFlags = {0};
+ JitFlags jitFlags;
- DWORD jitFlagsSize = 0;
#if COR_JIT_EE_VERSION > 460
- if (flags == CORJIT_FLG_CALL_GETJITFLAGS)
- {
- jitFlagsSize = compHnd->getJitFlags(&jitFlags, sizeof(jitFlags));
- }
-#endif
-
- assert(jitFlagsSize <= sizeof(jitFlags));
- if (jitFlagsSize == 0)
- {
- jitFlags.corJitFlags = flags;
- }
+ assert(flags == CORJIT_FLAGS::CORJIT_FLAG_CALL_GETJITFLAGS);
+ CORJIT_FLAGS corJitFlags;
+ DWORD jitFlagsSize = compHnd->getJitFlags(&corJitFlags, sizeof(corJitFlags));
+ assert(jitFlagsSize == sizeof(corJitFlags));
+ jitFlags.SetFromFlags(corJitFlags);
+#else // COR_JIT_EE_VERSION <= 460
+ jitFlags.SetFromOldFlags(flags, 0);
+#endif // COR_JIT_EE_VERSION <= 460
int result;
void* methodCodePtr = nullptr;
/*****************************************************************************
* Determine the maximum length of SIMD vector supported by this JIT.
*/
+
+#if COR_JIT_EE_VERSION > 460
+unsigned CILJit::getMaxIntrinsicSIMDVectorLength(CORJIT_FLAGS cpuCompileFlags)
+#else
unsigned CILJit::getMaxIntrinsicSIMDVectorLength(DWORD cpuCompileFlags)
+#endif
{
if (g_realJitCompiler != nullptr)
{
return g_realJitCompiler->getMaxIntrinsicSIMDVectorLength(cpuCompileFlags);
}
+ JitFlags jitFlags;
+
+#if COR_JIT_EE_VERSION > 460
+ jitFlags.SetFromFlags(cpuCompileFlags);
+#else // COR_JIT_EE_VERSION <= 460
+ jitFlags.SetFromOldFlags(cpuCompileFlags, 0);
+#endif // COR_JIT_EE_VERSION <= 460
+
#ifdef _TARGET_AMD64_
#ifdef FEATURE_AVX_SUPPORT
- if (((cpuCompileFlags & CORJIT_FLG_PREJIT) == 0) && ((cpuCompileFlags & CORJIT_FLG_FEATURE_SIMD) != 0) &&
- ((cpuCompileFlags & CORJIT_FLG_USE_AVX2) != 0))
+ if (!jitFlags.IsSet(JitFlags::JIT_FLAG_PREJIT) && jitFlags.IsSet(JitFlags::JIT_FLAG_FEATURE_SIMD) &&
+ jitFlags.IsSet(JitFlags::JIT_FLAG_USE_AVX2))
{
if (JitConfig.EnableAVX() != 0)
{
void getVersionIdentifier(GUID* versionIdentifier /* OUT */
);
+#if COR_JIT_EE_VERSION > 460
+ unsigned getMaxIntrinsicSIMDVectorLength(CORJIT_FLAGS cpuCompileFlags);
+#else
unsigned getMaxIntrinsicSIMDVectorLength(DWORD cpuCompileFlags);
+#endif
void setRealJit(ICorJitCompiler* realJitCompiler);
};
// ARM - This is currently broken on _TARGET_ARM_
// When nopSize is odd we misalign emitCurIGsize
//
- if (!(emitComp->opts.eeFlags & CORJIT_FLG_PREJIT) && !emitInInstrumentation &&
- !emitIGisInProlog(emitCurIG) // don't do this in prolog or epilog
- && !emitIGisInEpilog(emitCurIG) &&
+ if (!emitComp->opts.jitFlags->IsSet(JitFlags::JIT_FLAG_PREJIT) && !emitInInstrumentation &&
+ !emitIGisInProlog(emitCurIG) && // don't do this in prolog or epilog
+ !emitIGisInEpilog(emitCurIG) &&
emitRandomNops // sometimes we turn off where exact codegen is needed (pinvoke inline)
)
{
impImport(fgFirstBB);
- if (!(opts.eeFlags & CORJIT_FLG_SKIP_VERIFICATION))
+ if (!opts.jitFlags->IsSet(JitFlags::JIT_FLAG_SKIP_VERIFICATION))
{
CorInfoMethodRuntimeFlags verFlag;
verFlag = tiIsVerifiableCode ? CORINFO_FLG_VERIFIABLE : CORINFO_FLG_UNVERIFIABLE;
CORINFO_JUST_MY_CODE_HANDLE* pDbgHandle = nullptr;
CORINFO_JUST_MY_CODE_HANDLE dbgHandle = nullptr;
- if (opts.compDbgCode && !(opts.eeFlags & CORJIT_FLG_IL_STUB))
+ if (opts.compDbgCode && !opts.jitFlags->IsSet(JitFlags::JIT_FLAG_IL_STUB))
{
dbgHandle = info.compCompHnd->getJustMyCodeHandle(info.compMethodHnd, &pDbgHandle);
}
// we are willing to have more code expansion since we
// won't be running code from this page
//
- if (opts.eeFlags & CORJIT_FLG_PREJIT)
+ if (opts.jitFlags->IsSet(JitFlags::JIT_FLAG_PREJIT))
{
if (rareJump)
{
bool createDuplicateFgxFiles = true;
#ifdef DEBUG
- if (opts.eeFlags & CORJIT_FLG_PREJIT)
+ if (opts.jitFlags->IsSet(JitFlags::JIT_FLAG_PREJIT))
{
pattern = JitConfig.NgenDumpFg();
filename = JitConfig.NgenDumpFgFile();
pParam->pThis->eeGetMethodFullName(pParam->fncHandle),
pParam->pThis->dspPtr(pParam->inlineInfo->tokenLookupContextHandle)));
- CORJIT_FLAGS compileFlagsForInlinee;
- memcpy(&compileFlagsForInlinee, pParam->pThis->opts.jitFlags, sizeof(compileFlagsForInlinee));
- compileFlagsForInlinee.corJitFlags &= ~CORJIT_FLG_LOST_WHEN_INLINING;
- compileFlagsForInlinee.corJitFlags |= CORJIT_FLG_SKIP_VERIFICATION;
+ JitFlags compileFlagsForInlinee = *pParam->pThis->opts.jitFlags;
+
+ // The following flags are lost when inlining.
+ // (This is checked in Compiler::compInitOptions().)
+ compileFlagsForInlinee.Clear(JitFlags::JIT_FLAG_BBOPT);
+ compileFlagsForInlinee.Clear(JitFlags::JIT_FLAG_BBINSTR);
+ compileFlagsForInlinee.Clear(JitFlags::JIT_FLAG_PROF_ENTERLEAVE);
+ compileFlagsForInlinee.Clear(JitFlags::JIT_FLAG_DEBUG_EnC);
+ compileFlagsForInlinee.Clear(JitFlags::JIT_FLAG_DEBUG_INFO);
+
+ compileFlagsForInlinee.Set(JitFlags::JIT_FLAG_SKIP_VERIFICATION);
#ifdef DEBUG
if (pParam->pThis->verbose)
costSz += 2;
}
}
- else if ((opts.eeFlags & CORJIT_FLG_PREJIT) == 0)
+ else if (!opts.jitFlags->IsSet(JitFlags::JIT_FLAG_PREJIT))
{
costEx += 2;
costSz += 6;
#endif // DEBUG
// Add the non verifiable flag to the compiler
- if ((opts.eeFlags & CORJIT_FLG_IMPORT_ONLY) != 0)
+ if (opts.jitFlags->IsSet(JitFlags::JIT_FLAG_IMPORT_ONLY))
{
tiIsVerifiableCode = FALSE;
}
// coupled with the JIT64 IL Verification logic. Look inside verHandleVerificationFailure
// method for further explanation on why we raise this exception instead of making the jitted
// code throw the verification exception during execution.
- if (tiVerificationNeeded && (opts.eeFlags & CORJIT_FLG_IMPORT_ONLY) != 0)
+ if (tiVerificationNeeded && opts.jitFlags->IsSet(JitFlags::JIT_FLAG_IMPORT_ONLY))
{
BADCODE("Basic block marked as not verifiable");
}
// successful policy, so fake one up.
if (m_LastSuccessfulPolicy == nullptr)
{
- const bool isPrejitRoot = (opts.eeFlags & CORJIT_FLG_PREJIT) != 0;
+ const bool isPrejitRoot = opts.jitFlags->IsSet(JitFlags::JIT_FLAG_PREJIT);
m_LastSuccessfulPolicy = InlinePolicy::GetPolicy(m_Compiler, isPrejitRoot);
// Add in a bit of data....
const Compiler::Info& info = m_Compiler->info;
const Compiler::Options& opts = m_Compiler->opts;
- const bool isPrejitRoot = (opts.eeFlags & CORJIT_FLG_PREJIT) != 0;
+ const bool isPrejitRoot = opts.jitFlags->IsSet(JitFlags::JIT_FLAG_PREJIT);
const bool isForceInline = (info.compFlags & CORINFO_FLG_FORCEINLINE) != 0;
// We'd really like the method identifier to be unique and
const unsigned int MAX_INL_LCLS = 8;
#endif // LEGACY_BACKEND
-// Flags lost during inlining.
-
-#define CORJIT_FLG_LOST_WHEN_INLINING \
- (CORJIT_FLG_BBOPT | CORJIT_FLG_BBINSTR | CORJIT_FLG_PROF_ENTERLEAVE | CORJIT_FLG_DEBUG_EnC | CORJIT_FLG_DEBUG_INFO)
-
// Forward declarations
class InlineStrategy;
return
// If we are running the altjit for NGEN, then assume we can use the "BL" instruction.
// This matches the usual behavior for NGEN, since we normally do generate "BL".
- (!compiler->info.compMatchedVM && (compiler->opts.eeFlags & CORJIT_FLG_PREJIT)) ||
+ (!compiler->info.compMatchedVM && compiler->opts.jitFlags->IsSet(JitFlags::JIT_FLAG_PREJIT)) ||
(compiler->eeGetRelocTypeHint((void*)addr) == IMAGE_REL_BASED_THUMB_BRANCH24);
}
bool CodeGen::arm_Valid_Imm_For_BL(ssize_t addr)
#include "corhdr.h"
#include "corjit.h"
+#include "jitee.h"
#define __OPERATOR_NEW_INLINE 1 // indicate that I will define these
#define __PLACEMENT_NEW_INLINE // don't bring in the global placement new, it is easy to make a mistake
CORINFO_METHOD_INFO* methodInfo,
void** methodCodePtr,
ULONG* methodCodeSize,
- CORJIT_FLAGS* compileFlags,
+ JitFlags* compileFlags,
void* inlineInfoPtr);
#ifdef _HOST_64BIT_
--- /dev/null
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+// This class wraps the CORJIT_FLAGS type in the JIT-EE interface (in corjit.h) such that the JIT can
+// build with either the old flags (COR_JIT_EE_VERSION <= 460) or the new flags (COR_JIT_EE_VERSION > 460).
+// It actually is exactly the same as the new definition, and must be kept up-to-date with the new definition.
+// When built against an old JIT-EE interface, the old flags are converted into this structure.
+class JitFlags
+{
+public:
+ // clang-format off
+ enum JitFlag
+ {
+ JIT_FLAG_SPEED_OPT = 0,
+ JIT_FLAG_SIZE_OPT = 1,
+ JIT_FLAG_DEBUG_CODE = 2, // generate "debuggable" code (no code-mangling optimizations)
+ JIT_FLAG_DEBUG_EnC = 3, // We are in Edit-n-Continue mode
+ JIT_FLAG_DEBUG_INFO = 4, // generate line and local-var info
+ JIT_FLAG_MIN_OPT = 5, // disable all jit optimizations (not necesarily debuggable code)
+ JIT_FLAG_GCPOLL_CALLS = 6, // Emit calls to JIT_POLLGC for thread suspension.
+ JIT_FLAG_MCJIT_BACKGROUND = 7, // Calling from multicore JIT background thread, do not call JitComplete
+
+ #if defined(_TARGET_X86_)
+
+ JIT_FLAG_PINVOKE_RESTORE_ESP = 8, // Restore ESP after returning from inlined PInvoke
+ JIT_FLAG_TARGET_P4 = 9,
+ JIT_FLAG_USE_FCOMI = 10, // Generated code may use fcomi(p) instruction
+ JIT_FLAG_USE_CMOV = 11, // Generated code may use cmov instruction
+ JIT_FLAG_USE_SSE2 = 12, // Generated code may use SSE-2 instructions
+
+ #else // !defined(_TARGET_X86_)
+
+ JIT_FLAG_UNUSED1 = 8,
+ JIT_FLAG_UNUSED2 = 9,
+ JIT_FLAG_UNUSED3 = 10,
+ JIT_FLAG_UNUSED4 = 11,
+ JIT_FLAG_UNUSED5 = 12,
+
+ #endif // !defined(_TARGET_X86_)
+
+ #if defined(_TARGET_X86_) || defined(_TARGET_AMD64_)
+
+ JIT_FLAG_USE_SSE3_4 = 13,
+ JIT_FLAG_USE_AVX = 14,
+ JIT_FLAG_USE_AVX2 = 15,
+ JIT_FLAG_USE_AVX_512 = 16,
+ JIT_FLAG_FEATURE_SIMD = 17,
+
+ #else // !defined(_TARGET_X86_) && !defined(_TARGET_AMD64_)
+
+ JIT_FLAG_UNUSED6 = 13,
+ JIT_FLAG_UNUSED7 = 14,
+ JIT_FLAG_UNUSED8 = 15,
+ JIT_FLAG_UNUSED9 = 16,
+ JIT_FLAG_UNUSED10 = 17,
+
+ #endif // !defined(_TARGET_X86_) && !defined(_TARGET_AMD64_)
+
+ JIT_FLAG_MAKEFINALCODE = 18, // Use the final code generator, i.e., not the interpreter.
+ JIT_FLAG_READYTORUN = 19, // Use version-resilient code generation
+ JIT_FLAG_PROF_ENTERLEAVE = 20, // Instrument prologues/epilogues
+ JIT_FLAG_PROF_REJIT_NOPS = 21, // Insert NOPs to ensure code is re-jitable
+ JIT_FLAG_PROF_NO_PINVOKE_INLINE = 22, // Disables PInvoke inlining
+ JIT_FLAG_SKIP_VERIFICATION = 23, // (lazy) skip verification - determined without doing a full resolve. See comment below
+ JIT_FLAG_PREJIT = 24, // jit or prejit is the execution engine.
+ JIT_FLAG_RELOC = 25, // Generate relocatable code
+ JIT_FLAG_IMPORT_ONLY = 26, // Only import the function
+ JIT_FLAG_IL_STUB = 27, // method is an IL stub
+ JIT_FLAG_PROCSPLIT = 28, // JIT should separate code into hot and cold sections
+ JIT_FLAG_BBINSTR = 29, // Collect basic block profile information
+ JIT_FLAG_BBOPT = 30, // Optimize method based on profile information
+ JIT_FLAG_FRAMED = 31, // All methods have an EBP frame
+ JIT_FLAG_ALIGN_LOOPS = 32, // add NOPs before loops to align them at 16 byte boundaries
+ JIT_FLAG_PUBLISH_SECRET_PARAM = 33, // JIT must place stub secret param into local 0. (used by IL stubs)
+ JIT_FLAG_GCPOLL_INLINE = 34, // JIT must inline calls to GCPoll when possible
+ JIT_FLAG_SAMPLING_JIT_BACKGROUND = 35, // JIT is being invoked as a result of stack sampling for hot methods in the background
+ JIT_FLAG_USE_PINVOKE_HELPERS = 36, // The JIT should use the PINVOKE_{BEGIN,END} helpers instead of emitting inline transitions
+ JIT_FLAG_REVERSE_PINVOKE = 37, // The JIT should insert REVERSE_PINVOKE_{ENTER,EXIT} helpers into method prolog/epilog
+ JIT_FLAG_DESKTOP_QUIRKS = 38, // The JIT should generate desktop-quirk-compatible code
+ };
+ // clang-format on
+
+ JitFlags() : m_jitFlags(0)
+ {
+ // empty
+ }
+
+ // Convenience constructor to set exactly one flags.
+ JitFlags(JitFlag flag) : m_jitFlags(0)
+ {
+ Set(flag);
+ }
+
+ void Reset()
+ {
+ m_jitFlags = 0;
+ }
+
+ void Set(JitFlag flag)
+ {
+ m_jitFlags |= 1ULL << (unsigned __int64)flag;
+ }
+
+ void Clear(JitFlag flag)
+ {
+ m_jitFlags &= ~(1ULL << (unsigned __int64)flag);
+ }
+
+ bool IsSet(JitFlag flag) const
+ {
+ return (m_jitFlags & (1ULL << (unsigned __int64)flag)) != 0;
+ }
+
+ void Add(const JitFlags& other)
+ {
+ m_jitFlags |= other.m_jitFlags;
+ }
+
+ void Remove(const JitFlags& other)
+ {
+ m_jitFlags &= ~other.m_jitFlags;
+ }
+
+ bool IsEmpty() const
+ {
+ return m_jitFlags == 0;
+ }
+
+#if COR_JIT_EE_VERSION <= 460
+
+ void SetFromOldFlags(unsigned corJitFlags, unsigned corJitFlags2)
+ {
+ Reset();
+
+#define CONVERT_OLD_FLAG(oldf, newf) \
+ if ((corJitFlags & (oldf)) != 0) \
+ this->Set(JitFlags::newf);
+#define CONVERT_OLD_FLAG2(oldf, newf) \
+ if ((corJitFlags & (oldf)) != 0) \
+ this->Set(JitFlags::newf);
+
+ CONVERT_OLD_FLAG(CORJIT_FLG_SPEED_OPT, JIT_FLAG_SPEED_OPT)
+ CONVERT_OLD_FLAG(CORJIT_FLG_SIZE_OPT, JIT_FLAG_SIZE_OPT)
+ CONVERT_OLD_FLAG(CORJIT_FLG_DEBUG_CODE, JIT_FLAG_DEBUG_CODE)
+ CONVERT_OLD_FLAG(CORJIT_FLG_DEBUG_EnC, JIT_FLAG_DEBUG_EnC)
+ CONVERT_OLD_FLAG(CORJIT_FLG_DEBUG_INFO, JIT_FLAG_DEBUG_INFO)
+ CONVERT_OLD_FLAG(CORJIT_FLG_MIN_OPT, JIT_FLAG_MIN_OPT)
+ CONVERT_OLD_FLAG(CORJIT_FLG_GCPOLL_CALLS, JIT_FLAG_GCPOLL_CALLS)
+ CONVERT_OLD_FLAG(CORJIT_FLG_MCJIT_BACKGROUND, JIT_FLAG_MCJIT_BACKGROUND)
+
+#if defined(_TARGET_X86_)
+
+ CONVERT_OLD_FLAG(CORJIT_FLG_PINVOKE_RESTORE_ESP, JIT_FLAG_PINVOKE_RESTORE_ESP)
+ CONVERT_OLD_FLAG(CORJIT_FLG_TARGET_P4, JIT_FLAG_TARGET_P4)
+ CONVERT_OLD_FLAG(CORJIT_FLG_USE_FCOMI, JIT_FLAG_USE_FCOMI)
+ CONVERT_OLD_FLAG(CORJIT_FLG_USE_CMOV, JIT_FLAG_USE_CMOV)
+ CONVERT_OLD_FLAG(CORJIT_FLG_USE_SSE2, JIT_FLAG_USE_SSE2)
+
+#elif defined(_TARGET_AMD64_)
+
+ CONVERT_OLD_FLAG(CORJIT_FLG_USE_SSE3_4, JIT_FLAG_USE_SSE3_4)
+ CONVERT_OLD_FLAG(CORJIT_FLG_USE_AVX, JIT_FLAG_USE_AVX)
+ CONVERT_OLD_FLAG(CORJIT_FLG_USE_AVX2, JIT_FLAG_USE_AVX2)
+ CONVERT_OLD_FLAG(CORJIT_FLG_USE_AVX_512, JIT_FLAG_USE_AVX_512)
+ CONVERT_OLD_FLAG(CORJIT_FLG_FEATURE_SIMD, JIT_FLAG_FEATURE_SIMD)
+
+#endif // !defined(_TARGET_X86_) && !defined(_TARGET_AMD64_)
+
+ CONVERT_OLD_FLAG(CORJIT_FLG_MAKEFINALCODE, JIT_FLAG_MAKEFINALCODE)
+ CONVERT_OLD_FLAG(CORJIT_FLG_READYTORUN, JIT_FLAG_READYTORUN)
+ CONVERT_OLD_FLAG(CORJIT_FLG_PROF_ENTERLEAVE, JIT_FLAG_PROF_ENTERLEAVE)
+ CONVERT_OLD_FLAG(CORJIT_FLG_PROF_REJIT_NOPS, JIT_FLAG_PROF_REJIT_NOPS)
+ CONVERT_OLD_FLAG(CORJIT_FLG_PROF_NO_PINVOKE_INLINE, JIT_FLAG_PROF_NO_PINVOKE_INLINE)
+ CONVERT_OLD_FLAG(CORJIT_FLG_SKIP_VERIFICATION, JIT_FLAG_SKIP_VERIFICATION)
+ CONVERT_OLD_FLAG(CORJIT_FLG_PREJIT, JIT_FLAG_PREJIT)
+ CONVERT_OLD_FLAG(CORJIT_FLG_RELOC, JIT_FLAG_RELOC)
+ CONVERT_OLD_FLAG(CORJIT_FLG_IMPORT_ONLY, JIT_FLAG_IMPORT_ONLY)
+ CONVERT_OLD_FLAG(CORJIT_FLG_IL_STUB, JIT_FLAG_IL_STUB)
+ CONVERT_OLD_FLAG(CORJIT_FLG_PROCSPLIT, JIT_FLAG_PROCSPLIT)
+ CONVERT_OLD_FLAG(CORJIT_FLG_BBINSTR, JIT_FLAG_BBINSTR)
+ CONVERT_OLD_FLAG(CORJIT_FLG_BBOPT, JIT_FLAG_BBOPT)
+ CONVERT_OLD_FLAG(CORJIT_FLG_FRAMED, JIT_FLAG_FRAMED)
+ CONVERT_OLD_FLAG(CORJIT_FLG_ALIGN_LOOPS, JIT_FLAG_ALIGN_LOOPS)
+ CONVERT_OLD_FLAG(CORJIT_FLG_PUBLISH_SECRET_PARAM, JIT_FLAG_PUBLISH_SECRET_PARAM)
+ CONVERT_OLD_FLAG(CORJIT_FLG_GCPOLL_INLINE, JIT_FLAG_GCPOLL_INLINE)
+
+ CONVERT_OLD_FLAG2(CORJIT_FLG2_SAMPLING_JIT_BACKGROUND, JIT_FLAG_SAMPLING_JIT_BACKGROUND)
+
+#undef CONVERT_OLD_FLAG
+#undef CONVERT_OLD_FLAG2
+ }
+
+#else // COR_JIT_EE_VERSION > 460
+
+ void SetFromFlags(CORJIT_FLAGS flags)
+ {
+ // We don't want to have to check every one, so we assume it is exactly the same values as the JitFlag
+ // values defined in this type.
+ m_jitFlags = flags.GetFlagsRaw();
+
+ C_ASSERT(sizeof(m_jitFlags) == sizeof(CORJIT_FLAGS));
+
+#define FLAGS_EQUAL(a, b) C_ASSERT((unsigned)(a) == (unsigned)(b))
+
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_SPEED_OPT, JIT_FLAG_SPEED_OPT);
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_SIZE_OPT, JIT_FLAG_SIZE_OPT);
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_DEBUG_CODE, JIT_FLAG_DEBUG_CODE);
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_DEBUG_EnC, JIT_FLAG_DEBUG_EnC);
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_DEBUG_INFO, JIT_FLAG_DEBUG_INFO);
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_MIN_OPT, JIT_FLAG_MIN_OPT);
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_GCPOLL_CALLS, JIT_FLAG_GCPOLL_CALLS);
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_MCJIT_BACKGROUND, JIT_FLAG_MCJIT_BACKGROUND);
+
+#if defined(_TARGET_X86_)
+
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_PINVOKE_RESTORE_ESP, JIT_FLAG_PINVOKE_RESTORE_ESP);
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_TARGET_P4, JIT_FLAG_TARGET_P4);
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_USE_FCOMI, JIT_FLAG_USE_FCOMI);
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_USE_CMOV, JIT_FLAG_USE_CMOV);
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_USE_SSE2, JIT_FLAG_USE_SSE2);
+
+#endif
+
+#if defined(_TARGET_X86_) || defined(_TARGET_AMD64_)
+
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_USE_SSE3_4, JIT_FLAG_USE_SSE3_4);
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_USE_AVX, JIT_FLAG_USE_AVX);
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_USE_AVX2, JIT_FLAG_USE_AVX2);
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_USE_AVX_512, JIT_FLAG_USE_AVX_512);
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_FEATURE_SIMD, JIT_FLAG_FEATURE_SIMD);
+
+#endif
+
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_MAKEFINALCODE, JIT_FLAG_MAKEFINALCODE);
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_READYTORUN, JIT_FLAG_READYTORUN);
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_PROF_ENTERLEAVE, JIT_FLAG_PROF_ENTERLEAVE);
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_PROF_REJIT_NOPS, JIT_FLAG_PROF_REJIT_NOPS);
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_PROF_NO_PINVOKE_INLINE, JIT_FLAG_PROF_NO_PINVOKE_INLINE);
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_SKIP_VERIFICATION, JIT_FLAG_SKIP_VERIFICATION);
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_PREJIT, JIT_FLAG_PREJIT);
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_RELOC, JIT_FLAG_RELOC);
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_IMPORT_ONLY, JIT_FLAG_IMPORT_ONLY);
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_IL_STUB, JIT_FLAG_IL_STUB);
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_PROCSPLIT, JIT_FLAG_PROCSPLIT);
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_BBINSTR, JIT_FLAG_BBINSTR);
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_BBOPT, JIT_FLAG_BBOPT);
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_FRAMED, JIT_FLAG_FRAMED);
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_ALIGN_LOOPS, JIT_FLAG_ALIGN_LOOPS);
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_PUBLISH_SECRET_PARAM, JIT_FLAG_PUBLISH_SECRET_PARAM);
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_GCPOLL_INLINE, JIT_FLAG_GCPOLL_INLINE);
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_SAMPLING_JIT_BACKGROUND, JIT_FLAG_SAMPLING_JIT_BACKGROUND);
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_USE_PINVOKE_HELPERS, JIT_FLAG_USE_PINVOKE_HELPERS);
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_REVERSE_PINVOKE, JIT_FLAG_REVERSE_PINVOKE);
+ FLAGS_EQUAL(CORJIT_FLAGS::CORJIT_FLAG_DESKTOP_QUIRKS, JIT_FLAG_DESKTOP_QUIRKS);
+
+#undef FLAGS_EQUAL
+ }
+
+#endif // COR_JIT_EE_VERSION > 460
+
+private:
+ unsigned __int64 m_jitFlags;
+};
CLANG_FORMAT_COMMENT_ANCHOR;
#ifdef _TARGET_64BIT_
- if (comp->opts.eeFlags & CORJIT_FLG_IL_STUB)
+ if (comp->opts.jitFlags->IsSet(JitFlags::JIT_FLAG_IL_STUB))
{
// Push a frame - if we are NOT in an IL stub, this is done right before the call
// The init routine sets InlinedCallFrame's m_pNext, so we just set the thead's top-of-stack
CLANG_FORMAT_COMMENT_ANCHOR;
#ifdef _TARGET_64BIT_
- if (comp->opts.eeFlags & CORJIT_FLG_IL_STUB)
+ if (comp->opts.jitFlags->IsSet(JitFlags::JIT_FLAG_IL_STUB))
#endif // _TARGET_64BIT_
{
GenTree* frameUpd = CreateFrameLinkUpdate(PopFrame);
CLANG_FORMAT_COMMENT_ANCHOR;
#ifdef _TARGET_64BIT_
- if (!(comp->opts.eeFlags & CORJIT_FLG_IL_STUB))
+ if (!comp->opts.jitFlags->IsSet(JitFlags::JIT_FLAG_IL_STUB))
{
// Set the TCB's frame to be the one we just created.
// Note the init routine for the InlinedCallFrame (CORINFO_HELP_INIT_PINVOKE_FRAME)
CLANG_FORMAT_COMMENT_ANCHOR;
#ifdef _TARGET_64BIT_
- if (!(comp->opts.eeFlags & CORJIT_FLG_IL_STUB))
+ if (!comp->opts.jitFlags->IsSet(JitFlags::JIT_FLAG_IL_STUB))
{
tree = CreateFrameLinkUpdate(PopFrame);
BlockRange().InsertBefore(insertionPoint, LIR::SeqTree(comp, tree));
GenTree* Lowering::LowerNonvirtPinvokeCall(GenTreeCall* call)
{
// PInvoke lowering varies depending on the flags passed in by the EE. By default,
- // GC transitions are generated inline; if CORJIT_FLG2_USE_PINVOKE_HELPERS is specified,
+ // GC transitions are generated inline; if CORJIT_FLAG_USE_PINVOKE_HELPERS is specified,
// GC transitions are instead performed using helper calls. Examples of each case are given
// below. Note that the data structure that is used to store information about a call frame
// containing any P/Invoke calls is initialized in the method prolog (see
// AVX supports broadcast instructions to populate YMM reg with a single float/double value from memory.
// AVX2 supports broadcast instructions to populate YMM reg with a single value from memory or mm reg.
// If we decide to use AVX2 only, we can remove this assert.
- if ((compiler->opts.eeFlags & CORJIT_FLG_USE_AVX2) == 0)
+ if (!compiler->opts.jitFlags->IsSet(JitFlags::JIT_FLAG_USE_AVX2))
{
assert(baseType == TYP_FLOAT || baseType == TYP_DOUBLE);
}
#define REG_PINVOKE_TARGET_PARAM REG_EAX
#define RBM_PINVOKE_TARGET_PARAM RBM_EAX
- // IL stub's secret parameter (CORJIT_FLG_PUBLISH_SECRET_PARAM)
+ // IL stub's secret parameter (JitFlags::JIT_FLAG_PUBLISH_SECRET_PARAM)
#define REG_SECRET_STUB_PARAM REG_EAX
#define RBM_SECRET_STUB_PARAM RBM_EAX
#define RBM_PINVOKE_TARGET_PARAM RBM_R10
#define PREDICT_REG_PINVOKE_TARGET_PARAM PREDICT_REG_R10
- // IL stub's secret MethodDesc parameter (CORJIT_FLG_PUBLISH_SECRET_PARAM)
+ // IL stub's secret MethodDesc parameter (JitFlags::JIT_FLAG_PUBLISH_SECRET_PARAM)
#define REG_SECRET_STUB_PARAM REG_R10
#define RBM_SECRET_STUB_PARAM RBM_R10
#define RBM_PINVOKE_TARGET_PARAM RBM_R12
#define PREDICT_REG_PINVOKE_TARGET_PARAM PREDICT_REG_R12
- // IL stub's secret MethodDesc parameter (CORJIT_FLG_PUBLISH_SECRET_PARAM)
+ // IL stub's secret MethodDesc parameter (JitFlags::JIT_FLAG_PUBLISH_SECRET_PARAM)
#define REG_SECRET_STUB_PARAM REG_R12
#define RBM_SECRET_STUB_PARAM RBM_R12
#define RBM_PINVOKE_TARGET_PARAM RBM_R14
#define PREDICT_REG_PINVOKE_TARGET_PARAM PREDICT_REG_R14
- // IL stub's secret MethodDesc parameter (CORJIT_FLG_PUBLISH_SECRET_PARAM)
+ // IL stub's secret MethodDesc parameter (JitFlags::JIT_FLAG_PUBLISH_SECRET_PARAM)
#define REG_SECRET_STUB_PARAM REG_R12
#define RBM_SECRET_STUB_PARAM RBM_R12
pMD->GetMDImport(),
&ignored));
#ifdef FEATURE_INTERPRETER
- pMD->MakeJitWorker(pHeader, CORJIT_FLG_MAKEFINALCODE, 0);
+ pMD->MakeJitWorker(pHeader, CORJIT_FLAGS(CORJIT_FLAGS::CORJIT_FLAG_MAKEFINALCODE));
#else
- pMD->MakeJitWorker(pHeader, 0, 0);
+ pMD->MakeJitWorker(pHeader, CORJIT_FLAGS());
#endif
}
}
#endif // !_TARGET_X86_
-#if defined(_TARGET_AMD64_) && !defined(CROSSGEN_COMPILE)
+#if (defined(_TARGET_X86_) || defined(_TARGET_AMD64_)) && !defined(CROSSGEN_COMPILE)
extern "C" DWORD __stdcall getcpuid(DWORD arg, unsigned char result[16]);
-#endif // defined(_TARGET_AMD64_)
+#endif
inline bool TargetHasAVXSupport()
{
-#if defined(_TARGET_AMD64_) && !defined(CROSSGEN_COMPILE)
+#if (defined(_TARGET_X86_) || defined(_TARGET_AMD64_)) && !defined(CROSSGEN_COMPILE)
unsigned char buffer[16];
- // All AMD64 targets support cpuid.
+ // All x86/AMD64 targets support cpuid.
(void) getcpuid(1, buffer);
// getcpuid executes cpuid with eax set to its first argument, and ecx cleared.
// It returns the resulting eax, ebx, ecx and edx (in that order) in buffer[].
// The AVX feature is ECX bit 28.
return ((buffer[11] & 0x10) != 0);
-#endif // defined(_TARGET_AMD64_) && !defined(CROSSGEN_COMPILE)
+#endif // (defined(_TARGET_X86_) || defined(_TARGET_AMD64_)) && !defined(CROSSGEN_COMPILE)
return false;
}
// CRST_TAKEN_DURING_SHUTDOWN - We take this lock during shutdown if ETW is on (to do rundown)
m_CodeHeapCritSec( CrstSingleUseLock,
CrstFlags(CRST_UNSAFE_ANYMODE|CRST_DEBUGGER_THREAD|CRST_TAKEN_DURING_SHUTDOWN)),
+ m_CPUCompileFlags(),
m_EHClauseCritSec( CrstSingleUseLock )
{
CONTRACTL {
m_AltJITRequired = false;
#endif
- m_dwCPUCompileFlags = 0;
-
m_cleanupList = NULL;
}
-#if defined(_TARGET_AMD64_)
+#if defined(_TARGET_X86_) || defined(_TARGET_AMD64_)
extern "C" DWORD __stdcall getcpuid(DWORD arg, unsigned char result[16]);
extern "C" DWORD __stdcall xmmYmmStateSupport();
bool DoesOSSupportAVX()
{
+ LIMITED_METHOD_CONTRACT;
+
#ifndef FEATURE_PAL
// On Windows we have an api(GetEnabledXStateFeatures) to check if AVX is supported
typedef DWORD64 (WINAPI *PGETENABLEDXSTATEFEATURES)();
return TRUE;
}
-#endif // defined(_TARGET_AMD64_)
+#endif // defined(_TARGET_X86_) || defined(_TARGET_AMD64_)
void EEJitManager::SetCpuInfo()
{
// NOTE: This function needs to be kept in sync with Zapper::CompileAssembly()
//
- DWORD dwCPUCompileFlags = 0;
+ CORJIT_FLAGS CPUCompileFlags;
#if defined(_TARGET_X86_)
// NOTE: if you're adding any flags here, you probably should also be doing it
switch (CPU_X86_FAMILY(cpuInfo.dwCPUType))
{
case CPU_X86_PENTIUM_4:
- dwCPUCompileFlags |= CORJIT_FLG_TARGET_P4;
+ CPUCompileFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_TARGET_P4);
break;
default:
break;
if (CPU_X86_USE_CMOV(cpuInfo.dwFeatures))
{
- dwCPUCompileFlags |= CORJIT_FLG_USE_CMOV |
- CORJIT_FLG_USE_FCOMI;
+ CPUCompileFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_USE_CMOV);
+ CPUCompileFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_USE_FCOMI);
}
if (CPU_X86_USE_SSE2(cpuInfo.dwFeatures))
{
- dwCPUCompileFlags |= CORJIT_FLG_USE_SSE2;
+ CPUCompileFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_USE_SSE2);
}
-#elif defined(_TARGET_AMD64_)
+#endif // _TARGET_X86_
+
+#if defined(_TARGET_X86_) || defined(_TARGET_AMD64_)
unsigned char buffer[16];
DWORD maxCpuId = getcpuid(0, buffer);
if (maxCpuId >= 0)
// It returns the resulting eax in buffer[0-3], ebx in buffer[4-7], ecx in buffer[8-11],
// and edx in buffer[12-15].
// We will set the following flags:
- // CORJIT_FLG_USE_SSE3_4 if the following feature bits are set (input EAX of 1)
+ // CORJIT_FLAG_USE_SSE3_4 if the following feature bits are set (input EAX of 1)
// SSE3 - ECX bit 0 (buffer[8] & 0x01)
// SSSE3 - ECX bit 9 (buffer[9] & 0x02)
// SSE4.1 - ECX bit 19 (buffer[10] & 0x08)
// SSE4.2 - ECX bit 20 (buffer[10] & 0x10)
- // CORJIT_FLG_USE_AVX if the following feature bits are set (input EAX of 1), and xmmYmmStateSupport returns 1:
+ // CORJIT_FLAG_USE_AVX if the following feature bits are set (input EAX of 1), and xmmYmmStateSupport returns 1:
// OSXSAVE - ECX bit 27 (buffer[11] & 0x08)
// AVX - ECX bit 28 (buffer[11] & 0x10)
- // CORJIT_FLG_USE_AVX2 if the following feature bit is set (input EAX of 0x07 and input ECX of 0):
+ // CORJIT_FLAG_USE_AVX2 if the following feature bit is set (input EAX of 0x07 and input ECX of 0):
// AVX2 - EBX bit 5 (buffer[4] & 0x20)
- // CORJIT_FLG_USE_AVX_512 is not currently set, but defined so that it can be used in future without
+ // CORJIT_FLAG_USE_AVX_512 is not currently set, but defined so that it can be used in future without
// synchronously updating VM and JIT.
(void) getcpuid(1, buffer);
// If SSE2 is not enabled, there is no point in checking the rest.
((buffer[10] & 0x08) != 0) && // SSE4.1
((buffer[10] & 0x10) != 0)) // SSE4.2
{
- dwCPUCompileFlags |= CORJIT_FLG_USE_SSE3_4;
+ CPUCompileFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_USE_SSE3_4);
}
if ((buffer[11] & 0x18) == 0x18)
{
{
if (xmmYmmStateSupport() == 1)
{
- dwCPUCompileFlags |= CORJIT_FLG_USE_AVX;
+ CPUCompileFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_USE_AVX);
if (maxCpuId >= 0x07)
{
(void) getcpuid(0x07, buffer);
if ((buffer[4] & 0x20) != 0)
{
- dwCPUCompileFlags |= CORJIT_FLG_USE_AVX2;
+ CPUCompileFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_USE_AVX2);
}
}
}
static ConfigDWORD fFeatureSIMD;
if (fFeatureSIMD.val(CLRConfig::EXTERNAL_FeatureSIMD) != 0)
{
- dwCPUCompileFlags |= CORJIT_FLG_FEATURE_SIMD;
+ CPUCompileFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_FEATURE_SIMD);
}
}
}
-#endif // defined(_TARGET_AMD64_)
+#endif // defined(_TARGET_X86_) || defined(_TARGET_AMD64_)
- m_dwCPUCompileFlags = dwCPUCompileFlags;
+ m_CPUCompileFlags = CPUCompileFlags;
}
// Define some data that we can use to get a better idea of what happened when we get a Watson dump that indicates the JIT failed to load.
#endif // !DACCESS_COMPILE
private:
- DWORD m_dwCPUCompileFlags;
+ CORJIT_FLAGS m_CPUCompileFlags;
#if !defined CROSSGEN_COMPILE && !defined DACCESS_COMPILE
void SetCpuInfo();
#endif
public:
- inline DWORD GetCPUCompileFlags()
+ inline CORJIT_FLAGS GetCPUCompileFlags()
{
LIMITED_METHOD_CONTRACT;
- return m_dwCPUCompileFlags;
+ return m_CPUCompileFlags;
}
private :
COMPlusThrowHR(VLDTR_E_MD_BADHEADER);
#ifdef FEATURE_INTERPRETER
- pMethodDesc->MakeJitWorker(&header, CORJIT_FLG_MAKEFINALCODE, 0);
+ pMethodDesc->MakeJitWorker(&header, CORJIT_FLAGS(CORJIT_FLAGS::CORJIT_FLAG_MAKEFINALCODE));
#else // !FEATURE_INTERPRETER
- pMethodDesc->MakeJitWorker(&header, 0, 0);
+ pMethodDesc->MakeJitWorker(&header, CORJIT_FLAGS());
#endif // !FEATURE_INTERPRETER
}
HRESULT CEECompileInfo::GetBaseJitFlags(
IN CORINFO_METHOD_HANDLE hMethod,
- OUT DWORD *pFlags)
+ OUT CORJIT_FLAGS *pFlags)
{
STANDARD_VM_CONTRACT;
{
if (!pStubMD->AsDynamicMethodDesc()->GetILStubResolver()->IsCompiled())
{
- DWORD dwJitFlags = pStubMD->AsDynamicMethodDesc()->GetILStubResolver()->GetJitFlags();
+ CORJIT_FLAGS jitFlags = pStubMD->AsDynamicMethodDesc()->GetILStubResolver()->GetJitFlags();
- pfnCallback(pCallbackContext, (CORINFO_METHOD_HANDLE)pStubMD, dwJitFlags);
+ pfnCallback(pCallbackContext, (CORINFO_METHOD_HANDLE)pStubMD, jitFlags);
}
#ifndef FEATURE_FULL_NGEN // Deduplication
HRESULT GetBaseJitFlags(
IN CORINFO_METHOD_HANDLE hMethod,
- OUT DWORD *pFlags);
+ OUT CORJIT_FLAGS *pFlags);
#ifdef _WIN64
SIZE_T getPersonalityValue();
pcsUnmarshal->EmitRET();
}
- DWORD dwJitFlags = CORJIT_FLG_IL_STUB;
+ CORJIT_FLAGS jitFlags(CORJIT_FLAGS::CORJIT_FLAG_IL_STUB);
if (m_slIL.HasInteropParamExceptionInfo())
{
else
{
// All other IL stubs will need to use the secret parameter.
- dwJitFlags |= CORJIT_FLG_PUBLISH_SECRET_PARAM;
+ jitFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_PUBLISH_SECRET_PARAM);
}
if (SF_IsReverseStub(m_dwStubFlags))
m_slIL.GenerateCode(pbBuffer, cbCode);
m_slIL.GetLocalSig(pbLocalSig, cbSig);
- pResolver->SetJitFlags(dwJitFlags);
+ pResolver->SetJitFlags(jitFlags);
#ifdef LOGGING
LOG((LF_STUBS, LL_INFO1000, "---------------------------------------------------------------------\n"));
LogILStubFlags(LF_STUBS, LL_INFO1000, m_dwStubFlags);
- m_slIL.LogILStub(dwJitFlags);
+ m_slIL.LogILStub(jitFlags);
}
LOG((LF_STUBS, LL_INFO1000, "^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n"));
#endif // LOGGING
pStubMD,
pbLocalSig,
cbSig,
- dwJitFlags,
+ jitFlags,
&convertToHRTryCatch,
&cleanupTryFinally,
maxStack,
MethodDesc * pStubMD,
PCCOR_SIGNATURE pbLocalSig,
DWORD cbSig,
- DWORD dwJitFlags,
+ CORJIT_FLAGS jitFlags,
ILStubEHClause * pConvertToHRTryCatchBounds,
ILStubEHClause * pCleanupTryFinallyBounds,
DWORD maxStack,
strILStubCode.AppendPrintf(W(".maxstack %d \n"), maxStack);
strILStubCode.AppendPrintf(W(".locals %s\n"), strLocalSig.GetUnicode());
- m_slIL.LogILStub(dwJitFlags, &strILStubCode);
+ m_slIL.LogILStub(jitFlags, &strILStubCode);
if (pConvertToHRTryCatchBounds->cbTryLength != 0 && pConvertToHRTryCatchBounds->cbHandlerLength != 0)
{
// A dynamically generated IL stub
//
- DWORD dwFlags = pStubMD->AsDynamicMethodDesc()->GetILStubResolver()->GetJitFlags();
- pCode = pStubMD->MakeJitWorker(NULL, dwFlags, 0);
+ CORJIT_FLAGS jitFlags = pStubMD->AsDynamicMethodDesc()->GetILStubResolver()->GetJitFlags();
+ pCode = pStubMD->MakeJitWorker(NULL, jitFlags);
_ASSERTE(pCode == pStubMD->GetNativeCode());
}
dwStubFlags |= NDIRECTSTUB_FL_REVERSE_INTEROP; // could be either delegate interop or not--that info is passed in from the caller
#if defined(DEBUGGING_SUPPORTED)
- if (GetDebuggerCompileFlags(pSigInfo->GetModule(), 0) & CORJIT_FLG_DEBUG_CODE)
+ if (GetDebuggerCompileFlags(pSigInfo->GetModule(), CORJIT_FLAGS()).IsSet(CORJIT_FLAGS::CORJIT_FLAG_DEBUG_CODE))
{
dwStubFlags |= NDIRECTSTUB_FL_GENERATEDEBUGGABLEIL;
}
DWORD dwStubFlags = NDIRECTSTUB_FL_NGENEDSTUB | NDIRECTSTUB_FL_REVERSE_INTEROP | NDIRECTSTUB_FL_DELEGATE;
#if defined(DEBUGGING_SUPPORTED)
- if (GetDebuggerCompileFlags(GetModule(), 0) & CORJIT_FLG_DEBUG_CODE)
+ if (GetDebuggerCompileFlags(GetModule(), CORJIT_FLAGS()).IsSet(CORJIT_FLAGS::CORJIT_FLAG_DEBUG_CODE))
{
dwStubFlags |= NDIRECTSTUB_FL_GENERATEDEBUGGABLEIL;
}
#pragma warning(push)
#pragma warning(disable: 4035)
-DWORD getcpuid(DWORD arg, unsigned char result[16])
+extern "C" DWORD __stdcall getcpuid(DWORD arg, unsigned char result[16])
{
LIMITED_METHOD_CONTRACT
// Arg3 is a pointer to the return buffer
// No need to check whether or not CPUID is supported because we have already called CPUID with success to come here.
-DWORD getextcpuid(DWORD arg1, DWORD arg2, unsigned char result[16])
+extern "C" DWORD __stdcall getextcpuid(DWORD arg1, DWORD arg2, unsigned char result[16])
{
LIMITED_METHOD_CONTRACT
}
}
+extern "C" DWORD __stdcall xmmYmmStateSupport()
+{
+ // No CONTRACT
+ STATIC_CONTRACT_NOTHROW;
+ STATIC_CONTRACT_GC_NOTRIGGER;
+
+ __asm
+ {
+ mov ecx, 0 ; Specify xcr0
+ xgetbv ; result in EDX:EAX
+ and eax, 06H
+ cmp eax, 06H ; check OS has enabled both XMM and YMM state support
+ jne not_supported
+ mov eax, 1
+ jmp done
+ not_supported:
+ mov eax, 0
+ done:
+ }
+}
+
#pragma warning(pop)
pStubLinker->GenerateCode(pbBuffer, cbCode);
pStubLinker->GetLocalSig(pbLocalSig, cbSig);
- pResolver->SetJitFlags(CORJIT_FLG_IL_STUB);
+ pResolver->SetJitFlags(CORJIT_FLAGS(CORJIT_FLAGS::CORJIT_FLAG_IL_STUB));
}
pResolver->SetTokenLookupMap(pStubLinker->GetTokenLookupMap());
m_pStubMD(dac_cast<PTR_MethodDesc>(nullptr)),
m_pStubTargetMD(dac_cast<PTR_MethodDesc>(nullptr)),
m_type(Unassigned),
- m_dwJitFlags(0)
+ m_jitFlags()
{
LIMITED_METHOD_CONTRACT;
return (dac_cast<TADDR>(m_pCompileTimeState) != ILNotYetGenerated);
}
-void ILStubResolver::SetJitFlags(DWORD dwFlags)
+void ILStubResolver::SetJitFlags(CORJIT_FLAGS jitFlags)
{
LIMITED_METHOD_CONTRACT;
- m_dwJitFlags = dwFlags;
+ m_jitFlags = jitFlags;
}
-DWORD ILStubResolver::GetJitFlags()
+CORJIT_FLAGS ILStubResolver::GetJitFlags()
{
LIMITED_METHOD_CONTRACT;
- return m_dwJitFlags;
+ return m_jitFlags;
}
// static
void SetTokenLookupMap(TokenLookupMap* pMap);
- void SetJitFlags(DWORD dwJitFlags);
- DWORD GetJitFlags();
+ void SetJitFlags(CORJIT_FLAGS jitFlags);
+ CORJIT_FLAGS GetJitFlags();
static void StubGenFailed(ILStubResolver* pResolver);
PTR_MethodDesc m_pStubMD;
PTR_MethodDesc m_pStubTargetMD;
ILStubType m_type;
- DWORD m_dwJitFlags;
+ CORJIT_FLAGS m_jitFlags;
};
typedef Holder<ILStubResolver*, DoNothing<ILStubResolver*>, ILStubResolver::StubGenFailed, NULL> ILStubGenHolder;
fprintf(GetLogFile(), "JITting method %s:%s.\n", md->m_pszDebugClassName, md->m_pszDebugMethodName);
}
#endif // _DEBUG
- DWORD dwFlags = CORJIT_FLG_MAKEFINALCODE;
+ CORJIT_FLAGS jitFlags(CORJIT_FLAGS::CORJIT_FLAG_MAKEFINALCODE);
NewHolder<COR_ILMETHOD_DECODER> pDecoder(NULL);
// Dynamic methods (e.g., IL stubs) do not have an IL decoder but may
// require additional flags. Ordinary methods require the opposite.
if (md->IsDynamicMethod())
{
- dwFlags |= md->AsDynamicMethodDesc()->GetILStubResolver()->GetJitFlags();
+ jitFlags.Add(md->AsDynamicMethodDesc()->GetILStubResolver()->GetJitFlags());
}
else
{
md->GetMDImport(),
&status);
}
- PCODE res = md->MakeJitWorker(pDecoder, dwFlags, 0);
+ PCODE res = md->MakeJitWorker(pDecoder, jitFlags);
interpMethInfo->m_jittedCode = res;
}
}
// If the callee wants debuggable code, don't allow it to be inlined
- if (GetDebuggerCompileFlags(pCallee->GetModule(), 0) & CORJIT_FLG_DEBUG_CODE)
+ if (GetDebuggerCompileFlags(pCallee->GetModule(), CORJIT_FLAGS()).IsSet(CORJIT_FLAGS::CORJIT_FLAG_DEBUG_CODE))
{
result = INLINE_NEVER;
szFailReason = "Inlinee is debuggable";
CorElementType normType = typeHnd.GetInternalCorElementType();
// if we are looking up a value class, don't morph it to a refernece type
- // (This can only happen in illegal IL
+ // (This can only happen in illegal IL)
if (!CorTypeInfo::IsObjRef(normType) || type != ELEMENT_TYPE_VALUETYPE)
{
type = normType;
CorJitResult invokeCompileMethodHelper(EEJitManager *jitMgr,
CEEInfo *comp,
struct CORINFO_METHOD_INFO *info,
- unsigned flags,
- unsigned flags2,
+ CORJIT_FLAGS jitFlags,
BYTE **nativeEntry,
ULONG *nativeSizeOfCode)
{
CorJitResult ret = CORJIT_SKIPPED; // Note that CORJIT_SKIPPED is an error exit status code
- CORJIT_FLAGS jitFlags = { 0 };
- jitFlags.corJitFlags = flags;
- jitFlags.corJitFlags2 = flags2;
-
#if !defined(FEATURE_CORECLR)
// Ask the JIT to generate desktop-quirk-compatible code.
- jitFlags.corJitFlags2 |= CORJIT_FLG2_DESKTOP_QUIRKS;
+ jitFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_DESKTOP_QUIRKS);
#endif
comp->setJitFlags(jitFlags);
#if defined(CROSSGEN_COMPILE) && !defined(FEATURE_CORECLR)
ret = getJit()->compileMethod( comp,
info,
- CORJIT_FLG_CALL_GETJITFLAGS,
+ CORJIT_FLAGS::CORJIT_FLAG_CALL_GETJITFLAGS,
nativeEntry,
nativeSizeOfCode);
#if defined(ALLOW_SXS_JIT) && !defined(CROSSGEN_COMPILE)
if (FAILED(ret) && jitMgr->m_alternateJit
#ifdef FEATURE_STACK_SAMPLING
- && (!samplingEnabled || (jitFlags.corJitFlags2 & CORJIT_FLG2_SAMPLING_JIT_BACKGROUND))
+ && (!samplingEnabled || (jitFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_SAMPLING_JIT_BACKGROUND)))
#endif
)
{
ret = jitMgr->m_alternateJit->compileMethod( comp,
info,
- CORJIT_FLG_CALL_GETJITFLAGS,
+ CORJIT_FLAGS::CORJIT_FLAG_CALL_GETJITFLAGS,
nativeEntry,
nativeSizeOfCode );
#ifdef FEATURE_STACK_SAMPLING
- if (jitFlags.corJitFlags2 & CORJIT_FLG2_SAMPLING_JIT_BACKGROUND)
+ if (jitFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_SAMPLING_JIT_BACKGROUND))
{
// Don't bother with failures if we couldn't collect a trace.
ret = CORJIT_OK;
{
// If we're doing an "import_only" compilation, it's for verification, so don't interpret.
// (We assume that importation is completely architecture-independent, or at least nearly so.)
- if (FAILED(ret) && (jitFlags.corJitFlags & (CORJIT_FLG_IMPORT_ONLY | CORJIT_FLG_MAKEFINALCODE)) == 0)
+ if (FAILED(ret) && !jitFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_IMPORT_ONLY) && !jitFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_MAKEFINALCODE))
{
ret = Interpreter::GenerateInterpreterStub(comp, info, nativeEntry, nativeSizeOfCode);
}
ret = CompileMethodWithEtwWrapper(jitMgr,
comp,
info,
- CORJIT_FLG_CALL_GETJITFLAGS,
+ CORJIT_FLAGS::CORJIT_FLAG_CALL_GETJITFLAGS,
nativeEntry,
nativeSizeOfCode);
}
{
// If we're doing an "import_only" compilation, it's for verification, so don't interpret.
// (We assume that importation is completely architecture-independent, or at least nearly so.)
- if (FAILED(ret) && (jitFlags.corJitFlags & (CORJIT_FLG_IMPORT_ONLY | CORJIT_FLG_MAKEFINALCODE)) == 0)
+ if (FAILED(ret) && !jitFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_IMPORT_ONLY) && !jitFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_MAKEFINALCODE))
{
ret = Interpreter::GenerateInterpreterStub(comp, info, nativeEntry, nativeSizeOfCode);
}
{
ret = jitMgr->m_jit->compileMethod( comp,
info,
- CORJIT_FLG_CALL_GETJITFLAGS,
+ CORJIT_FLAGS::CORJIT_FLAG_CALL_GETJITFLAGS,
nativeEntry,
nativeSizeOfCode);
}
// If the JIT fails we keep the IL around and will
// try reJIT the same IL. VSW 525059
//
- if (SUCCEEDED(ret) && !(jitFlags.corJitFlags & CORJIT_FLG_IMPORT_ONLY) && !((CEEJitInfo*)comp)->JitAgain())
+ if (SUCCEEDED(ret) && !jitFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_IMPORT_ONLY) && !((CEEJitInfo*)comp)->JitAgain())
{
((CEEJitInfo*)comp)->CompressDebugInfo();
CorJitResult invokeCompileMethod(EEJitManager *jitMgr,
CEEInfo *comp,
struct CORINFO_METHOD_INFO *info,
- unsigned flags,
- unsigned flags2,
+ CORJIT_FLAGS jitFlags,
BYTE **nativeEntry,
ULONG *nativeSizeOfCode)
{
GCX_PREEMP();
- CorJitResult ret = invokeCompileMethodHelper(jitMgr, comp, info, flags, flags2, nativeEntry, nativeSizeOfCode);
+ CorJitResult ret = invokeCompileMethodHelper(jitMgr, comp, info, jitFlags, nativeEntry, nativeSizeOfCode);
//
// Verify that we are still in preemptive mode when we return
return ret;
}
-CorJitFlag GetCompileFlagsIfGenericInstantiation(
+CORJIT_FLAGS GetCompileFlagsIfGenericInstantiation(
CORINFO_METHOD_HANDLE method,
- CorJitFlag compileFlags,
+ CORJIT_FLAGS compileFlags,
ICorJitInfo * pCorJitInfo,
BOOL * raiseVerificationException,
BOOL * unverifiableGenericCode);
CorJitResult CallCompileMethodWithSEHWrapper(EEJitManager *jitMgr,
CEEInfo *comp,
struct CORINFO_METHOD_INFO *info,
- unsigned flags,
- unsigned flags2,
+ CORJIT_FLAGS flags,
BYTE **nativeEntry,
ULONG *nativeSizeOfCode,
MethodDesc *ftn)
EEJitManager *jitMgr;
CEEInfo *comp;
struct CORINFO_METHOD_INFO *info;
- unsigned flags;
- unsigned flags2;
+ CORJIT_FLAGS flags;
BYTE **nativeEntry;
ULONG *nativeSizeOfCode;
MethodDesc *ftn;
param.comp = comp;
param.info = info;
param.flags = flags;
- param.flags2 = flags2;
param.nativeEntry = nativeEntry;
param.nativeSizeOfCode = nativeSizeOfCode;
param.ftn = ftn;
pParam->comp,
pParam->info,
pParam->flags,
- pParam->flags2,
pParam->nativeEntry,
pParam->nativeSizeOfCode);
}
PAL_FINALLY
{
#if defined(DEBUGGING_SUPPORTED) && !defined(CROSSGEN_COMPILE)
- if (!(flags & (CORJIT_FLG_IMPORT_ONLY | CORJIT_FLG_MCJIT_BACKGROUND))
+ if (!flags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_IMPORT_ONLY) &&
+ !flags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_MCJIT_BACKGROUND)
#ifdef FEATURE_STACK_SAMPLING
- && !(flags2 & CORJIT_FLG2_SAMPLING_JIT_BACKGROUND)
+ && !flags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_SAMPLING_JIT_BACKGROUND)
#endif // FEATURE_STACK_SAMPLING
)
{
/*********************************************************************/
// Figures out the compile flags that are used by both JIT and NGen
-/* static */ DWORD CEEInfo::GetBaseCompileFlags(MethodDesc * ftn)
+/* static */ CORJIT_FLAGS CEEInfo::GetBaseCompileFlags(MethodDesc * ftn)
{
CONTRACTL {
THROWS;
// Figure out the code quality flags
//
- DWORD flags = 0;
+ CORJIT_FLAGS flags;
if (g_pConfig->JitFramed())
- flags |= CORJIT_FLG_FRAMED;
+ flags.Set(CORJIT_FLAGS::CORJIT_FLAG_FRAMED);
if (g_pConfig->JitAlignLoops())
- flags |= CORJIT_FLG_ALIGN_LOOPS;
+ flags.Set(CORJIT_FLAGS::CORJIT_FLAG_ALIGN_LOOPS);
if (ReJitManager::IsReJITEnabled() || g_pConfig->AddRejitNops())
- flags |= CORJIT_FLG_PROF_REJIT_NOPS;
+ flags.Set(CORJIT_FLAGS::CORJIT_FLAG_PROF_REJIT_NOPS);
#ifdef _TARGET_X86_
if (g_pConfig->PInvokeRestoreEsp(ftn->GetModule()->IsPreV4Assembly()))
- flags |= CORJIT_FLG_PINVOKE_RESTORE_ESP;
+ flags.Set(CORJIT_FLAGS::CORJIT_FLAG_PINVOKE_RESTORE_ESP);
#endif // _TARGET_X86_
//See if we should instruct the JIT to emit calls to JIT_PollGC for thread suspension. If we have a
#ifdef FEATURE_ENABLE_GCPOLL
EEConfig::GCPollType pollType = g_pConfig->GetGCPollType();
if (EEConfig::GCPOLL_TYPE_POLL == pollType)
- flags |= CORJIT_FLG_GCPOLL_CALLS;
+ flags.Set(CORJIT_FLAGS::CORJIT_FLAG_GCPOLL_CALLS);
else if (EEConfig::GCPOLL_TYPE_INLINE == pollType)
- flags |= CORJIT_FLG_GCPOLL_INLINE;
+ flags.Set(CORJIT_FLAGS::CORJIT_FLAG_GCPOLL_INLINE);
#endif //FEATURE_ENABLE_GCPOLL
// Set flags based on method's ImplFlags.
if (IsMiNoOptimization(dwImplFlags))
{
- flags |= CORJIT_FLG_MIN_OPT;
+ flags.Set(CORJIT_FLAGS::CORJIT_FLAG_MIN_OPT);
}
// Always emit frames for methods marked no-inline (see #define ETW_EBP_FRAMED in the JIT)
if (IsMiNoInlining(dwImplFlags))
{
- flags |= CORJIT_FLG_FRAMED;
+ flags.Set(CORJIT_FLAGS::CORJIT_FLAG_FRAMED);
}
}
// Figures out (some of) the flags to use to compile the method
// Returns the new set to use
-DWORD GetDebuggerCompileFlags(Module* pModule, DWORD flags)
+CORJIT_FLAGS GetDebuggerCompileFlags(Module* pModule, CORJIT_FLAGS flags)
{
STANDARD_VM_CONTRACT;
#ifdef _DEBUG
if (g_pConfig->GenDebuggableCode())
- flags |= CORJIT_FLG_DEBUG_CODE;
+ flags.Set(CORJIT_FLAGS::CORJIT_FLAG_DEBUG_CODE);
#endif // _DEBUG
#ifdef EnC_SUPPORTED
if (pModule->IsEditAndContinueEnabled())
{
- flags |= CORJIT_FLG_DEBUG_EnC;
+ flags.Set(CORJIT_FLAGS::CORJIT_FLAG_DEBUG_EnC);
}
#endif // EnC_SUPPORTED
// Debug info is always tracked
- flags |= CORJIT_FLG_DEBUG_INFO;
+ flags.Set(CORJIT_FLAGS::CORJIT_FLAG_DEBUG_INFO);
#endif // DEBUGGING_SUPPORTED
if (CORDisableJITOptimizations(pModule->GetDebuggerInfoBits()))
{
- flags |= CORJIT_FLG_DEBUG_CODE;
+ flags.Set(CORJIT_FLAGS::CORJIT_FLAG_DEBUG_CODE);
}
- if (flags & CORJIT_FLG_IMPORT_ONLY)
+ if (flags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_IMPORT_ONLY))
{
// If we are only verifying the method, dont need any debug info and this
// prevents getVars()/getBoundaries() from being called unnecessarily.
- flags &= ~(CORJIT_FLG_DEBUG_INFO|CORJIT_FLG_DEBUG_CODE);
+ flags.Clear(CORJIT_FLAGS::CORJIT_FLAG_DEBUG_INFO);
+ flags.Clear(CORJIT_FLAGS::CORJIT_FLAG_DEBUG_CODE);
}
return flags;
}
-CorJitFlag GetCompileFlags(MethodDesc * ftn, DWORD flags, CORINFO_METHOD_INFO * methodInfo)
+CORJIT_FLAGS GetCompileFlags(MethodDesc * ftn, CORJIT_FLAGS flags, CORINFO_METHOD_INFO * methodInfo)
{
STANDARD_VM_CONTRACT;
//
// Get the compile flags that are shared between JIT and NGen
//
- flags |= CEEInfo::GetBaseCompileFlags(ftn);
+ flags.Add(CEEInfo::GetBaseCompileFlags(ftn));
//
// Get CPU specific flags
//
- if ((flags & CORJIT_FLG_IMPORT_ONLY) == 0)
+ if (!flags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_IMPORT_ONLY))
{
- flags |= ExecutionManager::GetEEJitManager()->GetCPUCompileFlags();
+ flags.Add(ExecutionManager::GetEEJitManager()->GetCPUCompileFlags());
}
//
//
#ifdef DEBUGGING_SUPPORTED
- flags |= GetDebuggerCompileFlags(ftn->GetModule(), flags);
+ flags.Add(GetDebuggerCompileFlags(ftn->GetModule(), flags));
#endif
#ifdef PROFILING_SUPPORTED
- if (CORProfilerTrackEnterLeave()
- && !ftn->IsNoMetadata()
- )
- flags |= CORJIT_FLG_PROF_ENTERLEAVE;
+ if (CORProfilerTrackEnterLeave() && !ftn->IsNoMetadata())
+ flags.Set(CORJIT_FLAGS::CORJIT_FLAG_PROF_ENTERLEAVE);
if (CORProfilerTrackTransitions())
- flags |= CORJIT_FLG_PROF_NO_PINVOKE_INLINE;
+ flags.Set(CORJIT_FLAGS::CORJIT_FLAG_PROF_NO_PINVOKE_INLINE);
#endif // PROFILING_SUPPORTED
// Set optimization flags
- if (0 == (flags & CORJIT_FLG_MIN_OPT))
+ if (!flags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_MIN_OPT))
{
unsigned optType = g_pConfig->GenOptimizeType();
_ASSERTE(optType <= OPT_RANDOM);
optType = methodInfo->ILCodeSize % OPT_RANDOM;
if (g_pConfig->JitMinOpts())
- flags |= CORJIT_FLG_MIN_OPT;
+ flags.Set(CORJIT_FLAGS::CORJIT_FLAG_MIN_OPT);
- const static unsigned optTypeFlags[] =
+ if (optType == OPT_SIZE)
{
- 0, // OPT_BLENDED
- CORJIT_FLG_SIZE_OPT, // OPT_CODE_SIZE
- CORJIT_FLG_SPEED_OPT // OPT_CODE_SPEED
- };
-
- _ASSERTE(optType < OPT_RANDOM);
- _ASSERTE((sizeof(optTypeFlags)/sizeof(optTypeFlags[0])) == OPT_RANDOM);
- flags |= optTypeFlags[optType];
+ flags.Set(CORJIT_FLAGS::CORJIT_FLAG_SIZE_OPT);
+ }
+ else if (optType == OPT_SPEED)
+ {
+ flags.Set(CORJIT_FLAGS::CORJIT_FLAG_SPEED_OPT);
+ }
}
//
#ifdef _DEBUG
if (g_pConfig->IsJitVerificationDisabled())
- flags |= CORJIT_FLG_SKIP_VERIFICATION;
+ flags.Set(CORJIT_FLAGS::CORJIT_FLAG_SKIP_VERIFICATION);
#endif // _DEBUG
- if ((flags & CORJIT_FLG_IMPORT_ONLY) == 0 &&
- Security::CanSkipVerification(ftn))
- flags |= CORJIT_FLG_SKIP_VERIFICATION;
+ if (!flags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_IMPORT_ONLY) && Security::CanSkipVerification(ftn))
+ flags.Set(CORJIT_FLAGS::CORJIT_FLAG_SKIP_VERIFICATION);
if (ftn->IsILStub())
{
- flags |= CORJIT_FLG_SKIP_VERIFICATION;
+ flags.Set(CORJIT_FLAGS::CORJIT_FLAG_SKIP_VERIFICATION);
// no debug info available for IL stubs
- flags &= ~CORJIT_FLG_DEBUG_INFO;
+ flags.Clear(CORJIT_FLAGS::CORJIT_FLAG_DEBUG_INFO);
}
- return (CorJitFlag)flags;
+ return flags;
}
#if defined(_WIN64)
//
//This only works for real methods. If the method isn't IsIL, then IsVerifiable will AV. That would be a
//bad thing (TM).
-BOOL IsTransparentMethodSafeToSkipVerification(CorJitFlag flags, MethodDesc * ftn)
+BOOL IsTransparentMethodSafeToSkipVerification(CORJIT_FLAGS flags, MethodDesc * ftn)
{
STANDARD_VM_CONTRACT;
BOOL ret = FALSE;
- if (!(flags & CORJIT_FLG_IMPORT_ONLY) && !(flags & CORJIT_FLG_SKIP_VERIFICATION)
+ if (!flags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_IMPORT_ONLY) && !flags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_SKIP_VERIFICATION)
&& Security::IsMethodTransparent(ftn) &&
((ftn->IsIL() && !ftn->IsUnboxingStub()) ||
(ftn->IsDynamicMethod() && !ftn->IsILStub())))
// failed, then we need to throw an exception whenever we try
// to compile a real instantiation
-CorJitFlag GetCompileFlagsIfGenericInstantiation(
+CORJIT_FLAGS GetCompileFlagsIfGenericInstantiation(
CORINFO_METHOD_HANDLE method,
- CorJitFlag compileFlags,
+ CORJIT_FLAGS compileFlags,
ICorJitInfo * pCorJitInfo,
BOOL * raiseVerificationException,
BOOL * unverifiableGenericCode)
*unverifiableGenericCode = FALSE;
// If we have already decided to skip verification, keep on going.
- if (compileFlags & CORJIT_FLG_SKIP_VERIFICATION)
+ if (compileFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_SKIP_VERIFICATION))
return compileFlags;
CorInfoInstantiationVerification ver = pCorJitInfo->isInstantiationOfVerifiedGeneric(method);
case INSTVER_NOT_INSTANTIATION:
// Non-generic, or open instantiation of a generic type/method
if (IsTransparentMethodSafeToSkipVerification(compileFlags, (MethodDesc*)method))
- compileFlags = (CorJitFlag)(compileFlags | CORJIT_FLG_SKIP_VERIFICATION);
+ compileFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_SKIP_VERIFICATION);
return compileFlags;
case INSTVER_GENERIC_PASSED_VERIFICATION:
// If the typical instantiation is verifiable, there is no need
// to verify the concrete instantiations
- return (CorJitFlag)(compileFlags | CORJIT_FLG_SKIP_VERIFICATION);
+ compileFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_SKIP_VERIFICATION);
+ return compileFlags;
case INSTVER_GENERIC_FAILED_VERIFICATION:
// hits unverifiable code. Since we've already hit unverifiable code,
// there's no point in starting the JIT, just to have it give up, so we
// give up here.
- _ASSERTE(compileFlags & CORJIT_FLG_PREJIT);
+ _ASSERTE(compileFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_PREJIT));
*raiseVerificationException = TRUE;
- return (CorJitFlag)-1; // This value will not be used
+ return CORJIT_FLAGS(); // This value will not be used
}
#else // FEATURE_PREJIT
// Need to have this case here to keep the MAC build happy
// branches while compiling the concrete instantiation. Instead,
// just throw a VerificationException right away.
*raiseVerificationException = TRUE;
- return (CorJitFlag)-1; // This value will not be used
+ return CORJIT_FLAGS(); // This value will not be used
}
case CORINFO_VERIFICATION_CAN_SKIP:
{
- return (CorJitFlag)(compileFlags | CORJIT_FLG_SKIP_VERIFICATION);
+ compileFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_SKIP_VERIFICATION);
+ return compileFlags;
}
case CORINFO_VERIFICATION_RUNTIME_CHECK:
{
- // Compile the method without CORJIT_FLG_SKIP_VERIFICATION.
+ // Compile the method without CORJIT_FLAG_SKIP_VERIFICATION.
// The compiler will know to add a call to
// CORINFO_HELP_VERIFICATION_RUNTIME_CHECK, and then to skip verification.
return compileFlags;
// Calls to this method that occur to check if inlining can occur on x86,
// are OK since they discard the return value of this method.
-PCODE UnsafeJitFunction(MethodDesc* ftn, COR_ILMETHOD_DECODER* ILHeader,
- DWORD flags, DWORD flags2, ULONG * pSizeOfCode)
+PCODE UnsafeJitFunction(MethodDesc* ftn, COR_ILMETHOD_DECODER* ILHeader, CORJIT_FLAGS flags,
+ ULONG * pSizeOfCode)
{
STANDARD_VM_CONTRACT;
ftn->GetModule()->GetDomainFile()->IsZapRequired() &&
PartialNGenStressPercentage() == 0 &&
#ifdef FEATURE_STACK_SAMPLING
- !(flags2 & CORJIT_FLG2_SAMPLING_JIT_BACKGROUND) &&
+ !flags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_SAMPLING_JIT_BACKGROUND) &&
#endif
- !(flags & CORJIT_FLG_IMPORT_ONLY))
+ !flags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_IMPORT_ONLY))
{
StackSString ss(SString::Ascii, "ZapRequire: JIT compiler invoked for ");
TypeString::AppendMethodInternal(ss, ftn);
getMethodInfoHelper(ftn, ftnHnd, ILHeader, &methodInfo);
// If it's generic then we can only enter through an instantiated md (unless we're just verifying it)
- _ASSERTE((flags & CORJIT_FLG_IMPORT_ONLY) != 0 || !ftn->IsGenericMethodDefinition());
+ _ASSERTE(flags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_IMPORT_ONLY) || !ftn->IsGenericMethodDefinition());
// If it's an instance method then it must not be entered from a generic class
- _ASSERTE((flags & CORJIT_FLG_IMPORT_ONLY) != 0 || ftn->IsStatic() ||
+ _ASSERTE(flags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_IMPORT_ONLY) || ftn->IsStatic() ||
ftn->GetNumGenericClassArgs() == 0 || ftn->HasClassInstantiation());
// method attributes and signature are consistant
flags = GetCompileFlags(ftn, flags, &methodInfo);
#ifdef _DEBUG
- if (!(flags & CORJIT_FLG_SKIP_VERIFICATION))
+ if (!flags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_SKIP_VERIFICATION))
{
SString methodString;
if (LoggingOn(LF_VERIFIER, LL_INFO100))
for (;;)
{
#ifndef CROSSGEN_COMPILE
- CEEJitInfo jitInfo(ftn, ILHeader, jitMgr, (flags & CORJIT_FLG_IMPORT_ONLY) != 0);
+ CEEJitInfo jitInfo(ftn, ILHeader, jitMgr, flags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_IMPORT_ONLY));
#else
// This path should be only ever used for verification in crossgen and so we should not need EEJitManager
- _ASSERTE((flags & CORJIT_FLG_IMPORT_ONLY) != 0);
+ _ASSERTE(flags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_IMPORT_ONLY));
CEEInfo jitInfo(ftn, true);
EEJitManager *jitMgr = NULL;
#endif
flags = GetCompileFlagsIfGenericInstantiation(
ftnHnd,
- (CorJitFlag)flags,
+ flags,
&jitInfo,
&raiseVerificationException,
&unverifiableGenericCode);
#ifdef PERF_TRACK_METHOD_JITTIMES
//Because we're not calling QPC enough. I'm not going to track times if we're just importing.
LARGE_INTEGER methodJitTimeStart = {0};
- if (!(flags & CORJIT_FLG_IMPORT_ONLY))
+ if (!flags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_IMPORT_ONLY))
QueryPerformanceCounter (&methodJitTimeStart);
#endif
&jitInfo,
&methodInfo,
flags,
- flags2,
&nativeEntry,
&sizeOfCode,
(MethodDesc*)ftn);
#ifdef PERF_TRACK_METHOD_JITTIMES
//store the time in the string buffer. Module name and token are unique enough. Also, do not
//capture importing time, just actual compilation time.
- if (!(flags & CORJIT_FLG_IMPORT_ONLY))
+ if (!flags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_IMPORT_ONLY))
{
LARGE_INTEGER methodJitTimeStop;
QueryPerformanceCounter(&methodJitTimeStop);
ThrowExceptionForJit(res);
}
- if (flags & CORJIT_FLG_IMPORT_ONLY)
+ if (flags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_IMPORT_ONLY))
{
// The method must been processed by the verifier. Note that it may
// either have been marked as verifiable or unverifiable.
void InitJITHelpers2();
PCODE UnsafeJitFunction(MethodDesc* ftn, COR_ILMETHOD_DECODER* header,
- DWORD flags, DWORD flags2, ULONG* sizeOfCode = NULL);
+ CORJIT_FLAGS flags, ULONG* sizeOfCode = NULL);
void getMethodInfoHelper(MethodDesc * ftn,
CORINFO_METHOD_HANDLE ftnHnd,
);
// Returns that compilation flags that are shared between JIT and NGen
- static DWORD GetBaseCompileFlags(MethodDesc * ftn);
+ static CORJIT_FLAGS GetBaseCompileFlags(MethodDesc * ftn);
// Resolve metadata token into runtime method handles.
void resolveToken(/* IN, OUT */ CORINFO_RESOLVED_TOKEN * pResolvedToken);
static FCDECL3(void, UnsafeSetArrayElement, PtrArray* pPtrArray, INT32 index, Object* object);
};
-DWORD GetDebuggerCompileFlags(Module* pModule, DWORD flags);
+CORJIT_FLAGS GetDebuggerCompileFlags(Module* pModule, CORJIT_FLAGS flags);
bool TrackAllocationsEnabled();
#endif // _VER_EE_VERIFICATION_ENABLED
}
- UnsafeJitFunction(this, pHeader, CORJIT_FLG_IMPORT_ONLY, 0);
+ UnsafeJitFunction(this, pHeader, CORJIT_FLAGS(CORJIT_FLAGS::CORJIT_FLAG_IMPORT_ONLY));
_ASSERTE(IsVerified());
return (IsVerified() && (m_wFlags & mdcVerifiable));
PCODE DoPrestub(MethodTable *pDispatchingMT);
- PCODE MakeJitWorker(COR_ILMETHOD_DECODER* ILHeader, DWORD flags, DWORD flags2);
+ PCODE MakeJitWorker(COR_ILMETHOD_DECODER* ILHeader, CORJIT_FLAGS flags);
VOID GetMethodInfo(SString &namespaceOrClassName, SString &methodName, SString &methodSignature);
VOID GetMethodInfoWithNewSig(SString &namespaceOrClassName, SString &methodName, SString &methodSignature);
EEJitManager *jitMgr = ExecutionManager::GetEEJitManager();
if (jitMgr->LoadJIT())
{
- DWORD cpuCompileFlags = jitMgr->GetCPUCompileFlags();
- if ((cpuCompileFlags & CORJIT_FLG_FEATURE_SIMD) != 0)
+ CORJIT_FLAGS cpuCompileFlags = jitMgr->GetCPUCompileFlags();
+ if (cpuCompileFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_FEATURE_SIMD))
{
unsigned intrinsicSIMDVectorLength = jitMgr->m_jit->getMaxIntrinsicSIMDVectorLength(cpuCompileFlags);
if (intrinsicSIMDVectorLength != 0)
#endif
// MakeJitWorker calls back to MulticoreJitCodeStorage::StoreMethodCode under MethodDesc lock
- pMD->MakeJitWorker(& header, CORJIT_FLG_MCJIT_BACKGROUND, 0);
+ pMD->MakeJitWorker(& header, CORJIT_FLAGS(CORJIT_FLAGS::CORJIT_FLAG_MCJIT_BACKGROUND));
return true;
}
// which prevents us from trying to JIT the same method more that once.
-PCODE MethodDesc::MakeJitWorker(COR_ILMETHOD_DECODER* ILHeader, DWORD flags, DWORD flags2)
+PCODE MethodDesc::MakeJitWorker(COR_ILMETHOD_DECODER* ILHeader, CORJIT_FLAGS flags)
{
STANDARD_VM_CONTRACT;
#ifdef FEATURE_MULTICOREJIT
MulticoreJitManager & mcJitManager = GetAppDomain()->GetMulticoreJitManager();
- bool fBackgroundThread = (flags & CORJIT_FLG_MCJIT_BACKGROUND) != 0;
+ bool fBackgroundThread = flags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_MCJIT_BACKGROUND);
#endif
{
if (!fBackgroundThread)
#endif // FEATURE_MULTICOREJIT
{
- StackSampler::RecordJittingInfo(this, flags, flags2);
+ StackSampler::RecordJittingInfo(this, flags);
}
#endif // FEATURE_STACK_SAMPLING
EX_TRY
{
- pCode = UnsafeJitFunction(this, ILHeader, flags, flags2, &sizeOfCode);
+ pCode = UnsafeJitFunction(this, ILHeader, flags, &sizeOfCode);
}
EX_CATCH
{
// Mark the code as hot in case the method ends up in the native image
g_IBCLogger.LogMethodCodeAccess(this);
- pCode = MakeJitWorker(pHeader, 0, 0);
+ pCode = MakeJitWorker(pHeader, CORJIT_FLAGS());
#ifdef FEATURE_INTERPRETER
if ((pCode != NULL) && !HasStableEntryPoint())
//---------------------------------------------------------------------------------------
// Helpers
-inline DWORD JitFlagsFromProfCodegenFlags(DWORD dwCodegenFlags)
+inline CORJIT_FLAGS JitFlagsFromProfCodegenFlags(DWORD dwCodegenFlags)
{
LIMITED_METHOD_DAC_CONTRACT;
- DWORD jitFlags = 0;
+ CORJIT_FLAGS jitFlags;
// Note: COR_PRF_CODEGEN_DISABLE_INLINING is checked in
// code:CEEInfo::canInline#rejit (it has no equivalent CORJIT flag).
if ((dwCodegenFlags & COR_PRF_CODEGEN_DISABLE_ALL_OPTIMIZATIONS) != 0)
{
- jitFlags |= CORJIT_FLG_DEBUG_CODE;
+ jitFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_DEBUG_CODE);
}
// In the future more flags may be added that need to be converted here (e.g.,
- // COR_PRF_CODEGEN_ENTERLEAVE / CORJIT_FLG_PROF_ENTERLEAVE)
+ // COR_PRF_CODEGEN_ENTERLEAVE / CORJIT_FLAG_PROF_ENTERLEAVE)
return jitFlags;
}
pCodeOfRejittedCode = UnsafeJitFunction(
pInfo->GetMethodDesc(),
&ILHeader,
- JitFlagsFromProfCodegenFlags(pInfo->m_pShared->m_dwCodegenFlags),
- 0);
+ JitFlagsFromProfCodegenFlags(pInfo->m_pShared->m_dwCodegenFlags));
_ASSERTE(pCodeOfRejittedCode != NULL);
//
// An opportunity to record the parameters passed to the JIT at the time of JITting this method.
/* static */
-void StackSampler::RecordJittingInfo(MethodDesc* pMD, DWORD dwFlags, DWORD dwFlags2)
+void StackSampler::RecordJittingInfo(MethodDesc* pMD, CORJIT_FLAGS flags)
{
WRAPPER_NO_CONTRACT;
if (g_pStackSampler == nullptr)
return;
}
// Record in the hash map.
- g_pStackSampler->RecordJittingInfoInternal(pMD, dwFlags);
+ g_pStackSampler->RecordJittingInfoInternal(pMD, flags);
}
-void StackSampler::RecordJittingInfoInternal(MethodDesc* pMD, DWORD dwFlags)
+void StackSampler::RecordJittingInfoInternal(MethodDesc* pMD, CORJIT_FLAGS flags)
{
ADID dwDomainId = GetThread()->GetDomain()->GetId();
JitInfoHashEntry entry(pMD, dwDomainId);
// Indicate to the JIT or the JIT interface that we are JITting
// in the background for stack sampling.
- DWORD dwFlags2 = CORJIT_FLG2_SAMPLING_JIT_BACKGROUND;
+ CORJIT_FLAGS flags(CORJIT_FLAGS::CORJIT_FLAG_SAMPLING_JIT_BACKGROUND);
_ASSERTE(pMD->IsIL());
LOG((LF_JIT, LL_INFO100000, "%s:%s\n", pMD->GetMethodTable()->GetClass()->GetDebugClassName(), pMD->GetName()));
#endif
- PCODE pCode = UnsafeJitFunction(pMD, pDecoder, 0, dwFlags2);
+ PCODE pCode = UnsafeJitFunction(pMD, pDecoder, flags);
}
END_DOMAIN_TRANSITION;
public:
// Interface
static void Init();
- static void RecordJittingInfo(MethodDesc* pMD, DWORD dwFlags, DWORD dwFlags2);
+ static void RecordJittingInfo(MethodDesc* pMD, CORJIT_FLAGS flags);
private:
void JitAndCollectTrace(MethodDesc* pMD, const ADID& adId);
- void RecordJittingInfoInternal(MethodDesc* pMD, DWORD flags);
+ void RecordJittingInfoInternal(MethodDesc* pMD, CORJIT_FLAGS flags);
ADID GetDomainId(MethodDesc* pMD, const ADID& defaultId);
}
}
-static inline void LogOneFlag(DWORD flags, DWORD flag, LPCSTR str, DWORD facility, DWORD level)
-{
- if (flags & flag)
- {
- LOG((facility, level, str));
- }
-}
-
-static void LogJitFlags(DWORD facility, DWORD level, DWORD dwJitFlags)
+static void LogJitFlags(DWORD facility, DWORD level, CORJIT_FLAGS jitFlags)
{
CONTRACTL
{
}
CONTRACTL_END;
- LOG((facility, level, "dwJitFlags: 0x%08x\n", dwJitFlags));
+ LOG((facility, level, "jitFlags:\n"));
-#define LOG_FLAG(name) LogOneFlag(dwJitFlags, name, " " #name "\n", facility, level);
+#define LOG_FLAG(name) \
+ if (jitFlags.IsSet(name)) \
+ { \
+ LOG((facility, level, " " #name "\n")); \
+ jitFlags.Clear(name); \
+ }
// these are all we care about at the moment
- LOG_FLAG(CORJIT_FLG_IL_STUB);
- LOG_FLAG(CORJIT_FLG_PUBLISH_SECRET_PARAM);
+ LOG_FLAG(CORJIT_FLAGS::CORJIT_FLAG_IL_STUB);
+ LOG_FLAG(CORJIT_FLAGS::CORJIT_FLAG_PUBLISH_SECRET_PARAM);
#undef LOG_FLAGS
- DWORD dwKnownMask =
- CORJIT_FLG_IL_STUB |
- CORJIT_FLG_PUBLISH_SECRET_PARAM |
- NULL;
-
- DWORD dwUnknownFlags = dwJitFlags & ~dwKnownMask;
- if (0 != dwUnknownFlags)
+ if (!jitFlags.IsEmpty())
{
- LOG((facility, level, "UNKNOWN FLAGS: 0x%08x\n", dwUnknownFlags));
+ LOG((facility, level, "UNKNOWN FLAGS also set\n"));
}
}
-void ILStubLinker::LogILStub(DWORD dwJitFlags, SString *pDumpILStubCode)
+void ILStubLinker::LogILStub(CORJIT_FLAGS jitFlags, SString *pDumpILStubCode)
{
CONTRACTL
{
INT iCurStack = 0;
if (pDumpILStubCode == NULL)
- LogJitFlags(LF_STUBS, LL_INFO1000, dwJitFlags);
+ LogJitFlags(LF_STUBS, LL_INFO1000, jitFlags);
while (pCurrentStream)
{
#ifdef _DEBUG
if (fStackUnderflow)
{
- LogILStub(NULL);
+ LogILStub(CORJIT_FLAGS());
CONSISTENCY_CHECK_MSG(false, "IL stack underflow! -- see logging output");
}
#endif // _DEBUG
void ClearCodeStreams();
- void LogILStub(DWORD dwJitFlags, SString *pDumpILStubCode = NULL);
+ void LogILStub(CORJIT_FLAGS jitFlags, SString *pDumpILStubCode = NULL);
protected:
void LogILStubWorker(ILInstruction* pInstrBuffer, UINT numInstr, size_t* pcbCode, INT* piCurStack, SString *pDumpILStubCode = NULL);
void LogILInstruction(size_t curOffset, bool isLabeled, INT iCurStack, ILInstruction* pInstruction, SString *pDumpILStubCode = NULL);
#define CACHE_PARTITION_BITS 0x003FF000 // number of cache Physical Partitions is returned in EBX[21:12] (10 bits) using cpuid function 4
#define CACHE_LINESIZE_BITS 0x00000FFF // Linesize returned in EBX[11:0] (12 bits) using cpuid function 4
-#if defined(_TARGET_X86_)
- // these are defined in cgenx86.cpp
- extern DWORD getcpuid(DWORD arg1, unsigned char result[16]);
- extern DWORD getextcpuid(DWORD arg1, DWORD arg2, unsigned char result[16]);
-#elif defined(_TARGET_AMD64_)
- // these are defined in src\VM\AMD64\asmhelpers.asm
- extern "C" DWORD __stdcall getcpuid(DWORD arg1, unsigned char result[16]);
- extern "C" DWORD __stdcall getextcpuid(DWORD arg1, DWORD arg2, unsigned char result[16]);
-#endif
-
+// these are defined in src\VM\AMD64\asmhelpers.asm / cgenx86.cpp
+extern "C" DWORD __stdcall getcpuid(DWORD arg1, unsigned char result[16]);
+extern "C" DWORD __stdcall getextcpuid(DWORD arg1, DWORD arg2, unsigned char result[16]);
// The following function uses a deterministic mechanism for enumerating/calculating the details of the cache hierarychy at runtime
// by using deterministic cache parameter leafs on Prescott and higher processors.
//
// If we're instrumenting allocate a section for writing profile data
//
- if (m_zapper->m_pOpt->m_compilerFlags & CORJIT_FLG_BBINSTR)
+ if (m_zapper->m_pOpt->m_compilerFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_BBINSTR))
{
m_pInstrumentSection = NewVirtualSection(pDataSection, IBCUnProfiledSection | ColdRange | InstrumentSection, sizeof(TADDR));
}
//-----------------------------------------------------------------------------
// static void __stdcall
-void ZapImage::TryCompileMethodStub(LPVOID pContext, CORINFO_METHOD_HANDLE hStub, DWORD dwJitFlags)
+void ZapImage::TryCompileMethodStub(LPVOID pContext, CORINFO_METHOD_HANDLE hStub, CORJIT_FLAGS jitFlags)
{
STANDARD_VM_CONTRACT;
// The caller must always set the IL_STUB flag
- _ASSERTE((dwJitFlags & CORJIT_FLG_IL_STUB) != 0);
+ _ASSERTE(jitFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_IL_STUB));
CompileMethodStubContext *pCompileContext = reinterpret_cast<CompileMethodStubContext *>(pContext);
ZapImage *pImage = pCompileContext->pImage;
- unsigned oldFlags = pImage->m_zapper->m_pOpt->m_compilerFlags;
+ CORJIT_FLAGS oldFlags = pImage->m_zapper->m_pOpt->m_compilerFlags;
- pImage->m_zapper->m_pOpt->m_compilerFlags |= dwJitFlags;
- pImage->m_zapper->m_pOpt->m_compilerFlags &= ~(CORJIT_FLG_PROF_ENTERLEAVE |
- CORJIT_FLG_DEBUG_CODE |
- CORJIT_FLG_DEBUG_EnC |
- CORJIT_FLG_DEBUG_INFO);
+ CORJIT_FLAGS* pCompilerFlags = &pImage->m_zapper->m_pOpt->m_compilerFlags;
+ pCompilerFlags->Add(jitFlags);
+ pCompilerFlags->Clear(CORJIT_FLAGS::CORJIT_FLAG_PROF_ENTERLEAVE);
+ pCompilerFlags->Clear(CORJIT_FLAGS::CORJIT_FLAG_DEBUG_CODE);
+ pCompilerFlags->Clear(CORJIT_FLAGS::CORJIT_FLAG_DEBUG_EnC);
+ pCompilerFlags->Clear(CORJIT_FLAGS::CORJIT_FLAG_DEBUG_INFO);
mdMethodDef md = mdMethodDefNil;
if (GetCompiledMethod(handle) != NULL)
return ALREADY_COMPILED;
- _ASSERTE((m_zapper->m_pOpt->m_compilerFlags & CORJIT_FLG_IL_STUB) || IsNilToken(md) || handle == m_pPreloader->LookupMethodDef(md));
+ _ASSERTE(m_zapper->m_pOpt->m_compilerFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_IL_STUB) || IsNilToken(md) || handle == m_pPreloader->LookupMethodDef(md));
CompileStatus result = NOT_COMPILED;
CORINFO_MODULE_HANDLE module;
// We only compile IL_STUBs from the current assembly
- if (m_zapper->m_pOpt->m_compilerFlags & CORJIT_FLG_IL_STUB)
+ if (m_zapper->m_pOpt->m_compilerFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_IL_STUB))
module = m_hModule;
else
module = m_zapper->m_pEEJitInfo->getMethodModule(handle);
if (m_stats != NULL)
{
- if ((m_zapper->m_pOpt->m_compilerFlags & CORJIT_FLG_IL_STUB) == 0)
+ if (!m_zapper->m_pOpt->m_compilerFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_IL_STUB))
m_stats->m_failedMethods++;
else
m_stats->m_failedILStubs++;
// the final image.
//
#if 0
- if ((m_zapper->m_pOpt->m_compilerFlags & CORJIT_FLG_BBINSTR) != 0)
+ if (m_zapper->m_pOpt->m_compilerFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_BBINSTR))
return S_FALSE;
#endif
// No direct calls at all under some circumstances
- if ((m_zapper->m_pOpt->m_compilerFlags & CORJIT_FLG_PROF_ENTERLEAVE)
+ if (m_zapper->m_pOpt->m_compilerFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_PROF_ENTERLEAVE)
&& !m_pPreloader->IsDynamicMethod(callerFtn))
{
*pReason = CORINFO_INDIRECT_CALL_PROFILING;
NOT_COMPILED = 0, COMPILE_EXCLUDED = 1, // Info
COMPILE_SUCCEED = 10, ALREADY_COMPILED = 11}; // Success
- static void __stdcall TryCompileMethodStub(LPVOID pContext, CORINFO_METHOD_HANDLE hStub, DWORD dwJitFlags);
+ static void __stdcall TryCompileMethodStub(LPVOID pContext, CORINFO_METHOD_HANDLE hStub, CORJIT_FLAGS jitFlags);
BOOL IsVTableGapMethod(mdMethodDef md);
m_currentMethodName.AppendUTF8(szMethodName);
}
-int ZapInfo::ComputeJitFlags(CORINFO_METHOD_HANDLE handle)
+CORJIT_FLAGS ZapInfo::ComputeJitFlags(CORINFO_METHOD_HANDLE handle)
{
- int jitFlags = m_zapper->m_pOpt->m_compilerFlags;
+ CORJIT_FLAGS jitFlags = m_zapper->m_pOpt->m_compilerFlags;
- DWORD flags = 0;
+ CORJIT_FLAGS flags;
IfFailThrow(m_pEECompileInfo->GetBaseJitFlags(handle, &flags));
- jitFlags |= flags;
+ jitFlags.Add(flags);
// COMPlus_JitFramed specifies the default fpo setting for jitted and NGened code.
// You can override the behavior for NGened code using COMPlus_NGenFramed.
if (dwNGenFramed == 0)
{
// NGened code should enable fpo
- jitFlags &= ~CORJIT_FLG_FRAMED;
+ jitFlags.Clear(CORJIT_FLAGS::CORJIT_FLAG_FRAMED);
}
else if (dwNGenFramed == 1)
{
// NGened code should disable fpo
- jitFlags |= CORJIT_FLG_FRAMED;
+ jitFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_FRAMED);
}
if (canSkipMethodVerification(m_currentMethodHandle) == CORINFO_VERIFICATION_CAN_SKIP)
{
- jitFlags |= CORJIT_FLG_SKIP_VERIFICATION;
+ jitFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_SKIP_VERIFICATION);
}
if (m_pImage->m_profileDataSections[MethodBlockCounts].pData &&
!m_zapper->m_pOpt->m_ignoreProfileData)
{
- jitFlags |= CORJIT_FLG_BBOPT;
+ jitFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_BBOPT);
}
//
// By default we always enable Hot/Cold procedure splitting
//
- jitFlags |= CORJIT_FLG_PROCSPLIT;
+ jitFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_PROCSPLIT);
if (m_zapper->m_pOpt->m_noProcedureSplitting)
- jitFlags &= ~CORJIT_FLG_PROCSPLIT;
+ jitFlags.Clear(CORJIT_FLAGS::CORJIT_FLAG_PROCSPLIT);
//never emit inlined polls for NGen'd code. The extra indirection is not optimal.
- if (jitFlags & CORJIT_FLG_GCPOLL_INLINE)
+ if (jitFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_GCPOLL_INLINE))
{
- jitFlags &= ~CORJIT_FLG_GCPOLL_INLINE;
- jitFlags |= CORJIT_FLG_GCPOLL_CALLS;
+ jitFlags.Clear(CORJIT_FLAGS::CORJIT_FLAG_GCPOLL_INLINE);
+ jitFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_GCPOLL_CALLS);
}
// If the method is specified for min-opts then turn everything off
- if (jitFlags & CORJIT_FLG_MIN_OPT)
- jitFlags &= ~(CORJIT_FLG_BBINSTR | CORJIT_FLG_BBOPT | CORJIT_FLG_PROCSPLIT);
+ if (jitFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_MIN_OPT))
+ {
+ jitFlags.Clear(CORJIT_FLAGS::CORJIT_FLAG_BBINSTR);
+ jitFlags.Clear(CORJIT_FLAGS::CORJIT_FLAG_BBOPT);
+ jitFlags.Clear(CORJIT_FLAGS::CORJIT_FLAG_PROCSPLIT);
+ }
// Rejit is now enabled by default for NGEN'ed code. This costs us
// some size in exchange for diagnostic functionality, but we've got
// further work planned that should mitigate the size increase.
- jitFlags |= CORJIT_FLG_PROF_REJIT_NOPS;
+ jitFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_PROF_REJIT_NOPS);
#ifdef FEATURE_READYTORUN_COMPILER
if (IsReadyToRunCompilation())
- jitFlags |= CORJIT_FLG_READYTORUN;
+ jitFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_READYTORUN);
#endif
return jitFlags;
// this they can add the hint and reduce the perf cost at runtime.
m_pImage->m_pPreloader->PrePrepareMethodIfNecessary(m_currentMethodHandle);
- m_jitFlags = { 0 };
- m_jitFlags.corJitFlags = ComputeJitFlags(m_currentMethodHandle);
+ m_jitFlags = ComputeJitFlags(m_currentMethodHandle);
#ifdef FEATURE_READYTORUN_COMPILER
if (IsReadyToRunCompilation())
{
// READYTORUN: FUTURE: Producedure spliting
- m_jitFlags.corJitFlags &= ~CORJIT_FLG_PROCSPLIT;
+ m_jitFlags.Clear(CORJIT_FLAGS::CORJIT_FLAG_PROCSPLIT);
DWORD methodAttribs = getMethodAttribs(m_currentMethodHandle);
if (!(methodAttribs & CORINFO_FLG_NOSECURITYWRAP) || (methodAttribs & CORINFO_FLG_SECURITYCHECK))
}
#endif
- if ((m_jitFlags.corJitFlags & CORJIT_FLG_SKIP_VERIFICATION) == 0)
+ if (!m_jitFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_SKIP_VERIFICATION))
{
BOOL raiseVerificationException, unverifiableGenericCode;
- m_jitFlags.corJitFlags = GetCompileFlagsIfGenericInstantiation(
+ m_jitFlags = GetCompileFlagsIfGenericInstantiation(
m_currentMethodHandle,
- (CorJitFlag)m_jitFlags.corJitFlags,
+ m_jitFlags,
this,
&raiseVerificationException,
&unverifiableGenericCode);
#if !defined(FEATURE_CORECLR)
// Ask the JIT to generate desktop-quirk-compatible code.
- m_jitFlags.corJitFlags2 |= CORJIT_FLG2_DESKTOP_QUIRKS;
+ m_jitFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_DESKTOP_QUIRKS);
#endif
if (m_pImage->m_stats)
res = m_zapper->m_alternateJit->compileMethod( this,
&m_currentMethodInfo,
- CORJIT_FLG_CALL_GETJITFLAGS,
+ CORJIT_FLAGS::CORJIT_FLAG_CALL_GETJITFLAGS,
&pCode,
&cCode );
if (FAILED(res))
ICorJitCompiler * pCompiler = m_zapper->m_pJitCompiler;
res = pCompiler->compileMethod(this,
&m_currentMethodInfo,
- CORJIT_FLG_CALL_GETJITFLAGS,
+ CORJIT_FLAGS::CORJIT_FLAG_CALL_GETJITFLAGS,
&pCode,
&cCode);
//
// For now, the only methods eligible for de-duplication are IL stubs
//
- if (m_zapper->m_pOpt->m_compilerFlags & CORJIT_FLG_IL_STUB)
+ if (m_zapper->m_pOpt->m_compilerFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_IL_STUB))
{
ZapMethodHeader * pDuplicateMethod = m_pImage->m_CodeDeduplicator.Lookup(pMethod);
if (pDuplicateMethod != NULL)
// Stubs that have no metadata token cannot be tracked by IBC data.
if (m_currentMethodProfilingDataFlags & (1 << ReadMethodCode))
{
- if (m_zapper->m_pOpt->m_compilerFlags & CORJIT_FLG_IL_STUB)
+ if (m_zapper->m_pOpt->m_compilerFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_IL_STUB))
m_pImage->m_PrioritizedGCInfo.Append(pMethod->m_pGCInfo);
}
{
HRESULT hr;
- if (m_zapper->m_pOpt->m_compilerFlags & CORJIT_FLG_IL_STUB)
+ if (m_zapper->m_pOpt->m_compilerFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_IL_STUB))
{
*ppBlock = NULL;
return E_NOTIMPL;
// the profile data is in that module
// @TODO: Fetch the profile data from the other module.
if ((m_currentMethodModule != m_pImage->m_hModule) ||
- (m_zapper->m_pOpt->m_compilerFlags & CORJIT_FLG_IL_STUB))
+ m_zapper->m_pOpt->m_compilerFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_IL_STUB))
{
return E_FAIL;
}
void ** roDataBlock /* OUT */
)
{
- bool optForSize = ((m_zapper->m_pOpt->m_compilerFlags & CORJIT_FLG_SIZE_OPT) == CORJIT_FLG_SIZE_OPT);
+ bool optForSize = m_zapper->m_pOpt->m_compilerFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_SIZE_OPT);
UINT align = DEFAULT_CODE_ALIGN;
{
ilClause->ClassToken = clause->ClassToken;
- if ((m_zapper->m_pOpt->m_compilerFlags & CORJIT_FLG_IL_STUB) && (clause->ClassToken != 0))
+ if (m_zapper->m_pOpt->m_compilerFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_IL_STUB) && (clause->ClassToken != 0))
{
// IL stub tokens are 'private' and do not resolve correctly in their parent module's metadata.
m_pImage->m_pPreloader->AddTypeToTransitiveClosureOfInstantiations(cls);
- if(!(m_zapper->m_pOpt->m_compilerFlags & CORJIT_FLG_DEBUG_CODE))
+ if (!m_zapper->m_pOpt->m_compilerFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_DEBUG_CODE))
{
if (isRIDClassDomainID(cls))
{
{
// ILStubs are generated internally by the CLR. There is no need to
// verify it, or any of its callees.
- if (m_zapper->m_pOpt->m_compilerFlags & CORJIT_FLG_IL_STUB)
+ if (m_zapper->m_pOpt->m_compilerFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_IL_STUB))
return CORINFO_VERIFICATION_CAN_SKIP;
CorInfoCanSkipVerificationResult canSkipVer =
void InitMethodName();
- int ComputeJitFlags(CORINFO_METHOD_HANDLE handle);
+ CORJIT_FLAGS ComputeJitFlags(CORINFO_METHOD_HANDLE handle);
ZapDebugInfo * EmitDebugInfo();
ZapGCInfo * EmitGCInfo();
// unless we're producing an instrumented version - the IBC logging for meta data doesn't
// work for the hot/cold split version.
- if (m_pImage->m_zapper->m_pOpt->m_compilerFlags & CORJIT_FLG_BBINSTR)
+ if (m_pImage->m_zapper->m_pOpt->m_compilerFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_BBINSTR))
IfFailThrow(pIMetaDataCorProfileData->SetCorProfileData(NULL));
else
IfFailThrow(pIMetaDataCorProfileData->SetCorProfileData(m_pImage->GetProfileData()));
// If we are ngening with the tuning option, the IBC data that is
// generated gets reordered and may be inconsistent with the
// metadata in the original IL image. Let's just skip that case.
- if (!(m_pImage->m_zapper->m_pOpt->m_compilerFlags & CORJIT_FLG_BBINSTR))
+ if (!m_pImage->m_zapper->m_pOpt->m_compilerFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_BBINSTR))
{
// Communicate the reordering option for saving
NonVMComHolder<IMDInternalMetadataReorderingOptions> pIMDInternalMetadataReorderingOptions;
m_fPartialNGen(false),
m_fPartialNGenSet(false),
m_fNGenLastRetry(false),
- m_compilerFlags(CORJIT_FLG_RELOC | CORJIT_FLG_PREJIT),
+ m_compilerFlags(),
m_legacyMode(false)
#ifdef FEATURE_CORECLR
,m_fNoMetaData(s_fNGenNoMetaData)
#endif
{
+ m_compilerFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_RELOC);
+ m_compilerFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_PREJIT);
+
m_zapSet = CLRConfig::GetConfigValue(CLRConfig::EXTERNAL_ZapSet);
if (m_zapSet != NULL && wcslen(m_zapSet) > 3)
{
pOptions = ¤tVersionOptions;
- zo->m_compilerFlags = CORJIT_FLG_RELOC | CORJIT_FLG_PREJIT;
+ zo->m_compilerFlags.Reset();
+ zo->m_compilerFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_RELOC);
+ zo->m_compilerFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_PREJIT);
zo->m_autodebug = true;
if (pOptions->fDebug)
{
- zo->m_compilerFlags |= CORJIT_FLG_DEBUG_INFO|CORJIT_FLG_DEBUG_CODE;
+ zo->m_compilerFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_DEBUG_INFO);
+ zo->m_compilerFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_DEBUG_CODE);
zo->m_autodebug = false;
}
if (pOptions->fProf)
{
- zo->m_compilerFlags |= CORJIT_FLG_PROF_ENTERLEAVE;
+ zo->m_compilerFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_PROF_ENTERLEAVE);
}
#ifdef FEATURE_FUSION
#endif //FEATURE_FUSION
if (pOptions->fInstrument)
- zo->m_compilerFlags |= CORJIT_FLG_BBINSTR;
+ zo->m_compilerFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_BBINSTR);
zo->m_verbose = pOptions->fVerbose;
zo->m_statOptions = pOptions->uStats;
BOOL fForceDebug = FALSE;
if (!m_pOpt->m_autodebug)
- fForceDebug = (m_pOpt->m_compilerFlags & CORJIT_FLG_DEBUG_INFO) != 0;
+ fForceDebug = m_pOpt->m_compilerFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_DEBUG_INFO);
- BOOL fForceProfile = (m_pOpt->m_compilerFlags & CORJIT_FLG_PROF_ENTERLEAVE) != 0;
- BOOL fForceInstrument = (m_pOpt->m_compilerFlags & CORJIT_FLG_BBINSTR) != 0;
+ BOOL fForceProfile = m_pOpt->m_compilerFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_PROF_ENTERLEAVE);
+ BOOL fForceInstrument = m_pOpt->m_compilerFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_BBINSTR);
InitEE(fForceDebug, fForceProfile, fForceInstrument);
void Zapper::InitializeCompilerFlags(CORCOMPILE_VERSION_INFO * pVersionInfo)
{
- m_pOpt->m_compilerFlags &= ~(CORJIT_FLG_DEBUG_INFO
- | CORJIT_FLG_DEBUG_CODE
- | CORJIT_FLG_PROF_ENTERLEAVE
- | CORJIT_FLG_PROF_NO_PINVOKE_INLINE);
+ m_pOpt->m_compilerFlags.Clear(CORJIT_FLAGS::CORJIT_FLAG_DEBUG_INFO);
+ m_pOpt->m_compilerFlags.Clear(CORJIT_FLAGS::CORJIT_FLAG_DEBUG_CODE);
+ m_pOpt->m_compilerFlags.Clear(CORJIT_FLAGS::CORJIT_FLAG_PROF_ENTERLEAVE);
+ m_pOpt->m_compilerFlags.Clear(CORJIT_FLAGS::CORJIT_FLAG_PROF_NO_PINVOKE_INLINE);
// We track debug info all the time in the ngen image
- m_pOpt->m_compilerFlags |= CORJIT_FLG_DEBUG_INFO;
+ m_pOpt->m_compilerFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_DEBUG_INFO);
if (pVersionInfo->wCodegenFlags & CORCOMPILE_CODEGEN_DEBUGGING)
{
- m_pOpt->m_compilerFlags |= (CORJIT_FLG_DEBUG_INFO|
- CORJIT_FLG_DEBUG_CODE);
+ m_pOpt->m_compilerFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_DEBUG_INFO);
+ m_pOpt->m_compilerFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_DEBUG_CODE);
}
if (pVersionInfo->wCodegenFlags & CORCOMPILE_CODEGEN_PROFILING)
{
- m_pOpt->m_compilerFlags |= CORJIT_FLG_PROF_ENTERLEAVE | CORJIT_FLG_PROF_NO_PINVOKE_INLINE;
+ m_pOpt->m_compilerFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_PROF_ENTERLEAVE);
+ m_pOpt->m_compilerFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_PROF_NO_PINVOKE_INLINE);
m_pOpt->m_ngenProfileImage = true;
}
if (pVersionInfo->wCodegenFlags & CORCOMPILE_CODEGEN_PROF_INSTRUMENTING)
- m_pOpt->m_compilerFlags |= CORJIT_FLG_BBINSTR;
+ m_pOpt->m_compilerFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_BBINSTR);
#if defined(_TARGET_X86_)
switch (CPU_X86_FAMILY(pVersionInfo->cpuInfo.dwCPUType))
{
case CPU_X86_PENTIUM_4:
- m_pOpt->m_compilerFlags |= CORJIT_FLG_TARGET_P4;
+ m_pOpt->m_compilerFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_TARGET_P4);
break;
default:
if (CPU_X86_USE_CMOV(pVersionInfo->cpuInfo.dwFeatures))
{
- m_pOpt->m_compilerFlags |= CORJIT_FLG_USE_CMOV |
- CORJIT_FLG_USE_FCOMI;
+ m_pOpt->m_compilerFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_USE_CMOV);
+ m_pOpt->m_compilerFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_USE_FCOMI);
}
if (CPU_X86_USE_SSE2(pVersionInfo->cpuInfo.dwFeatures))
{
- m_pOpt->m_compilerFlags |= CORJIT_FLG_USE_SSE2;
+ m_pOpt->m_compilerFlags.Set(CORJIT_FLAGS::CORJIT_FLAG_USE_SSE2);
}
#endif // _TARGET_X86_
- if ( (m_pOpt->m_compilerFlags & CORJIT_FLG_DEBUG_INFO)
- && (m_pOpt->m_compilerFlags & CORJIT_FLG_DEBUG_CODE)
- && (m_pOpt->m_compilerFlags & CORJIT_FLG_PROF_ENTERLEAVE))
+ if ( m_pOpt->m_compilerFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_DEBUG_INFO)
+ && m_pOpt->m_compilerFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_DEBUG_CODE)
+ && m_pOpt->m_compilerFlags.IsSet(CORJIT_FLAGS::CORJIT_FLAG_PROF_ENTERLEAVE))
{
//
// We've decided not to support debugging + optimizations disabled + profiling to
projects / platform / upstream / dotnet / runtime.git / commitdiff