diff options
Diffstat (limited to 'src/jit')
39 files changed, 775 insertions, 392 deletions
diff --git a/src/jit/CMakeLists.txt b/src/jit/CMakeLists.txt index e8c7204715..305c54a1c6 100644 --- a/src/jit/CMakeLists.txt +++ b/src/jit/CMakeLists.txt @@ -31,6 +31,7 @@ set( JIT_SOURCES hashbv.cpp importer.cpp instr.cpp + jitconfig.cpp jittelemetry.cpp lclvars.cpp liveness.cpp diff --git a/src/jit/alloc.cpp b/src/jit/alloc.cpp index 4ca13cdbd4..cc27c83fd0 100644 --- a/src/jit/alloc.cpp +++ b/src/jit/alloc.cpp @@ -65,8 +65,7 @@ bool norls_allocator::nraInit(IEEMemoryManager* pMemoryManager, size_t pageSiz nraPageSize = pageSize ? pageSize : THE_ALLOCATOR_BASE_SIZE; #ifdef DEBUG - static ConfigDWORD fShouldInjectFault; - nraShouldInjectFault = fShouldInjectFault.val(CLRConfig::INTERNAL_InjectFault) != 0; + nraShouldInjectFault = JitConfig.ShouldInjectFault() != 0; #endif if (preAlloc) diff --git a/src/jit/alloc.h b/src/jit/alloc.h index 601b98455f..11bb1f8d72 100644 --- a/src/jit/alloc.h +++ b/src/jit/alloc.h @@ -208,8 +208,7 @@ inline bool norls_allocator::nraDirectAlloc() // directly to the OS. This allows taking advantage of pageheap and other gflag // knobs for ensuring that we do not have buffer overruns in the JIT. - static ConfigDWORD fJitDirectAlloc; - return (fJitDirectAlloc.val(CLRConfig::INTERNAL_JitDirectAlloc) != 0); + return JitConfig.JitDirectAlloc() != 0; } #else // RELEASE diff --git a/src/jit/block.cpp b/src/jit/block.cpp index 30211d6a9f..0103988318 100644 --- a/src/jit/block.cpp +++ b/src/jit/block.cpp @@ -37,8 +37,7 @@ flowList* ShuffleHelper(unsigned hash, flowList* res) unsigned SsaStressHashHelper() { // hash = 0: turned off, hash = 1: use method hash, hash = *: use custom hash. - static ConfigDWORD fJitSsaStress; - unsigned hash = fJitSsaStress.val(CLRConfig::INTERNAL_JitSsaStress); + unsigned hash = JitConfig.JitSsaStress(); if (hash == 0) { diff --git a/src/jit/codegencommon.cpp b/src/jit/codegencommon.cpp index b8eee4dbba..06df590c75 100644 --- a/src/jit/codegencommon.cpp +++ b/src/jit/codegencommon.cpp @@ -3035,11 +3035,9 @@ void CodeGen::genGenerateCode(void * * codePtr, { // Use COMPLUS_JitNoForceFallback=1 to prevent NOWAY assert testing from happening, // especially that caused by enabling JIT stress. - static ConfigDWORD fJitNoForceFallback; - if (!fJitNoForceFallback.val(CLRConfig::INTERNAL_JitNoForceFallback)) + if (!JitConfig.JitNoForceFallback()) { - static ConfigDWORD fJitForceFallback; - if (fJitForceFallback.val(CLRConfig::INTERNAL_JitForceFallback) || + if (JitConfig.JitForceFallback() || compiler->compStressCompile(Compiler::STRESS_GENERIC_VARN, 5) ) { NO_WAY_NOASSERT("Stress failure"); diff --git a/src/jit/codegenlegacy.cpp b/src/jit/codegenlegacy.cpp index 57807fb846..846f51df05 100644 --- a/src/jit/codegenlegacy.cpp +++ b/src/jit/codegenlegacy.cpp @@ -6209,8 +6209,7 @@ bool CodeGen::genCodeForQmarkWithCMOV(GenTreePtr tree, noway_assert(colon->gtOper == GT_COLON); #ifdef DEBUG - static ConfigDWORD fJitNoCMOV; - if (fJitNoCMOV.val(CLRConfig::INTERNAL_JitNoCMOV)) + if (JitConfig.JitNoCMOV()) { return false; } @@ -12254,8 +12253,7 @@ void CodeGen::genCodeForTreeSpecialOp(GenTreePtr tree, #ifdef FEATURE_ENABLE_NO_RANGE_CHECKS // MUST NEVER CHECK-IN WITH THIS ENABLED. // This is just for convenience in doing performance investigations and requires x86ret builds - static ConfigDWORD fJitNoRngChk; - if (!fJitNoRngChk.val(CLRConfig::PRIVATE_JitNoRangeChks)) + if (!JitConfig.JitNoRngChk()) #endif genRangeCheck(tree); } diff --git a/src/jit/compiler.cpp b/src/jit/compiler.cpp index 71312bc61f..074540b00b 100644 --- a/src/jit/compiler.cpp +++ b/src/jit/compiler.cpp @@ -58,6 +58,7 @@ LONG Compiler::jitNestingLevel = 0; #ifdef ALT_JIT // static +bool Compiler::s_pAltJitExcludeAssembliesListInitialized = false; AssemblyNamesList2* Compiler::s_pAltJitExcludeAssembliesList = nullptr; #endif // ALT_JIT @@ -758,8 +759,7 @@ void Compiler::compShutdown() #if defined(DEBUG) || MEASURE_INLINING #ifdef DEBUG - static ConfigDWORD fJitInlinePrintStats; - if ((unsigned)fJitInlinePrintStats.val(CLRConfig::INTERNAL_JitInlinePrintStats) == 1) + if ((unsigned)JitConfig.JitInlinePrintStats() == 1) #endif // DEBUG { fprintf(fout, "\n"); @@ -1023,8 +1023,7 @@ void Compiler::compShutdown() #if LOOP_HOIST_STATS #ifdef DEBUG // Always display loop stats in retail - static ConfigDWORD fDisplayLoopHoistStats; - if (fDisplayLoopHoistStats.val(CLRConfig::INTERNAL_JitLoopHoistStats) != 0) + if (JitConfig.DisplayLoopHoistStats() != 0) #endif // DEBUG { PrintAggregateLoopHoistStats(stdout); @@ -1526,8 +1525,7 @@ static bool DidComponentUnitTests = false; void Compiler::compDoComponentUnitTestsOnce() { - static ConfigDWORD fRunComponentUnitTests; - if (!fRunComponentUnitTests.val(CLRConfig::INTERNAL_JitComponentUnitTests)) + if (!JitConfig.RunComponentUnitTests()) return; if (!DidComponentUnitTests) @@ -1853,8 +1851,7 @@ void Compiler::compSetProcessor() if (((compileFlags & CORJIT_FLG_PREJIT) == 0) && ((compileFlags & CORJIT_FLG_USE_AVX2) != 0)) { - static ConfigDWORD fEnableAVX; - if (fEnableAVX.val(CLRConfig::EXTERNAL_EnableAVX) != 0) + if (JitConfig.EnableAVX() != 0) { opts.compCanUseAVX = true; if (!compIsForInlining()) @@ -1885,11 +1882,9 @@ void Compiler::compSetProcessor() SSE2_FORCE_INVALID = -1 }; - static ConfigDWORD fJitCanUseSSE2; - - if (fJitCanUseSSE2.val_DontUse_(CLRConfig::INTERNAL_JitCanUseSSE2, (unsigned) SSE2_FORCE_INVALID) == SSE2_FORCE_DISABLE) + if (JitConfig.JitCanUseSSE2() == SSE2_FORCE_DISABLE) opts.compCanUseSSE2 = false; - else if (fJitCanUseSSE2.val_DontUse_(CLRConfig::INTERNAL_JitCanUseSSE2, (unsigned) SSE2_FORCE_INVALID) == SSE2_FORCE_USE) + else if (JitConfig.JitCanUseSSE2() == SSE2_FORCE_USE) opts.compCanUseSSE2 = true; else if (opts.compCanUseSSE2) opts.compCanUseSSE2 = !compStressCompile(STRESS_GENERIC_VARN, 50); @@ -1938,8 +1933,8 @@ bool Compiler::compShouldThrowOnNoway( return !opts.MinOpts() || !compIsFullTrust(); } -// ConfigDWORD does not offer an option for decimal flags. Any numbers are interpreted as hex. -// I could add the decimal option to ConfigDWORD or I could write a function to reinterpret this +// ConfigInteger does not offer an option for decimal flags. Any numbers are interpreted as hex. +// I could add the decimal option to ConfigInteger or I could write a function to reinterpret this // value as the user intended. unsigned ReinterpretHexAsDecimal(unsigned in) { @@ -2059,20 +2054,14 @@ void Compiler::compInitOptions(CORJIT_FLAGS* jitFlags) #ifdef DEBUG - ConfigMethodSet* pfAltJit; + const JitConfigValues::MethodSet* pfAltJit; if (opts.eeFlags & CORJIT_FLG_PREJIT) { - static ConfigMethodSet fAltJitNgen; - fAltJitNgen.ensureInit(CLRConfig::INTERNAL_AltJitNgen); - - pfAltJit = &fAltJitNgen; + pfAltJit = &JitConfig.AltJitNgen(); } else { - static ConfigMethodSet fAltJit; - fAltJit.ensureInit(CLRConfig::EXTERNAL_AltJit); - - pfAltJit = &fAltJit; + pfAltJit = &JitConfig.AltJit(); } #ifdef ALT_JIT @@ -2081,8 +2070,7 @@ void Compiler::compInitOptions(CORJIT_FLAGS* jitFlags) opts.altJit = true; } - static ConfigDWORD fAltJitLimit; - unsigned altJitLimit = ReinterpretHexAsDecimal(fAltJitLimit.val(CLRConfig::INTERNAL_AltJitLimit)); + unsigned altJitLimit = ReinterpretHexAsDecimal(JitConfig.AltJitLimit()); if (altJitLimit > 0 && Compiler::jitTotalMethodCompiled >= altJitLimit) { opts.altJit = false; @@ -2091,16 +2079,14 @@ void Compiler::compInitOptions(CORJIT_FLAGS* jitFlags) #else // !DEBUG - LPWSTR altJitVal; + const char* altJitVal; if (opts.eeFlags & CORJIT_FLG_PREJIT) { - static ConfigString fAltJitNgen; - altJitVal = fAltJitNgen.val(CLRConfig::INTERNAL_AltJitNgen); + altJitVal = JitConfig.AltJitNgen().list(); } else { - static ConfigString fAltJit; - altJitVal = fAltJit.val(CLRConfig::EXTERNAL_AltJit); + altJitVal = JitConfig.AltJit().list(); } #ifdef ALT_JIT @@ -2108,7 +2094,7 @@ void Compiler::compInitOptions(CORJIT_FLAGS* jitFlags) // You don't get to give a regular expression of methods to match. // (Partially, this is because we haven't computed and stored the method and class name except in debug, and it // might be expensive to do so.) - if ((altJitVal != NULL) && (wcscmp(altJitVal, W("*")) == 0)) + if ((altJitVal != nullptr) && (strcmp(altJitVal, "*") == 0)) { opts.altJit = true; } @@ -2121,16 +2107,16 @@ void Compiler::compInitOptions(CORJIT_FLAGS* jitFlags) if (opts.altJit) { // First, initialize the AltJitExcludeAssemblies list, but only do it once. - static ConfigString fAltJitExcludeAssemblies; - if (!fAltJitExcludeAssemblies.isInitialized()) + if (!s_pAltJitExcludeAssembliesListInitialized) { - LPWSTR wszAltJitExcludeAssemblyList = fAltJitExcludeAssemblies.val(CLRConfig::EXTERNAL_AltJitExcludeAssemblies); + const wchar_t* wszAltJitExcludeAssemblyList = JitConfig.AltJitExcludeAssemblies(); if (wszAltJitExcludeAssemblyList != nullptr) { // NOTE: The Assembly name list is allocated in the process heap, not in the no-release heap, which is reclaimed // for every compilation. This is ok because we only allocate once, due to the static. s_pAltJitExcludeAssembliesList = new (ProcessHeapAllocator::Singleton()) AssemblyNamesList2(wszAltJitExcludeAssemblyList, ProcessHeapAllocator::Singleton()); } + s_pAltJitExcludeAssembliesListInitialized = true; } if (s_pAltJitExcludeAssembliesList != nullptr) @@ -2158,9 +2144,7 @@ void Compiler::compInitOptions(CORJIT_FLAGS* jitFlags) // if (compIsForImportOnly() && (!altJitConfig || opts.altJit)) { - static ConfigMethodSet fJitImportBreak; - fJitImportBreak.ensureInit(CLRConfig::INTERNAL_JitImportBreak); - if (fJitImportBreak.contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) + if (JitConfig.JitImportBreak().contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) assert(!"JitImportBreak reached"); } @@ -2192,63 +2176,41 @@ void Compiler::compInitOptions(CORJIT_FLAGS* jitFlags) if (opts.eeFlags & CORJIT_FLG_PREJIT) { - static ConfigMethodSet fNgenDump; - fNgenDump.ensureInit(CLRConfig::INTERNAL_NgenDump); - - if (fNgenDump.contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) + if (JitConfig.NgenDump().contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) verboseDump = true; - static ConfigDWORD fNgenHashDump; - unsigned ngenHashDumpVal = (unsigned) fNgenHashDump.val(CLRConfig::INTERNAL_NgenHashDump); + unsigned ngenHashDumpVal = (unsigned) JitConfig.NgenHashDump(); if ((ngenHashDumpVal != (DWORD)-1) && (ngenHashDumpVal == info.compMethodHash())) verboseDump = true; - static ConfigMethodSet fNgenDumpIR; - fNgenDumpIR.ensureInit(CLRConfig::INTERNAL_NgenDumpIR); - - if (fNgenDumpIR.contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) + if (JitConfig.NgenDumpIR().contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) dumpIR = true; - static ConfigDWORD fNgenHashDumpIR; - unsigned ngenHashDumpIRVal = (unsigned) fNgenHashDumpIR.val(CLRConfig::INTERNAL_NgenHashDumpIR); + unsigned ngenHashDumpIRVal = (unsigned) JitConfig.NgenHashDumpIR(); if ((ngenHashDumpIRVal != (DWORD)-1) && (ngenHashDumpIRVal == info.compMethodHash())) dumpIR = true; - static ConfigString ngenDumpIRFormat; - dumpIRFormat = ngenDumpIRFormat.val(CLRConfig::INTERNAL_NgenDumpIRFormat); - - static ConfigString ngenDumpIRPhase; - dumpIRPhase = ngenDumpIRPhase.val(CLRConfig::INTERNAL_NgenDumpIRPhase); + dumpIRFormat = JitConfig.NgenDumpIRFormat(); + dumpIRPhase = JitConfig.NgenDumpIRPhase(); } else { - static ConfigMethodSet fJitDump; - fJitDump.ensureInit(CLRConfig::INTERNAL_JitDump); - - if (fJitDump.contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) + if (JitConfig.JitDump().contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) verboseDump = true; - static ConfigDWORD fJitHashDump; - unsigned jitHashDumpVal = (unsigned) fJitHashDump.val(CLRConfig::INTERNAL_JitHashDump); + unsigned jitHashDumpVal = (unsigned) JitConfig.JitHashDump(); if ((jitHashDumpVal != (DWORD)-1) && (jitHashDumpVal == info.compMethodHash())) verboseDump = true; - static ConfigMethodSet fJitDumpIR; - fJitDumpIR.ensureInit(CLRConfig::INTERNAL_JitDumpIR); - - if (fJitDumpIR.contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) + if (JitConfig.JitDumpIR().contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) dumpIR = true; - static ConfigDWORD fJitHashDumpIR; - unsigned jitHashDumpIRVal = (unsigned) fJitHashDumpIR.val(CLRConfig::INTERNAL_JitHashDumpIR); + unsigned jitHashDumpIRVal = (unsigned) JitConfig.JitHashDumpIR(); if ((jitHashDumpIRVal != (DWORD)-1) && (jitHashDumpIRVal == info.compMethodHash())) dumpIR = true; - static ConfigString jitDumpIRFormat; - dumpIRFormat = jitDumpIRFormat.val(CLRConfig::INTERNAL_JitDumpIRFormat); - - static ConfigString jitDumpIRPhase; - dumpIRPhase = jitDumpIRPhase.val(CLRConfig::INTERNAL_JitDumpIRPhase); + dumpIRFormat = JitConfig.JitDumpIRFormat(); + dumpIRPhase = JitConfig.JitDumpIRPhase(); } if (dumpIRPhase == nullptr) @@ -2614,83 +2576,60 @@ void Compiler::compInitOptions(CORJIT_FLAGS* jitFlags) { if (opts.eeFlags & CORJIT_FLG_PREJIT) { - static ConfigDWORD fNgenOrder; - if ((fNgenOrder.val(CLRConfig::INTERNAL_NgenOrder) & 1) == 1) + if ((JitConfig.NgenOrder() & 1) == 1) opts.dspOrder = true; - static ConfigMethodSet fNgenGCDump; - fNgenGCDump.ensureInit(CLRConfig::INTERNAL_NgenGCDump); - if (fNgenGCDump.contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) + if (JitConfig.NgenGCDump().contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) opts.dspGCtbls = true; - static ConfigMethodSet fNgenDisasm; - fNgenDisasm.ensureInit(CLRConfig::INTERNAL_NgenDisasm); - if (fNgenDisasm.contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) + if (JitConfig.NgenDisasm().contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) opts.disAsm = true; - if (fNgenDisasm.contains("SPILLED", NULL)) + if (JitConfig.NgenDisasm().contains("SPILLED", NULL, NULL)) opts.disAsmSpilled = true; - static ConfigMethodSet fNgenUnwindDump; - fNgenUnwindDump.ensureInit(CLRConfig::INTERNAL_NgenUnwindDump); - if (fNgenUnwindDump.contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) + if (JitConfig.NgenUnwindDump().contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) opts.dspUnwind = true; - static ConfigMethodSet fNgenEHDump; - fNgenEHDump.ensureInit(CLRConfig::INTERNAL_NgenEHDump); - if (fNgenEHDump.contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) + if (JitConfig.NgenEHDump().contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) opts.dspEHTable = true; } else { - static ConfigDWORD fJitOrder; - if ((fJitOrder.val(CLRConfig::INTERNAL_JitOrder) & 1) == 1) + if ((JitConfig.JitOrder() & 1) == 1) opts.dspOrder = true; - static ConfigMethodSet fJitGCDump; - fJitGCDump.ensureInit(CLRConfig::INTERNAL_JitGCDump); - if (fJitGCDump.contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) + if (JitConfig.JitGCDump().contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) opts.dspGCtbls = true; - static ConfigMethodSet fJitDisasm; - fJitDisasm.ensureInit(CLRConfig::INTERNAL_JitDisasm); - if (fJitDisasm.contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) + if (JitConfig.JitDisasm().contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) opts.disAsm = true; - if (fJitDisasm.contains("SPILLED", NULL)) + if (JitConfig.JitDisasm().contains("SPILLED", NULL, NULL)) opts.disAsmSpilled = true; - static ConfigMethodSet fJitUnwindDump; - fJitUnwindDump.ensureInit(CLRConfig::INTERNAL_JitUnwindDump); - if (fJitUnwindDump.contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) + if (JitConfig.JitUnwindDump().contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) opts.dspUnwind = true; - static ConfigMethodSet fJitEHDump; - fJitEHDump.ensureInit(CLRConfig::INTERNAL_JitEHDump); - if (fJitEHDump.contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) + if (JitConfig.JitEHDump().contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) opts.dspEHTable = true; } #ifdef LATE_DISASM - static ConfigMethodSet fJitLateDisasm; - fJitLateDisasm.ensureInit(CLRConfig::INTERNAL_JitLateDisasm); - if (fJitLateDisasm.contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) + if (JitConfig.JitLateDisasm().contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) opts.doLateDisasm = true; #endif // LATE_DISASM // This one applies to both Ngen/Jit Disasm output: COMPLUS_JitDiffableDasm=1 - static ConfigDWORD fDiffableDasm; - if (fDiffableDasm.val(CLRConfig::INTERNAL_JitDiffableDasm) != 0) + if (JitConfig.DiffableDasm() != 0) { opts.disDiffable = true; opts.dspDiffable = true; } - static ConfigDWORD fDisplayMemStats; - if (fDisplayMemStats.val(CLRConfig::INTERNAL_JitMemStats) != 0) + if (JitConfig.DisplayMemStats() != 0) s_dspMemStats = true; - static ConfigDWORD fJitLargeBranches; - if (fJitLargeBranches.val(CLRConfig::INTERNAL_JitLargeBranches) != 0) + if (JitConfig.JitLargeBranches() != 0) opts.compLargeBranches = true; } @@ -2707,12 +2646,10 @@ void Compiler::compInitOptions(CORJIT_FLAGS* jitFlags) codeGen->setVerbose(true); } - static ConfigDWORD fTreesBeforeAfterMorph; - treesBeforeAfterMorph = (fTreesBeforeAfterMorph.val(CLRConfig::INTERNAL_JitDumpBeforeAfterMorph) == 1); + treesBeforeAfterMorph = (JitConfig.TreesBeforeAfterMorph() == 1); morphNum = 0; // Initialize the morphed-trees counting. - static ConfigDWORD fJitExpensiveDebugCheckLevel; - expensiveDebugCheckLevel = fJitExpensiveDebugCheckLevel.val(CLRConfig::INTERNAL_JitExpensiveDebugCheckLevel); + expensiveDebugCheckLevel = JitConfig.JitExpensiveDebugCheckLevel(); if (expensiveDebugCheckLevel == 0) { // If we're in a stress mode that modifies the flowgraph, make 1 the default. @@ -2729,21 +2666,16 @@ void Compiler::compInitOptions(CORJIT_FLAGS* jitFlags) printf(""); // in our logic this causes a flush } - static ConfigMethodSet fJitBreak; - fJitBreak.ensureInit(CLRConfig::INTERNAL_JitBreak); - if (fJitBreak.contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) + if (JitConfig.JitBreak().contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) assert(!"JitBreak reached"); - static ConfigDWORD fJitHashBreak; - unsigned jitHashBreakVal = (unsigned)fJitHashBreak.val(CLRConfig::INTERNAL_JitHashBreak); + unsigned jitHashBreakVal = (unsigned)JitConfig.JitHashBreak(); if ((jitHashBreakVal != (DWORD)-1) && (jitHashBreakVal == info.compMethodHash())) assert(!"JitHashBreak reached"); - static ConfigMethodSet fJitDebugBreak; - fJitDebugBreak.ensureInit(CLRConfig::INTERNAL_JitDebugBreak); if (verbose || - fJitDebugBreak.contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args) || - fJitBreak.contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) + JitConfig.JitDebugBreak().contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args) || + JitConfig.JitBreak().contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) { compDebugBreak = true; } @@ -2757,8 +2689,7 @@ void Compiler::compInitOptions(CORJIT_FLAGS* jitFlags) #ifdef DEBUGGING_SUPPORT #ifdef DEBUG assert(!codeGen->isGCTypeFixed()); - static ConfigDWORD fJitGCChecks; - opts.compGcChecks = (fJitGCChecks.val_DontUse_(CLRConfig::INTERNAL_JitGCChecks) != 0) || + opts.compGcChecks = (JitConfig.JitGCChecks() != 0) || compStressCompile(STRESS_GENERIC_VARN, 5); enum @@ -2768,8 +2699,7 @@ void Compiler::compInitOptions(CORJIT_FLAGS* jitFlags) STACK_CHECK_ALL = 0x3, }; - static ConfigDWORD fJitStackChecks; - DWORD dwJitStackChecks = fJitStackChecks.val_DontUse_(CLRConfig::INTERNAL_JitStackChecks); + DWORD dwJitStackChecks = JitConfig.JitStackChecks(); if (compStressCompile(STRESS_GENERIC_VARN, 5)) dwJitStackChecks = STACK_CHECK_ALL; opts.compStackCheckOnRet = (dwJitStackChecks & DWORD(STACK_CHECK_ON_RETURN)) != 0; opts.compStackCheckOnCall = (dwJitStackChecks & DWORD(STACK_CHECK_ON_CALL)) != 0; @@ -2800,8 +2730,7 @@ void Compiler::compInitOptions(CORJIT_FLAGS* jitFlags) // Honour complus_JitELTHookEnabled only if VM has not asked us to generate profiler // hooks in the first place. That is, Override VM only if it hasn't asked for a // profiler callback for this method. - static ConfigDWORD fJitELTHookEnabled; - if (!compProfilerHookNeeded && (fJitELTHookEnabled.val(CLRConfig::INTERNAL_JitELTHookEnabled) != 0)) + if (!compProfilerHookNeeded && (JitConfig.JitELTHookEnabled() != 0)) { opts.compJitELTHookEnabled = true; } @@ -2817,14 +2746,13 @@ void Compiler::compInitOptions(CORJIT_FLAGS* jitFlags) #endif // PROFILING_SUPPORTED #if FEATURE_TAILCALL_OPT - static ConfigString fTailCallOpt; - LPWSTR strTailCallOpt = fTailCallOpt.val(CLRConfig::EXTERNAL_TailCallOpt); + const wchar_t* strTailCallOpt = JitConfig.TailCallOpt(); if (strTailCallOpt != nullptr) { opts.compTailCallOpt = (UINT)_wtoi(strTailCallOpt) != 0; } - static ConfigDWORD fTailCallLoopOpt; - if (fTailCallLoopOpt.val(CLRConfig::EXTERNAL_TailCallLoopOpt) == 0) + + if (JitConfig.TailCallLoopOpt() == 0) { opts.compTailCallLoopOpt = false; } @@ -2848,8 +2776,7 @@ void Compiler::compInitOptions(CORJIT_FLAGS* jitFlags) #ifdef DEBUG #if defined(_TARGET_XARCH_) && !defined(LEGACY_BACKEND) // Whether encoding of absolute addr as PC-rel offset is enabled in RyuJIT - static ConfigDWORD fEnablePCRelAddr; - opts.compEnablePCRelAddr = (fEnablePCRelAddr.val(CLRConfig::INTERNAL_JitEnablePCRelAddr) != 0); + opts.compEnablePCRelAddr = (JitConfig.EnablePCRelAddr() != 0); #endif #endif //DEBUG @@ -2873,21 +2800,15 @@ void Compiler::compInitOptions(CORJIT_FLAGS* jitFlags) // JitForceProcedureSplitting is used to force procedure splitting on checked assemblies. // This is useful for debugging on a checked build. Note that we still only do procedure // splitting in the zapper. - static ConfigMethodSet fJitForceProcedureSplitting; - fJitForceProcedureSplitting.ensureInit(CLRConfig::INTERNAL_JitForceProcedureSplitting); - if (fJitForceProcedureSplitting.contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) + if (JitConfig.JitForceProcedureSplitting().contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) opts.compProcedureSplitting = true; // JitNoProcedureSplitting will always disable procedure splitting. - static ConfigMethodSet fJitNoProcedureSplitting; - fJitNoProcedureSplitting.ensureInit(CLRConfig::INTERNAL_JitNoProcedureSplitting); - if (fJitNoProcedureSplitting.contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) + if (JitConfig.JitNoProcedureSplitting().contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) opts.compProcedureSplitting = false; // // JitNoProcedureSplittingEH will disable procedure splitting in functions with EH. - static ConfigMethodSet fJitNoProcedureSplittingEH; - fJitNoProcedureSplittingEH.ensureInit(CLRConfig::INTERNAL_JitNoProcedureSplittingEH); - if (fJitNoProcedureSplittingEH.contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) + if (JitConfig.JitNoProcedureSplittingEH().contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) opts.compProcedureSplittingEH = false; #endif } @@ -2933,8 +2854,7 @@ void Compiler::compInitOptions(CORJIT_FLAGS* jitFlags) opts.compNeedStackProbes = false; #ifdef DEBUG - static ConfigDWORD fStackProbesOverride; - if (fStackProbesOverride.val_DontUse_(CLRConfig::INTERNAL_JitStackProbes) != 0 || + if (JitConfig.StackProbesOverride() != 0 || compStressCompile(STRESS_GENERIC_VARN, 5)) { opts.compNeedStackProbes = true; @@ -2945,9 +2865,8 @@ void Compiler::compInitOptions(CORJIT_FLAGS* jitFlags) // Now, set compMaxUncheckedOffsetForNullObject for STRESS_NULL_OBJECT_CHECK if (compStressCompile(STRESS_NULL_OBJECT_CHECK, 30)) { - static ConfigDWORD fJitMaxUncheckedOffset; compMaxUncheckedOffsetForNullObject = - (unsigned) fJitMaxUncheckedOffset.val(CLRConfig::INTERNAL_JitMaxUncheckedOffset); + (unsigned) JitConfig.JitMaxUncheckedOffset(); if (verbose) { printf("STRESS_NULL_OBJECT_CHECK: compMaxUncheckedOffsetForNullObject=0x%X\n", compMaxUncheckedOffsetForNullObject); } @@ -3011,17 +2930,14 @@ bool Compiler::compJitHaltMethod() /* This method returns true when we use an INS_BREAKPOINT to allow us to step into the generated native code */ /* Note that this these two "Jit" environment variables also work for ngen images */ - static ConfigMethodSet fJitHalt; - fJitHalt.ensureInit(CLRConfig::INTERNAL_JitHalt); - if (fJitHalt.contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) + if (JitConfig.JitHalt().contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) { return true; } /* Use this Hash variant when there are a lot of method with the same name and different signatures */ - static ConfigDWORD fJitHashHalt; - unsigned fJitHashHaltVal = (unsigned)fJitHashHalt.val(CLRConfig::INTERNAL_JitHashHalt); + unsigned fJitHashHaltVal = (unsigned)JitConfig.JitHashHalt(); if ((fJitHashHaltVal != (unsigned)-1) && (fJitHashHaltVal == info.compMethodHash())) { return true; @@ -3056,21 +2972,17 @@ bool Compiler::compStressCompile(compStressArea stressArea, return false; } - static ConfigMethodSet fJitStressOnly; - fJitStressOnly.ensureInit(CLRConfig::INTERNAL_JitStressOnly); - if (!fJitStressOnly.isEmpty() && - !fJitStressOnly.contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) + if (!JitConfig.JitStressOnly().isEmpty() && + !JitConfig.JitStressOnly().contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) { return false; } bool doStress = false; - static ConfigString fJitStressModeNames; - LPWSTR strStressModeNames; + const wchar_t* strStressModeNames; // Does user explicitly prevent using this STRESS_MODE through the command line? - static ConfigString fJitStressModeNamesNot; - LPWSTR strStressModeNamesNot = fJitStressModeNamesNot.val(CLRConfig::INTERNAL_JitStressModeNamesNot); + const wchar_t* strStressModeNamesNot = JitConfig.JitStressModeNamesNot(); if ((strStressModeNamesNot != NULL) && (wcsstr(strStressModeNamesNot, s_compStressModeNames[stressArea]) != NULL)) { @@ -3083,7 +2995,7 @@ bool Compiler::compStressCompile(compStressArea stressArea, } // Does user explicitly set this STRESS_MODE through the command line? - strStressModeNames = fJitStressModeNames.val(CLRConfig::INTERNAL_JitStressModeNames); + strStressModeNames = JitConfig.JitStressModeNames(); if ((strStressModeNames != NULL) && (wcsstr(strStressModeNames, s_compStressModeNames[stressArea]) != NULL)) { @@ -3258,9 +3170,7 @@ void Compiler::compSetOptimizationLevel() } #ifdef DEBUG - static ConfigDWORD fJitMinOpts; - - jitMinOpts = fJitMinOpts.val_DontUse_(CLRConfig::UNSUPPORTED_JITMinOpts, 0); + jitMinOpts = JitConfig.JitMinOpts(); if (!theMinOptsValue && (jitMinOpts > 0)) { @@ -3324,10 +3234,7 @@ void Compiler::compSetOptimizationLevel() if (!theMinOptsValue) { - static ConfigMethodSet jitMinOptsName; - jitMinOptsName.ensureInit(CLRConfig::INTERNAL_JITMinOptsName); - - if (jitMinOptsName.contains(info.compMethodName, info.compClassName, info.compMethodInfo->args.pSig)) + if (JitConfig.JitMinOptsName().contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) theMinOptsValue = true; } @@ -3339,34 +3246,27 @@ void Compiler::compSetOptimizationLevel() // unless unless CLFLG_MINOPT is set else if (!(compileFlags & CORJIT_FLG_PREJIT)) { - static ConfigDWORD fJitMinOptsCodeSize; - static ConfigDWORD fJitMinOptsInstrCount; - static ConfigDWORD fJitMinOptsBbCount; - static ConfigDWORD fJitMinOptsLvNumCount; - static ConfigDWORD fJitMinOptsLvRefCount; - static ConfigDWORD fJitBreakOnMinOpts; - - if (fJitMinOptsCodeSize.val_DontUse_(CLRConfig::INTERNAL_JITMinOptsCodeSize, DEFAULT_MIN_OPTS_CODE_SIZE) < info.compILCodeSize) + if ((unsigned)JitConfig.JitMinOptsCodeSize() < info.compILCodeSize) { JITLOG((LL_INFO10, "IL Code Size exceeded, using MinOpts for method %s\n", info.compFullName)); theMinOptsValue = true; } - else if (fJitMinOptsInstrCount.val_DontUse_(CLRConfig::INTERNAL_JITMinOptsInstrCount, DEFAULT_MIN_OPTS_INSTR_COUNT) < opts.instrCount) + else if ((unsigned)JitConfig.JitMinOptsInstrCount() < opts.instrCount) { JITLOG((LL_INFO10, "IL instruction count exceeded, using MinOpts for method %s\n", info.compFullName)); theMinOptsValue = true; } - else if (fJitMinOptsBbCount.val_DontUse_(CLRConfig::INTERNAL_JITMinOptsBbCount, DEFAULT_MIN_OPTS_BB_COUNT) < fgBBcount) + else if ((unsigned)JitConfig.JitMinOptsBbCount() < fgBBcount) { JITLOG((LL_INFO10, "Basic Block count exceeded, using MinOpts for method %s\n", info.compFullName)); theMinOptsValue = true; } - else if (fJitMinOptsLvNumCount.val_DontUse_(CLRConfig::INTERNAL_JITMinOptsLvNumcount, DEFAULT_MIN_OPTS_LV_NUM_COUNT) < lvaCount) + else if ((unsigned)JitConfig.JitMinOptsLvNumCount() < lvaCount) { JITLOG((LL_INFO10, "Local Variable Num count exceeded, using MinOpts for method %s\n", info.compFullName)); theMinOptsValue = true; } - else if (fJitMinOptsLvRefCount.val_DontUse_(CLRConfig::INTERNAL_JITMinOptsLvRefcount, DEFAULT_MIN_OPTS_LV_REF_COUNT) < opts.lvRefCount) + else if ((unsigned)JitConfig.JitMinOptsLvRefCount() < opts.lvRefCount) { JITLOG((LL_INFO10, "Local Variable Ref count exceeded, using MinOpts for method %s\n", info.compFullName)); theMinOptsValue = true; @@ -3375,7 +3275,7 @@ void Compiler::compSetOptimizationLevel() { JITLOG((LL_INFO10000, "IL Code Size,Instr %4d,%4d, Basic Block count %3d, Local Variable Num,Ref count %3d,%3d for method %s\n", info.compILCodeSize, opts.instrCount, fgBBcount, lvaCount, opts.lvRefCount, info.compFullName)); - if (fJitBreakOnMinOpts.val_DontUse_(CLRConfig::INTERNAL_JITBreakOnMinOpts, 0) != 0) + if (JitConfig.JitBreakOnMinOpts() != 0) { assert(!"MinOpts enabled"); } @@ -3624,7 +3524,7 @@ void Compiler::compCompile(void * * methodCodePtr, EndPhase(PHASE_PRE_IMPORT); #ifdef DEBUG - bool funcTrace = (CLRConfig::GetConfigValue(CLRConfig::INTERNAL_JitFunctionTrace) != 0); + bool funcTrace = JitConfig.JitFunctionTrace() != 0; if (!compIsForInlining()) { @@ -3864,14 +3764,13 @@ void Compiler::compCompile(void * * methodCodePtr, bool doRangeAnalysis = true; #ifdef DEBUG - static ConfigDWORD fJitDoOptConfig[7]; - doSsa = (fJitDoOptConfig[0].val(CLRConfig::INTERNAL_JitDoSsa) != 0); - doEarlyProp = doSsa && (fJitDoOptConfig[1].val(CLRConfig::INTERNAL_JitDoEarlyProp) != 0); - doValueNum = doSsa && (fJitDoOptConfig[2].val(CLRConfig::INTERNAL_JitDoValueNumber) != 0); - doLoopHoisting = doValueNum && (fJitDoOptConfig[3].val(CLRConfig::INTERNAL_JitDoLoopHoisting) != 0); - doCopyProp = doValueNum && (fJitDoOptConfig[4].val(CLRConfig::INTERNAL_JitDoCopyProp) != 0); - doAssertionProp = doValueNum && (fJitDoOptConfig[5].val(CLRConfig::INTERNAL_JitDoAssertionProp) != 0); - doRangeAnalysis = doAssertionProp && (fJitDoOptConfig[6].val(CLRConfig::INTERNAL_JitDoRangeAnalysis) != 0); + doSsa = (JitConfig.JitDoSsa() != 0); + doEarlyProp = doSsa && (JitConfig.JitDoEarlyProp() != 0); + doValueNum = doSsa && (JitConfig.JitDoValueNumber() != 0); + doLoopHoisting = doValueNum && (JitConfig.JitDoLoopHoisting() != 0); + doCopyProp = doValueNum && (JitConfig.JitDoCopyProp() != 0); + doAssertionProp = doValueNum && (JitConfig.JitDoAssertionProp() != 0); + doRangeAnalysis = doAssertionProp && (JitConfig.JitDoRangeAnalysis() != 0); #endif if (doSsa) @@ -4199,18 +4098,14 @@ void* forceFrameJIT; // used to force to frame &useful for fastchecked deb bool Compiler::skipMethod() { static ConfigMethodRange fJitRange; - fJitRange.ensureInit(CLRConfig::INTERNAL_JitRange); + fJitRange.ensureInit(JitConfig.JitRange()); if (!fJitRange.contains(info.compCompHnd, info.compMethodHnd)) return true; - static ConfigMethodSet fJitExclude; - fJitExclude.ensureInit(CLRConfig::INTERNAL_JitExclude); - if (fJitExclude.contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) + if (JitConfig.JitExclude().contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) return true; - static ConfigMethodSet fJitInclude; - fJitInclude.ensureInit(CLRConfig::INTERNAL_JitInclude); - if (!fJitInclude.isEmpty() && !fJitInclude.contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) + if (!JitConfig.JitInclude().isEmpty() && !JitConfig.JitInclude().contains(info.compMethodName, info.compClassName, &info.compMethodInfo->args)) return true; return false; @@ -4285,8 +4180,7 @@ int Compiler::compCompile(CORINFO_METHOD_HANDLE methodHnd, #endif #if FUNC_INFO_LOGGING - static ConfigString jitFuncInfoFile; - LPCWSTR tmpJitFuncInfoFilename = jitFuncInfoFile.val(CLRConfig::INTERNAL_JitFuncInfoLogFile); + LPCWSTR tmpJitFuncInfoFilename = JitConfig.JitFuncInfoFile(); if (tmpJitFuncInfoFilename != NULL) { @@ -4368,7 +4262,7 @@ int Compiler::compCompile(CORINFO_METHOD_HANDLE methodHnd, } static ConfigMethodRange fJitStressRange; - fJitStressRange.ensureInit(CLRConfig::INTERNAL_JitStressRange); + fJitStressRange.ensureInit(JitConfig.JitStressRange()); if (fJitStressRange.contains(info.compCompHnd, info.compMethodHnd)) { bRangeAllowStress = true; @@ -4830,8 +4724,7 @@ int Compiler::compCompileHelper (CORINFO_MODULE_HANDLE clas #endif // Check for COMPLUS_AgressiveInlining - static ConfigDWORD fJitAggressiveInlining; - if (fJitAggressiveInlining.val(CLRConfig::INTERNAL_JitAggressiveInlining)) + if (JitConfig.JitAggressiveInlining()) { compDoAggressiveInlining = true; } @@ -4857,8 +4750,7 @@ int Compiler::compCompileHelper (CORINFO_MODULE_HANDLE clas } // Force verification if asked to do so - static ConfigDWORD fJitForceVer; - if (fJitForceVer.val(CLRConfig::INTERNAL_JitForceVer)) + if (JitConfig.JitForceVer()) tiVerificationNeeded = (instVerInfo == INSTVER_NOT_INSTANTIATION); if (tiVerificationNeeded) @@ -5088,8 +4980,7 @@ int Compiler::compCompileHelper (CORINFO_MODULE_HANDLE clas } #ifdef DEBUG - static ConfigDWORD fDumpJittedMethods; - if (fDumpJittedMethods.val(CLRConfig::INTERNAL_DumpJittedMethods) == 1 && !compIsForInlining()) + if (JitConfig.DumpJittedMethods() == 1 && !compIsForInlining()) { printf("Compiling %4d %s::%s, IL size = %u, hsh=0x%x\n", Compiler::jitTotalMethodCompiled, @@ -5136,8 +5027,7 @@ _Next: #ifdef ALT_JIT #ifdef DEBUG - static ConfigDWORD fRunAltJitCode; - if (fRunAltJitCode.val(CLRConfig::INTERNAL_RunAltJitCode) == 0) + if (JitConfig.RunAltJitCode() == 0) { return CORJIT_SKIPPED; } @@ -6710,8 +6600,7 @@ CritSecObject JitTimer::s_csvLock; LPCWSTR Compiler::JitTimeLogCsv() { - static ConfigString jitConfigTimeLogCsv; - LPCWSTR jitTimeLogCsv = jitConfigTimeLogCsv.val(CLRConfig::INTERNAL_JitTimeLogCsv); + LPCWSTR jitTimeLogCsv = JitConfig.JitTimeLogCsv(); return jitTimeLogCsv; } diff --git a/src/jit/compiler.h b/src/jit/compiler.h index 7925602c0c..bb302ee623 100644 --- a/src/jit/compiler.h +++ b/src/jit/compiler.h @@ -4323,8 +4323,7 @@ protected : unsigned fgStressBBProf() { #ifdef DEBUG - static ConfigDWORD fJitStressBBProf; - unsigned result = fJitStressBBProf.val(CLRConfig::INTERNAL_JitStressBBProf); + unsigned result = JitConfig.JitStressBBProf(); if (result == 0) { if (compStressCompile(STRESS_BB_PROFILE, 15)) @@ -7549,6 +7548,7 @@ public : opts; #ifdef ALT_JIT + static bool s_pAltJitExcludeAssembliesListInitialized; static AssemblyNamesList2* s_pAltJitExcludeAssembliesList; #endif // ALT_JIT @@ -7641,8 +7641,7 @@ public : bool compTailCallStress() { #ifdef DEBUG - static ConfigDWORD fTailcallStress; - return (fTailcallStress.val(CLRConfig::INTERNAL_TailcallStress) !=0 + return (JitConfig.TailcallStress() !=0 || compStressCompile(STRESS_TAILCALL, 5) ); #else diff --git a/src/jit/compiler.hpp b/src/jit/compiler.hpp index 6637891523..882cf51381 100644 --- a/src/jit/compiler.hpp +++ b/src/jit/compiler.hpp @@ -38,10 +38,7 @@ inline bool getInlinePInvokeEnabled() { #ifdef DEBUG - static ConfigDWORD fJITPInvokeEnabled; - static ConfigDWORD fStressCOMCall; - - return fJITPInvokeEnabled.val(CLRConfig::INTERNAL_JITPInvokeEnabled) && !fStressCOMCall.val(CLRConfig::INTERNAL_StressCOMCall); + return JitConfig.JitPInvokeEnabled() && !JitConfig.StressCOMCall(); #else return true; #endif @@ -51,8 +48,7 @@ inline bool getInlinePInvokeCheckEnabled() { #ifdef DEBUG - static ConfigDWORD fJITPInvokeCheckEnabled; - return fJITPInvokeCheckEnabled.val(CLRConfig::INTERNAL_JITPInvokeCheckEnabled) != 0; + return JitConfig.JitPInvokeCheckEnabled() != 0; #else return false; #endif @@ -89,8 +85,7 @@ inline RoundLevel getRoundFloatLevel() { #ifdef DEBUG - static ConfigDWORD fJITRoundFloat; - return (RoundLevel) fJITRoundFloat.val_DontUse_(CLRConfig::INTERNAL_JITRoundFloat, DEFAULT_ROUND_LEVEL); + return (RoundLevel) JitConfig.JitRoundFloat(); #else return DEFAULT_ROUND_LEVEL; #endif @@ -3092,15 +3087,13 @@ void Compiler::tmpDone() inline bool Compiler::shouldUseVerboseTrees() { - static ConfigDWORD fVerboseTrees; - return (fVerboseTrees.val(CLRConfig::INTERNAL_JitDumpVerboseTrees) == 1); + return (JitConfig.JitDumpVerboseTrees() == 1); } inline bool Compiler::shouldUseVerboseSsa() { - static ConfigDWORD fVerboseSsa; - return (fVerboseSsa.val(CLRConfig::INTERNAL_JitDumpVerboseSsa) == 1); + return (JitConfig.JitDumpVerboseSsa() == 1); } //------------------------------------------------------------------------ @@ -3112,8 +3105,7 @@ bool Compiler::shouldUseVerboseSsa() inline bool Compiler::shouldDumpASCIITrees() { - static ConfigDWORD fASCIITrees; - return (fASCIITrees.val(CLRConfig::INTERNAL_JitDumpASCII) == 1); + return (JitConfig.JitDumpASCII() == 1); } /***************************************************************************** @@ -3126,8 +3118,7 @@ bool Compiler::shouldDumpASCIITrees() inline DWORD getJitStressLevel() { - static ConfigDWORD fJitStress; - return fJitStress.val(CLRConfig::INTERNAL_JitStress); + return JitConfig.JitStress(); } /***************************************************************************** @@ -3137,9 +3128,7 @@ DWORD getJitStressLevel() inline DWORD StrictCheckForNonVirtualCallToVirtualMethod() { - static ConfigDWORD fJitStrictCheckForNonVirtualCallToVirtualMethod; - return fJitStrictCheckForNonVirtualCallToVirtualMethod.val( - CLRConfig::INTERNAL_JitStrictCheckForNonVirtualCallToVirtualMethod) == 1; + return JitConfig.JitStrictCheckForNonVirtualCallToVirtualMethod() == 1; } #endif // DEBUG diff --git a/src/jit/disasm.cpp b/src/jit/disasm.cpp index 3a3e0230f1..9b8e0c3c47 100644 --- a/src/jit/disasm.cpp +++ b/src/jit/disasm.cpp @@ -1531,9 +1531,7 @@ void DisAssembler::disAsmCode(BYTE* hotCodePtr, size_t hotCodeSize, BYTE* col #endif // !DEBUG #ifdef DEBUG - static ConfigString fJITLateDisasmTo; - - LPWSTR fileName = fJITLateDisasmTo.val(CLRConfig::INTERNAL_JITLateDisasmTo); + const wchar_t* fileName = JitConfig.JitLateDisasmTo(); if (fileName != nullptr) { errno_t ec = _wfopen_s(&disAsmFile, fileName, W("a+")); diff --git a/src/jit/ee_il_dll.cpp b/src/jit/ee_il_dll.cpp index f0da62d153..46cdb6b43e 100644 --- a/src/jit/ee_il_dll.cpp +++ b/src/jit/ee_il_dll.cpp @@ -52,6 +52,14 @@ void __stdcall jitStartup(ICorJitHost* jitHost) { g_jitHost = jitHost; + // `jitStartup` may be called multiple times + // when pre-jitting. We should not reinitialize + // config values each time. + if (!JitConfig.isInitialized()) + { + JitConfig.initialize(jitHost); + } + #ifdef FEATURE_TRACELOGGING JitTelemetry::NotifyDllProcessAttach(); #endif @@ -285,8 +293,7 @@ unsigned CILJit::getMaxIntrinsicSIMDVectorLength(DWORD cpuCompileFlags) ((cpuCompileFlags & CORJIT_FLG_FEATURE_SIMD) != 0) && ((cpuCompileFlags & CORJIT_FLG_USE_AVX2) != 0)) { - static ConfigDWORD fEnableAVX; - if (fEnableAVX.val(CLRConfig::EXTERNAL_EnableAVX) != 0) + if (JitConfig.EnableAVX() != 0) { return 32; } diff --git a/src/jit/emit.cpp b/src/jit/emit.cpp index 35b16b679a..5af7adeffc 100644 --- a/src/jit/emit.cpp +++ b/src/jit/emit.cpp @@ -924,8 +924,7 @@ void emitter::emitTmpSizeChanged(unsigned tmpSize) #ifdef DEBUG // Workaround for FP code - static ConfigDWORD fMaxTempAssert; - bool bAssert = fMaxTempAssert.val(CLRConfig::INTERNAL_JITMaxTempAssert)?true:false; + bool bAssert = JitConfig.JitMaxTempAssert()?true:false; if (tmpSize > emitMaxTmpSize && bAssert) { diff --git a/src/jit/emitarm.cpp b/src/jit/emitarm.cpp index a405246d24..99049e4b0e 100644 --- a/src/jit/emitarm.cpp +++ b/src/jit/emitarm.cpp @@ -6620,8 +6620,7 @@ DONE_CALL: { // set JitEmitPrintRefRegs=1 will print out emitThisGCrefRegs and emitThisByrefRegs // at the beginning of this method. - static ConfigDWORD fJitEmitPrintRefRegs; - if (fJitEmitPrintRefRegs.val(CLRConfig::INTERNAL_JitEmitPrintRefRegs) != 0) { + if (JitConfig.JitEmitPrintRefRegs() != 0) { printf("Before emitOutputInstr for id->idDebugOnlyInfo()->idNum=0x%02x\n", id->idDebugOnlyInfo()->idNum); printf(" emitThisGCrefRegs(0x%p)=", dspPtr(&emitThisGCrefRegs)); printRegMaskInt(emitThisGCrefRegs); @@ -6635,8 +6634,7 @@ DONE_CALL: // For example, set JitBreakEmitOutputInstr=a6 will break when this method is called for // emitting instruction a6, (i.e. IN00a6 in jitdump). - static ConfigDWORD fJitBreakEmitOutputInstr; - if ((unsigned)fJitBreakEmitOutputInstr.val(CLRConfig::INTERNAL_JitBreakEmitOutputInstr) == id->idDebugOnlyInfo()->idNum) + if ((unsigned)JitConfig.JitBreakEmitOutputInstr() == id->idDebugOnlyInfo()->idNum) { assert(!"JitBreakEmitOutputInstr reached"); } diff --git a/src/jit/emitarm64.cpp b/src/jit/emitarm64.cpp index 2b203499b4..7421f0dcd7 100644 --- a/src/jit/emitarm64.cpp +++ b/src/jit/emitarm64.cpp @@ -9167,8 +9167,7 @@ size_t emitter::emitOutputInstr(insGroup *ig, { // For example, set JitBreakEmitOutputInstr=a6 will break when this method is called for // emitting instruction a6, (i.e. IN00a6 in jitdump). - static ConfigDWORD fJitBreakEmitOutputInstr; - if ((unsigned)fJitBreakEmitOutputInstr.val(CLRConfig::INTERNAL_JitBreakEmitOutputInstr) == id->idDebugOnlyInfo()->idNum) + if ((unsigned)JitConfig.JitBreakEmitOutputInstr() == id->idDebugOnlyInfo()->idNum) { assert(!"JitBreakEmitOutputInstr reached"); } diff --git a/src/jit/emitxarch.cpp b/src/jit/emitxarch.cpp index 4bf0affe4c..343e00f182 100644 --- a/src/jit/emitxarch.cpp +++ b/src/jit/emitxarch.cpp @@ -11159,8 +11159,7 @@ size_t emitter::emitOutputInstr(insGroup* ig, instrDesc* id, BYTE** { // set JitEmitPrintRefRegs=1 will print out emitThisGCrefRegs and emitThisByrefRegs // at the beginning of this method. - static ConfigDWORD fJitEmitPrintRefRegs; - if (fJitEmitPrintRefRegs.val(CLRConfig::INTERNAL_JitEmitPrintRefRegs) != 0) + if (JitConfig.JitEmitPrintRefRegs() != 0) { printf("Before emitOutputInstr for id->idDebugOnlyInfo()->idNum=0x%02x\n", id->idDebugOnlyInfo()->idNum); printf(" emitThisGCrefRegs(0x%p)=", emitComp->dspPtr(&emitThisGCrefRegs)); @@ -11175,8 +11174,7 @@ size_t emitter::emitOutputInstr(insGroup* ig, instrDesc* id, BYTE** // For example, set JitBreakEmitOutputInstr=a6 will break when this method is called for // emitting instruction a6, (i.e. IN00a6 in jitdump). - static ConfigDWORD fJitBreakEmitOutputInstr; - if ((unsigned)fJitBreakEmitOutputInstr.val(CLRConfig::INTERNAL_JitBreakEmitOutputInstr) == id->idDebugOnlyInfo()->idNum) + if ((unsigned)JitConfig.JitBreakEmitOutputInstr() == id->idDebugOnlyInfo()->idNum) { assert(!"JitBreakEmitOutputInstr reached"); } diff --git a/src/jit/error.cpp b/src/jit/error.cpp index 2f30227cf3..b853b9f8ef 100644 --- a/src/jit/error.cpp +++ b/src/jit/error.cpp @@ -34,8 +34,7 @@ void DECLSPEC_NORETURN fatal(int errCode) #ifdef DEBUG if (errCode != CORJIT_SKIPPED) // Don't stop on NYI: use COMPLUS_AltJitAssertOnNYI for that. { - static ConfigDWORD fDebugBreakOnVerificationFailure; - if (fDebugBreakOnVerificationFailure.val(CLRConfig::INTERNAL_DebugBreakOnVerificationFailure)) + if (JitConfig.DebugBreakOnVerificationFailure()) { DebugBreak(); } @@ -90,8 +89,7 @@ void DECLSPEC_NORETURN noWayAssertBody() // have the assert code to fall back on here. // The debug path goes through this function also, to do the call to 'fatal'. // This kind of noway is hit for unreached(). - static ConfigDWORD fJitEnableNoWayAssert; - if (fJitEnableNoWayAssert.val(CLRConfig::INTERNAL_JitEnableNoWayAssert)) + if (JitConfig.JitEnableNoWayAssert()) { DebugBreak(); } @@ -172,9 +170,7 @@ void notYetImplemented(const char * msg, const char * filename, unsigned line) #endif // !DEBUG #endif // FUNC_INFO_LOGGING - static ConfigDWORD fAltJitAssertOnNYI; - - DWORD value = fAltJitAssertOnNYI.val(CLRConfig::INTERNAL_AltJitAssertOnNYI); + DWORD value = JitConfig.AltJitAssertOnNYI(); // 0 means just silently skip // If we are in retail builds, assume ignore @@ -237,8 +233,7 @@ LONG __JITfilter(PEXCEPTION_POINTERS pExceptionPointers, LPVOID lpvParam) DWORD getBreakOnBadCode() { - static ConfigDWORD fBreakOnBadCode; - return fBreakOnBadCode.val_DontUse_(CLRConfig::INTERNAL_JitBreakOnBadCode, false); + return JitConfig.JitBreakOnBadCode(); } /*****************************************************************************/ @@ -251,10 +246,9 @@ void debugError(const char* msg, const char* file, unsigned line) logf(LL_ERROR, "COMPILATION FAILED: file: %s:%d compiling method %s reason %s\n", file, line, env->compiler->info.compFullName, msg); - static ConfigDWORD fJitRequired; // We now only assert when user explicitly set ComPlus_JitRequired=1 // If ComPlus_JitRequired is 0 or is not set, we will not assert. - if (fJitRequired.val(CLRConfig::INTERNAL_JITRequired) == 1 || getBreakOnBadCode()) + if (JitConfig.JitRequired() == 1 || getBreakOnBadCode()) { // Don't assert if verification is done. if (!env->compiler->tiVerificationNeeded || getBreakOnBadCode()) @@ -323,8 +317,7 @@ void __cdecl assertAbort(const char *why, const char *file, unsigned line) // to the fallback JIT behavior. This is useful when doing ASM diffs, where we only want to see // the first assert for any function, but we don't want to kill the whole ngen process on the // first assert (which would happen if you used COMPLUS_NoGuiOnAssert=1 for example). - static ConfigDWORD fAltJitSkipOnAssert; - if (fAltJitSkipOnAssert.val(CLRConfig::INTERNAL_AltJitSkipOnAssert) != 0) + if (JitConfig.AltJitSkipOnAssert() != 0) { fatal(CORJIT_SKIPPED); } @@ -334,9 +327,7 @@ void __cdecl assertAbort(const char *why, const char *file, unsigned line) // When we are bringing up the new Arm64 JIT we set COMPLUS_ContinueOnAssert=1 // We only want to hit one assert then we will fall back to the interpreter. // - static ConfigDWORD s_InterpreterFallback; - - bool interpreterFallback = (s_InterpreterFallback.val(CLRConfig::INTERNAL_InterpreterFallback) != 0); + bool interpreterFallback = (JitConfig.InterpreterFallback() != 0); if (interpreterFallback) { @@ -360,8 +351,7 @@ int logf_stdout(const char* fmt, va_list args) char buffer[BUFF_SIZE]; int written = _vsnprintf_s(&buffer[0], BUFF_SIZE, _TRUNCATE, fmt, args); - static ConfigDWORD fJitDumpToDebugger; - if (fJitDumpToDebugger.val(CLRConfig::INTERNAL_JitDumpToDebugger)) + if (JitConfig.JitDumpToDebugger()) { OutputDebugStringA(buffer); } @@ -536,8 +526,7 @@ void DECLSPEC_NORETURN badCode3(const char* msg, const char* msg2, int arg, void noWayAssertAbortHelper(const char * cond, const char * file, unsigned line) { // Show the assert UI. - static ConfigDWORD fJitEnableNoWayAssert; - if (fJitEnableNoWayAssert.val(CLRConfig::INTERNAL_JitEnableNoWayAssert)) + if (JitConfig.JitEnableNoWayAssert()) { assertAbort(cond, file, line); } diff --git a/src/jit/flowgraph.cpp b/src/jit/flowgraph.cpp index 3af856f153..0dc9fe67bf 100644 --- a/src/jit/flowgraph.cpp +++ b/src/jit/flowgraph.cpp @@ -31,8 +31,7 @@ void Compiler::fgInit() #ifdef DEBUG fgInlinedCount = 0; - static ConfigDWORD fJitPrintInlinedMethods; - fgPrintInlinedMethods = fJitPrintInlinedMethods.val(CLRConfig::EXTERNAL_JitPrintInlinedMethods) == 1; + fgPrintInlinedMethods = JitConfig.JitPrintInlinedMethods() == 1; #endif // DEBUG /* We haven't yet computed the bbPreds lists */ @@ -163,12 +162,11 @@ void Compiler::fgInit() #ifdef DEBUG if (!compIsForInlining()) { - static ConfigDWORD fJitNoStructPromotion; - if ((fJitNoStructPromotion.val(CLRConfig::INTERNAL_JitNoStructPromotion) & 1) == 1) + if ((JitConfig.JitNoStructPromotion() & 1) == 1) { fgNoStructPromotion = true; } - if ((fJitNoStructPromotion.val(CLRConfig::INTERNAL_JitNoStructPromotion) & 2) == 2) + if ((JitConfig.JitNoStructPromotion() & 2) == 2) { fgNoStructParamPromotion = true; } @@ -10049,8 +10047,7 @@ void Compiler::fgCompactBlocks(BasicBlock* block, BasicBlock* bNe #endif #if DEBUG - static ConfigDWORD fSlowDebugChecksEnabled; - if (fSlowDebugChecksEnabled.val(CLRConfig::INTERNAL_JitSlowDebugChecksEnabled) != 0) + if (JitConfig.JitSlowDebugChecksEnabled() != 0) { // Make sure that the predecessor lists are accurate fgDebugCheckBBlist(); @@ -18914,21 +18911,15 @@ FILE* Compiler::fgOpenFlowGraphFile(bool* wbDontClose, Phases phas #ifdef DEBUG if (opts.eeFlags & CORJIT_FLG_PREJIT) { - static ConfigString sNgenDumpFg; - pattern = sNgenDumpFg.val(CLRConfig::INTERNAL_NgenDumpFg); - static ConfigString sNgenDumpFgFile; - filename = sNgenDumpFgFile.val(CLRConfig::INTERNAL_NgenDumpFgFile); - static ConfigString sNgenDumpFgDir; - pathname = sNgenDumpFgDir.val(CLRConfig::INTERNAL_NgenDumpFgDir); + pattern = JitConfig.NgenDumpFg(); + filename = JitConfig.NgenDumpFgFile(); + pathname = JitConfig.NgenDumpFgDir(); } else { - static ConfigString sJitDumpFg; - pattern = sJitDumpFg.val(CLRConfig::INTERNAL_JitDumpFg); - static ConfigString sJitDumpFgFile; - filename = sJitDumpFgFile.val(CLRConfig::INTERNAL_JitDumpFgFile); - static ConfigString sJitDumpFgDir; - pathname = sJitDumpFgDir.val(CLRConfig::INTERNAL_JitDumpFgDir); + pattern = JitConfig.JitDumpFg(); + filename = JitConfig.JitDumpFgFile(); + pathname = JitConfig.JitDumpFgDir(); } #endif // DEBUG @@ -18941,8 +18932,7 @@ FILE* Compiler::fgOpenFlowGraphFile(bool* wbDontClose, Phases phas if (wcslen(pattern) == 0) return NULL; - static ConfigString sJitDumpFgPhase; - LPCWSTR phasePattern = sJitDumpFgPhase.val(CLRConfig::INTERNAL_JitDumpFgPhase); + LPCWSTR phasePattern = JitConfig.JitDumpFgPhase(); LPCWSTR phaseName = PhaseShortNames[phase]; if (phasePattern == 0) { @@ -19204,9 +19194,8 @@ bool Compiler::fgDumpFlowGraph(Phases phase) { bool result = false; bool dontClose = false; - static ConfigDWORD fJitDumpFgDot; bool createDotFile = false; - if (fJitDumpFgDot.val(CLRConfig::INTERNAL_JitDumpFgDot)) + if (JitConfig.JitDumpFgDot()) { createDotFile = true; } diff --git a/src/jit/gcencode.cpp b/src/jit/gcencode.cpp index cae78c4df5..d5fff4833f 100644 --- a/src/jit/gcencode.cpp +++ b/src/jit/gcencode.cpp @@ -3325,13 +3325,12 @@ class GcInfoEncoderWithLogging { GcInfoEncoder* m_gcInfoEncoder; bool m_doLogging; - static ConfigDWORD s_fJitGCInfoLogging; public: GcInfoEncoderWithLogging(GcInfoEncoder* gcInfoEncoder, bool verbose) : m_gcInfoEncoder(gcInfoEncoder), - m_doLogging(verbose || s_fJitGCInfoLogging.val(CLRConfig::INTERNAL_JitGCInfoLogging) != 0) + m_doLogging(verbose || JitConfig.JitGCInfoLogging() != 0) {} GcSlotId GetStackSlotId( INT32 spOffset, GcSlotFlags flags, GcStackSlotBase spBase = GC_CALLER_SP_REL ) @@ -3484,8 +3483,6 @@ public: }; -ConfigDWORD GcInfoEncoderWithLogging::s_fJitGCInfoLogging; - #define GCENCODER_WITH_LOGGING(withLog, realEncoder) \ GcInfoEncoderWithLogging withLog ## Var(realEncoder, compiler->verbose || compiler->opts.dspGCtbls); \ GcInfoEncoderWithLogging * withLog = &withLog ## Var; diff --git a/src/jit/gentree.h b/src/jit/gentree.h index 08cc26473f..01878a1768 100644 --- a/src/jit/gentree.h +++ b/src/jit/gentree.h @@ -2649,8 +2649,7 @@ struct GenTreeIndex: public GenTreeOp gtStructElemClass(nullptr) // We always initialize this after construction. { #ifdef DEBUG - static ConfigDWORD fJitSkipArrayBoundCheck; - if (fJitSkipArrayBoundCheck.val(CLRConfig::INTERNAL_JitSkipArrayBoundCheck) == 1) + if (JitConfig.JitSkipArrayBoundCheck() == 1) { // Skip bounds check } diff --git a/src/jit/importer.cpp b/src/jit/importer.cpp index 0ad5dc2948..c865fb0f1d 100644 --- a/src/jit/importer.cpp +++ b/src/jit/importer.cpp @@ -71,8 +71,7 @@ void Compiler::impInit() #ifndef DEBUG impInlineSize = DEFAULT_MAX_INLINE_SIZE; #else - static ConfigDWORD fJitInlineSize; - impInlineSize = fJitInlineSize.val_DontUse_(CLRConfig::INTERNAL_JITInlineSize, DEFAULT_MAX_INLINE_SIZE); + impInlineSize = JitConfig.JitInlineSize(); if (compStressCompile(STRESS_INLINE, 50)) impInlineSize *= 10; @@ -191,8 +190,7 @@ inline void Compiler::verRaiseVerifyExceptionIfNeeded(INDEBUG(const char* msg) D const char* tail = strrchr(file, '\\'); if (tail) file = tail+1; - static ConfigDWORD fJitBreakOnUnsafeCode; - if (fJitBreakOnUnsafeCode.val(CLRConfig::INTERNAL_JitBreakOnUnsafeCode)) + if (JitConfig.JitBreakOnUnsafeCode()) assert(!"Unsafe code detected"); #endif @@ -3462,8 +3460,7 @@ void Compiler::verConvertBBToThrowVerificationException(BasicBlock* block printf("\n\nVerification failure: %s near IL %xh \n", info.compFullName, block->bbCodeOffs); } - static ConfigDWORD fDebugBreakOnVerificationFailure; - if (fDebugBreakOnVerificationFailure.val(CLRConfig::INTERNAL_DebugBreakOnVerificationFailure)) + if (JitConfig.DebugBreakOnVerificationFailure()) { DebugBreak(); } @@ -15621,8 +15618,7 @@ void Compiler::impCanInlineNative(int callsiteNativeEstima // effect of different values was within the standard deviation. This may be a place where future tuning // (with additional benchmarks) would be valuable. - static ConfigDWORD fJitInlineSIMDMultiplier; - int simdMultiplier = fJitInlineSIMDMultiplier.val(CLRConfig::INTERNAL_JitInlineSIMDMultiplier); + int simdMultiplier = JitConfig.JitInlineSIMDMultiplier(); multiplier += simdMultiplier; JITDUMP("\nInline candidate has SIMD type args, locals or return value. Multipler increased to %g.", multiplier); @@ -15711,8 +15707,7 @@ void Compiler::impCanInlineNative(int callsiteNativeEstima } #ifdef DEBUG - static ConfigDWORD fJitInlineAdditionalMultiplier; - int additionalMultiplier = fJitInlineAdditionalMultiplier.val(CLRConfig::EXTERNAL_JitInlineAdditionalMultiplier); + int additionalMultiplier = JitConfig.JitInlineAdditionalMultiplier(); if (additionalMultiplier!=0) { @@ -15930,8 +15925,7 @@ void Compiler::impCheckCanInline(GenTreePtr call, const char * className; methodName = pParam->pThis->eeGetMethodName(pParam->fncHandle, &className); - static ConfigDWORD fJitNoInline; - if (fJitNoInline.val(CLRConfig::INTERNAL_JitNoInline)) + if (JitConfig.JitNoInline()) { pParam->result->noteFatal(InlineObservation::CALLEE_IS_JIT_NOINLINE); goto _exit; diff --git a/src/jit/instr.cpp b/src/jit/instr.cpp index c6ca9d35c5..aca8b57ee4 100644 --- a/src/jit/instr.cpp +++ b/src/jit/instr.cpp @@ -3905,8 +3905,7 @@ void CodeGen::instGen_Return(unsigned stkArgSize) void CodeGen::instGen_MemoryBarrier() { #ifdef DEBUG - static ConfigDWORD fJitNoMemoryBarriers; - if (fJitNoMemoryBarriers.val(CLRConfig::INTERNAL_JitNoMemoryBarriers) == 1) + if (JitConfig.JitNoMemoryBarriers() == 1) return; #endif // DEBUG diff --git a/src/jit/jit.h b/src/jit/jit.h index af78504aa0..2b7fdf1357 100644 --- a/src/jit/jit.h +++ b/src/jit/jit.h @@ -199,6 +199,18 @@ #define __PLACEMENT_NEW_INLINE // don't bring in the global placement new, it is easy to make a mistake // with our new(compiler*) pattern. +#if COR_JIT_EE_VER > 460 +#define NO_CLRCONFIG // Don't bring in the usual CLRConfig infrastructure, since the JIT uses the JIT/EE + // interface to retrieve config values. + +// This is needed for contract.inl when FEATURE_STACK_PROBE is enabled. +struct CLRConfig +{ + static struct ConfigKey { } EXTERNAL_NO_SO_NOT_MAINLINE; + static DWORD GetConfigValue(const ConfigKey& key) { return 0; } +}; +#endif + #include "utilcode.h" // this defines assert as _ASSERTE #include "host.h" // this redefines assert for the JIT to use assertAbort #include "utils.h" @@ -520,8 +532,7 @@ extern JitOptions jitOpts; template<typename T> inline T UninitializedWord() { - static ConfigDWORD fDefaultFill; - __int64 word = 0x0101010101010101LL * (fDefaultFill.val(CLRConfig::INTERNAL_JitDefaultFill) & 0xFF); + __int64 word = 0x0101010101010101LL * (JitConfig.JitDefaultFill() & 0xFF); return (T)word; } diff --git a/src/jit/jit.settings.targets b/src/jit/jit.settings.targets index 5f93c539ea..0f3e9e4deb 100644 --- a/src/jit/jit.settings.targets +++ b/src/jit/jit.settings.targets @@ -81,6 +81,7 @@ <CppCompile Include="..\RangeCheck.cpp" /> <CppCompile Include="..\LoopCloning.cpp" /> <CppCompile Include="..\inline.cpp" /> + <CppCompile Include="..\jitconfig.cpp" /> <CppCompile Condition="'$(ClDefines.Contains(`LEGACY_BACKEND`))'=='True'" Include="..\CodeGenLegacy.cpp" /> <CppCompile Condition="'$(ClDefines.Contains(`LEGACY_BACKEND`))'=='False'" Include="..\Lower.cpp" /> <CppCompile Condition="'$(ClDefines.Contains(`LEGACY_BACKEND`))'=='False'" Include="..\LSRA.cpp" /> diff --git a/src/jit/jitconfig.cpp b/src/jit/jitconfig.cpp new file mode 100644 index 0000000000..da1875ca0e --- /dev/null +++ b/src/jit/jitconfig.cpp @@ -0,0 +1,298 @@ +// 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. + +#include "jitpch.h" +#ifdef _MSC_VER +#pragma hdrstop +#endif + +#include "jitconfig.h" + +JitConfigValues JitConfig; + +void JitConfigValues::MethodSet::initialize(const wchar_t* list, ICorJitHost* host) +{ + _ASSERTE(m_list == nullptr); + + enum State { NO_NAME, CLS_NAME, FUNC_NAME, ARG_LIST }; // parsing state machine + + const char SEP_CHAR = ' '; // current character use to separate each entry + + wchar_t lastChar = '?'; // dummy + int nameStart = -1; // Index of the start of the current class or method name + MethodName currentName; // Buffer used while parsing the current entry + MethodName** lastName = &m_names; // Last entry inserted into the list + bool isQuoted = false; + + currentName.m_next = nullptr; + currentName.m_methodNameStart = -1; + currentName.m_methodNameLen = -1; + currentName.m_classNameStart = -1; + currentName.m_classNameLen = -1; + currentName.m_numArgs = -1; + + // Convert the input list to UTF-8 + int utf8ListLen = WszWideCharToMultiByte(CP_UTF8, 0, list, -1, NULL, 0, NULL, NULL); + m_list = (char*)host->allocateMemory(utf8ListLen); + if (WszWideCharToMultiByte(CP_UTF8, 0, list, -1, const_cast<LPSTR>(m_list), utf8ListLen, NULL, NULL) == 0) + { + // Failed to convert the list. Free the memory and ignore the list. + host->freeMemory(reinterpret_cast<void*>(const_cast<char*>(m_list))); + m_list = ""; + return; + } + + State state = NO_NAME; + for (int i = 0; lastChar != '\0'; i++) + { + lastChar = m_list[i]; + + switch(state) + { + case NO_NAME: + if (m_list[i] != SEP_CHAR) + { + nameStart = i; + state = CLS_NAME; // we have found the start of the next entry + } + break; + + case CLS_NAME: + if (m_list[nameStart] == '"') + { + for (; m_list[i] != '\0' && m_list[i] != '"'; i++) + ; + + nameStart++; + isQuoted = true; + } + + if (m_list[i] == ':') + { + if (m_list[nameStart] == '*' && !isQuoted) + { + // The class name is a wildcard; mark it invalid. + currentName.m_classNameStart = -1; + currentName.m_classNameLen = -1; + } + else + { + currentName.m_classNameStart = nameStart; + currentName.m_classNameLen = i - nameStart; + + // Remove the trailing quote, if any + if (isQuoted) + { + currentName.m_classNameLen--; + isQuoted = false; + } + } + + // Accept class::name syntax as well + if (m_list[i + 1] == ':') + { + i++; + } + + nameStart = i + 1; + state = FUNC_NAME; + } + else if (m_list[i] == '\0' || m_list[i] == SEP_CHAR || m_list[i] == '(') + { + // Treat this as a method name without a class name. + currentName.m_classNameStart = -1; + currentName.m_classNameLen = -1; + goto DONE_FUNC_NAME; + } + break; + + case FUNC_NAME: + if (m_list[nameStart] == '"') + { + // The first half of the outer contdition handles the case where the + // class name is valid. + for (; nameStart == i || (m_list[i] != '\0' && m_list[i] != '"'); i++) + ; + + nameStart++; + isQuoted = true; + } + + if (m_list[i] == '\0' || m_list[i] == SEP_CHAR || m_list[i] == '(') + { + DONE_FUNC_NAME: + _ASSERTE(m_list[i] == '\0' || m_list[i] == SEP_CHAR || m_list[i] == '('); + + if (m_list[nameStart] == '*' && !isQuoted) + { + // The method name is a wildcard; mark it invalid. + currentName.m_methodNameStart = -1; + currentName.m_methodNameLen = -1; + } + else + { + currentName.m_methodNameStart = nameStart; + currentName.m_methodNameLen = i - nameStart; + + // Remove the trailing quote, if any + if (isQuoted) + { + currentName.m_classNameLen--; + isQuoted = false; + } + } + + if (m_list[i] == '\0' || m_list[i] == SEP_CHAR) + { + currentName.m_numArgs = -1; + goto DONE_ARG_LIST; + } + else + { + _ASSERTE(m_list[i] == '('); + currentName.m_numArgs = -1; + state = ARG_LIST; + } + } + break; + + case ARG_LIST: + if (m_list[i] == '\0' || m_list[i] == ')') + { + if (currentName.m_numArgs == -1) + { + currentName.m_numArgs = 0; + } + + DONE_ARG_LIST: + _ASSERTE(m_list[i] == '\0' || m_list[i] == SEP_CHAR || m_list[i] == ')'); + + // We have parsed an entire method name; create a new entry in the list for it. + MethodName* name = (MethodName*)host->allocateMemory(sizeof(MethodName)); + *name = currentName; + + _ASSERTE(name->m_next == nullptr); + *lastName = name; + lastName = &name->m_next; + + state = NO_NAME; + + // Skip anything after the argument list until we find the next + // separator character. Otherwise if we see "func(a,b):foo" we + // create entries for "func(a,b)" as well as ":foo". + if (m_list[i] == ')') + { + for (; m_list[i] && m_list[i] != SEP_CHAR; i++) + ; + + lastChar = m_list[i]; + } + } + else + { + if (m_list[i] != SEP_CHAR && currentName.m_numArgs == -1) + { + currentName.m_numArgs = 1; + } + + if (m_list[i] == ',') + { + currentName.m_numArgs++; + } + } + break; + + default: + _ASSERTE(!"Bad state"); + break; + } + } +} + +static bool matchesName(const char* const name, int nameLen, const char* const s2) +{ + return strncmp(name, s2, nameLen) == 0 && s2[nameLen] == '\0'; +} + +bool JitConfigValues::MethodSet::contains(const char* methodName, const char* className, CORINFO_SIG_INFO* sigInfo) const +{ + int numArgs = sigInfo != nullptr ? sigInfo->numArgs : -1; + + // Try to match any the entries in the list. + for (MethodName* name = m_names; name != nullptr; name = name->m_next) + { + // If m_numArgs is valid, check for a mismatch + if (name->m_numArgs != -1 && name->m_numArgs != numArgs) + { + continue; + } + + // If m_methodNameStart is valid, check for a mismatch + if (name->m_methodNameStart != -1) + { + const char* expectedMethodName = &m_list[name->m_methodNameStart]; + if (!matchesName(expectedMethodName, name->m_methodNameLen, methodName)) + { + // C++ embeds the class name into the method name; deal with that here. + const char* colon = strchr(methodName, ':'); + if (colon != nullptr && colon[1] == ':' && matchesName(expectedMethodName, name->m_methodNameLen, methodName)) + { + int classLen = (int)(colon - methodName); + if (name->m_classNameStart == -1 || + (classLen == name->m_classNameLen && + strncmp(&m_list[name->m_classNameStart], methodName, classLen) == 0)) + { + return true; + } + } + continue; + } + } + + // If m_classNameStart is valid, check for a mismatch + if (className == nullptr || name->m_classNameStart == -1 || matchesName(&m_list[name->m_classNameStart], name->m_classNameLen, className)) + { + return true; + } + + // Check for suffix wildcard like System.* + if (name->m_classNameLen > 0 && + m_list[name->m_classNameStart + name->m_classNameLen - 1] == '*' && + strncmp(&m_list[name->m_classNameStart], className, name->m_classNameLen - 1) == 0) + { + return true; + } + +#ifdef _DEBUG + // Maybe className doesn't include the namespace. Try to match that + const char* nsSep = strrchr(className, '.'); + if (nsSep != nullptr && nsSep != className) + { + const char* onlyClass = nsSep[-1] == '.' ? nsSep : &nsSep[1]; + if (matchesName(&m_list[name->m_classNameStart], name->m_classNameLen, onlyClass)) + { + return true; + } + } +#endif + } + + return false; +} + +void JitConfigValues::initialize(ICorJitHost* host) +{ + _ASSERTE(!m_isInitialized); + +#define CONFIG_INTEGER(name, key, defaultValue) m_##name = host->getIntConfigValue(key, defaultValue); +#define CONFIG_STRING(name, key) m_##name = host->getStringConfigValue(key); +#define CONFIG_METHODSET(name, key) \ + const wchar_t* name##value = host->getStringConfigValue(key); \ + m_##name.initialize(name##value, host); \ + host->freeStringConfigValue(name##value); + +#include "jitconfigvalues.h" + + m_isInitialized = true; +} diff --git a/src/jit/jitconfig.h b/src/jit/jitconfig.h new file mode 100644 index 0000000000..9da5808a5a --- /dev/null +++ b/src/jit/jitconfig.h @@ -0,0 +1,70 @@ +// 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. + +#ifndef _JITCONFIG_H_ +#define _JITCONFIG_H_ + +struct CORINFO_SIG_INFO; +class ICorJitHost; + +class JitConfigValues +{ +public: + class MethodSet + { + private: + struct MethodName + { + MethodName* m_next; + int m_methodNameStart; + int m_methodNameLen; + int m_classNameStart; + int m_classNameLen; + int m_numArgs; + }; + + const char* m_list; + MethodName* m_names; + + MethodSet(const MethodSet& other) = delete; + MethodSet& operator=(const MethodSet& other) = delete; + + public: + MethodSet() { } + inline const char* list() const { return m_list; } + + void initialize(const wchar_t* list, ICorJitHost* host); + + inline bool isEmpty() const { return m_names == nullptr; } + bool contains(const char* methodName, const char* className, CORINFO_SIG_INFO* sigInfo) const; + }; + +private: +#define CONFIG_INTEGER(name, key, defaultValue) int m_##name; +#define CONFIG_STRING(name, key) const wchar_t* m_##name; +#define CONFIG_METHODSET(name, key) MethodSet m_##name; +#include "jitconfigvalues.h" + +public: +#define CONFIG_INTEGER(name, key, defaultValue) inline int name() const { return m_##name; } +#define CONFIG_STRING(name, key) inline const wchar_t* name() const { return m_##name; } +#define CONFIG_METHODSET(name, key) inline const MethodSet& name() const { return m_##name; } +#include "jitconfigvalues.h" + +private: + bool m_isInitialized; + + JitConfigValues(const JitConfigValues& other) = delete; + JitConfigValues& operator=(const JitConfigValues& other) = delete; + +public: + JitConfigValues() {} + + inline bool isInitialized() const { return m_isInitialized != 0; } + void initialize(ICorJitHost* host); +}; + +extern JitConfigValues JitConfig; + +#endif diff --git a/src/jit/jitconfigvalues.h b/src/jit/jitconfigvalues.h new file mode 100644 index 0000000000..8136517078 --- /dev/null +++ b/src/jit/jitconfigvalues.h @@ -0,0 +1,193 @@ +// 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. + +#if !defined(CONFIG_INTEGER) || !defined(CONFIG_STRING) || !defined(CONFIG_METHODSET) +#error CONFIG_INTEGER, CONFIG_STRING, and CONFIG_METHODSET must be defined before including this file. +#endif // !defined(CONFIG_INTEGER) || !defined(CONFIG_STRING) || !defined(CONFIG_METHODSET) + +#if defined(DEBUG) +CONFIG_INTEGER(AltJitLimit, W("AltJitLimit"), 0) // Max number of functions to use altjit for (decimal) +CONFIG_INTEGER(AltJitSkipOnAssert, W("AltJitSkipOnAssert"), 0) // If AltJit hits an assert, fall back to the fallback JIT. Useful in conjunction with COMPLUS_ContinueOnAssert=1 +CONFIG_INTEGER(BreakOnDumpToken, W("BreakOnDumpToken"), 0xffffffff) // Breaks when using internal logging on a particular token value. +CONFIG_INTEGER(DebugBreakOnVerificationFailure, W("DebugBreakOnVerificationFailure"), 0) // Halts the jit on verification failure +CONFIG_INTEGER(DiffableDasm, W("JitDiffableDasm"), 0) // Make the disassembly diff-able +CONFIG_INTEGER(DisplayLoopHoistStats, W("JitLoopHoistStats"), 0) // Display JIT loop hoisting statistics +CONFIG_INTEGER(DisplayMemStats, W("JitMemStats"), 0) // Display JIT memory usage statistics +CONFIG_INTEGER(DumpJittedMethods, W("DumpJittedMethods"), 0) // Prints all jitted methods to the console +CONFIG_INTEGER(EnablePCRelAddr, W("JitEnablePCRelAddr"), 1) // Whether absolute addr be encoded as PC-rel offset by RyuJIT where possible +CONFIG_INTEGER(InterpreterFallback, W("InterpreterFallback"), 0) // Fallback to the interpreter when the JIT compiler fails +CONFIG_INTEGER(JitAssertOnMaxRAPasses, W("JitAssertOnMaxRAPasses"), 0) +CONFIG_INTEGER(JitBreakEmitOutputInstr, W("JitBreakEmitOutputInstr"), -1) +CONFIG_INTEGER(JitBreakMorphTree, W("JitBreakMorphTree"), 0xffffffff) +CONFIG_INTEGER(JitBreakOnBadCode, W("JitBreakOnBadCode"), 0) +CONFIG_INTEGER(JitBreakOnMinOpts, W("JITBreakOnMinOpts"), 0) // Halt if jit switches to MinOpts +CONFIG_INTEGER(JitBreakOnUnsafeCode, W("JitBreakOnUnsafeCode"), 0) +CONFIG_INTEGER(JitCanUseSSE2, W("JitCanUseSSE2"), -1) +CONFIG_INTEGER(JitCloneLoops, W("JitCloneLoops"), 1) // If 0, don't clone. Otherwise clone loops for optimizations. +CONFIG_INTEGER(JitDebugLogLoopCloning, W("JitDebugLogLoopCloning"), 0) // In debug builds log places where loop cloning optimizations are performed on the fast path. +CONFIG_INTEGER(JitDefaultFill, W("JitDefaultFill"), 0xff) // In debug builds, initialize the memory allocated by the nra with this byte. +CONFIG_INTEGER(JitDirectAlloc, W("JitDirectAlloc"), 0) +CONFIG_INTEGER(JitDoAssertionProp, W("JitDoAssertionProp"), 1) // Perform assertion propagation optimization +CONFIG_INTEGER(JitDoCopyProp, W("JitDoCopyProp"), 1) // Perform copy propagation on variables that appear redundant +CONFIG_INTEGER(JitDoEarlyProp, W("JitDoEarlyProp"), 1) // Perform Early Value Propagataion +CONFIG_INTEGER(JitDoLoopHoisting, W("JitDoLoopHoisting"), 1) // Perform loop hoisting on loop invariant values +CONFIG_INTEGER(JitDoRangeAnalysis, W("JitDoRangeAnalysis"), 1) // Perform range check analysis +CONFIG_INTEGER(JitDoSsa, W("JitDoSsa"), 1) // Perform Static Single Assignment (SSA) numbering on the variables +CONFIG_INTEGER(JitDoValueNumber, W("JitDoValueNumber"), 1) // Perform value numbering on method expressions +CONFIG_INTEGER(JitDoubleAlign, W("JitDoubleAlign"), 1) +CONFIG_INTEGER(JitDumpASCII, W("JitDumpASCII"), 1) // Uses only ASCII characters in tree dumps +CONFIG_INTEGER(JitDumpFgDot, W("JitDumpFgDot"), 0) // Set to non-zero to emit Dot instead of Xml Flowgraph dump +CONFIG_INTEGER(JitDumpTerseLsra, W("JitDumpTerseLsra"), 1) // Produce terse dump output for LSRA +CONFIG_INTEGER(JitDumpToDebugger, W("JitDumpToDebugger"), 0) // Output JitDump output to the debugger +CONFIG_INTEGER(JitDumpVerboseSsa, W("JitDumpVerboseSsa"), 0) // Produce especially verbose dump output for SSA +CONFIG_INTEGER(JitDumpVerboseTrees, W("JitDumpVerboseTrees"), 0) // Enable more verbose tree dumps +CONFIG_INTEGER(JitEmitPrintRefRegs, W("JitEmitPrintRefRegs"), 0) +CONFIG_INTEGER(JitExpensiveDebugCheckLevel, W("JitExpensiveDebugCheckLevel"), 0) // Level indicates how much checking beyond the default to do in debug builds (currently 1-2) +CONFIG_INTEGER(JitForceFallback, W("JitForceFallback"), 0) // Set to non-zero to test NOWAY assert by forcing a retry +CONFIG_INTEGER(JitForceVer, W("JitForceVer"), 0) +CONFIG_INTEGER(JitFullyInt, W("JitFullyInt"), 0) // Forces Fully interruptable code +CONFIG_INTEGER(JitFunctionTrace, W("JitFunctionTrace"), 0) // If non-zero, print JIT start/end logging +CONFIG_INTEGER(JitGCChecks, W("JitGCChecks"), 0) +CONFIG_INTEGER(JitGCInfoLogging, W("JitGCInfoLogging"), 0) // If true, prints GCInfo-related output to standard output. +CONFIG_INTEGER(JitHashBreak, W("JitHashBreak"), -1) // Same as JitBreak, but for a method hash +CONFIG_INTEGER(JitHashDump, W("JitHashDump"), -1) // Same as JitDump, but for a method hash +CONFIG_INTEGER(JitHashDumpIR, W("JitHashDumpIR"), -1) // Same as JitDumpIR, but for a method hash +CONFIG_INTEGER(JitHashHalt, W("JitHashHalt"), -1) // Same as JitHalt, but for a method hash +CONFIG_INTEGER(JitInlineAdditionalMultiplier, W("JitInlineAdditionalMultiplier"), 0) +CONFIG_INTEGER(JitInlinePrintStats, W("JitInlinePrintStats"), 0) +CONFIG_INTEGER(JitInlineSize, W("JITInlineSize"), DEFAULT_MAX_INLINE_SIZE) +CONFIG_INTEGER(JitLargeBranches, W("JitLargeBranches"), 0) // Force using the largest conditional branch format +CONFIG_INTEGER(JitMaxTempAssert, W("JITMaxTempAssert"), 1) +CONFIG_INTEGER(JitMaxUncheckedOffset, W("JitMaxUncheckedOffset"), 8) +CONFIG_INTEGER(JitMinOpts, W("JITMinOpts"), 0) // Forces MinOpts +CONFIG_INTEGER(JitMinOptsBbCount, W("JITMinOptsBbCount"), DEFAULT_MIN_OPTS_BB_COUNT) // Internal jit control of MinOpts +CONFIG_INTEGER(JitMinOptsCodeSize, W("JITMinOptsCodeSize"), DEFAULT_MIN_OPTS_CODE_SIZE) // Internal jit control of MinOpts +CONFIG_INTEGER(JitMinOptsInstrCount, W("JITMinOptsInstrCount"), DEFAULT_MIN_OPTS_INSTR_COUNT) // Internal jit control of MinOpts +CONFIG_INTEGER(JitMinOptsLvNumCount, W("JITMinOptsLvNumcount"), DEFAULT_MIN_OPTS_LV_NUM_COUNT) // Internal jit control of MinOpts +CONFIG_INTEGER(JitMinOptsLvRefCount, W("JITMinOptsLvRefcount"), DEFAULT_MIN_OPTS_LV_REF_COUNT) // Internal jit control of MinOpts +CONFIG_INTEGER(JitNoCMOV, W("JitNoCMOV"), 0) +CONFIG_INTEGER(JitNoCSE, W("JitNoCSE"), 0) +CONFIG_INTEGER(JitNoCSE2, W("JitNoCSE2"), 0) +CONFIG_INTEGER(JitNoForceFallback, W("JitNoForceFallback"), 0) // Set to non-zero to prevent NOWAY assert testing. Overrides COMPLUS_JitForceFallback and JIT stress flags. +CONFIG_INTEGER(JitNoHoist, W("JitNoHoist"), 0) +CONFIG_INTEGER(JitNoInline, W("JitNoInline"), 0) // Disables inlining of all methods +CONFIG_INTEGER(JitNoMemoryBarriers, W("JitNoMemoryBarriers"), 0) // If 1, don't generate memory barriers +CONFIG_INTEGER(JitNoRegLoc, W("JitNoRegLoc"), 0) +CONFIG_INTEGER(JitNoStructPromotion, W("JitNoStructPromotion"), 0) // Disables struct promotion in Jit32 +CONFIG_INTEGER(JitNoUnroll, W("JitNoUnroll"), 0) +CONFIG_INTEGER(JitOrder, W("JitOrder"), 0) +CONFIG_INTEGER(JitPInvokeCheckEnabled, W("JITPInvokeCheckEnabled"), 0) +CONFIG_INTEGER(JitPInvokeEnabled, W("JITPInvokeEnabled"), 1) +CONFIG_INTEGER(JitPrintInlinedMethods, W("JitPrintInlinedMethods"), 0) +CONFIG_INTEGER(JitRequired, W("JITRequired"), -1) +CONFIG_INTEGER(JitRoundFloat, W("JITRoundFloat"), DEFAULT_ROUND_LEVEL) +CONFIG_INTEGER(JitSkipArrayBoundCheck, W("JitSkipArrayBoundCheck"), 0) +CONFIG_INTEGER(JitSlowDebugChecksEnabled, W("JitSlowDebugChecksEnabled"), 1) // Turn on slow debug checks +CONFIG_INTEGER(JitSplitFunctionSize, W("JitSplitFunctionSize"), 0) // On ARM, use this as the maximum function/funclet size for creating function fragments (and creating multiple RUNTIME_FUNCTION entries) +CONFIG_INTEGER(JitSsaStress, W("JitSsaStress"), 0) // Perturb order of processing of blocks in SSA; 0 = no stress; 1 = use method hash; * = supplied value as random hash +CONFIG_INTEGER(JitStackChecks, W("JitStackChecks"), 0) +CONFIG_INTEGER(JitStress, W("JitStress"), 0) // Internal Jit stress mode: 0 = no stress, 2 = all stress, other = vary stress based on a hash of the method and this value +CONFIG_INTEGER(JitStressBBProf, W("JitStressBBProf"), 0) // Internal Jit stress mode +CONFIG_INTEGER(JitStressBiasedCSE, W("JitStressBiasedCSE"), 0x101) // Internal Jit stress mode: decimal bias value between (0,100) to perform CSE on a candidate. 100% = All CSEs. 0% = 0 CSE. (> 100) means no stress. +CONFIG_INTEGER(JitStressFP, W("JitStressFP"), 0) // Internal Jit stress mode +CONFIG_INTEGER(JitStressRegs, W("JitStressRegs"), 0) +CONFIG_INTEGER(JitStrictCheckForNonVirtualCallToVirtualMethod, W("JitStrictCheckForNonVirtualCallToVirtualMethod"), 1) +CONFIG_INTEGER(JitVNMapSelLimit, W("JitVNMapSelLimit"), 0) // If non-zero, assert if # of VNF_MapSelect applications considered reaches this +CONFIG_INTEGER(NgenHashDump, W("NgenHashDump"), -1) // same as JitHashDump, but for ngen +CONFIG_INTEGER(NgenHashDumpIR, W("NgenHashDumpIR"), -1) // same as JitHashDumpIR, but for ngen +CONFIG_INTEGER(NgenOrder, W("NgenOrder"), 0) +CONFIG_INTEGER(RunAltJitCode, W("RunAltJitCode"), 1) // If non-zero, and the compilation succeeds for an AltJit, then use the code. If zero, then we always throw away the generated code and fall back to the default compiler. +CONFIG_INTEGER(RunComponentUnitTests, W("JitComponentUnitTests"), 0) // Run JIT component unit tests +CONFIG_INTEGER(ShouldInjectFault, W("InjectFault"), 0) +CONFIG_INTEGER(StackProbesOverride, W("JitStackProbes"), 0) +CONFIG_INTEGER(StressCOMCall, W("StressCOMCall"), 0) +CONFIG_INTEGER(TailcallStress, W("TailcallStress"), 0) +CONFIG_INTEGER(TreesBeforeAfterMorph, W("JitDumpBeforeAfterMorph"), 0) // If 1, display each tree before/after morphing +CONFIG_METHODSET(JitBreak, W("JitBreak")) // Stops in the importer when compiling a specified method +CONFIG_METHODSET(JitDebugBreak, W("JitDebugBreak")) +CONFIG_METHODSET(JitDisasm, W("JitDisasm")) // Dumps disassembly for specified method +CONFIG_METHODSET(JitDump, W("JitDump")) // Dumps trees for specified method +CONFIG_METHODSET(JitDumpIR, W("JitDumpIR")) // Dumps trees (in linear IR form) for specified method +CONFIG_METHODSET(JitEHDump, W("JitEHDump")) // Dump the EH table for the method, as reported to the VM +CONFIG_METHODSET(JitExclude, W("JitExclude")) +CONFIG_METHODSET(JitForceProcedureSplitting, W("JitForceProcedureSplitting")) +CONFIG_METHODSET(JitGCDump, W("JitGCDump")) +CONFIG_METHODSET(JitHalt, W("JitHalt")) // Emits break instruction into jitted code +CONFIG_METHODSET(JitImportBreak, W("JitImportBreak")) +CONFIG_METHODSET(JitInclude, W("JitInclude")) +CONFIG_METHODSET(JitLateDisasm, W("JitLateDisasm")) +CONFIG_METHODSET(JitMinOptsName, W("JITMinOptsName")) // Forces MinOpts for a named function +CONFIG_METHODSET(JitNoProcedureSplitting, W("JitNoProcedureSplitting")) // Disallow procedure splitting for specified methods +CONFIG_METHODSET(JitNoProcedureSplittingEH, W("JitNoProcedureSplittingEH")) // Disallow procedure splitting for specified methods if they contain exception handling +CONFIG_METHODSET(JitStressOnly, W("JitStressOnly")) // Internal Jit stress mode: stress only the specified method(s) +CONFIG_METHODSET(JitUnwindDump, W("JitUnwindDump")) // Dump the unwind codes for the method +CONFIG_METHODSET(NgenDisasm, W("NgenDisasm")) // Same as JitDisasm, but for ngen +CONFIG_METHODSET(NgenDump, W("NgenDump")) // Same as JitDump, but for ngen +CONFIG_METHODSET(NgenDumpIR, W("NgenDumpIR")) // Same as JitDumpIR, but for ngen +CONFIG_METHODSET(NgenEHDump, W("NgenEHDump")) // Dump the EH table for the method, as reported to the VM +CONFIG_METHODSET(NgenGCDump, W("NgenGCDump")) +CONFIG_METHODSET(NgenUnwindDump, W("NgenUnwindDump")) // Dump the unwind codes for the method +CONFIG_STRING(JitDumpFg, W("JitDumpFg")) // Dumps Xml/Dot Flowgraph for specified method +CONFIG_STRING(JitDumpFgDir, W("JitDumpFgDir")) // Directory for Xml/Dot flowgraph dump(s) +CONFIG_STRING(JitDumpFgFile, W("JitDumpFgFile")) // Filename for Xml/Dot flowgraph dump(s) +CONFIG_STRING(JitDumpFgPhase, W("JitDumpFgPhase")) // Phase-based Xml/Dot flowgraph support. Set to the short name of a phase to see the flowgraph after that phase. Leave unset to dump after COLD-BLK (determine first cold block) or set to * for all phases +CONFIG_STRING(JitDumpIRFormat, W("JitDumpIRFormat")) // Comma separated format control for JitDumpIR, values = {types | locals | ssa | valnums | kinds | flags | nodes | nolists | nostmts | noleafs | trees | dataflow} +CONFIG_STRING(JitDumpIRPhase, W("JitDumpIRPhase")) // Phase control for JitDumpIR, values = {* | phasename} +CONFIG_STRING(JitLateDisasmTo, W("JITLateDisasmTo")) +CONFIG_STRING(JitRange, W("JitRange")) +CONFIG_STRING(JitStressModeNames, W("JitStressModeNames")) // Internal Jit stress mode: stress using the given set of stress mode names, e.g. STRESS_REGS, STRESS_TAILCALL +CONFIG_STRING(JitStressModeNamesNot, W("JitStressModeNamesNot")) // Internal Jit stress mode: do NOT stress using the given set of stress mode names, e.g. STRESS_REGS, STRESS_TAILCALL +CONFIG_STRING(JitStressRange, W("JitStressRange")) // Internal Jit stress mode +CONFIG_STRING(NgenDumpFg, W("NgenDumpFg")) // Ngen Xml Flowgraph support +CONFIG_STRING(NgenDumpFgDir, W("NgenDumpFgDir")) // Ngen Xml Flowgraph support +CONFIG_STRING(NgenDumpFgFile, W("NgenDumpFgFile")) // Ngen Xml Flowgraph support +CONFIG_STRING(NgenDumpIRFormat, W("NgenDumpIRFormat")) // Same as JitDumpIRFormat, but for ngen +CONFIG_STRING(NgenDumpIRPhase, W("NgenDumpIRPhase")) // Same as JitDumpIRPhase, but for ngen +#endif // defined(DEBUG) + +// AltJitAssertOnNYI should be 0 on targets where JIT is under developement or bring up stage, so as to facilitate fallback to main JIT on hitting a NYI. +#if defined(_TARGET_ARM64_) || defined(_TARGET_X86_) +CONFIG_INTEGER(AltJitAssertOnNYI, W("AltJitAssertOnNYI"), 0) // Controls the AltJit behavior of NYI stuff +#else // !defined(_TARGET_ARM64_) && !defined(_TARGET_X86_) +CONFIG_INTEGER(AltJitAssertOnNYI, W("AltJitAssertOnNYI"), 1) // Controls the AltJit behavior of NYI stuff +#endif // defined(_TARGET_ARM64_) || defined(_TARGET_X86_) + +#if defined(_TARGET_AMD64_) +CONFIG_INTEGER(EnableAVX, W("EnableAVX"), 1) // Enable AVX instruction set for wide operations as default +#else // !defined(_TARGET_AMD64_) +CONFIG_INTEGER(EnableAVX, W("EnableAVX"), 0) // Enable AVX instruction set for wide operations as default +#endif // defined(_TARGET_AMD64_) + +#if (!defined(DEBUG) && !defined(_DEBUG)) || (defined(CROSSGEN_COMPILE) && !defined(FEATURE_CORECLR)) +CONFIG_INTEGER(JitEnableNoWayAssert, W("JitEnableNoWayAssert"), 0) +#else // (defined(DEBUG) || defined(_DEBUG)) && (!defined(CROSSGEN_COMPILE) || defined(FEATURE_CORECLR)) +CONFIG_INTEGER(JitEnableNoWayAssert, W("JitEnableNoWayAssert"), 1) +#endif // (!defined(DEBUG) && !defined(_DEBUG)) || (defined(CROSSGEN_COMPILE) && !defined(FEATURE_CORECLR)) + +CONFIG_INTEGER(JitAggressiveInlining, W("JitAggressiveInlining"), 0) // Aggressive inlining of all methods +CONFIG_INTEGER(JitELTHookEnabled, W("JitELTHookEnabled"), 0) // On ARM, setting this will emit Enter/Leave/TailCall callbacks +CONFIG_INTEGER(JitInlineSIMDMultiplier, W("JitInlineSIMDMultiplier"), 3) + +#if defined(FEATURE_ENABLE_NO_RANGE_CHECKS) +CONFIG_INTEGER(JitNoRngChks, W("JitNoRngChks"), 0) // If 1, don't generate range checks +#endif // defined(FEATURE_ENABLE_NO_RANGE_CHECKS) + +CONFIG_INTEGER(JitRegisterFP, W("JitRegisterFP"), 3) // Control FP enregistration +CONFIG_INTEGER(JitTelemetry, W("JitTelemetry"), 1) // If non-zero, gather JIT telemetry data +CONFIG_INTEGER(JitVNMapSelBudget, W("JitVNMapSelBudget"), 100) // Max # of MapSelect's considered for a particular top-level invocation. +CONFIG_INTEGER(TailCallLoopOpt, W("TailCallLoopOpt"), 1) // Convert recursive tail calls to loops +CONFIG_METHODSET(AltJit, W("AltJit")) // Enables AltJit and selectively limits it to the specified methods. +CONFIG_METHODSET(AltJitNgen, W("AltJitNgen")) // Enables AltJit for NGEN and selectively limits it to the specified methods. + +#if defined(ALT_JIT) +CONFIG_STRING(AltJitExcludeAssemblies, W("AltJitExcludeAssemblies")) // Do not use AltJit on this semicolon-delimited list of assemblies. +#endif // defined(ALT_JIT) + +CONFIG_STRING(JitFuncInfoFile, W("JitFuncInfoLogFile")) // If set, gather JIT function info and write to this file. +CONFIG_STRING(JitTimeLogCsv, W("JitTimeLogCsv")) // If set, gather JIT throughput data and write to a CSV file. This mode must be used in internal retail builds. +CONFIG_STRING(TailCallOpt, W("TailCallOpt")) + +#undef CONFIG_INTEGER +#undef CONFIG_STRING +#undef CONFIG_METHODSET diff --git a/src/jit/jitpch.h b/src/jit/jitpch.h index a3c7e24464..58c9c6bd95 100644 --- a/src/jit/jitpch.h +++ b/src/jit/jitpch.h @@ -20,6 +20,7 @@ #include "corjithost.h" #include "jithost.h" #endif +#include "jitconfig.h" #include "jit.h" #include "iallocator.h" #include "hashbv.h" diff --git a/src/jit/jittelemetry.cpp b/src/jit/jittelemetry.cpp index cac324f6b2..1b79272991 100644 --- a/src/jit/jittelemetry.cpp +++ b/src/jit/jittelemetry.cpp @@ -158,8 +158,7 @@ void JitTelemetry::Initialize(Compiler* c) /* static */ bool JitTelemetry::IsTelemetryEnabled() { - static ConfigDWORD fJitTelemetry; - return fJitTelemetry.val(CLRConfig::EXTERNAL_JitTelemetry) != 0; + return JitConfig.JitTelemetry() != 0; } //------------------------------------------------------------------------ diff --git a/src/jit/lsra.cpp b/src/jit/lsra.cpp index 9fbf0a9550..7541c36568 100644 --- a/src/jit/lsra.cpp +++ b/src/jit/lsra.cpp @@ -952,8 +952,7 @@ LinearScan::LinearScan(Compiler * theCompiler) initRefTypeNames(); // Get the value of the environment variable that controls stress for register allocation - static ConfigDWORD fJitStressRegs; - lsraStressMask = fJitStressRegs.val(CLRConfig::INTERNAL_JitStressRegs); + lsraStressMask = JitConfig.JitStressRegs(); #if 0 #ifdef DEBUG if (lsraStressMask != 0) @@ -990,8 +989,7 @@ LinearScan::LinearScan(Compiler * theCompiler) #endif // DEBUG #endif - static ConfigDWORD fJitDumpTerseLsra; - dumpTerse = (fJitDumpTerseLsra.val(CLRConfig::INTERNAL_JitDumpTerseLsra) != 0); + dumpTerse = (JitConfig.JitDumpTerseLsra() != 0); #endif // DEBUG refPositionCount = 0; diff --git a/src/jit/morph.cpp b/src/jit/morph.cpp index 4591a03d41..016f432978 100644 --- a/src/jit/morph.cpp +++ b/src/jit/morph.cpp @@ -12854,8 +12854,7 @@ GenTreePtr Compiler::fgMorphTree(GenTreePtr tree, MorphAddrContext* mac #ifdef DEBUG if (verbose) { - static ConfigDWORD fBreakOnMorphTree; - if (fBreakOnMorphTree.val(CLRConfig::INTERNAL_JitBreakMorphTree) == tree->gtTreeID) + if ((unsigned)JitConfig.JitBreakMorphTree() == tree->gtTreeID) { noway_assert(!"JitBreakMorphTree hit"); } @@ -14240,8 +14239,7 @@ void Compiler::fgSetOptions() /* Should we force fully interruptible code ? */ #ifdef DEBUG - static ConfigDWORD fJitFullyInt; - if (fJitFullyInt.val(CLRConfig::INTERNAL_JitFullyInt) || + if (JitConfig.JitFullyInt() || compStressCompile(STRESS_GENERIC_VARN, 30)) { noway_assert(!codeGen->isGCTypeFixed()); diff --git a/src/jit/optcse.cpp b/src/jit/optcse.cpp index e1d78690fe..61f99047af 100644 --- a/src/jit/optcse.cpp +++ b/src/jit/optcse.cpp @@ -1290,9 +1290,8 @@ public: } // Obtain the bias value and reinterpret as decimal. - static ConfigDWORD fJitStressBiasedCSE; unsigned bias = ReinterpretHexAsDecimal( - fJitStressBiasedCSE.val(CLRConfig::INTERNAL_JitStressBiasedCSE)); + JitConfig.JitStressBiasedCSE()); // Invalid value, check if JitStress is ON. if (bias > 100) @@ -2286,8 +2285,7 @@ bool Compiler::optConfigDisableCSE(bool lexicalCSE) // Next check if COMPLUS_JitNoCSE is set and applies to this method // - static ConfigDWORD fJitNoCSE; - unsigned jitNoCSE = fJitNoCSE.val(CLRConfig::INTERNAL_JitNoCSE); + unsigned jitNoCSE = JitConfig.JitNoCSE(); if (jitNoCSE > 0) { @@ -2327,8 +2325,7 @@ bool Compiler::optConfigDisableCSE2() { static unsigned totalCSEcount = 0; - static ConfigDWORD fNoCSE2; - unsigned jitNoCSE2 = fNoCSE2.val(CLRConfig::INTERNAL_JitNoCSE2); + unsigned jitNoCSE2 = JitConfig.JitNoCSE2(); totalCSEcount++; diff --git a/src/jit/optimizer.cpp b/src/jit/optimizer.cpp index 3f6a8f656f..7cbc1c27de 100644 --- a/src/jit/optimizer.cpp +++ b/src/jit/optimizer.cpp @@ -17,8 +17,6 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX #pragma warning ( disable : 4701 ) #endif -static ConfigDWORD fCloneLoops; - /*****************************************************************************/ #if COUNT_RANGECHECKS @@ -2697,8 +2695,7 @@ void Compiler::optUnrollLoops() return; #ifdef DEBUG - static ConfigDWORD fJitNoUnroll; - if (fJitNoUnroll.val(CLRConfig::INTERNAL_JitNoUnroll)) + if (JitConfig.JitNoUnroll()) { return; } @@ -4089,8 +4086,7 @@ bool Compiler::optComputeDerefConditions(unsigned loopNum, LoopCloneContext* con // void Compiler::optDebugLogLoopCloning(BasicBlock* block, GenTreePtr insertBefore) { - static ConfigDWORD fDebugLogLoopCloning; - if (fDebugLogLoopCloning.val(CLRConfig::INTERNAL_JitDebugLogLoopCloning) == 0) + if (JitConfig.JitDebugLogLoopCloning() == 0) { return; } @@ -4165,7 +4161,7 @@ bool Compiler::optCanCloneLoops() // Enabled for retail builds now. unsigned cloneLoopsFlag = 1; #ifdef DEBUG - cloneLoopsFlag = fCloneLoops.val(CLRConfig::INTERNAL_JitCloneLoops); + cloneLoopsFlag = JitConfig.JitCloneLoops(); #endif return (cloneLoopsFlag != 0); } @@ -5438,8 +5434,7 @@ void Compiler::optHoistLoopCode() return; #ifdef DEBUG - static ConfigDWORD fJitNoHoist; - unsigned jitNoHoist = fJitNoHoist.val(CLRConfig::INTERNAL_JitNoHoist); + unsigned jitNoHoist = JitConfig.JitNoHoist(); if (jitNoHoist > 0) { return; diff --git a/src/jit/regalloc.cpp b/src/jit/regalloc.cpp index da48a87256..63a3195e05 100644 --- a/src/jit/regalloc.cpp +++ b/src/jit/regalloc.cpp @@ -22,9 +22,7 @@ XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX #if FEATURE_FP_REGALLOC Compiler::enumConfigRegisterFP Compiler::raConfigRegisterFP() { - static ConfigDWORD dwJitRegisterFP; - - DWORD val = dwJitRegisterFP.val(CLRConfig::EXTERNAL_JitRegisterFP); + DWORD val = JitConfig.JitRegisterFP(); return (enumConfigRegisterFP) (val & 0x3); } @@ -63,8 +61,7 @@ DWORD Compiler::getCanDoubleAlign() if (compStressCompile(STRESS_DBL_ALN, 20)) return MUST_DOUBLE_ALIGN; - static ConfigDWORD fJitDoubleAlign; - return fJitDoubleAlign.val_DontUse_(CLRConfig::INTERNAL_JitDoubleAlign, DEFAULT_DOUBLE_ALIGN); + return JitConfig.JitDoubleAlign(); #else return DEFAULT_DOUBLE_ALIGN; #endif @@ -6260,8 +6257,7 @@ void Compiler::rpPredictRegUse() #endif #ifdef DEBUG - static ConfigDWORD jitNoRegLoc; - BOOL fJitNoRegLoc = jitNoRegLoc.val(CLRConfig::INTERNAL_JitNoRegLoc); + BOOL fJitNoRegLoc = JitConfig.JitNoRegLoc(); if (fJitNoRegLoc) regAvail = RBM_NONE; #endif @@ -6395,8 +6391,7 @@ void Compiler::rpPredictRegUse() } #ifdef DEBUG - static ConfigDWORD fJitMaxRegAllocPasses; - if (fJitMaxRegAllocPasses.val(CLRConfig::INTERNAL_JitAssertOnMaxRAPasses)) + if (JitConfig.JitAssertOnMaxRAPasses()) { noway_assert(rpPasses < rpPassesMax && "This may not a bug, but dev team should look and see what is happening"); diff --git a/src/jit/regset.cpp b/src/jit/regset.cpp index 704c3f8b88..4d3efa3468 100644 --- a/src/jit/regset.cpp +++ b/src/jit/regset.cpp @@ -178,8 +178,7 @@ RegSet::rsStressRegsType RegSet::rsStressRegs() #ifndef LEGACY_BACKEND return RS_STRESS_NONE; #else // LEGACY_BACKEND - static ConfigDWORD fJitStressRegs; - rsStressRegsType val = (rsStressRegsType) fJitStressRegs.val(CLRConfig::INTERNAL_JitStressRegs); + rsStressRegsType val = (rsStressRegsType) JitConfig.JitStressRegs(); if (val == RS_STRESS_NONE && m_rsCompiler->compStressCompile(Compiler::STRESS_REGS, 15)) val = RS_PICK_BAD_REG; return val; #endif // LEGACY_BACKEND diff --git a/src/jit/sharedfloat.cpp b/src/jit/sharedfloat.cpp index db539d3dae..2864c54681 100644 --- a/src/jit/sharedfloat.cpp +++ b/src/jit/sharedfloat.cpp @@ -65,8 +65,7 @@ #ifdef DEBUG int CodeGenInterface::genStressFloat() { - static ConfigDWORD fJitStressRegs; - return compiler->compStressCompile(Compiler::STRESS_FLATFP, 40)?1:fJitStressRegs.val(CLRConfig::INTERNAL_JitStressFP); + return compiler->compStressCompile(Compiler::STRESS_FLATFP, 40)?1:JitConfig.JitStressFP(); } #endif diff --git a/src/jit/unwindarm.cpp b/src/jit/unwindarm.cpp index 4459a7253c..0852924aad 100644 --- a/src/jit/unwindarm.cpp +++ b/src/jit/unwindarm.cpp @@ -1595,8 +1595,7 @@ void UnwindInfo::Split() #ifdef DEBUG // Consider COMPLUS_JitSplitFunctionSize - static ConfigDWORD fJitSplitFunctionSize; - unsigned splitFunctionSize = (unsigned) fJitSplitFunctionSize.val(CLRConfig::INTERNAL_JitSplitFunctionSize); + unsigned splitFunctionSize = (unsigned) JitConfig.JitSplitFunctionSize(); if (splitFunctionSize != 0) if (splitFunctionSize < maxFragmentSize) diff --git a/src/jit/utils.cpp b/src/jit/utils.cpp index 85ccdb75c3..c38fc3ddc0 100644 --- a/src/jit/utils.cpp +++ b/src/jit/utils.cpp @@ -721,24 +721,18 @@ bool ConfigMethodRange::contains(ICorJitInfo* info, CORINFO_METHOD_HANDLE method } /**************************************************************************/ -void ConfigMethodRange::init(const CLRConfig::ConfigStringInfo & info) +void ConfigMethodRange::initRanges(const wchar_t* rangeStr) { // make sure that the memory was zero initialized _ASSERTE(m_inited == 0 || m_inited == 1); - LPWSTR str = CLRConfig::GetConfigValue(info); - initRanges(str); - CLRConfig::FreeConfigString(str); - m_inited = true; -} - -/**************************************************************************/ -void ConfigMethodRange::initRanges(__in_z LPCWSTR rangeStr) -{ - if (rangeStr == 0) + if (rangeStr == nullptr) + { + m_inited = true; return; + } - LPCWSTR p = rangeStr; + LPCWSTR p = const_cast<LPCWSTR>(rangeStr); unsigned char lastRange = 0; while (*p) { while (*p == ' ') //skip blanks @@ -767,6 +761,8 @@ void ConfigMethodRange::initRanges(__in_z LPCWSTR rangeStr) m_ranges[lastRange++] = MAX_RANGE; assert(lastRange < 100); m_lastRange = lastRange; + + m_inited = true; } #endif // DEBUG @@ -1412,7 +1408,7 @@ void HelperCallProperties::init() // MyAssembly;mscorlib;System // MyAssembly;mscorlib System -AssemblyNamesList2::AssemblyNamesList2(__in LPWSTR list, IAllocator* alloc) +AssemblyNamesList2::AssemblyNamesList2(const wchar_t* list, IAllocator* alloc) : m_alloc(alloc) { assert(m_alloc != nullptr); @@ -1421,7 +1417,7 @@ AssemblyNamesList2::AssemblyNamesList2(__in LPWSTR list, IAllocator* alloc) LPWSTR nameStart = nullptr; // start of the name currently being processed. nullptr if no current name AssemblyName** ppPrevLink = &m_pNames; - for (LPWSTR listWalk = list; prevChar != '\0'; prevChar = *listWalk, listWalk++) + for (LPWSTR listWalk = const_cast<LPWSTR>(list); prevChar != '\0'; prevChar = *listWalk, listWalk++) { WCHAR curChar = *listWalk; diff --git a/src/jit/utils.h b/src/jit/utils.h index 659c81623b..25ca684dc8 100644 --- a/src/jit/utils.h +++ b/src/jit/utils.h @@ -77,20 +77,19 @@ class ConfigMethodRange public: bool contains(class ICorJitInfo* info, CORINFO_METHOD_HANDLE method); - inline void ensureInit(const CLRConfig::ConfigStringInfo & info) + inline void ensureInit(const wchar_t* rangeStr) { // make sure that the memory was zero initialized _ASSERTE(m_inited == 0 || m_inited == 1); if (!m_inited) { - init(info); + initRanges(rangeStr); _ASSERTE(m_inited == 1); } } private: - void init(const CLRConfig::ConfigStringInfo & info); void initRanges(__in_z LPCWSTR rangeStr); private: @@ -426,7 +425,7 @@ class AssemblyNamesList2 public: // Take a Unicode string list of assembly names, parse it, and store it. - AssemblyNamesList2(__in LPWSTR list, __in IAllocator* alloc); + AssemblyNamesList2(const wchar_t* list, __in IAllocator* alloc); ~AssemblyNamesList2(); diff --git a/src/jit/valuenum.cpp b/src/jit/valuenum.cpp index 54ef578361..a1b3e9ef84 100644 --- a/src/jit/valuenum.cpp +++ b/src/jit/valuenum.cpp @@ -83,8 +83,7 @@ ValueNumStore::ValueNumStore(Compiler* comp, IAllocator* alloc) ChunkNum cn = m_chunks.Push(specialConstChunk); assert(cn == 0); - static ConfigDWORD fMapSelBudget; - m_mapSelectBudget = fMapSelBudget.val(CLRConfig::INTERNAL_JitVNMapSelBudget); + m_mapSelectBudget = JitConfig.JitVNMapSelBudget(); } // static. @@ -1243,8 +1242,7 @@ TailCall: // This printing is sometimes useful in debugging. // if ((m_numMapSels % 1000) == 0) printf("%d VNF_MapSelect applications.\n", m_numMapSels); #endif - static ConfigDWORD fMapSelLim; - unsigned selLim = fMapSelLim.val(CLRConfig::INTERNAL_JitVNMapSelLimit); + unsigned selLim = JitConfig.JitVNMapSelLimit(); assert(selLim == 0 || m_numMapSels < selLim); #endif ValueNum res; |