mirror of
https://github.com/danbulant/Cosmos
synced 2026-05-20 04:48:53 +00:00
1076 lines
No EOL
48 KiB
C#
1076 lines
No EOL
48 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Reflection;
|
|
using Indy.IL2CPU.IL;
|
|
using Indy.IL2CPU.Plugs;
|
|
using Indy.IL2CPU.Assembler;
|
|
using System.Xml;
|
|
using System.Runtime.InteropServices;
|
|
using System.Diagnostics.SymbolStore;
|
|
using Microsoft.Samples.Debugging.CorSymbolStore;
|
|
|
|
|
|
namespace Indy.IL2CPU.Compiler
|
|
{
|
|
/// <summary>
|
|
/// This is our new compiler class. It will compile an assembly completely. It doesn't do any scanning, but just compiles each type and method.
|
|
/// </summary>
|
|
public partial class AssemblyCompiler
|
|
{
|
|
public AssemblyCompiler()
|
|
{
|
|
Plugs = new List<string>();
|
|
AssemblyReferences = new List<string>();
|
|
Types = new List<Type>();
|
|
Methods = new List<MethodBase>();
|
|
StaticFields = new List<FieldInfo>();
|
|
}
|
|
|
|
#region Settings properties
|
|
|
|
public Assembly Assembly
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public OpCodeMap OpCodeMap
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public Assembler.Assembler Assembler
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public List<string> Plugs
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public DebugMode DebugMode
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public byte DebugComNumber
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public bool IsEntrypointAssembly
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public List<string> AssemblyReferences
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
public Action<LogSeverityEnum, string> DebugLog;
|
|
|
|
#endregion Setting Properties
|
|
|
|
public void Execute()
|
|
{
|
|
EnsureCanExecute();
|
|
Initialize();
|
|
ScanAssembly();
|
|
CompileAllMethods();
|
|
CompileAllStaticFields();
|
|
}
|
|
|
|
private void Initialize()
|
|
{
|
|
InitializePlugs(Plugs);
|
|
OpCodeMap.SetServiceProvider(this);
|
|
OpCodeMap.Initialize(Assembler, new []{Assembly});
|
|
}
|
|
|
|
private void ScanAssembly()
|
|
{
|
|
foreach (var xType in Assembly.GetTypes())
|
|
{
|
|
Types.Add(xType);
|
|
}
|
|
foreach (var xType in Types)
|
|
{
|
|
foreach (var xMethod in xType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly))
|
|
{
|
|
Methods.Add(xMethod);
|
|
}
|
|
foreach (var xCtor in xType.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly))
|
|
{
|
|
Methods.Add(xCtor);
|
|
}
|
|
foreach (var xField in xType.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.DeclaredOnly))
|
|
{
|
|
StaticFields.Add(xField);
|
|
}
|
|
}
|
|
}
|
|
|
|
private MethodBase GetCustomMethodImplementation(string aMethodName)
|
|
{
|
|
if (mPlugMethods.ContainsKey(aMethodName))
|
|
{
|
|
return mPlugMethods[aMethodName];
|
|
}
|
|
return null;
|
|
}
|
|
|
|
|
|
private void CompileAllStaticFields()
|
|
{
|
|
foreach (var xField in StaticFields)
|
|
{
|
|
if (xField.DeclaringType.IsGenericTypeDefinition)
|
|
{
|
|
// the generic type definitions (Nullable<>) shouldnt be emitted
|
|
continue;
|
|
}
|
|
string xFieldName = xField.GetFullName();
|
|
xFieldName = DataMember.GetStaticFieldName(xField);
|
|
if (Assembler.DataMembers.Count(x => x.Name == xFieldName) == 0)
|
|
{
|
|
var xItemList = (from item in xField.GetCustomAttributes(false)
|
|
where item.GetType().FullName == "ManifestResourceStreamAttribute"
|
|
select item).ToList();
|
|
|
|
object xItem = null;
|
|
if (xItemList.Count > 0)
|
|
xItem = xItemList[0];
|
|
string xManifestResourceName = null;
|
|
if (xItem != null)
|
|
{
|
|
var xItemType = xItem.GetType();
|
|
xManifestResourceName = (string)xItemType.GetField("ResourceName").GetValue(xItem);
|
|
}
|
|
if (xManifestResourceName != null)
|
|
{
|
|
//RegisterType(xCurrentField.FieldType);
|
|
//string xFileName = Path.Combine(mOutputDir,
|
|
// (xCurrentField.DeclaringType.Assembly.FullName + "__" + xManifestResourceName).Replace(",",
|
|
// "_") + ".res");
|
|
//using (var xStream = xCurrentField.DeclaringType.Assembly.GetManifestResourceStream(xManifestResourceName)) {
|
|
// if (xStream == null) {
|
|
// throw new Exception("Resource '" + xManifestResourceName + "' not found!");
|
|
// }
|
|
// using (var xTarget = File.Create(xFileName)) {
|
|
// // todo: abstract this array code out.
|
|
// xTarget.Write(BitConverter.GetBytes(Engine.RegisterType(Engine.GetType("mscorlib",
|
|
// "System.Array"))),
|
|
// 0,
|
|
// 4);
|
|
// xTarget.Write(BitConverter.GetBytes((uint)InstanceTypeEnum.StaticEmbeddedArray),
|
|
// 0,
|
|
// 4);
|
|
// xTarget.Write(BitConverter.GetBytes((int)xStream.Length), 0, 4);
|
|
// xTarget.Write(BitConverter.GetBytes((int)1), 0, 4);
|
|
// var xBuff = new byte[128];
|
|
// while (xStream.Position < xStream.Length) {
|
|
// int xBytesRead = xStream.Read(xBuff, 0, 128);
|
|
// xTarget.Write(xBuff, 0, xBytesRead);
|
|
// }
|
|
// }
|
|
//}
|
|
//mAssembler.DataMembers.Add(new DataMember("___" + xFieldName + "___Contents",
|
|
// "incbin",
|
|
// "\"" + xFileName + "\""));
|
|
//mAssembler.DataMembers.Add(new DataMember(xFieldName,
|
|
// "dd",
|
|
// "___" + xFieldName + "___Contents"));
|
|
throw new NotImplementedException();
|
|
}
|
|
else
|
|
{
|
|
//RegisterType(xCurrentField.FieldType);
|
|
uint xTheSize;
|
|
//string theType = "db";
|
|
Type xFieldTypeDef = xField.FieldType;
|
|
if (!xFieldTypeDef.IsClass || xFieldTypeDef.IsValueType)
|
|
{
|
|
xTheSize = GetFieldStorageSize(xField.FieldType);
|
|
}
|
|
else
|
|
{
|
|
xTheSize = 4;
|
|
}
|
|
byte[] xData = new byte[xTheSize];
|
|
try
|
|
{
|
|
object xValue = xField.GetValue(null);
|
|
if (xValue != null)
|
|
{
|
|
try
|
|
{
|
|
xData = new byte[xTheSize];
|
|
if (xValue.GetType().IsValueType)
|
|
{
|
|
for (int x = 0; x < xTheSize; x++)
|
|
{
|
|
xData[x] = Marshal.ReadByte(xValue,
|
|
x);
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
Assembler.DataMembers.Add(new DataMember(xFieldName, xData));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public List<MethodBase> Methods;
|
|
public List<Type> Types;
|
|
public List<FieldInfo> StaticFields;
|
|
|
|
private int mInstructionsToSkip = 0;
|
|
private void CompileAllMethods()
|
|
{
|
|
// all methods are in Methods, so we just need to iterate over them.
|
|
foreach (var xCurrentMethod in Methods)
|
|
{
|
|
if (Console.KeyAvailable)
|
|
{
|
|
throw new Exception("Temporary abort");
|
|
}
|
|
TypeInformation xTypeInfo = null;
|
|
if (xCurrentMethod.IsAbstract)
|
|
{
|
|
continue;
|
|
}
|
|
if (xCurrentMethod.ContainsGenericParameters)
|
|
{
|
|
// we only want concrete methods
|
|
continue;
|
|
}
|
|
if (xCurrentMethod.DeclaringType.ContainsGenericParameters)
|
|
{
|
|
continue;
|
|
}
|
|
if (!xCurrentMethod.IsStatic)
|
|
{
|
|
xTypeInfo = GetTypeInfo(xCurrentMethod.DeclaringType);
|
|
}
|
|
var xMethodName = Label.GenerateLabelName(xCurrentMethod);
|
|
var xMethodScanInfo = new SortedList<string, object>(StringComparer.InvariantCultureIgnoreCase);
|
|
MethodInformation xMethodInfo = GetMethodInfo(xCurrentMethod, xCurrentMethod
|
|
, xMethodName, xTypeInfo, DebugMode != DebugMode.None, xMethodScanInfo);
|
|
|
|
#region Prescan method
|
|
try
|
|
{
|
|
ILReader xReader = new ILReader(xCurrentMethod);
|
|
MethodBody xBody = xCurrentMethod.GetMethodBody();
|
|
// todo: add better detection of implementation state
|
|
|
|
if (xBody != null)
|
|
{
|
|
mInstructionsToSkip = 0;
|
|
Assembler.StackContents.Clear();
|
|
|
|
var xInstructionInfos = new List<DebugSymbolsAssemblyTypeMethodInstruction>();
|
|
while (xReader.Read())
|
|
{
|
|
OpCodeMap.ScanILCode(xReader, xMethodInfo, xMethodScanInfo);
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
#endregion
|
|
|
|
#if VERBOSE_DEBUG
|
|
string comment = "(No Type Info available)";
|
|
if (xMethodInfo.TypeInfo != null)
|
|
{
|
|
comment = "Type Info:\r\n \r\n" + xMethodInfo.TypeInfo;
|
|
}
|
|
foreach (string s in comment.Trim().Split(new string[] { "\r\n" }
|
|
, StringSplitOptions.RemoveEmptyEntries))
|
|
{
|
|
new Comment(s);
|
|
}
|
|
comment = xMethodInfo.ToString();
|
|
foreach (string s in comment.Trim().Split(new string[] { "\r\n" }
|
|
, StringSplitOptions.RemoveEmptyEntries))
|
|
{
|
|
new Comment(s);
|
|
}
|
|
#endif
|
|
Op xOp = GetOpFromType(OpCodeMap.MethodHeaderOp, null, xMethodInfo);
|
|
xOp.Assembler = Assembler;
|
|
xOp.SetServiceProvider(this);
|
|
xOp.Assemble();
|
|
MethodBase xCustomImplementation = GetCustomMethodImplementation(xMethodName);
|
|
bool xIsCustomImplementation = (xCustomImplementation != null);
|
|
// what to do if a method doesn't have a body?
|
|
bool xContentProduced = false;
|
|
if (xIsCustomImplementation)
|
|
{
|
|
// this is for the support for having extra fields on types, and being able to use
|
|
// them in custom implementation methods
|
|
CustomMethodImplementationProxyOp xProxyOp = (CustomMethodImplementationProxyOp)GetOpFromType(OpCodeMap.CustomMethodImplementationProxyOp, null, xMethodInfo);
|
|
xProxyOp.SetServiceProvider(this);
|
|
xProxyOp.Assembler = Assembler;
|
|
xProxyOp.ProxiedMethod = xCustomImplementation;
|
|
xProxyOp.Assemble();
|
|
xContentProduced = true;
|
|
}
|
|
if (!xContentProduced)
|
|
{
|
|
Type xOpType = OpCodeMap.GetOpForCustomMethodImplementation(xMethodName);
|
|
if (xOpType != null)
|
|
{
|
|
Op xMethodOp = GetOpFromType(xOpType, null, xMethodInfo);
|
|
if (xMethodOp != null)
|
|
{
|
|
xMethodOp.Assembler = Assembler;
|
|
xMethodOp.SetServiceProvider(this);
|
|
xMethodOp.Assemble();
|
|
xContentProduced = true;
|
|
}
|
|
}
|
|
}
|
|
if (!xContentProduced)
|
|
{
|
|
if (OpCodeMap.HasCustomAssembleImplementation(xMethodInfo))
|
|
{
|
|
OpCodeMap.DoCustomAssembleImplementation(Assembler, xMethodInfo);
|
|
// No plugs, we need to compile the IL from the method
|
|
}
|
|
else
|
|
{
|
|
MethodBody xBody = xCurrentMethod.GetMethodBody();
|
|
// todo: add better detection of implementation state
|
|
if (xBody != null)
|
|
{
|
|
mInstructionsToSkip = 0;
|
|
Assembler.StackContents.Clear();
|
|
var xReader = new ILReader(xCurrentMethod);
|
|
if (xMethodInfo.LabelName == "_BBE9E9A7F7761F7DC23F15255BBB0FF7")
|
|
{
|
|
Console.Write("");
|
|
}
|
|
var xInstructionInfos = new List<DebugSymbolsAssemblyTypeMethodInstruction>();
|
|
|
|
// Section currently is dead code. Working on matching it up
|
|
// with contents from inside the read
|
|
int[] xCodeOffsets = null;
|
|
if (DebugMode == DebugMode.Source)
|
|
{
|
|
var xSymbolReader = GetSymbolReaderForAssembly(xCurrentMethod.DeclaringType.Assembly);
|
|
if (xSymbolReader != null)
|
|
{
|
|
var xSmbMethod = xSymbolReader.GetMethod(new SymbolToken(xCurrentMethod.MetadataToken));
|
|
// This gets the Sequence Points.
|
|
// Sequence Points are spots that identify what the compiler/debugger says is a spot
|
|
// that a breakpoint can occur one. Essentially, an atomic source line in C#
|
|
if (xSmbMethod != null)
|
|
{
|
|
xCodeOffsets = new int[xSmbMethod.SequencePointCount];
|
|
var xCodeDocuments = new ISymbolDocument[xSmbMethod.SequencePointCount];
|
|
var xCodeLines = new int[xSmbMethod.SequencePointCount];
|
|
var xCodeColumns = new int[xSmbMethod.SequencePointCount];
|
|
var xCodeEndLines = new int[xSmbMethod.SequencePointCount];
|
|
var xCodeEndColumns = new int[xSmbMethod.SequencePointCount];
|
|
xSmbMethod.GetSequencePoints(xCodeOffsets, xCodeDocuments
|
|
, xCodeLines, xCodeColumns, xCodeEndLines, xCodeEndColumns);
|
|
}
|
|
}
|
|
}
|
|
// Scan each IL op in the method
|
|
xReader = new ILReader(xCurrentMethod);
|
|
while (xReader.Read())
|
|
{
|
|
ExceptionHandlingClause xCurrentHandler = null;
|
|
|
|
#region Exception handling support code
|
|
// todo: add support for nested handlers using a stack or so..
|
|
foreach (ExceptionHandlingClause xHandler in xBody.ExceptionHandlingClauses)
|
|
{
|
|
if (xHandler.TryOffset > 0)
|
|
{
|
|
if (xHandler.TryOffset <= xReader.NextPosition && (xHandler.TryLength + xHandler.TryOffset) > xReader.NextPosition)
|
|
{
|
|
if (xCurrentHandler == null)
|
|
{
|
|
xCurrentHandler = xHandler;
|
|
continue;
|
|
}
|
|
else if (xHandler.TryOffset > xCurrentHandler.TryOffset && (xHandler.TryLength + xHandler.TryOffset) < (xCurrentHandler.TryLength + xCurrentHandler.TryOffset))
|
|
{
|
|
// only replace if the current found handler is narrower
|
|
xCurrentHandler = xHandler;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
if (xHandler.HandlerOffset > 0)
|
|
{
|
|
if (xHandler.HandlerOffset <= xReader.NextPosition && (xHandler.HandlerOffset + xHandler.HandlerLength) > xReader.NextPosition)
|
|
{
|
|
if (xCurrentHandler == null)
|
|
{
|
|
xCurrentHandler = xHandler;
|
|
continue;
|
|
}
|
|
else if (xHandler.HandlerOffset > xCurrentHandler.HandlerOffset && (xHandler.HandlerOffset + xHandler.HandlerLength) < (xCurrentHandler.HandlerOffset + xCurrentHandler.HandlerLength))
|
|
{
|
|
// only replace if the current found handler is narrower
|
|
xCurrentHandler = xHandler;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
if ((xHandler.Flags & ExceptionHandlingClauseOptions.Filter) > 0)
|
|
{
|
|
if (xHandler.FilterOffset > 0)
|
|
{
|
|
if (xHandler.FilterOffset <= xReader.NextPosition)
|
|
{
|
|
if (xCurrentHandler == null)
|
|
{
|
|
xCurrentHandler = xHandler;
|
|
continue;
|
|
}
|
|
else if (xHandler.FilterOffset > xCurrentHandler.FilterOffset)
|
|
{
|
|
// only replace if the current found handler is narrower
|
|
xCurrentHandler = xHandler;
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
xMethodInfo.CurrentHandler = xCurrentHandler;
|
|
xOp = GetOpFromType(OpCodeMap.GetOpForOpCode(xReader.OpCode), xReader, xMethodInfo);
|
|
|
|
xOp.Assembler = Assembler;
|
|
new Comment("StackItems = " + Assembler.StackContents.Count);
|
|
foreach (var xStackContent in Assembler.StackContents)
|
|
{
|
|
new Comment(" " + xStackContent.Size);
|
|
}
|
|
|
|
// Create label for current point
|
|
string xLabel = Op.GetInstructionLabel(xReader);
|
|
if (xLabel.StartsWith("."))
|
|
{
|
|
xLabel = DataMember.FilterStringForIncorrectChars(
|
|
Label.LastFullLabel + "__DOT__" + xLabel.Substring(1));
|
|
}
|
|
|
|
// Possibly emit Tracer call
|
|
EmitTracer(xOp, xCurrentMethod.DeclaringType.Namespace, (int)xReader.Position,
|
|
xCodeOffsets, xLabel);
|
|
|
|
//using (mSymbolsLocker.AcquireWriterLock())
|
|
//{
|
|
// if (mSymbols != null)
|
|
// {
|
|
// var xMLSymbol = new MLDebugSymbol();
|
|
// xMLSymbol.LabelName = xLabel;
|
|
// int xStackSize = (from item in mAssembler.StackContents
|
|
// let xSize = (item.Size % 4 == 0)
|
|
// ? item.Size
|
|
// : (item.Size + (4 - (item.Size % 4)))
|
|
// select xSize).Sum();
|
|
// xMLSymbol.StackDifference = xMethodInfo.LocalsSize + xStackSize;
|
|
// try
|
|
// {
|
|
// xMLSymbol.AssemblyFile = xCurrentMethod.DeclaringType.Assembly.Location;
|
|
// }
|
|
// catch (NotSupportedException)
|
|
// {
|
|
// xMLSymbol.AssemblyFile = "DYNAMIC: " + xCurrentMethod.DeclaringType.Assembly.FullName;
|
|
// }
|
|
// xMLSymbol.MethodToken = xCurrentMethod.MetadataToken;
|
|
// xMLSymbol.TypeToken = xCurrentMethod.DeclaringType.MetadataToken;
|
|
// xMLSymbol.ILOffset = (int)xReader.Position;
|
|
// mSymbols.Add(xMLSymbol);
|
|
// }
|
|
//}
|
|
xOp.SetServiceProvider(this);
|
|
xOp.Assemble();
|
|
}
|
|
//if (mSymbols != null && !EMITmode)
|
|
//{
|
|
// MLDebugSymbol[] xSymbols;
|
|
// using (mSymbolsLocker.AcquireReaderLock())
|
|
// {
|
|
// xSymbols = mSymbols.ToArray();
|
|
// }
|
|
// using (mMethodsLocker.AcquireReaderLock())
|
|
// {
|
|
// mMethods[xCurrentMethod].Instructions = xSymbols;
|
|
// }
|
|
//}
|
|
}
|
|
else
|
|
{
|
|
if ((xCurrentMethod.Attributes & MethodAttributes.PinvokeImpl) != 0)
|
|
{
|
|
LogMessage(LogSeverityEnum.Error,
|
|
"Method '{0}' not generated!",
|
|
xCurrentMethod.GetFullName());
|
|
new Comment("Method not being generated yet, as it's handled by a PInvoke");
|
|
}
|
|
else
|
|
{
|
|
LogMessage(LogSeverityEnum.Error,
|
|
"Method '{0}' not generated!",
|
|
xCurrentMethod.GetFullName());
|
|
new Comment("Method not being generated yet, as it's handled by an iCall");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
xOp = GetOpFromType(OpCodeMap.MethodFooterOp, null, xMethodInfo);
|
|
xOp.Assembler = Assembler;
|
|
xOp.SetServiceProvider(this);
|
|
xOp.Assemble();
|
|
Assembler.StackContents.Clear();
|
|
}
|
|
}
|
|
|
|
private static Op GetOpFromType(Type aType, ILReader aReader, MethodInformation aMethodInfo)
|
|
{
|
|
return (Op)Activator.CreateInstance(aType, aReader, aMethodInfo);
|
|
}
|
|
|
|
|
|
private IDictionary<string, MethodBase> mPlugMethods;
|
|
private IDictionary<Type, Dictionary<string, PlugFieldAttribute>> mPlugFields;
|
|
|
|
private Assembly CurrentDomain_AssemblyResolve(object sender,
|
|
ResolveEventArgs args)
|
|
{
|
|
if (File.Exists(Path.Combine(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location),
|
|
args.Name + ".dll")))
|
|
{
|
|
return Assembly.ReflectionOnlyLoadFrom(Path.Combine(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location),
|
|
args.Name + ".dll"));
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private void CurrentDomain_AssemblyLoad(object sender,
|
|
AssemblyLoadEventArgs args)
|
|
{
|
|
CheckAssemblyForPlugAssemblies(args.LoadedAssembly);
|
|
}
|
|
|
|
private static string GetStrippedMethodBaseFullName(MethodBase aMethod,
|
|
MethodBase aRefMethod)
|
|
{
|
|
StringBuilder xBuilder = new StringBuilder();
|
|
string[] xParts = aMethod.ToString().Split(' ');
|
|
string[] xParts2 = xParts.Skip(1).ToArray();
|
|
MethodInfo xMethodInfo = aMethod as MethodInfo;
|
|
if (xMethodInfo != null)
|
|
{
|
|
xBuilder.Append(xMethodInfo.ReturnType.FullName);
|
|
}
|
|
else
|
|
{
|
|
if (aMethod is ConstructorInfo)
|
|
{
|
|
xBuilder.Append(typeof(void).FullName);
|
|
}
|
|
else
|
|
{
|
|
xBuilder.Append(xParts[0]);
|
|
}
|
|
}
|
|
xBuilder.Append(" ");
|
|
xBuilder.Append(".");
|
|
xBuilder.Append(aMethod.Name);
|
|
xBuilder.Append("(");
|
|
ParameterInfo[] xParams = aMethod.GetParameters();
|
|
bool xParamAdded = false;
|
|
for (int i = 0; i < xParams.Length; i++)
|
|
{
|
|
if (i == 0 && (aRefMethod != null && !aRefMethod.IsStatic))
|
|
{
|
|
continue;
|
|
}
|
|
if (xParams[i].IsDefined(typeof(FieldAccessAttribute), true))
|
|
{
|
|
continue;
|
|
}
|
|
if (xParamAdded)
|
|
{
|
|
xBuilder.Append(", ");
|
|
}
|
|
xBuilder.Append(xParams[i].ParameterType.FullName);
|
|
xParamAdded = true;
|
|
}
|
|
xBuilder.Append(")");
|
|
return xBuilder.ToString();
|
|
}
|
|
|
|
|
|
private void LoadPlugAssembly(Assembly aAssemblyDef)
|
|
{
|
|
foreach (var xType in (from item in aAssemblyDef.GetTypes()
|
|
let xCustomAttribs = item.GetCustomAttributes(typeof(PlugAttribute),
|
|
false)
|
|
where xCustomAttribs != null && xCustomAttribs.Length > 0
|
|
select new KeyValuePair<Type, PlugAttribute>(item,
|
|
(PlugAttribute)xCustomAttribs[0])))
|
|
{
|
|
PlugAttribute xPlugAttrib = xType.Value;
|
|
if (xPlugAttrib.IsMonoOnly && !RunningOnMono)
|
|
{
|
|
continue;
|
|
}
|
|
if (xPlugAttrib.IsMicrosoftdotNETOnly && RunningOnMono)
|
|
{
|
|
continue;
|
|
}
|
|
Type xTypeRef = xPlugAttrib.Target;
|
|
if (xTypeRef == null)
|
|
{
|
|
xTypeRef = Type.GetType(xPlugAttrib.TargetName,
|
|
true);
|
|
}
|
|
|
|
PlugFieldAttribute[] xTypePlugFields = xType.Key.GetCustomAttributes(typeof(PlugFieldAttribute),
|
|
false) as PlugFieldAttribute[];
|
|
if (xTypePlugFields != null && xTypePlugFields.Length > 0)
|
|
{
|
|
Dictionary<string, PlugFieldAttribute> xPlugFields;
|
|
if (mPlugFields.ContainsKey(xTypeRef))
|
|
{
|
|
xPlugFields = mPlugFields[xTypeRef];
|
|
}
|
|
else
|
|
{
|
|
mPlugFields.Add(xTypeRef,
|
|
xPlugFields = new Dictionary<string, PlugFieldAttribute>());
|
|
}
|
|
foreach (var xPlugField in xTypePlugFields)
|
|
{
|
|
if (xPlugAttrib.IsMonoOnly && !RunningOnMono)
|
|
{
|
|
continue;
|
|
}
|
|
if (xPlugAttrib.IsMicrosoftdotNETOnly && RunningOnMono)
|
|
{
|
|
continue;
|
|
}
|
|
if (!xPlugFields.ContainsKey(xPlugField.FieldId))
|
|
{
|
|
xPlugFields.Add(xPlugField.FieldId,
|
|
xPlugField);
|
|
}
|
|
}
|
|
}
|
|
|
|
foreach (MethodBase xMethod in xType.Key.GetMethods(BindingFlags.Public | BindingFlags.Static))
|
|
{
|
|
PlugMethodAttribute xPlugMethodAttrib = xMethod.GetCustomAttributes(typeof(PlugMethodAttribute),
|
|
true).Cast<PlugMethodAttribute>().FirstOrDefault();
|
|
string xSignature = String.Empty;
|
|
if (xPlugMethodAttrib != null)
|
|
{
|
|
xSignature = xPlugMethodAttrib.Signature;
|
|
if (!xPlugMethodAttrib.Enabled)
|
|
{
|
|
continue;
|
|
}
|
|
if (xPlugAttrib.IsMonoOnly && !RunningOnMono)
|
|
{
|
|
continue;
|
|
}
|
|
if (xPlugAttrib.IsMicrosoftdotNETOnly && RunningOnMono)
|
|
{
|
|
continue;
|
|
}
|
|
if (!String.IsNullOrEmpty(xSignature))
|
|
{
|
|
if (!mPlugMethods.ContainsKey(xSignature))
|
|
{
|
|
mPlugMethods.Add(xSignature,
|
|
xMethod);
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
foreach (MethodBase xOrigMethodDef in xTypeRef.GetMethods(BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.NonPublic))
|
|
{
|
|
string xStrippedSignature = GetStrippedMethodBaseFullName(xMethod,
|
|
xOrigMethodDef);
|
|
string xOrigStrippedSignature = GetStrippedMethodBaseFullName(xOrigMethodDef,
|
|
null);
|
|
if (xOrigStrippedSignature == xStrippedSignature)
|
|
{
|
|
if (!mPlugMethods.ContainsKey(Label.GenerateLabelName(xOrigMethodDef)))
|
|
{
|
|
mPlugMethods.Add(Label.GenerateLabelName(xOrigMethodDef),
|
|
xMethod);
|
|
}
|
|
}
|
|
}
|
|
foreach (MethodBase xOrigMethodDef in xTypeRef.GetConstructors(BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.NonPublic))
|
|
{
|
|
string xStrippedSignature = GetStrippedMethodBaseFullName(xMethod,
|
|
xOrigMethodDef);
|
|
string xOrigStrippedSignature = GetStrippedMethodBaseFullName(xOrigMethodDef,
|
|
null);
|
|
if (xOrigStrippedSignature == xStrippedSignature)
|
|
{
|
|
if (mPlugMethods.ContainsKey(Label.GenerateLabelName(xOrigMethodDef)))
|
|
{
|
|
System.Diagnostics.Debugger.Break();
|
|
}
|
|
mPlugMethods.Add(Label.GenerateLabelName(xOrigMethodDef),
|
|
xMethod);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
private void CheckAssemblyForPlugAssemblies(Assembly aAssembly)
|
|
{
|
|
//If in the GAC, then ignore assembly
|
|
if (aAssembly.GlobalAssemblyCache)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// todo: try to get rid of the try..catch. find a way to detect dynamic assemblies.
|
|
try
|
|
{
|
|
//Search for related .config file
|
|
string configFile = aAssembly.Location + ".cosmos-config";
|
|
if (System.IO.File.Exists(configFile))
|
|
{
|
|
//Load and parse all PlugAssemblies referred to in the .config file
|
|
foreach (Assembly xAssembly in GetAssembliesFromConfigFile(configFile))
|
|
{
|
|
LoadPlugAssembly(xAssembly);
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Retrieves a list of plug assemblies from the given .config file.
|
|
/// </summary>
|
|
/// <param name="configFile"></param>
|
|
private IEnumerable<Assembly> GetAssembliesFromConfigFile(string configFile)
|
|
{
|
|
//Parse XML and get all the PlugAssembly names
|
|
XmlDocument xml = new XmlDocument();
|
|
xml.Load(configFile);
|
|
// do version check:
|
|
if (xml.DocumentElement.Attributes["version"] == null || xml.DocumentElement.Attributes["version"].Value != "1")
|
|
{
|
|
throw new Exception(".DLL configuration version mismatch!");
|
|
}
|
|
|
|
string xHintPath = null;
|
|
if (xml.DocumentElement.Attributes["hintpath"] != null)
|
|
{
|
|
xHintPath = xml.DocumentElement.Attributes["hintpath"].Value;
|
|
}
|
|
foreach (XmlNode assemblyName in xml.GetElementsByTagName("plug-assembly"))
|
|
{
|
|
string xName = assemblyName.InnerText;
|
|
if (xName.EndsWith(".dll",
|
|
StringComparison.InvariantCultureIgnoreCase) || xName.EndsWith(".exe",
|
|
StringComparison.InvariantCultureIgnoreCase))
|
|
{
|
|
if (!String.IsNullOrEmpty(xHintPath))
|
|
{
|
|
yield return Assembly.LoadFile(Path.Combine(xHintPath,
|
|
xName));
|
|
continue;
|
|
}
|
|
}
|
|
yield return Assembly.Load(assemblyName.InnerText);
|
|
}
|
|
}
|
|
|
|
private void InitializePlugs(IEnumerable<string> aPlugs)
|
|
{
|
|
if (mPlugMethods != null)
|
|
{
|
|
throw new Exception("PlugMethods list already initialized!");
|
|
}
|
|
if (mPlugFields != null)
|
|
{
|
|
throw new Exception("PlugFields list already initialized!");
|
|
}
|
|
|
|
mPlugMethods = new SortedList<string, MethodBase>();
|
|
mPlugFields = new SortedList<Type, Dictionary<string, PlugFieldAttribute>>(new TypeComparer());
|
|
|
|
AppDomain.CurrentDomain.AssemblyLoad += CurrentDomain_AssemblyLoad;
|
|
AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(CurrentDomain_AssemblyResolve);
|
|
foreach (var xAsm in AppDomain.CurrentDomain.GetAssemblies())
|
|
{
|
|
CheckAssemblyForPlugAssemblies(xAsm);
|
|
}
|
|
List<Assembly> xPlugs = new List<Assembly>();
|
|
var xComparer = new AssemblyEqualityComparer();
|
|
|
|
foreach (string s in aPlugs)
|
|
{
|
|
Assembly a = Assembly.LoadFrom(s);
|
|
a.GetTypes();
|
|
if (!xPlugs.Contains(a,
|
|
xComparer))
|
|
{
|
|
xPlugs.Add(a);
|
|
}
|
|
}
|
|
|
|
foreach (var item in GetPlugAssemblies())
|
|
{
|
|
if (!xPlugs.Contains(item,
|
|
xComparer))
|
|
{
|
|
xPlugs.Add(item);
|
|
}
|
|
}
|
|
|
|
foreach (Assembly xAssemblyDef in xPlugs)
|
|
{
|
|
LoadPlugAssembly(xAssemblyDef);
|
|
}
|
|
}
|
|
|
|
private IList<Assembly> GetPlugAssemblies()
|
|
{
|
|
var xResult = OpCodeMap.GetPlugAssemblies();
|
|
xResult.Add(typeof(AssemblyCompiler).Assembly);
|
|
return xResult;
|
|
}
|
|
|
|
public void LogMessage(LogSeverityEnum aSeverity, string aMessage, params object[] aArgs)
|
|
{
|
|
DebugLog(aSeverity, String.Format(aMessage, aArgs));
|
|
}
|
|
|
|
|
|
|
|
private void EnsureCanExecute()
|
|
{
|
|
if (Assembly == null)
|
|
{
|
|
throw new Exception("Cannot execute because no Assembly is specified");
|
|
}
|
|
if (Assembler == null)
|
|
{
|
|
throw new Exception("Cannot execute because no Assembler is specified");
|
|
}
|
|
if (OpCodeMap == null)
|
|
{
|
|
throw new Exception("Cannot execute because no OpCodeMap is specified");
|
|
}
|
|
if (IsEntrypointAssembly)
|
|
{
|
|
if (AssemblyReferences.Count ==0)
|
|
{
|
|
throw new Exception("EntrypointAssemblies should have their references specified!");
|
|
}
|
|
}
|
|
}
|
|
|
|
public readonly bool RunningOnMono;
|
|
|
|
public uint GetFieldStorageSize(Type aType)
|
|
{
|
|
if (aType.FullName == "System.Void")
|
|
{
|
|
return 0;
|
|
}
|
|
if ((!aType.IsValueType && aType.IsClass) || aType.IsInterface)
|
|
{
|
|
return 4;
|
|
}
|
|
switch (aType.FullName)
|
|
{
|
|
case "System.Char":
|
|
return 2;
|
|
case "System.Byte":
|
|
case "System.SByte":
|
|
return 1;
|
|
case "System.UInt16":
|
|
case "System.Int16":
|
|
return 2;
|
|
case "System.UInt32":
|
|
case "System.Int32":
|
|
return 4;
|
|
case "System.UInt64":
|
|
case "System.Int64":
|
|
return 8;
|
|
// for now hardcode IntPtr and UIntPtr to be 32-bit
|
|
case "System.UIntPtr":
|
|
case "System.IntPtr":
|
|
return 4;
|
|
case "System.Boolean":
|
|
return 1;
|
|
case "System.Single":
|
|
return 4;
|
|
case "System.Double":
|
|
return 8;
|
|
case "System.Decimal":
|
|
return 16;
|
|
case "System.Guid":
|
|
return 16;
|
|
case "System.DateTime":
|
|
return 8; // todo: check for correct size
|
|
}
|
|
if (aType.FullName != null && aType.FullName.EndsWith("*"))
|
|
{
|
|
// pointer
|
|
return 4;
|
|
}
|
|
// array
|
|
//TypeSpecification xTypeSpec = aType as TypeSpecification;
|
|
//if (xTypeSpec != null) {
|
|
// return 4;
|
|
//}
|
|
if (aType.IsEnum)
|
|
{
|
|
return GetFieldStorageSize(aType.GetField("value__").FieldType);
|
|
}
|
|
if (aType.IsValueType)
|
|
{
|
|
StructLayoutAttribute xSLA = aType.StructLayoutAttribute;
|
|
if (xSLA != null)
|
|
{
|
|
if (xSLA.Size > 0)
|
|
{
|
|
return (uint)xSLA.Size;
|
|
}
|
|
}
|
|
}
|
|
uint xResult;
|
|
GetTypeFieldInfo(aType,
|
|
out xResult);
|
|
return xResult;
|
|
}
|
|
|
|
public TraceAssemblies TraceAssemblies;
|
|
|
|
private ISymbolReader GetSymbolReaderForAssembly(Assembly aAssembly)
|
|
{
|
|
try
|
|
{
|
|
return SymbolAccess.GetReaderForFile(aAssembly.Location);
|
|
}
|
|
catch (NotSupportedException)
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
protected void EmitTracer(Op aOp, string aNamespace, int aPos, int[] aCodeOffsets, string aLabel)
|
|
{
|
|
// NOTE - These if statemens can be optimized down - but clarity is
|
|
// more importnat the optimizations would not offer much benefit
|
|
|
|
// Determine if a new DebugStub should be emitted
|
|
//bool xEmit = false;
|
|
// Skip NOOP's so we dont have breakpoints on them
|
|
//TODO: Each IL op should exist in IL, and descendants in IL.X86.
|
|
// Because of this we have this hack
|
|
if (aOp.ToString() == "Indy.IL2CPU.IL.X86.Nop")
|
|
{
|
|
return;
|
|
}
|
|
else if (DebugMode == DebugMode.None)
|
|
{
|
|
return;
|
|
}
|
|
else if (DebugMode == DebugMode.Source)
|
|
{
|
|
// If the current position equals one of the offsets, then we have
|
|
// reached a new atomic C# statement
|
|
if (aCodeOffsets != null)
|
|
{
|
|
if (aCodeOffsets.Contains(aPos) == false)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check options for Debug Level
|
|
// Set based on TracedAssemblies
|
|
if (TraceAssemblies == TraceAssemblies.Cosmos || TraceAssemblies == TraceAssemblies.User)
|
|
{
|
|
if (aNamespace.StartsWith("System.", StringComparison.InvariantCultureIgnoreCase))
|
|
{
|
|
return;
|
|
}
|
|
else if (aNamespace.ToLower() == "system")
|
|
{
|
|
return;
|
|
}
|
|
else if (aNamespace.StartsWith("Microsoft.", StringComparison.InvariantCultureIgnoreCase))
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
if (TraceAssemblies == TraceAssemblies.User)
|
|
{
|
|
//TODO: Maybe an attribute that could be used to turn tracing on and off
|
|
//TODO: This doesnt match Cosmos.Kernel exact vs Cosmos.Kernel., so a user
|
|
// could do Cosmos.KernelMine and it will fail. Need to fix this
|
|
if (aNamespace.StartsWith("Cosmos.Kernel", StringComparison.InvariantCultureIgnoreCase))
|
|
{
|
|
return;
|
|
}
|
|
else if (aNamespace.StartsWith("Cosmos.Sys", StringComparison.InvariantCultureIgnoreCase))
|
|
{
|
|
return;
|
|
}
|
|
else if (aNamespace.StartsWith("Cosmos.Hardware", StringComparison.InvariantCultureIgnoreCase))
|
|
{
|
|
return;
|
|
}
|
|
else if (aNamespace.StartsWith("Indy.IL2CPU", StringComparison.InvariantCultureIgnoreCase))
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
// If we made it this far, emit the Tracer
|
|
OpCodeMap.EmitOpDebugHeader(Assembler, 0, aLabel);
|
|
}
|
|
}
|
|
} |