public T Run <T>(TestCompilerSettings settings, string ns, string type, string method, params object[] parameters)
{
CompileTestCode(settings);
// Find the test method to execute
RuntimeMethod runtimeMethod = FindMethod(
ns,
type,
method
);
Debug.Assert(runtimeMethod != null, runtimeMethod.ToString());
//Debug.Assert(runtimeMethod.Address != null, runtimeMethod.ToString());
//Debug.Assert(runtimeMethod.Address != IntPtr.Zero, runtimeMethod.ToString());
// Get delegate name
string delegateName;
if (default(T) is System.ValueType)
{
delegateName = "Mosa.Test.Prebuilt.Delegates+" + DelegateUtility.GetDelegteName(default(T), parameters);
}
else
{
delegateName = "Mosa.Test.Prebuilt.Delegates+" + DelegateUtility.GetDelegteName(null, parameters);
}
// Get the prebuilt delegate type
Type delegateType = Prebuilt.GetType(delegateName);
Debug.Assert(delegateType != null, delegateName);
IntPtr address = linker.GetSymbol(runtimeMethod.ToString()).VirtualAddress;
// Create a delegate for the test method
Delegate fn = Marshal.GetDelegateForFunctionPointer(
address,
delegateType
);
// Execute the test method
object tempResult = fn.DynamicInvoke(parameters);
try
{
if (default(T) is System.ValueType)
{
return((T)tempResult);
}
else
{
return(default(T));
}
}
catch (InvalidCastException e)
{
Assert.Fail(@"Failed to convert result {0} of type {1} to type {2}.", tempResult, tempResult.GetType(), typeof(T));
throw e;
}
}
protected string FormatRuntimeMember(RuntimeMethod method)
{
if (!showTokenValues.Checked)
{
return(method.Name);
}
return("[" + TokenToString(method.Token) + "] " + method.ToString());
}
private void CompileMethod(RuntimeMethod method)
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.Write(@"[Compiling] ");
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine(method.ToString());
Debug.WriteLine(@"Compiling " + method.ToString());
using (IMethodCompiler mc = compiler.CreateMethodCompiler(this, method.DeclaringType, method))
{
mc.Compile();
//try
//{
// mc.Compile();
//}
//catch (Exception e)
//{
// HandleCompilationException(e);
// throw;
//}
}
}
/// <summary>
/// Performs stage specific processing on the compiler context.
/// </summary>
void IAssemblyCompilerStage.Run()
{
CheckImplementation();
ITypeModule mainModule = typeSystem.MainTypeModule;
if (mainModule.MetadataModule.EntryPoint.RID != 0)
{
RuntimeMethod entrypoint = mainModule.GetMethod(mainModule.MetadataModule.EntryPoint);
implementation.EntryPoint = GetSymbol(entrypoint.ToString());
}
// Run the real linker
IAssemblyCompilerStage assemblyCompilerStage = implementation as IAssemblyCompilerStage;
Debug.Assert(assemblyCompilerStage != null, @"Linker doesn't implement IAssemblyCompilerStage.");
if (assemblyCompilerStage != null)
{
assemblyCompilerStage.Run();
}
}
/// <summary>
/// Issues a linker request for the given runtime method.
/// </summary>
/// <param name="linkType">The type of link required.</param>
/// <param name="method">The method the patched code belongs to.</param>
/// <param name="methodOffset">The offset inside the method where the patch is placed.</param>
/// <param name="methodRelativeBase">The base virtualAddress, if a relative link is required.</param>
/// <param name="targetSymbolName">The linker symbol to link against.</param>
/// <param name="offset">The offset to apply to the symbol to link against.</param>
/// <returns>
/// The return value is the preliminary virtualAddress to place in the generated machine
/// code. On 32-bit systems, only the lower 32 bits are valid. The above are not used. An implementation of
/// IAssemblyLinker may not rely on 64-bits being stored in the memory defined by position.
/// </returns>
public virtual long Link(LinkType linkType, RuntimeMethod method, int methodOffset, int methodRelativeBase, string targetSymbolName, IntPtr offset)
{
Debug.Assert(null != targetSymbolName, @"Symbol can't be null.");
if (null == targetSymbolName)
throw new ArgumentNullException(@"symbol");
string symbolName = method.ToString();
return this.Link(linkType, symbolName, methodOffset, methodRelativeBase, targetSymbolName, offset);
}
/// <summary>
/// Creates a symbol operand for the given method.
/// </summary>
/// <param name="method">The method to create a symbol operand for.</param>
/// <returns>The created symbol operand.</returns>
public static SymbolOperand FromMethod(RuntimeMethod method)
{
string symbolName = method.ToString();
return new SymbolOperand(BuiltInSigType.IntPtr, symbolName);
}
private void CompileMethod(RuntimeMethod method)
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.Write(@"[Compiling] ");
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine(method.ToString());
Debug.WriteLine(@"Compiling " + method.ToString());
using (IMethodCompiler mc = compiler.CreateMethodCompiler(this, method.DeclaringType, method))
{
mc.Compile();
//try
//{
// mc.Compile();
//}
//catch (Exception e)
//{
// HandleCompilationException(e);
// throw;
//}
}
}
/// <summary>
/// Requests a stream to emit native instructions to.
/// </summary>
/// <returns>A stream object, which can be used to store emitted instructions.</returns>
public virtual Stream RequestCodeStream()
{
return(linker.Allocate(method.ToString(), SectionKind.Text, 0, 0));
}
private string CreateSymbolName(RuntimeMethod symbol)
{
//if (symbol == null)
// throw new ArgumentNullException("symbol");
//// TODO: If it is a generic method instance, then the symbol name needs to be carefully constructed. ~BMarkham,2/18/09
//if (symbol.IsGeneric)
// throw new NotImplementedException();
//StringBuilder sb = new StringBuilder();
//sb.Append(CreateSymbolName(symbol.DeclaringType));
//sb.Append('.');
//sb.Append(symbol.Name);
//sb.Append('(');
//bool hasEmittedSignaturePart = false;
//foreach (SigType parameterSignatureType in symbol.Signature.Parameters) {
// if (hasEmittedSignaturePart)
// sb.Append(',');
// sb.Append(parameterSignatureType.ToSymbolPart()); // FIXME : This obviously doesn't work! We need to emit class names.
// hasEmittedSignaturePart = true;
//}
//sb.Append(')');
//return sb.ToString();
string symbolName = symbol.ToString();
return symbolName;
}
/// <summary>
/// Creates a symbol operand for the given method.
/// </summary>
/// <param name="method">The method to create a symbol operand for.</param>
/// <returns>The created symbol operand.</returns>
public static SymbolOperand FromMethod(RuntimeMethod method)
{
string symbolName = method.ToString();
return(new SymbolOperand(BuiltInSigType.IntPtr, symbolName));
}