Пример #1
0
        protected override TypeDesc MarshalArgument(TypeDesc managedType, ILEmitter emitter, ILCodeStream marshallingCodeStream, ILCodeStream unmarshallingCodeStream)
        {
            TypeSystemContext context = PInvokeMethodData.Context;

            if (PInvokeMethodData.GetCharSet() == PInvokeAttributes.CharSetUnicode)
            {
                // TODO: Handles [out] marshalling only for now

                var stringBuilderType = context.SystemModule.GetKnownType("System.Text", "StringBuilder");
                var charArrayType     = context.GetWellKnownType(WellKnownType.Char).MakeArrayType();

                IL.Stubs.ILLocalVariable vStringBuilder = emitter.NewLocal(stringBuilderType);
                IL.Stubs.ILLocalVariable vBuffer        = emitter.NewLocal(charArrayType);

                marshallingCodeStream.EmitStLoc(vStringBuilder);

                marshallingCodeStream.EmitLdLoc(vStringBuilder);
                marshallingCodeStream.Emit(ILOpcode.call, emitter.NewToken(
                                               context.GetHelperEntryPoint("InteropHelpers", "GetEmptyStringBuilderBuffer")));
                marshallingCodeStream.EmitStLoc(vBuffer);

                unmarshallingCodeStream.EmitLdLoc(vStringBuilder);
                unmarshallingCodeStream.EmitLdLoc(vBuffer);
                unmarshallingCodeStream.Emit(ILOpcode.call, emitter.NewToken(
                                                 context.GetHelperEntryPoint("InteropHelpers", "ReplaceStringBuilderBuffer")));

                marshallingCodeStream.EmitLdLoc(vBuffer);
                return(base.MarshalArgument(charArrayType, emitter, marshallingCodeStream, unmarshallingCodeStream));
            }
            else
            {
                throw new NotSupportedException();
            }
        }
Пример #2
0
        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));
            }
        }
Пример #3
0
        /// <summary>
        /// Create a marshaller
        /// </summary>
        /// <param name="parameterType">type of the parameter to marshal</param>
        /// <param name="pInvokeMethodData">PInvoke Method specific marshal data</param>
        /// <param name="pInvokeParameterdata">PInvoke parameter specific marshal data</param>
        /// <returns>The  created Marshaller</returns>
        public static Marshaller CreateMarshaller(TypeDesc parameterType, PInvokeMethodData pInvokeMethodData, ParameterMetadata pInvokeParameterdata)
        {
            MarshallerKind marshallerKind = GetMarshallerKind(parameterType, pInvokeParameterdata.MarshalAsDescriptor, pInvokeMethodData, pInvokeParameterdata.Return);

            // Create the marshaller based on MarshallerKind
            Marshaller marshaller = Marshaller.CreateMarshallerInternal(marshallerKind);

            marshaller.PInvokeMethodData        = pInvokeMethodData;
            marshaller.PInvokeParameterMetadata = pInvokeParameterdata;
            marshaller.MarshallerKind           = marshallerKind;
            marshaller.NativeType  = null;
            marshaller.ManagedType = parameterType;

            return(marshaller);
        }
Пример #4
0
        /// <summary>
        /// Create a marshaller
        /// </summary>
        /// <param name="parameterType">type of the parameter to marshal</param>
        /// <param name="pInvokeMethodData">PInvoke Method specific marshal data</param>
        /// <param name="pInvokeParameterdata">PInvoke parameter specific marshal data</param>
        /// <returns>The  created Marshaller</returns>
        public static Marshaller CreateMarshaller(TypeDesc parameterType, PInvokeMethodData pInvokeMethodData, ParameterMetadata pInvokeParameterdata)
        {
            MarshallerKind marshallerKind = GetMarshallerKind(parameterType,
                                                              pInvokeParameterdata,
                                                              pInvokeMethodData,
                                                              isField: false);

            // Create the marshaller based on MarshallerKind
            Marshaller marshaller = Marshaller.CreateMarshallerInternal(marshallerKind);

            marshaller.PInvokeMethodData        = pInvokeMethodData;
            marshaller.PInvokeParameterMetadata = pInvokeParameterdata;
            marshaller.MarshallerKind           = marshallerKind;
            marshaller.NativeParameterType      = null;
            marshaller.ManagedParameterType     = parameterType;
            marshaller.Optional = pInvokeParameterdata.Optional;
            marshaller.Return   = pInvokeParameterdata.Return;
            marshaller.IsByRef  = parameterType.IsByRef;
            marshaller.In       = pInvokeParameterdata.In;
            //
            // Desktop ignores [Out] on marshaling scenarios where they don't make sense (such as passing
            // value types and string as [out] without byref).
            //
            if (parameterType.IsByRef)
            {
                // Passing as [Out] by ref is valid
                marshaller.Out = pInvokeParameterdata.Out;
            }
            else
            {
                // Passing as [Out] is valid only if it is not ValueType nor string
                if (!parameterType.IsValueType && !parameterType.IsString)
                {
                    marshaller.Out = pInvokeParameterdata.Out;
                }
            }

            if (!marshaller.In && !marshaller.Out)
            {
                //
                // Rules for in/out
                // 1. ByRef args: [in]/[out] implied by default
                // 2. StringBuilder: [in, out] by default
                // 3. non-ByRef args: [In] is implied if no [In]/[Out] is specified
                //
                if (parameterType.IsByRef)
                {
                    marshaller.In  = true;
                    marshaller.Out = true;
                }
                else if (pInvokeMethodData.IsStringBuilder(parameterType))
                {
                    marshaller.In  = true;
                    marshaller.Out = true;
                }
                else
                {
                    marshaller.In = true;
                }
            }
            return(marshaller);
        }
Пример #5
0
        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);
        }
Пример #6
0
        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);
        }
Пример #7
0
        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();
        }