public JitAction( CallingConvention callingConvention = CallingConvention.Default, FunctionHints hints = FunctionHints.None, CodeGenerator codeGenerator = null) : base(callingConvention, hints, codeGenerator) { }
internal static string ToString(CallingConvention flags) { var sb = new StringBuilder(); switch (flags & CallingConvention.Mask) { case CallingConvention.Default: sb.Append("Default"); break; case CallingConvention.C: sb.Append("C"); break; case CallingConvention.StdCall: sb.Append("StdCall"); break; case CallingConvention.ThisCall: sb.Append("ThisCall"); break; case CallingConvention.FastCall: sb.Append("FastCall"); break; case CallingConvention.VarArg: sb.Append("VarArg"); break; case CallingConvention.Field: sb.Append("Field"); break; case CallingConvention.LocalSig: sb.Append("LocalSig"); break; case CallingConvention.Property: sb.Append("Property"); break; case CallingConvention.Unmanaged: sb.Append("Unmanaged"); break; case CallingConvention.GenericInst: sb.Append("GenericInst"); break; case CallingConvention.NativeVarArg: sb.Append("NativeVarArg"); break; default: sb.Append(string.Format("CC_UNKNOWN_0x{0:X}", (int)(flags & CallingConvention.Mask))); break; } if ((flags & CallingConvention.Generic) != 0) sb.Append(" | Generic"); if ((flags & CallingConvention.HasThis) != 0) sb.Append(" | HasThis"); if ((flags & CallingConvention.ExplicitThis) != 0) sb.Append(" | ExplicitThis"); if ((flags & CallingConvention.ReservedByCLR) != 0) sb.Append(" | ReservedByCLR"); return sb.ToString(); }
internal UnmanagedCalliDescriptor(CallingConvention unmanagedCallConv, Type returnType, Type[] parameterTypes) : base() { this.Value = string.Format(CultureInfo.CurrentCulture, "unmanaged {0} {1}({2})", unmanagedCallConv.ToString().ToLower(CultureInfo.CurrentCulture), new TypeDescriptor(returnType).Value, string.Join(", ", CalliDescriptor.GetArguments(parameterTypes).ToArray())); }
internal __StandAloneMethodSig(bool unmanaged, CallingConvention unmanagedCallingConvention, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, Type[] optionalParameterTypes) { this.unmanaged = unmanaged; this.unmanagedCallingConvention = unmanagedCallingConvention; this.callingConvention = callingConvention; this.returnType = returnType; this.parameterTypes = parameterTypes; this.optionalParameterTypes = optionalParameterTypes; }
private SignatureHelper(Module mod, IntPtr context, IntPtr sig) { this.mod = mod; this.context = context; this.sig = sig; this.numArgs = 0; this.callConv = (CallingConvention)0; this.field = false; this.bytesOffset = -1; ((ModuleBuilder)mod).assembly.AddDetach(this); }
public CompilerFunctionCall(Compiler compiler, CompilerFunction caller, Operand target, CallingConvention callingConvention, VariableType[] arguments, VariableType returnValue) : base(compiler) { Contract.Requires(arguments != null); _caller = caller; _target = target; _functionPrototype = new FunctionDeclaration(callingConvention, arguments, returnValue); if (arguments != null && arguments.Length > 0) _args = new Operand[arguments.Length]; }
internal FunctionDeclaration(CallingConvention callingConvention, VariableType[] arguments, VariableType returnValue) { Contract.Requires(arguments != null); if (callingConvention == CallingConvention.Default) callingConvention = CallingConventionInfo.DefaultCallingConvention; _callingConvention = callingConvention; if (arguments.Length > 32) throw new ArgumentException(); SetPrototype(arguments, returnValue); }
public CompilerFunctionCall(Compiler compiler, CompilerFunction caller, Operand target, CallingConvention callingConvention, Type delegateType) : base(compiler) { Contract.Requires(compiler != null); Contract.Requires(caller != null); _caller = caller; _target = target; _functionPrototype = new FunctionDeclaration(callingConvention, delegateType); if (_functionPrototype.Arguments != null && _functionPrototype.Arguments.Length > 0) _args = new Operand[_functionPrototype.Arguments.Length]; }
public static object DynamicDllFunctionInvoke( string dllPath, string entryPoint, MethodAttributes methodAttr, CallingConvention nativeCallConv, CharSet nativeCharSet, Type returnType, Type[] parameterTypes, object[] parameterValues ) { string dllName = Path.GetFileNameWithoutExtension(dllPath); // ����һ����̬����(assembly)��ģ��(module) AssemblyName assemblyName = new AssemblyName(); assemblyName.Name = string.Format("A{0}{1}", dllName, Guid.NewGuid().ToString( "N" ) ); AssemblyBuilder dynamicAssembly = AppDomain.CurrentDomain.DefineDynamicAssembly( assemblyName, AssemblyBuilderAccess.Run); ModuleBuilder dynamicModule = dynamicAssembly.DefineDynamicModule( string.Format("M{0}{1}", dllName, Guid.NewGuid().ToString("N")) ); // ʹ��ָ������Ϣ����ƽ̨����ǩ�� MethodBuilder dynamicMethod = dynamicModule.DefinePInvokeMethod( entryPoint, dllPath, methodAttr, CallingConventions.Standard, returnType, parameterTypes, nativeCallConv, nativeCharSet ); // �������� dynamicModule.CreateGlobalFunctions(); // ���ƽ̨���õķ��� MethodInfo methodInfo = dynamicModule.GetMethod(entryPoint, parameterTypes); // ���÷��йܺ�������÷��صĽ�� object result = methodInfo.Invoke(null, parameterValues); return result; }
public unsafe MethodDesc(string name, string dll, string entryPoint, FUNCDESC funcdesc, string[] argumentNames, Func<uint, TypeDesc> typeFactory) { string tmpl = "___overloaded000"; if ((name.Length > tmpl.Length) && (name.IndexOf("___overloaded") == (name.Length - tmpl.Length))) name = name.Substring(0, name.Length - tmpl.Length); Name = EscapMethodName(name); Dll = dll; EntryPoint = entryPoint; Offset = funcdesc.oVft; ReturnValue = new ParameterDesc(funcdesc.elemdescFunc, string.Empty, typeFactory, 0, false, null); List<ParameterDesc> parameters = new List<ParameterDesc>(); for (int i = 0; i < funcdesc.cParams; i++) parameters.Add(new ParameterDesc(funcdesc.lprgelemdescParam[i], (i < argumentNames.Length) ? argumentNames[i] : "__arg" + i, typeFactory, 0, false, null)); Parameters = parameters.AsReadOnly(); //if (funcdesc.cParamsOpt != 0) // throw new Exception("Variable number of optional parameters is not supported"); //if (funcdesc.invkind != INVOKEKIND.INVOKE_FUNC) // throw new Exception("Only functions are currently supported"); if (funcdesc.cScodes >= 1) throw new Exception("Only one return value is supported"); switch (funcdesc.callconv) { case System.Runtime.InteropServices.ComTypes.CALLCONV.CC_CDECL: Convention = CallingConvention.Cdecl; break; case System.Runtime.InteropServices.ComTypes.CALLCONV.CC_STDCALL: Convention = CallingConvention.StdCall; break; default: throw new Exception("Calling convention " + funcdesc.callconv + " is not supported"); } switch (funcdesc.funckind) { case FUNCKIND.FUNC_DISPATCH: case FUNCKIND.FUNC_VIRTUAL: case FUNCKIND.FUNC_PUREVIRTUAL: case FUNCKIND.FUNC_NONVIRTUAL: case FUNCKIND.FUNC_STATIC: break; default: throw new Exception("Function kind " + funcdesc.funckind + " is not supported"); } }
public MethodSignature( bool hasThis, bool explicitThis, CallingConvention callingConvention, int genericParamCount, IReadOnlyList<Parameter> parameters, Type retType ) { m_hasThis = hasThis; m_explicitThis = explicitThis; m_callingConvention = callingConvention.CheckDefined("callingConvention"); m_genericParamCount = genericParamCount.CheckGTE(0, "genericParamCount"); m_parameters = parameters.CheckNotNull("parameters"); m_retType = retType.CheckNotNull("retType"); }
internal FunctionDeclaration(CallingConvention callingConvention, Type delegateType) { if (delegateType == null) throw new ArgumentNullException("delegateType"); if (callingConvention == CallingConvention.Default) callingConvention = CallingConventionInfo.DefaultCallingConvention; _callingConvention = callingConvention; if (delegateType == typeof(Action)) { SetPrototype(new VariableType[0], VariableType.Invalid); } else { if (!delegateType.IsGenericType) throw new ArgumentException(); VariableType[] arguments = null; VariableType returnValue = VariableType.Invalid; Type genericType = delegateType.GetGenericTypeDefinition(); if (genericType.FullName.StartsWith("System.Action`")) { arguments = Array.ConvertAll(delegateType.GetGenericArguments(), Compiler.TypeToId); } else if (genericType.FullName.StartsWith("System.Func`")) { Type[] typeArguments = delegateType.GetGenericArguments(); returnValue = Compiler.TypeToId(typeArguments[typeArguments.Length - 1]); Array.Resize(ref typeArguments, typeArguments.Length - 1); arguments = Array.ConvertAll(typeArguments, Compiler.TypeToId); } else { throw new ArgumentException(); } SetPrototype(arguments, returnValue); } }
public DLLExportAttribute(string exportName,CallingConvention callingConvention) { ExportName = exportName; switch(callingConvention) { case CallingConvention.Winapi: case CallingConvention.StdCall: Convention = typeof(CallConvStdcall).FullName; break; case CallingConvention.FastCall: Convention = typeof(CallConvFastcall).FullName; break; case CallingConvention.ThisCall: Convention = typeof(CallConvThiscall).FullName; break; case CallingConvention.Cdecl: Convention = typeof(CallConvCdecl).FullName; break; default: throw new NotImplementedException(); } }
public MethodBuilder DefinePInvokeMethod(string name, string dllName, string entryName, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] returnTypeRequiredCustomModifiers, Type[] returnTypeOptionalCustomModifiers, Type[] parameterTypes, Type[][] parameterTypeRequiredCustomModifiers, Type[][] parameterTypeOptionalCustomModifiers, CallingConvention nativeCallConv, CharSet nativeCharSet) { MethodBuilder mb = DefineMethod(name, attributes | MethodAttributes.PinvokeImpl, callingConvention, returnType, returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, parameterTypes, parameterTypeRequiredCustomModifiers, parameterTypeOptionalCustomModifiers); mb.SetDllImportPseudoCustomAttribute(dllName, entryName, nativeCallConv, nativeCharSet, null, null, null, null, null); return mb; }
public UnmanagedFunctionPointerAttribute(CallingConvention callingConvention) { m_callingConvention = callingConvention; }
public static void EmitCalli(ILGenerator il, OpCode opcode, CallingConvention unmanagedCallConv, Type returnType, Type[] parameterTypes) { il.EmitCalli(opcode, unmanagedCallConv, returnType, parameterTypes); }
internal static MethodImportAttributes MakeFlags(bool exactSpelling, CharSet charSet, bool setLastError, CallingConvention callingConvention, bool?useBestFit, bool?throwOnUnmappable) { MethodImportAttributes result = 0; if (exactSpelling) { result |= MethodImportAttributes.ExactSpelling; } switch (charSet) { case CharSet.Ansi: result |= MethodImportAttributes.CharSetAnsi; break; case CharSet.Unicode: result |= MethodImportAttributes.CharSetUnicode; break; case Cci.Constants.CharSet_Auto: result |= MethodImportAttributes.CharSetAuto; break; // Dev10: use default without reporting an error } if (setLastError) { result |= MethodImportAttributes.SetLastError; } switch (callingConvention) { default: // Dev10: uses default without reporting an error result |= MethodImportAttributes.CallingConventionWinApi; break; case CallingConvention.Cdecl: result |= MethodImportAttributes.CallingConventionCDecl; break; case CallingConvention.StdCall: result |= MethodImportAttributes.CallingConventionStdCall; break; case CallingConvention.ThisCall: result |= MethodImportAttributes.CallingConventionThisCall; break; case Cci.Constants.CallingConvention_FastCall: result |= MethodImportAttributes.CallingConventionFastCall; break; } if (throwOnUnmappable.HasValue) { if (throwOnUnmappable.Value) { result |= MethodImportAttributes.ThrowOnUnmappableCharEnable; } else { result |= MethodImportAttributes.ThrowOnUnmappableCharDisable; } } if (useBestFit.HasValue) { if (useBestFit.Value) { result |= MethodImportAttributes.BestFitMappingEnable; } else { result |= MethodImportAttributes.BestFitMappingDisable; } } return(result); }
[DllImport(libraryPath, EntryPoint = "JSValueGetType", CallingConvention = CallingConvention.Cdecl)]
public override CallingConvention GetCallingConvention(string ccName) { switch (Architecture.Name) { case "mips-be-32": case "mips-le-32": case "mips-be-64": case "mips-le-64": return(new MipsCallingConvention(Architecture)); //$ ccName? case "ppc-be-32": case "ppc-le-32": return(new PowerPcCallingConvention(Architecture)); case "sparc32": return(new SparcCallingConvention(Architecture)); case "x86-protected-32": if (this.ccX86 == null) { var t = Type.GetType("Reko.Arch.X86.X86CallingConvention,Reko.Arch.X86", true); this.ccX86 = (CallingConvention)Activator.CreateInstance( t, 4, // retAddressOnStack, 4, // stackAlignment, 4, // pointerSize, true, // callerCleanup, false); // reverseArguments) } return(this.ccX86); case "x86-protected-64": return(new X86_64CallingConvention(Architecture)); case "xtensa": return(new XtensaCallingConvention(Architecture)); case "arm": return(new Arm32CallingConvention(Architecture)); case "arm-64": return(new Arm64CallingConvention(Architecture)); case "m68k": return(new M68kCallingConvention(Architecture)); case "avr8": return(new Avr8CallingConvention(Architecture)); case "msp430": return(new Msp430CallingConvention(Architecture)); case "risc-v": if (this.ccRiscV == null) { var t = Type.GetType("Reko.Arch.RiscV.RiscVCallingConvention,Reko.Arch.RiscV", true); this.ccRiscV = (CallingConvention)Activator.CreateInstance(t, Architecture); } return(this.ccRiscV); case "superH-le": case "superH-be": return(new SuperHCallingConvention(Architecture)); case "alpha": return(new AlphaCallingConvention(Architecture)); case "zSeries": return(new zSeriesCallingConvention(Architecture)); case "blackfin": return(new BlackfinCallingConvention(Architecture)); default: throw new NotImplementedException(string.Format("ELF calling convention for {0} not implemented yet.", Architecture.Description)); } }
/// <summary> /// Constructor /// </summary> /// <param name="callingConvention">Calling convention</param> /// <param name="genParamCount">Number of generic parameters</param> public MethodSig(CallingConvention callingConvention, uint genParamCount) { this.callingConvention = callingConvention; this.genParamCount = genParamCount; this.parameters = ThreadSafeListCreator.Create <TypeSig>(); }
/// <summary> /// Constructor /// </summary> /// <param name="callingConvention">Calling convention (must have Property set)</param> internal PropertySig(CallingConvention callingConvention) { this.callingConvention = callingConvention; this.parameters = ThreadSafeListCreator.Create <TypeSig>(); }
/// <summary> /// Constructor /// </summary> /// <param name="type">Field type</param> /// <param name="callingConvention">The calling convention (must have Field set)</param> internal FieldSig(CallingConvention callingConvention, TypeSig type) { this.callingConvention = callingConvention; this.type = type; }
/// <summary> /// Constructor /// </summary> /// <param name="callingConvention">Calling convention</param> public MethodSig(CallingConvention callingConvention) { this.callingConvention = callingConvention; this.parameters = ThreadSafeListCreator.Create <TypeSig>(); }
/// <summary> /// Constructor /// </summary> /// <param name="callingConvention">The calling convention</param> protected CallingConventionSig(CallingConvention callingConvention) { this.callingConvention = callingConvention; }
/// <summary> /// Constructor /// </summary> /// <param name="callingConvention">Calling convention (must have GenericInst set)</param> /// <param name="size">Number of generic args</param> internal GenericInstMethodSig(CallingConvention callingConvention, uint size) { this.callingConvention = callingConvention; this.genericArgs = ThreadSafeListCreator.Create <TypeSig>((int)size); }
internal UnmanagedFunctionPointerAttribute(CallingConvention callingConventionType) { _callingConvention = callingConventionType.ToString(); }
[System.Security.SecurityCritical] // auto-generated #endif private MethodBuilder DefinePInvokeMethodNoLock(String name, String dllName, String entryName, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, CallingConvention nativeCallConv, CharSet nativeCharSet) { //Global methods must be static. if ((attributes & MethodAttributes.Static) == 0) { throw new ArgumentException(Environment.GetResourceString("Argument_GlobalFunctionHasToBeStatic")); } Contract.Ensures(Contract.Result<MethodBuilder>() != null); Contract.EndContractBlock(); CheckContext(returnType); CheckContext(parameterTypes); m_moduleData.m_fHasGlobal = true; return m_moduleData.m_globalTypeBuilder.DefinePInvokeMethod(name, dllName, entryName, attributes, callingConvention, returnType, parameterTypes, nativeCallConv, nativeCharSet); }
public MethodBuilder DefinePInvokeMethod(string name, string dllName, string entryName, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, CallingConvention nativeCallConv, CharSet nativeCharSet) { if (name == null) { throw new ArgumentNullException("name"); } if ((attributes & MethodAttributes.Static) == 0) { throw new ArgumentException("global methods must be static"); } if (global_type_created != null) { throw new InvalidOperationException("global methods already created"); } CreateGlobalType(); MethodBuilder mb = global_type.DefinePInvokeMethod(name, dllName, entryName, attributes, callingConvention, returnType, parameterTypes, nativeCallConv, nativeCharSet); addGlobalMethod(mb); return(mb); }
public virtual void EmitCalli(OpCode opcode, CallingConvention unmanagedCallConv, Type returnType, Type[] parameterTypes) { int stackchange = 0; int cParams = 0; int i; SignatureHelper sig; ModuleBuilder modBuilder = (ModuleBuilder) m_methodBuilder.Module; if (parameterTypes != null) { cParams = parameterTypes.Length; } sig = SignatureHelper.GetMethodSigHelper( modBuilder, unmanagedCallConv, returnType); if (parameterTypes != null) { for (i = 0; i < cParams; i++) { sig.AddArgument(parameterTypes[i]); } } // If there is a non-void return type, push one. if (returnType != typeof(void)) stackchange++; // Pop off arguments if any. if (parameterTypes != null) stackchange -= cParams; // Pop the native function pointer. stackchange--; UpdateStackSize(OpCodes.Calli, stackchange); EnsureCapacity(7); Emit(OpCodes.Calli); RecordTokenFixup(); PutInteger4(modBuilder.GetSignatureToken(sig).Token); }
public static SignatureHelper GetMethodSigHelper(CallingConvention unmanagedCallingConvention, Type returnType) { return(GetMethodSigHelper(null, unmanagedCallingConvention, returnType)); }
public MethodBuilder DefinePInvokeMethod(string name, string dllName, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, CallingConvention nativeCallConv, CharSet nativeCharSet) { return(DefinePInvokeMethod(name, dllName, name, attributes, callingConvention, returnType, parameterTypes, nativeCallConv, nativeCharSet)); }
/// <summary> /// Creates a method for calling with the specified signature. The returned method has a signature /// of the form: /// /// (IntPtr funcAddress, arg0, arg1, ..., object[] constantPool) /// /// where IntPtr is the address of the function to be called. The arguments types are based upon /// the types that the ArgumentMarshaller requires. /// </summary> private static MethodInfo /*!*/ CreateInteropInvoker(CallingConvention convention, ArgumentMarshaller /*!*/[] /*!*/ sig, INativeType nativeRetType, bool retVoid, List <object> constantPool) { Type[] sigTypes = new Type[sig.Length + 2]; sigTypes[0] = typeof(IntPtr); for (int i = 0; i < sig.Length; i++) { sigTypes[i + 1] = sig[i].ArgumentExpression.Type; } sigTypes[sigTypes.Length - 1] = typeof(object[]); Type retType = retVoid ? typeof(void) : nativeRetType != null?nativeRetType.GetPythonType() : typeof(int); Type calliRetType = retVoid ? typeof(void) : nativeRetType != null?nativeRetType.GetNativeType() : typeof(int); #if !CTYPES_USE_SNIPPETS DynamicMethod dm = new DynamicMethod("InteropInvoker", retType, sigTypes, DynamicModule); #else TypeGen tg = Snippets.Shared.DefineType("InteropInvoker", typeof(object), false, false); MethodBuilder dm = tg.TypeBuilder.DefineMethod("InteropInvoker", CompilerHelpers.PublicStatic, retType, sigTypes); #endif ILGenerator method = dm.GetILGenerator(); LocalBuilder calliRetTmp = null, finalRetValue = null; if (dm.ReturnType != typeof(void)) { calliRetTmp = method.DeclareLocal(calliRetType); finalRetValue = method.DeclareLocal(dm.ReturnType); } // try { // emit all of the arguments, save their cleanups method.BeginExceptionBlock(); List <MarshalCleanup> cleanups = null; for (int i = 0; i < sig.Length; i++) { #if DEBUG method.Emit(OpCodes.Ldstr, String.Format("Argument #{0}, Marshaller: {1}, Native Type: {2}", i, sig[i], sig[i].NativeType)); method.Emit(OpCodes.Pop); #endif MarshalCleanup cleanup = sig[i].EmitCallStubArgument(method, i + 1, constantPool, sigTypes.Length - 1); if (cleanup != null) { if (cleanups == null) { cleanups = new List <MarshalCleanup>(); } cleanups.Add(cleanup); } } // emit the target function pointer and the calli #if DEBUG method.Emit(OpCodes.Ldstr, "!!! CALLI !!!"); method.Emit(OpCodes.Pop); #endif method.Emit(OpCodes.Ldarg_0); method.Emit(OpCodes.Calli, GetCalliSignature(convention, sig, calliRetType)); // if we have a return value we need to store it and marshal to Python // before we run any cleanup code. if (retType != typeof(void)) { #if DEBUG method.Emit(OpCodes.Ldstr, "!!! Return !!!"); method.Emit(OpCodes.Pop); #endif if (nativeRetType != null) { method.Emit(OpCodes.Stloc, calliRetTmp); nativeRetType.EmitReverseMarshalling(method, new Local(calliRetTmp), constantPool, sig.Length + 1); method.Emit(OpCodes.Stloc, finalRetValue); } else { Debug.Assert(retType == typeof(int)); // no marshalling necessary method.Emit(OpCodes.Stloc, finalRetValue); } } // } finally { // emit the cleanup code method.BeginFinallyBlock(); if (cleanups != null) { foreach (MarshalCleanup mc in cleanups) { mc.Cleanup(method); } } method.EndExceptionBlock(); // } // load the temporary value and return it. if (retType != typeof(void)) { method.Emit(OpCodes.Ldloc, finalRetValue); } method.Emit(OpCodes.Ret); #if CTYPES_USE_SNIPPETS return(tg.TypeBuilder.CreateType().GetMethod("InteropInvoker")); #else return(dm); #endif }
public NativeSymbolAttribute([NotNull, CallerMemberName] string entrypoint = "") { CallingConvention = CallingConvention.Cdecl; Entrypoint = entrypoint; }
public MethodBuilder DefinePInvokeMethod(String name, String dllName, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, CallingConvention nativeCallConv, CharSet nativeCharSet) { MethodBuilder method = DefinePInvokeMethodHelper( name, dllName, name, attributes, callingConvention, returnType, null, null, parameterTypes, null, null, nativeCallConv, nativeCharSet); return method; }
public void Ctor_CallingConvention(CallingConvention callingConvention) { var attribute = new UnmanagedFunctionPointerAttribute(callingConvention); Assert.Equal(callingConvention, attribute.CallingConvention); }
[System.Security.SecurityCritical] // auto-generated private MethodBuilder DefinePInvokeMethodHelper( String name, String dllName, String importName, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] returnTypeRequiredCustomModifiers, Type[] returnTypeOptionalCustomModifiers, Type[] parameterTypes, Type[][] parameterTypeRequiredCustomModifiers, Type[][] parameterTypeOptionalCustomModifiers, CallingConvention nativeCallConv, CharSet nativeCharSet) { CheckContext(returnType); CheckContext(returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, parameterTypes); CheckContext(parameterTypeRequiredCustomModifiers); CheckContext(parameterTypeOptionalCustomModifiers); AppDomain.CheckDefinePInvokeSupported(); lock (SyncRoot) { return DefinePInvokeMethodHelperNoLock(name, dllName, importName, attributes, callingConvention, returnType, returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, parameterTypes, parameterTypeRequiredCustomModifiers, parameterTypeOptionalCustomModifiers, nativeCallConv, nativeCharSet); } }
public UnmanagedFunctionPointerAttribute() { _callingConvention = CallingConvention.Winapi; }
public UnmanagedFunctionPointerAttribute(CallingConvention callingConvention) { this.call_conv = callingConvention; }
/// <summary> /// Only constructor. /// </summary> /// <param name="ChanKind"></param> /// <param name="ObjType"></param> /// <param name="CallConv"></param> /// <param name="InvKind"></param> public Client(ChannelKind ChanKind, Type ObjType, CallingConvention CallConv, InvokeKind InvKind, string Host) { m_ChanKind = ChanKind; m_ObjType = ObjType; m_CallConv = CallConv; m_InvKind = InvKind; m_Host = Host; }//constructor
/// <summary> /// Constructor /// </summary> /// <param name="callingConvention">Calling convention (must have LocalSig set)</param> /// <param name="count">Number of locals</param> internal LocalSig(CallingConvention callingConvention, uint count) { this.callingConvention = callingConvention; this.locals = ThreadSafeListCreator.Create <TypeSig>((int)count); }
public void SetCustomAttribute(CustomAttributeBuilder customBuilder) { if (customBuilder == null) { throw new ArgumentNullException("customBuilder"); } switch (customBuilder.Ctor.ReflectedType.FullName) { case "System.Runtime.CompilerServices.MethodImplAttribute": byte[] data = customBuilder.Data; int impla; // the (stupid) ctor takes a short or an int ... impla = (int)data [2]; impla |= ((int)data [3]) << 8; iattrs |= (MethodImplAttributes)impla; return; case "System.Runtime.InteropServices.DllImportAttribute": CustomAttributeBuilder.CustomAttributeInfo attr = CustomAttributeBuilder.decode_cattr(customBuilder); bool preserveSig = true; /* * It would be easier to construct a DllImportAttribute from * the custom attribute builder, but the DllImportAttribute * does not contain all the information required here, ie. * - some parameters, like BestFitMapping has three values * ("on", "off", "missing"), but DllImportAttribute only * contains two (on/off). * - PreserveSig is true by default, while it is false by * default in DllImportAttribute. */ pi_dll = (string)attr.ctorArgs[0]; if (pi_dll == null || pi_dll.Length == 0) { throw new ArgumentException("DllName cannot be empty"); } native_cc = System.Runtime.InteropServices.CallingConvention.Winapi; for (int i = 0; i < attr.namedParamNames.Length; ++i) { string name = attr.namedParamNames [i]; object value = attr.namedParamValues [i]; if (name == "CallingConvention") { native_cc = (CallingConvention)value; } else if (name == "CharSet") { charset = (CharSet)value; } else if (name == "EntryPoint") { pi_entry = (string)value; } else if (name == "ExactSpelling") { ExactSpelling = (bool)value; } else if (name == "SetLastError") { SetLastError = (bool)value; } else if (name == "PreserveSig") { preserveSig = (bool)value; } #if NET_1_1 else if (name == "BestFitMapping") { BestFitMapping = (bool)value; } else if (name == "ThrowOnUnmappableChar") { ThrowOnUnmappableChar = (bool)value; } #endif } attrs |= MethodAttributes.PinvokeImpl; if (preserveSig) { iattrs |= MethodImplAttributes.PreserveSig; } return; case "System.Runtime.InteropServices.PreserveSigAttribute": iattrs |= MethodImplAttributes.PreserveSig; return; #if NET_2_0 case "System.Runtime.CompilerServices.SpecialNameAttribute": attrs |= MethodAttributes.SpecialName; return; #endif case "System.Security.SuppressUnmanagedCodeSecurityAttribute": attrs |= MethodAttributes.HasSecurity; break; } if (cattrs != null) { CustomAttributeBuilder[] new_array = new CustomAttributeBuilder [cattrs.Length + 1]; cattrs.CopyTo(new_array, 0); new_array [cattrs.Length] = customBuilder; cattrs = new_array; } else { cattrs = new CustomAttributeBuilder [1]; cattrs [0] = customBuilder; } }
uint IInternFactory.GetFunctionPointerTypeReferenceInternedKey(CallingConvention callingConvention, IEnumerable<IParameterTypeInformation> parameters, IEnumerable<IParameterTypeInformation> extraArgumentTypes, IEnumerable<ICustomModifier> returnValueCustomModifiers, bool returnValueIsByRef, ITypeReference returnType) { lock (GlobalLock.LockingObject) { return this.GetFunctionPointerTypeReferenceInternId(callingConvention, parameters, extraArgumentTypes, returnValueCustomModifiers, returnValueIsByRef, returnType); } }
public static SignatureHelper GetMethodSigHelper(Module mod, CallingConvention unmanagedCallConv, Type returnType) { return(GetMethodSigHelper(mod, CallingConventions.Standard, unmanagedCallConv, returnType, null)); }
public MethodBuilder DefinePInvokeMethod(String name, String dllName, String entryName, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] returnTypeRequiredCustomModifiers, Type[] returnTypeOptionalCustomModifiers, Type[] parameterTypes, Type[][] parameterTypeRequiredCustomModifiers, Type[][] parameterTypeOptionalCustomModifiers, CallingConvention nativeCallConv, CharSet nativeCharSet) { MethodBuilder method = DefinePInvokeMethodHelper( name, dllName, entryName, attributes, callingConvention, returnType, returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, parameterTypes, parameterTypeRequiredCustomModifiers, parameterTypeOptionalCustomModifiers, nativeCallConv, nativeCharSet); return method; }
internal static SignatureHelper GetMethodSigHelper(Module mod, CallingConventions callingConvention, CallingConvention unmanagedCallingConvention, Type returnType, Type [] parameters) { if (mod != null && !(mod is ModuleBuilder)) { throw new ArgumentException("ModuleBuilder is expected"); } if (returnType == null) { returnType = typeof(void); } if (returnType.IsUserType) { throw new NotSupportedException("User defined subclasses of System.Type are not yet supported."); } if (parameters != null) { for (int i = 0; i < parameters.Length; ++i) { if (parameters [i].IsUserType) { throw new NotSupportedException("User defined subclasses of System.Type are not yet supported."); } } } SignatureHelper helper = new SignatureHelper((ModuleBuilder)mod, SignatureHelperType.HELPER_METHOD); helper.returnType = returnType; helper.callConv = callingConvention; helper.unmanagedCallConv = unmanagedCallingConvention; if (parameters != null) { helper.arguments = new Type [parameters.Length]; for (int i = 0; i < parameters.Length; ++i) { helper.arguments [i] = parameters [i]; } } return(helper); }
[System.Security.SecurityCritical] // auto-generated private MethodBuilder DefinePInvokeMethodHelperNoLock( String name, String dllName, String importName, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] returnTypeRequiredCustomModifiers, Type[] returnTypeOptionalCustomModifiers, Type[] parameterTypes, Type[][] parameterTypeRequiredCustomModifiers, Type[][] parameterTypeOptionalCustomModifiers, CallingConvention nativeCallConv, CharSet nativeCharSet) { if (name == null) throw new ArgumentNullException("name"); if (name.Length == 0) throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "name"); if (dllName == null) throw new ArgumentNullException("dllName"); if (dllName.Length == 0) throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "dllName"); if (importName == null) throw new ArgumentNullException("importName"); if (importName.Length == 0) throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "importName"); if ((attributes & MethodAttributes.Abstract) != 0) throw new ArgumentException(Environment.GetResourceString("Argument_BadPInvokeMethod")); Contract.EndContractBlock(); if ((m_iAttr & TypeAttributes.ClassSemanticsMask) == TypeAttributes.Interface) throw new ArgumentException(Environment.GetResourceString("Argument_BadPInvokeOnInterface")); ThrowIfCreated(); attributes = attributes | MethodAttributes.PinvokeImpl; MethodBuilder method = new MethodBuilder(name, attributes, callingConvention, returnType, returnTypeRequiredCustomModifiers, returnTypeOptionalCustomModifiers, parameterTypes, parameterTypeRequiredCustomModifiers, parameterTypeOptionalCustomModifiers, m_module, this, false); //The signature grabbing code has to be up here or the signature won't be finished //and our equals check won't work. int sigLength; byte[] sigBytes = method.GetMethodSignature().InternalGetSignature(out sigLength); if (m_listMethods.Contains(method)) { throw new ArgumentException(Environment.GetResourceString("Argument_MethodRedefined")); } m_listMethods.Add(method); MethodToken token = method.GetToken(); int linkFlags = 0; switch(nativeCallConv) { case CallingConvention.Winapi: linkFlags =(int)PInvokeMap.CallConvWinapi; break; case CallingConvention.Cdecl: linkFlags =(int)PInvokeMap.CallConvCdecl; break; case CallingConvention.StdCall: linkFlags =(int)PInvokeMap.CallConvStdcall; break; case CallingConvention.ThisCall: linkFlags =(int)PInvokeMap.CallConvThiscall; break; case CallingConvention.FastCall: linkFlags =(int)PInvokeMap.CallConvFastcall; break; } switch(nativeCharSet) { case CharSet.None: linkFlags |=(int)PInvokeMap.CharSetNotSpec; break; case CharSet.Ansi: linkFlags |=(int)PInvokeMap.CharSetAnsi; break; case CharSet.Unicode: linkFlags |=(int)PInvokeMap.CharSetUnicode; break; case CharSet.Auto: linkFlags |=(int)PInvokeMap.CharSetAuto; break; } SetPInvokeData(m_module.GetNativeHandle(), dllName, importName, token.Token, linkFlags); method.SetToken(token); return method; }
/// <summary> /// Reads a <see cref="FieldSig"/> /// </summary> /// <param name="callingConvention">First byte of signature</param> /// <returns>A new <see cref="FieldSig"/> instance</returns> FieldSig ReadField(CallingConvention callingConvention) => new FieldSig(callingConvention, ReadType());
public UnmanagedFunctionPointerAttribute(CallingConvention callingConvention) { _callingConvention = callingConvention; }
/// <summary> /// Reads a <see cref="MethodSig"/> /// </summary> /// <param name="callingConvention">First byte of signature</param> /// <returns>A new <see cref="MethodSig"/> instance</returns> MethodSig ReadMethod(CallingConvention callingConvention) => ReadSig(new MethodSig(callingConvention));
}//Usage() /// <summary> /// Gets user options. /// </summary> private static void GetOptions() { GetChannel: Console.Write("\nHttp (h), TCP (t) or both (b) using threads? "); string Reply = Console.ReadLine(); switch (Reply.ToLower()) { case "b": m_ChanKind = ChannelKind.Both; break; case "h": m_ChanKind = ChannelKind.Http; break; case "t": m_ChanKind = ChannelKind.TCP; break; default: Console.WriteLine("Invalid option, please try again."); goto GetChannel; }//switch GetConvention: Console.Write("\nBy ref (r) or by val (v)? "); Reply = Console.ReadLine(); switch (Reply.ToLower()) { case "r": m_CallConv = CallingConvention.ByRef; break; case "v": m_CallConv = CallingConvention.ByVal; break; default: Console.WriteLine("Invalid option, please try again."); goto GetConvention; }//switch GetInvoke: Console.Write("\nSerial (s) or async (a)? "); Reply = Console.ReadLine(); switch (Reply.ToLower()) { case "a": m_InvKind = InvokeKind.Async; break; case "s": m_InvKind = InvokeKind.Sequential; break; default: Console.WriteLine("Invalid option, please try again."); goto GetInvoke; }//switch //Setup the correct Type object to pass to the Client object for object creation. switch (m_CallConv) { case CallingConvention.ByRef: m_ObjType = Type.GetType("RemotingSamples.HelloServerByRef,remotingshared"); break; case CallingConvention.ByVal: m_ObjType = Type.GetType("RemotingSamples.HelloServerByVal,remotingshared"); break; default: throw new System.InvalidOperationException("Invalid Calling Convention in Main()"); }//switch Console.WriteLine(); return; }//GetOptions()
/// <summary> /// Reads a <see cref="PropertySig"/> /// </summary> /// <param name="callingConvention">First byte of signature</param> /// <returns>A new <see cref="PropertySig"/> instance</returns> PropertySig ReadProperty(CallingConvention callingConvention) => ReadSig(new PropertySig(callingConvention));
public MethodBuilder DefinePInvokeMethod(string name, string dllName, string entryName, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, CallingConvention nativeCallConv, CharSet nativeCharSet) { return DefinePInvokeMethod(name, dllName, entryName, attributes, callingConvention, returnType, null, null, parameterTypes, null, null, nativeCallConv, nativeCharSet); }
/// <summary> /// Reads a <see cref="FieldSig"/> /// </summary> /// <param name="callingConvention">First byte of signature</param> /// <returns>A new <see cref="FieldSig"/> instance</returns> FieldSig ReadField(CallingConvention callingConvention) { return(new FieldSig(callingConvention, ReadType())); }
[System.Security.SecurityCritical] // auto-generated #endif public MethodBuilder DefinePInvokeMethod(String name, String dllName, String entryName, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, CallingConvention nativeCallConv, CharSet nativeCharSet) { Contract.Ensures(Contract.Result<MethodBuilder>() != null); lock(SyncRoot) { return DefinePInvokeMethodNoLock(name, dllName, entryName, attributes, callingConvention, returnType, parameterTypes, nativeCallConv, nativeCharSet); } }
/// <summary> /// Reads a <see cref="MethodSig"/> /// </summary> /// <param name="callingConvention">First byte of signature</param> /// <returns>A new <see cref="MethodSig"/> instance</returns> MethodSig ReadMethod(CallingConvention callingConvention) { return(ReadSig(new MethodSig(callingConvention))); }
public DllExportAttribute(CallingConvention convention, string name) { ExportedName = name; this.CallingConvention = convention; }
/// <summary> /// Reads a <see cref="PropertySig"/> /// </summary> /// <param name="callingConvention">First byte of signature</param> /// <returns>A new <see cref="PropertySig"/> instance</returns> PropertySig ReadProperty(CallingConvention callingConvention) { return(ReadSig(new PropertySig(callingConvention))); }
/// <summary> /// Puts a Calli instruction onto the Microsoft intermediate language (MSIL) stream, specifying an unmanaged /// calling convention for the indirect call. /// </summary> public void EmitCalli(OpCode opcode, CallingConvention unmanagedCallConv, Type returnType, Type[] parameterTypes) { if (InterceptEmit(opcode, null)) il.EmitCalli(opcode, unmanagedCallConv, returnType, parameterTypes); }
public CallingConventionAttribute(CallingConvention callingConvention) { }