CreateCPURegister() public static method

Creates a new physical register Operand.
public static CreateCPURegister ( MosaType type, Register register ) : Operand
type MosaType The type.
register Register The register.
return Operand
Operand Class Documentation
示例#1
0
        public Compiler(MosaCompiler mosaCompiler)
        {
            TypeSystem      = mosaCompiler.TypeSystem;
            TypeLayout      = mosaCompiler.TypeLayout;
            CompilerOptions = mosaCompiler.CompilerOptions;
            Linker          = mosaCompiler.Linker;
            CompilerTrace   = mosaCompiler.CompilerTrace;
            Architecture    = CompilerOptions.Architecture;

            StackFrame   = Operand.CreateCPURegister(TypeSystem.BuiltIn.Pointer, Architecture.StackFrameRegister);
            StackPointer = Operand.CreateCPURegister(TypeSystem.BuiltIn.Pointer, Architecture.StackPointerRegister);

            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;
        }
示例#2
0
        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);

            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 attributes = (IntrinsicMethodAttribute[])method.GetCustomAttributes(typeof(IntrinsicMethodAttribute), true);

                    for (int i = 0; i < attributes.Length; i++)
                    {
                        var d = (IntrinsicMethodDelegate)Delegate.CreateDelegate(typeof(IntrinsicMethodDelegate), 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(CompilerSettings, Architecture.Is64BitPlatform));

            // Call hook to allow for the extension of the pipeline
            CompilerHooks.ExtendCompilerPipeline?.Invoke(CompilerPipeline);

            Architecture.ExtendCompilerPipeline(CompilerPipeline, CompilerSettings);

            IsStopped = false;
        }