private PInvokeILEmitter(MethodDesc targetMethod, PInvokeILEmitterConfiguration pinvokeILEmitterConfiguration)
{
Debug.Assert(targetMethod.IsPInvoke || targetMethod is DelegateMarshallingMethodThunk);
_methodData = new PInvokeMethodData(targetMethod, pinvokeILEmitterConfiguration);
_marshallers = InitializeMarshallers(_methodData);
}
public PInvokeMethodData(MethodDesc method, PInvokeILEmitterConfiguration config)
{
TargetMethod = method;
PInvokeILEmitterConfiguration = config;
Context = method.Context;
ImportMetadata = method.GetPInvokeMethodMetadata();
}
private PInvokeILEmitter(MethodDesc targetMethod, PInvokeILEmitterConfiguration pinvokeILEmitterConfiguration, InteropStateManager interopStateManager)
{
Debug.Assert(targetMethod.IsPInvoke || targetMethod is DelegateMarshallingMethodThunk);
_targetMethod = targetMethod;
_pInvokeILEmitterConfiguration = pinvokeILEmitterConfiguration;
_importMetadata = targetMethod.GetPInvokeMethodMetadata();
_interopStateManager = interopStateManager;
PInvokeFlags flags = new PInvokeFlags();
if (targetMethod.IsPInvoke)
{
flags = _importMetadata.Flags;
}
else
{
var delegateType = ((DelegateMarshallingMethodThunk)_targetMethod).DelegateType as EcmaType;
if (delegateType != null)
{
flags = delegateType.GetDelegatePInvokeFlags();
}
}
_marshallers = InitializeMarshallers(targetMethod, interopStateManager, flags);
}
public static MethodIL EmitIL(MethodDesc method, PInvokeILEmitterConfiguration pinvokeILEmitterConfiguration)
{
try
{
return(new PInvokeILEmitter(method, pinvokeILEmitterConfiguration).EmitIL());
}
catch (NotSupportedException)
{
ILEmitter emitter = new ILEmitter();
string message = "Method '" + method.ToString() +
"' requires non-trivial marshalling that is not yet supported by this compiler.";
TypeSystemContext context = method.Context;
MethodSignature ctorSignature = new MethodSignature(0, 0, context.GetWellKnownType(WellKnownType.Void),
new TypeDesc[] { context.GetWellKnownType(WellKnownType.String) });
MethodDesc exceptionCtor = method.Context.GetWellKnownType(WellKnownType.Exception).GetKnownMethod(".ctor", ctorSignature);
ILCodeStream codeStream = emitter.NewCodeStream();
codeStream.Emit(ILOpcode.ldstr, emitter.NewToken(message));
codeStream.Emit(ILOpcode.newobj, emitter.NewToken(exceptionCtor));
codeStream.Emit(ILOpcode.throw_);
codeStream.Emit(ILOpcode.ret);
return(emitter.Link(method));
}
}
private PInvokeILEmitter(MethodDesc targetMethod, PInvokeILEmitterConfiguration pinvokeILEmitterConfiguration)
{
Debug.Assert(targetMethod.IsPInvoke);
_methodData = new PInvokeMethodData(targetMethod, pinvokeILEmitterConfiguration, MarshalDirection.Forward);
_marshallers = InitializeMarshallers(_methodData);
}
/// <summary>
/// Returns true if the PInvoke target should be resolved lazily.
/// </summary>
public static bool UseLazyResolution(MethodDesc method, string importModule, PInvokeILEmitterConfiguration configuration)
{
bool?forceLazyResolution = configuration.ForceLazyResolution;
if (forceLazyResolution.HasValue)
{
return(forceLazyResolution.Value);
}
// Determine whether this call should be made through a lazy resolution or a static reference
// Eventually, this should be controlled by a custom attribute (or an extension to the metadata format).
if (importModule == "[MRT]" || importModule == "*")
{
return(false);
}
if (method.Context.Target.IsWindows)
{
return(!importModule.StartsWith("api-ms-win-"));
}
else
{
// Account for System.Private.CoreLib.Native / System.Globalization.Native / System.Native / etc
return(!importModule.StartsWith("System."));
}
}
/// <summary>
/// Returns true if <paramref name="method"/> requires a stub to be generated.
/// </summary>
public static bool IsStubRequired(MethodDesc method, PInvokeILEmitterConfiguration configuration)
{
Debug.Assert(method.IsPInvoke);
// TODO: true if there are any custom marshalling rules on the parameters
TypeDesc returnType = method.Signature.ReturnType;
if (!MarshalHelpers.IsBlittableType(returnType) && !returnType.IsVoid)
{
return(true);
}
for (int i = 0; i < method.Signature.Length; i++)
{
if (!MarshalHelpers.IsBlittableType(method.Signature[i]))
{
return(true);
}
}
PInvokeMetadata methodData = method.GetPInvokeMethodMetadata();
if (UseLazyResolution(method, methodData.Module, configuration))
{
return(true);
}
if ((methodData.Attributes & PInvokeAttributes.SetLastError) == PInvokeAttributes.SetLastError)
{
return(true);
}
return(false);
}
private PInvokeILEmitter(MethodDesc targetMethod, PInvokeILEmitterConfiguration pinvokeILEmitterConfiguration, InteropStateManager interopStateManager)
{
Debug.Assert(targetMethod.IsPInvoke || targetMethod is DelegateMarshallingMethodThunk);
_targetMethod = targetMethod;
_pInvokeILEmitterConfiguration = pinvokeILEmitterConfiguration;
_importMetadata = targetMethod.GetPInvokeMethodMetadata();
_interopStateManager = interopStateManager;
//
// targetMethod could be either a PInvoke or a DelegateMarshallingMethodThunk
// ForwardNativeFunctionWrapper method thunks are marked as PInvokes, so it is
// important to check them first here so that we get the right flags.
//
DelegateMarshallingMethodThunk delegateThunk = _targetMethod as DelegateMarshallingMethodThunk;
if (delegateThunk != null)
{
_flags = ((EcmaType)delegateThunk.DelegateType).GetDelegatePInvokeFlags();
}
else
{
Debug.Assert(_targetMethod.IsPInvoke);
_flags = _importMetadata.Flags;
}
_marshallers = InitializeMarshallers(targetMethod, interopStateManager, _flags);
}
public PInvokeMethodData(MethodDesc method, PInvokeILEmitterConfiguration config, MarshalDirection direction)
{
TargetMethod = method;
PInvokeILEmitterConfiguration = config;
Context = method.Context;
ImportMetadata = method.GetPInvokeMethodMetadata();
Direction = direction;
}
internal ILScannerBuilder(CompilerTypeSystemContext context, CompilationModuleGroup compilationGroup, NameMangler mangler, ILProvider ilProvider, PInvokeILEmitterConfiguration pinvokePolicy)
{
_context = context;
_compilationGroup = compilationGroup;
_nameMangler = mangler;
_metadataManager = new EmptyMetadataManager(context);
_ilProvider = ilProvider;
_pinvokePolicy = pinvokePolicy;
}
internal ILScanner(
DependencyAnalyzerBase <NodeFactory> dependencyGraph,
ILScanNodeFactory nodeFactory,
IEnumerable <ICompilationRootProvider> roots,
ILProvider ilProvider,
DebugInformationProvider debugInformationProvider,
PInvokeILEmitterConfiguration pinvokePolicy,
Logger logger)
: base(dependencyGraph, nodeFactory, roots, ilProvider, debugInformationProvider, null, pinvokePolicy, logger)
{
}
internal CppCodegenCompilation(
DependencyAnalyzerBase <NodeFactory> dependencyGraph,
NodeFactory nodeFactory,
IEnumerable <ICompilationRootProvider> roots,
ILProvider ilProvider,
DebugInformationProvider debugInformationProvider,
PInvokeILEmitterConfiguration pinvokePolicy,
Logger logger,
CppCodegenConfigProvider options)
: base(dependencyGraph, nodeFactory, GetCompilationRoots(roots, nodeFactory), ilProvider, debugInformationProvider, null, pinvokePolicy, logger)
{
Options = options;
}
internal RyuJitCompilation(
DependencyAnalyzerBase <NodeFactory> dependencyGraph,
NodeFactory nodeFactory,
IEnumerable <ICompilationRootProvider> roots,
ILProvider ilProvider,
DebugInformationProvider debugInformationProvider,
PInvokeILEmitterConfiguration pinvokePolicy,
Logger logger,
DevirtualizationManager devirtualizationManager,
JitConfigProvider configProvider)
: base(dependencyGraph, nodeFactory, roots, ilProvider, debugInformationProvider, devirtualizationManager, pinvokePolicy, logger)
{
_jitConfigProvider = configProvider;
}
private PInvokeILEmitter(MethodDesc targetMethod, PInvokeILEmitterConfiguration pinvokeIlEmitterConfiguration)
{
Debug.Assert(targetMethod.IsPInvoke);
_targetMethod = targetMethod;
_pinvokeILEmitterConfiguration = pinvokeIlEmitterConfiguration;
_context = _targetMethod.Context;
_importMetadata = targetMethod.GetPInvokeMethodMetadata();
_emitter = null;
_marshallingCodeStream = null;
_returnValueMarshallingCodeStream = null;
_unmarshallingCodestream = null;
}
internal RyuJitCompilation(
DependencyAnalyzerBase <NodeFactory> dependencyGraph,
NodeFactory nodeFactory,
IEnumerable <ICompilationRootProvider> roots,
ILProvider ilProvider,
DebugInformationProvider debugInformationProvider,
PInvokeILEmitterConfiguration pinvokePolicy,
Logger logger,
DevirtualizationManager devirtualizationManager,
JitConfigProvider configProvider,
RyuJitCompilationOptions options)
: base(dependencyGraph, nodeFactory, roots, ilProvider, debugInformationProvider, devirtualizationManager, pinvokePolicy, logger)
{
_jitConfigProvider = configProvider;
_compilationOptions = options;
_hardwareIntrinsicFlags = new ExternSymbolMappedField(nodeFactory.TypeSystemContext.GetWellKnownType(WellKnownType.Int32), "g_cpuFeatures");
}
public static MethodIL EmitIL(MethodDesc method, PInvokeILEmitterConfiguration pinvokeILEmitterConfiguration)
{
try
{
return(new PInvokeILEmitter(method, pinvokeILEmitterConfiguration).EmitIL());
}
catch (NotSupportedException)
{
string message = "Method '" + method.ToString() +
"' requires non-trivial marshalling that is not yet supported by this compiler.";
return(EmitExceptionBody(message, method));
}
catch (InvalidProgramException ex)
{
Debug.Assert(!String.IsNullOrEmpty(ex.Message));
return(EmitExceptionBody(ex.Message, method));
}
}
internal WebAssemblyCodegenCompilation(
DependencyAnalyzerBase <NodeFactory> dependencyGraph,
WebAssemblyCodegenNodeFactory nodeFactory,
IEnumerable <ICompilationRootProvider> roots,
ILProvider ilProvider,
DebugInformationProvider debugInformationProvider,
PInvokeILEmitterConfiguration pinvokePolicy,
Logger logger,
WebAssemblyCodegenConfigProvider options)
: base(dependencyGraph, nodeFactory, GetCompilationRoots(roots, nodeFactory), ilProvider, debugInformationProvider, null, pinvokePolicy, logger)
{
NodeFactory = nodeFactory;
Module = LLVM.ModuleCreateWithName("netscripten");
LLVM.SetTarget(Module, "asmjs-unknown-emscripten");
Options = options;
DIBuilder = LLVMPInvokes.LLVMCreateDIBuilder(Module);
DebugMetadataMap = new Dictionary <string, DebugMetadata>();
}
internal ReadyToRunCodegenCompilation(
DependencyAnalyzerBase <NodeFactory> dependencyGraph,
ReadyToRunCodegenNodeFactory nodeFactory,
IEnumerable <ICompilationRootProvider> roots,
ILProvider ilProvider,
DebugInformationProvider debugInformationProvider,
PInvokeILEmitterConfiguration pInvokePolicy,
Logger logger,
DevirtualizationManager devirtualizationManager,
JitConfigProvider configProvider,
string inputFilePath)
: base(dependencyGraph, nodeFactory, roots, ilProvider, debugInformationProvider, devirtualizationManager, pInvokePolicy, logger)
{
NodeFactory = nodeFactory;
SymbolNodeFactory = new ReadyToRunSymbolNodeFactory(nodeFactory);
_jitConfigProvider = configProvider;
_inputFilePath = inputFilePath;
_corInfo = new CorInfoImpl(this, _jitConfigProvider);
}
protected Compilation(
DependencyAnalyzerBase <NodeFactory> dependencyGraph,
NodeFactory nodeFactory,
IEnumerable <ICompilationRootProvider> compilationRoots,
ILProvider ilProvider,
DebugInformationProvider debugInformationProvider,
DevirtualizationManager devirtualizationManager,
PInvokeILEmitterConfiguration pInvokeConfiguration,
Logger logger)
{
_dependencyGraph = dependencyGraph;
_nodeFactory = nodeFactory;
_logger = logger;
_debugInformationProvider = debugInformationProvider;
_devirtualizationManager = devirtualizationManager;
_dependencyGraph.ComputeDependencyRoutine += ComputeDependencyNodeDependencies;
NodeFactory.AttachToDependencyGraph(_dependencyGraph);
var rootingService = new RootingServiceProvider(dependencyGraph, nodeFactory);
foreach (var rootProvider in compilationRoots)
{
rootProvider.AddCompilationRoots(rootingService);
}
MetadataType globalModuleGeneratedType = nodeFactory.TypeSystemContext.GeneratedAssembly.GetGlobalModuleType();
_typeGetTypeMethodThunks = new TypeGetTypeMethodThunkCache(globalModuleGeneratedType);
_assemblyGetExecutingAssemblyMethodThunks = new AssemblyGetExecutingAssemblyMethodThunkCache(globalModuleGeneratedType);
_methodBaseGetCurrentMethodThunks = new MethodBaseGetCurrentMethodThunkCache();
if (!(nodeFactory.InteropStubManager is EmptyInteropStubManager))
{
PInvokeILProvider = new PInvokeILProvider(pInvokeConfiguration, nodeFactory.InteropStubManager.InteropStateManager);
ilProvider = new CombinedILProvider(ilProvider, PInvokeILProvider);
}
_methodILCache = new ILCache(ilProvider);
}
/// <summary>
/// Returns true if the PInvoke target should be resolved lazily.
/// </summary>
public static bool UseLazyResolution(MethodDesc method, string importModule, PInvokeILEmitterConfiguration configuration)
{
bool?forceLazyResolution = configuration.ForceLazyResolution;
if (forceLazyResolution.HasValue)
{
return(forceLazyResolution.Value);
}
// In multi-module library mode, the WinRT p/invokes in System.Private.Interop cause linker failures
// since we don't link against the OS libraries containing those APIs. Force them to be lazy.
// See https://github.com/dotnet/corert/issues/2601
string assemblySimpleName = ((IAssemblyDesc)((MetadataType)method.OwningType).Module).GetName().Name;
if (assemblySimpleName == "System.Private.Interop")
{
return(true);
}
// Determine whether this call should be made through a lazy resolution or a static reference
// Eventually, this should be controlled by a custom attribute (or an extension to the metadata format).
if (importModule == "[MRT]" || importModule == "*")
{
return(false);
}
if (method.Context.Target.IsWindows)
{
return(!importModule.StartsWith("api-ms-win-"));
}
else
{
// Account for System.Private.CoreLib.Native / System.Globalization.Native / System.Native / etc
return(!importModule.StartsWith("System."));
}
}
private MethodIL EmitIL()
{
PInvokeILCodeStreams pInvokeILCodeStreams = new PInvokeILCodeStreams();
ILEmitter emitter = pInvokeILCodeStreams.Emitter;
ILCodeStream fnptrLoadStream = pInvokeILCodeStreams.FunctionPointerLoadStream;
ILCodeStream callsiteSetupCodeStream = pInvokeILCodeStreams.CallsiteSetupCodeStream;
ILCodeStream unmarshallingCodestream = pInvokeILCodeStreams.UnmarshallingCodestream;
// Marshal the arguments
for (int i = 0; i < _marshallers.Length; i++)
{
_marshallers[i].EmitMarshallingIL(pInvokeILCodeStreams);
}
// make the call
TypeDesc nativeReturnType = _marshallers[0].NativeParameterType;
TypeDesc[] nativeParameterTypes = new TypeDesc[_marshallers.Length - 1];
for (int i = 1; i < _marshallers.Length; i++)
{
nativeParameterTypes[i - 1] = _marshallers[i].NativeParameterType;
}
MethodDesc targetMethod = _methodData.TargetMethod;
PInvokeMetadata importMetadata = _methodData.ImportMetadata;
PInvokeILEmitterConfiguration pinvokeILEmitterConfiguration = _methodData.PInvokeILEmitterConfiguration;
MethodSignature nativeSig;
// if the SetLastError flag is set in DllImport, clear the error code before doing P/Invoke
if ((importMetadata.Attributes & PInvokeAttributes.SetLastError) == PInvokeAttributes.SetLastError)
{
callsiteSetupCodeStream.Emit(ILOpcode.call, emitter.NewToken(
_methodData.PInvokeMarshal.GetKnownMethod("ClearLastWin32Error", null)));
}
if (targetMethod is DelegateMarshallingMethodThunk)
{
nativeSig = new MethodSignature(MethodSignatureFlags.Static, 0, nativeReturnType, nativeParameterTypes);
TypeDesc[] parameters = new TypeDesc[_marshallers.Length - 1];
for (int i = 1; i < _marshallers.Length; i++)
{
parameters[i - 1] = _marshallers[i].ManagedParameterType;
}
MethodSignature managedSignature = new MethodSignature(MethodSignatureFlags.Static, 0, _marshallers[0].ManagedParameterType, parameters);
fnptrLoadStream.Emit(ILOpcode.call, emitter.NewToken(targetMethod.Context.GetHelperType("InteropHelpers").GetKnownMethod("GetDelegateFunctionPointer", null)));
ILLocalVariable vDelegateStub = emitter.NewLocal(targetMethod.Context.GetWellKnownType(WellKnownType.IntPtr));
fnptrLoadStream.EmitStLoc(vDelegateStub);
callsiteSetupCodeStream.EmitLdLoc(vDelegateStub);
callsiteSetupCodeStream.Emit(ILOpcode.calli, emitter.NewToken(managedSignature));
}
else if (MarshalHelpers.UseLazyResolution(targetMethod, importMetadata.Module, pinvokeILEmitterConfiguration))
{
MetadataType lazyHelperType = targetMethod.Context.GetHelperType("InteropHelpers");
FieldDesc lazyDispatchCell = new PInvokeLazyFixupField((DefType)targetMethod.OwningType, importMetadata);
fnptrLoadStream.Emit(ILOpcode.ldsflda, emitter.NewToken(lazyDispatchCell));
fnptrLoadStream.Emit(ILOpcode.call, emitter.NewToken(lazyHelperType.GetKnownMethod("ResolvePInvoke", null)));
MethodSignatureFlags unmanagedCallConv = PInvokeMetadata.GetUnmanagedCallingConvention(importMetadata.Attributes);
nativeSig = new MethodSignature(
targetMethod.Signature.Flags | unmanagedCallConv, 0, nativeReturnType, nativeParameterTypes);
ILLocalVariable vNativeFunctionPointer = emitter.NewLocal(targetMethod.Context.GetWellKnownType(WellKnownType.IntPtr));
fnptrLoadStream.EmitStLoc(vNativeFunctionPointer);
callsiteSetupCodeStream.EmitLdLoc(vNativeFunctionPointer);
callsiteSetupCodeStream.Emit(ILOpcode.calli, emitter.NewToken(nativeSig));
}
else
{
// Eager call
PInvokeMetadata nativeImportMetadata =
new PInvokeMetadata(importMetadata.Module, importMetadata.Name ?? targetMethod.Name, importMetadata.Attributes);
nativeSig = new MethodSignature(
targetMethod.Signature.Flags, 0, nativeReturnType, nativeParameterTypes);
MethodDesc nativeMethod =
new PInvokeTargetNativeMethod(targetMethod.OwningType, nativeSig, nativeImportMetadata, pinvokeILEmitterConfiguration.GetNextNativeMethodId());
callsiteSetupCodeStream.Emit(ILOpcode.call, emitter.NewToken(nativeMethod));
}
// if the SetLastError flag is set in DllImport, call the PInvokeMarshal.SaveLastWin32Error so that last error can be used later
// by calling PInvokeMarshal.GetLastWin32Error
if ((importMetadata.Attributes & PInvokeAttributes.SetLastError) == PInvokeAttributes.SetLastError)
{
callsiteSetupCodeStream.Emit(ILOpcode.call, emitter.NewToken(
_methodData.PInvokeMarshal.GetKnownMethod("SaveLastWin32Error", null)));
}
unmarshallingCodestream.Emit(ILOpcode.ret);
return(new PInvokeILStubMethodIL((ILStubMethodIL)emitter.Link(targetMethod), IsStubRequired(), nativeSig));
}
/// <summary>
/// Returns true if the PInvoke target should be resolved lazily.
/// </summary>
private static bool UseLazyResolution(MethodDesc method, string importModule, PInvokeILEmitterConfiguration configuration)
{
// TODO: Test and make this work on non-Windows
if (!method.Context.Target.IsWindows)
{
return(false);
}
if (configuration.ForceLazyResolution)
{
return(true);
}
// Determine whether this call should be made through a lazy resolution or a static reference
// Eventually, this should be controlled by a custom attribute (or an extension to the metadata format).
if (importModule == "[MRT]" || importModule == "*")
{
return(false);
}
if (method.Context.Target.IsWindows)
{
return(!importModule.StartsWith("api-ms-win-"));
}
else
{
return(!importModule.StartsWith("System.Private."));
}
}
public CompilationBuilder UsePInvokePolicy(PInvokeILEmitterConfiguration policy)
{
_pinvokePolicy = policy;
return(this);
}
public AnalysisBasedInteropStubManager(InteropStateManager interopStateManager, PInvokeILEmitterConfiguration pInvokeILEmitterConfiguration, IEnumerable <DefType> typesWithStructMarshalling, IEnumerable <DefType> typesWithDelegateMarshalling)
: base(interopStateManager, pInvokeILEmitterConfiguration)
{
_typesWithStructMarshalling = typesWithStructMarshalling;
_typesWithDelegateMarshalling = typesWithDelegateMarshalling;
}
public AnalysisBasedInteropStubManager GetInteropStubManager(InteropStateManager stateManager, PInvokeILEmitterConfiguration pinvokePolicy)
{
return(new AnalysisBasedInteropStubManager(stateManager, pinvokePolicy,
_factory.MetadataManager.GetTypesWithStructMarshalling(),
_factory.MetadataManager.GetTypesWithDelegateMarshalling()));
}
private MethodIL EmitIL()
{
// We have 4 code streams:
// - _marshallingCodeStream is used to convert each argument into a native type and
// store that into the local
// - callsiteSetupCodeStream is used to used to load each previously generated local
// and call the actual target native method.
// - _returnValueMarshallingCodeStream is used to convert the native return value
// to managed one.
// - _unmarshallingCodestream is used to propagate [out] native arguments values to
// managed ones.
ILEmitter emitter = new ILEmitter();
ILCodeStream fnptrLoadStream = emitter.NewCodeStream();
ILCodeStream marshallingCodeStream = emitter.NewCodeStream();
ILCodeStream callsiteSetupCodeStream = emitter.NewCodeStream();
ILCodeStream returnValueMarshallingCodeStream = emitter.NewCodeStream();
ILCodeStream unmarshallingCodestream = emitter.NewCodeStream();
// Marshal the arguments
for (int i = 0; i < _marshallers.Length; i++)
{
Marshaller marshaller = _marshallers[i];
marshaller.EmitMarshallingIL(emitter, marshallingCodeStream, callsiteSetupCodeStream, unmarshallingCodestream, returnValueMarshallingCodeStream);
}
// make the call
TypeDesc nativeReturnType = _marshallers[0].NativeType;
TypeDesc[] nativeParameterTypes = new TypeDesc[_marshallers.Length - 1];
for (int i = 1; i < _marshallers.Length; i++)
{
nativeParameterTypes[i - 1] = _marshallers[i].NativeType;
}
MethodDesc targetMethod = _methodData.TargetMethod;
PInvokeMetadata importMetadata = _methodData.ImportMetadata;
PInvokeILEmitterConfiguration pinvokeILEmitterConfiguration = _methodData.PInvokeILEmitterConfiguration;
// if the SetLastError flag is set in DllImport, clear the error code before doing P/Invoke
if ((importMetadata.Attributes & PInvokeAttributes.SetLastError) == PInvokeAttributes.SetLastError)
{
callsiteSetupCodeStream.Emit(ILOpcode.call, emitter.NewToken(
_methodData.PInvokeMarshal.GetKnownMethod("ClearLastWin32Error", null)));
}
if (MarshalHelpers.UseLazyResolution(targetMethod, importMetadata.Module, pinvokeILEmitterConfiguration))
{
MetadataType lazyHelperType = targetMethod.Context.GetHelperType("InteropHelpers");
FieldDesc lazyDispatchCell = new PInvokeLazyFixupField((DefType)targetMethod.OwningType, importMetadata);
fnptrLoadStream.Emit(ILOpcode.ldsflda, emitter.NewToken(lazyDispatchCell));
fnptrLoadStream.Emit(ILOpcode.call, emitter.NewToken(lazyHelperType.GetKnownMethod("ResolvePInvoke", null)));
MethodSignatureFlags unmanagedCallConv = PInvokeMetadata.GetUnmanagedCallingConvention(importMetadata.Attributes);
MethodSignature nativeCalliSig = new MethodSignature(
targetMethod.Signature.Flags | unmanagedCallConv, 0, nativeReturnType, nativeParameterTypes);
ILLocalVariable vNativeFunctionPointer = emitter.NewLocal(targetMethod.Context.GetWellKnownType(WellKnownType.IntPtr));
fnptrLoadStream.EmitStLoc(vNativeFunctionPointer);
callsiteSetupCodeStream.EmitLdLoc(vNativeFunctionPointer);
callsiteSetupCodeStream.Emit(ILOpcode.calli, emitter.NewToken(nativeCalliSig));
}
else
{
// Eager call
PInvokeMetadata nativeImportMetadata =
new PInvokeMetadata(importMetadata.Module, importMetadata.Name ?? targetMethod.Name, importMetadata.Attributes);
MethodSignature nativeSig = new MethodSignature(
targetMethod.Signature.Flags, 0, nativeReturnType, nativeParameterTypes);
MethodDesc nativeMethod =
new PInvokeTargetNativeMethod(targetMethod.OwningType, nativeSig, nativeImportMetadata, pinvokeILEmitterConfiguration.GetNextNativeMethodId());
callsiteSetupCodeStream.Emit(ILOpcode.call, emitter.NewToken(nativeMethod));
}
// if the SetLastError flag is set in DllImport, call the PInvokeMarshal.SaveLastWin32Error so that last error can be used later
// by calling PInvokeMarshal.GetLastWin32Error
if ((importMetadata.Attributes & PInvokeAttributes.SetLastError) == PInvokeAttributes.SetLastError)
{
callsiteSetupCodeStream.Emit(ILOpcode.call, emitter.NewToken(
_methodData.PInvokeMarshal.GetKnownMethod("SaveLastWin32Error", null)));
}
unmarshallingCodestream.Emit(ILOpcode.ret);
return(emitter.Link(targetMethod));
}
public CompilerGeneratedInteropStubManager(InteropStateManager interopStateManager, PInvokeILEmitterConfiguration pInvokeILEmitterConfiguration)
{
_interopStateManager = interopStateManager;
_pInvokeILEmitterConfiguration = pInvokeILEmitterConfiguration;
}
public UsageBasedInteropStubManager(InteropStateManager interopStateManager, PInvokeILEmitterConfiguration pInvokeILEmitterConfiguration)
: base(interopStateManager, pInvokeILEmitterConfiguration)
{
}
