/// <summary>
/// Link time code generator used to compile dynamically created methods during link time.
/// </summary>
/// <param name="compiler">The assembly compiler used to compile this method.</param>
/// <param name="methodName">The name of the created method.</param>
/// <param name="instructionSet">The instruction set.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentNullException"><paramref name="compiler"/>, <paramref name="methodName"/> or <paramref name="instructionSet"/> is null.</exception>
/// <exception cref="System.ArgumentException"><paramref name="methodName"/> is invalid.</exception>
public static LinkerGeneratedMethod Compile(AssemblyCompiler compiler, string methodName, InstructionSet instructionSet, ITypeSystem typeSystem)
{
if (compiler == null)
throw new ArgumentNullException(@"compiler");
if (methodName == null)
throw new ArgumentNullException(@"methodName");
if (methodName.Length == 0)
throw new ArgumentException(@"Invalid method name.");
LinkerGeneratedType compilerGeneratedType = typeSystem.InternalTypeModule.GetType(@"Mosa.Tools.Compiler", @"LinkerGenerated") as LinkerGeneratedType;
// Create the type if we need to.
if (compilerGeneratedType == null)
{
compilerGeneratedType = new LinkerGeneratedType(typeSystem.InternalTypeModule, @"Mosa.Tools.Compiler", @"LinkerGenerated", null);
typeSystem.AddInternalType(compilerGeneratedType);
}
MethodSignature signature = new MethodSignature(BuiltInSigType.Void, new SigType[0]);
// Create the method
// HACK: <$> prevents the method from being called from CIL
LinkerGeneratedMethod method = new LinkerGeneratedMethod(typeSystem.InternalTypeModule, "<$>" + methodName, compilerGeneratedType, signature);
compilerGeneratedType.AddMethod(method);
LinkerMethodCompiler methodCompiler = new LinkerMethodCompiler(compiler, compiler.Pipeline.FindFirst<ICompilationSchedulerStage>(), method, instructionSet);
methodCompiler.Compile();
return method;
}
public override IEnumerable GetValues()
{
yield return TokenString("Name", row.NameString);
yield return Value("Flags", row.Flags.ToString());
yield return Value("ImplFlags", row.ImplFlags.ToString());
yield return Value("ParamList", row.ParamList);
yield return Value("Rva", row.Rva.ToString());
MethodSignature signature = new MethodSignature(Metadata, row.SignatureBlob);
yield return Value("Signature", signature.ToString());
if (row.Rva != 0)
{
var code = MetadataModule.GetInstructionStream((long)row.Rva);
var codeReader = new EndianAwareBinaryReader(code, Endianness.Little);
var header = new MethodHeader(codeReader);
if (header.LocalVarSigTok.RID != 0)
{
yield return Value("LocalVarSigTok", header.LocalVarSigTok.ToString());
StandAloneSigRow standAlongSigRow = Metadata.ReadStandAloneSigRow(header.LocalVarSigTok);
var local = new LocalVariableSignature(Metadata, standAlongSigRow.SignatureBlob);
yield return Value("Method Header", local.ToString());
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CilGenericMethod"/> class.
/// </summary>
/// <param name="module">The module.</param>
/// <param name="genericMethod">The generic method.</param>
/// <param name="signature">The signature.</param>
/// <param name="declaringType">Type of the declaring.</param>
public CilGenericMethod(ITypeModule module, CilRuntimeMethod genericMethod, MethodSignature signature, RuntimeType declaringType)
: base(module, genericMethod.Token, declaringType)
{
this.Signature = signature;
this.Attributes = genericMethod.Attributes;
this.ImplAttributes = genericMethod.ImplAttributes;
this.Rva = genericMethod.Rva;
this.Parameters = genericMethod.Parameters;
base.Name = genericMethod.Name;
}
/// <summary>
/// Initializes a new instance of the <see cref="LinkerGeneratedMethod"/> class.
/// </summary>
/// <param name="typeSystem">The type system.</param>
/// <param name="name">The name of the method.</param>
/// <param name="declaringType">Type of the declaring.</param>
public LinkerGeneratedMethod(ITypeModule typeSystem, string name, RuntimeType declaringType, MethodSignature signature)
: base(typeSystem, Token.Zero, declaringType)
{
if (name == null)
throw new ArgumentNullException(@"name");
base.Name = name;
base.Signature = signature;
this.Parameters = new List<RuntimeParameter>();
}
/// <summary>
/// Initializes a new instance of the <see cref="CilRuntimeMethod"/> class.
/// </summary>
/// <param name="module">The module.</param>
/// <param name="name">The name.</param>
/// <param name="signature">The signature.</param>
/// <param name="token">The token.</param>
/// <param name="declaringType">Type of the declaring.</param>
/// <param name="methodAttributes">The method attributes.</param>
/// <param name="methodImplAttributes">The method impl attributes.</param>
/// <param name="rva">The rva.</param>
public CilRuntimeMethod(ITypeModule module, string name, MethodSignature signature, Token token, RuntimeType declaringType, MethodAttributes methodAttributes, MethodImplAttributes methodImplAttributes, uint rva)
: base(module, token, declaringType)
{
base.Attributes = methodAttributes;
base.ImplAttributes = methodImplAttributes;
base.Rva = rva;
this.Name = name;
this.Signature = signature;
this.Parameters = new List<RuntimeParameter>();
}
public override IEnumerable GetValues()
{
yield return TokenString("Name", row.NameStringIdx);
yield return Value("NameStringIdx", row.NameStringIdx);
yield return Value("Flags", row.Flags.ToString());
yield return Value("ImplFlags", row.ImplFlags.ToString());
yield return Value("ParamList", row.ParamList);
yield return Value("Rva", row.Rva.ToString());
yield return Value("SignatureBlobIdx", row.SignatureBlobIdx);
MethodSignature signature = new MethodSignature(Metadata, row.SignatureBlobIdx);
yield return Value("Signature Token", signature.Token);
yield return Value("Signature Generic Parameters", signature.GenericParameterCount.ToString());
}
/// <summary>
/// Matches the specified other.
/// </summary>
/// <param name="other">The other.</param>
/// <returns></returns>
public bool Matches(MethodSignature other)
{
if (object.ReferenceEquals(this, other))
return true;
// TODO: Check this to make sure it is correct
if (other.GenericParameterCount != this.GenericParameterCount)
return false;
if (other.MethodCallingConvention != this.MethodCallingConvention)
return false;
if (other.HasThis != this.HasThis)
return false;
if (other.HasExplicitThis != this.HasExplicitThis)
return false;
if (this.Parameters.Length != other.Parameters.Length)
return false;
if (!this.ReturnType.Matches(other.ReturnType))
return false;
for (int i = 0; i < this.Parameters.Length; i++)
{
if (!this.Parameters[i].Matches(other.Parameters[i]))
return false;
}
return true;
}
/// <summary>
/// Initializes a new instance of the <see cref="MethodSignature"/> class.
/// </summary>
/// <param name="signature">The signature.</param>
/// <param name="genericArguments">The generic arguments.</param>
public MethodSignature(MethodSignature signature, SigType[] genericArguments)
: this(signature)
{
ApplyGenericArguments(genericArguments);
}
/// <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 void ResolveMethods()
{
foreach (CilRuntimeMethod method in baseGenericType.Methods)
{
var signature = new MethodSignature(method.Signature, genericArguments);
var genericInstanceMethod = new CilGenericMethod(Module, method, signature, this);
Methods.Add(genericInstanceMethod);
}
}
