public Compiler(MosaCompiler mosaCompiler) { TypeSystem = mosaCompiler.TypeSystem; TypeLayout = mosaCompiler.TypeLayout; CompilerOptions = mosaCompiler.CompilerOptions; Linker = mosaCompiler.Linker; CompilerTrace = mosaCompiler.CompilerTrace; Architecture = CompilerOptions.Architecture; PostCompilerTraceEvent(CompilerEvent.CompilerStart); CompilerExtensions.AddRange(mosaCompiler.CompilerExtensions); MethodStagePipelines = new Pipeline <BaseMethodCompilerStage> [mosaCompiler.MaxThreads + 1]; MethodScheduler = new MethodScheduler(this); MethodScanner = new MethodScanner(this); foreach (var type in Assembly.GetExecutingAssembly().GetTypes()) { if (!type.IsClass) { continue; } foreach (var method in type.GetRuntimeMethods()) { // Now get all the IntrinsicMethodAttribute attributes var attributes = (IntrinsicMethodAttribute[])method.GetCustomAttributes(typeof(IntrinsicMethodAttribute), true); for (int i = 0; i < attributes.Length; i++) { var d = (InstrinsicMethodDelegate)Delegate.CreateDelegate(typeof(InstrinsicMethodDelegate), method); // Finally add the dictionary entry mapping the target name and the delegate InternalIntrinsicMethods.Add(attributes[i].Target, d); } } } PlugSystem = new PlugSystem(TypeSystem); PlatformInternalRuntimeType = GetPlatformInternalRuntimeType(); InternalRuntimeType = GeInternalRuntimeType(); // Build the default compiler pipeline CompilerPipeline.Add(GetDefaultCompilerPipeline(CompilerOptions)); foreach (var extension in CompilerExtensions) { extension.ExtendCompilerPipeline(CompilerPipeline); } Architecture.ExtendCompilerPipeline(CompilerPipeline, CompilerOptions); IsStopped = false; WorkCount = 0; }
public void Initialize(MosaCompiler compiler) { if (compiler == null) { throw new ArgumentNullException(@"compiler"); } Compiler = compiler; Architecture = Compiler.CompilerOptions.Architecture; TypeSystem = Compiler.TypeSystem; TypeLayout = Compiler.TypeLayout; CompilerTrace = Compiler.CompilerTrace; CompilerOptions = Compiler.CompilerOptions; CompilationScheduler = Compiler.CompilationScheduler; Linker = compiler.Linker; PreCompilePipeline = new CompilerPipeline(); PostCompilePipeline = new CompilerPipeline(); Counters = new Counters(); PlugSystem = new PlugSystem(); CompilerData = new CompilerData(this); // Create new dictionary IntrinsicTypes = new Dictionary <string, Type>(); // Get all the classes that implement the IIntrinsicInternalMethod interface IEnumerable <Type> types = AppDomain.CurrentDomain.GetAssemblies() .SelectMany(s => s.GetTypes()) .Where(p => typeof(IIntrinsicInternalMethod).IsAssignableFrom(p) && p.IsClass); // Iterate through all the found types foreach (var t in types) { // Now get all the ReplacementTarget attributes var attributes = (ReplacementTargetAttribute[])t.GetCustomAttributes(typeof(ReplacementTargetAttribute), true); for (int i = 0; i < attributes.Length; i++) { // Finally add the dictionary entry mapping the target string and the type IntrinsicTypes.Add(attributes[i].Target, t); } } PlatformInternalRuntimeType = GetPlatformInternalRuntimeType(); // Extended Setup ExtendCompilerSetup(); // Build the default pre-compiler pipeline Architecture.ExtendPreCompilerPipeline(this.PreCompilePipeline); // Build the default post-compiler pipeline Architecture.ExtendPostCompilerPipeline(this.PostCompilePipeline); }
public void Initialize(MosaCompiler compiler) { if (compiler == null) { throw new ArgumentNullException(@"compiler"); } Compiler = compiler; Architecture = Compiler.CompilerOptions.Architecture; TypeSystem = Compiler.TypeSystem; TypeLayout = Compiler.TypeLayout; CompilerTrace = Compiler.CompilerTrace; CompilerOptions = Compiler.CompilerOptions; CompilationScheduler = Compiler.CompilationScheduler; Linker = compiler.Linker; PreCompilePipeline = new CompilerPipeline(); PostCompilePipeline = new CompilerPipeline(); GlobalCounters = new Counters(); PlugSystem = new PlugSystem(); CompilerData = new CompilerData(); // Create new dictionary IntrinsicTypes = new Dictionary <string, Type>(); foreach (var type in Assembly.GetExecutingAssembly().GetTypes()) { if (type.IsClass && typeof(IIntrinsicInternalMethod).IsAssignableFrom(type)) { // Now get all the ReplacementTarget attributes var attributes = (ReplacementTargetAttribute[])type.GetCustomAttributes(typeof(ReplacementTargetAttribute), true); for (int i = 0; i < attributes.Length; i++) { // Finally add the dictionary entry mapping the target string and the type IntrinsicTypes.Add(attributes[i].Target, type); } } } PlatformInternalRuntimeType = GetPlatformInternalRuntimeType(); InternalRuntimeType = GeInternalRuntimeType(); // Extended Setup ExtendCompilerSetup(); // Build the default pre-compiler pipeline Architecture.ExtendPreCompilerPipeline(PreCompilePipeline); // Build the default post-compiler pipeline Architecture.ExtendPostCompilerPipeline(PostCompilePipeline); }
public Compiler(MosaCompiler mosaCompiler) { Architecture = mosaCompiler.CompilerOptions.Architecture; TypeSystem = mosaCompiler.TypeSystem; TypeLayout = mosaCompiler.TypeLayout; CompilerTrace = mosaCompiler.CompilerTrace; CompilerOptions = mosaCompiler.CompilerOptions; CompilationScheduler = mosaCompiler.CompilationScheduler; Linker = mosaCompiler.Linker; CompilerExtensions.AddRange(mosaCompiler.CompilerExtensions); methodStagePipelines = new Pipeline <BaseMethodCompilerStage> [mosaCompiler.MaxThreads]; // Create new dictionary IntrinsicTypes = new Dictionary <string, Type>(); foreach (var type in Assembly.GetExecutingAssembly().GetTypes()) { if (type.IsClass && typeof(IIntrinsicInternalMethod).IsAssignableFrom(type)) { // Now get all the ReplacementTarget attributes var attributes = (ReplacementTargetAttribute[])type.GetCustomAttributes(typeof(ReplacementTargetAttribute), true); for (int i = 0; i < attributes.Length; i++) { // Finally add the dictionary entry mapping the target string and the type IntrinsicTypes.Add(attributes[i].Target, type); } } } PlugSystem = new PlugSystem(TypeSystem); PlatformInternalRuntimeType = GetPlatformInternalRuntimeType(); InternalRuntimeType = GeInternalRuntimeType(); // Build the default compiler pipeline CompilerPipeline.Add(GetDefaultCompilerPipeline(CompilerOptions)); foreach (var extension in CompilerExtensions) { extension.ExtendCompilerPipeline(CompilerPipeline); } Architecture.ExtendCompilerPipeline(CompilerPipeline); IsStopped = false; }
/// <summary> /// Initializes a new compiler instance. /// </summary> /// <param name="architecture">The compiler target architecture.</param> /// <param name="typeSystem">The type system.</param> /// <param name="typeLayout">The type layout.</param> /// <param name="compilationScheduler">The compilation scheduler.</param> /// <param name="compilerTrace">The compiler trace.</param> /// <param name="linker">The linker.</param> /// <param name="compilerOptions">The compiler options.</param> /// <exception cref="System.ArgumentNullException">@Architecture</exception> protected BaseCompiler(BaseArchitecture architecture, TypeSystem typeSystem, MosaTypeLayout typeLayout, ICompilationScheduler compilationScheduler, CompilerTrace compilerTrace, BaseLinker linker, CompilerOptions compilerOptions) { if (architecture == null) throw new ArgumentNullException(@"Architecture"); Pipeline = new CompilerPipeline(); Architecture = architecture; TypeSystem = typeSystem; TypeLayout = typeLayout; CompilerTrace = compilerTrace; CompilerOptions = compilerOptions; Counters = new Counters(); CompilationScheduler = compilationScheduler; PlugSystem = new PlugSystem(); Linker = linker; if (Linker == null) { Linker = compilerOptions.LinkerFactory(); Linker.Initialize(compilerOptions.BaseAddress, architecture.Endianness, architecture.ElfMachineType); } // Create new dictionary IntrinsicTypes = new Dictionary<string, Type>(); // Get all the classes that implement the IIntrinsicInternalMethod interface IEnumerable<Type> types = AppDomain.CurrentDomain.GetAssemblies() .SelectMany(s => s.GetTypes()) .Where(p => typeof(IIntrinsicInternalMethod).IsAssignableFrom(p) && p.IsClass); // Iterate through all the found types foreach (var t in types) { // Now get all the ReplacementTarget attributes var attributes = (ReplacementTargetAttribute[])t.GetCustomAttributes(typeof(ReplacementTargetAttribute), true); for (int i = 0; i < attributes.Length; i++) { // Finally add the dictionary entry mapping the target string and the type IntrinsicTypes.Add(attributes[i].Target, t); } } PlatformInternalRuntimeType = GetPlatformInternalRuntimeType(); }
/// <summary> /// Initializes a new compiler instance. /// </summary> /// <param name="architecture">The compiler target architecture.</param> /// <param name="typeSystem">The type system.</param> /// <param name="typeLayout">The type layout.</param> /// <param name="compilationScheduler">The compilation scheduler.</param> /// <param name="internalTrace">The internal trace.</param> /// <param name="compilerOptions">The compiler options.</param> protected BaseCompiler(BaseArchitecture architecture, TypeSystem typeSystem, MosaTypeLayout typeLayout, ICompilationScheduler compilationScheduler, IInternalTrace internalTrace, ILinker linker, CompilerOptions compilerOptions) { if (architecture == null) throw new ArgumentNullException(@"Architecture"); Pipeline = new CompilerPipeline(); Architecture = architecture; TypeSystem = typeSystem; TypeLayout = typeLayout; InternalTrace = internalTrace; CompilerOptions = compilerOptions; Counters = new Counters(); CompilationScheduler = compilationScheduler; PlugSystem = new PlugSystem(); Linker = linker; if (Linker == null) { Linker = compilerOptions.LinkerFactory(); Linker.Initialize(compilerOptions.OutputFile, architecture.Endianness, architecture.ElfMachineType); } }
public void Initialize(MosaCompiler compiler) { if (compiler == null) throw new ArgumentNullException(@"compiler"); Compiler = compiler; Architecture = Compiler.CompilerOptions.Architecture; TypeSystem = Compiler.TypeSystem; TypeLayout = Compiler.TypeLayout; CompilerTrace = Compiler.CompilerTrace; CompilerOptions = Compiler.CompilerOptions; CompilationScheduler = Compiler.CompilationScheduler; Linker = compiler.Linker; PreCompilePipeline = new CompilerPipeline(); PostCompilePipeline = new CompilerPipeline(); GlobalCounters = new Counters(); PlugSystem = new PlugSystem(); CompilerData = new CompilerData(); // Create new dictionary IntrinsicTypes = new Dictionary<string, Type>(); foreach (var type in Assembly.GetExecutingAssembly().GetTypes()) { if (type.IsClass && typeof(IIntrinsicInternalMethod).IsAssignableFrom(type)) { // Now get all the ReplacementTarget attributes var attributes = (ReplacementTargetAttribute[])type.GetCustomAttributes(typeof(ReplacementTargetAttribute), true); for (int i = 0; i < attributes.Length; i++) { // Finally add the dictionary entry mapping the target string and the type IntrinsicTypes.Add(attributes[i].Target, type); } } } PlatformInternalRuntimeType = GetPlatformInternalRuntimeType(); InternalRuntimeType = GeInternalRuntimeType(); // Extended Setup ExtendCompilerSetup(); // Build the default pre-compiler pipeline Architecture.ExtendPreCompilerPipeline(PreCompilePipeline); // Build the default post-compiler pipeline Architecture.ExtendPostCompilerPipeline(PostCompilePipeline); }
public void Initialize(MosaCompiler compiler) { if (compiler == null) throw new ArgumentNullException(@"compiler"); Compiler = compiler; Architecture = Compiler.CompilerOptions.Architecture; TypeSystem = Compiler.TypeSystem; TypeLayout = Compiler.TypeLayout; CompilerTrace = Compiler.CompilerTrace; CompilerOptions = Compiler.CompilerOptions; CompilationScheduler = Compiler.CompilationScheduler; Linker = compiler.Linker; PreCompilePipeline = new CompilerPipeline(); PostCompilePipeline = new CompilerPipeline(); Counters = new Counters(); PlugSystem = new PlugSystem(); CompilerData = new CompilerData(this); // Create new dictionary IntrinsicTypes = new Dictionary<string, Type>(); // Get all the classes that implement the IIntrinsicInternalMethod interface IEnumerable<Type> types = AppDomain.CurrentDomain.GetAssemblies() .SelectMany(s => s.GetTypes()) .Where(p => typeof(IIntrinsicInternalMethod).IsAssignableFrom(p) && p.IsClass); // Iterate through all the found types foreach (var t in types) { // Now get all the ReplacementTarget attributes var attributes = (ReplacementTargetAttribute[])t.GetCustomAttributes(typeof(ReplacementTargetAttribute), true); for (int i = 0; i < attributes.Length; i++) { // Finally add the dictionary entry mapping the target string and the type IntrinsicTypes.Add(attributes[i].Target, t); } } PlatformInternalRuntimeType = GetPlatformInternalRuntimeType(); // Extended Setup ExtendCompilerSetup(); // Build the default pre-compiler pipeline Architecture.ExtendPreCompilerPipeline(this.PreCompilePipeline); // Build the default post-compiler pipeline Architecture.ExtendPostCompilerPipeline(this.PostCompilePipeline); }
/// <summary> /// Initializes a new compiler instance. /// </summary> /// <param name="architecture">The compiler target architecture.</param> /// <param name="typeSystem">The type system.</param> /// <param name="typeLayout">The type layout.</param> /// <param name="compilationScheduler">The compilation scheduler.</param> /// <param name="internalTrace">The internal trace.</param> /// <param name="compilerOptions">The compiler options.</param> protected BaseCompiler(IArchitecture architecture, ITypeSystem typeSystem, ITypeLayout typeLayout, ICompilationScheduler compilationScheduler, IInternalTrace internalTrace, CompilerOptions compilerOptions) { if (architecture == null) throw new ArgumentNullException(@"architecture"); this.pipeline = new CompilerPipeline(); this.architecture = architecture; this.typeSystem = typeSystem; this.typeLayout = typeLayout; this.internalTrace = internalTrace; this.compilerOptions = compilerOptions; this.genericTypePatcher = new GenericTypePatcher(typeSystem); this.counters = new Counters(); this.compilationScheduler = compilationScheduler; this.linker = compilerOptions.Linker; this.plugSystem = new PlugSystem(); }
public Compiler(MosaCompiler mosaCompiler) { TypeSystem = mosaCompiler.TypeSystem; TypeLayout = mosaCompiler.TypeLayout; CompilerSettings = mosaCompiler.CompilerSettings; Architecture = mosaCompiler.Platform; CompilerHooks = mosaCompiler.CompilerHooks; TraceLevel = CompilerSettings.TraceLevel; Statistics = CompilerSettings.Statistics; Linker = new MosaLinker(this); ObjectHeaderSize = Architecture.NativePointerSize + 4 + 4; // Hash Value (32-bit) + Lock & Status (32-bit) + Method Table StackFrame = Operand.CreateCPURegister(TypeSystem.BuiltIn.Pointer, Architecture.StackFrameRegister); StackPointer = Operand.CreateCPURegister(TypeSystem.BuiltIn.Pointer, Architecture.StackPointerRegister); LinkRegister = Architecture.LinkRegister == null ? null : Operand.CreateCPURegister(TypeSystem.BuiltIn.Object, Architecture.LinkRegister); ProgramCounter = Architecture.ProgramCounter == null ? null : Operand.CreateCPURegister(TypeSystem.BuiltIn.Object, Architecture.ProgramCounter); ExceptionRegister = Operand.CreateCPURegister(TypeSystem.BuiltIn.Object, Architecture.ExceptionRegister); LeaveTargetRegister = Operand.CreateCPURegister(TypeSystem.BuiltIn.Object, Architecture.LeaveTargetRegister); PostEvent(CompilerEvent.CompileStart); MethodStagePipelines = new Pipeline <BaseMethodCompilerStage> [MaxThreads]; MethodScheduler = new MethodScheduler(this); MethodScanner = new MethodScanner(this); foreach (var type in Assembly.GetExecutingAssembly().GetTypes()) { if (!type.IsClass) { continue; } foreach (var method in type.GetRuntimeMethods()) { // Now get all the IntrinsicMethodAttribute attributes var intrinsicMethodAttributes = (IntrinsicMethodAttribute[])method.GetCustomAttributes(typeof(IntrinsicMethodAttribute), true); for (int i = 0; i < intrinsicMethodAttributes.Length; i++) { var d = (IntrinsicMethodDelegate)System.Delegate.CreateDelegate(typeof(IntrinsicMethodDelegate), method); // Finally add the dictionary entry mapping the target name and the delegate InternalIntrinsicMethods.Add(intrinsicMethodAttributes[i].Target, d); } // Now get all the StubMethodAttribute attributes var stubMethodAttributes = (StubMethodAttribute[])method.GetCustomAttributes(typeof(StubMethodAttribute), true); for (int i = 0; i < stubMethodAttributes.Length; i++) { var d = (StubMethodDelegate)System.Delegate.CreateDelegate(typeof(StubMethodDelegate), method); // Finally add the dictionary entry mapping the target name and the delegate InternalStubMethods.Add(stubMethodAttributes[i].Target, d); } } } PlugSystem = new PlugSystem(TypeSystem); PlatformInternalRuntimeType = GetPlatformInternalRuntimeType(); InternalRuntimeType = GeInternalRuntimeType(); // Build the default compiler pipeline CompilerPipeline.Add(GetDefaultCompilerPipeline(CompilerSettings, Architecture.Is64BitPlatform)); // Call hook to allow for the extension of the pipeline CompilerHooks.ExtendCompilerPipeline?.Invoke(CompilerPipeline); Architecture.ExtendCompilerPipeline(CompilerPipeline, CompilerSettings); IsStopped = false; }