204 references to MethodSignatureFlags
ILCompiler.Compiler (97)
Compiler\Compilation.cs (1)
460if ((signature.Flags & MethodSignatureFlags.UnmanagedCallingConventionMask) != 0)
Compiler\DependencyAnalysis\NativeLayoutVertexNode.cs (1)
292if ((_signature.Flags & MethodSignatureFlags.UnmanagedCallingConventionMask) != 0)
Compiler\DependencyAnalysis\StringAllocatorMethodNode.cs (1)
42signatureBuilder.Flags = MethodSignatureFlags.Static;
Compiler\JitHelper.cs (2)
226new MethodSignature(MethodSignatureFlags.Static, 0, t, [t, t])); 233new MethodSignature(MethodSignatureFlags.Static, 0, t, [t, t]));
Compiler\LibraryRootProvider.cs (2)
89if ((signature.Flags & MethodSignatureFlags.UnmanagedCallingConventionMask) == MethodSignatureFlags.CallingConventionVarargs)
Compiler\ReachabilityInstrumentationProvider.cs (1)
273_signature ??= new MethodSignature(MethodSignatureFlags.Static, 0,
IL\ILImporter.Scanner.cs (6)
549if ((method.Signature.Flags & MethodSignatureFlags.UnmanagedCallingConventionMask) == MethodSignatureFlags.CallingConventionVarargs) 1126MethodSignatureFlags.Static, 1168if ((signature.Flags & MethodSignatureFlags.UnmanagedCallingConventionMask) == 0) 2060MethodSignature signature = new MethodSignature(MethodSignatureFlags.Static, 0, context.GetWellKnownType(WellKnownType.Void), [parameterType]); 2069MethodSignature signature = new MethodSignature(MethodSignatureFlags.Static, 1, signatureVariable, [parameterType]);
IL\Stubs\StartupCode\NativeLibraryStartupMethod.cs (2)
91_signature ??= new MethodSignature(MethodSignatureFlags.Static | MethodSignatureFlags.UnmanagedCallingConvention, 0,
IL\Stubs\StartupCode\StartupCodeMainMethod.cs (2)
179_signature ??= new MethodSignature(MethodSignatureFlags.Static | MethodSignatureFlags.UnmanagedCallingConvention, 0,
parent\parent\Common\Compiler\TypeMapMetadata.cs (1)
181public override MethodSignature Signature => new MethodSignature(MethodSignatureFlags.Static, 0, Context.GetWellKnownType(WellKnownType.Void), []);
parent\parent\Common\Internal\Runtime\EETypeBuilderHelpers.cs (1)
160return (sig.Flags & MethodSignatureFlags.UnmanagedCallingConventionMask) switch
parent\parent\Common\JitInterface\WasmLowering.cs (6)
30return new MethodSignature(MethodSignatureFlags.Static, 0, signature.Context.GetWellKnownType(WellKnownType.String), arguments); 539MethodSignatureFlags flags = hasThis ? MethodSignatureFlags.None : MethodSignatureFlags.Static; 542flags |= MethodSignatureFlags.UnmanagedCallingConvention; 656if (!flags.HasFlag(LoweringFlags.IsUnmanagedCallersOnly) && signature.Flags.HasFlag(MethodSignatureFlags.UnmanagedCallingConvention))
parent\parent\Common\TypeSystem\IL\NativeAotILProvider.cs (1)
158MethodSignatureFlags.None,
parent\parent\Common\TypeSystem\IL\Stubs\AssemblyGetExecutingAssemblyMethodThunk.cs (1)
25Signature = new MethodSignature(MethodSignatureFlags.Static, 0,
parent\parent\Common\TypeSystem\IL\Stubs\AsyncResumptionStub.cs (1)
50return _signature = new MethodSignature(MethodSignatureFlags.Static, 0, objectType, [objectType, byrefByte]);
parent\parent\Common\TypeSystem\IL\Stubs\AsyncThunks.cs (4)
163MethodSignatureFlags.Static, 176MethodSignatureFlags.Static, 198MethodSignatureFlags.Static, 211MethodSignatureFlags.Static,
parent\parent\Common\TypeSystem\IL\Stubs\CalliMarshallingMethodThunk.cs (1)
82MethodSignatureFlags.Static,
parent\parent\Common\TypeSystem\IL\Stubs\CalliMarshallingMethodThunk.Mangling.cs (2)
28Debug.Assert((_targetSignature.Flags & MethodSignatureFlags.UnmanagedCallingConventionMask) == MethodSignatureFlags.UnmanagedCallingConvention);
parent\parent\Common\TypeSystem\IL\Stubs\DelegateMarshallingMethodThunk.cs (5)
142MethodSignatureFlags unmanagedCallingConvention = flags.UnmanagedCallingConvention; 143if (unmanagedCallingConvention == MethodSignatureFlags.None) 144unmanagedCallingConvention = MethodSignatureFlags.UnmanagedCallingConvention; 152builder.Flags = MethodSignatureFlags.Static | unmanagedCallingConvention; 209_signature = new MethodSignature(MethodSignatureFlags.Static | unmanagedCallingConvention, 0, nativeReturnType, nativeParameterTypes);
parent\parent\Common\TypeSystem\IL\Stubs\DelegateThunks.cs (2)
111builder.Flags = Signature.Flags | MethodSignatureFlags.Static; 260Signature.Flags | MethodSignatureFlags.Static, 0, Signature.ReturnType, targetMethodParameters);
parent\parent\Common\TypeSystem\IL\Stubs\DynamicInvokeMethodThunk.cs (5)
34private static MethodSignatureFlags MethodSignatureFlags_ValueTypeInstanceMethod => (MethodSignatureFlags)0x8000; 38MethodSignatureFlags flags = 0; 41flags |= MethodSignatureFlags.Static; 102MethodSignatureFlags.Static,
parent\parent\Common\TypeSystem\IL\Stubs\ForwardDelegateCreationThunk.cs (2)
58_signature ??= new MethodSignature(MethodSignatureFlags.Static, 0, 117new MethodSignature(MethodSignatureFlags.None,
parent\parent\Common\TypeSystem\IL\Stubs\InterlockedIntrinsics.cs (1)
61MethodSignatureFlags.Static,
parent\parent\Common\TypeSystem\IL\Stubs\MethodBaseGetCurrentMethodThunk.cs (1)
25Signature = new MethodSignature(MethodSignatureFlags.Static, 0,
parent\parent\Common\TypeSystem\IL\Stubs\PInvokeILEmitter.cs (7)
173MethodSignatureFlags.Static, 0, _marshallers[0].ManagedParameterType, parameters); 237MethodSignatureFlags unmanagedCallingConvention = _flags.UnmanagedCallingConvention; 238if (unmanagedCallingConvention == MethodSignatureFlags.None) 239unmanagedCallingConvention = MethodSignatureFlags.UnmanagedCallingConvention; 242MethodSignatureFlags.Static | unmanagedCallingConvention, 0, nativeReturnType, nativeParameterTypes); 304MethodSignatureFlags.Static | MethodSignatureFlags.UnmanagedCallingConvention, 0, nativeReturnType, nativeParameterTypes,
parent\parent\Common\TypeSystem\IL\Stubs\StructMarshallingThunk.cs (1)
103_signature = new MethodSignature(MethodSignatureFlags.Static, 0, Context.GetWellKnownType(WellKnownType.Void), parameters);
parent\parent\Common\TypeSystem\Interop\IL\InlineArrayType.cs (2)
360_signature = new MethodSignature(MethodSignatureFlags.None, 367_signature = new MethodSignature(MethodSignatureFlags.None,
parent\parent\Common\TypeSystem\Interop\IL\Marshaller.Aot.cs (6)
980MethodSignatureFlags.None, 1229new MethodSignature(MethodSignatureFlags.Static, 0, customMarshallerType, [ Context.GetWellKnownType(WellKnownType.String) ])); 1269new MethodSignature(MethodSignatureFlags.None, 0, Context.GetWellKnownType(WellKnownType.IntPtr), [ Context.GetWellKnownType(WellKnownType.Object) ])); 1298new MethodSignature(MethodSignatureFlags.None, 0, Context.GetWellKnownType(WellKnownType.Object), [ Context.GetWellKnownType(WellKnownType.IntPtr) ])); 1316new MethodSignature(MethodSignatureFlags.None, 0, Context.GetWellKnownType(WellKnownType.Void), [ Context.GetWellKnownType(WellKnownType.Object) ])); 1333new MethodSignature(MethodSignatureFlags.None, 0, Context.GetWellKnownType(WellKnownType.Void), [ Context.GetWellKnownType(WellKnownType.IntPtr) ]));
parent\parent\Common\TypeSystem\Interop\IL\Marshaller.cs (4)
1703MethodSignatureFlags.None, 0, Context.GetWellKnownType(WellKnownType.Void), 1896new MethodSignature(MethodSignatureFlags.None, genericParameterCount: 0, 2061new MethodSignature(MethodSignatureFlags.Static, 1, Context.GetWellKnownType(WellKnownType.IntPtr), 2087new MethodSignature(MethodSignatureFlags.Static, 1, Context.GetSignatureVariable(0, method: true),
parent\parent\Common\TypeSystem\Interop\IL\PInvokeDelegateWrapperConstructor.cs (1)
48_signature ??= new MethodSignature(MethodSignatureFlags.None,
parent\parent\Common\TypeSystem\Interop\InteropStateManager.cs (2)
192normalizedSignatureBuilder.Flags = (signature.Flags & MethodSignatureFlags.Static) | MethodSignatureFlags.UnmanagedCallingConvention;
parent\parent\Common\TypeSystem\Interop\UnmanagedCallingConventions.cs (16)
54MethodSignatureFlags unmanagedCallconv = signature.Flags & MethodSignatureFlags.UnmanagedCallingConventionMask; 55if (unmanagedCallconv != MethodSignatureFlags.UnmanagedCallingConvention) 57Debug.Assert((int)MethodSignatureFlags.UnmanagedCallingConventionCdecl == (int)UnmanagedCallingConventions.Cdecl 58&& (int)MethodSignatureFlags.UnmanagedCallingConventionStdCall == (int)UnmanagedCallingConventions.Stdcall 59&& (int)MethodSignatureFlags.UnmanagedCallingConventionThisCall == (int)UnmanagedCallingConventions.Thiscall); 115MethodSignatureFlags unmanagedCallConv = method.GetPInvokeMethodMetadata().Flags.UnmanagedCallingConvention; 116if (unmanagedCallConv != MethodSignatureFlags.None) 118Debug.Assert((int)MethodSignatureFlags.UnmanagedCallingConventionCdecl == (int)UnmanagedCallingConventions.Cdecl 119&& (int)MethodSignatureFlags.UnmanagedCallingConventionStdCall == (int)UnmanagedCallingConventions.Stdcall 120&& (int)MethodSignatureFlags.UnmanagedCallingConventionThisCall == (int)UnmanagedCallingConventions.Thiscall); 148MethodSignatureFlags unmanagedCallConv = ecmaDelegate.GetDelegatePInvokeFlags().UnmanagedCallingConvention; 149if (unmanagedCallConv != MethodSignatureFlags.None) 151Debug.Assert((int)MethodSignatureFlags.UnmanagedCallingConventionCdecl == (int)UnmanagedCallingConventions.Cdecl 152&& (int)MethodSignatureFlags.UnmanagedCallingConventionStdCall == (int)UnmanagedCallingConventions.Stdcall 153&& (int)MethodSignatureFlags.UnmanagedCallingConventionThisCall == (int)UnmanagedCallingConventions.Thiscall);
parent\parent\Common\TypeSystem\MetadataEmitter\TypeSystemMetadataEmitter.cs (6)
665switch (sig.Flags & MethodSignatureFlags.UnmanagedCallingConventionMask) 667case MethodSignatureFlags.CallingConventionVarargs: 670case MethodSignatureFlags.UnmanagedCallingConventionCdecl: 673case MethodSignatureFlags.UnmanagedCallingConventionStdCall: 676case MethodSignatureFlags.UnmanagedCallingConventionThisCall: 679case MethodSignatureFlags.UnmanagedCallingConvention:
ILCompiler.MetadataTransform (6)
ILCompiler\Metadata\Transform.Method.cs (6)
239Debug.Assert((int)Cts.MethodSignatureFlags.UnmanagedCallingConventionCdecl == (int)SignatureCallingConvention.Cdecl); 240Debug.Assert((int)Cts.MethodSignatureFlags.UnmanagedCallingConventionThisCall == (int)SignatureCallingConvention.ThisCall); 241Debug.Assert((int)Cts.MethodSignatureFlags.UnmanagedCallingConventionMask == (int)SignatureCallingConvention.UnmanagedCallingConventionMask); 242SignatureCallingConvention callingConvention = (SignatureCallingConvention)(signature.Flags & Cts.MethodSignatureFlags.UnmanagedCallingConventionMask); 243if ((signature.Flags & Cts.MethodSignatureFlags.Static) == 0) 247if ((signature.Flags & Cts.MethodSignatureFlags.ExplicitThis) != 0)
ILCompiler.ReadyToRun (58)
Compiler\DependencyAnalysis\ReadyToRun\GCRefMapBuilder.cs (1)
80bool hasThis = (signature.Flags & MethodSignatureFlags.Static) == 0;
Compiler\DependencyAnalysis\ReadyToRun\SignatureBuilder.cs (2)
380SignatureCallingConvention callingConvention = (SignatureCallingConvention)(type.Signature.Flags & MethodSignatureFlags.UnmanagedCallingConventionMask); 381SignatureAttributes callingConventionAttributes = ((type.Signature.Flags & MethodSignatureFlags.Static) != 0 ? SignatureAttributes.None : SignatureAttributes.Instance);
Compiler\ReadyToRunCodegenCompilation.cs (4)
1034asyncHelpers.GetKnownMethod("TransparentAwait"u8, new MethodSignature(MethodSignatureFlags.Static, 0, voidType, [taskType])), 1035asyncHelpers.GetKnownMethod("TransparentAwait"u8, new MethodSignature(MethodSignatureFlags.Static, 0, voidType, [valueTaskType])), 1036asyncHelpers.GetKnownMethod("TransparentAwait"u8, new MethodSignature(MethodSignatureFlags.Static, 1, methodVar, [taskOfTType.MakeInstantiatedType(methodVar)])), 1037asyncHelpers.GetKnownMethod("TransparentAwait"u8, new MethodSignature(MethodSignatureFlags.Static, 1, methodVar, [valueTaskOfTType.MakeInstantiatedType(methodVar)])),
Compiler\ReadyToRunLibraryRootProvider.cs (2)
93if ((signature.Flags & MethodSignatureFlags.UnmanagedCallingConventionMask) == MethodSignatureFlags.CallingConventionVarargs)
IL\Stubs\InstanceCalliHelperIntrinsics.cs (2)
52builder.Flags = (sig.Flags | MethodSignatureFlags.ExplicitThis) & ~MethodSignatureFlags.Static;
JitInterface\CorInfoImpl.ReadyToRun.cs (3)
3486switch (signature.Flags & MethodSignatureFlags.UnmanagedCallingConventionMask) 3488case MethodSignatureFlags.None: 3489case MethodSignatureFlags.CallingConventionVarargs:
parent\parent\Common\Compiler\TypeMapMetadata.cs (1)
181public override MethodSignature Signature => new MethodSignature(MethodSignatureFlags.Static, 0, Context.GetWellKnownType(WellKnownType.Void), []);
parent\parent\Common\JitInterface\CorInfoImpl.cs (5)
922sig->callConv = (CorInfoCallConv)(signature.Flags & MethodSignatureFlags.UnmanagedCallingConventionMask); 1784if ((methodDesc.Signature.Flags & MethodSignatureFlags.UnmanagedCallingConventionMask) == 0) 3721MethodSignature signature = new MethodSignature(MethodSignatureFlags.Static, 0, context.GetWellKnownType(WellKnownType.Void), [parameterType]); 3731MethodSignature signature = new MethodSignature(MethodSignatureFlags.Static, 1, signatureVariable, [parameterType]); 3792MethodSignatureFlags.Static,
parent\parent\Common\JitInterface\WasmLowering.cs (6)
30return new MethodSignature(MethodSignatureFlags.Static, 0, signature.Context.GetWellKnownType(WellKnownType.String), arguments); 539MethodSignatureFlags flags = hasThis ? MethodSignatureFlags.None : MethodSignatureFlags.Static; 542flags |= MethodSignatureFlags.UnmanagedCallingConvention; 656if (!flags.HasFlag(LoweringFlags.IsUnmanagedCallersOnly) && signature.Flags.HasFlag(MethodSignatureFlags.UnmanagedCallingConvention))
parent\parent\Common\TypeSystem\IL\Stubs\AsyncResumptionStub.cs (1)
50return _signature = new MethodSignature(MethodSignatureFlags.Static, 0, objectType, [objectType, byrefByte]);
parent\parent\Common\TypeSystem\IL\Stubs\AsyncThunks.cs (4)
163MethodSignatureFlags.Static, 176MethodSignatureFlags.Static, 198MethodSignatureFlags.Static, 211MethodSignatureFlags.Static,
parent\parent\Common\TypeSystem\IL\Stubs\InterlockedIntrinsics.cs (1)
61MethodSignatureFlags.Static,
parent\parent\Common\TypeSystem\Interop\IL\Marshaller.cs (4)
1703MethodSignatureFlags.None, 0, Context.GetWellKnownType(WellKnownType.Void), 1896new MethodSignature(MethodSignatureFlags.None, genericParameterCount: 0, 2061new MethodSignature(MethodSignatureFlags.Static, 1, Context.GetWellKnownType(WellKnownType.IntPtr), 2087new MethodSignature(MethodSignatureFlags.Static, 1, Context.GetSignatureVariable(0, method: true),
parent\parent\Common\TypeSystem\Interop\UnmanagedCallingConventions.cs (16)
54MethodSignatureFlags unmanagedCallconv = signature.Flags & MethodSignatureFlags.UnmanagedCallingConventionMask; 55if (unmanagedCallconv != MethodSignatureFlags.UnmanagedCallingConvention) 57Debug.Assert((int)MethodSignatureFlags.UnmanagedCallingConventionCdecl == (int)UnmanagedCallingConventions.Cdecl 58&& (int)MethodSignatureFlags.UnmanagedCallingConventionStdCall == (int)UnmanagedCallingConventions.Stdcall 59&& (int)MethodSignatureFlags.UnmanagedCallingConventionThisCall == (int)UnmanagedCallingConventions.Thiscall); 115MethodSignatureFlags unmanagedCallConv = method.GetPInvokeMethodMetadata().Flags.UnmanagedCallingConvention; 116if (unmanagedCallConv != MethodSignatureFlags.None) 118Debug.Assert((int)MethodSignatureFlags.UnmanagedCallingConventionCdecl == (int)UnmanagedCallingConventions.Cdecl 119&& (int)MethodSignatureFlags.UnmanagedCallingConventionStdCall == (int)UnmanagedCallingConventions.Stdcall 120&& (int)MethodSignatureFlags.UnmanagedCallingConventionThisCall == (int)UnmanagedCallingConventions.Thiscall); 148MethodSignatureFlags unmanagedCallConv = ecmaDelegate.GetDelegatePInvokeFlags().UnmanagedCallingConvention; 149if (unmanagedCallConv != MethodSignatureFlags.None) 151Debug.Assert((int)MethodSignatureFlags.UnmanagedCallingConventionCdecl == (int)UnmanagedCallingConventions.Cdecl 152&& (int)MethodSignatureFlags.UnmanagedCallingConventionStdCall == (int)UnmanagedCallingConventions.Stdcall 153&& (int)MethodSignatureFlags.UnmanagedCallingConventionThisCall == (int)UnmanagedCallingConventions.Thiscall);
parent\parent\Common\TypeSystem\MetadataEmitter\TypeSystemMetadataEmitter.cs (6)
665switch (sig.Flags & MethodSignatureFlags.UnmanagedCallingConventionMask) 667case MethodSignatureFlags.CallingConventionVarargs: 670case MethodSignatureFlags.UnmanagedCallingConventionCdecl: 673case MethodSignatureFlags.UnmanagedCallingConventionStdCall: 676case MethodSignatureFlags.UnmanagedCallingConventionThisCall: 679case MethodSignatureFlags.UnmanagedCallingConvention:
ILCompiler.RyuJit (8)
JitInterface\CorInfoImpl.RyuJit.cs (1)
2008if ((signature.Flags & MethodSignatureFlags.UnmanagedCallingConventionMask) == 0)
parent\ILCompiler.Compiler\Compiler\JitHelper.cs (2)
226new MethodSignature(MethodSignatureFlags.Static, 0, t, [t, t])); 233new MethodSignature(MethodSignatureFlags.Static, 0, t, [t, t]));
parent\parent\Common\JitInterface\CorInfoImpl.cs (5)
922sig->callConv = (CorInfoCallConv)(signature.Flags & MethodSignatureFlags.UnmanagedCallingConventionMask); 1784if ((methodDesc.Signature.Flags & MethodSignatureFlags.UnmanagedCallingConventionMask) == 0) 3721MethodSignature signature = new MethodSignature(MethodSignatureFlags.Static, 0, context.GetWellKnownType(WellKnownType.Void), [parameterType]); 3731MethodSignature signature = new MethodSignature(MethodSignatureFlags.Static, 1, signatureVariable, [parameterType]); 3792MethodSignatureFlags.Static,
ILCompiler.TypeSystem (35)
parent\parent\Common\TypeSystem\Common\MethodDesc.cs (7)
49internal MethodSignatureFlags _flags; 75public MethodSignature(MethodSignatureFlags flags, int genericParameterCount, TypeDesc returnType, TypeDesc[] parameters, EmbeddedSignatureData[] embeddedSignatureData = null) 124public MethodSignatureFlags Flags 136return (_flags & MethodSignatureFlags.Static) != 0; 144return (_flags & MethodSignatureFlags.ExplicitThis) != 0; 401private MethodSignatureFlags _flags; 418public MethodSignatureFlags Flags
parent\parent\Common\TypeSystem\Common\TypeSystemContext.cs (2)
247Debug.Assert((signature.Flags & MethodSignatureFlags.UnmanagedCallingConventionMask) is 0 or MethodSignatureFlags.UnmanagedCallingConvention);
parent\parent\Common\TypeSystem\Ecma\EcmaSignatureParser.cs (10)
392MethodSignatureFlags flags = 0; 398Debug.Assert((int)MethodSignatureFlags.UnmanagedCallingConventionCdecl == (int)SignatureCallingConvention.CDecl); 399Debug.Assert((int)MethodSignatureFlags.UnmanagedCallingConventionStdCall == (int)SignatureCallingConvention.StdCall); 400Debug.Assert((int)MethodSignatureFlags.UnmanagedCallingConventionThisCall == (int)SignatureCallingConvention.ThisCall); 401Debug.Assert((int)MethodSignatureFlags.CallingConventionVarargs == (int)SignatureCallingConvention.VarArgs); 402Debug.Assert((int)MethodSignatureFlags.UnmanagedCallingConvention == (int)SignatureCallingConvention.Unmanaged); 408flags = MethodSignatureFlags.UnmanagedCallingConvention; 415flags = (MethodSignatureFlags)signatureCallConv; 420flags |= MethodSignatureFlags.Static; 423flags |= MethodSignatureFlags.ExplicitThis;
parent\parent\Common\TypeSystem\Ecma\EcmaType.cs (2)
396if ((sig.Flags & MethodSignatureFlags.UnmanagedCallingConventionMask) == MethodSignatureFlags.CallingConventionVarargs)
parent\parent\Common\TypeSystem\Ecma\MetadataExtensions.cs (3)
243flags.UnmanagedCallingConvention = MethodSignatureFlags.UnmanagedCallingConventionStdCall; 246flags.UnmanagedCallingConvention = MethodSignatureFlags.UnmanagedCallingConventionCdecl; 249flags.UnmanagedCallingConvention = MethodSignatureFlags.UnmanagedCallingConventionThisCall;
parent\parent\Common\TypeSystem\IL\UnsafeAccessors.cs (2)
326if ((declSig.Flags & MethodSignatureFlags.UnmanagedCallingConventionMask) 327!= (maybeSig.Flags & MethodSignatureFlags.UnmanagedCallingConventionMask))
parent\parent\Common\TypeSystem\Interop\MethodDesc.Interop.cs (9)
155public MethodSignatureFlags UnmanagedCallingConvention 162return MethodSignatureFlags.UnmanagedCallingConventionCdecl; 164return MethodSignatureFlags.UnmanagedCallingConventionStdCall; 166return MethodSignatureFlags.UnmanagedCallingConventionThisCall; 169return MethodSignatureFlags.None; 172return MethodSignatureFlags.None; // unreachable 181case MethodSignatureFlags.UnmanagedCallingConventionStdCall: 184case MethodSignatureFlags.UnmanagedCallingConventionCdecl: 187case MethodSignatureFlags.UnmanagedCallingConventionThisCall: