private bool MethodSignatureHasVarsNeedingCallingConventionConverter_NativeLayout(TypeSystemContext context, RuntimeSignature methodSig)
{
NativeReader reader = GetNativeLayoutInfoReader(methodSig);
NativeParser parser = new NativeParser(reader, methodSig.NativeLayoutOffset);
NativeFormatModuleInfo module = ModuleList.Instance.GetModuleInfoByHandle(new TypeManagerHandle(methodSig.ModuleHandle));
MethodCallingConvention callingConvention = (MethodCallingConvention)parser.GetUnsigned();
uint numGenArgs = callingConvention.HasFlag(MethodCallingConvention.Generic) ? parser.GetUnsigned() : 0;
uint parameterCount = parser.GetUnsigned();
// Check the return type of the method
if (TypeSignatureHasVarsNeedingCallingConventionConverter(ref parser, module, context, HasVarsInvestigationLevel.Parameter))
{
return(true);
}
// Check the parameters of the method
for (uint i = 0; i < parameterCount; i++)
{
if (TypeSignatureHasVarsNeedingCallingConventionConverter(ref parser, module, context, HasVarsInvestigationLevel.Parameter))
{
return(true);
}
}
return(false);
}
public CallSite(
bool hasThis,
bool explicitThis,
MethodCallingConvention callConv,
TypeSignature returnType,
IReadOnlyList <TypeSignature> arguments,
int varArgIndex,
int genericParameterCount)
{
if (returnType == null)
{
throw new ArgumentNullException("returnType");
}
_hasThis = hasThis;
_explicitThis = hasThis && explicitThis;
_genericParameterCount = genericParameterCount;
_callConv = callConv;
_returnType = returnType;
_arguments = arguments ?? ReadOnlyList <TypeSignature> .Empty;
if (callConv == MethodCallingConvention.VarArgs)
{
_varArgIndex = varArgIndex;
}
}
private bool MethodSignatureHasVarsNeedingCallingConventionConverter_NativeLayout(TypeSystemContext context, IntPtr methodSig)
{
IntPtr moduleHandle = RuntimeAugments.GetModuleFromPointer(methodSig);
NativeReader reader = GetNativeLayoutInfoReader(moduleHandle);
NativeParser parser = new NativeParser(reader, reader.AddressToOffset(methodSig));
MethodCallingConvention callingConvention = (MethodCallingConvention)parser.GetUnsigned();
uint numGenArgs = callingConvention.HasFlag(MethodCallingConvention.Generic) ? parser.GetUnsigned() : 0;
uint parameterCount = parser.GetUnsigned();
// Check the return type of the method
if (TypeSignatureHasVarsNeedingCallingConventionConverter(ref parser, context, HasVarsInvestigationLevel.Parameter))
{
return(true);
}
// Check the parameters of the method
for (uint i = 0; i < parameterCount; i++)
{
if (TypeSignatureHasVarsNeedingCallingConventionConverter(ref parser, context, HasVarsInvestigationLevel.Parameter))
{
return(true);
}
}
return(false);
}
public FunctionSignature(Type returnType, Type[] parameterTypes, MethodCallingConvention callingConvention, PInvokeInfo pinvoke)
{
ReturnType = returnType;
ParameterTypes = parameterTypes;
CallingConvention = callingConvention;
PInvokeInfo = pinvoke;
}
private MethodCallingConvention _convention = MethodCallingConvention.Default;//TODO: calling convention
private void FindNames()
{
var attr = Method.PInvokeInfo;
if (attr != null)
{
if (attr.IsCallConvCdecl)
{
_convention = MethodCallingConvention.C;
}
else if (attr.IsCallConvFastcall)
{
_convention = MethodCallingConvention.FastCall;
}
else if (attr.IsCallConvThiscall)
{
_convention = MethodCallingConvention.ThisCall;
}
else if (attr.IsCallConvStdCall)
{
_convention = MethodCallingConvention.StdCall;
}
else if (attr.IsCallConvWinapi)
{
throw new NotSupportedException();
}
_libraryName = attr.Module.Name;
_mangledName = attr.EntryPoint;
}
else
{
throw new NotImplementedException();
}
}
public override Vertex WriteVertex(NodeFactory factory)
{
MethodCallingConvention methodCallingConvention = default(MethodCallingConvention);
if (_method.Signature.GenericParameterCount > 0)
{
methodCallingConvention |= MethodCallingConvention.Generic;
}
if (_method.Signature.IsStatic)
{
methodCallingConvention |= MethodCallingConvention.Static;
}
Debug.Assert(_method.Signature.Length == _parametersSig.Length);
Vertex returnType = _returnTypeSig.WriteVertex(factory);
Vertex[] parameters = new Vertex[_parametersSig.Length];
for (int i = 0; i < _parametersSig.Length; i++)
{
parameters[i] = _parametersSig[i].WriteVertex(factory);
}
Vertex signature = GetNativeWriter(factory).GetMethodSigSignature((uint)methodCallingConvention, (uint)_method.Signature.GenericParameterCount, returnType, parameters);
return(factory.MetadataManager.NativeLayoutInfo.SignaturesSection.Place(signature));
}
private void CreateInteropCall(ILProcessor processor, FieldDefinition fnPtr, MethodCallingConvention convention)
{
int index = 0;
ReturnParameterMarshaler?.InitializeMarshalInfo(processor);
Instruction cleanupInstructions = null;
for (int i = 0; i < Method.Parameters.Count; i++)
{
var p = Method.Parameters[i];
var marshaller = MarshalProcessors[i];
marshaller?.InitializeMarshalInfo(processor);
if (marshaller == null)
{
processor.Emit(OpCodes.Ldarg, index++);
}
}
foreach (var mP in MarshalProcessors)
{
mP?.MarshalManaged(processor, cleanupInstructions);
cleanupInstructions = mP?.CleanUpInstruction ?? cleanupInstructions;
}
CreatePrimitiveInterop(processor, fnPtr, convention, cleanupInstructions);
ReturnParameterMarshaler?.MarshalNative(processor, cleanupInstructions);
}
private void PrintMethodCallConv(MethodCallingConvention callConv)
{
switch (callConv)
{
case MethodCallingConvention.C:
_builder.Append("cdecl ");
break;
case MethodCallingConvention.FastCall:
_builder.Append("fastcall ");
break;
case MethodCallingConvention.StdCall:
_builder.Append("stdcall ");
break;
case MethodCallingConvention.ThisCall:
_builder.Append("thiscall ");
break;
case MethodCallingConvention.VarArgs:
_builder.Append("vararg ");
break;
}
}
internal MethodReference(string name, bool hasThis,
bool explicitThis, MethodCallingConvention callConv) : this(name)
{
m_parameters = new ParameterDefinitionCollection(this);
m_hasThis = hasThis;
m_explicitThis = explicitThis;
m_callConv = callConv;
}
public MethodReference(string name, TypeReference declaringType, TypeReference returnType, bool hasThis, bool explicitThis, MethodCallingConvention callingConvention)
: this(name, returnType)
{
this.DeclaringType = declaringType;
this.HasThis = hasThis;
this.ExplicitThis = explicitThis;
this.CallingConvention = callingConvention;
}
public MethodReference(string name,
TypeReference declaringType, TypeReference returnType,
bool hasThis, bool explicitThis, MethodCallingConvention callConv)
: this(name, hasThis, explicitThis, callConv)
{
this.DeclaringType = declaringType;
this.ReturnType.ReturnType = returnType;
}
public MethodReference(string name,
TypeReference declaringType, TypeReference returnType,
bool hasThis, bool explicitThis, MethodCallingConvention callConv) :
this(name, hasThis, explicitThis, callConv)
{
this.DeclaringType = declaringType;
this.ReturnType.ReturnType = returnType;
}
internal MethodReference(string name, bool hasThis,
bool explicitThis, MethodCallingConvention callConv)
: this(name)
{
m_parameters = new ParameterDefinitionCollection (this);
m_hasThis = hasThis;
m_explicitThis = explicitThis;
m_callConv = callConv;
}
public FunctionSignature(IABI abi, Type returnType, Type[] parameterTypes, MethodCallingConvention callingConvention, PInvokeInfo pinvoke)
{
ReturnType = new FunctionParameterType(abi, returnType);
ParameterTypes = new FunctionParameterType[parameterTypes.Length];
for (int index = 0; index < parameterTypes.Length; index++)
ParameterTypes[index] = new FunctionParameterType(abi, parameterTypes[index]);
CallingConvention = callingConvention;
PInvokeInfo = pinvoke;
}
internal bool GetCallingConverterDataFromMethodSignature_NativeLayout_Common(
TypeSystemContext context,
RuntimeSignature methodSig,
Instantiation typeInstantiation,
Instantiation methodInstantiation,
out bool hasThis,
out TypeDesc[] parameters,
out bool[] parametersWithGenericDependentLayout,
NativeReader nativeReader)
{
NativeLayoutInfoLoadContext nativeLayoutContext = new NativeLayoutInfoLoadContext();
nativeLayoutContext._module = (NativeFormatModuleInfo)methodSig.GetModuleInfo();
nativeLayoutContext._typeSystemContext = context;
nativeLayoutContext._typeArgumentHandles = typeInstantiation;
nativeLayoutContext._methodArgumentHandles = methodInstantiation;
NativeFormatModuleInfo module = ModuleList.Instance.GetModuleInfoByHandle(new TypeManagerHandle(methodSig.ModuleHandle));
NativeReader reader = GetNativeLayoutInfoReader(methodSig);
NativeParser parser = new NativeParser(reader, methodSig.NativeLayoutOffset);
MethodCallingConvention callingConvention = (MethodCallingConvention)parser.GetUnsigned();
hasThis = !callingConvention.HasFlag(MethodCallingConvention.Static);
if (callingConvention.HasFlag(MethodCallingConvention.Generic))
{
parser.SkipInteger(); // numGenArgs
}
uint parameterCount = parser.GetUnsigned();
parameters = new TypeDesc[parameterCount + 1];
parametersWithGenericDependentLayout = new bool[parameterCount + 1];
// One extra parameter to account for the return type
for (uint i = 0; i <= parameterCount; i++)
{
// NativeParser is a struct, so it can be copied.
NativeParser parserCopy = parser;
// Parse the signature twice. The first time to find out the exact type of the signature
// The second time to identify if the parameter loaded via the signature should be forced to be
// passed byref as part of the universal generic calling convention.
parameters[i] = GetConstructedTypeFromParserAndNativeLayoutContext(ref parser, nativeLayoutContext);
parametersWithGenericDependentLayout[i] = TypeSignatureHasVarsNeedingCallingConventionConverter(ref parserCopy, module, context, HasVarsInvestigationLevel.Parameter);
if (parameters[i] == null)
{
return(false);
}
}
return(true);
}
public FunctionSignature(IABI abi, Type returnType, Type[] parameterTypes, MethodCallingConvention callingConvention, PInvokeInfo pinvoke)
{
ReturnType = new FunctionParameterType(abi, returnType);
ParameterTypes = new FunctionParameterType[parameterTypes.Length];
for (int index = 0; index < parameterTypes.Length; index++)
{
ParameterTypes[index] = new FunctionParameterType(abi, parameterTypes[index]);
}
CallingConvention = callingConvention;
PInvokeInfo = pinvoke;
}
public ReferencedCallSite(
AssemblyManager assemblyManager, bool hasThis, bool explicitThis, int varArgIndex,
MethodCallingConvention callConv, IType returnType, IReadOnlyList <IType> arguments)
{
_hasThis = hasThis;
_explicitThis = explicitThis;
_callConv = callConv;
_returnType = returnType;
_arguments = arguments;
_varArgIndex = varArgIndex;
_assemblyManager = assemblyManager;
}
public MethodDefinition(string name, RVA rva,
MethodAttributes attrs, MethodImplAttributes implAttrs,
bool hasThis, bool explicitThis, MethodCallingConvention callConv)
: base(name, hasThis, explicitThis, callConv)
{
m_rva = rva;
m_attributes = attrs;
m_implAttrs = implAttrs;
if (!IsStatic)
m_this = new ParameterDefinition ("this", 0, (ParameterAttributes) 0, null);
}
private uint GetGenericArgCountFromSig(NativeParser parser)
{
MethodCallingConvention callingConvention = (MethodCallingConvention)parser.GetUnsigned();
if ((callingConvention & MethodCallingConvention.Generic) == MethodCallingConvention.Generic)
{
return(parser.GetUnsigned());
}
else
{
return(0);
}
}
public MethodDefinition(string name, RVA rva,
MethodAttributes attrs, MethodImplAttributes implAttrs,
bool hasThis, bool explicitThis, MethodCallingConvention callConv) :
base(name, hasThis, explicitThis, callConv)
{
m_rva = rva;
m_attributes = attrs;
m_implAttrs = implAttrs;
if (!IsStatic)
{
m_this = new ParameterDefinition("this", 0, (ParameterAttributes)0, null);
}
}
string StringifyCallingConvention(MethodCallingConvention cconv)
{
switch (cconv)
{
case MethodCallingConvention.Default:
return("default");
case MethodCallingConvention.VarArg:
return("vararg");
default:
throw new NotImplementedException(cconv.ToString());
}
}
private static bool CompareCallingConventions(MethodCallingConvention callingConvention, MethodBase methodBase)
{
if (callingConvention.HasFlag(MethodCallingConvention.Static) != methodBase.IsStatic)
{
return(false);
}
if (callingConvention.HasFlag(MethodCallingConvention.Generic) != (methodBase.IsGenericMethod | methodBase.IsGenericMethodDefinition))
{
return(false);
}
return(true);
}
/// <summary>
/// Initializes a new instance of the <see cref="MethodSignature"/> class.
/// </summary>
/// <param name="signature">The signature.</param>
public MethodSignature(MethodSignature signature)
: base(signature)
{
this.methodCallingConvention = signature.methodCallingConvention;
this.hasExplicitThis = signature.hasExplicitThis;
this.hasThis = signature.hasThis;
this.returnType = signature.returnType;
this.genericParameterCount = signature.genericParameterCount;
this.parameters = new SigType[signature.parameters.Length];
for (int i = 0; i < signature.parameters.Length; i++)
{
this.parameters[i] = signature.parameters[i];
}
}
public static CallingConvention CecilCConvToInteropCConv(MethodCallingConvention methodCallingConvention)
{
switch (methodCallingConvention)
{
case MethodCallingConvention.C:
return CallingConvention.Cdecl;
case MethodCallingConvention.FastCall:
return CallingConvention.FastCall;
case MethodCallingConvention.StdCall:
return CallingConvention.StdCall;
case MethodCallingConvention.ThisCall:
return CallingConvention.ThisCall;
default:
return CallingConvention.Winapi;
}
}
public static CallingConventions GetCallingConventions(MethodReference methodReference)
{
MethodCallingConvention c = (MethodCallingConvention)((int)methodReference.CallingConvention & 0x0f);
switch (c)
{
case MethodCallingConvention.ThisCall:
return(CallingConventions.HasThis);
case MethodCallingConvention.VarArg:
return(CallingConventions.VarArgs);
default:
return(CallingConventions.Standard);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="MethodSignature"/> class.
/// </summary>
/// <param name="returnType">Type of the return value.</param>
/// <param name="parameters">The parameter types.</param>
public MethodSignature(SigType returnType, SigType[] parameters)
{
if (returnType == null)
{
throw new ArgumentNullException(@"returnType");
}
if (parameters == null)
{
throw new ArgumentNullException(@"parameters");
}
this.methodCallingConvention = MethodCallingConvention.Default;
this.hasExplicitThis = false;
this.hasThis = false;
this.parameters = parameters;
this.returnType = returnType;
this.genericParameterCount = 0;
}
/// <summary>
/// Adds a new method to the <paramref name="typeDef">target type</paramref>.
/// </summary>
/// <param name="typeDef">The type that will hold the newly-created method.</param>
/// <param name="attributes">The <see cref="Mono.Cecil.MethodAttributes"/> parameter that describes the characteristics of the method.</param>
/// <param name="methodName">The name to be given to the new method.</param>
/// <param name="returnType">The method return type.</param>
/// <param name="callingConvention">The calling convention of the method being created.</param>
/// <param name="parameterTypes">The list of argument types that will be used to define the method signature.</param>
/// <returns>A <see cref="MethodDefinition"/> instance that represents the newly-created method.</returns>
public static MethodDefinition DefineMethod(this TypeDefinition typeDef, string methodName,
MethodAttributes attributes, MethodCallingConvention callingConvention, Type returnType, params Type[] parameterTypes)
{
var method = new MethodDefinition(methodName, attributes, null)
{
CallingConvention = callingConvention
};
typeDef.Methods.Add(method);
// Match the parameter types
method.AddParameters(parameterTypes);
// Match the return type
method.SetReturnType(returnType);
return(method);
}
internal bool IsStaticMethodSignature(RuntimeSignature methodSig)
{
if (methodSig.IsNativeLayoutSignature)
{
NativeReader reader = GetNativeLayoutInfoReader(methodSig.ModuleHandle);
NativeParser parser = new NativeParser(reader, methodSig.NativeLayoutOffset);
MethodCallingConvention callingConvention = (MethodCallingConvention)parser.GetUnsigned();
return(callingConvention.HasFlag(MethodCallingConvention.Static));
}
else
{
var metadataReader = ModuleList.Instance.GetMetadataReaderForModule(methodSig.ModuleHandle);
var methodHandle = methodSig.Token.AsHandle().ToMethodHandle(metadataReader);
var method = methodHandle.GetMethod(metadataReader);
return((method.Flags & MethodAttributes.Static) != 0);
}
}
/// <summary>
/// Parses the signature.
/// </summary>
/// <param name="reader">The reader.</param>
protected sealed override void ParseSignature(SignatureReader reader)
{
byte value = reader.ReadByte();
// Check for instance signature
if (HAS_THIS == (value & HAS_THIS))
{
hasThis = true;
}
if (HAS_EXPLICIT_THIS == (value & HAS_EXPLICIT_THIS))
{
hasExplicitThis = true;
}
if (GENERIC == (value & GENERIC))
{
methodCallingConvention = MethodCallingConvention.Generic;
genericParameterCount = reader.ReadCompressedInt32();
}
else if (VARARG == (value & VARARG))
{
methodCallingConvention = MethodCallingConvention.VarArg;
}
else if ((value & 0x1F) != 0x00)
{
throw new InvalidOperationException(@"Invalid method definition signature.");
}
// Number of parameters
int paramCount = reader.ReadCompressedInt32();
parameters = new SigType[paramCount];
// Read the return type
returnType = SigType.ParseTypeSignature(reader);
// Read all parameters
for (int i = 0; i < paramCount; i++)
{
parameters[i] = SigType.ParseTypeSignature(reader);
}
}
internal bool IsStaticMethodSignature(RuntimeSignature methodSig)
{
if (methodSig.IsNativeLayoutSignature)
{
NativeReader reader = GetNativeLayoutInfoReader(methodSig);
NativeParser parser = new NativeParser(reader, methodSig.NativeLayoutOffset);
MethodCallingConvention callingConvention = (MethodCallingConvention)parser.GetUnsigned();
return(callingConvention.HasFlag(MethodCallingConvention.Static));
}
else
{
ModuleInfo module = methodSig.GetModuleInfo();
#if ECMA_METADATA_SUPPORT
if (module is NativeFormatModuleInfo)
#endif
{
NativeFormatModuleInfo nativeFormatModule = (NativeFormatModuleInfo)module;
var metadataReader = nativeFormatModule.MetadataReader;
var methodHandle = methodSig.Token.AsHandle().ToMethodHandle(metadataReader);
var method = methodHandle.GetMethod(metadataReader);
return((method.Flags & MethodAttributes.Static) != 0);
}
#if ECMA_METADATA_SUPPORT
else
{
EcmaModuleInfo ecmaModuleInfo = (EcmaModuleInfo)module;
var metadataReader = ecmaModuleInfo.MetadataReader;
var ecmaHandle = (System.Reflection.Metadata.MethodDefinitionHandle)System.Reflection.Metadata.Ecma335.MetadataTokens.Handle(methodSig.Token);
var method = metadataReader.GetMethodDefinition(ecmaHandle);
var blobHandle = method.Signature;
var blobReader = metadataReader.GetBlobReader(blobHandle);
byte sigByte = blobReader.ReadByte();
return((sigByte & (byte)System.Reflection.Metadata.SignatureAttributes.Instance) == 0);
}
#endif
}
}
internal bool GetCallingConverterDataFromMethodSignature_NativeLayout(TypeSystemContext context, IntPtr methodSig, NativeLayoutInfoLoadContext nativeLayoutContext, out bool hasThis, out TypeDesc[] parameters, out bool[] parametersWithGenericDependentLayout)
{
hasThis = false;
parameters = null;
IntPtr moduleHandle = RuntimeAugments.GetModuleFromPointer(methodSig);
NativeReader reader = GetNativeLayoutInfoReader(moduleHandle);
NativeParser parser = new NativeParser(reader, reader.AddressToOffset(methodSig));
MethodCallingConvention callingConvention = (MethodCallingConvention)parser.GetUnsigned();
hasThis = !callingConvention.HasFlag(MethodCallingConvention.Static);
uint numGenArgs = callingConvention.HasFlag(MethodCallingConvention.Generic) ? parser.GetUnsigned() : 0;
uint parameterCount = parser.GetUnsigned();
parameters = new TypeDesc[parameterCount + 1];
parametersWithGenericDependentLayout = new bool[parameterCount + 1];
// One extra parameter to account for the return type
for (uint i = 0; i <= parameterCount; i++)
{
// NativeParser is a struct, so it can be copied.
NativeParser parserCopy = parser;
// Parse the signature twice. The first time to find out the exact type of the signature
// The second time to identify if the parameter loaded via the signature should be forced to be
// passed byref as part of the universal generic calling convention.
parameters[i] = GetConstructedTypeFromParserAndNativeLayoutContext(ref parser, nativeLayoutContext);
parametersWithGenericDependentLayout[i] = TypeSignatureHasVarsNeedingCallingConventionConverter(ref parserCopy, context, HasVarsInvestigationLevel.Parameter);
if (parameters[i] == null)
{
return(false);
}
}
return(true);
}
private static Type GetConvention(MethodCallingConvention convention)
{
switch (convention)
{
case MethodCallingConvention.C:
return(typeof(System.Runtime.CompilerServices.CallConvCdecl));
case MethodCallingConvention.Default:
return(null);
case MethodCallingConvention.FastCall:
return(typeof(System.Runtime.CompilerServices.CallConvFastcall));
case MethodCallingConvention.StdCall:
return(typeof(System.Runtime.CompilerServices.CallConvStdcall));
case MethodCallingConvention.ThisCall:
return(typeof(System.Runtime.CompilerServices.CallConvThiscall));
default:
throw new NotSupportedException();
}
}
private bool CompareMethodSigs(NativeParser parser1, NativeFormatModuleInfo moduleHandle1, NativeParser parser2, NativeFormatModuleInfo moduleHandle2)
{
MethodCallingConvention callingConvention1 = (MethodCallingConvention)parser1.GetUnsigned();
MethodCallingConvention callingConvention2 = (MethodCallingConvention)parser2.GetUnsigned();
if (callingConvention1 != callingConvention2)
{
return(false);
}
if ((callingConvention1 & MethodCallingConvention.Generic) == MethodCallingConvention.Generic)
{
if (parser1.GetUnsigned() != parser2.GetUnsigned())
{
return(false);
}
}
uint parameterCount1 = parser1.GetUnsigned();
uint parameterCount2 = parser2.GetUnsigned();
if (parameterCount1 != parameterCount2)
{
return(false);
}
// Compare one extra parameter to account for the return type
for (uint i = 0; i <= parameterCount1; i++)
{
if (!CompareTypeSigs(ref parser1, moduleHandle1, ref parser2, moduleHandle2))
{
return(false);
}
}
return(true);
}
private bool CompareCallingConventions(MethodCallingConvention callingConvention)
{
return (callingConvention.HasFlag(MethodCallingConvention.Static) == _isStatic) &&
(callingConvention.HasFlag(MethodCallingConvention.Generic) == _isGeneric);
}
/// <summary>
/// Parses the signature.
/// </summary>
/// <param name="reader">The reader.</param>
protected override sealed void ParseSignature(SignatureReader reader)
{
byte value = reader.ReadByte();
// Check for instance signature
if (HAS_THIS == (value & HAS_THIS))
{
hasThis = true;
}
if (HAS_EXPLICIT_THIS == (value & HAS_EXPLICIT_THIS))
{
hasExplicitThis = true;
}
if (GENERIC == (value & GENERIC))
{
methodCallingConvention = MethodCallingConvention.Generic;
genericParameterCount = reader.ReadCompressedInt32();
}
else if (VARARG == (value & VARARG))
{
methodCallingConvention = MethodCallingConvention.VarArg;
}
else if ((value & 0x1F) != 0x00)
{
throw new InvalidOperationException(@"Invalid method definition signature.");
}
// Number of parameters
int paramCount = reader.ReadCompressedInt32();
parameters = new SigType[paramCount];
// Read the return type
returnType = SigType.ParseTypeSignature(reader);
// Read all parameters
for (int i = 0; i < paramCount; i++)
parameters[i] = SigType.ParseTypeSignature(reader);
}
public FunctionPointerType(bool hasThis, bool explicitThis, MethodCallingConvention callConv, MethodReturnType retType)
: base(retType.ReturnType)
{
m_function = new MethodReference ("method", hasThis, explicitThis, callConv);
m_function.ReturnType = retType;
}
/// <summary>
/// Initializes a new instance of the <see cref="MethodSignature"/> class.
/// </summary>
/// <param name="returnType">Type of the return value.</param>
/// <param name="parameters">The parameter types.</param>
public MethodSignature(SigType returnType, SigType[] parameters)
{
if (returnType == null)
throw new ArgumentNullException(@"returnType");
if (parameters == null)
throw new ArgumentNullException(@"parameters");
this.methodCallingConvention = MethodCallingConvention.Default;
this.hasExplicitThis = false;
this.hasThis = false;
this.parameters = parameters;
this.returnType = returnType;
this.genericParameterCount = 0;
}
/// <summary>
/// Initializes a new instance of the <see cref="MethodSignature"/> class.
/// </summary>
/// <param name="signature">The signature.</param>
public MethodSignature(MethodSignature signature)
: base(signature)
{
this.methodCallingConvention = signature.methodCallingConvention;
this.hasExplicitThis = signature.hasExplicitThis;
this.hasThis = signature.hasThis;
this.returnType = signature.returnType;
this.genericParameterCount = signature.genericParameterCount;
this.parameters = new SigType[signature.parameters.Length];
for (int i = 0; i < signature.parameters.Length; i++)
this.parameters[i] = signature.parameters[i];
}
private bool CompareCallingConventions(MethodCallingConvention callingConvention)
{
return((callingConvention.HasFlag(MethodCallingConvention.Static) == _isStatic) &&
(callingConvention.HasFlag(MethodCallingConvention.Generic) == _isGeneric));
}
/// <summary>
/// Adds a new method to the <paramref name="typeDef">target type</paramref>.
/// </summary>
/// <param name="typeDef">The type that will hold the newly-created method.</param>
/// <param name="attributes">The <see cref="Mono.Cecil.MethodAttributes"/> parameter that describes the characteristics of the method.</param>
/// <param name="methodName">The name to be given to the new method.</param>
/// <param name="returnType">The method return type.</param>
/// <param name="callingConvention">The calling convention of the method being created.</param>
/// <param name="parameterTypes">The list of argument types that will be used to define the method signature.</param>
/// <returns>A <see cref="MethodDefinition"/> instance that represents the newly-created method.</returns>
public static MethodDefinition DefineMethod(this TypeDefinition typeDef, string methodName,
MethodAttributes attributes, MethodCallingConvention callingConvention, Type returnType, params Type[] parameterTypes)
{
var method = new MethodDefinition(methodName, attributes, null)
{
CallingConvention = callingConvention
};
typeDef.Methods.Add(method);
// Match the parameter types
method.AddParameters(parameterTypes);
// Match the return type
method.SetReturnType(returnType);
return method;
}
private string GetParameterDeclarationListText(IParameterDeclarationCollection value, MethodCallingConvention callingConvention)
{
using (StringWriter writer = new StringWriter(CultureInfo.InvariantCulture))
{
for (int i = 0; i < value.Count; i++)
{
IType parameterType = value[i].ParameterType;
if ((parameterType != null) || ((i + 1) != value.Count))
{
if (i != 0)
{
writer.Write(",");
}
if (parameterType == null)
{
writer.Write("...");
}
else
{
writer.Write(this.GetTypeText(parameterType));
}
}
}
if (callingConvention == MethodCallingConvention.VariableArguments)
{
if (value.Count > 0)
{
writer.Write(",");
}
writer.Write("...");
}
return writer.ToString();
}
}
public FunctionPointerType(bool hasThis, bool explicitThis, MethodCallingConvention callConv, MethodReturnType retType) :
base(retType.ReturnType)
{
m_function = new MethodReference("method", hasThis, explicitThis, callConv);
m_function.ReturnType = retType;
}
private static bool CompareCallingConventions(MethodCallingConvention callingConvention, MethodBase methodBase)
{
if (callingConvention.HasFlag(MethodCallingConvention.Static) != methodBase.IsStatic)
return false;
if (callingConvention.HasFlag(MethodCallingConvention.Generic) != (methodBase.IsGenericMethod | methodBase.IsGenericMethodDefinition))
return false;
return true;
}
public CallSite(bool hasThis, bool explicitThis, MethodCallingConvention callConv, MethodReturnType retType)
{
m_function = new MethodReference(string.Empty, hasThis, explicitThis, callConv);
m_function.ReturnType = retType;
}
string StringifyCallingConvention (MethodCallingConvention cconv) {
switch (cconv) {
case MethodCallingConvention.Default:
return "default";
case MethodCallingConvention.VarArg:
return "vararg";
default:
throw new NotImplementedException (cconv.ToString ());
}
}
public CallSite (bool hasThis, bool explicitThis, MethodCallingConvention callConv, MethodReturnType retType)
{
m_function = new MethodReference (string.Empty, hasThis, explicitThis, callConv);
m_function.ReturnType = retType;
}
void WriteMethodCallingConvention (MethodCallingConvention cc)
{
m_writer.WriteFlags ((int) cc, m_methodCallConvVals, m_methodCallConvMap);
}
