Preliminary Interpreter Support (#6182)

30 files changed, 945 insertions, 40 deletions

diff --git a/src/BuildIntegration/Microsoft.NETCore.Native.targets b/src/BuildIntegration/Microsoft.NETCore.Native.targets
index 0318a9d61..79f3a61b7 100644
--- a/src/BuildIntegration/Microsoft.NETCore.Native.targets
+++ b/src/BuildIntegration/Microsoft.NETCore.Native.targets
@@ -80,11 +80,21 @@ See the LICENSE file in the project root for more information.
 
   <ItemGroup>
     <AutoInitializedAssemblies Include="System.Private.CoreLib" />
+    <AutoInitializedAssemblies Include="System.Private.DeveloperExperience.Console" />
+    <AutoInitializedAssemblies Include="System.Private.StackTraceMetadata" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(ExperimentalInterpreterSupport)' != 'true'">
     <AutoInitializedAssemblies Include="System.Private.TypeLoader" />
     <AutoInitializedAssemblies Include="System.Private.Reflection.Execution" />
-    <AutoInitializedAssemblies Include="System.Private.DeveloperExperience.Console" />
     <AutoInitializedAssemblies Include="System.Private.Interop" />
-    <AutoInitializedAssemblies Include="System.Private.StackTraceMetadata" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(ExperimentalInterpreterSupport)' == 'true'">
+    <AutoInitializedAssemblies Include="System.Private.Interpreter" />
+    <AutoInitializedAssemblies Include="System.Private.TypeLoader.Experimental" />
+    <AutoInitializedAssemblies Include="System.Private.Reflection.Execution.Experimental" />
+    <AutoInitializedAssemblies Include="System.Private.Interop.Experimental" />
   </ItemGroup>
 
   <ItemGroup>
@@ -170,6 +180,7 @@ See the LICENSE file in the project root for more information.
       <IlcArg Condition="$(OutputType) == 'Library' and $(NativeLib) != ''" Include="--nativelib" />
       <IlcArg Condition="$(ExportsFile) != ''" Include="--exportsfile:$(ExportsFile)" />
       <ILcArg Condition="'$(Platform)' == 'wasm'" Include="--wasm" />
+      <ILcArg Condition="'$(ExperimentalInterpreterSupport)' == 'true'" Include="--nometadatablocking" />
       <IlcArg Include="@(AutoInitializedAssemblies->'--initassembly:%(Identity)')" />
       <IlcArg Include="@(AppContextSwitchOverrides->'--appcontextswitch:%(Identity)')" />
       <IlcArg Condition="$(ServerGarbageCollection) != ''" Include="--runtimeopt:RH_UseServerGC=1" />
diff --git a/src/Common/src/System/Collections/Generic/LowLevelStack.cs b/src/Common/src/System/Collections/Generic/LowLevelStack.cs
new file mode 100644
index 000000000..b193036a2
--- /dev/null
+++ b/src/Common/src/System/Collections/Generic/LowLevelStack.cs
@@ -0,0 +1,161 @@
+// 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.
+
+/*============================================================
+**
+**
+** Private version of Stack<T> for internal System.Private.CoreLib use. This
+** permits sharing more source between BCL and System.Private.CoreLib (as well as the
+** fact that Stack<T> is just a useful class in general.)
+**
+** This does not strive to implement the full api surface area
+** (but any portion it does implement should match the real Stack<T>'s
+** behavior.)
+** 
+===========================================================*/
+
+namespace System.Collections.Generic
+{
+    // Implements a variable-size Stack that uses an array of objects to store the
+    // elements. A Stack has a capacity, which is the allocated length
+    // of the internal array. As elements are added to a Stack, the capacity
+    // of the Stack is automatically increased as required by reallocating the
+    // internal array.
+    // 
+    /// <summary>
+    /// LowLevelStack with no interface implementation to minimize both code and data size
+    /// Data size is smaller because there will be minimal virtual function table.
+    /// Code size is smaller because only functions called will be in the binary.
+    /// </summary>
+    internal class LowLevelStack<T>
+    {
+        protected T[] _items;
+        protected int _size;
+        protected int _version;
+
+        private static readonly T[] s_emptyArray = new T[0];
+
+        public LowLevelStack()
+        {
+            _items = s_emptyArray;
+        }
+
+        public LowLevelStack(int capacity)
+        {
+            if (capacity < 0)
+                throw new ArgumentOutOfRangeException(nameof(capacity));
+
+            if (capacity == 0)
+                _items = s_emptyArray;
+            else
+            {
+                _size = capacity;
+                _items = new T[capacity];
+            }
+        }
+
+        public LowLevelStack(IEnumerable<T> collection)
+        {
+            if (collection == null)
+                throw new ArgumentNullException(nameof(collection));
+
+            ICollection<T> c = collection as ICollection<T>;
+            if (c != null)
+            {
+                int count = c.Count;
+                if (count == 0)
+                {
+                    _items = s_emptyArray;
+                }
+                else
+                {
+                    _items = new T[count];
+                    c.CopyTo(_items, 0);
+                    _size = count;
+                }
+            }
+            else
+            {
+                _size = 0;
+                _items = s_emptyArray;
+
+                using (IEnumerator<T> en = collection.GetEnumerator())
+                {
+                    while (en.MoveNext())
+                    {
+                        Push(en.Current);
+                    }
+                }
+            }
+        }
+
+        public int Count
+        {
+            get
+            {
+                return _items.Length;
+            }
+        }
+
+        public void Push(T item)
+        {
+            _size = _size + 1;
+            Array.Resize(ref _items, _size);
+            _items[_size - 1] = item;
+            _version++;
+        }
+
+        public T Pop()
+        {
+            ThrowIfEmptyStack();
+
+            _size = _size - 1;
+            T item = _items[_size];
+            Array.Resize(ref _items, _size);
+            _version++;
+            return item;
+        }
+
+        public bool TryPop(out T result)
+        {
+            if (_size == 0)
+            {
+                result = default;
+                return false;
+            }
+
+            _size = _size - 1;
+            result = _items[_size];
+            Array.Resize(ref _items, _size);
+            _version++;
+
+            return true;
+        }
+
+        public T Peek()
+        {
+            ThrowIfEmptyStack();
+            return _items[_size - 1];
+        }
+
+        public bool TryPeek(out T result)
+        {
+            if (_size == 0)
+            {
+                result = default;
+                return false;
+            }
+
+            result = _items[_size - 1];
+            _version++;
+            return true;
+        }
+
+        private void ThrowIfEmptyStack()
+        {
+            if (_size == 0)
+                throw new InvalidOperationException();
+        }
+    }
+}
diff --git a/src/Common/src/TypeSystem/NativeFormat/NativeFormatMetadataUnit.cs b/src/Common/src/TypeSystem/NativeFormat/NativeFormatMetadataUnit.cs
index 298e8431e..d4e9718ee 100644
--- a/src/Common/src/TypeSystem/NativeFormat/NativeFormatMetadataUnit.cs
+++ b/src/Common/src/TypeSystem/NativeFormat/NativeFormatMetadataUnit.cs
@@ -502,7 +502,7 @@ namespace Internal.TypeSystem.NativeFormat
             AssemblyBindResult bindResult;
             RuntimeAssemblyName assemblyName = AssemblyNameParser.Parse(assemblyNameString);
             Exception failureException;
-            if (!AssemblyBinderImplementation.Instance.Bind(assemblyName, out bindResult, out failureException))
+            if (!AssemblyBinderImplementation.Instance.Bind(assemblyName, cacheMissedLookups: true, out bindResult, out failureException))
             {
                 throw failureException;
             }
diff --git a/src/System.Private.Interop/src/System.Private.Interop.Experimental.csproj b/src/System.Private.Interop/src/System.Private.Interop.Experimental.csproj
new file mode 100644
index 000000000..3fcaee81c
--- /dev/null
+++ b/src/System.Private.Interop/src/System.Private.Interop.Experimental.csproj
@@ -0,0 +1,9 @@
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" DefaultTargets="Build">
+  <PropertyGroup>
+    <AssemblyName>System.Private.Interop.Experimental</AssemblyName>
+    <EcmaMetadataSupport>true</EcmaMetadataSupport>
+    <DynamicCodeSupport>true</DynamicCodeSupport>
+  </PropertyGroup>
+
+  <Import Project="System.Private.Interop.csproj" />
+</Project>
diff --git a/src/System.Private.Interop/src/System.Private.Interop.csproj b/src/System.Private.Interop/src/System.Private.Interop.csproj
index 73411b210..f3561abda 100644
--- a/src/System.Private.Interop/src/System.Private.Interop.csproj
+++ b/src/System.Private.Interop/src/System.Private.Interop.csproj
@@ -1,7 +1,7 @@
 <Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" DefaultTargets="Build">
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" />
   <PropertyGroup>
-    <AssemblyName>System.Private.Interop</AssemblyName>
+    <AssemblyName Condition="'$(AssemblyName)' == ''">System.Private.Interop</AssemblyName>
     <OutputType>Library</OutputType>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <DefineConstants>$(DefineConstants);TARGET_CORE_API_SET</DefineConstants>
@@ -21,7 +21,8 @@
       <SkipGetTargetFrameworkProperties>true</SkipGetTargetFrameworkProperties>
     </ProjectReference>
     <ProjectReference Include="..\..\System.Private.CoreLib\src\System.Private.CoreLib.csproj" />
-    <ProjectReference Include="..\..\System.Private.TypeLoader\src\System.Private.TypeLoader.csproj" />
+    <ProjectReference Condition="'$(DynamicCodeSupport)' != 'true'" Include="..\..\System.Private.TypeLoader\src\System.Private.TypeLoader.csproj" />
+    <ProjectReference Condition="'$(DynamicCodeSupport)' == 'true'" Include="..\..\System.Private.TypeLoader\src\System.Private.TypeLoader.Experimental.csproj" />
   </ItemGroup>
 
   <Import Project="System.Private.Interop.Shared.projitems" />
diff --git a/src/System.Private.Interpreter/src/Internal/Runtime/CompilerHelpers/LibraryInitializer.cs b/src/System.Private.Interpreter/src/Internal/Runtime/CompilerHelpers/LibraryInitializer.cs
new file mode 100644
index 000000000..82c5b1299
--- /dev/null
+++ b/src/System.Private.Interpreter/src/Internal/Runtime/CompilerHelpers/LibraryInitializer.cs
@@ -0,0 +1,17 @@
+// 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.
+
+using Internal.Runtime.Interpreter;
+using Internal.Runtime.TypeLoader;
+
+namespace Internal.Runtime.CompilerHelpers
+{
+    public class LibraryInitializer
+    {
+        public static void InitializeLibrary()
+        {
+            MethodExecutionStrategy.GlobalExecutionStrategy = new InterpreterExecutionStrategy();
+        }
+    }
+}
diff --git a/src/System.Private.Interpreter/src/Internal/Runtime/Interpreter/ILImporter.Interpreter.cs b/src/System.Private.Interpreter/src/Internal/Runtime/Interpreter/ILImporter.Interpreter.cs
new file mode 100644
index 000000000..a86ef2d67
--- /dev/null
+++ b/src/System.Private.Interpreter/src/Internal/Runtime/Interpreter/ILImporter.Interpreter.cs
@@ -0,0 +1,447 @@
+// 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.
+
+using System;
+using Internal.Runtime.Interpreter;
+using Internal.TypeSystem;
+
+namespace Internal.IL
+{
+    partial class ILImporter
+    {
+        private class BasicBlock
+        {
+            // Common fields
+            public enum ImportState : byte
+            {
+                Unmarked,
+                IsPending
+            }
+
+            public BasicBlock Next;
+
+            public int StartOffset;
+            public ImportState State = ImportState.Unmarked;
+
+            public bool TryStart;
+            public bool FilterStart;
+            public bool HandlerStart;
+        }
+
+        private class ExceptionRegion
+        {
+            public ILExceptionRegion ILRegion;
+        }
+
+        private readonly byte[] _ilBytes;
+        private readonly MethodDesc _method;
+        private readonly MethodIL _methodIL;
+        private readonly ILInterpreter _interpreter;
+        private ExceptionRegion[] _exceptionRegions;
+
+        public ILImporter(ILInterpreter interpreter, MethodDesc method, MethodIL methodIL)
+        {
+            _ilBytes = methodIL.GetILBytes();
+            _method = method;
+            _methodIL = methodIL;
+            _interpreter = interpreter;
+
+            var ilExceptionRegions = methodIL.GetExceptionRegions();
+            _exceptionRegions = new ExceptionRegion[methodIL.GetExceptionRegions().Length];
+            for (int i = 0; i < ilExceptionRegions.Length; i++)
+            {
+                _exceptionRegions[i] = new ExceptionRegion() { ILRegion = ilExceptionRegions[i] };
+            }
+        }
+
+        public void Interpret()
+        {
+            FindBasicBlocks();
+            ImportBasicBlocks();
+        }
+
+        private void MarkInstructionBoundary() { }
+
+        private void StartImportingInstruction() { }
+
+        private void EndImportingInstruction() { }
+
+        private void StartImportingBasicBlock(BasicBlock basicBlock) { }
+
+        private void EndImportingBasicBlock(BasicBlock basicBlock) { }
+
+        private void ReportInvalidBranchTarget(int targetOffset)
+        {
+            ThrowHelper.ThrowInvalidProgramException();
+        }
+
+        private void ReportFallthroughAtEndOfMethod()
+        {
+            ThrowHelper.ThrowInvalidProgramException();
+        }
+
+        private void ReportMethodEndInsideInstruction()
+        {
+            ThrowHelper.ThrowInvalidProgramException();
+        }
+
+        private void ReportInvalidInstruction(ILOpcode opcode)
+        {
+            ThrowHelper.ThrowInvalidProgramException();
+        }
+
+        private TypeDesc ResolveTypeToken(int token)
+        {
+            return (TypeDesc)_methodIL.GetObject(token);
+        }
+
+        private TypeDesc GetWellKnownType(WellKnownType wellKnownType)
+        {
+            return _interpreter.TypeSystemContext.GetWellKnownType(wellKnownType);
+        }
+
+        private void ImportNop()
+        {
+            // Do nothing!
+        }
+
+        private void ImportBreak()
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportLoadVar(int index, bool argument)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportStoreVar(int index, bool argument)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportAddressOfVar(int index, bool argument)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportDup()
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportPop()
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportCalli(int token)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportLoadNull()
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportReturn()
+        {
+            bool hasReturnValue = _interpreter.EvaluationStack.TryPop(out StackItem stackItem);
+            if (!hasReturnValue)
+                return;
+
+            switch (stackItem.Kind)
+            {
+                case StackValueKind.Int32:
+                    _interpreter.SetReturnValue(((Int32StackItem)stackItem).Value);
+                    break;
+                case StackValueKind.Int64:
+                    _interpreter.SetReturnValue(((Int64StackItem)stackItem).Value);
+                    break;
+                case StackValueKind.Unknown:
+                case StackValueKind.NativeInt:
+                case StackValueKind.Float:
+                case StackValueKind.ByRef:
+                case StackValueKind.ObjRef:
+                case StackValueKind.ValueType:
+                default:
+                    break;
+            }
+        }
+
+        private void ImportLoadInt(long value, StackValueKind kind)
+        {
+            if (kind == StackValueKind.Int32)
+                _interpreter.EvaluationStack.Push(new Int32StackItem((int)value));
+            else if (kind == StackValueKind.Int64)
+                _interpreter.EvaluationStack.Push(new Int64StackItem(value));
+        }
+
+        private void ImportLoadFloat(double value)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportShiftOperation(ILOpcode opcode)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportCompareOperation(ILOpcode opcode)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportConvert(WellKnownType wellKnownType, bool checkOverflow, bool unsigned)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportUnaryOperation(ILOpcode opCode)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportCpOpj(int token)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportCkFinite()
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportLocalAlloc()
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportEndFilter()
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportCpBlk()
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportInitBlk()
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportRethrow()
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportSizeOf(int token)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportUnalignedPrefix(byte alignment)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportVolatilePrefix()
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportTailPrefix()
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportNoPrefix(byte mask)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportThrow()
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportInitObj(int token)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportLoadLength()
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportEndFinally()
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportFallthrough(BasicBlock nextBasicBlock)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportReadOnlyPrefix()
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportRefAnyType()
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportConstrainedPrefix(int v)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportLdFtn(int v, ILOpcode opCode)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportArgList()
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportLeave(BasicBlock basicBlock)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportLdToken(int v)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportMkRefAny(int v)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportRefAnyVal(int v)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportAddressOfElement(int v)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportNewArray(int v)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportBox(int v)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportStoreField(int v1, bool v2)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportAddressOfField(int v1, bool v2)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportLoadField(int v1, bool v2)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportUnbox(int v, ILOpcode opCode)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportCasting(ILOpcode opCode, int v)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportLoadString(int v)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportBinaryOperation(ILOpcode opCode)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportSwitchJump(int jmpBase, int[] jmpDelta, BasicBlock basicBlock)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportBranch(ILOpcode iLOpcode, BasicBlock basicBlock1, BasicBlock basicBlock2)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportCall(ILOpcode opCode, int v)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportJmp(int v)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportLoadIndirect(int token)
+        {
+            ImportLoadIndirect(ResolveTypeToken(token));
+        }
+
+        private void ImportLoadIndirect(TypeDesc type)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportStoreIndirect(int token)
+        {
+            ImportStoreIndirect(ResolveTypeToken(token));
+        }
+
+        private void ImportStoreIndirect(TypeDesc type)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportLoadElement(int token)
+        {
+            ImportLoadElement(ResolveTypeToken(token));
+        }
+
+        private void ImportLoadElement(TypeDesc elementType)
+        {
+            throw new NotImplementedException();
+        }
+
+        private void ImportStoreElement(int token)
+        {
+            ImportStoreElement(ResolveTypeToken(token));
+        }
+
+        private void ImportStoreElement(TypeDesc elementType)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}
diff --git a/src/System.Private.Interpreter/src/Internal/Runtime/Interpreter/ILInterpreter.cs b/src/System.Private.Interpreter/src/Internal/Runtime/Interpreter/ILInterpreter.cs
new file mode 100644
index 000000000..d78611ec9
--- /dev/null
+++ b/src/System.Private.Interpreter/src/Internal/Runtime/Interpreter/ILInterpreter.cs
@@ -0,0 +1,58 @@
+// 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.
+
+using System.Collections.Generic;
+
+using Internal.IL;
+using Internal.Runtime.CallInterceptor;
+using Internal.TypeSystem;
+
+namespace Internal.Runtime.Interpreter
+{
+    internal unsafe class ILInterpreter
+    {
+        private readonly MethodDesc _method;
+        private readonly MethodIL _methodIL;
+        private readonly TypeSystemContext _context;
+        private readonly LowLevelStack<StackItem> _stack;
+
+        private CallInterceptorArgs _callInterceptorArgs;
+        
+        public LowLevelStack<StackItem> EvaluationStack
+        {
+            get
+            {
+                return _stack;
+            }
+        }
+
+        public TypeSystemContext TypeSystemContext
+        {
+            get
+            {
+                return _context;
+            }
+        }
+
+        public ILInterpreter(TypeSystemContext context, MethodDesc method, MethodIL methodIL)
+        {
+            _context = context;
+            _method = method;
+            _methodIL = methodIL;
+            _stack = new LowLevelStack<StackItem>();
+        }
+
+        public void InterpretMethod(ref CallInterceptorArgs callInterceptorArgs)
+        {
+            _callInterceptorArgs = callInterceptorArgs;
+            ILImporter importer = new ILImporter(this, _method, _methodIL);
+            importer.Interpret();
+        }
+
+        public void SetReturnValue<T>(T value)
+        {
+            _callInterceptorArgs.ArgumentsAndReturnValue.SetVar<T>(0, value);
+        }
+    }
+}
diff --git a/src/System.Private.Interpreter/src/Internal/Runtime/Interpreter/InterpreterCallInterceptor.cs b/src/System.Private.Interpreter/src/Internal/Runtime/Interpreter/InterpreterCallInterceptor.cs
new file mode 100644
index 000000000..3703d213b
--- /dev/null
+++ b/src/System.Private.Interpreter/src/Internal/Runtime/Interpreter/InterpreterCallInterceptor.cs
@@ -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.
+
+using Internal.IL;
+using Internal.Runtime.CallConverter;
+using Internal.Runtime.CallInterceptor;
+using Internal.TypeSystem;
+using Internal.TypeSystem.Ecma;
+
+namespace Internal.Runtime.Interpreter
+{
+    public class InterpreterCallInterceptor : CallInterceptor.CallInterceptor
+    {
+        private readonly MethodDesc _method;
+        private readonly MethodIL _methodIL;
+        private readonly TypeSystemContext _context;
+
+        public InterpreterCallInterceptor(TypeSystemContext context, MethodDesc method) : base(false)
+        {
+            _context = context;
+            _method = method;
+            _methodIL = EcmaMethodIL.Create(method as EcmaMethod);
+        }
+
+        public override LocalVariableType[] ArgumentAndReturnTypes
+        {
+            get
+            {
+                LocalVariableType[] localVariableTypes = new LocalVariableType[_method.Signature.Length + 1];
+                localVariableTypes[0] = new LocalVariableType(_method.Signature.ReturnType.RuntimeTypeHandle, false, _method.Signature.ReturnType.IsByRef);
+                for (int i = 0; i < _method.Signature.Length; i++)
+                {
+                    var argument = _method.Signature[i];
+                    localVariableTypes[i + 1] = new LocalVariableType(argument.RuntimeTypeHandle, false, argument.IsByRef);
+                }
+
+                return localVariableTypes;
+            }
+        }
+
+        public override CallingConvention CallingConvention
+        {
+            get
+            {
+                return _method.Signature.IsStatic ? CallingConvention.ManagedStatic : CallingConvention.ManagedInstance;
+            }
+        }
+
+        public override LocalVariableType[] LocalVariableTypes
+        {
+            get
+            {
+                LocalVariableDefinition[] locals = _methodIL.GetLocals();
+                LocalVariableType[] localVariableTypes = new LocalVariableType[locals.Length];
+                for (int i = 0; i < locals.Length; i++)
+                {
+                    var variable = locals[i];
+                    localVariableTypes[i] = new LocalVariableType(variable.Type.RuntimeTypeHandle, variable.IsPinned, variable.Type.IsByRef);
+                }
+
+                return localVariableTypes;
+            }
+        }
+
+        public override void ThunkExecute(ref CallInterceptorArgs callInterceptorArgs)
+        {
+            ILInterpreter interpreter = new ILInterpreter(_context, _method, _methodIL);
+            interpreter.InterpretMethod(ref callInterceptorArgs);
+        }
+    }
+}
diff --git a/src/System.Private.Interpreter/src/Internal/Runtime/Interpreter/InterpreterExecutionStrategy.cs b/src/System.Private.Interpreter/src/Internal/Runtime/Interpreter/InterpreterExecutionStrategy.cs
new file mode 100644
index 000000000..7fa3a5742
--- /dev/null
+++ b/src/System.Private.Interpreter/src/Internal/Runtime/Interpreter/InterpreterExecutionStrategy.cs
@@ -0,0 +1,22 @@
+// 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.
+
+using System;
+
+using Internal.Runtime.TypeLoader;
+using Internal.TypeSystem;
+
+namespace Internal.Runtime.Interpreter
+{
+    public class InterpreterExecutionStrategy : MethodExecutionStrategy
+    {
+        public override IntPtr OnEntryPoint(MethodEntrypointPtr methodEntrypointPtr, IntPtr callerArgumentsInfo)
+        {
+            var context = TypeSystemContextFactory.Create();
+            MethodDesc method = methodEntrypointPtr.MethodIdentifier.ToMethodDesc(context);
+            InterpreterCallInterceptor callInterceptor = new InterpreterCallInterceptor(context, method);
+            return callInterceptor.GetThunkAddress();
+        }
+    }
+}
diff --git a/src/System.Private.Interpreter/src/Internal/Runtime/Interpreter/StackItem.cs b/src/System.Private.Interpreter/src/Internal/Runtime/Interpreter/StackItem.cs
new file mode 100644
index 000000000..b35b8bb05
--- /dev/null
+++ b/src/System.Private.Interpreter/src/Internal/Runtime/Interpreter/StackItem.cs
@@ -0,0 +1,60 @@
+// 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.
+
+using System;
+using Internal.IL;
+
+namespace Internal.Runtime.Interpreter
+{
+    internal abstract class StackItem
+    {
+        public StackValueKind Kind { get; set; }
+    }
+
+    internal class StackItem<T> : StackItem
+    {
+        public T Value { get; }
+
+        public StackItem(T value, StackValueKind kind)
+        {
+            Value = value;
+            Kind = kind;
+        }
+    }
+
+    internal class Int32StackItem : StackItem<int>
+    {
+        public Int32StackItem(int value) : base(value, StackValueKind.Int32)
+        {
+        }
+    }
+
+    internal class Int64StackItem : StackItem<long>
+    {
+        public Int64StackItem(long value) : base(value, StackValueKind.Int64)
+        {
+        }
+    }
+
+    internal class FloatStackItem : StackItem<double>
+    {
+        public FloatStackItem(double value) : base(value, StackValueKind.Float)
+        {
+        }
+    }
+
+    internal class ValueTypeStackItem : StackItem<ValueType>
+    {
+        public ValueTypeStackItem(ValueType value) : base(value, StackValueKind.ValueType)
+        {
+        }
+    }
+
+    internal class ObjectRefStackItem : StackItem<Object>
+    {
+        public ObjectRefStackItem(Object value) : base(value, StackValueKind.ObjRef)
+        {
+        }
+    }
+}
diff --git a/src/System.Private.Interpreter/src/System.Private.Interpreter.csproj b/src/System.Private.Interpreter/src/System.Private.Interpreter.csproj
new file mode 100644
index 000000000..3808516a4
--- /dev/null
+++ b/src/System.Private.Interpreter/src/System.Private.Interpreter.csproj
@@ -0,0 +1,35 @@
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" DefaultTargets="Build">
+  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" />
+  <PropertyGroup>
+    <AssemblyName>System.Private.Interpreter</AssemblyName>
+    <AssemblyVersion>4.0.0.0</AssemblyVersion>
+    <OutputType>Library</OutputType>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+  </PropertyGroup>
+  <ItemGroup Condition="'$(IsProjectNLibrary)' != 'true'">
+    <ProjectReference Include="..\..\AotPackageReference\AotPackageReference.depproj">
+      <ReferenceOutputAssembly>false</ReferenceOutputAssembly>
+      <SkipGetTargetFrameworkProperties>true</SkipGetTargetFrameworkProperties>
+    </ProjectReference>
+    <ReferencePath Include="$(AotPackageReferencePath)\System.Runtime.dll" />
+    <ReferencePath Include="$(AotPackageReferencePath)\System.Runtime.Extensions.dll" />
+    <ReferencePath Include="$(AotPackageReferencePath)\System.Private.Reflection.Metadata.Ecma335.dll" />
+    <ProjectReference Include="..\..\System.Private.CoreLib\src\System.Private.CoreLib.csproj" />
+    <ProjectReference Include="..\..\System.Private.Reflection.Metadata\src\System.Private.Reflection.Metadata.csproj" />
+    <ProjectReference Include="..\..\System.Private.TypeLoader\src\System.Private.TypeLoader.Experimental.csproj" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="..\..\Common\src\TypeSystem\IL\EcmaMethodIL.cs" />
+    <Compile Include="..\..\Common\src\TypeSystem\IL\ILImporter.cs" />
+    <Compile Include="..\..\Common\src\System\Collections\Generic\LowLevelStack.cs" />
+    <Compile Include="Internal\Runtime\CompilerHelpers\LibraryInitializer.cs" />
+    <Compile Include="Internal\Runtime\Interpreter\StackItem.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Internal\Runtime\Interpreter\ILImporter.Interpreter.cs" />
+    <Compile Include="Internal\Runtime\Interpreter\ILInterpreter.cs" />
+    <Compile Include="Internal\Runtime\Interpreter\InterpreterCallInterceptor.cs" />
+    <Compile Include="Internal\Runtime\Interpreter\InterpreterExecutionStrategy.cs" />
+  </ItemGroup>
+  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
+</Project>
\ No newline at end of file
diff --git a/src/System.Private.Jit/src/Internal/Runtime/CompilerHelpers/LibraryInitializer.cs b/src/System.Private.Jit/src/Internal/Runtime/CompilerHelpers/LibraryInitializer.cs
new file mode 100644
index 000000000..ff2abd9e8
--- /dev/null
+++ b/src/System.Private.Jit/src/Internal/Runtime/CompilerHelpers/LibraryInitializer.cs
@@ -0,0 +1,17 @@
+// 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.
+
+using Internal.Runtime.JitSupport;
+using Internal.Runtime.TypeLoader;
+
+namespace Internal.Runtime.CompilerHelpers
+{
+    public class LibraryInitializer
+    {
+        public static void InitializeLibrary()
+        {
+            MethodExecutionStrategy.GlobalExecutionStrategy = new RyuJitExecutionStrategy();
+        }
+    }
+}
diff --git a/src/System.Private.Jit/src/System.Private.Jit.csproj b/src/System.Private.Jit/src/System.Private.Jit.csproj
index f49426928..942a0b74b 100644
--- a/src/System.Private.Jit/src/System.Private.Jit.csproj
+++ b/src/System.Private.Jit/src/System.Private.Jit.csproj
@@ -1,4 +1,4 @@
-<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" DefaultTargets="Build">
+<Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" DefaultTargets="Build">
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.props))\dir.props" />
   <PropertyGroup>
     <AssemblyName>System.Private.Jit</AssemblyName>
@@ -31,7 +31,7 @@
     </ProjectReference>
     <ProjectReference Include="..\..\System.Private.Reflection.Metadata\src\System.Private.Reflection.Metadata.csproj" />
     <ProjectReference Include="..\..\System.Private.TypeLoader\src\System.Private.TypeLoader.Experimental.csproj" />
-    <ProjectReference Include="..\..\System.Private.Interop\src\System.Private.Interop.csproj" />
+    <ProjectReference Include="..\..\System.Private.Interop\src\System.Private.Interop.Experimental.csproj" />
   </ItemGroup>
   <PropertyGroup>
     <NativeFormatCommonPath>..\..\Common\src\Internal\NativeFormat</NativeFormatCommonPath>
@@ -43,6 +43,7 @@
     <JitInterfaceBasePath>..\..\JitInterface\src</JitInterfaceBasePath>
   </PropertyGroup>
   <ItemGroup>
+    <Compile Include="Internal\Runtime\CompilerHelpers\LibraryInitializer.cs" />
     <Compile Include="Internal\Runtime\JitSupport\ExternObjectSymbolNode.cs" />
     <Compile Include="Internal\Runtime\JitSupport\FrozenStrings.cs" />
     <Compile Include="Internal\Runtime\JitSupport\JitCompilation.cs" />
@@ -155,4 +156,4 @@
     <Compile Include="Internal\Runtime\JitSupport\VirtualMethodSlotHelper.cs" />
   </ItemGroup>
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-</Project>
+</Project>
\ No newline at end of file
diff --git a/src/System.Private.Reflection.Core/src/System.Private.Reflection.Core.Experimental.csproj b/src/System.Private.Reflection.Core/src/System.Private.Reflection.Core.Experimental.csproj
index 75f14057a..2cc7b4b44 100644
--- a/src/System.Private.Reflection.Core/src/System.Private.Reflection.Core.Experimental.csproj
+++ b/src/System.Private.Reflection.Core/src/System.Private.Reflection.Core.Experimental.csproj
@@ -2,7 +2,7 @@
   <PropertyGroup>
     <AssemblyName>System.Private.Reflection.Core.Experimental</AssemblyName>
     <EcmaMetadataSupport>true</EcmaMetadataSupport>
-    <JitSupport>true</JitSupport>
+    <DynamicCodeSupport>true</DynamicCodeSupport>
   </PropertyGroup>
 
   <Import Project="System.Private.Reflection.Core.csproj" />
diff --git a/src/System.Private.Reflection.Core/src/System.Private.Reflection.Core.csproj b/src/System.Private.Reflection.Core/src/System.Private.Reflection.Core.csproj
index 696f74096..014a80f7f 100644
--- a/src/System.Private.Reflection.Core/src/System.Private.Reflection.Core.csproj
+++ b/src/System.Private.Reflection.Core/src/System.Private.Reflection.Core.csproj
@@ -24,14 +24,15 @@
       <SkipGetTargetFrameworkProperties>true</SkipGetTargetFrameworkProperties>
     </ProjectReference>
     <ProjectReference Include="..\..\System.Private.CoreLib\src\System.Private.CoreLib.csproj" />
-    <ProjectReference Include="..\..\System.Private.Interop\src\System.Private.Interop.csproj" />
     <ProjectReference Include="..\..\System.Private.Reflection.Metadata\src\System.Private.Reflection.Metadata.csproj" />
   </ItemGroup>
   <ItemGroup Condition="'$(IsProjectNLibrary)' != 'true' and '$(EcmaMetadataSupport)' != 'true'">
     <ProjectReference Include="..\..\System.Private.TypeLoader\src\System.Private.TypeLoader.csproj" />
+    <ProjectReference Include="..\..\System.Private.Interop\src\System.Private.Interop.csproj" />
   </ItemGroup>
   <ItemGroup Condition="'$(IsProjectNLibrary)' != 'true' and '$(EcmaMetadataSupport)' == 'true'">
     <ProjectReference Include="..\..\System.Private.TypeLoader\src\System.Private.TypeLoader.Experimental.csproj" />
+    <ProjectReference Include="..\..\System.Private.Interop\src\System.Private.Interop.Experimental.csproj" />
     <ReferencePath Include="$(AotPackageReferencePath)\System.Private.Reflection.Metadata.Ecma335.dll" />
   </ItemGroup>
   <ItemGroup Condition="'$(EcmaMetadataSupport)' == 'true'">
diff --git a/src/System.Private.Reflection.Core/src/System/Reflection/Runtime/General/Dispensers.cs b/src/System.Private.Reflection.Core/src/System/Reflection/Runtime/General/Dispensers.cs
index 79eca8868..90d5f4803 100644
--- a/src/System.Private.Reflection.Core/src/System/Reflection/Runtime/General/Dispensers.cs
+++ b/src/System.Private.Reflection.Core/src/System/Reflection/Runtime/General/Dispensers.cs
@@ -97,7 +97,7 @@ namespace System.Reflection.Runtime.Assemblies
                     AssemblyBinder binder = ReflectionCoreExecution.ExecutionDomain.ReflectionDomainSetup.AssemblyBinder;
                     AssemblyBindResult bindResult;
                     Exception exception;
-                    if (!binder.Bind(assemblyRefName, out bindResult, out exception))
+                    if (!binder.Bind(assemblyRefName, cacheMissedLookups: true, out bindResult, out exception))
                         return exception;
 
                     return GetRuntimeAssembly(bindResult);
diff --git a/src/System.Private.Reflection.Execution/src/Internal/Reflection/Execution/ReflectionExecution.cs b/src/System.Private.Reflection.Execution/src/Internal/Reflection/Execution/ReflectionExecution.cs
index f0261574f..c8b4a019e 100644
--- a/src/System.Private.Reflection.Execution/src/Internal/Reflection/Execution/ReflectionExecution.cs
+++ b/src/System.Private.Reflection.Execution/src/Internal/Reflection/Execution/ReflectionExecution.cs
@@ -64,10 +64,6 @@ namespace Internal.Reflection.Execution
                 };
 
             ExecutionEnvironment = executionEnvironment;
-
-#if SUPPORT_JIT
-            Internal.Runtime.TypeLoader.MethodExecutionStrategy.GlobalExecutionStrategy = new Internal.Runtime.JitSupport.RyuJitExecutionStrategy();
-#endif
         }
 
         //
diff --git a/src/System.Private.Reflection.Execution/src/System.Private.Reflection.Execution.Experimental.csproj b/src/System.Private.Reflection.Execution/src/System.Private.Reflection.Execution.Experimental.csproj
index 069aa60a9..d70b8fc7a 100644
--- a/src/System.Private.Reflection.Execution/src/System.Private.Reflection.Execution.Experimental.csproj
+++ b/src/System.Private.Reflection.Execution/src/System.Private.Reflection.Execution.Experimental.csproj
@@ -2,7 +2,7 @@
   <PropertyGroup>
     <AssemblyName>System.Private.Reflection.Execution.Experimental</AssemblyName>
     <EcmaMetadataSupport>true</EcmaMetadataSupport>
-    <JitSupport>true</JitSupport>
+    <DynamicCodeSupport>true</DynamicCodeSupport>
   </PropertyGroup>
 
   <Import Project="System.Private.Reflection.Execution.csproj" />
diff --git a/src/System.Private.Reflection.Execution/src/System.Private.Reflection.Execution.csproj b/src/System.Private.Reflection.Execution/src/System.Private.Reflection.Execution.csproj
index 5b935ef32..ed737d170 100644
--- a/src/System.Private.Reflection.Execution/src/System.Private.Reflection.Execution.csproj
+++ b/src/System.Private.Reflection.Execution/src/System.Private.Reflection.Execution.csproj
@@ -13,9 +13,6 @@
   <PropertyGroup Condition="'$(EcmaMetadataSupport)' == 'true'">
     <DefineConstants>ECMA_METADATA_SUPPORT;$(DefineConstants)</DefineConstants>
   </PropertyGroup>
-  <PropertyGroup Condition="'$(JitSupport)' == 'true'">
-    <DefineConstants>SUPPORT_JIT;$(DefineConstants)</DefineConstants>
-  </PropertyGroup>
 
   <!-- Setup the right references -->
   <ItemGroup>
@@ -28,17 +25,18 @@
       <Aliases>global,System_Private_CoreLib</Aliases>
     </ProjectReference>
     <ProjectReference Include="..\..\System.Private.Reflection.Metadata\src\System.Private.Reflection.Metadata.csproj" />
-
-    <ProjectReference Include="..\..\System.Private.Interop\src\System.Private.Interop.csproj" />
   </ItemGroup>
   <ItemGroup Condition="'$(IsProjectNLibrary)' != 'true' and '$(EcmaMetadataSupport)' != 'true'">
+    <ProjectReference Include="..\..\System.Private.Interop\src\System.Private.Interop.csproj" />
     <ProjectReference Include="..\..\System.Private.TypeLoader\src\System.Private.TypeLoader.csproj" />
     <ProjectReference Include="..\..\System.Private.Reflection.Core\src\System.Private.Reflection.Core.csproj" />
   </ItemGroup>
   <ItemGroup Condition="'$(IsProjectNLibrary)' != 'true' and '$(EcmaMetadataSupport)' == 'true'">
+    <ProjectReference Include="..\..\System.Private.Interop\src\System.Private.Interop.Experimental.csproj" />
     <ProjectReference Include="..\..\System.Private.TypeLoader\src\System.Private.TypeLoader.Experimental.csproj" />
     <ProjectReference Include="..\..\System.Private.Reflection.Core\src\System.Private.Reflection.Core.Experimental.csproj" />
     <ProjectReference Include="..\..\System.Private.Jit\src\System.Private.Jit.csproj" />
+    <ProjectReference Include="..\..\System.Private.Interpreter\src\System.Private.Interpreter.csproj" />
   </ItemGroup>
 
   <PropertyGroup>
@@ -95,7 +93,6 @@
     <Compile Include="Internal\Reflection\Extensions\NonPortable\DelegateMethodInfoRetriever.cs" />
     <Compile Include="Internal\Runtime\CompilerHelpers\LibraryInitializer.cs" />
     <Compile Include="System\Reflection\MissingRuntimeArtifactException.cs" />
-
   </ItemGroup>
   <ItemGroup>
     <Compile Include="..\..\Common\src\Internal\Runtime\MetadataBlob.cs" >
diff --git a/src/System.Private.TypeLoader/src/Internal/Reflection/Core/AssemblyBinder.cs b/src/System.Private.TypeLoader/src/Internal/Reflection/Core/AssemblyBinder.cs
index 75cb21e54..e346f5f6b 100644
--- a/src/System.Private.TypeLoader/src/Internal/Reflection/Core/AssemblyBinder.cs
+++ b/src/System.Private.TypeLoader/src/Internal/Reflection/Core/AssemblyBinder.cs
@@ -30,7 +30,7 @@ namespace Internal.Reflection.Core
     {
         public const String DefaultAssemblyNameForGetType = "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089";
 
-        public abstract bool Bind(RuntimeAssemblyName refName, out AssemblyBindResult result, out Exception exception);
+        public abstract bool Bind(RuntimeAssemblyName refName, bool cacheMissedLookups, out AssemblyBindResult result, out Exception exception);
 
         public abstract bool Bind(byte[] rawAssembly, byte[] rawSymbolStore, out AssemblyBindResult result, out Exception exception);
 
diff --git a/src/System.Private.TypeLoader/src/Internal/Reflection/Execution/AssemblyBinderImplementation.Ecma.cs b/src/System.Private.TypeLoader/src/Internal/Reflection/Execution/AssemblyBinderImplementation.Ecma.cs
index c6342da01..444538f55 100644
--- a/src/System.Private.TypeLoader/src/Internal/Reflection/Execution/AssemblyBinderImplementation.Ecma.cs
+++ b/src/System.Private.TypeLoader/src/Internal/Reflection/Execution/AssemblyBinderImplementation.Ecma.cs
@@ -59,7 +59,7 @@ namespace Internal.Reflection.Execution
             lock(s_ecmaLoadedAssemblies)
             {
                 // 3. Attempt to bind to already loaded assembly
-                if (Bind(runtimeAssemblyName, out bindResult, out exception))
+                if (Bind(runtimeAssemblyName, cacheMissedLookups: false, out bindResult, out exception))
                 {
                     result = true;
                     return;
@@ -75,7 +75,7 @@ namespace Internal.Reflection.Execution
                 moduleList.RegisterModule(newModuleInfo);
 
                 // 5. Then try to load by name again. This load should always succeed
-                if (Bind(runtimeAssemblyName, out bindResult, out exception))
+                if (Bind(runtimeAssemblyName, cacheMissedLookups: true, out bindResult, out exception))
                 {
                     result = true;
                     return;
@@ -86,7 +86,7 @@ namespace Internal.Reflection.Execution
             }
         }
 
-        partial void BindEcmaAssemblyName(RuntimeAssemblyName refName, ref AssemblyBindResult result, ref Exception exception, ref Exception preferredException, ref bool foundMatch)
+        partial void BindEcmaAssemblyName(RuntimeAssemblyName refName, bool cacheMissedLookups, ref AssemblyBindResult result, ref Exception exception, ref Exception preferredException, ref bool foundMatch)
         {
             lock(s_ecmaLoadedAssemblies)
             {
@@ -186,7 +186,7 @@ namespace Internal.Reflection.Execution
                     }
 
                     // Cache missed lookups
-                    if (!foundMatch)
+                    if (cacheMissedLookups && !foundMatch)
                     {
                         PEInfo peinfo = new PEInfo(refName, null, null);
                         s_ecmaLoadedAssemblies.Add(peinfo);
diff --git a/src/System.Private.TypeLoader/src/Internal/Reflection/Execution/AssemblyBinderImplementation.cs b/src/System.Private.TypeLoader/src/Internal/Reflection/Execution/AssemblyBinderImplementation.cs
index 701160534..e2fcc6a57 100644
--- a/src/System.Private.TypeLoader/src/Internal/Reflection/Execution/AssemblyBinderImplementation.cs
+++ b/src/System.Private.TypeLoader/src/Internal/Reflection/Execution/AssemblyBinderImplementation.cs
@@ -35,7 +35,7 @@ namespace Internal.Reflection.Execution
         public static AssemblyBinderImplementation Instance { get; } = new AssemblyBinderImplementation();
 
         partial void BindEcmaByteArray(byte[] rawAssembly, byte[] rawSymbolStore, ref AssemblyBindResult bindResult, ref Exception exception, ref bool? result);
-        partial void BindEcmaAssemblyName(RuntimeAssemblyName refName, ref AssemblyBindResult result, ref Exception exception, ref Exception preferredException, ref bool resultBoolean);
+        partial void BindEcmaAssemblyName(RuntimeAssemblyName refName, bool cacheMissedLookups, ref AssemblyBindResult result, ref Exception exception, ref Exception preferredException, ref bool resultBoolean);
         partial void InsertEcmaLoadedAssemblies(List<AssemblyBindResult> loadedAssemblies);
 
         public sealed override bool Bind(byte[] rawAssembly, byte[] rawSymbolStore, out AssemblyBindResult bindResult, out Exception exception)
@@ -53,7 +53,7 @@ namespace Internal.Reflection.Execution
                 return result.Value;
         }
 
-        public sealed override bool Bind(RuntimeAssemblyName refName, out AssemblyBindResult result, out Exception exception)
+        public sealed override bool Bind(RuntimeAssemblyName refName, bool cacheMissedLookups, out AssemblyBindResult result, out Exception exception)
         {
             bool foundMatch = false;
             result = default(AssemblyBindResult);
@@ -102,7 +102,7 @@ namespace Internal.Reflection.Execution
                 }
             }
 
-            BindEcmaAssemblyName(refName, ref result, ref exception, ref preferredException, ref foundMatch);
+            BindEcmaAssemblyName(refName, cacheMissedLookups, ref result, ref exception, ref preferredException, ref foundMatch);
             if (exception != null)
                 return false;
 
diff --git a/src/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/JitSupport.MethodEntrypointStubs.cs b/src/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/MethodEntrypointStubs.cs
index 6f0c2927c..6f0c2927c 100644
--- a/src/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/JitSupport.MethodEntrypointStubs.cs
+++ b/src/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/MethodEntrypointStubs.cs
diff --git a/src/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/TypeLoaderEnvironment.LdTokenResultLookup.cs b/src/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/TypeLoaderEnvironment.LdTokenResultLookup.cs
index 3c6ecf107..b8682b894 100644
--- a/src/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/TypeLoaderEnvironment.LdTokenResultLookup.cs
+++ b/src/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/TypeLoaderEnvironment.LdTokenResultLookup.cs
@@ -363,7 +363,7 @@ namespace Internal.Runtime.TypeLoader
 
             DynamicMethodHandleInfo* methodData = (DynamicMethodHandleInfo*)runtimeMethodHandleValue.ToPointer();
             declaringTypeHandle = *(RuntimeTypeHandle*)&(methodData->DeclaringType);
-            genericMethodArgs = null;
+            genericMethodArgs = Array.Empty<RuntimeTypeHandle>();
 
             if (methodData->NumGenericArgs > 0)
             {
diff --git a/src/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/TypeLoaderEnvironment.Metadata.cs b/src/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/TypeLoaderEnvironment.Metadata.cs
index bde93220d..67a0d3da6 100644
--- a/src/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/TypeLoaderEnvironment.Metadata.cs
+++ b/src/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/TypeLoaderEnvironment.Metadata.cs
@@ -1340,7 +1340,7 @@ namespace Internal.Runtime.TypeLoader
 #if SUPPORTS_R2R_LOADING
             TryGetCodeTableEntry(methodOnType, out entryPoint, out unboxingStubAddress, out foundAddressType);
 #endif
-#if SUPPORT_JIT
+#if SUPPORT_DYNAMIC_CODE
             if (foundAddressType == MethodAddressType.None)
                 MethodEntrypointStubs.TryGetMethodEntrypoint(methodOnType, out entryPoint, out unboxingStubAddress, out foundAddressType);
 #endif
diff --git a/src/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/TypeLoaderEnvironment.MethodAddress.cs b/src/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/TypeLoaderEnvironment.MethodAddress.cs
index 1f33974f8..dbc95140f 100644
--- a/src/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/TypeLoaderEnvironment.MethodAddress.cs
+++ b/src/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/TypeLoaderEnvironment.MethodAddress.cs
@@ -52,7 +52,7 @@ namespace Internal.Runtime.TypeLoader
 #if SUPPORTS_R2R_LOADING
             TryGetCodeTableEntry(method, out methodAddress, out unboxingStubAddress, out foundAddressType);
 #endif
-#if SUPPORT_JIT
+#if SUPPORT_DYNAMIC_CODE
             if (foundAddressType == MethodAddressType.None)
                 MethodEntrypointStubs.TryGetMethodEntrypoint(method, out methodAddress, out unboxingStubAddress, out foundAddressType);
 #endif
diff --git a/src/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/TypeLoaderTypeSystemContext.cs b/src/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/TypeLoaderTypeSystemContext.cs
index 3b9b0bcd1..ccbf4aff9 100644
--- a/src/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/TypeLoaderTypeSystemContext.cs
+++ b/src/System.Private.TypeLoader/src/Internal/Runtime/TypeLoader/TypeLoaderTypeSystemContext.cs
@@ -45,7 +45,7 @@ namespace Internal.Runtime.TypeLoader
         public override FieldLayoutAlgorithm GetLayoutAlgorithmForType(DefType type)
         {
             if ((type == UniversalCanonType)
-#if SUPPORT_JIT
+#if SUPPORT_DYNAMIC_CODE
                 || (type.IsRuntimeDeterminedType && (((RuntimeDeterminedType)type).CanonicalType == UniversalCanonType)))
 #else
                 )
@@ -202,7 +202,7 @@ namespace Internal.Runtime.TypeLoader
 #if SUPPORTS_NATIVE_METADATA_TYPE_LOADING
             AssemblyBindResult bindResult;
             Exception failureException;
-            if (!AssemblyBinderImplementation.Instance.Bind(name.ToRuntimeAssemblyName(), out bindResult, out failureException))
+            if (!AssemblyBinderImplementation.Instance.Bind(name.ToRuntimeAssemblyName(), cacheMissedLookups: true, out bindResult, out failureException))
             {
                 if (throwErrorIfNotFound)
                     throw failureException;
diff --git a/src/System.Private.TypeLoader/src/System.Private.TypeLoader.Experimental.csproj b/src/System.Private.TypeLoader/src/System.Private.TypeLoader.Experimental.csproj
index 530409f48..1625467d0 100644
--- a/src/System.Private.TypeLoader/src/System.Private.TypeLoader.Experimental.csproj
+++ b/src/System.Private.TypeLoader/src/System.Private.TypeLoader.Experimental.csproj
@@ -2,7 +2,7 @@
   <PropertyGroup>
     <AssemblyName>System.Private.TypeLoader.Experimental</AssemblyName>
     <EcmaMetadataSupport>true</EcmaMetadataSupport>
-    <JitSupport>true</JitSupport>
+    <DynamicCodeSupport>true</DynamicCodeSupport>
   </PropertyGroup>
 
   <Import Project="System.Private.TypeLoader.csproj" />
diff --git a/src/System.Private.TypeLoader/src/System.Private.TypeLoader.csproj b/src/System.Private.TypeLoader/src/System.Private.TypeLoader.csproj
index 11afdf633..0a9048622 100644
--- a/src/System.Private.TypeLoader/src/System.Private.TypeLoader.csproj
+++ b/src/System.Private.TypeLoader/src/System.Private.TypeLoader.csproj
@@ -33,8 +33,8 @@
   <PropertyGroup Condition="'$(IsProjectNLibrary)' != 'true'">
     <DefineConstants>EETYPE_TYPE_MANAGER;$(DefineConstants)</DefineConstants>
   </PropertyGroup>
-  <PropertyGroup Condition="'$(JitSupport)' == 'true'">
-    <DefineConstants>SUPPORT_JIT;$(DefineConstants)</DefineConstants>
+  <PropertyGroup Condition="'$(DynamicCodeSupport)' == 'true'">
+    <DefineConstants>SUPPORT_DYNAMIC_CODE;$(DefineConstants)</DefineConstants>
   </PropertyGroup>
   <PropertyGroup Condition="'$(IsProjectNLibrary)' == 'true'">
     <DefineConstants>FEATURE_INTERPRETER;$(DefineConstants)</DefineConstants>
@@ -56,7 +56,7 @@
   <PropertyGroup>
     <NativeFormatCommonPath>..\..\Common\src\Internal\NativeFormat</NativeFormatCommonPath>
   </PropertyGroup>
-  <ItemGroup Condition="'$(JitSupport)' == 'true'">
+  <ItemGroup Condition="'$(DynamicCodeSupport)' == 'true'">
     <Compile Include="..\..\Common\src\TypeSystem\CodeGen\TypeDesc.CodeGen.cs" />
     <Compile Include="..\..\Common\src\TypeSystem\RuntimeDetermined\ArrayType.RuntimeDetermined.cs" />
     <Compile Include="..\..\Common\src\TypeSystem\RuntimeDetermined\ByRefType.RuntimeDetermined.cs" />
@@ -93,7 +93,7 @@
     <Compile Include="..\..\Common\src\TypeSystem\IL\TypeSystemContext.GeneratedAssembly.cs" />
     <Compile Include="Internal\TypeSystem\ILStubMethod.Runtime.cs" />
     <Compile Include="Internal\TypeSystem\MethodForRuntimeDeterminedType.Runtime.cs" />
-    <Compile Include="Internal\Runtime\TypeLoader\JitSupport.MethodEntrypointStubs.cs" />
+    <Compile Include="Internal\Runtime\TypeLoader\MethodEntrypointStubs.cs" />
   </ItemGroup>
   <ItemGroup Condition="'$(EcmaMetadataSupport)' == 'true'" >
     <Compile Include="System\Reflection\Runtime\General\QHandles.Ecma.cs" />