diff --git a/src/mscorlib/Resources/Strings.resx b/src/mscorlib/Resources/Strings.resx
index 6448024c2867..9e2b7841bb68 100644
--- a/src/mscorlib/Resources/Strings.resx
+++ b/src/mscorlib/Resources/Strings.resx
@@ -3715,4 +3715,13 @@
   <data name="Argument_InvalidGenericInstantiation" xml:space="preserve">
     <value>The given generic instantiation was invalid.</value>
   </data>
+  <data name="NativeLibrary_CallerNotSpecified" xml:space="preserve">
+    <value>A calling assembly must be provided if the flag DllImportSearchPath.AssemblyDirectory is specified.</value>
+  </data>
+  <data name="NativeLibrary_FlagsInvalidForPlatform" xml:space="preserve">
+    <value>The specified DllImportSearchPath flags are not supported on the current platform.</value>
+  </data>
+  <data name="NativeLibrary_InvalidOrdinal" xml:space="preserve">
+    <value>An invalid ordinal value was specified.</value>
+  </data>
 </root>
diff --git a/src/mscorlib/System.Private.CoreLib.csproj b/src/mscorlib/System.Private.CoreLib.csproj
index aec27ca03244..8460baf0f6f6 100644
--- a/src/mscorlib/System.Private.CoreLib.csproj
+++ b/src/mscorlib/System.Private.CoreLib.csproj
@@ -58,7 +58,7 @@
   <PropertyGroup Condition="'$(Platform)' == 'x86'">
     <PlatformTarget>x86</PlatformTarget>
     <BaseAddress>0x10000000</BaseAddress>
-    <DefineConstants>BIT32;$(DefineConstants)</DefineConstants>
+    <DefineConstants>BIT32;X86;$(DefineConstants)</DefineConstants>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Platform)' == 'arm'">
     <PlatformTarget>arm</PlatformTarget>
@@ -149,6 +149,7 @@
     <Compile Include="$(BclSourcesRoot)\System\Runtime\InteropServices\ICustomMarshaler.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Runtime\InteropServices\InvalidOleVariantTypeException.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Runtime\InteropServices\Marshal.cs" />
+    <Compile Include="$(BclSourcesRoot)\System\Runtime\InteropServices\NativeLibrary.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Runtime\InteropServices\PInvokeMap.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Runtime\InteropServices\PInvokeMarshal.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Runtime\InteropServices\RuntimeEnvironment.cs" />
@@ -585,6 +586,7 @@
     <Compile Include="$(BclSourcesRoot)\System\Globalization\GlobalizationMode.Unix.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Runtime\Versioning\CompatibilitySwitch.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Threading\ClrThreadPoolBoundHandle.Unix.cs" />
+    <Compile Include="$(BclSourcesRoot)\System\Runtime\InteropServices\NativeLibrary.Unix.cs" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetsWindows)' == 'true'">
     <Compile Include="$(BclSourcesRoot)\Interop\Windows\Kernel32\Interop.GetSystemDirectoryW.cs" />
@@ -594,6 +596,7 @@
     <Compile Include="$(BclSourcesRoot)\System\Globalization\GlobalizationMode.Windows.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Threading\ClrThreadPoolBoundHandle.Windows.cs" />
     <Compile Include="$(BclSourcesRoot)\System\Environment.Windows.cs" />
+    <Compile Include="$(BclSourcesRoot)\System\Runtime\InteropServices\NativeLibrary.Windows.cs" />
   </ItemGroup>
   <ItemGroup>
     <!--
@@ -669,4 +672,4 @@
   </ItemGroup>
 
   <Import Project="GenerateCompilerResponseFile.targets" />
-</Project>
\ No newline at end of file
+</Project>
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/Marshal.cs b/src/mscorlib/src/System/Runtime/InteropServices/Marshal.cs
index 98b33e39087c..96c328e04134 100644
--- a/src/mscorlib/src/System/Runtime/InteropServices/Marshal.cs
+++ b/src/mscorlib/src/System/Runtime/InteropServices/Marshal.cs
@@ -864,6 +864,14 @@ public static void PrelinkAll(Type c)
             }
         }
 
+        internal static int NumParamBytes(RuntimeMethodInfo m, bool isForStdCallDelegate)
+        {
+            return InternalNumParamBytes(m, isForStdCallDelegate);
+        }
+
+        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
+        private static extern int InternalNumParamBytes(IRuntimeMethodInfo m, bool isForStdCallDelegate);
+
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         public static extern /* struct _EXCEPTION_POINTERS* */ IntPtr GetExceptionPointers();
         
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/NativeLibrary.Unix.cs b/src/mscorlib/src/System/Runtime/InteropServices/NativeLibrary.Unix.cs
new file mode 100644
index 000000000000..e87727c5fa0b
--- /dev/null
+++ b/src/mscorlib/src/System/Runtime/InteropServices/NativeLibrary.Unix.cs
@@ -0,0 +1,24 @@
+// 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.
+
+namespace System.Runtime.InteropServices
+{
+    // Contains UNIX-specific logic for NativeLibrary class.
+    public unsafe sealed partial class NativeLibrary
+    {
+        // The allowed mask values for the DllImportSearchPath.
+        // Non-Windows sytems only allow AssemblyDirectory and LegacyBehavior.
+        private const uint AllowedDllImportSearchPathsMask = (uint)(DllImportSearchPath.AssemblyDirectory | DllImportSearchPath.LegacyBehavior);
+
+        // [DllImport] (NDirectMethodDesc::FindEntryPoint) doesn't allow lookup by ordinal on non-Windows.
+        private const bool AllowLocatingFunctionsByOrdinal = false;
+
+        private static bool IsValidModuleHandle(IntPtr hModule)
+        {
+            // No validation other than checking for null.
+
+            return (hModule != IntPtr.Zero);
+        }
+    }
+}
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/NativeLibrary.Windows.cs b/src/mscorlib/src/System/Runtime/InteropServices/NativeLibrary.Windows.cs
new file mode 100644
index 000000000000..3d73d8489c7a
--- /dev/null
+++ b/src/mscorlib/src/System/Runtime/InteropServices/NativeLibrary.Windows.cs
@@ -0,0 +1,59 @@
+// 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.
+
+namespace System.Runtime.InteropServices
+{
+    // Contains Windows-specific logic for NativeLibrary class.
+    public sealed partial class NativeLibrary
+    {
+        // The allowed mask values for the DllImportSearchPath.
+        // The high three bytes are passed as-is to the OS (which will check them for validity),
+        // and the low byte is allowed to contain AssemblyDirectory or LegacyBehavior.
+        private const uint AllowedDllImportSearchPathsMask = ~0xFFU | (uint)(DllImportSearchPath.AssemblyDirectory | DllImportSearchPath.LegacyBehavior);
+
+        // [DllImport] (NDirectMethodDesc::FindEntryPoint) allows lookup by ordinal on Windows.
+        private const bool AllowLocatingFunctionsByOrdinal = true;
+
+        // from libloaderapi.h
+        private const uint GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS = 0x00000004;
+        private const uint GET_MODULE_HANDLE_EX_FLAG_PIN = 0x00000001;
+
+        private static bool IsValidModuleHandle(IntPtr hModule)
+        {
+            // This method has two purposes: (a) it ensures that the provided module handle is indeed valid,
+            // and (b) it pins the module so that it can never be unloaded from the current process. The CLR
+            // expects modules to be pinned (see the call to BaseHolder<...>::Extract in NDirect::LoadLibraryModule),
+            // and we should enforce this invariant regardless of which code path ended up loading the module.
+
+            if (hModule == IntPtr.Zero)
+            {
+                return false;
+            }
+
+            if (!GetModuleHandleEx(
+                dwFlags: GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_PIN,
+                lpModuleName: hModule, // module base address, not module name
+                phModule: out IntPtr baseAddress))
+            {
+                return false;
+            }
+
+            if (hModule != baseAddress)
+            {
+                return false;
+            }
+
+            // all checks succeeded
+            return true;
+        }
+
+        // https://msdn.microsoft.com/en-us/library/windows/desktop/ms683200(v=vs.85).aspx
+        [DllImport(Interop.Libraries.Kernel32, EntryPoint = "GetModuleHandleExW", CharSet = CharSet.Unicode, SetLastError = true)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static extern bool GetModuleHandleEx(
+            [In] uint dwFlags,
+            [In] IntPtr lpModuleName,
+            [Out] out IntPtr phModule);
+    }
+}
diff --git a/src/mscorlib/src/System/Runtime/InteropServices/NativeLibrary.cs b/src/mscorlib/src/System/Runtime/InteropServices/NativeLibrary.cs
new file mode 100644
index 000000000000..758218ec1c86
--- /dev/null
+++ b/src/mscorlib/src/System/Runtime/InteropServices/NativeLibrary.cs
@@ -0,0 +1,338 @@
+// 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.Diagnostics;
+using System.Globalization;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+namespace System.Runtime.InteropServices
+{
+    /// <summary>
+    /// A helper class which allows interacting with dynamically loaded modules.
+    /// </summary>
+    /// <remarks>
+    /// This is similar in principle to <see cref="DllImportAttribute"/>, but it can be used where
+    /// the module name or export names are not known at compile time.
+    /// </remarks>
+    public sealed partial class NativeLibrary
+    {
+        // The CLR's internal HINSTANCE, which may not match the OS-provided handle.
+        private readonly IntPtr _hInstance;
+
+        private NativeLibrary(IntPtr hModule)
+        {
+            if (!IsValidModuleHandle(hModule))
+            {
+                throw new ArgumentException(
+                    paramName: nameof(hModule),
+                    message: SR.Argument_InvalidHandle);
+            }
+
+            _hInstance = hModule;
+        }
+
+        // This is a managed equivalent to NDirectMethodDesc::FindEntryPoint.
+        private TDelegate CreateDelegateCore<TDelegate>(string name, bool exactSpelling, RuntimeMethodInfo delegateInvokeMethod) where TDelegate : class
+        {
+            Debug.Assert(typeof(TDelegate) is RuntimeType);
+            Debug.Assert(((RuntimeType)typeof(TDelegate)).IsDelegate());
+            Debug.Assert(name != null);
+            Debug.Assert(delegateInvokeMethod != null);
+
+            // If we allow lookup by ordinal value and an ordinal is specified ("#1234", where
+            // the value immediately following the '#' can fit into a WORD), then process the
+            // ordinal and skip all other logic in this routine.
+
+            if (AllowLocatingFunctionsByOrdinal && name.Length >= 1 && name[0] == '#')
+            {
+                if (UInt16.TryParse(name.AsReadOnlySpan(1), style: NumberStyles.None, provider: CultureInfo.InvariantCulture, out ushort ordinal))
+                {
+                    return CreateDelegateForSymbolByOrdinal<TDelegate>(ordinal);
+                }
+                else
+                {
+                    throw new ArgumentException(
+                        paramName: nameof(name),
+                        message: SR.NativeLibrary_InvalidOrdinal);
+                }
+            }
+
+            GetCharsetAndCallingConvention(delegateInvokeMethod, out bool isAnsi, out bool isStdcall);
+
+            // Always look for the unmangled name first.
+            // If there's a match and we're in ANSI mode, return it without looking for mangled names.
+            // If mangling is disabled, don't proceed, even if we couldn't find the matching symbol.
+
+            TDelegate retVal = CreateDelegateForSymbolByName<TDelegate>(name);
+            if (exactSpelling || (retVal != null && isAnsi))
+            {
+                return retVal;
+            }
+
+            // Try appending an 'A' or 'W' suffix to get the ANSI / Unicode version of the API.
+
+            if (isAnsi)
+            {
+                Debug.Assert(retVal == null);
+                retVal = CreateDelegateForSymbolByName<TDelegate>(name + "A");
+            }
+            else
+            {
+                // On Unicode only (not ANSI), a method with a 'W' suffix takes precedence
+                // over a method with an exact name match when name mangling is enabled.
+                retVal = CreateDelegateForSymbolByName<TDelegate>(name + "W") ?? retVal;
+            }
+
+#if X86
+            // On x86 only, look for __stdcall mangled names as a last resort.
+            // They'll be of the form "_Name@x", where x is the stack size in bytes of the method arguments.
+
+            if (retVal == null && isStdcall)
+            {
+                Debug.Assert(!exactSpelling);
+                string stdcallMangledName = FormattableString.Invariant($"_{name}@{(uint)Marshal.NumParamBytes(delegateInvokeMethod, isForStdCallDelegate: true):D}");
+                retVal = CreateDelegateForSymbolByName<TDelegate>(stdcallMangledName);
+            }
+#endif
+
+            // This could still be null if we had no match, but there's nothing left for us to try.
+            return retVal;
+        }
+
+        // Looks up a symbol by name (caller is responsible for mangling), and if it's found returns a delegate for it.
+        // Returns null if the symbol is not found.
+        private TDelegate CreateDelegateForSymbolByName<TDelegate>(string symbolName) where TDelegate : class
+        {
+            Debug.Assert(((RuntimeType)typeof(TDelegate)).IsDelegate());
+
+            IntPtr symbolAddress = GetProcAddress(_hInstance, symbolName);
+            return (symbolAddress != IntPtr.Zero)
+                ? Marshal.GetDelegateForFunctionPointer<TDelegate>(symbolAddress)
+                : null;
+        }
+
+        // Looks up a symbol by ordinal and if it's found returns a delegate for it.
+        // Returns null if the symbol is not found.
+        private TDelegate CreateDelegateForSymbolByOrdinal<TDelegate>(ushort ordinal) where TDelegate : class
+        {
+            Debug.Assert(((RuntimeType)typeof(TDelegate)).IsDelegate());
+
+            IntPtr symbolAddress = GetProcAddress(_hInstance, (IntPtr)ordinal);
+            return (symbolAddress != IntPtr.Zero)
+                ? Marshal.GetDelegateForFunctionPointer<TDelegate>(symbolAddress)
+                : null;
+        }
+
+        /// <summary>
+        /// Equivalent to <see cref="TryGetDelegate{TDelegate}(string, bool, out TDelegate)"/> where <em>exactSpelling</em> is <see langword="false"/>.
+        /// </summary>
+        public bool TryGetDelegate<TDelegate>(string name, out TDelegate result) where TDelegate : class
+            => TryGetDelegate<TDelegate>(name, exactSpelling: false, out result);
+
+        /// <summary>
+        /// Attempts to locate a named function in the module's export table and return a managed delegate to that function.
+        /// </summary>
+        /// <typeparam name="TDelegate">The delegate type that will be created. This type must subclass <see cref="MulticastDelegate"/>.
+        /// This type <em>should</em> be (but is not required to be) annotated with <see cref="UnmanagedFunctionPointerAttribute"/>.
+        /// Generic delegate types (e.g., <see cref="Func{T, TResult}"/>) are not supported.</typeparam>
+        /// <param name="name">The name of the function to look up.</param>
+        /// <param name="exactSpelling"><see langword="false"/> (default) if the runtime should automatically perform name decoration when
+        /// locating the exported function; <see langword="true"/> if the runtime should use the provided name as-is with no additional
+        /// decoration. See also <see cref="DllImportAttribute.ExactSpelling"/>.</param>
+        /// <param name="result">A <typeparamref name="TDelegate"/> that represents the exported function,
+        /// or <see langword="null"/> if the function cannot be located in the export table.</param>
+        /// <returns><see langword="true"/> if the function was found, otherwise <see langword="false"/>.</returns>
+        /// <remarks>
+        /// Functions can also be queried by ordinal export by using a "#" prefix (e.g., "#1") for <paramref name="name"/>.
+        /// </remarks>
+        public bool TryGetDelegate<TDelegate>(string name, bool exactSpelling, out TDelegate result) where TDelegate : class
+        {
+            // Parameter validation
+            // Some checks overlap with Marshal.GetDelegateForFunctionPointer since we need to
+            // call into the CLR separately so that we can support mangling and other features.
+
+            var delegateType = typeof(TDelegate) as RuntimeType;
+
+            // Must be a normal RuntimeType and the immediate parent class must be MulticastDelegate
+            if (delegateType == null || !delegateType.IsDelegate())
+            {
+                throw new ArgumentException(
+                    paramName: nameof(TDelegate),
+                    message: SR.Arg_MustBeDelegate);
+            }
+
+            RuntimeMethodHandleInternal invokeMethodHandle = new RuntimeMethodHandleInternal(System.StubHelpers.StubHelpers.GetDelegateInvokeMethodFromDelegateType(delegateType));
+            RuntimeMethodInfo invokeMethodInfo = (RuntimeMethodInfo)RuntimeType.GetMethodBase(delegateType, invokeMethodHandle);
+
+            // Generic types are disallowed
+            if (delegateType.IsGenericType || invokeMethodInfo.IsGenericMethod)
+            {
+                throw new ArgumentException(
+                    paramName: nameof(TDelegate),
+                    message: SR.Argument_NeedNonGenericType);
+            }
+
+            if (invokeMethodInfo.CallingConvention == CallingConventions.VarArgs)
+            {
+                throw new ArgumentException(
+                    paramName: nameof(TDelegate),
+                    message: SR.NotSupported_CallToVarArg);
+            }
+
+            if (name == null)
+            {
+                throw new ArgumentNullException(nameof(name));
+            }
+
+            // End parameter validation
+
+            result = CreateDelegateCore<TDelegate>(name, exactSpelling, invokeMethodInfo);
+            return (result != null);
+        }
+
+        /// <summary>
+        /// Attempts to locate the address of a symbol in the module's export table.
+        /// </summary>
+        /// <param name="symbolName">The name of the symbol to locate.</param>
+        /// <param name="result">The address of the symbol, or <see cref="IntPtr.Zero"/> if the symbol cannot be found.</param>
+        /// <returns><see langword="true"/> if the symbol was found, otherwise <see langword="false"/>.</returns>
+        /// <remarks>
+        /// Unlike <see cref="TryGetDelegate{TDelegate}(string, bool, out TDelegate)"/>, this method does not perform name decoration.
+        /// The name provided in <paramref name="symbolName"/> must exactly match the name present in the export table.
+        /// </remarks>
+        public bool TryGetSymbolAddress(string symbolName, out IntPtr result)
+        {
+            // Parameter validation
+
+            if (symbolName == null)
+            {
+                throw new ArgumentNullException(nameof(symbolName));
+            }
+
+            // End parameter validation
+
+            // We expect that the caller has provided the exact symbol name; we don't perform extra mangling.
+
+            result = GetProcAddress(_hInstance, symbolName);
+            return (result != IntPtr.Zero);
+        }
+
+        /// <summary>
+        /// Attempts to dynamically load the named module.
+        /// </summary>
+        /// <param name="name">The name of the module to load, similar to <see cref="DllImportAttribute.Value"/>.</param>
+        /// <param name="caller">The assembly which is requesting the module load. Generally this should be the managed assembly
+        /// which has a direct dependency on the native library.</param>
+        /// <param name="paths">A flags value which contains the locations that should be searched during module load.</param>
+        /// <param name="result">A <see cref="NativeLibrary"/> instance that represents the loaded module,
+        /// or <see langword="null"/> if the module could not be found. Once loaded, a module cannot be unloaded.</param>
+        /// <returns><see langword="true"/> if the module was found and loaded, otherwise <see langword="false"/>.</returns>
+        /// <remarks>
+        /// There are some behavioral differences between this method and <see cref="DllImportAttribute"/>. For example, the
+        /// value provided in <paramref name="name"/> cannot be the display name of a managed assembly. Additionally, if
+        /// <paramref name="caller"/> is not specified, then <paramref name="paths"/> cannot have the flags values
+        /// <see cref="DllImportSearchPath.LegacyBehavior"/> or <see cref="DllImportSearchPath.AssemblyDirectory"/>.
+        /// If <paramref name="caller"/> is specified and <paramref name="paths"/> is <see cref="DllImportSearchPath.LegacyBehavior"/>
+        /// and an assembly-level <see cref="DefaultDllImportSearchPathsAttribute"/> is present, the assembly-level default
+        /// <see cref="DllImportSearchPath"/> value will be used instead.
+        /// This method may throw an exception in certain cases, such as if the module was located but is invalid
+        /// for the current architecture.
+        /// </remarks>
+        public static bool TryLoad(string name, Assembly caller, DllImportSearchPath paths, out NativeLibrary result)
+        {
+            // Parameter validation
+
+            if (name == null)
+            {
+                throw new ArgumentNullException(nameof(name));
+            }
+
+            RuntimeAssembly callerAsRuntimeAssembly = null;
+            if (caller != null)
+            {
+                callerAsRuntimeAssembly = caller as RuntimeAssembly;
+
+                if (callerAsRuntimeAssembly != null)
+                {
+                    throw new ArgumentException(
+                        paramName: nameof(caller),
+                        message: SR.Argument_MustBeRuntimeAssembly);
+                }
+
+                // Assembly-level default search paths win out over legacy behavior.
+                // This is a slight change in behavior from [DllImport], where search paths specified at
+                // the method level override search paths specified at the assembly level. But since our
+                // paths parameter isn't nullable, we need to resolve the ambiguity *somehow*, and this
+                // seems like the way that'll be least surprising to consumers.
+
+                if (paths == DllImportSearchPath.LegacyBehavior)
+                {
+                    var attr = caller.GetCustomAttribute<DefaultDllImportSearchPathsAttribute>();
+                    if (attr != null)
+                    {
+                        paths = attr.Paths;
+                    }
+                }
+            }
+
+            // The set of allowed flags is going to be different per OS. The caller is responsible
+            // for querying RuntimeInformation.IsOSPlatform(...) so that they don't inadvertently
+            // provide flags that are meaningless for the current OS.
+
+            if (((uint)paths & ~AllowedDllImportSearchPathsMask) != 0)
+            {
+                throw new ArgumentException(
+                    paramName: nameof(paths),
+                    message: SR.NativeLibrary_FlagsInvalidForPlatform);
+            }
+
+            // "Should search assembly directory?" gets special treatment by the CLR,
+            // so we strip it off into its own parameter.
+
+            bool searchAssemblyDirectory = paths.HasFlag(DllImportSearchPath.AssemblyDirectory);
+            paths &= ~DllImportSearchPath.AssemblyDirectory;
+
+            if (caller == null && searchAssemblyDirectory)
+            {
+                throw new ArgumentException(
+                    paramName: nameof(paths),
+                    message: SR.NativeLibrary_CallerNotSpecified);
+            }
+
+            // End parameter validation
+
+            IntPtr hModule = LoadLibrary(name, callerAsRuntimeAssembly?.GetNativeHandle(), searchAssemblyDirectory, paths);
+            result = (hModule != IntPtr.Zero) ? new NativeLibrary(hModule) : null;
+            return (result != null);
+        }
+
+        // For symbol lookups by name
+        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
+        private static extern void GetCharsetAndCallingConvention(
+            [In] IRuntimeMethodInfo pMdDelegate,
+            [Out] out bool pfIsAnsi,
+            [Out] out bool pfIsStdcall);
+
+        // For symbol lookups by name
+        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode, ThrowOnUnmappableChar = true)]
+        private static extern IntPtr GetProcAddress(
+            [In] IntPtr hModule,
+            [In, MarshalAs(UnmanagedType.LPStr)] string lpProcName);
+
+        // For symbol lookups by ordinal value
+        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
+        private static extern IntPtr GetProcAddress(
+            [In] IntPtr hModule,
+            [In] IntPtr lpProcName);
+
+        // Loads a library by name
+        [DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode, ThrowOnUnmappableChar = true)]
+        private static extern IntPtr LoadLibrary(
+                [In, MarshalAs(UnmanagedType.LPUTF8Str)] string moduleName,
+                [In] RuntimeAssembly callingAssembly,
+                [In] bool searchAssemblyDirectory,
+                [In] DllImportSearchPath searchPaths);
+    }
+}
diff --git a/src/mscorlib/src/System/StubHelpers.cs b/src/mscorlib/src/System/StubHelpers.cs
index fb196041ad46..7981561e7f65 100644
--- a/src/mscorlib/src/System/StubHelpers.cs
+++ b/src/mscorlib/src/System/StubHelpers.cs
@@ -1561,6 +1561,9 @@ internal static class StubHelpers
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         static internal extern IntPtr GetDelegateTarget(Delegate pThis, ref IntPtr pStubArg);
 
+        [MethodImplAttribute(MethodImplOptions.InternalCall)]
+        static internal extern IntPtr GetDelegateInvokeMethodFromDelegateType(RuntimeType pDelegateClass);
+
         [MethodImplAttribute(MethodImplOptions.InternalCall)]
         static internal extern void ClearLastError();
 
diff --git a/src/vm/CMakeLists.txt b/src/vm/CMakeLists.txt
index b7b9d2259f8e..7fbf486d0469 100644
--- a/src/vm/CMakeLists.txt
+++ b/src/vm/CMakeLists.txt
@@ -221,6 +221,7 @@ set(VM_SOURCES_WKS
     multicorejit.cpp # Condition="'$(FeatureMulticoreJIT)' == 'true'
     multicorejitplayer.cpp # Condition="'$(FeatureMulticoreJIT)' == 'true'
     nativeeventsource.cpp
+    nativelibrary.cpp
     nativeoverlapped.cpp
     objectlist.cpp
     olevariant.cpp
diff --git a/src/vm/dllimport.cpp b/src/vm/dllimport.cpp
index 345b3d6a7026..fc2bce652624 100644
--- a/src/vm/dllimport.cpp
+++ b/src/vm/dllimport.cpp
@@ -5774,6 +5774,12 @@ class LoadLibErrorTracker
         return m_message;
     }
 
+    // Returns true if this tracker contains a higher-priority error than simply "not found".
+    bool ContainsHighPriorityError()
+    {
+        return (m_priorityOfLastError > const_priorityNotFound);
+    }
+
     void DECLSPEC_NORETURN Throw(SString &libraryNameOrPath)
     {
         STANDARD_VM_CONTRACT;
@@ -5907,7 +5913,7 @@ HMODULE NDirect::LoadLibraryFromPath(LPCWSTR libraryPath)
 }
 
 /* static */
-HMODULE NDirect::LoadLibraryModuleViaHost(NDirectMethodDesc * pMD, AppDomain* pDomain, const wchar_t* wszLibName)
+HMODULE NDirect::LoadLibraryModuleViaHost(Assembly * pAssembly, AppDomain* pDomain, const wchar_t* wszLibName)
 {
     STANDARD_VM_CONTRACT;
     //Dynamic Pinvoke Support:
@@ -5924,7 +5930,6 @@ HMODULE NDirect::LoadLibraryModuleViaHost(NDirectMethodDesc * pMD, AppDomain* pD
 
     LPVOID hmod = NULL;
     CLRPrivBinderCoreCLR *pTPABinder = pDomain->GetTPABinderContext();
-    Assembly* pAssembly = pMD->GetMethodTable()->GetAssembly();
    
     PEFile *pManifestFile = pAssembly->GetManifestFile();
     PTR_ICLRPrivBinder pBindingContext = pManifestFile->GetBindingContext();
@@ -6098,6 +6103,8 @@ static void DetermineLibNameVariations(const char* const** libNameVariations, in
 }
 #endif
 
+// This routine is used for methods annotated with [DllImport].
+// Keep it (generally) in sync with LoadLibraryModuleForNativeLibrary.
 HINSTANCE NDirect::LoadLibraryModule(NDirectMethodDesc * pMD, LoadLibErrorTracker * pErrorTracker)
 {
     CONTRACTL
@@ -6125,7 +6132,7 @@ HINSTANCE NDirect::LoadLibraryModule(NDirectMethodDesc * pMD, LoadLibErrorTracke
     // AppX mode.
     if (!AppX::IsAppXProcess())
     {
-        hmod = LoadLibraryModuleViaHost(pMD, pDomain, wszLibName);
+        hmod = LoadLibraryModuleViaHost(pMD->GetMethodTable()->GetAssembly(), pDomain, wszLibName);
     }
     
     
@@ -6277,6 +6284,118 @@ HINSTANCE NDirect::LoadLibraryModule(NDirectMethodDesc * pMD, LoadLibErrorTracke
     return hmod.Extract();
 }
 
+// This method is used by the NativeLibrary class for mimicking [DllImport] but without having that exact annotation.
+// Keep it (generally) in sync with LoadLibraryModule.
+HINSTANCE NDirect::LoadLibraryModuleForNativeLibrary(LPCUTF8 name, Assembly* pCallingAssembly, BOOL fSearchAssemblyDirectory, DWORD dwSearchPaths)
+{
+    CONTRACTL
+    {
+        STANDARD_VM_CHECK;
+        PRECONDITION(CheckPointer(name));
+    }
+    CONTRACTL_END;
+
+    // This is a lightweight version of LoadLibraryModule intended to be used by application code,
+    // not framework code. As such this doesn't support all features that [DllImport] would support.
+    // For example, calls into the CLR aren't special-cased, nor are Windows-specific API sets, nor
+    // is checking to see if the library name is actually a managed assembly name. There's also no
+    // guarantee that a caller assembly has been provided, and if this is the case we need to skip
+    // the assembly-relative lookups (either via AssemblyLoadContext or directory fixups).
+
+    LoadLibErrorTracker errorTracker;
+    ModuleHandleHolder hmod;
+
+    DWORD loadWithAlteredPathFlags = GetLoadWithAlteredSearchPathFlag();
+
+    PREFIX_ASSUME(name != NULL);
+    MAKE_WIDEPTR_FROMUTF8(wszLibName, name);
+
+    AppDomain* pDomain = GetAppDomain();
+
+    // AssemblyLoadContext is not supported in AppX mode and thus,
+    // we should not perform PInvoke resolution via it when operating in
+    // AppX mode.
+    if (pCallingAssembly != nullptr && !AppX::IsAppXProcess())
+    {
+        hmod = LoadLibraryModuleViaHost(pCallingAssembly, pDomain, wszLibName);
+    }
+
+    if (hmod == nullptr)
+    {
+        hmod = pDomain->FindUnmanagedImageInCache(wszLibName);
+    }
+
+    if (hmod != nullptr)
+    {
+        return hmod.Extract();
+    }
+
+    bool libNameIsRelativePath = Path::IsRelative(wszLibName);
+#ifdef FEATURE_PAL
+    // P/Invokes are often declared with variations on the actual library name.
+    // For example, it's common to leave off the extension/suffix of the library
+    // even if it has one, or to leave off a prefix like "lib" even if it has one
+    // (both of these are typically done to smooth over cross-platform differences). 
+    // We try to dlopen with such variations on the original.
+    const char* const* prefixSuffixCombinations = nullptr;
+    int numberOfVariations = 0;
+    DetermineLibNameVariations(&prefixSuffixCombinations, &numberOfVariations, wszLibName, libNameIsRelativePath);
+    for (int i = 0; hmod == nullptr && i < numberOfVariations; i++)
+    {
+        SString currLibNameVariation;
+        currLibNameVariation.Printf(prefixSuffixCombinations[i], PAL_SHLIB_PREFIX, name, PAL_SHLIB_SUFFIX);
+#else
+    {
+        LPCWSTR currLibNameVariation = wszLibName;
+#endif
+        if (hmod == nullptr)
+        {
+            // NATIVE_DLL_SEARCH_DIRECTORIES set by host is considered well known path 
+            hmod = LoadFromNativeDllSearchDirectories(pDomain, currLibNameVariation, loadWithAlteredPathFlags, &errorTracker);
+        }
+
+        if (hmod == nullptr)
+        {
+            if (!libNameIsRelativePath)
+            {
+                DWORD flags = loadWithAlteredPathFlags;
+                if ((dwSearchPaths & LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR) != 0)
+                {
+                    // LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR is the only flag affecting absolute path. Don't OR the flags
+                    // unconditionally as all absolute path P/Invokes could then lose LOAD_WITH_ALTERED_SEARCH_PATH.
+                    flags |= dwSearchPaths;
+                }
+
+                hmod = LocalLoadLibraryHelper(currLibNameVariation, flags, &errorTracker);
+            }
+            else if (fSearchAssemblyDirectory)
+            {
+                hmod = LoadFromPInvokeAssemblyDirectory(pCallingAssembly, currLibNameVariation, loadWithAlteredPathFlags | dwSearchPaths, &errorTracker);
+            }
+        }
+
+        // This call searches the application directory instead of the location for the library.
+        if (hmod == nullptr)
+        {
+            hmod = LocalLoadLibraryHelper(currLibNameVariation, dwSearchPaths, &errorTracker);
+        }
+    }
+
+    // After all this, if we have a handle add it to the cache.
+    if (hmod != nullptr)
+    {
+        pDomain->AddUnmanagedImageToCache(wszLibName, hmod);
+    }
+
+    if (hmod == nullptr && errorTracker.ContainsHighPriorityError())
+    {
+        SString libNameSString(wszLibName);
+        errorTracker.Throw(libNameSString);
+    }
+
+    return hmod.Extract();
+}
+
 //---------------------------------------------------------
 // Loads the DLL and finds the procaddress for an N/Direct call.
 //---------------------------------------------------------
diff --git a/src/vm/dllimport.h b/src/vm/dllimport.h
index 058484c45eb1..012c17b53582 100644
--- a/src/vm/dllimport.h
+++ b/src/vm/dllimport.h
@@ -79,6 +79,7 @@ class NDirect
     static LPVOID NDirectGetEntryPoint(NDirectMethodDesc *pMD, HINSTANCE hMod);
     static HMODULE LoadLibraryFromPath(LPCWSTR libraryPath);
     static HINSTANCE LoadLibraryModule(NDirectMethodDesc * pMD, LoadLibErrorTracker *pErrorTracker);
+    static HINSTANCE LoadLibraryModuleForNativeLibrary(LPCUTF8 name, Assembly* pCallingAssembly, BOOL fSearchAssemblyDirectory, DWORD dwSearchPaths);
 
 
     static VOID NDirectLink(NDirectMethodDesc *pMD);
@@ -129,7 +130,7 @@ class NDirect
     static HMODULE LoadFromNativeDllSearchDirectories(AppDomain* pDomain, LPCWSTR libName, DWORD flags, LoadLibErrorTracker *pErrorTracker);
     static HMODULE LoadFromPInvokeAssemblyDirectory(Assembly *pAssembly, LPCWSTR libName, DWORD flags, LoadLibErrorTracker *pErrorTracker);
 
-    static HMODULE LoadLibraryModuleViaHost(NDirectMethodDesc * pMD, AppDomain* pDomain, const wchar_t* wszLibName);
+    static HMODULE LoadLibraryModuleViaHost(Assembly * pAssembly, AppDomain* pDomain, const wchar_t* wszLibName);
 
 #if !defined(FEATURE_PAL)
     // Indicates if the OS supports the new secure LoadLibraryEx flags introduced in KB2533623
diff --git a/src/vm/ecalllist.h b/src/vm/ecalllist.h
index 1259759ba08c..97ea1b80c848 100644
--- a/src/vm/ecalllist.h
+++ b/src/vm/ecalllist.h
@@ -887,6 +887,7 @@ FCFuncStart(gInteropMarshalFuncs)
     FCFuncElement("DestroyStructure", MarshalNative::DestroyStructure)
     FCFuncElement("UnsafeAddrOfPinnedArrayElement", MarshalNative::FCUnsafeAddrOfPinnedArrayElement)
     FCFuncElement("GetExceptionCode", ExceptionNative::GetExceptionCode)
+    QCFuncElement("InternalNumParamBytes", MarshalNative::NumParamBytes)
     FCFuncElement("GetExceptionPointers", ExceptionNative::GetExceptionPointers)
     QCFuncElement("GetHINSTANCE", COMModule::GetHINSTANCE)
 
@@ -932,6 +933,12 @@ FCFuncStart(gInteropMarshalFuncs)
 #endif // FEATURE_COMINTEROP
 FCFuncEnd()
 
+FCFuncStart(gInteropNativeLibraryFuncs)
+    QCFuncElement("GetCharsetAndCallingConvention", NativeLibrary::GetCharsetAndCallingConvention)
+    QCFuncElement("GetProcAddress", NativeLibrary::GetProcAddress)
+    QCFuncElement("LoadLibrary", NativeLibrary::LoadLibrary)
+FCFuncEnd()
+
 FCFuncStart(gArrayWithOffsetFuncs)
     FCFuncElement("CalculateCount", MarshalNative::CalculateCount)
 FCFuncEnd()
@@ -1116,6 +1123,7 @@ FCFuncStart(gStubHelperFuncs)
     FCFuncElement("InitDeclaringType", StubHelpers::InitDeclaringType)
     FCIntrinsic("GetNDirectTarget", StubHelpers::GetNDirectTarget, CORINFO_INTRINSIC_StubHelpers_GetNDirectTarget)
     FCFuncElement("GetDelegateTarget", StubHelpers::GetDelegateTarget)
+    FCFuncElement("GetDelegateInvokeMethodFromDelegateType", StubHelpers::GetDelegateInvokeMethodFromDelegateType)
     FCFuncElement("SetLastError", StubHelpers::SetLastError)
     FCFuncElement("ClearLastError", StubHelpers::ClearLastError)
     FCFuncElement("ThrowInteropParamException", StubHelpers::ThrowInteropParamException)
@@ -1349,6 +1357,7 @@ FCClassElement("MngdSafeArrayMarshaler", "System.StubHelpers", gMngdSafeArrayMar
 FCClassElement("ModuleBuilder", "System.Reflection.Emit", gCOMModuleBuilderFuncs)
 FCClassElement("ModuleHandle", "System", gCOMModuleHandleFuncs)
 FCClassElement("Monitor", "System.Threading", gMonitorFuncs)
+FCClassElement("NativeLibrary", "System.Runtime.InteropServices", gInteropNativeLibraryFuncs)
 FCClassElement("Number", "System", gNumberFuncs)
 #ifdef FEATURE_COMINTEROP
 FCClassElement("OAVariantLib", "Microsoft.Win32", gOAVariantFuncs)
diff --git a/src/vm/marshalnative.cpp b/src/vm/marshalnative.cpp
index a552ef33f5ea..64580d0bc08f 100644
--- a/src/vm/marshalnative.cpp
+++ b/src/vm/marshalnative.cpp
@@ -54,7 +54,7 @@
 //
 // NumParamBytes
 // Counts # of parameter bytes
-INT32 QCALLTYPE MarshalNative::NumParamBytes(MethodDesc * pMD)
+INT32 QCALLTYPE MarshalNative::NumParamBytes(MethodDesc * pMD, CLR_BOOL fForStdCallDelegate)
 {
     QCALL_CONTRACT;
 
@@ -65,7 +65,7 @@ INT32 QCALLTYPE MarshalNative::NumParamBytes(MethodDesc * pMD)
 
     BEGIN_QCALL;
 
-    if (!(pMD->IsNDirect()))
+    if (!fForStdCallDelegate && !(pMD->IsNDirect()))
         COMPlusThrow(kArgumentException, IDS_EE_NOTNDIRECT);
 
     // Read the unmanaged stack size from the stub MethodDesc. For vararg P/Invoke,
@@ -83,13 +83,29 @@ INT32 QCALLTYPE MarshalNative::NumParamBytes(MethodDesc * pMD)
 
     cbParamBytes = pStubMD->AsDynamicMethodDesc()->GetNativeStackArgSize();
 
-#ifdef _X86_
-    if (((NDirectMethodDesc *)pMD)->IsThisCall())
+#ifdef _TARGET_X86_
+    if (fForStdCallDelegate)
+    {
+        // Compute the kStdCallWithRetBuf flag which is needed at link time for entry point mangling.
+        // This logic is a hybrid of the logic in NDirect::PopulateNDirectMethodDesc and NDirectMethodDesc::FindEntryPoint.
+        MetaSig msig(pMD);
+        ArgIterator argit(&msig);
+        if (argit.HasRetBuffArg())
+        {
+            MethodTable *pRetMT = msig.GetRetTypeHandleThrowing().AsMethodTable();
+            if (IsUnmanagedValueTypeReturnedByRef(pRetMT->GetNativeSize()))
+            {
+                _ASSERTE(cbParamBytes >= sizeof(LPVOID));
+                cbParamBytes -= sizeof(LPVOID);
+            }
+        }
+    }
+    else if (((NDirectMethodDesc *)pMD)->IsThisCall())
     {
         // The size of 'this' is not included in native stack arg size.
         cbParamBytes += sizeof(LPVOID);
     }
-#endif // _X86_
+#endif // _TARGET_X86_
 
     END_QCALL;
 
diff --git a/src/vm/marshalnative.h b/src/vm/marshalnative.h
index f5d4d0473393..bdae601ab28a 100644
--- a/src/vm/marshalnative.h
+++ b/src/vm/marshalnative.h
@@ -38,7 +38,7 @@ enum ComMemberType
 class MarshalNative
 {
 public:
-    static INT32 QCALLTYPE NumParamBytes(MethodDesc * pMD);
+    static INT32 QCALLTYPE NumParamBytes(MethodDesc * pMD, CLR_BOOL fForStdCallDelegate);
     static VOID QCALLTYPE Prelink(MethodDesc * pMD);
 
     //====================================================================
diff --git a/src/vm/mscorlib.cpp b/src/vm/mscorlib.cpp
index 75c1f058f003..45a908973bba 100644
--- a/src/vm/mscorlib.cpp
+++ b/src/vm/mscorlib.cpp
@@ -67,6 +67,7 @@
 #include "comdependenthandle.h"
 #include "weakreferencenative.h"
 #include "varargsnative.h"
+#include "nativelibrary.h"
 
 #ifdef MDA_SUPPORTED 
 #include "mdaassistants.h"
diff --git a/src/vm/nativelibrary.cpp b/src/vm/nativelibrary.cpp
new file mode 100644
index 000000000000..862a3dd857eb
--- /dev/null
+++ b/src/vm/nativelibrary.cpp
@@ -0,0 +1,91 @@
+// 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.
+// 
+// File: NativeLibrary.cpp
+//
+
+//
+// Unmanaged implementation of the NativeLibrary class
+//
+
+
+#include "common.h"
+#include "nativelibrary.h"
+#include "dllimport.h"
+
+//
+// GetCharsetAndCallingConvention
+// Returns the charset and calling convention of the given delegate's invoke method
+VOID QCALLTYPE NativeLibrary::GetCharsetAndCallingConvention(MethodDesc* pMdDelegate, BOOL* pfIsAnsi, BOOL* pfIsStdcall)
+{
+    QCALL_CONTRACT;
+
+    // Arguments are check on managed side
+    PRECONDITION(pMdDelegate != nullptr);
+    PRECONDITION(pfIsAnsi != nullptr);
+    PRECONDITION(pfIsStdcall != nullptr);
+
+    *pfIsAnsi = FALSE;
+    *pfIsStdcall = FALSE;
+
+    BEGIN_QCALL;
+
+    PInvokeStaticSigInfo sigInfo{ pMdDelegate };
+    *pfIsAnsi = (sigInfo.GetCharSet() == nltAnsi);
+    *pfIsStdcall = IsPmCallConvStdcall(sigInfo.GetCallConv());
+
+    END_QCALL;
+}
+
+//
+// GetProcAddress
+// Returns the address of the specified symbol from the target module, or nullptr if not found
+LPVOID QCALLTYPE NativeLibrary::GetProcAddress(HMODULE hModule, LPCSTR lpProcName)
+{
+    QCALL_CONTRACT;
+
+    // Arguments are check on managed side
+    PRECONDITION(hModule != nullptr);
+
+    LPVOID procAddress = nullptr;
+
+    BEGIN_QCALL;
+
+    procAddress = reinterpret_cast<LPVOID>(::GetProcAddress(hModule, lpProcName));
+
+    END_QCALL;
+
+    return procAddress;
+}
+
+//
+// LoadLibrary
+// Loads the specified library, returning its handles, or nullptr if library cannot be found
+HINSTANCE QCALLTYPE NativeLibrary::LoadLibrary(LPCUTF8 moduleName, QCall::AssemblyHandle callingAssembly, BOOL searchAssemblyDirectory, DWORD searchPaths)
+{
+    // Quick sanity check to make sure we've got the sizes correct on the managed side.
+    static_assert(sizeof(HINSTANCE) == sizeof(uintptr_t), "Unexpected size for HINSTANCE.");
+
+    QCALL_CONTRACT;
+
+    // Arguments are check on managed side
+    PRECONDITION(moduleName != nullptr);
+
+    HINSTANCE hmod = nullptr;
+
+    BEGIN_QCALL;
+
+    Assembly* pAssembly = nullptr;
+
+    if (static_cast<DomainAssembly*>(callingAssembly) != nullptr)
+    {
+        pAssembly = callingAssembly->GetAssembly();
+    }
+
+    hmod = NDirect::LoadLibraryModuleForNativeLibrary(moduleName, pAssembly, searchAssemblyDirectory, searchPaths);
+
+    END_QCALL;
+
+    return hmod;
+}
diff --git a/src/vm/nativelibrary.h b/src/vm/nativelibrary.h
new file mode 100644
index 000000000000..1ecf848102a6
--- /dev/null
+++ b/src/vm/nativelibrary.h
@@ -0,0 +1,26 @@
+// 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.
+// 
+// File: NativeLibrary.h
+//
+
+//
+// Unmanaged implementation of the NativeLibrary class
+//
+
+
+#ifndef __NATIVELIBRARY_H__
+#define __NATIVELIBRARY_H__
+
+#include "qcall.h"
+
+class NativeLibrary
+{
+public:
+    static VOID QCALLTYPE GetCharsetAndCallingConvention(MethodDesc* pMdDelegate, BOOL* pfIsAnsi, BOOL* pfIsStdcall);
+    static LPVOID QCALLTYPE GetProcAddress(HMODULE hModule, LPCSTR lpProcName);
+    static HINSTANCE QCALLTYPE LoadLibrary(LPCUTF8 moduleName, QCall::AssemblyHandle callingAssembly, BOOL searchAssemblyDirectory, DWORD searchPaths);
+};
+
+#endif
diff --git a/src/vm/stubhelpers.cpp b/src/vm/stubhelpers.cpp
index ead312d04205..92f9c9f1ecb4 100644
--- a/src/vm/stubhelpers.cpp
+++ b/src/vm/stubhelpers.cpp
@@ -1191,6 +1191,30 @@ FCIMPL2(void*, StubHelpers::GetDelegateTarget, DelegateObject *pThisUNSAFE, UINT
 FCIMPLEND
 
 
+FCIMPL1(MethodDesc*, StubHelpers::GetDelegateInvokeMethodFromDelegateType, ReflectClassBaseObject* refTypeUNSAFE)
+{
+    FCALL_CONTRACT;
+
+    MethodDesc *pMD = NULL;
+
+    REFLECTCLASSBASEREF refType = (REFLECTCLASSBASEREF) refTypeUNSAFE;
+    HELPER_METHOD_FRAME_BEGIN_RET_1(refType);
+
+    MethodTable* pMT = refType->GetType().GetMethodTable();
+    pMD = COMDelegate::FindDelegateInvokeMethod(pMT);
+    if (pMD->IsSharedByGenericInstantiations())
+    {
+        // we need the exact MethodDesc
+        pMD = InstantiatedMethodDesc::FindOrCreateExactClassMethod(pMT, pMD);
+    }
+
+    HELPER_METHOD_FRAME_END();
+
+    _ASSERTE(pMD);
+    return pMD;
+}
+FCIMPLEND
+
 
 FCIMPL2(void, StubHelpers::ThrowInteropParamException, UINT resID, UINT paramIdx)
 {
diff --git a/src/vm/stubhelpers.h b/src/vm/stubhelpers.h
index 70fb529cff49..d83a47c0c7b9 100644
--- a/src/vm/stubhelpers.h
+++ b/src/vm/stubhelpers.h
@@ -94,6 +94,7 @@ class StubHelpers
     static FCDECL1(void,            InitDeclaringType,      NDirectMethodDesc* pMND);
     static FCDECL1(void*,           GetNDirectTarget,       NDirectMethodDesc* pNMD);
     static FCDECL2(void*,           GetDelegateTarget,      DelegateObject *pThisUNSAFE, UINT_PTR *ppStubArg);
+    static FCDECL1(MethodDesc *,    GetDelegateInvokeMethodFromDelegateType, ReflectClassBaseObject *refTypeUNSAFE);
 
 
     static FCDECL2(void,            ThrowInteropParamException, UINT resID, UINT paramIdx);