/// <summary> /// Initializes a new instance of the <see cref="AotMethodCompiler" /> class. /// </summary> /// <param name="compiler">The compiler.</param> /// <param name="method">The method.</param> /// <param name="basicBlocks">The basic blocks.</param> /// <param name="instructionSet">The instruction set.</param> public AotMethodCompiler(BaseCompiler compiler, MosaMethod method, BasicBlocks basicBlocks, InstructionSet instructionSet) : base(compiler, method, basicBlocks, instructionSet) { var compilerOptions = compiler.CompilerOptions; Pipeline.Add(new IMethodCompilerStage[] { new CILDecodingStage(), new BasicBlockBuilderStage(), new StackSetupStage(), new ExceptionPrologueStage(), new OperandAssignmentStage(), new StaticAllocationResolutionStage(), new CILTransformationStage(), new ConvertCompoundMoveStage(), (compilerOptions.EnableSSA) ? new PromoteLocalVariablesStage() : null, (compilerOptions.EnableSSA) ? new EdgeSplitStage() : null, (compilerOptions.EnableSSA) ? new PhiPlacementStage() : null, (compilerOptions.EnableSSA) ? new EnterSSAStage() : null, (compilerOptions.EnableSSA && compilerOptions.EnableSSAOptimizations) ? new SSAOptimizations() : null, (compilerOptions.EnableSSA) ? new LeaveSSA() : null, (compilerOptions.EnableSSA) ? new ConvertCompoundMoveStage() : null, new PlatformStubStage(), new PlatformEdgeSplitStage(), new GreedyRegisterAllocatorStage(), new StackLayoutStage(), new EmptyBlockRemovalStage(), new BlockOrderingStage(), new CodeGenerationStage(), }); }
/// <summary> /// Initializes a new instance of the <see cref="AotMethodCompiler"/> class. /// </summary> /// <param name="compiler">The compiler.</param> /// <param name="method">The method.</param> public AotMethodCompiler(BaseCompiler compiler, RuntimeMethod method) : base(compiler, method, null) { var compilerOptions = compiler.CompilerOptions; Pipeline.AddRange(new IMethodCompilerStage[] { new CILDecodingStage(), new BasicBlockBuilderStage(), new ExceptionPrologueStage(), new OperandAssignmentStage(), new StaticAllocationResolutionStage(), new CILTransformationStage(), new IRCheckStage(), (compilerOptions.EnableSSA && compilerOptions.EnableSSAOptimizations) ? new LocalVariablePromotionStage() : null, (compilerOptions.EnableSSA) ? new EdgeSplitStage() : null, (compilerOptions.EnableSSA) ? new DominanceCalculationStage() : null, (compilerOptions.EnableSSA) ? new PhiPlacementStage() : null, (compilerOptions.EnableSSA) ? new EnterSSAStage() : null, (compilerOptions.EnableSSA && compilerOptions.EnableSSAOptimizations) ? new SSAOptimizations() : null, (compilerOptions.EnableSSA) ? new LeaveSSA() : null, new StackLayoutStage(), new PlatformIntrinsicTransformationStage(), new PlatformStubStage(), new LoopAwareBlockOrderStage(), //new SimpleTraceBlockOrderStage(), //new ReverseBlockOrderStage(), //new LocalCSE(), new CodeGenerationStage(), //new RegisterUsageAnalyzerStage(), }); }
public void Setup(BaseCompiler compiler) { this.compiler = compiler; architecture = compiler.Architecture; typeSystem = compiler.TypeSystem; typeLayout = compiler.TypeLayout; }
public CompilerData(BaseCompiler compiler) { if (compiler == null) throw new ArgumentNullException("compiler"); Compiler = compiler; }
/// <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) { this.Compiler = compiler; this.Method = method; this.Type = method.DeclaringType; this.Scheduler = compiler.CompilationScheduler; this.Architecture = compiler.Architecture; this.TypeSystem = compiler.TypeSystem; this.TypeLayout = Compiler.TypeLayout; this.Trace = Compiler.CompilerTrace; this.Linker = compiler.Linker; this.BasicBlocks = basicBlocks ?? new BasicBlocks(); this.Pipeline = new CompilerPipeline(); this.StackLayout = new StackLayout(Architecture, method.Signature.Parameters.Count + (method.HasThis || method.HasExplicitThis ? 1 : 0)); this.VirtualRegisters = new VirtualRegisters(Architecture); this.LocalVariables = emptyOperandList; this.ThreadID = threadID; this.DominanceAnalysis = new Dominance(Compiler.CompilerOptions.DominanceAnalysisFactory, this.BasicBlocks); EvaluateParameterOperands(); this.stop = false; Debug.Assert(this.Linker != null); }
/// <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="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="instructionSet">The instruction set.</param> protected BaseMethodCompiler(BaseCompiler compiler, MosaMethod method, BasicBlocks basicBlocks, InstructionSet instructionSet) { this.Compiler = compiler; this.Method = method; this.Type = method.DeclaringType; this.Scheduler = compiler.CompilationScheduler; this.Architecture = compiler.Architecture; this.TypeSystem = compiler.TypeSystem; this.TypeLayout = Compiler.TypeLayout; this.InternalTrace = Compiler.InternalTrace; this.Linker = compiler.Linker; this.BasicBlocks = basicBlocks ?? new BasicBlocks(); this.InstructionSet = instructionSet ?? new InstructionSet(256); this.Pipeline = new CompilerPipeline(); this.StackLayout = new StackLayout(Architecture, method.Signature.Parameters.Count + (method.HasThis || method.HasExplicitThis ? 1 : 0)); this.VirtualRegisters = new VirtualRegisters(Architecture); this.LocalVariables = emptyOperandList; this.DominanceAnalysis = new DominanceAnalysis(Compiler.CompilerOptions.DominanceAnalysisFactory, this.BasicBlocks); EvaluateParameterOperands(); this.stop = false; Debug.Assert(this.Linker != null); }
/// <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(BaseCompiler 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); //compiler.Scheduler.TrackTypeAllocated(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); //compiler.Scheduler.TrackMethodInvoked(method); LinkerMethodCompiler methodCompiler = new LinkerMethodCompiler(compiler, method, instructionSet); methodCompiler.Compile(); return method; }
public void Setup(BaseCompiler compiler) { this.OutputFile = compiler.CompilerOptions.OutputFile; this.FileAlignment = compiler.CompilerOptions.Elf32.FileAlignment; this.IsLittleEndian = compiler.Architecture.IsLittleEndian; this.Machine = (MachineType)compiler.Architecture.ElfMachineType; }
void ICompilerStage.Initialize(BaseCompiler compiler) { Debug.Assert(compiler != null); Compiler = compiler; Setup(); }
public void Execute(int threads) { Initialize(); PreCompile(); ScheduleAll(); BaseCompiler.ExecuteThreadedCompile(threads); PostCompile(); }
public void Initialize() { Linker = new BaseLinker(CompilerOptions.BaseAddress, CompilerOptions.Architecture.Endianness, CompilerOptions.Architecture.MachineType, CompilerOptions.EmitSymbols, CompilerOptions.LinkerFormatType); BaseCompiler = CompilerFactory(); BaseCompiler.Initialize(this); }
public CompilerData(BaseCompiler compiler) { if (compiler == null) { throw new ArgumentNullException("compiler"); } Compiler = compiler; }
public void Initialize() { Linker = CompilerOptions.LinkerFactory(); Linker.Initialize(CompilerOptions.BaseAddress, CompilerOptions.Architecture.Endianness, CompilerOptions.Architecture.ElfMachineType); BaseCompiler = CompilerFactory(); BaseCompiler.Initialize(this); }
public void Setup(BaseCompiler 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="LinkerMethodCompiler"/> class. /// </summary> /// <param name="compiler">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> public LinkerMethodCompiler(BaseCompiler compiler, RuntimeMethod method, InstructionSet instructionSet) : base(compiler, method, instructionSet) { BasicBlocks.CreateBlock(BasicBlock.PrologueLabel, 0); BasicBlocks.AddHeaderBlock(BasicBlocks.PrologueBlock); this.Pipeline.AddRange(new IMethodCompilerStage[] { new LoopAwareBlockOrderStage(), new PlatformStubStage(), new CodeGenerationStage(), }); compiler.Architecture.ExtendMethodCompilerPipeline(this.Pipeline); }
/// <summary> /// Initializes a new instance of the <see cref="AotMethodCompiler" /> class. /// </summary> /// <param name="compiler">The compiler.</param> /// <param name="method">The method.</param> /// <param name="basicBlocks">The basic blocks.</param> /// <param name="threadID">The thread identifier.</param> public AotMethodCompiler(BaseCompiler compiler, MosaMethod method, BasicBlocks basicBlocks, int threadID) : base(compiler, method, basicBlocks, threadID) { var compilerOptions = compiler.CompilerOptions; // Populate the pipeline Pipeline.Add(new IMethodCompilerStage[] { new CILDecodingStage(), new ExceptionPrologueStage(), new OperandAssignmentStage(), new StackSetupStage(), new CILProtectedRegionStage(), new ExceptionStage(), new StaticAllocationResolutionStage(), new CILTransformationStage(), //new ConvertCompoundStage(), new UnboxValueTypeStage(), (compilerOptions.EnableInlinedMethods) ? new InlineStage() : null, (compilerOptions.EnableSSA) ? new EdgeSplitStage() : null, (compilerOptions.EnableSSA) ? new PhiPlacementStage() : null, (compilerOptions.EnableSSA) ? new EnterSSAStage() : null, (compilerOptions.EnableOptimizations && compilerOptions.EnableSparseConditionalConstantPropagation && compilerOptions.EnableSSA) ? new SparseConditionalConstantPropagationStage() : null, (compilerOptions.EnableOptimizations) ? new IROptimizationStage() : null, (compilerOptions.TwoPassOptimizationStages && compilerOptions.EnableOptimizations && compilerOptions.EnableSparseConditionalConstantPropagation && compilerOptions.EnableSSA) ? new SparseConditionalConstantPropagationStage() : null, (compilerOptions.TwoPassOptimizationStages && compilerOptions.EnableOptimizations && compilerOptions.EnableSparseConditionalConstantPropagation && compilerOptions.EnableSSA) ? new IROptimizationStage() : null, (compilerOptions.EnableSSA) ? new LeaveSSA() : null, new IRCleanupStage(), (compilerOptions.EnableInlinedMethods) ? new InlineEvaluationStage() : null, new PlatformStubStage(), new PlatformEdgeSplitStage(), new VirtualRegisterRenameStage(), new GreedyRegisterAllocatorStage(), new StackLayoutStage(), new EmptyBlockRemovalStage(), new BlockOrderingStage(), new CodeGenerationStage(), new ProtectedRegionLayoutStage(), }); }
public void Compile() { BaseCompiler.ExecuteCompile(); }
void ICompilerStage.Initialize(BaseCompiler compiler) { this.Compiler = compiler; Setup(); }
/// <summary> /// Initializes a new instance of the <see cref="DelegatePatcher"/> class. /// </summary> /// <param name="compiler">The compiler.</param> public DelegatePatcher(BaseCompiler compiler) { Compiler = compiler; }
/// <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(BaseCompiler compiler, string methodName, ITypeSystem typeSystem) { return Compile(compiler, methodName, null, typeSystem); }
void ICompilerStage.Initialize(BaseCompiler compiler) { Debug.Assert(compiler != null); this.Compiler = compiler; Setup(); }
void ICompilerStage.Setup(BaseCompiler compiler) { base.Setup(compiler); linker = RetrieveLinkerFromCompiler(); 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 ICompilerStage.Setup(BaseCompiler compiler) { base.Setup(compiler); }
/// <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="instructionSet">The instruction set.</param> protected BaseMethodCompiler(BaseCompiler compiler, RuntimeMethod method, InstructionSet instructionSet) { this.compiler = compiler; this.method = method; this.type = method.DeclaringType; this.compilationScheduler = compiler.Scheduler; this.moduleTypeSystem = method.Module; this.architecture = compiler.Architecture; this.typeSystem = compiler.TypeSystem; this.typeLayout = Compiler.TypeLayout; this.internalTrace = Compiler.InternalTrace; this.linker = compiler.Linker; 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(); this.stopMethodCompiler = false; }
public void PreCompile() { BaseCompiler.PreCompile(); }
void ICompilerStage.Setup(BaseCompiler compiler) { base.Setup(compiler); this.MethodPipelineExportDirectory = compiler.CompilerOptions.MethodPipelineExportDirectory; }
void ICompilerStage.Setup(BaseCompiler compiler) { base.Setup(compiler); linker = RetrieveLinkerFromCompiler(); }
public void PostCompile() { BaseCompiler.PostCompile(); }