protected override void EmitElementCount(ILCodeStream codeStream, MarshalDirection direction)
{
ILEmitter emitter = _ilCodeStreams.Emitter;
if (MarshalAsDescriptor == null || !MarshalAsDescriptor.SizeConst.HasValue)
{
throw new InvalidProgramException("SizeConst is required for ByValArray.");
}
if (direction == MarshalDirection.Forward)
{
// In forward direction ElementCount = Min(managed.length, SizeConst);
var vLength = emitter.NewLocal(Context.GetWellKnownType(WellKnownType.Int32));
var lSmaller = emitter.NewCodeLabel();
var lDone = emitter.NewCodeLabel();
codeStream.EmitLdArg(0);
codeStream.Emit(ILOpcode.ldfld, emitter.NewToken(_managedField));
var lNullCheck = emitter.NewCodeLabel();
codeStream.Emit(ILOpcode.brfalse, lNullCheck);
codeStream.EmitLdArg(0);
codeStream.Emit(ILOpcode.ldfld, emitter.NewToken(_managedField));
codeStream.Emit(ILOpcode.ldlen);
codeStream.Emit(ILOpcode.conv_i4);
codeStream.EmitStLoc(vLength);
codeStream.EmitLabel(lNullCheck);
Debug.Assert(MarshalAsDescriptor.SizeConst.HasValue);
int sizeConst = (int)MarshalAsDescriptor.SizeConst.Value;
codeStream.EmitLdc(sizeConst);
codeStream.EmitLdLoc(vLength);
codeStream.Emit(ILOpcode.blt, lSmaller);
codeStream.EmitLdLoc(vLength);
codeStream.Emit(ILOpcode.br, lDone);
codeStream.EmitLabel(lSmaller);
codeStream.EmitLdc(sizeConst);
codeStream.EmitLabel(lDone);
}
else
{
// In reverse direction ElementCount = SizeConst;
Debug.Assert(MarshalAsDescriptor.SizeConst.HasValue);
int sizeConst = (int)MarshalAsDescriptor.SizeConst.Value;
codeStream.EmitLdc(sizeConst);
}
}
protected override void EmitMarshalArgumentManagedToNative()
{
ILEmitter emitter = _ilCodeStreams.Emitter;
ILCodeStream marshallingCodeStream = _ilCodeStreams.MarshallingCodeStream;
TypeSystemContext context = PInvokeMethodData.Context;
//
// Unicode marshalling. Pin the string and push a pointer to the first character on the stack.
//
TypeDesc stringType = context.GetWellKnownType(WellKnownType.String);
IL.Stubs.ILLocalVariable vPinnedString = emitter.NewLocal(stringType, true);
ILCodeLabel lNullString = emitter.NewCodeLabel();
marshallingCodeStream.EmitStLoc(vPinnedString);
marshallingCodeStream.EmitLdLoc(vPinnedString);
marshallingCodeStream.Emit(ILOpcode.conv_i);
marshallingCodeStream.Emit(ILOpcode.dup);
// Marshalling a null string?
marshallingCodeStream.Emit(ILOpcode.brfalse, lNullString);
marshallingCodeStream.Emit(ILOpcode.call, emitter.NewToken(
context.SystemModule.
GetKnownType("System.Runtime.CompilerServices", "RuntimeHelpers").
GetKnownMethod("get_OffsetToStringData", null)));
marshallingCodeStream.Emit(ILOpcode.add);
marshallingCodeStream.EmitLabel(lNullString);
NativeParameterType = context.GetWellKnownType(WellKnownType.IntPtr);
}
protected override void EmitMarshalArgumentManagedToNative()
{
ILCodeStream marshallingCodeStream = _ilCodeStreams.MarshallingCodeStream;
ILEmitter emitter = _ilCodeStreams.Emitter;
var arrayType = (ArrayType)ManagedParameterType;
Debug.Assert(arrayType.IsSzArray);
IL.Stubs.ILLocalVariable vPinnedFirstElement = emitter.NewLocal(arrayType.ParameterType.MakeByRefType(), true);
IL.Stubs.ILLocalVariable vArray = emitter.NewLocal(arrayType);
ILCodeLabel lNullArray = emitter.NewCodeLabel();
// Check for null array, or 0 element array.
marshallingCodeStream.Emit(ILOpcode.dup);
marshallingCodeStream.EmitStLoc(vArray);
marshallingCodeStream.Emit(ILOpcode.brfalse, lNullArray);
marshallingCodeStream.EmitLdLoc(vArray);
marshallingCodeStream.Emit(ILOpcode.ldlen);
marshallingCodeStream.Emit(ILOpcode.conv_i4);
marshallingCodeStream.Emit(ILOpcode.brfalse, lNullArray);
// Array has elements.
marshallingCodeStream.EmitLdLoc(vArray);
marshallingCodeStream.EmitLdc(0);
marshallingCodeStream.Emit(ILOpcode.ldelema, emitter.NewToken(arrayType.ElementType));
marshallingCodeStream.EmitStLoc(vPinnedFirstElement);
// Fall through. If array didn't have elements, vPinnedFirstElement is zeroinit.
marshallingCodeStream.EmitLabel(lNullArray);
marshallingCodeStream.EmitLdLoc(vPinnedFirstElement);
marshallingCodeStream.Emit(ILOpcode.conv_i);
NativeParameterType = PInvokeMethodData.Context.GetWellKnownType(WellKnownType.IntPtr);
}
protected override void AllocNativeToManaged(ILCodeStream codeStream)
{
var emitter = _ilCodeStreams.Emitter;
var lNull = emitter.NewCodeLabel();
// Check for null
LoadNativeValue(codeStream);
codeStream.Emit(ILOpcode.brfalse, lNull);
codeStream.Emit(ILOpcode.newobj, emitter.NewToken(
ManagedType.GetParameterlessConstructor()));
StoreManagedValue(codeStream);
codeStream.EmitLabel(lNull);
}
protected override TypeDesc MarshalArgument(TypeDesc managedType, ILEmitter emitter, ILCodeStream marshallingCodeStream, ILCodeStream unmarshallingCodeStream)
{
TypeSystemContext context = PInvokeMethodData.Context;
if (PInvokeMethodData.GetCharSet() == PInvokeAttributes.CharSetUnicode)
{
//
// Unicode marshalling. Pin the string and push a pointer to the first character on the stack.
//
TypeDesc stringType = context.GetWellKnownType(WellKnownType.String);
IL.Stubs.ILLocalVariable vPinnedString = emitter.NewLocal(stringType, true);
ILCodeLabel lNullString = emitter.NewCodeLabel();
marshallingCodeStream.EmitStLoc(vPinnedString);
marshallingCodeStream.EmitLdLoc(vPinnedString);
marshallingCodeStream.Emit(ILOpcode.conv_i);
marshallingCodeStream.Emit(ILOpcode.dup);
// Marshalling a null string?
marshallingCodeStream.Emit(ILOpcode.brfalse, lNullString);
marshallingCodeStream.Emit(ILOpcode.call, emitter.NewToken(
context.SystemModule.
GetKnownType("System.Runtime.CompilerServices", "RuntimeHelpers").
GetKnownMethod("get_OffsetToStringData", null)));
marshallingCodeStream.Emit(ILOpcode.add);
marshallingCodeStream.EmitLabel(lNullString);
return(context.GetWellKnownType(WellKnownType.IntPtr));
}
else
{
//
// ANSI marshalling. Allocate a byte array, copy characters, pin first element.
//
var stringToAnsi = context.GetHelperEntryPoint("InteropHelpers", "StringToAnsi");
marshallingCodeStream.Emit(ILOpcode.call, emitter.NewToken(stringToAnsi));
// Call the Array marshaller MarshalArgument
return(base.MarshalArgument(context.GetWellKnownType(WellKnownType.Byte).MakeArrayType(), emitter, marshallingCodeStream, unmarshallingCodeStream));
}
}
/// <summary>
/// Emits a call to a throw helper. Use this to emit calls to static parameterless methods that don't return.
/// The advantage of using this extension method is that you don't have to deal with what code to emit after
/// the call (e.g. do you need to make sure the stack is balanced?).
/// </summary>
public static void EmitCallThrowHelper(this ILCodeStream codeStream, ILEmitter emitter, MethodDesc method)
{
Debug.Assert(method.Signature.Length == 0 && method.Signature.IsStatic);
// Emit a call followed by a branch to the call.
// We are emitting this instead of emitting a tight loop that jumps to itself
// so that the JIT doesn't generate extra GC checks within the loop.
ILCodeLabel label = emitter.NewCodeLabel();
codeStream.EmitLabel(label);
codeStream.Emit(ILOpcode.call, emitter.NewToken(method));
codeStream.Emit(ILOpcode.br, label);
}
protected override void TransformNativeToManaged(ILCodeStream codeStream)
{
ILEmitter emitter = _ilCodeStreams.Emitter;
ILCodeLabel lNull = emitter.NewCodeLabel();
LoadManagedValue(codeStream);
codeStream.Emit(ILOpcode.brfalse, lNull);
LoadNativeValue(codeStream);
LoadManagedValue(codeStream);
codeStream.Emit(ILOpcode.call, _ilCodeStreams.Emitter.NewToken(
Context.GetHelperEntryPoint("InteropHelpers", "AsAnyMarshalNativeToManaged")));
codeStream.EmitLabel(lNull);
}
protected override void TransformNativeToManaged(ILCodeStream codeStream)
{
ILEmitter emitter = _ilCodeStreams.Emitter;
ILCodeLabel lNull = emitter.NewCodeLabel();
LoadManagedValue(codeStream);
codeStream.Emit(ILOpcode.brfalse, lNull);
LoadNativeValue(codeStream);
LoadManagedValue(codeStream);
codeStream.Emit(ILOpcode.call, _ilCodeStreams.Emitter.NewToken(
InteropStateManager.GetStructMarshallingNativeToManagedThunk(ManagedType)));
codeStream.EmitLabel(lNull);
}
protected override void EmitCleanupManaged(ILCodeStream codeStream)
{
// Only do cleanup if it is IN
if (!In)
{
return;
}
ILEmitter emitter = _ilCodeStreams.Emitter;
ILCodeLabel lNull = emitter.NewCodeLabel();
LoadManagedValue(codeStream);
codeStream.Emit(ILOpcode.brfalse, lNull);
LoadNativeValue(codeStream);
codeStream.Emit(ILOpcode.call, emitter.NewToken(
InteropStateManager.GetStructMarshallingCleanupThunk(ManagedType)));
codeStream.EmitLabel(lNull);
}
protected override void EmitCleanupManaged(ILCodeStream codeStream)
{
// Only do cleanup if it is IN
if (!In)
{
return;
}
ILEmitter emitter = _ilCodeStreams.Emitter;
ILCodeLabel lNull = emitter.NewCodeLabel();
LoadManagedValue(codeStream);
codeStream.Emit(ILOpcode.brfalse, lNull);
LoadNativeValue(codeStream);
LoadManagedValue(codeStream);
codeStream.Emit(ILOpcode.call, emitter.NewToken(
Context.GetHelperEntryPoint("InteropHelpers", "AsAnyCleanupNative")));
codeStream.EmitLabel(lNull);
}
protected override void AllocManagedToNative(ILCodeStream codeStream)
{
ILEmitter emitter = _ilCodeStreams.Emitter;
ILCodeLabel lNull = emitter.NewCodeLabel();
codeStream.EmitLdc(0);
codeStream.Emit(ILOpcode.conv_i);
StoreNativeValue(codeStream);
LoadManagedValue(codeStream);
codeStream.Emit(ILOpcode.brfalse, lNull);
TypeDesc nativeStructType = InteropStateManager.GetStructMarshallingNativeType(ManagedType);
ILLocalVariable lNativeType = emitter.NewLocal(nativeStructType);
codeStream.EmitLdLoca(lNativeType);
codeStream.Emit(ILOpcode.initobj, emitter.NewToken(nativeStructType));
codeStream.EmitLdLoca(lNativeType);
StoreNativeValue(codeStream);
codeStream.EmitLabel(lNull);
}
protected override void AllocManagedToNative(ILCodeStream codeStream)
{
ILEmitter emitter = _ilCodeStreams.Emitter;
ILCodeLabel lNull = emitter.NewCodeLabel();
ILLocalVariable lSize = emitter.NewLocal(Context.GetWellKnownType(WellKnownType.Int32));
LoadManagedValue(codeStream);
codeStream.Emit(ILOpcode.brfalse, lNull);
MethodDesc getNativeSizeHelper = Context.GetHelperEntryPoint("InteropHelpers", "AsAnyGetNativeSize");
LoadManagedValue(codeStream);
codeStream.Emit(ILOpcode.call, emitter.NewToken(getNativeSizeHelper));
codeStream.Emit(ILOpcode.dup);
codeStream.EmitStLoc(lSize);
codeStream.Emit(ILOpcode.localloc);
codeStream.Emit(ILOpcode.dup);
StoreNativeValue(codeStream);
codeStream.EmitLdc(0);
codeStream.EmitLdLoc(lSize);
codeStream.Emit(ILOpcode.initblk);
codeStream.EmitLabel(lNull);
}
protected override void TransformNativeToManaged(ILCodeStream codeStream)
{
ILEmitter emitter = _ilCodeStreams.Emitter;
ILCodeLabel lNonNull = emitter.NewCodeLabel();
LoadManagedValue(codeStream);
codeStream.Emit(ILOpcode.brtrue, lNonNull);
MethodDesc ctor = ManagedType.GetParameterlessConstructor();
if (ctor == null)
{
throw new InvalidProgramException();
}
codeStream.Emit(ILOpcode.newobj, emitter.NewToken(ctor));
StoreManagedValue(codeStream);
codeStream.EmitLabel(lNonNull);
LoadNativeAddr(codeStream);
LoadManagedValue(codeStream);
codeStream.Emit(ILOpcode.call, _ilCodeStreams.Emitter.NewToken(
InteropStateManager.GetStructMarshallingNativeToManagedThunk(ManagedType)));
}
protected override void EmitMarshalFieldNativeToManaged()
{
ILEmitter emitter = _ilCodeStreams.Emitter;
ILCodeStream codeStream = _ilCodeStreams.UnmarshallingCodestream;
// It generates the following IL:
// ManagedArg.s = new ElementType[Length];
//
// for (uint index = 0u; index < Length; index += 1u)
// {
// ManagedArg.s[index] = NativeArg.s[index];
// }
//
ILCodeLabel lRangeCheck = emitter.NewCodeLabel();
ILCodeLabel lLoopHeader = emitter.NewCodeLabel();
Debug.Assert(ManagedType is ArrayType);
var nativeArrayType = NativeType as InlineArrayType;
Debug.Assert(nativeArrayType != null);
var managedElementType = ((ArrayType)ManagedType).ElementType;
ILLocalVariable vLength = emitter.NewLocal(Context.GetWellKnownType(WellKnownType.Int32));
codeStream.EmitLdArg(1);
// load the length
EmitElementCount(codeStream, MarshalDirection.Reverse);
codeStream.EmitStLoc(vLength);
codeStream.EmitLdLoc(vLength);
codeStream.Emit(ILOpcode.newarr, emitter.NewToken(managedElementType));
codeStream.Emit(ILOpcode.stfld, emitter.NewToken(_managedField));
var vIndex = emitter.NewLocal(Context.GetWellKnownType(WellKnownType.Int32));
// index = 0
codeStream.EmitLdc(0);
codeStream.EmitStLoc(vIndex);
codeStream.Emit(ILOpcode.br, lRangeCheck);
codeStream.EmitLabel(lLoopHeader);
// load managed type
codeStream.EmitLdArg(1);
codeStream.Emit(ILOpcode.ldfld, emitter.NewToken(_managedField));
codeStream.EmitLdLoc(vIndex);
// load native type
codeStream.EmitLdArg(0);
codeStream.Emit(ILOpcode.ldflda, emitter.NewToken(_nativeField));
codeStream.EmitLdLoc(vIndex);
codeStream.Emit(ILOpcode.call, emitter.NewToken(
nativeArrayType.GetInlineArrayMethod(InlineArrayMethodKind.Getter)));
// generate marshalling IL for the element
GetElementMarshaller(MarshalDirection.Reverse)
.EmitMarshallingIL(new PInvokeILCodeStreams(_ilCodeStreams.Emitter, codeStream));
codeStream.EmitStElem(managedElementType);
codeStream.EmitLdLoc(vIndex);
codeStream.EmitLdc(1);
codeStream.Emit(ILOpcode.add);
codeStream.EmitStLoc(vIndex);
codeStream.EmitLabel(lRangeCheck);
codeStream.EmitLdLoc(vIndex);
codeStream.EmitLdLoc(vLength);
codeStream.Emit(ILOpcode.blt, lLoopHeader);
}
protected override void EmitMarshalFieldManagedToNative()
{
// It generates the following code
//if (ManagedArg.Field != null)
//{
//
// fixed (InlineArray* pUnsafe = &NativeArg.Field)
// {
// uint index = 0u;
// while ((ulong)index < (ulong)((long)ManagedArg.Field.Length))
// {
// NativeArg.s[index] = ManagedArg.Field[(int)index];
// index += 1u;
// }
// }
//}
ILEmitter emitter = _ilCodeStreams.Emitter;
ILCodeStream codeStream = _ilCodeStreams.MarshallingCodeStream;
var nativeArrayType = NativeType as InlineArrayType;
Debug.Assert(nativeArrayType != null);
Debug.Assert(ManagedType is ArrayType);
var managedElementType = ((ArrayType)ManagedType).ElementType;
ILCodeLabel lDone = emitter.NewCodeLabel();
ILCodeLabel lRangeCheck = emitter.NewCodeLabel();
ILCodeLabel lLoopHeader = emitter.NewCodeLabel();
ILLocalVariable vIndex = emitter.NewLocal(Context.GetWellKnownType(WellKnownType.Int32));
ILLocalVariable vLength = emitter.NewLocal(Context.GetWellKnownType(WellKnownType.Int32));
ILLocalVariable vNative = emitter.NewLocal(NativeType.MakeByRefType(), isPinned: true);
// check if ManagedType == null, then return
codeStream.EmitLdArg(0);
codeStream.Emit(ILOpcode.ldfld, emitter.NewToken(_managedField));
codeStream.Emit(ILOpcode.brfalse, lDone);
codeStream.EmitLdArg(1);
codeStream.Emit(ILOpcode.ldflda, emitter.NewToken(_nativeField));
codeStream.EmitStLoc(vNative);
EmitElementCount(codeStream, MarshalDirection.Forward);
codeStream.EmitStLoc(vLength);
codeStream.EmitLdc(0);
codeStream.EmitStLoc(vIndex);
codeStream.Emit(ILOpcode.br, lRangeCheck);
codeStream.EmitLabel(lLoopHeader);
codeStream.EmitLdArg(1);
codeStream.Emit(ILOpcode.ldflda, emitter.NewToken(_nativeField));
codeStream.EmitLdLoc(vIndex);
codeStream.EmitLdArg(0);
codeStream.Emit(ILOpcode.ldfld, emitter.NewToken(_managedField));
codeStream.EmitLdLoc(vIndex);
codeStream.EmitLdElem(managedElementType);
// generate marshalling IL for the element
GetElementMarshaller(MarshalDirection.Forward)
.EmitMarshallingIL(new PInvokeILCodeStreams(_ilCodeStreams.Emitter, codeStream));
codeStream.Emit(ILOpcode.call, emitter.NewToken(
nativeArrayType.GetInlineArrayMethod(InlineArrayMethodKind.Setter)));
codeStream.EmitLdLoc(vIndex);
codeStream.EmitLdc(1);
codeStream.Emit(ILOpcode.add);
codeStream.EmitStLoc(vIndex);
codeStream.EmitLabel(lRangeCheck);
codeStream.EmitLdLoc(vIndex);
codeStream.EmitLdLoc(vLength);
codeStream.Emit(ILOpcode.blt, lLoopHeader);
codeStream.EmitLabel(lDone);
}