/// <summary>
/// Initializes a new instance of the <see cref="MethodCompiler" /> class.
/// </summary>
/// <param name="compiler">The assembly compiler.</param>
/// <param name="method">The method to compile by this instance.</param>
/// <param name="basicBlocks">The basic blocks.</param>
/// <param name="threadID">The thread identifier.</param>
public MethodCompiler(Compiler compiler, MosaMethod method, BasicBlocks basicBlocks, int threadID)
{
Stopwatch = Stopwatch.StartNew();
Compiler = compiler;
Method = method;
MethodScheduler = compiler.MethodScheduler;
Architecture = compiler.Architecture;
TypeSystem = compiler.TypeSystem;
TypeLayout = compiler.TypeLayout;
Trace = compiler.CompilerTrace;
Linker = compiler.Linker;
MethodScanner = compiler.MethodScanner;
BasicBlocks = basicBlocks ?? new BasicBlocks();
LocalStack = new List <Operand>();
VirtualRegisters = new VirtualRegisters();
Parameters = new Operand[method.Signature.Parameters.Count + (method.HasThis || method.HasExplicitThis ? 1 : 0)];
ConstantZero32 = CreateConstant((uint)0);
ConstantZero64 = CreateConstant((ulong)0);
ConstantZeroR4 = CreateConstant(0.0f);
ConstantZeroR8 = CreateConstant(0.0d);
ConstantZero = Architecture.Is32BitPlatform ? ConstantZero32 : ConstantZero64;
LocalVariables = emptyOperandList;
ThreadID = threadID;
IsStopped = false;
IsExecutePipeline = true;
IsCILDecodeRequired = true;
IsStackFrameRequired = true;
IsMethodInlined = false;
HasProtectedRegions = Method.ExceptionHandlers.Count != 0;
MethodData = Compiler.GetMethodData(Method);
MethodData.Counters.Reset();
MethodData.Version++;
MethodData.IsMethodImplementationReplaced = IsMethodPlugged;
if (Symbol == null)
{
Symbol = Linker.DefineSymbol(Method.FullName, SectionKind.Text, 0, 0);
Symbol.MethodData = MethodData; // for debugging
Symbol.MosaMethod = Method; // for debugging
}
else
{
Symbol.RemovePatches();
}
EvaluateParameterOperands();
CalculateMethodParameterSize();
MethodData.Counters.NewCountSkipLock("ExecutionTime.Setup.Ticks", (int)Stopwatch.ElapsedTicks);
}
/// <summary>
/// Initializes a new instance of the <see cref="MethodCompiler" /> class.
/// </summary>
/// <param name="compiler">The assembly compiler.</param>
/// <param name="method">The method to compile by this instance.</param>
/// <param name="basicBlocks">The basic blocks.</param>
/// <param name="threadID">The thread identifier.</param>
public MethodCompiler(Compiler compiler, MosaMethod method, BasicBlocks basicBlocks, int threadID)
{
Compiler = compiler;
Method = method;
Type = method.DeclaringType;
Scheduler = compiler.CompilationScheduler;
Architecture = compiler.Architecture;
TypeSystem = compiler.TypeSystem;
TypeLayout = compiler.TypeLayout;
Trace = compiler.CompilerTrace;
Linker = compiler.Linker;
BasicBlocks = basicBlocks ?? new BasicBlocks();
LocalStack = new List <Operand>();
VirtualRegisters = new VirtualRegisters();
StackFrame = Operand.CreateCPURegister(TypeSystem.BuiltIn.Pointer, Architecture.StackFrameRegister);
StackPointer = Operand.CreateCPURegister(TypeSystem.BuiltIn.Pointer, Architecture.StackPointerRegister);
Parameters = new Operand[method.Signature.Parameters.Count + (method.HasThis || method.HasExplicitThis ? 1 : 0)];
ConstantZero = Architecture.Is32BitPlatform ? CreateConstant((uint)0) : CreateConstant((ulong)0);
LocalVariables = emptyOperandList;
ThreadID = threadID;
PluggedMethod = compiler.PlugSystem.GetReplacement(Method);
IsStopped = false;
IsInSSAForm = false;
MethodData = compiler.CompilerData.GetCompilerMethodData(Method);
MethodData.Counters.Reset();
EvaluateParameterOperands();
CalculateMethodParameterSize();
}
/// <summary>
/// Initializes a new instance of the <see cref="BaseMethodCompiler" /> class.
/// </summary>
/// <param name="compiler">The assembly compiler.</param>
/// <param name="method">The method to compile by this instance.</param>
/// <param name="basicBlocks">The basic blocks.</param>
/// <param name="threadID">The thread identifier.</param>
protected BaseMethodCompiler(BaseCompiler compiler, MosaMethod method, BasicBlocks basicBlocks, int threadID)
{
Compiler = compiler;
Method = method;
Type = method.DeclaringType;
Scheduler = compiler.CompilationScheduler;
Architecture = compiler.Architecture;
TypeSystem = compiler.TypeSystem;
TypeLayout = compiler.TypeLayout;
Trace = compiler.CompilerTrace;
Linker = compiler.Linker;
BasicBlocks = basicBlocks ?? new BasicBlocks();
Pipeline = new CompilerPipeline();
StackLayout = new StackLayout(Architecture, method.Signature.Parameters.Count + (method.HasThis || method.HasExplicitThis ? 1 : 0));
VirtualRegisters = new VirtualRegisters(Architecture);
LocalVariables = emptyOperandList;
ThreadID = threadID;
DominanceAnalysis = new Dominance(Compiler.CompilerOptions.DominanceAnalysisFactory, BasicBlocks);
PluggedMethod = compiler.PlugSystem.GetPlugMethod(Method);
stop = false;
MethodData = compiler.CompilerData.GetCompilerMethodData(Method);
MethodData.Counters.Clear();
EvaluateParameterOperands();
}
/// <summary>
/// Initializes a new instance of the <see cref="BaseMethodCompiler" /> class.
/// </summary>
/// <param name="compiler">The assembly compiler.</param>
/// <param name="method">The method to compile by this instance.</param>
/// <param name="basicBlocks">The basic blocks.</param>
/// <param name="threadID">The thread identifier.</param>
protected BaseMethodCompiler(BaseCompiler compiler, MosaMethod method, BasicBlocks basicBlocks, int threadID)
{
Compiler = compiler;
Method = method;
Type = method.DeclaringType;
Scheduler = compiler.CompilationScheduler;
Architecture = compiler.Architecture;
TypeSystem = compiler.TypeSystem;
TypeLayout = compiler.TypeLayout;
Trace = compiler.CompilerTrace;
Linker = compiler.Linker;
BasicBlocks = basicBlocks ?? new BasicBlocks();
Pipeline = new CompilerPipeline();
LocalStack = new List <Operand>();
ConstantZero = Operand.CreateConstant(0, TypeSystem);
StackFrame = Operand.CreateCPURegister(TypeSystem.BuiltIn.Pointer, Architecture.StackFrameRegister);
StackPointer = Operand.CreateCPURegister(TypeSystem.BuiltIn.Pointer, Architecture.StackPointerRegister);
Parameters = new Operand[method.Signature.Parameters.Count + (method.HasThis || method.HasExplicitThis ? 1 : 0)];
VirtualRegisters = new VirtualRegisters();
LocalVariables = emptyOperandList;
ThreadID = threadID;
PluggedMethod = compiler.PlugSystem.GetPlugMethod(Method);
stop = false;
MethodData = compiler.CompilerData.GetCompilerMethodData(Method);
MethodData.Counters.Clear();
EvaluateParameterOperands();
CalculateMethodParameterSize();
}
/// <summary>
/// Initializes a new instance of the <see cref="MethodCompiler" /> class.
/// </summary>
/// <param name="compiler">The assembly compiler.</param>
/// <param name="method">The method to compile by this instance.</param>
/// <param name="basicBlocks">The basic blocks.</param>
/// <param name="threadID">The thread identifier.</param>
public MethodCompiler(Compiler compiler, MosaMethod method, BasicBlocks basicBlocks, int threadID)
{
Stopwatch = Stopwatch.StartNew();
Compiler = compiler;
Method = method;
MethodScheduler = compiler.MethodScheduler;
Architecture = compiler.Architecture;
TypeSystem = compiler.TypeSystem;
TypeLayout = compiler.TypeLayout;
Trace = compiler.CompilerTrace;
Linker = compiler.Linker;
MethodScanner = compiler.MethodScanner;
BasicBlocks = basicBlocks ?? new BasicBlocks();
LocalStack = new List <Operand>();
VirtualRegisters = new VirtualRegisters();
StackFrame = Operand.CreateCPURegister(TypeSystem.BuiltIn.Pointer, Architecture.StackFrameRegister);
StackPointer = Operand.CreateCPURegister(TypeSystem.BuiltIn.Pointer, Architecture.StackPointerRegister);
Parameters = new Operand[method.Signature.Parameters.Count + (method.HasThis || method.HasExplicitThis ? 1 : 0)];
ConstantZero32 = CreateConstant((uint)0);
ConstantZero64 = CreateConstant((ulong)0);
ConstantZero = Architecture.Is32BitPlatform ? ConstantZero32 : ConstantZero64;
LocalVariables = emptyOperandList;
ThreadID = threadID;
IsStopped = false;
IsExecutePipeline = true;
IsCILDecodeRequired = true;
IsStackFrameRequired = true;
IsMethodInlined = false;
MethodData = compiler.CompilerData.GetMethodData(Method);
MethodData.Counters.Reset();
// Both defines the symbol and also clears the data
Symbol = Linker.DefineSymbol(Method.FullName, SectionKind.Text, 0, 0);
EvaluateParameterOperands();
CalculateMethodParameterSize();
MethodData.Counters.NewCountSkipLock("ExecutionTime.Setup.Ticks", (int)Stopwatch.ElapsedTicks);
}
/// <summary>
/// Allocates the local variable virtual registers.
/// </summary>
/// <param name="locals">The locals.</param>
public void SetLocalVariables(IList <MosaLocal> locals)
{
LocalVariables = new Operand[locals.Count];
for (int index = 0; index < locals.Count; index++)
{
var local = locals[index];
Operand operand;
if (local.Type.IsValueType || local.Type.IsPointer)
{
operand = StackLayout.AddStackLocal(local.Type);
}
else
{
var stacktype = local.Type.GetStackType();
operand = VirtualRegisters.Allocate(stacktype);
}
LocalVariables[index] = operand;
}
}
/// <summary>
/// Splits the long operand.
/// </summary>
/// <param name="longOperand">The long operand.</param>
public void SplitLongOperand(Operand longOperand)
{
VirtualRegisters.SplitLongOperand(TypeSystem, longOperand);
}
/// <summary>
/// Creates a new virtual register operand.
/// </summary>
/// <param name="type">The signature type of the virtual register.</param>
/// <returns>
/// An operand, which represents the virtual register.
/// </returns>
public Operand CreateVirtualRegister(MosaType type)
{
return(VirtualRegisters.Allocate(type));
}
/// <summary>
/// Initializes a new instance of the <see cref="MethodCompiler" /> class.
/// </summary>
/// <param name="compiler">The assembly compiler.</param>
/// <param name="method">The method to compile by this instance.</param>
/// <param name="basicBlocks">The basic blocks.</param>
/// <param name="threadID">The thread identifier.</param>
public MethodCompiler(Compiler compiler, MosaMethod method, BasicBlocks basicBlocks, int threadID)
{
Stopwatch = Stopwatch.StartNew();
Compiler = compiler;
Method = method;
MethodScheduler = compiler.MethodScheduler;
Architecture = compiler.Architecture;
TypeSystem = compiler.TypeSystem;
TypeLayout = compiler.TypeLayout;
Linker = compiler.Linker;
MethodScanner = compiler.MethodScanner;
CompilerHooks = compiler.CompilerHooks;
NotifyTraceLogHandler = GetMethodInstructionTraceHandler();
Statistics = compiler.Statistics;
IsInSSAForm = false;
BasicBlocks = basicBlocks ?? new BasicBlocks();
LocalStack = new List <Operand>();
VirtualRegisters = new VirtualRegisters();
Parameters = new Operand[method.Signature.Parameters.Count + (method.HasThis || method.HasExplicitThis ? 1 : 0)];
ConstantZero32 = CreateConstant((uint)0);
ConstantZero64 = CreateConstant((ulong)0);
ConstantZeroR4 = CreateConstant(0.0f);
ConstantZeroR8 = CreateConstant(0.0d);
ConstantZero = Architecture.Is32BitPlatform ? ConstantZero32 : ConstantZero64; // FUTURE: This could just be Constant64 or Constant32 once the caling stage uses the method signature intead of the operand types
LocalVariables = emptyOperandList;
ThreadID = threadID;
IsStopped = false;
IsExecutePipeline = true;
IsMethodInlined = false;
IsCILStream = !Method.IsCompilerGenerated;
HasProtectedRegions = Method.ExceptionHandlers.Count != 0;
MethodData = Compiler.GetMethodData(Method);
MethodData.Counters.Reset();
MethodData.HasCode = false;
MethodData.Version++;
MethodData.IsMethodImplementationReplaced = IsMethodPlugged;
IsStackFrameRequired = MethodData.StackFrameRequired;
if (Symbol == null)
{
Symbol = Linker.DefineSymbol(Method.FullName, SectionKind.Text, 0, 0);
Symbol.MethodData = MethodData; // for debugging
Symbol.MosaMethod = Method; // for debugging
}
else
{
Symbol.RemovePatches();
}
var methodInfo = TypeLayout.__GetMethodInfo(Method);
MethodData.ParameterSizes = methodInfo.ParameterSizes;
MethodData.ParameterOffsets = methodInfo.ParameterOffsets;
MethodData.ParameterStackSize = methodInfo.ParameterStackSize;
MethodData.ReturnSize = methodInfo.ReturnSize;
MethodData.ReturnInRegister = methodInfo.ReturnInRegister;
EvaluateParameterOperands();
MethodData.Counters.NewCountSkipLock("ExecutionTime.Setup.Ticks", (int)Stopwatch.ElapsedTicks);
}