Reapply change 1578859: Add a new set of APIs for JIT configuration.

SuperPMI has been udpated to accommodate this change, and should no
longer crash when run using a JIT built with these changes.

[tfs-changeset: 1582144]

41 files changed, 818 insertions, 396 deletions

diff --git a/src/inc/utilcode.h b/src/inc/utilcode.h
index 48d096ee7c..b9e902f995 100644
--- a/src/inc/utilcode.h
+++ b/src/inc/utilcode.h
@@ -1189,6 +1189,8 @@ void    SplitPath(__in SString const &path,
                   __inout_opt SString *fname,
                   __inout_opt SString *ext);
 
+#if !defined(NO_CLRCONFIG)
+
 //*****************************************************************************
 //
 // **** REGUTIL - Static helper functions for reading/writing to Windows registry.
@@ -1523,6 +1525,8 @@ private:
     LPWSTR m_wszString;
 };
 
+#endif // defined(NO_CLRCONFIG)
+
 #include "ostype.h"
 
 #define CLRGetTickCount64() GetTickCount64()
@@ -4175,6 +4179,8 @@ public:
     }
 };
 
+#if !defined(NO_CLRCONFIG)
+
 /**************************************************************************/
 /* simple wrappers around the REGUTIL and MethodNameList routines that make
    the lookup lazy */
@@ -4281,6 +4287,8 @@ private:
     BYTE m_inited;
 };
 
+#endif // !defined(NO_CLRCONFIG)
+
 //*****************************************************************************
 // Convert a pointer to a string into a GUID.
 //*****************************************************************************
diff --git a/src/jit/CMakeLists.txt b/src/jit/CMakeLists.txt
index b492cf7a9c..8990afca47 100644
--- a/src/jit/CMakeLists.txt
+++ b/src/jit/CMakeLists.txt
@@ -37,6 +37,7 @@ set( JIT_SOURCES
   inline.cpp
   inlinepolicy.cpp
   instr.cpp
+  jitconfig.cpp
   jiteh.cpp
   jittelemetry.cpp
   lclvars.cpp
diff --git a/src/jit/alloc.cpp b/src/jit/alloc.cpp
index aacd174efe..d09bbe641f 100644
--- a/src/jit/alloc.cpp
+++ b/src/jit/alloc.cpp
@@ -60,8 +60,7 @@ bool ArenaAllocator::bypassHostAllocator()
     // 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 s_jitDirectAlloc;
-    return s_jitDirectAlloc.val(CLRConfig::INTERNAL_JitDirectAlloc) != 0;
+    return JitConfig.JitDirectAlloc() != 0;
 #else // defined(DEBUG)
     return false;
 #endif // !defined(DEBUG)
@@ -333,8 +332,7 @@ void* ArenaAllocator::allocateMemory(size_t size)
     // Ensure that we always allocate in pointer sized increments.
     size = (size_t)roundUp(size, sizeof(size_t));
 
-    static ConfigDWORD s_shouldInjectFault;
-    if (s_shouldInjectFault.val(CLRConfig::INTERNAL_InjectFault) != 0)
+    if (JitConfig.ShouldInjectFault() != 0)
     {
         // Force the underlying memory allocator (either the OS or the CLR hoster) 
         // to allocate the memory. Any fault injection will kick in.
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 06a7e3e2c6..9376666762 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 8146f3aa2b..9eebae880d 100644
--- a/src/jit/compiler.cpp
+++ b/src/jit/compiler.cpp
@@ -59,6 +59,7 @@ LONG     Compiler::jitNestingLevel = 0;
 
 #ifdef ALT_JIT
 // static
+bool Compiler::s_pAltJitExcludeAssembliesListInitialized = false;
 AssemblyNamesList2* Compiler::s_pAltJitExcludeAssembliesList = nullptr;
 #endif // ALT_JIT
 
@@ -744,8 +745,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");
@@ -1009,8 +1009,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);
@@ -1511,8 +1510,7 @@ static bool DidComponentUnitTests = false;
 
 void Compiler::compDoComponentUnitTestsOnce()
 {
-    static ConfigDWORD fRunComponentUnitTests;
-    if (!fRunComponentUnitTests.val(CLRConfig::INTERNAL_JitComponentUnitTests))
+    if (!JitConfig.RunComponentUnitTests())
         return;
 
     if (!DidComponentUnitTests) 
@@ -1838,8 +1836,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())
@@ -1870,11 +1867,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);
@@ -1923,8 +1918,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)
 {
@@ -2043,20 +2038,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
@@ -2065,8 +2054,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;
@@ -2075,16 +2063,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
@@ -2092,7 +2078,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;
     }
@@ -2105,16 +2091,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 (HostAllocator::getHostAllocator()) AssemblyNamesList2(wszAltJitExcludeAssemblyList, HostAllocator::getHostAllocator());
             }
+            s_pAltJitExcludeAssembliesListInitialized = true;
         }
 
         if (s_pAltJitExcludeAssembliesList != nullptr)
@@ -2142,9 +2128,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");
     }
 
@@ -2176,63 +2160,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)
@@ -2591,83 +2553,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;
     }
 
@@ -2684,12 +2623,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.
@@ -2706,21 +2643,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;
     }
@@ -2734,8 +2666,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
@@ -2745,8 +2676,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;
@@ -2777,8 +2707,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;
     }
@@ -2794,14 +2723,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;
     }
@@ -2825,8 +2753,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
 
@@ -2850,21 +2777,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
     }
@@ -2910,8 +2831,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;
@@ -2922,9 +2842,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);
         }
@@ -2988,17 +2907,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;
@@ -3033,21 +2949,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))
     {
@@ -3060,7 +2972,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))
     {
@@ -3235,9 +3147,7 @@ void                 Compiler::compSetOptimizationLevel()
     }
 
 #ifdef  DEBUG
-    static ConfigDWORD fJitMinOpts;
-
-    jitMinOpts = fJitMinOpts.val_DontUse_(CLRConfig::UNSUPPORTED_JITMinOpts, 0);
+    jitMinOpts = JitConfig.JitMinOpts();
 
     if (!theMinOptsValue && (jitMinOpts > 0))
     {
@@ -3301,10 +3211,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;
     }
 
@@ -3316,34 +3223,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;
@@ -3352,7 +3252,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");
             }
@@ -3601,7 +3501,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())
     {
@@ -3841,14 +3741,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)
@@ -4176,18 +4075,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;
@@ -4262,8 +4157,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)
     {
@@ -4345,7 +4239,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;
@@ -4807,8 +4701,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;
         }
@@ -4834,8 +4727,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)
@@ -5073,8 +4965,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,
@@ -5121,8 +5012,7 @@ _Next:
 
 #ifdef ALT_JIT
 #ifdef DEBUG
-            static ConfigDWORD fRunAltJitCode;
-            if (fRunAltJitCode.val(CLRConfig::INTERNAL_RunAltJitCode) == 0)
+            if (JitConfig.RunAltJitCode() == 0)
             {
                 return CORJIT_SKIPPED;
             }
@@ -6684,8 +6574,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 3f585f974a..7c4b8f5552 100644
--- a/src/jit/compiler.h
+++ b/src/jit/compiler.h
@@ -4337,8 +4337,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))
@@ -7563,6 +7562,7 @@ public :
         opts;
 
 #ifdef ALT_JIT
+    static bool s_pAltJitExcludeAssembliesListInitialized;
     static AssemblyNamesList2* s_pAltJitExcludeAssembliesList;
 #endif // ALT_JIT
 
@@ -7655,8 +7655,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 a935bd7b8c..03b4f1ce16 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 da0ae901fe..3c33d418a6 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 2cd045b59a..539d6e4532 100644
--- a/src/jit/emit.cpp
+++ b/src/jit/emit.cpp
@@ -925,8 +925,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 d817b75c07..8dfdf961bc 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 15af9aa848..4507ee4ccb 100644
--- a/src/jit/emitxarch.cpp
+++ b/src/jit/emitxarch.cpp
@@ -11191,8 +11191,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));
@@ -11207,8 +11206,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 1bb3e1db88..00c5c89e6f 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;
          }
@@ -10042,8 +10040,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();
@@ -18907,21 +18904,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
 
@@ -18934,8 +18925,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)
     {
@@ -19197,9 +19187,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 4018188607..a1787f1d72 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 9bb76f118c..304024a1cc 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();
     }
@@ -15639,8 +15636,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)  
     {   
@@ -15848,8 +15844,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/inlinepolicy.cpp b/src/jit/inlinepolicy.cpp
index 31580aff9b..ca878e51a2 100644
--- a/src/jit/inlinepolicy.cpp
+++ b/src/jit/inlinepolicy.cpp
@@ -333,10 +333,7 @@ double LegacyPolicy::determineMultiplier()
 
     if (inlHasSimd)
     {
-        static ConfigDWORD fJitInlineSIMDMultiplier;
-        int simdMultiplier = fJitInlineSIMDMultiplier.val(CLRConfig::INTERNAL_JitInlineSIMDMultiplier);
-
-        multiplier += simdMultiplier;
+        multiplier += JitConfig.JitInlineSIMDMultiplier();
         JITDUMP("\nInline candidate has SIMD type args, locals or return value.  Multiplier increased to %g.", multiplier);
     }
 
diff --git a/src/jit/instr.cpp b/src/jit/instr.cpp
index 1bd1ab6032..1ed705321b 100644
--- a/src/jit/instr.cpp
+++ b/src/jit/instr.cpp
@@ -3912,8 +3912,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 19a4f332d8..bfdb195e28 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 b95852f63c..26b5af903d 100644
--- a/src/jit/jit.settings.targets
+++ b/src/jit/jit.settings.targets
@@ -82,6 +82,7 @@
         <CppCompile Include="..\LoopCloning.cpp" />
         <CppCompile Include="..\inline.cpp" />
         <CppCompile Include="..\inlinepolicy.cpp" />
+        <CppCompile Include="..\jitconfig.cpp" />
         <CppCompile Include="..\hostallocator.cpp" />
         <CppCompile Condition="'$(ClDefines.Contains(`LEGACY_BACKEND`))'=='True'" Include="..\CodeGenLegacy.cpp" />
         <CppCompile Condition="'$(ClDefines.Contains(`LEGACY_BACKEND`))'=='False'"  Include="..\Lower.cpp" />
diff --git a/src/jit/jitconfig.cpp b/src/jit/jitconfig.cpp
new file mode 100644
index 0000000000..009b877578
--- /dev/null
+++ b/src/jit/jitconfig.cpp
@@ -0,0 +1,329 @@
+// 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;
+        }
+    }
+}
+
+void JitConfigValues::MethodSet::destroy(ICorJitHost* host)
+{
+    // Free method names, free the list string, and reset our state
+    for (MethodName* name = m_names, *next = nullptr; name != nullptr; name = next)
+    {
+        next = name->m_next;
+        host->freeMemory(reinterpret_cast<void*>(const_cast<MethodName*>(name)));
+    }
+
+    host->freeMemory(reinterpret_cast<void*>(const_cast<char*>(m_list)));
+
+    m_names = nullptr;
+    m_list = nullptr;
+}
+
+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;
+}
+
+void JitConfigValues::destroy(ICorJitHost* host)
+{
+    if (!m_isInitialized)
+    {
+        return;
+    }
+
+#define CONFIG_INTEGER(name, key, defaultValue)
+#define CONFIG_STRING(name, key) host->freeStringConfigValue(m_##name);
+#define CONFIG_METHODSET(name, key) m_##name.destroy(host);
+
+#include "jitconfigvalues.h"
+
+    m_isInitialized = false;
+}
diff --git a/src/jit/jitconfig.h b/src/jit/jitconfig.h
new file mode 100644
index 0000000000..076d920192
--- /dev/null
+++ b/src/jit/jitconfig.h
@@ -0,0 +1,72 @@
+// 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);
+        void destroy(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);
+    void destroy(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 a798e60d5f..af0f0e9f63 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 13c7398b99..16ece5f76f 100644
--- a/src/jit/morph.cpp
+++ b/src/jit/morph.cpp
@@ -12861,8 +12861,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");
         }
@@ -14247,8 +14246,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 6c2d579521..881761382f 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 cb32378bbb..4e33dd9722 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
@@ -6262,8 +6259,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
@@ -6397,8 +6393,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 2688a0111e..e13009f23a 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
@@ -1399,7 +1395,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);
@@ -1408,7 +1404,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 5817d40224..63788465dd 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;
diff --git a/src/utilcode/jithost.cpp b/src/utilcode/jithost.cpp
index 412cc47786..3174aa6188 100644
--- a/src/utilcode/jithost.cpp
+++ b/src/utilcode/jithost.cpp
@@ -41,7 +41,7 @@ int JitHost::getIntConfigValue(const wchar_t* name, int defaultValue)
     WRAPPER_NO_CONTRACT;
 
     // Translate JIT call into runtime configuration query
-    CLRConfig::ConfigDWORDInfo info{ name, defaultValue, CLRConfig::REGUTIL_default };
+    CLRConfig::ConfigDWORDInfo info{ name, defaultValue, CLRConfig::EEConfig_default };
 
     // Perform a CLRConfig look up on behalf of the JIT.
     return CLRConfig::GetConfigValue(info);
@@ -52,7 +52,7 @@ const wchar_t* JitHost::getStringConfigValue(const wchar_t* name)
     WRAPPER_NO_CONTRACT;
 
     // Translate JIT call into runtime configuration query
-    CLRConfig::ConfigStringInfo info{ name, CLRConfig::REGUTIL_default };
+    CLRConfig::ConfigStringInfo info{ name, CLRConfig::EEConfig_default };
 
     // Perform a CLRConfig look up on behalf of the JIT.
     return CLRConfig::GetConfigValue(info);