public void Setup(AssemblyCompiler compiler)
{
this.compiler = compiler;
architecture = compiler.Architecture;
typeSystem = compiler.TypeSystem;
typeLayout = compiler.TypeLayout;
}
public void Setup(AssemblyCompiler compiler)
{
this.OutputFile = compiler.CompilerOptions.OutputFile;
//this.FileAlignment = compiler.CompilerOptions.Elf64.FileAlignment;
this.IsLittleEndian = compiler.Architecture.IsLittleEndian;
this.Machine = (MachineType)compiler.Architecture.ElfMachineType;
}
/// <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;
}
void IAssemblyCompilerStage.Setup(AssemblyCompiler compiler)
{
base.Setup(compiler);
scheduler = compiler.Pipeline.FindFirst<ICompilationSchedulerStage>();
if (scheduler == null)
throw new InvalidOperationException(@"No compilation scheduler found in the assembly compiler pipeline.");
}
/// <summary>
/// Initializes a new instance of the <see cref="LinkerMethodCompiler"/> class.
/// </summary>
/// <param name="assemblyCompiler">The assembly compiler executing this method compiler.</param>
/// <param name="method">The metadata of the method to compile.</param>
/// <param name="instructionSet">The instruction set.</param>
/// <exception cref="System.ArgumentNullException"><paramref name="assemblyCompiler"/>, <paramref name="method"/> or <paramref name="instructionSet"/> is null.</exception>
public LinkerMethodCompiler(AssemblyCompiler assemblyCompiler, ICompilationSchedulerStage compilationScheduler, RuntimeMethod method, InstructionSet instructionSet)
: base(assemblyCompiler, method.DeclaringType, method, instructionSet, compilationScheduler)
{
this.CreateBlock(-1, 0);
this.Pipeline.AddRange(new IMethodCompilerStage[] {
new SimpleTraceBlockOrderStage(),
new PlatformStubStage(),
new CodeGenerationStage(),
});
assemblyCompiler.Architecture.ExtendMethodCompilerPipeline(this.Pipeline);
}
public void Setup(AssemblyCompiler compiler)
{
this.OutputFile = compiler.CompilerOptions.OutputFile;
this.IsLittleEndian = compiler.Architecture.IsLittleEndian;
if (compiler.CompilerOptions.PortableExecutable.FileAlignment.HasValue)
this.FileAlignment = compiler.CompilerOptions.PortableExecutable.FileAlignment.Value;
if (compiler.CompilerOptions.PortableExecutable.SectionAlignment.HasValue)
this.SectionAlignment = compiler.CompilerOptions.PortableExecutable.SectionAlignment.Value;
if (compiler.CompilerOptions.PortableExecutable.SetChecksum.HasValue)
this.SetChecksum = compiler.CompilerOptions.PortableExecutable.SetChecksum.Value;
}
/// <summary>
/// Initializes a new instance of the <see cref="AotMethodCompiler"/> class.
/// </summary>
public AotMethodCompiler(AssemblyCompiler assemblyCompiler, ICompilationSchedulerStage compilationScheduler, RuntimeType type, RuntimeMethod method, CompilerOptions compilerOptions)
: base(assemblyCompiler, type, method, null, compilationScheduler)
{
this.Pipeline.AddRange(
new IMethodCompilerStage[]
{
new DecodingStage(),
new BasicBlockBuilderStage(),
new ExceptionPrologueStage(),
new OperandDeterminationStage(),
new StaticAllocationResolutionStage(),
new CILTransformationStage(),
(compilerOptions.EnableSSA) ? new EdgeSplitStage() : null,
(compilerOptions.EnableSSA) ? new DominanceCalculationStage() : null,
(compilerOptions.EnableSSA) ? new PhiPlacementStage() : null,
(compilerOptions.EnableSSA) ? new EnterSSAStage() : null,
(compilerOptions.EnableSSA) ? new SSAOptimizations() : null,
//(compilerOptions.EnableSSA) ? new ConstantPropagationStage(ConstantPropagationStage.PropagationStage.PreFolding) : null,
//(compilerOptions.EnableSSA) ? new ConstantFoldingStage() : null,
//(compilerOptions.EnableSSA) ? new ConstantPropagationStage(ConstantPropagationStage.PropagationStage.PostFolding) : null,
(compilerOptions.EnableSSA) ? new LeaveSSA() : null,
new StrengthReductionStage(),
new StackLayoutStage(),
new PlatformStubStage(),
//new LoopAwareBlockOrderStage(),
new SimpleTraceBlockOrderStage(),
//new ReverseBlockOrderStage(),
//new LocalCSE(),
//new SimpleRegisterAllocatorStage(),
new CodeGenerationStage(),
//new RegisterUsageAnalyzerStage(),
});
}
private static List<RuntimeMethod> RecompileMethods(AssemblyCompiler compiler, List<Token> types, RuntimeMethod method)
{
throw new NotImplementedException();
}
void IAssemblyCompilerStage.Setup(AssemblyCompiler compiler)
{
base.Setup(compiler);
linker = RetrieveAssemblyLinkerFromCompiler();
if (compiler.CompilerOptions.Multiboot.VideoDepth.HasValue)
this.VideoDepth = compiler.CompilerOptions.Multiboot.VideoDepth.Value;
if (compiler.CompilerOptions.Multiboot.VideoHeight.HasValue)
this.VideoHeight = compiler.CompilerOptions.Multiboot.VideoHeight.Value;
if (compiler.CompilerOptions.Multiboot.VideoMode.HasValue)
this.VideoMode = compiler.CompilerOptions.Multiboot.VideoMode.Value;
if (compiler.CompilerOptions.Multiboot.VideoWidth.HasValue)
this.VideoWidth = compiler.CompilerOptions.Multiboot.VideoWidth.Value;
}
void IAssemblyCompilerStage.Setup(AssemblyCompiler compiler)
{
base.Setup(compiler);
}
void IAssemblyCompilerStage.Setup(AssemblyCompiler compiler)
{
base.Setup(compiler);
this.MethodPipelineExportDirectory = compiler.CompilerOptions.MethodPipelineExportDirectory;
}
/// <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>
/// <returns></returns>
/// <exception cref="System.ArgumentNullException"><paramref name="compiler"/> or <paramref name="methodName"/> is null.</exception>
/// <exception cref="System.ArgumentException"><paramref name="methodName"/> is invalid.</exception>
public static LinkerGeneratedMethod Compile(AssemblyCompiler compiler, string methodName, ITypeSystem typeSystem)
{
return Compile(compiler, methodName, null, typeSystem);
}
/// <summary>
/// Initializes a new instance of the <see cref="BaseMethodCompiler"/> class.
/// </summary>
/// <param name="assemblyCompiler">The assembly compiler.</param>
/// <param name="type">The type, which owns the method to compile.</param>
/// <param name="method">The method to compile by this instance.</param>
/// <param name="instructionSet">The instruction set.</param>
/// <param name="compilationScheduler">The compilation scheduler.</param>
protected BaseMethodCompiler(AssemblyCompiler assemblyCompiler, RuntimeType type, RuntimeMethod method, InstructionSet instructionSet, ICompilationSchedulerStage compilationScheduler)
{
if (compilationScheduler == null)
throw new ArgumentNullException(@"compilationScheduler");
this.assemblyCompiler = assemblyCompiler;
this.method = method;
this.type = type;
this.compilationScheduler = compilationScheduler;
this.moduleTypeSystem = method.Module;
this.architecture = assemblyCompiler.Architecture;
this.typeSystem = assemblyCompiler.TypeSystem;
this.typeLayout = AssemblyCompiler.TypeLayout;
this.internalTrace = AssemblyCompiler.InternalTrace;
this.linker = assemblyCompiler.Pipeline.FindFirst<IAssemblyLinker>();
this.plugSystem = assemblyCompiler.Pipeline.FindFirst<IPlugSystem>();
this.parameters = new List<Operand>(new Operand[method.Parameters.Count]);
this.nextStackSlot = 0;
this.basicBlocks = new List<BasicBlock>();
this.instructionSet = instructionSet ?? new InstructionSet(256);
this.pipeline = new CompilerPipeline();
}
/// <summary>
/// Setups the specified compiler.
/// </summary>
/// <param name="compiler">The compiler.</param>
void IAssemblyCompilerStage.Setup(AssemblyCompiler compiler)
{
base.Setup(compiler);
linker = RetrieveAssemblyLinkerFromCompiler();
}
private static List<Token> GetTokenTypesForMethod(AssemblyCompiler compiler, RuntimeType type, RuntimeMethod method)
{
throw new NotImplementedException();
}
void IAssemblyCompilerStage.Setup(AssemblyCompiler compiler)
{
base.Setup(compiler);
this.linker = RetrieveAssemblyLinkerFromCompiler();
plugTypeAttribute = typeSystem.GetType("Mosa.Internal.Plug", "Mosa.Internal.Plug", "PlugTypeAttribute");
plugMethodAttribute = typeSystem.GetType("Mosa.Internal.Plug", "Mosa.Internal.Plug", "PlugMethodAttribute");
}
/// <summary>
/// Initializes a new instance of the <see cref="BaseMethodCompiler"/> class.
/// </summary>
/// <param name="assemblyCompiler">The assembly compiler.</param>
/// <param name="type">The type, which owns the method to compile.</param>
/// <param name="method">The method to compile by this instance.</param>
/// <param name="instructionSet">The instruction set.</param>
/// <param name="compilationScheduler">The compilation scheduler.</param>
protected BaseMethodCompiler(AssemblyCompiler assemblyCompiler, RuntimeType type, RuntimeMethod method, InstructionSet instructionSet, ICompilationSchedulerStage compilationScheduler)
{
if (compilationScheduler == null)
throw new ArgumentNullException(@"compilationScheduler");
this.assemblyCompiler = assemblyCompiler;
this.method = method;
this.type = type;
this.compilationScheduler = compilationScheduler;
this.moduleTypeSystem = method.Module;
this.architecture = assemblyCompiler.Architecture;
this.typeSystem = assemblyCompiler.TypeSystem;
this.typeLayout = AssemblyCompiler.TypeLayout;
this.internalTrace = AssemblyCompiler.InternalTrace;
this.linker = assemblyCompiler.Pipeline.FindFirst<IAssemblyLinker>();
this.plugSystem = assemblyCompiler.Pipeline.FindFirst<IPlugSystem>();
this.parameters = new List<Operand>(new Operand[method.Parameters.Count]);
this.basicBlocks = new BasicBlocks();
this.instructionSet = instructionSet ?? new InstructionSet(256);
this.pipeline = new CompilerPipeline();
this.stackLayout = new StackLayout(architecture, method.Parameters.Count + (method.Signature.HasThis || method.Signature.HasExplicitThis ? 1 : 0));
this.virtualRegisterLayout = new VirtualRegisterLayout(architecture, stackLayout);
EvaluateParameterOperands();
}
