public override ParameterMetadata[] GetParameterMetadata() { MetadataReader metadataReader = MetadataReader; // Spot check the enums match Debug.Assert((int)ParameterAttributes.In == (int)ParameterMetadataAttributes.In); Debug.Assert((int)ParameterAttributes.Out == (int)ParameterMetadataAttributes.Out); Debug.Assert((int)ParameterAttributes.Optional == (int)ParameterMetadataAttributes.Optional); Debug.Assert((int)ParameterAttributes.HasDefault == (int)ParameterMetadataAttributes.HasDefault); Debug.Assert((int)ParameterAttributes.HasFieldMarshal == (int)ParameterMetadataAttributes.HasFieldMarshal); ParameterHandleCollection parameterHandles = metadataReader.GetMethodDefinition(_handle).GetParameters(); ParameterMetadata[] parameterMetadataArray = new ParameterMetadata[parameterHandles.Count]; int index = 0; foreach (ParameterHandle parameterHandle in parameterHandles) { Parameter parameter = metadataReader.GetParameter(parameterHandle); MarshalAsDescriptor marshalAsDescriptor = GetMarshalAsDescriptor(parameter); ParameterMetadata data = new ParameterMetadata(parameter.SequenceNumber, (ParameterMetadataAttributes)parameter.Attributes, marshalAsDescriptor); parameterMetadataArray[index++] = data; } return(parameterMetadataArray); }
private MarshalAsDescriptor GetMarshalAsDescriptor(FieldDefinition fieldDefinition) { if ((fieldDefinition.Attributes & FieldAttributes.HasFieldMarshal) == FieldAttributes.HasFieldMarshal) { MetadataReader metadataReader = MetadataReader; BlobReader marshalAsReader = metadataReader.GetBlobReader(fieldDefinition.GetMarshallingDescriptor()); EcmaSignatureParser parser = new EcmaSignatureParser(EcmaModule, marshalAsReader); MarshalAsDescriptor marshalAs = parser.ParseMarshalAsDescriptor(); Debug.Assert(marshalAs != null); return(marshalAs); } return(null); }
private MarshalAsDescriptor GetMarshalAsDescriptor(Parameter parameter) { if ((parameter.Attributes & ParameterAttributes.HasFieldMarshal) == ParameterAttributes.HasFieldMarshal) { MetadataReader metadataReader = MetadataReader; BlobReader marshalAsReader = metadataReader.GetBlobReader(parameter.GetMarshallingDescriptor()); EcmaSignatureParser parser = new EcmaSignatureParser(Module, marshalAsReader); MarshalAsDescriptor marshalAs = parser.ParseMarshalAsDescriptor(); Debug.Assert(marshalAs != null); return(marshalAs); } return(null); }
private TypeDesc GetNativeMethodParameterType(TypeDesc managedType, MarshalAsDescriptor marshalAs, InteropStateManager interopStateManager, bool isReturn, bool isAnsi) { TypeDesc nativeType; try { nativeType = MarshalHelpers.GetNativeMethodParameterType(managedType, marshalAs, interopStateManager, isReturn, isAnsi); } catch (NotSupportedException) { // if marshalling is not supported for this type the generated stubs will emit appropriate // error message. We just set native type to be same as managedtype nativeType = managedType; } return(nativeType); }
internal static TypeDesc GetNativeStructFieldType(TypeDesc type, MarshalAsDescriptor marshalAs, InteropStateManager interopStateManager, bool isAnsi) { MarshallerKind elementMarshallerKind; MarshallerKind marshallerKind = MarshalHelpers.GetMarshallerKind(type, marshalAs, false, /* isReturn */ isAnsi, /* isAnsi */ MarshallerType.Field, out elementMarshallerKind); return(GetNativeTypeFromMarshallerKind(type, marshallerKind, elementMarshallerKind, interopStateManager, marshalAs)); }
public override MarshalAsDescriptor[] GetFieldMarshalAsDescriptors() { var fieldDefinitionHandles = _typeDefinition.GetFields(); MarshalAsDescriptor[] marshalAsDescriptors = new MarshalAsDescriptor[fieldDefinitionHandles.Count]; int index = 0; foreach (var handle in fieldDefinitionHandles) { var fieldDefinition = MetadataReader.GetFieldDefinition(handle); MarshalAsDescriptor marshalAsDescriptor = GetMarshalAsDescriptor(fieldDefinition); marshalAsDescriptors[index++] = marshalAsDescriptor; } return(marshalAsDescriptors); }
internal static TypeDesc GetNativeMethodParameterType(TypeDesc type, MarshalAsDescriptor marshalAs, InteropStateManager interopStateManager, bool isReturn, bool isAnsi) { MarshallerKind elementMarshallerKind; MarshallerKind marshallerKind = MarshalHelpers.GetMarshallerKind(type, marshalAs, isReturn, isAnsi, MarshallerType.Argument, out elementMarshallerKind); return(GetNativeTypeFromMarshallerKind(type, marshallerKind, elementMarshallerKind, interopStateManager, marshalAs)); }
private static MarshallerKind GetMarshallerKind(TypeDesc type, MarshalAsDescriptor marshalAs, PInvokeMethodData PInvokeMethodData, bool isReturn) { if (isReturn) { if (type.IsVoid) { return(MarshallerKind.VoidReturn); } if (MarshalHelpers.IsBlittableType(type)) { return(MarshallerKind.BlittableValue); } if (type.Category == TypeFlags.Boolean) { return(MarshallerKind.Bool); } if (PInvokeMethodData.IsSafeHandle(type)) { return(MarshallerKind.SafeHandle); } throw new NotSupportedException(); } if (MarshalHelpers.IsBlittableType(type)) { return(MarshallerKind.BlittableValue); } TypeSystemContext context = PInvokeMethodData.Context; if (type.IsSzArray) { var arrayType = (ArrayType)type; if (MarshalHelpers.IsBlittableType(arrayType.ParameterType)) { return(MarshallerKind.BlittableArray); } if (arrayType.ParameterType == context.GetWellKnownType(WellKnownType.Char)) { if (PInvokeMethodData.GetCharSet() == PInvokeAttributes.CharSetUnicode) { return(MarshallerKind.BlittableArray); } } } if (type.IsByRef) { var byRefType = (ByRefType)type; if (MarshalHelpers.IsBlittableType(byRefType.ParameterType)) { return(MarshallerKind.BlittableByRef); } if (byRefType.ParameterType == context.GetWellKnownType(WellKnownType.Char)) { if (PInvokeMethodData.GetCharSet() == PInvokeAttributes.CharSetUnicode) { return(MarshallerKind.BlittableByRef); } } } if (type.IsString) { return(MarshallerKind.String); } if (type.Category == TypeFlags.Boolean) { return(MarshallerKind.Bool); } if (type is MetadataType) { var metadataType = (MetadataType)type; if (metadataType.Module == context.SystemModule) { var nameSpace = metadataType.Namespace; var name = metadataType.Name; if (name == "StringBuilder" && nameSpace == "System.Text") { return(MarshallerKind.StringBuilder); } } } if (PInvokeMethodData.IsSafeHandle(type)) { return(MarshallerKind.SafeHandle); } throw new NotSupportedException(); }
private static MarshallerKind GetArrayElementMarshallerKind( ArrayType arrayType, MarshalAsDescriptor marshalAs, bool isAnsi) { TypeDesc elementType = arrayType.ElementType; NativeTypeKind nativeType = NativeTypeKind.Invalid; TypeSystemContext context = arrayType.Context; if (marshalAs != null) { nativeType = (NativeTypeKind)marshalAs.ArraySubType; } if (elementType.IsPrimitive) { switch (elementType.Category) { case TypeFlags.Char: switch (nativeType) { case NativeTypeKind.I1: case NativeTypeKind.U1: return(MarshallerKind.AnsiChar); case NativeTypeKind.I2: case NativeTypeKind.U2: return(MarshallerKind.UnicodeChar); default: if (isAnsi) { return(MarshallerKind.AnsiChar); } else { return(MarshallerKind.UnicodeChar); } } case TypeFlags.Boolean: switch (nativeType) { case NativeTypeKind.Boolean: return(MarshallerKind.Bool); case NativeTypeKind.I1: case NativeTypeKind.U1: return(MarshallerKind.CBool); case NativeTypeKind.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 (InteropTypes.IsSystemDecimal(context, elementType)) { switch (nativeType) { case NativeTypeKind.Invalid: case NativeTypeKind.Struct: return(MarshallerKind.Decimal); case NativeTypeKind.LPStruct: return(MarshallerKind.BlittableStructPtr); default: return(MarshallerKind.Invalid); } } else if (InteropTypes.IsSystemGuid(context, elementType)) { switch (nativeType) { case NativeTypeKind.Invalid: case NativeTypeKind.Struct: return(MarshallerKind.BlittableValue); case NativeTypeKind.LPStruct: return(MarshallerKind.BlittableStructPtr); default: return(MarshallerKind.Invalid); } } else if (InteropTypes.IsSystemDateTime(context, elementType)) { if (nativeType == NativeTypeKind.Invalid || nativeType == NativeTypeKind.Struct) { return(MarshallerKind.OleDateTime); } else { return(MarshallerKind.Invalid); } } else if (InteropTypes.IsHandleRef(context, elementType)) { if (nativeType == NativeTypeKind.Invalid) { return(MarshallerKind.HandleRef); } else { return(MarshallerKind.Invalid); } } else { if (MarshalHelpers.IsBlittableType(elementType)) { switch (nativeType) { case NativeTypeKind.Invalid: case NativeTypeKind.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 if (elementType.IsPointer || elementType.IsFunctionPointer) { if (nativeType == NativeTypeKind.Invalid) { return(MarshallerKind.BlittableValue); } else { return(MarshallerKind.Invalid); } } else if (elementType.IsString) { switch (nativeType) { case NativeTypeKind.Invalid: if (isAnsi) { return(MarshallerKind.AnsiString); } else { return(MarshallerKind.UnicodeString); } case NativeTypeKind.LPStr: return(MarshallerKind.AnsiString); case NativeTypeKind.LPWStr: return(MarshallerKind.UnicodeString); default: return(MarshallerKind.Invalid); } } // else if (elementType.IsObject) // { // if (nativeType == NativeTypeKind.Invalid) // return MarshallerKind.Variant; // else // return MarshallerKind.Invalid; // } else { return(MarshallerKind.Invalid); } }
internal static MarshallerKind GetMarshallerKind( TypeDesc type, MarshalAsDescriptor marshalAs, bool isReturn, bool isAnsi, MarshallerType marshallerType, out MarshallerKind elementMarshallerKind) { if (type.IsByRef) { type = type.GetParameterType(); } TypeSystemContext context = type.Context; NativeTypeKind nativeType = NativeTypeKind.Invalid; bool isField = marshallerType == MarshallerType.Field; if (marshalAs != null) { nativeType = (NativeTypeKind)marshalAs.Type; } elementMarshallerKind = MarshallerKind.Invalid; // // 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 NativeTypeKind.Invalid: case NativeTypeKind.Boolean: return(MarshallerKind.Bool); case NativeTypeKind.U1: case NativeTypeKind.I1: return(MarshallerKind.CBool); default: return(MarshallerKind.Invalid); } case TypeFlags.Char: switch (nativeType) { case NativeTypeKind.I1: case NativeTypeKind.U1: return(MarshallerKind.AnsiChar); case NativeTypeKind.I2: case NativeTypeKind.U2: return(MarshallerKind.UnicodeChar); case NativeTypeKind.Invalid: if (isAnsi) { return(MarshallerKind.AnsiChar); } else { return(MarshallerKind.UnicodeChar); } default: return(MarshallerKind.Invalid); } case TypeFlags.SByte: case TypeFlags.Byte: if (nativeType == NativeTypeKind.I1 || nativeType == NativeTypeKind.U1 || nativeType == NativeTypeKind.Invalid) { return(MarshallerKind.BlittableValue); } else { return(MarshallerKind.Invalid); } case TypeFlags.Int16: case TypeFlags.UInt16: if (nativeType == NativeTypeKind.I2 || nativeType == NativeTypeKind.U2 || nativeType == NativeTypeKind.Invalid) { return(MarshallerKind.BlittableValue); } else { return(MarshallerKind.Invalid); } case TypeFlags.Int32: case TypeFlags.UInt32: if (nativeType == NativeTypeKind.I4 || nativeType == NativeTypeKind.U4 || nativeType == NativeTypeKind.Invalid) { return(MarshallerKind.BlittableValue); } else { return(MarshallerKind.Invalid); } case TypeFlags.Int64: case TypeFlags.UInt64: if (nativeType == NativeTypeKind.I8 || nativeType == NativeTypeKind.U8 || nativeType == NativeTypeKind.Invalid) { return(MarshallerKind.BlittableValue); } else { return(MarshallerKind.Invalid); } case TypeFlags.IntPtr: case TypeFlags.UIntPtr: if (nativeType == NativeTypeKind.Invalid) { return(MarshallerKind.BlittableValue); } else { return(MarshallerKind.Invalid); } case TypeFlags.Single: if (nativeType == NativeTypeKind.R4 || nativeType == NativeTypeKind.Invalid) { return(MarshallerKind.BlittableValue); } else { return(MarshallerKind.Invalid); } case TypeFlags.Double: if (nativeType == NativeTypeKind.R8 || nativeType == NativeTypeKind.Invalid) { return(MarshallerKind.BlittableValue); } else { return(MarshallerKind.Invalid); } default: return(MarshallerKind.Invalid); } } else if (type.IsValueType) { if (type.IsEnum) { return(MarshallerKind.Enum); } if (InteropTypes.IsSystemDateTime(context, type)) { if (nativeType == NativeTypeKind.Invalid || nativeType == NativeTypeKind.Struct) { return(MarshallerKind.OleDateTime); } else { return(MarshallerKind.Invalid); } } else if (InteropTypes.IsHandleRef(context, type)) { if (nativeType == NativeTypeKind.Invalid) { return(MarshallerKind.HandleRef); } else { return(MarshallerKind.Invalid); } } switch (nativeType) { case NativeTypeKind.Invalid: case NativeTypeKind.Struct: if (InteropTypes.IsSystemDecimal(context, type)) { return(MarshallerKind.Decimal); } break; case NativeTypeKind.LPStruct: if (InteropTypes.IsSystemGuid(context, type) || InteropTypes.IsSystemDecimal(context, type)) { if (isField || isReturn) { return(MarshallerKind.Invalid); } else { return(MarshallerKind.BlittableStructPtr); } } break; default: return(MarshallerKind.Invalid); } if (type is MetadataType) { MetadataType metadataType = (MetadataType)type; // the struct type need to be either sequential or explicit. If it is // auto layout we will throw exception. if (!metadataType.IsSequentialLayout && !metadataType.IsExplicitLayout) { throw new InvalidProgramException("The specified structure " + metadataType.Name + " has invalid StructLayout information. It must be either Sequential or Explicit."); } } if (MarshalHelpers.IsBlittableType(type)) { return(MarshallerKind.BlittableStruct); } else { return(MarshallerKind.Struct); } } else if (type.IsSzArray) { if (nativeType == NativeTypeKind.Invalid) { nativeType = NativeTypeKind.Array; } switch (nativeType) { case NativeTypeKind.Array: { if (isField || isReturn) { return(MarshallerKind.Invalid); } var arrayType = (ArrayType)type; elementMarshallerKind = GetArrayElementMarshallerKind( arrayType, marshalAs, isAnsi); // 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 elementMarshallerKind == MarshallerKind.Enum || elementMarshallerKind == MarshallerKind.BlittableValue) { return(MarshallerKind.BlittableArray); } else { return(MarshallerKind.Array); } } case NativeTypeKind.ByValArray: // fix sized array { var arrayType = (ArrayType)type; elementMarshallerKind = GetArrayElementMarshallerKind( arrayType, marshalAs, isAnsi); // 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.IsPointer || type.IsFunctionPointer) { if (nativeType == NativeTypeKind.Invalid) { return(MarshallerKind.BlittableValue); } else { return(MarshallerKind.Invalid); } } else if (type.IsDelegate) { if (nativeType == NativeTypeKind.Invalid || nativeType == NativeTypeKind.Func) { return(MarshallerKind.FunctionPointer); } else { return(MarshallerKind.Invalid); } } else if (type.IsString) { switch (nativeType) { case NativeTypeKind.LPWStr: return(MarshallerKind.UnicodeString); case NativeTypeKind.LPStr: return(MarshallerKind.AnsiString); case NativeTypeKind.LPTStr: return(MarshallerKind.UnicodeString); case NativeTypeKind.ByValTStr: if (isAnsi) { elementMarshallerKind = MarshallerKind.AnsiChar; return(MarshallerKind.ByValAnsiString); } else { elementMarshallerKind = MarshallerKind.UnicodeChar; return(MarshallerKind.ByValUnicodeString); } case NativeTypeKind.Invalid: if (isAnsi) { return(MarshallerKind.AnsiString); } else { return(MarshallerKind.UnicodeString); } default: return(MarshallerKind.Invalid); } } // else if (type.IsObject) // { // if (nativeType == NativeTypeKind.Invalid) // return MarshallerKind.Variant; // else // return MarshallerKind.Invalid; // } else if (InteropTypes.IsStringBuilder(context, type)) { switch (nativeType) { case NativeTypeKind.Invalid: if (isAnsi) { return(MarshallerKind.AnsiStringBuilder); } else { return(MarshallerKind.UnicodeStringBuilder); } case NativeTypeKind.LPStr: return(MarshallerKind.AnsiStringBuilder); case NativeTypeKind.LPWStr: return(MarshallerKind.UnicodeStringBuilder); default: return(MarshallerKind.Invalid); } } else if (InteropTypes.IsSafeHandle(context, type)) { if (nativeType == NativeTypeKind.Invalid) { return(MarshallerKind.SafeHandle); } else { return(MarshallerKind.Invalid); } } else if (InteropTypes.IsCriticalHandle(context, type)) { if (nativeType == NativeTypeKind.Invalid) { return(MarshallerKind.CriticalHandle); } else { return(MarshallerKind.Invalid); } } else { return(MarshallerKind.Invalid); } }
internal static InlineArrayCandidate GetInlineArrayCandidate(TypeDesc managedElementType, MarshallerKind elementMarshallerKind, InteropStateManager interopStateManager, MarshalAsDescriptor marshalAs) { TypeDesc nativeType = GetNativeTypeFromMarshallerKind( managedElementType, elementMarshallerKind, MarshallerKind.Unknown, interopStateManager, null); var elementNativeType = nativeType as MetadataType; if (elementNativeType == null) { Debug.Assert(nativeType.IsPointer || nativeType.IsFunctionPointer); // If it is a pointer type we will create InlineArray for IntPtr elementNativeType = (MetadataType)managedElementType.Context.GetWellKnownType(WellKnownType.IntPtr); } Debug.Assert(marshalAs != null && marshalAs.SizeConst.HasValue); // if SizeConst is not specified, we will default to 1. // the marshaller will throw appropriate exception uint size = 1; if (marshalAs.SizeConst.HasValue) { size = marshalAs.SizeConst.Value; } return(new InlineArrayCandidate(elementNativeType, size)); }
internal static TypeDesc GetNativeTypeFromMarshallerKind(TypeDesc type, MarshallerKind kind, MarshallerKind elementMarshallerKind, InteropStateManager interopStateManager, MarshalAsDescriptor marshalAs, bool isArrayElement = false) { TypeSystemContext context = type.Context; NativeTypeKind nativeType = NativeTypeKind.Invalid; if (marshalAs != null) { nativeType = isArrayElement ? marshalAs.ArraySubType : marshalAs.Type; } switch (kind) { case MarshallerKind.BlittableValue: { switch (nativeType) { case NativeTypeKind.I1: return(context.GetWellKnownType(WellKnownType.SByte)); case NativeTypeKind.U1: return(context.GetWellKnownType(WellKnownType.Byte)); case NativeTypeKind.I2: return(context.GetWellKnownType(WellKnownType.Int16)); case NativeTypeKind.U2: return(context.GetWellKnownType(WellKnownType.UInt16)); case NativeTypeKind.I4: return(context.GetWellKnownType(WellKnownType.Int32)); case NativeTypeKind.U4: return(context.GetWellKnownType(WellKnownType.UInt32)); case NativeTypeKind.I8: return(context.GetWellKnownType(WellKnownType.Int64)); case NativeTypeKind.U8: return(context.GetWellKnownType(WellKnownType.UInt64)); case NativeTypeKind.R4: return(context.GetWellKnownType(WellKnownType.Single)); case NativeTypeKind.R8: return(context.GetWellKnownType(WellKnownType.Double)); default: return(type.UnderlyingType); } } case MarshallerKind.Bool: return(context.GetWellKnownType(WellKnownType.Int32)); case MarshallerKind.CBool: return(context.GetWellKnownType(WellKnownType.Byte)); case MarshallerKind.Enum: case MarshallerKind.BlittableStruct: case MarshallerKind.Decimal: case MarshallerKind.VoidReturn: return(type); case MarshallerKind.Struct: return(interopStateManager.GetStructMarshallingNativeType((MetadataType)type)); case MarshallerKind.BlittableStructPtr: return(type.MakePointerType()); case MarshallerKind.HandleRef: return(context.GetWellKnownType(WellKnownType.IntPtr)); case MarshallerKind.UnicodeChar: if (nativeType == NativeTypeKind.U2) { return(context.GetWellKnownType(WellKnownType.UInt16)); } else { return(context.GetWellKnownType(WellKnownType.Int16)); } case MarshallerKind.OleDateTime: return(context.GetWellKnownType(WellKnownType.Double)); case MarshallerKind.SafeHandle: case MarshallerKind.CriticalHandle: return(context.GetWellKnownType(WellKnownType.IntPtr)); case MarshallerKind.UnicodeString: case MarshallerKind.UnicodeStringBuilder: return(context.GetWellKnownType(WellKnownType.Char).MakePointerType()); case MarshallerKind.AnsiString: case MarshallerKind.AnsiStringBuilder: return(context.GetWellKnownType(WellKnownType.Byte).MakePointerType()); case MarshallerKind.BlittableArray: case MarshallerKind.Array: case MarshallerKind.AnsiCharArray: { ArrayType arrayType = type as ArrayType; Debug.Assert(arrayType != null, "Expecting array"); // // We need to construct the unsafe array from the right unsafe array element type // TypeDesc elementNativeType = GetNativeTypeFromMarshallerKind( arrayType.ElementType, elementMarshallerKind, MarshallerKind.Unknown, interopStateManager, marshalAs, isArrayElement: true); return(elementNativeType.MakePointerType()); } case MarshallerKind.AnsiChar: return(context.GetWellKnownType(WellKnownType.Byte)); case MarshallerKind.FunctionPointer: return(context.GetWellKnownType(WellKnownType.IntPtr)); case MarshallerKind.ByValUnicodeString: case MarshallerKind.ByValAnsiString: { var inlineArrayCandidate = GetInlineArrayCandidate(context.GetWellKnownType(WellKnownType.Char), elementMarshallerKind, interopStateManager, marshalAs); return(interopStateManager.GetInlineArrayType(inlineArrayCandidate)); } case MarshallerKind.ByValAnsiCharArray: case MarshallerKind.ByValArray: { ArrayType arrayType = type as ArrayType; Debug.Assert(arrayType != null, "Expecting array"); var inlineArrayCandidate = GetInlineArrayCandidate(arrayType.ElementType, elementMarshallerKind, interopStateManager, marshalAs); return(interopStateManager.GetInlineArrayType(inlineArrayCandidate)); } case MarshallerKind.Unknown: default: throw new NotSupportedException(); } }
internal static MarshallerKind GetMarshallerKind( TypeDesc type, MarshalAsDescriptor marshalAs, bool isReturn, bool isAnsi, MarshallerType marshallerType, out MarshallerKind elementMarshallerKind) { elementMarshallerKind = MarshallerKind.Invalid; bool isByRef = false; if (type.IsByRef) { isByRef = true; type = type.GetParameterType(); // Compat note: CLR allows ref returning blittable structs for IJW if (isReturn) { return(MarshallerKind.Invalid); } } TypeSystemContext context = type.Context; NativeTypeKind nativeType = NativeTypeKind.Default; bool isField = marshallerType == MarshallerType.Field; if (marshalAs != null) { nativeType = marshalAs.Type; } // // Determine MarshalerKind // // This mostly resembles .NET Framework 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 NativeTypeKind.Default: case NativeTypeKind.Boolean: return(MarshallerKind.Bool); case NativeTypeKind.U1: case NativeTypeKind.I1: return(MarshallerKind.CBool); default: return(MarshallerKind.Invalid); } case TypeFlags.Char: switch (nativeType) { case NativeTypeKind.I1: case NativeTypeKind.U1: return(MarshallerKind.AnsiChar); case NativeTypeKind.I2: case NativeTypeKind.U2: return(MarshallerKind.UnicodeChar); case NativeTypeKind.Default: if (isAnsi) { return(MarshallerKind.AnsiChar); } else { return(MarshallerKind.UnicodeChar); } default: return(MarshallerKind.Invalid); } case TypeFlags.SByte: case TypeFlags.Byte: if (nativeType == NativeTypeKind.I1 || nativeType == NativeTypeKind.U1 || nativeType == NativeTypeKind.Default) { return(MarshallerKind.BlittableValue); } else { return(MarshallerKind.Invalid); } case TypeFlags.Int16: case TypeFlags.UInt16: if (nativeType == NativeTypeKind.I2 || nativeType == NativeTypeKind.U2 || nativeType == NativeTypeKind.Default) { return(MarshallerKind.BlittableValue); } else { return(MarshallerKind.Invalid); } case TypeFlags.Int32: case TypeFlags.UInt32: if (nativeType == NativeTypeKind.I4 || nativeType == NativeTypeKind.U4 || nativeType == NativeTypeKind.Default) { return(MarshallerKind.BlittableValue); } else { return(MarshallerKind.Invalid); } case TypeFlags.Int64: case TypeFlags.UInt64: if (nativeType == NativeTypeKind.I8 || nativeType == NativeTypeKind.U8 || nativeType == NativeTypeKind.Default) { return(MarshallerKind.BlittableValue); } else { return(MarshallerKind.Invalid); } case TypeFlags.IntPtr: case TypeFlags.UIntPtr: if (nativeType == NativeTypeKind.SysInt || nativeType == NativeTypeKind.SysUInt || nativeType == NativeTypeKind.Default) { return(MarshallerKind.BlittableValue); } else { return(MarshallerKind.Invalid); } case TypeFlags.Single: if (nativeType == NativeTypeKind.R4 || nativeType == NativeTypeKind.Default) { return(MarshallerKind.BlittableValue); } else { return(MarshallerKind.Invalid); } case TypeFlags.Double: if (nativeType == NativeTypeKind.R8 || nativeType == NativeTypeKind.Default) { return(MarshallerKind.BlittableValue); } else { return(MarshallerKind.Invalid); } default: return(MarshallerKind.Invalid); } } else if (type.IsValueType) { if (type.IsEnum) { return(MarshallerKind.Enum); } if (InteropTypes.IsSystemDateTime(context, type)) { if (nativeType == NativeTypeKind.Default || nativeType == NativeTypeKind.Struct) { return(MarshallerKind.OleDateTime); } else { return(MarshallerKind.Invalid); } } else if (InteropTypes.IsHandleRef(context, type)) { if (nativeType == NativeTypeKind.Default) { return(MarshallerKind.HandleRef); } else { return(MarshallerKind.Invalid); } } else if (InteropTypes.IsSystemDecimal(context, type)) { if (nativeType == NativeTypeKind.Struct || nativeType == NativeTypeKind.Default) { return(MarshallerKind.Decimal); } else if (nativeType == NativeTypeKind.LPStruct && !isField && !isReturn) { return(MarshallerKind.BlittableStructPtr); } else { return(MarshallerKind.Invalid); } } else if (InteropTypes.IsSystemGuid(context, type)) { if (nativeType == NativeTypeKind.Struct || nativeType == NativeTypeKind.Default) { return(MarshallerKind.BlittableStruct); } else if (nativeType == NativeTypeKind.LPStruct && !isField && !isReturn) { return(MarshallerKind.BlittableStructPtr); } else { return(MarshallerKind.Invalid); } } else if (InteropTypes.IsSystemArgIterator(context, type)) { // Don't want to fall through to the blittable/haslayout case return(MarshallerKind.Invalid); } bool isBlittable = MarshalUtils.IsBlittableType(type); // Blittable generics are allowed to be marshalled with the following exceptions: // * ByReference<T>: This represents an interior pointer and is not actually blittable // * Nullable<T>: We don't want to be locked into the default behavior as we may want special handling later // * Vector64<T>: Represents the __m64 ABI primitive which requires currently unimplemented handling // * Vector128<T>: Represents the __m128 ABI primitive which requires currently unimplemented handling // * Vector256<T>: Represents the __m256 ABI primitive which requires currently unimplemented handling // * Vector<T>: Has a variable size (either __m128 or __m256) and isn't readily usable for inteorp scenarios if (type.HasInstantiation && (!isBlittable || InteropTypes.IsSystemByReference(context, type) || InteropTypes.IsSystemNullable(context, type) || InteropTypes.IsSystemRuntimeIntrinsicsVector64T(context, type) || InteropTypes.IsSystemRuntimeIntrinsicsVector128T(context, type) || InteropTypes.IsSystemRuntimeIntrinsicsVector256T(context, type) || InteropTypes.IsSystemNumericsVectorT(context, type))) { // Generic types cannot be marshaled. return(MarshallerKind.Invalid); } if (isBlittable) { if (nativeType != NativeTypeKind.Default && nativeType != NativeTypeKind.Struct) { return(MarshallerKind.Invalid); } return(MarshallerKind.BlittableStruct); } else if (((MetadataType)type).HasLayout()) { if (nativeType != NativeTypeKind.Default && nativeType != NativeTypeKind.Struct) { return(MarshallerKind.Invalid); } return(MarshallerKind.Struct); } else { return(MarshallerKind.Invalid); } } else if (type.IsSzArray) { #if READYTORUN // We don't want the additional test/maintenance cost of this in R2R. if (isByRef) { return(MarshallerKind.Invalid); } #else _ = isByRef; #endif if (nativeType == NativeTypeKind.Default) { nativeType = NativeTypeKind.Array; } switch (nativeType) { case NativeTypeKind.Array: { if (isField || isReturn) { return(MarshallerKind.Invalid); } var arrayType = (ArrayType)type; elementMarshallerKind = GetArrayElementMarshallerKind( arrayType, marshalAs, isAnsi); // 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 elementMarshallerKind == MarshallerKind.Enum || elementMarshallerKind == MarshallerKind.BlittableValue) { return(MarshallerKind.BlittableArray); } else { return(MarshallerKind.Array); } } case NativeTypeKind.ByValArray: // fix sized array { var arrayType = (ArrayType)type; elementMarshallerKind = GetArrayElementMarshallerKind( arrayType, marshalAs, isAnsi); // 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.IsPointer) { #if READYTORUN TypeDesc parameterType = ((PointerType)type).ParameterType; if ((!parameterType.IsEnum && !parameterType.IsPrimitive && !MarshalUtils.IsBlittableType(parameterType)) || parameterType.IsGCPointer) { // Pointers cannot reference marshaled structures. Use ByRef instead. return(MarshallerKind.Invalid); } #else // Do not bother enforcing the above artificial restriction // See https://github.com/dotnet/coreclr/issues/27800 #endif if (nativeType == NativeTypeKind.Default) { return(MarshallerKind.BlittableValue); } else { return(MarshallerKind.Invalid); } } else if (type.IsFunctionPointer) { if (nativeType == NativeTypeKind.Func || nativeType == NativeTypeKind.Default) { return(MarshallerKind.BlittableValue); } else { return(MarshallerKind.Invalid); } } else if (type.IsDelegate) { if (type.HasInstantiation) { // Generic types cannot be marshaled. return(MarshallerKind.Invalid); } if (nativeType == NativeTypeKind.Default || nativeType == NativeTypeKind.Func) { return(MarshallerKind.FunctionPointer); } else { return(MarshallerKind.Invalid); } } else if (type.IsString) { switch (nativeType) { case NativeTypeKind.LPWStr: return(MarshallerKind.UnicodeString); case NativeTypeKind.LPStr: return(MarshallerKind.AnsiString); case NativeTypeKind.LPUTF8Str: return(MarshallerKind.UTF8String); case NativeTypeKind.LPTStr: return(MarshallerKind.UnicodeString); case NativeTypeKind.ByValTStr: if (isAnsi) { elementMarshallerKind = MarshallerKind.AnsiChar; return(MarshallerKind.ByValAnsiString); } else { elementMarshallerKind = MarshallerKind.UnicodeChar; return(MarshallerKind.ByValUnicodeString); } case NativeTypeKind.Default: if (isAnsi) { return(MarshallerKind.AnsiString); } else { return(MarshallerKind.UnicodeString); } default: return(MarshallerKind.Invalid); } } else if (type.IsObject) { if (nativeType == NativeTypeKind.AsAny) { return(isAnsi ? MarshallerKind.AsAnyA : MarshallerKind.AsAnyW); } else { return(MarshallerKind.Invalid); } } else if (InteropTypes.IsStringBuilder(context, type)) { switch (nativeType) { case NativeTypeKind.Default: if (isAnsi) { return(MarshallerKind.AnsiStringBuilder); } else { return(MarshallerKind.UnicodeStringBuilder); } case NativeTypeKind.LPStr: return(MarshallerKind.AnsiStringBuilder); case NativeTypeKind.LPWStr: return(MarshallerKind.UnicodeStringBuilder); default: return(MarshallerKind.Invalid); } } else if (InteropTypes.IsSafeHandle(context, type)) { if (nativeType == NativeTypeKind.Default) { return(MarshallerKind.SafeHandle); } else { return(MarshallerKind.Invalid); } } else if (InteropTypes.IsCriticalHandle(context, type)) { if (nativeType == NativeTypeKind.Default) { return(MarshallerKind.CriticalHandle); } else { return(MarshallerKind.Invalid); } } else if (type is MetadataType mdType && mdType.HasLayout()) { if (type.HasInstantiation) { // Generic types cannot be marshaled. return(MarshallerKind.Invalid); } if (!isField && nativeType == NativeTypeKind.Default || nativeType == NativeTypeKind.LPStruct) { return(MarshallerKind.LayoutClassPtr); } else if (isField && (nativeType == NativeTypeKind.Default || nativeType == NativeTypeKind.Struct)) { return(MarshallerKind.LayoutClass); } else { return(MarshallerKind.Invalid); } }
internal static MarshallerKind GetMarshallerKind( TypeDesc type, MarshalAsDescriptor marshalAs, bool isReturn, bool isAnsi, MarshallerType marshallerType, out MarshallerKind elementMarshallerKind) { elementMarshallerKind = MarshallerKind.Invalid; bool isByRef = false; if (type.IsByRef) { isByRef = true; type = type.GetParameterType(); // Compat note: CLR allows ref returning blittable structs for IJW if (isReturn) { return(MarshallerKind.Invalid); } } TypeSystemContext context = type.Context; NativeTypeKind nativeType = NativeTypeKind.Default; bool isField = marshallerType == MarshallerType.Field; if (marshalAs != null) { nativeType = marshalAs.Type; } // // 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 NativeTypeKind.Default: case NativeTypeKind.Boolean: return(MarshallerKind.Bool); case NativeTypeKind.U1: case NativeTypeKind.I1: return(MarshallerKind.CBool); default: return(MarshallerKind.Invalid); } case TypeFlags.Char: switch (nativeType) { case NativeTypeKind.I1: case NativeTypeKind.U1: return(MarshallerKind.AnsiChar); case NativeTypeKind.I2: case NativeTypeKind.U2: return(MarshallerKind.UnicodeChar); case NativeTypeKind.Default: if (isAnsi) { return(MarshallerKind.AnsiChar); } else { return(MarshallerKind.UnicodeChar); } default: return(MarshallerKind.Invalid); } case TypeFlags.SByte: case TypeFlags.Byte: if (nativeType == NativeTypeKind.I1 || nativeType == NativeTypeKind.U1 || nativeType == NativeTypeKind.Default) { return(MarshallerKind.BlittableValue); } else { return(MarshallerKind.Invalid); } case TypeFlags.Int16: case TypeFlags.UInt16: if (nativeType == NativeTypeKind.I2 || nativeType == NativeTypeKind.U2 || nativeType == NativeTypeKind.Default) { return(MarshallerKind.BlittableValue); } else { return(MarshallerKind.Invalid); } case TypeFlags.Int32: case TypeFlags.UInt32: if (nativeType == NativeTypeKind.I4 || nativeType == NativeTypeKind.U4 || nativeType == NativeTypeKind.Default) { return(MarshallerKind.BlittableValue); } else { return(MarshallerKind.Invalid); } case TypeFlags.Int64: case TypeFlags.UInt64: if (nativeType == NativeTypeKind.I8 || nativeType == NativeTypeKind.U8 || nativeType == NativeTypeKind.Default) { return(MarshallerKind.BlittableValue); } else { return(MarshallerKind.Invalid); } case TypeFlags.IntPtr: case TypeFlags.UIntPtr: if (nativeType == NativeTypeKind.SysInt || nativeType == NativeTypeKind.SysUInt || nativeType == NativeTypeKind.Default) { return(MarshallerKind.BlittableValue); } else { return(MarshallerKind.Invalid); } case TypeFlags.Single: if (nativeType == NativeTypeKind.R4 || nativeType == NativeTypeKind.Default) { return(MarshallerKind.BlittableValue); } else { return(MarshallerKind.Invalid); } case TypeFlags.Double: if (nativeType == NativeTypeKind.R8 || nativeType == NativeTypeKind.Default) { return(MarshallerKind.BlittableValue); } else { return(MarshallerKind.Invalid); } default: return(MarshallerKind.Invalid); } } else if (type.IsValueType) { if (type.IsEnum) { return(MarshallerKind.Enum); } if (InteropTypes.IsSystemDateTime(context, type)) { if (nativeType == NativeTypeKind.Default || nativeType == NativeTypeKind.Struct) { return(MarshallerKind.OleDateTime); } else { return(MarshallerKind.Invalid); } } else if (InteropTypes.IsHandleRef(context, type)) { if (nativeType == NativeTypeKind.Default) { return(MarshallerKind.HandleRef); } else { return(MarshallerKind.Invalid); } } else if (InteropTypes.IsSystemDecimal(context, type)) { if (nativeType == NativeTypeKind.Struct || nativeType == NativeTypeKind.Default) { return(MarshallerKind.Decimal); } else if (nativeType == NativeTypeKind.LPStruct && !isField && !isReturn) { return(MarshallerKind.BlittableStructPtr); } else { return(MarshallerKind.Invalid); } } else if (InteropTypes.IsSystemGuid(context, type)) { if (nativeType == NativeTypeKind.Struct || nativeType == NativeTypeKind.Default) { return(MarshallerKind.BlittableStruct); } else if (nativeType == NativeTypeKind.LPStruct && !isField && !isReturn) { return(MarshallerKind.BlittableStructPtr); } else { return(MarshallerKind.Invalid); } } else if (InteropTypes.IsSystemArgIterator(context, type)) { // Don't want to fall through to the blittable/haslayout case return(MarshallerKind.Invalid); } if (type.HasInstantiation) { // Generic types cannot be marshaled. return(MarshallerKind.Invalid); } if (MarshalUtils.IsBlittableType(type)) { if (nativeType != NativeTypeKind.Default && nativeType != NativeTypeKind.Struct) { return(MarshallerKind.Invalid); } return(MarshallerKind.BlittableStruct); } else if (((MetadataType)type).HasLayout()) { if (nativeType != NativeTypeKind.Default && nativeType != NativeTypeKind.Struct) { return(MarshallerKind.Invalid); } return(MarshallerKind.Struct); } else { return(MarshallerKind.Invalid); } } else if (type.IsSzArray) { #if READYTORUN // We don't want the additional test/maintenance cost of this in R2R. if (isByRef) { return(MarshallerKind.Invalid); } #else _ = isByRef; #endif if (nativeType == NativeTypeKind.Default) { nativeType = NativeTypeKind.Array; } switch (nativeType) { case NativeTypeKind.Array: { if (isField || isReturn) { return(MarshallerKind.Invalid); } var arrayType = (ArrayType)type; elementMarshallerKind = GetArrayElementMarshallerKind( arrayType, marshalAs, isAnsi); // 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 elementMarshallerKind == MarshallerKind.Enum || elementMarshallerKind == MarshallerKind.BlittableValue) { return(MarshallerKind.BlittableArray); } else { return(MarshallerKind.Array); } } case NativeTypeKind.ByValArray: // fix sized array { var arrayType = (ArrayType)type; elementMarshallerKind = GetArrayElementMarshallerKind( arrayType, marshalAs, isAnsi); // 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.IsPointer) { TypeDesc parameterType = ((PointerType)type).ParameterType; if ((!parameterType.IsEnum && !parameterType.IsPrimitive && !MarshalUtils.IsBlittableType(parameterType)) || parameterType.IsGCPointer) { // Pointers cannot reference marshaled structures. Use ByRef instead. return(MarshallerKind.Invalid); } if (nativeType == NativeTypeKind.Default) { return(MarshallerKind.BlittableValue); } else { return(MarshallerKind.Invalid); } } else if (type.IsFunctionPointer) { if (nativeType == NativeTypeKind.Func || nativeType == NativeTypeKind.Default) { return(MarshallerKind.BlittableValue); } else { return(MarshallerKind.Invalid); } } else if (type.IsDelegate) { if (type.HasInstantiation) { // Generic types cannot be marshaled. return(MarshallerKind.Invalid); } if (nativeType == NativeTypeKind.Default || nativeType == NativeTypeKind.Func) { return(MarshallerKind.FunctionPointer); } else { return(MarshallerKind.Invalid); } } else if (type.IsString) { switch (nativeType) { case NativeTypeKind.LPWStr: return(MarshallerKind.UnicodeString); case NativeTypeKind.LPStr: return(MarshallerKind.AnsiString); case NativeTypeKind.LPUTF8Str: return(MarshallerKind.UTF8String); case NativeTypeKind.LPTStr: return(MarshallerKind.UnicodeString); case NativeTypeKind.ByValTStr: if (isAnsi) { elementMarshallerKind = MarshallerKind.AnsiChar; return(MarshallerKind.ByValAnsiString); } else { elementMarshallerKind = MarshallerKind.UnicodeChar; return(MarshallerKind.ByValUnicodeString); } case NativeTypeKind.Default: if (isAnsi) { return(MarshallerKind.AnsiString); } else { return(MarshallerKind.UnicodeString); } default: return(MarshallerKind.Invalid); } } else if (type.IsObject) { if (nativeType == NativeTypeKind.AsAny) { return(isAnsi ? MarshallerKind.AsAnyA : MarshallerKind.AsAnyW); } else { return(MarshallerKind.Invalid); } } else if (InteropTypes.IsStringBuilder(context, type)) { switch (nativeType) { case NativeTypeKind.Default: if (isAnsi) { return(MarshallerKind.AnsiStringBuilder); } else { return(MarshallerKind.UnicodeStringBuilder); } case NativeTypeKind.LPStr: return(MarshallerKind.AnsiStringBuilder); case NativeTypeKind.LPWStr: return(MarshallerKind.UnicodeStringBuilder); default: return(MarshallerKind.Invalid); } } else if (InteropTypes.IsSafeHandle(context, type)) { if (nativeType == NativeTypeKind.Default) { return(MarshallerKind.SafeHandle); } else { return(MarshallerKind.Invalid); } } else if (InteropTypes.IsCriticalHandle(context, type)) { if (nativeType == NativeTypeKind.Default) { return(MarshallerKind.CriticalHandle); } else { return(MarshallerKind.Invalid); } } else if (type is MetadataType mdType && mdType.HasLayout()) { if (type.HasInstantiation) { // Generic types cannot be marshaled. return(MarshallerKind.Invalid); } if (!isField && nativeType == NativeTypeKind.Default || nativeType == NativeTypeKind.LPStruct) { return(MarshallerKind.LayoutClassPtr); } else if (isField && (nativeType == NativeTypeKind.Default || nativeType == NativeTypeKind.Struct)) { return(MarshallerKind.LayoutClass); } else { return(MarshallerKind.Invalid); } }
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); }
internal static MarshallerKind GetMarshallerKind( TypeDesc type, int?parameterIndex, EmbeddedSignatureData[] customModifierData, MarshalAsDescriptor marshalAs, bool isReturn, bool isAnsi, MarshallerType marshallerType, out MarshallerKind elementMarshallerKind) { elementMarshallerKind = MarshallerKind.Invalid; bool isByRef = false; if (type.IsByRef) { isByRef = true; type = type.GetParameterType(); if (!type.IsPrimitive && type.IsValueType && marshallerType != MarshallerType.Field && HasCopyConstructorCustomModifier(parameterIndex, customModifierData)) { return(MarshallerKind.BlittableValueClassWithCopyCtor); } // Compat note: CLR allows ref returning blittable structs for IJW if (isReturn) { return(MarshallerKind.Invalid); } } TypeSystemContext context = type.Context; NativeTypeKind nativeType = NativeTypeKind.Default; bool isField = marshallerType == MarshallerType.Field; if (marshalAs != null) { nativeType = marshalAs.Type; } // // Determine MarshalerKind // if (type.IsPrimitive) { switch (type.Category) { case TypeFlags.Void: return(MarshallerKind.VoidReturn); case TypeFlags.Boolean: switch (nativeType) { case NativeTypeKind.Default: case NativeTypeKind.Boolean: return(MarshallerKind.Bool); case NativeTypeKind.U1: case NativeTypeKind.I1: return(MarshallerKind.CBool); case NativeTypeKind.VariantBool: if (context.Target.IsWindows) { return(MarshallerKind.VariantBool); } else { return(MarshallerKind.Invalid); } default: return(MarshallerKind.Invalid); } case TypeFlags.Char: switch (nativeType) { case NativeTypeKind.I1: case NativeTypeKind.U1: return(MarshallerKind.AnsiChar); case NativeTypeKind.I2: case NativeTypeKind.U2: return(MarshallerKind.UnicodeChar); case NativeTypeKind.Default: if (isAnsi) { return(MarshallerKind.AnsiChar); } else { return(MarshallerKind.UnicodeChar); } default: return(MarshallerKind.Invalid); } case TypeFlags.SByte: case TypeFlags.Byte: if (nativeType == NativeTypeKind.I1 || nativeType == NativeTypeKind.U1 || nativeType == NativeTypeKind.Default) { return(MarshallerKind.BlittableValue); } else { return(MarshallerKind.Invalid); } case TypeFlags.Int16: case TypeFlags.UInt16: if (nativeType == NativeTypeKind.I2 || nativeType == NativeTypeKind.U2 || nativeType == NativeTypeKind.Default) { return(MarshallerKind.BlittableValue); } else { return(MarshallerKind.Invalid); } case TypeFlags.Int32: case TypeFlags.UInt32: if (nativeType == NativeTypeKind.I4 || nativeType == NativeTypeKind.U4 || nativeType == NativeTypeKind.Default) { return(MarshallerKind.BlittableValue); } else { return(MarshallerKind.Invalid); } case TypeFlags.Int64: case TypeFlags.UInt64: if (nativeType == NativeTypeKind.I8 || nativeType == NativeTypeKind.U8 || nativeType == NativeTypeKind.Default) { return(MarshallerKind.BlittableValue); } else { return(MarshallerKind.Invalid); } case TypeFlags.IntPtr: case TypeFlags.UIntPtr: if (nativeType == NativeTypeKind.SysInt || nativeType == NativeTypeKind.SysUInt || nativeType == NativeTypeKind.Default) { return(MarshallerKind.BlittableValue); } else { return(MarshallerKind.Invalid); } case TypeFlags.Single: if (nativeType == NativeTypeKind.R4 || nativeType == NativeTypeKind.Default) { return(MarshallerKind.BlittableValue); } else { return(MarshallerKind.Invalid); } case TypeFlags.Double: if (nativeType == NativeTypeKind.R8 || nativeType == NativeTypeKind.Default) { return(MarshallerKind.BlittableValue); } else { return(MarshallerKind.Invalid); } default: return(MarshallerKind.Invalid); } } else if (type.IsValueType) { if (type.IsEnum) { return(MarshallerKind.Enum); } if (InteropTypes.IsSystemDateTime(context, type)) { if (nativeType == NativeTypeKind.Default || nativeType == NativeTypeKind.Struct) { return(MarshallerKind.OleDateTime); } else { return(MarshallerKind.Invalid); } } else if (InteropTypes.IsHandleRef(context, type)) { if (nativeType == NativeTypeKind.Default) { return(MarshallerKind.HandleRef); } else { return(MarshallerKind.Invalid); } } else if (InteropTypes.IsSystemDecimal(context, type)) { if (nativeType == NativeTypeKind.Struct || nativeType == NativeTypeKind.Default) { return(MarshallerKind.Decimal); } else if (nativeType == NativeTypeKind.LPStruct && !isField) { return(MarshallerKind.BlittableStructPtr); } else if (nativeType == NativeTypeKind.Currency) { return(MarshallerKind.OleCurrency); } else { return(MarshallerKind.Invalid); } } else if (InteropTypes.IsSystemGuid(context, type)) { if (nativeType == NativeTypeKind.Struct || nativeType == NativeTypeKind.Default) { return(MarshallerKind.BlittableStruct); } else if (nativeType == NativeTypeKind.LPStruct && !isField) { return(MarshallerKind.BlittableStructPtr); } else { return(MarshallerKind.Invalid); } } else if (InteropTypes.IsSystemArgIterator(context, type)) { // Don't want to fall through to the blittable/haslayout case return(MarshallerKind.Invalid); } bool isBlittable = MarshalUtils.IsBlittableType(type); // Blittable generics are allowed to be marshalled with the following exceptions: // * ByReference<T>: This represents an interior pointer and is not actually blittable // * Nullable<T>: We don't want to be locked into the default behavior as we may want special handling later // * Vector64<T>: Represents the __m64 ABI primitive which requires currently unimplemented handling // * Vector128<T>: Represents the __m128 ABI primitive which requires currently unimplemented handling // * Vector256<T>: Represents the __m256 ABI primitive which requires currently unimplemented handling // * Vector<T>: Has a variable size (either __m128 or __m256) and isn't readily usable for interop scenarios // We can't block these types for field scenarios for back-compat reasons. if (type.HasInstantiation && !isField && (!isBlittable || InteropTypes.IsSystemByReference(context, type) || InteropTypes.IsSystemSpan(context, type) || InteropTypes.IsSystemReadOnlySpan(context, type) || InteropTypes.IsSystemNullable(context, type) || InteropTypes.IsSystemRuntimeIntrinsicsVector64T(context, type) || InteropTypes.IsSystemRuntimeIntrinsicsVector128T(context, type) || InteropTypes.IsSystemRuntimeIntrinsicsVector256T(context, type) || InteropTypes.IsSystemNumericsVectorT(context, type))) { // Generic types cannot be marshaled. return(MarshallerKind.Invalid); } if (isBlittable) { if (nativeType != NativeTypeKind.Default && nativeType != NativeTypeKind.Struct) { return(MarshallerKind.Invalid); } return(MarshallerKind.BlittableStruct); } else if (((MetadataType)type).HasLayout()) { if (nativeType != NativeTypeKind.Default && nativeType != NativeTypeKind.Struct) { return(MarshallerKind.Invalid); } return(MarshallerKind.Struct); } else { return(MarshallerKind.Invalid); } } else if (type.IsSzArray) { #if READYTORUN // We don't want the additional test/maintenance cost of this in R2R. if (isByRef) { return(MarshallerKind.Invalid); } #else _ = isByRef; #endif if (nativeType == NativeTypeKind.Default) { nativeType = NativeTypeKind.Array; } switch (nativeType) { case NativeTypeKind.Array: { if (isField) { return(MarshallerKind.Invalid); } var arrayType = (ArrayType)type; elementMarshallerKind = GetArrayElementMarshallerKind( arrayType, marshalAs, isAnsi); // 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 elementMarshallerKind == MarshallerKind.Enum || elementMarshallerKind == MarshallerKind.BlittableValue) { return(MarshallerKind.BlittableArray); } else { return(MarshallerKind.Array); } } case NativeTypeKind.ByValArray: // fix sized array { var arrayType = (ArrayType)type; elementMarshallerKind = GetArrayElementMarshallerKind( arrayType, marshalAs, isAnsi); // 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.IsPointer) { if (nativeType == NativeTypeKind.Default) { var pointedAtType = type.GetParameterType(); if (!pointedAtType.IsPrimitive && !type.IsEnum && marshallerType != MarshallerType.Field && HasCopyConstructorCustomModifier(parameterIndex, customModifierData)) { return(MarshallerKind.BlittableValueClassWithCopyCtor); } return(MarshallerKind.BlittableValue); } else { return(MarshallerKind.Invalid); } } else if (type.IsFunctionPointer) { if (nativeType == NativeTypeKind.Func || nativeType == NativeTypeKind.Default) { return(MarshallerKind.BlittableValue); } else { return(MarshallerKind.Invalid); } } else if (type.IsDelegate) { if (type.HasInstantiation) { // Generic types cannot be marshaled. return(MarshallerKind.Invalid); } if (nativeType == NativeTypeKind.Default || nativeType == NativeTypeKind.Func) { return(MarshallerKind.FunctionPointer); } else { return(MarshallerKind.Invalid); } } else if (type.IsString) { switch (nativeType) { case NativeTypeKind.LPWStr: return(MarshallerKind.UnicodeString); case NativeTypeKind.LPStr: return(MarshallerKind.AnsiString); case NativeTypeKind.LPUTF8Str: return(MarshallerKind.UTF8String); case NativeTypeKind.LPTStr: return(MarshallerKind.UnicodeString); case NativeTypeKind.ByValTStr: if (isAnsi) { elementMarshallerKind = MarshallerKind.AnsiChar; return(MarshallerKind.ByValAnsiString); } else { elementMarshallerKind = MarshallerKind.UnicodeChar; return(MarshallerKind.ByValUnicodeString); } case NativeTypeKind.TBStr: case NativeTypeKind.BStr: return(MarshallerKind.BSTRString); case NativeTypeKind.AnsiBStr: return(MarshallerKind.AnsiBSTRString); case NativeTypeKind.Default: if (isAnsi) { return(MarshallerKind.AnsiString); } else { return(MarshallerKind.UnicodeString); } default: return(MarshallerKind.Invalid); } } else if (type.IsObject) { if (nativeType == NativeTypeKind.AsAny) { return(isAnsi ? MarshallerKind.AsAnyA : MarshallerKind.AsAnyW); } else if (context.Target.IsWindows) { if ((isField && nativeType == NativeTypeKind.Default) || nativeType == NativeTypeKind.Intf || nativeType == NativeTypeKind.IUnknown) { return(MarshallerKind.ComInterface); } else { return(MarshallerKind.Variant); } } else { return(MarshallerKind.Invalid); } } else if (InteropTypes.IsStringBuilder(context, type)) { switch (nativeType) { case NativeTypeKind.Default: if (isAnsi) { return(MarshallerKind.AnsiStringBuilder); } else { return(MarshallerKind.UnicodeStringBuilder); } case NativeTypeKind.LPStr: return(MarshallerKind.AnsiStringBuilder); case NativeTypeKind.LPWStr: return(MarshallerKind.UnicodeStringBuilder); default: return(MarshallerKind.Invalid); } } else if (InteropTypes.IsSafeHandle(context, type)) { if (nativeType == NativeTypeKind.Default) { return(MarshallerKind.SafeHandle); } else { return(MarshallerKind.Invalid); } } else if (InteropTypes.IsCriticalHandle(context, type)) { if (nativeType == NativeTypeKind.Default) { return(MarshallerKind.CriticalHandle); } else { return(MarshallerKind.Invalid); } } else if (type is MetadataType mdType && mdType.HasLayout()) { if (type.HasInstantiation) { // Generic types cannot be marshaled. return(MarshallerKind.Invalid); } if (!isField && nativeType == NativeTypeKind.Default || nativeType == NativeTypeKind.LPStruct) { return(MarshallerKind.LayoutClassPtr); } else if (isField && (nativeType == NativeTypeKind.Default || nativeType == NativeTypeKind.Struct)) { return(MarshallerKind.LayoutClass); } else { return(MarshallerKind.Invalid); } }
internal static TypeDesc GetNativeTypeFromMarshallerKind(TypeDesc type, MarshallerKind kind, MarshallerKind elementMarshallerKind, #if !READYTORUN InteropStateManager interopStateManager, #endif MarshalAsDescriptor marshalAs, bool isArrayElement = false) { TypeSystemContext context = type.Context; NativeTypeKind nativeType = NativeTypeKind.Default; if (marshalAs != null) { nativeType = isArrayElement ? marshalAs.ArraySubType : marshalAs.Type; } switch (kind) { case MarshallerKind.BlittableValue: { switch (nativeType) { case NativeTypeKind.I1: return(context.GetWellKnownType(WellKnownType.SByte)); case NativeTypeKind.U1: return(context.GetWellKnownType(WellKnownType.Byte)); case NativeTypeKind.I2: return(context.GetWellKnownType(WellKnownType.Int16)); case NativeTypeKind.U2: return(context.GetWellKnownType(WellKnownType.UInt16)); case NativeTypeKind.I4: return(context.GetWellKnownType(WellKnownType.Int32)); case NativeTypeKind.U4: return(context.GetWellKnownType(WellKnownType.UInt32)); case NativeTypeKind.I8: return(context.GetWellKnownType(WellKnownType.Int64)); case NativeTypeKind.U8: return(context.GetWellKnownType(WellKnownType.UInt64)); case NativeTypeKind.R4: return(context.GetWellKnownType(WellKnownType.Single)); case NativeTypeKind.R8: return(context.GetWellKnownType(WellKnownType.Double)); default: return(type.UnderlyingType); } } case MarshallerKind.Bool: return(context.GetWellKnownType(WellKnownType.Int32)); case MarshallerKind.CBool: return(context.GetWellKnownType(WellKnownType.Byte)); case MarshallerKind.VariantBool: return(context.GetWellKnownType(WellKnownType.Int16)); case MarshallerKind.Enum: case MarshallerKind.BlittableStruct: case MarshallerKind.Decimal: case MarshallerKind.VoidReturn: return(type); #if !READYTORUN case MarshallerKind.Struct: case MarshallerKind.LayoutClass: Debug.Assert(interopStateManager is not null, "An InteropStateManager is required to look up the native representation of a non-blittable struct or class with layout."); return(interopStateManager.GetStructMarshallingNativeType((MetadataType)type)); #endif case MarshallerKind.BlittableStructPtr: return(type.MakePointerType()); case MarshallerKind.HandleRef: return(context.GetWellKnownType(WellKnownType.IntPtr)); case MarshallerKind.UnicodeChar: if (nativeType == NativeTypeKind.U2) { return(context.GetWellKnownType(WellKnownType.UInt16)); } else { return(context.GetWellKnownType(WellKnownType.Int16)); } case MarshallerKind.OleDateTime: return(context.GetWellKnownType(WellKnownType.Double)); case MarshallerKind.FailedTypeLoad: return(context.GetWellKnownType(WellKnownType.IntPtr)); case MarshallerKind.SafeHandle: case MarshallerKind.CriticalHandle: return(context.GetWellKnownType(WellKnownType.IntPtr)); case MarshallerKind.BSTRString: case MarshallerKind.UnicodeString: case MarshallerKind.UnicodeStringBuilder: return(context.GetWellKnownType(WellKnownType.Char).MakePointerType()); case MarshallerKind.AnsiBSTRString: case MarshallerKind.AnsiString: case MarshallerKind.AnsiStringBuilder: case MarshallerKind.UTF8String: return(context.GetWellKnownType(WellKnownType.Byte).MakePointerType()); case MarshallerKind.BlittableArray: case MarshallerKind.Array: case MarshallerKind.AnsiCharArray: { ArrayType arrayType = type as ArrayType; Debug.Assert(arrayType != null, "Expecting array"); // // We need to construct the unsafe array from the right unsafe array element type // TypeDesc elementNativeType = GetNativeTypeFromMarshallerKind( arrayType.ElementType, elementMarshallerKind, MarshallerKind.Unknown, #if !READYTORUN interopStateManager, #endif marshalAs, isArrayElement: true); return(elementNativeType.MakePointerType()); } case MarshallerKind.AnsiChar: return(context.GetWellKnownType(WellKnownType.Byte)); case MarshallerKind.FunctionPointer: return(context.GetWellKnownType(WellKnownType.IntPtr)); #if !READYTORUN case MarshallerKind.ByValUnicodeString: case MarshallerKind.ByValAnsiString: { var inlineArrayCandidate = GetInlineArrayCandidate(context.GetWellKnownType(WellKnownType.Char), elementMarshallerKind, interopStateManager, marshalAs); return(interopStateManager.GetInlineArrayType(inlineArrayCandidate)); } case MarshallerKind.ByValAnsiCharArray: case MarshallerKind.ByValArray: { ArrayType arrayType = type as ArrayType; Debug.Assert(arrayType != null, "Expecting array"); var inlineArrayCandidate = GetInlineArrayCandidate(arrayType.ElementType, elementMarshallerKind, interopStateManager, marshalAs); return(interopStateManager.GetInlineArrayType(inlineArrayCandidate)); } #endif case MarshallerKind.LayoutClassPtr: case MarshallerKind.AsAnyA: case MarshallerKind.AsAnyW: return(context.GetWellKnownType(WellKnownType.IntPtr)); case MarshallerKind.ComInterface: return(context.GetWellKnownType(WellKnownType.IntPtr)); #if !READYTORUN case MarshallerKind.Variant: return(InteropTypes.GetVariant(context)); case MarshallerKind.CustomMarshaler: return(context.GetWellKnownType(WellKnownType.IntPtr)); #endif case MarshallerKind.OleCurrency: return(context.GetWellKnownType(WellKnownType.Int64)); case MarshallerKind.Unknown: default: throw new NotSupportedException(); } }
internal static InlineArrayCandidate GetInlineArrayCandidate(TypeDesc managedElementType, MarshallerKind elementMarshallerKind, InteropStateManager interopStateManager, MarshalAsDescriptor marshalAs) { var elementNativeType = (MetadataType)GetNativeTypeFromMarshallerKind( managedElementType, elementMarshallerKind, MarshallerKind.Unknown, interopStateManager, null); Debug.Assert(marshalAs.SizeConst.HasValue); // if SizeConst is not specified, we will default to 1. // the marshaller will throw appropriate exception uint size = 1; if (marshalAs.SizeConst.HasValue) { size = marshalAs.SizeConst.Value; } return(new InlineArrayCandidate(elementNativeType, size)); }