private static MarshallerKind GetArrayElementMarshallerKind(
ArrayType arrayType,
TypeDesc elementType,
MarshalAsDescriptor marshalAs,
PInvokeMethodData methodData,
bool isField)
{
bool isAnsi = (methodData.GetCharSet() & PInvokeAttributes.CharSetAnsi) == PInvokeAttributes.CharSetAnsi;
NativeType nativeType = NativeType.Invalid;
if (marshalAs != null)
{
nativeType = (NativeType)marshalAs.ArraySubType;
}
if (elementType.IsPrimitive)
{
switch (elementType.Category)
{
case TypeFlags.Char:
switch (nativeType)
{
case NativeType.I1:
case NativeType.U1:
return(MarshallerKind.AnsiChar);
case NativeType.I2:
case NativeType.U2:
return(MarshallerKind.UnicodeChar);
default:
if (isAnsi)
{
return(MarshallerKind.AnsiChar);
}
else
{
return(MarshallerKind.UnicodeChar);
}
}
case TypeFlags.Boolean:
switch (nativeType)
{
case NativeType.Boolean:
return(MarshallerKind.Bool);
case NativeType.I1:
case NativeType.U1:
return(MarshallerKind.CBool);
case NativeType.Invalid:
default:
return(MarshallerKind.Bool);
}
case TypeFlags.IntPtr:
case TypeFlags.UIntPtr:
return(MarshallerKind.BlittableValue);
case TypeFlags.Void:
return(MarshallerKind.Invalid);
case TypeFlags.SByte:
case TypeFlags.Int16:
case TypeFlags.Int32:
case TypeFlags.Int64:
case TypeFlags.Byte:
case TypeFlags.UInt16:
case TypeFlags.UInt32:
case TypeFlags.UInt64:
case TypeFlags.Single:
case TypeFlags.Double:
return(MarshallerKind.BlittableValue);
default:
return(MarshallerKind.Invalid);
}
}
else if (elementType.IsValueType)
{
if (elementType.IsEnum)
{
return(MarshallerKind.Enum);
}
if (methodData.IsSystemDecimal(elementType))
{
switch (nativeType)
{
case NativeType.Invalid:
case NativeType.Struct:
return(MarshallerKind.Decimal);
case NativeType.LPStruct:
return(MarshallerKind.BlittableStructPtr);
default:
return(MarshallerKind.Invalid);
}
}
else if (methodData.IsSystemGuid(elementType))
{
switch (nativeType)
{
case NativeType.Invalid:
case NativeType.Struct:
return(MarshallerKind.BlittableValue);
case NativeType.LPStruct:
return(MarshallerKind.BlittableStructPtr);
default:
return(MarshallerKind.Invalid);
}
}
else if (methodData.IsSystemDateTime(elementType))
{
if (nativeType == NativeType.Invalid ||
nativeType == NativeType.Struct)
{
return(MarshallerKind.OleDateTime);
}
else
{
return(MarshallerKind.Invalid);
}
}
/*
* TODO: Bring HandleRef to CoreLib
* https://github.com/dotnet/corert/issues/2570
*
* else if (methodData.IsHandleRef(elementType))
* {
* return MarshallerKind.HandleRef;
* }
*/
else
{
if (MarshalHelpers.IsBlittableType(elementType))
{
switch (nativeType)
{
case NativeType.Invalid:
case NativeType.Struct:
return(MarshallerKind.BlittableStruct);
default:
return(MarshallerKind.Invalid);
}
}
else
{
// TODO: Differentiate between struct and Union, we only need to support struct not union here
return(MarshallerKind.Struct);
}
}
}
else // !valueType
{
if (elementType.IsString)
{
switch (nativeType)
{
case NativeType.Invalid:
if (isAnsi)
{
return(MarshallerKind.AnsiString);
}
else
{
return(MarshallerKind.UnicodeString);
}
case NativeType.LPStr:
return(MarshallerKind.AnsiString);
case NativeType.LPWStr:
return(MarshallerKind.UnicodeString);
default:
return(MarshallerKind.Invalid);
}
}
if (elementType.IsObject)
{
if (nativeType == NativeType.Invalid)
{
return(MarshallerKind.Variant);
}
else
{
return(MarshallerKind.Invalid);
}
}
if (elementType.IsSzArray)
{
return(MarshallerKind.Invalid);
}
if (elementType.IsPointer)
{
return(MarshallerKind.Invalid);
}
if (methodData.IsSafeHandle(elementType))
{
return(MarshallerKind.Invalid);
}
/*
* TODO: Bring CriticalHandle to CoreLib
* https://github.com/dotnet/corert/issues/2570
*
* if (methodData.IsCriticalHandle(elementType))
* {
* return MarshallerKind.Invalid;
* }
*/
}
return(MarshallerKind.Invalid);
}
private static MarshallerKind GetMarshallerKind(
TypeDesc type,
ParameterMetadata parameterData,
PInvokeMethodData methodData,
bool isField)
{
if (type.IsByRef)
{
var byRefType = (ByRefType)type;
type = byRefType.ParameterType;
}
NativeType nativeType = NativeType.Invalid;
bool isReturn = parameterData.Return;
MarshalAsDescriptor marshalAs = parameterData.MarshalAsDescriptor;
if (marshalAs != null)
{
nativeType = (NativeType)marshalAs.Type;
}
bool isAnsi = (methodData.GetCharSet() & PInvokeAttributes.CharSetAnsi) == PInvokeAttributes.CharSetAnsi;
//
// Determine MarshalerKind
//
// This mostly resembles desktop CLR and .NET Native code as we need to match their behavior
//
if (type.IsPrimitive)
{
switch (type.Category)
{
case TypeFlags.Void:
return(MarshallerKind.VoidReturn);
case TypeFlags.Boolean:
switch (nativeType)
{
case NativeType.Invalid:
case NativeType.Boolean:
return(MarshallerKind.Bool);
case NativeType.U1:
case NativeType.I1:
return(MarshallerKind.CBool);
default:
return(MarshallerKind.Invalid);
}
case TypeFlags.Char:
switch (nativeType)
{
case NativeType.I1:
case NativeType.U1:
return(MarshallerKind.AnsiChar);
case NativeType.I2:
case NativeType.U2:
return(MarshallerKind.UnicodeChar);
case NativeType.Invalid:
if (isAnsi)
{
return(MarshallerKind.AnsiChar);
}
else
{
return(MarshallerKind.UnicodeChar);
}
default:
return(MarshallerKind.Invalid);
}
case TypeFlags.SByte:
case TypeFlags.Byte:
if (nativeType == NativeType.I1 || nativeType == NativeType.U1 || nativeType == NativeType.Invalid)
{
return(MarshallerKind.BlittableValue);
}
else
{
return(MarshallerKind.Invalid);
}
case TypeFlags.Int16:
case TypeFlags.UInt16:
if (nativeType == NativeType.I2 || nativeType == NativeType.U2 || nativeType == NativeType.Invalid)
{
return(MarshallerKind.BlittableValue);
}
else
{
return(MarshallerKind.Invalid);
}
case TypeFlags.Int32:
case TypeFlags.UInt32:
if (nativeType == NativeType.I4 || nativeType == NativeType.U4 || nativeType == NativeType.Invalid)
{
return(MarshallerKind.BlittableValue);
}
else
{
return(MarshallerKind.Invalid);
}
case TypeFlags.Int64:
case TypeFlags.UInt64:
if (nativeType == NativeType.I8 || nativeType == NativeType.U8 || nativeType == NativeType.Invalid)
{
return(MarshallerKind.BlittableValue);
}
else
{
return(MarshallerKind.Invalid);
}
case TypeFlags.IntPtr:
case TypeFlags.UIntPtr:
if (nativeType == NativeType.Invalid)
{
return(MarshallerKind.BlittableValue);
}
else
{
return(MarshallerKind.Invalid);
}
case TypeFlags.Single:
if (nativeType == NativeType.R4 || nativeType == NativeType.Invalid)
{
return(MarshallerKind.BlittableValue);
}
else
{
return(MarshallerKind.Invalid);
}
case TypeFlags.Double:
if (nativeType == NativeType.R8 || nativeType == NativeType.Invalid)
{
return(MarshallerKind.BlittableValue);
}
else
{
return(MarshallerKind.Invalid);
}
default:
return(MarshallerKind.Invalid);
}
}
else if (type.IsValueType)
{
if (type.IsEnum)
{
return(MarshallerKind.Enum);
}
if (methodData.IsSystemDateTime(type))
{
if (nativeType == NativeType.Invalid ||
nativeType == NativeType.Struct)
{
return(MarshallerKind.OleDateTime);
}
else
{
return(MarshallerKind.Invalid);
}
}
/*
* TODO: Bring HandleRef to CoreLib
* https://github.com/dotnet/corert/issues/2570
*
* else if (methodData.IsHandleRef(type))
* {
* if (nativeType == NativeType.Invalid)
* return MarshallerKind.HandleRef;
* else
* return MarshallerKind.Invalid;
* }
*/
switch (nativeType)
{
case NativeType.Invalid:
case NativeType.Struct:
if (methodData.IsSystemDecimal(type))
{
return(MarshallerKind.Decimal);
}
break;
case NativeType.LPStruct:
if (methodData.IsSystemGuid(type) ||
methodData.IsSystemDecimal(type))
{
if (isField || isReturn)
{
return(MarshallerKind.Invalid);
}
else
{
return(MarshallerKind.BlittableStructPtr);
}
}
break;
default:
return(MarshallerKind.Invalid);
}
if (MarshalHelpers.IsBlittableType(type))
{
return(MarshallerKind.BlittableStruct);
}
else
{
return(MarshallerKind.Struct);
}
}
else // !ValueType
{
if (type.Category == TypeFlags.Class)
{
if (type.IsString)
{
switch (nativeType)
{
case NativeType.LPWStr:
return(MarshallerKind.UnicodeString);
case NativeType.LPStr:
return(MarshallerKind.AnsiString);
case NativeType.Invalid:
if (isAnsi)
{
return(MarshallerKind.AnsiString);
}
else
{
return(MarshallerKind.UnicodeString);
}
default:
return(MarshallerKind.Invalid);
}
}
else if (type.IsDelegate)
{
if (nativeType == NativeType.Invalid || nativeType == NativeType.Func)
{
return(MarshallerKind.FunctionPointer);
}
else
{
return(MarshallerKind.Invalid);
}
}
else if (type.IsObject)
{
if (nativeType == NativeType.Invalid)
{
return(MarshallerKind.Variant);
}
else
{
return(MarshallerKind.Invalid);
}
}
else if (methodData.IsStringBuilder(type))
{
switch (nativeType)
{
case NativeType.Invalid:
if (isAnsi)
{
return(MarshallerKind.AnsiStringBuilder);
}
else
{
return(MarshallerKind.UnicodeStringBuilder);
}
case NativeType.LPStr:
return(MarshallerKind.AnsiStringBuilder);
case NativeType.LPWStr:
return(MarshallerKind.UnicodeStringBuilder);
default:
return(MarshallerKind.Invalid);
}
}
else if (methodData.IsSafeHandle(type))
{
if (nativeType == NativeType.Invalid)
{
return(MarshallerKind.SafeHandle);
}
else
{
return(MarshallerKind.Invalid);
}
}
/*
* TODO: Bring CriticalHandle to CoreLib
* https://github.com/dotnet/corert/issues/2570
*
* else if (methodData.IsCriticalHandle(type))
* {
* if (nativeType != NativeType.Invalid || isField)
* {
* return MarshallerKind.Invalid;
* }
* else
* {
* return MarshallerKind.CriticalHandle;
* }
* }
*/
return(MarshallerKind.Invalid);
}
else if (methodData.IsSystemArray(type))
{
return(MarshallerKind.Invalid);
}
else if (type.IsSzArray)
{
MarshallerKind elementMarshallerKind;
if (nativeType == NativeType.Invalid)
{
nativeType = NativeType.Array;
}
switch (nativeType)
{
case NativeType.Array:
{
if (isField || isReturn)
{
return(MarshallerKind.Invalid);
}
var arrayType = (ArrayType)type;
elementMarshallerKind = GetArrayElementMarshallerKind(
arrayType,
arrayType.ElementType,
marshalAs,
methodData,
isField);
// If element is invalid type, the array itself is invalid
if (elementMarshallerKind == MarshallerKind.Invalid)
{
return(MarshallerKind.Invalid);
}
if (elementMarshallerKind == MarshallerKind.AnsiChar)
{
return(MarshallerKind.AnsiCharArray);
}
else if (elementMarshallerKind == MarshallerKind.UnicodeChar)
{
// Arrays of unicode char should be marshalled as blittable arrays
return(MarshallerKind.BlittableArray);
}
else
{
return(MarshallerKind.Array);
}
}
case NativeType.ByValArray: // fix sized array
{
var arrayType = (ArrayType)type;
elementMarshallerKind = GetArrayElementMarshallerKind(
arrayType,
arrayType.ElementType,
marshalAs,
methodData,
isField);
// If element is invalid type, the array itself is invalid
if (elementMarshallerKind == MarshallerKind.Invalid)
{
return(MarshallerKind.Invalid);
}
if (elementMarshallerKind == MarshallerKind.AnsiChar)
{
return(MarshallerKind.ByValAnsiCharArray);
}
else
{
return(MarshallerKind.ByValArray);
}
}
default:
return(MarshallerKind.Invalid);
}
}
else if (type.Category == TypeFlags.Pointer)
{
//
// @TODO - add checks for the pointee type in case the pointee type is not blittable
// C# already does this and will emit compilation errors (can't declare pointers to
// managed type).
//
if (nativeType == NativeType.Invalid)
{
return(MarshallerKind.BlittableValue);
}
else
{
return(MarshallerKind.Invalid);
}
}
}
return(MarshallerKind.Invalid);
}