コード例 #1
0
ファイル: Starter.cs プロジェクト: tgiphil/MOSA-Project
 public Starter(Options options, AppLocations appLocations, string imagefile, IStarterEvent launcherEvent, BaseLinker linker)
     : base(options, appLocations)
 {
     ImageFile = imagefile;
     LauncherEvent = launcherEvent;
     Linker = linker;
 }
コード例 #2
0
ファイル: SimCompiler.cs プロジェクト: Boddlnagg/MOSA-Project
        /// <summary>
        /// Compiles the specified type system.
        /// </summary>
        /// <param name="typeSystem">The type system.</param>
        /// <param name="typeLayout">The type layout.</param>
        /// <param name="compilerTrace">The compiler trace.</param>
        /// <param name="compilerOptions">The compiler options.</param>
        /// <param name="architecture">The architecture.</param>
        /// <param name="simAdapter">The sim adapter.</param>
        /// <param name="linker">The linker.</param>
        /// <returns></returns>
        public static SimCompiler Compile(TypeSystem typeSystem, MosaTypeLayout typeLayout, CompilerTrace compilerTrace, CompilerOptions compilerOptions, BaseArchitecture architecture, ISimAdapter simAdapter, BaseLinker linker)
        {
            var compiler = new SimCompiler(architecture, typeSystem, typeLayout, linker, compilerOptions, compilerTrace, simAdapter);

            compiler.Compile();

            return compiler;
        }
コード例 #3
0
 /// <summary>
 /// Emits all the section created in the binary file.
 /// </summary>
 /// <param name="linker">The linker.</param>
 private void EmitSections(BaseLinker linker)
 {
     writer.WriteLine("Offset           Virtual          Length           Name                             Class");
     foreach (var section in linker.LinkerSections)
     {
         writer.WriteLine("{0:x16} {1:x16} {2:x16} {3} {4}", section.FileOffset, section.VirtualAddress, section.Size, section.Name.PadRight(32), section.SectionKind);
     }
 }
コード例 #4
0
        /// <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();
        }
コード例 #5
0
ファイル: SimCompiler.cs プロジェクト: Boddlnagg/MOSA-Project
        /// <summary>
        /// Prevents a default instance of the <see cref="SimCompiler" /> class from being created.
        /// </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="linker">The linker.</param>
        /// <param name="compilerOptions">The compiler options.</param>
        /// <param name="compilerTrace">The internal trace.</param>
        /// <param name="simAdapter">The sim adapter.</param>
        public SimCompiler(BaseArchitecture architecture, TypeSystem typeSystem, MosaTypeLayout typeLayout, BaseLinker linker, CompilerOptions compilerOptions, CompilerTrace compilerTrace, ISimAdapter simAdapter)
            : base(architecture, typeSystem, typeLayout, new CompilationScheduler(typeSystem, true), compilerTrace, linker, compilerOptions)
        {
            this.simAdapter = simAdapter;

            // Build the assembly compiler pipeline
            Pipeline.Add(new ICompilerStage[] {
                new PlugStage(),
                new MethodCompilerSchedulerStage(),
                new TypeInitializerSchedulerStage(),
                new SimPowerUpStage(),
                new MethodLookupTableStage(),
                new MethodExceptionLookupTableStage(),
                new MetadataStage(),
                new SimLinkerFinalizationStage(simAdapter.SimCPU),
            });

            architecture.ExtendCompilerPipeline(Pipeline);
        }
コード例 #6
0
        /// <summary>
        /// Initializes a new instance of <see cref="BaseCodeEmitter" />.
        /// </summary>
        /// <param name="methodName">Name of the method.</param>
        /// <param name="linker">The linker.</param>
        /// <param name="codeStream">The stream the machine code is written to.</param>
        /// <param name="typeSystem">The type system.</param>
        public void Initialize(string methodName, BaseLinker linker, Stream codeStream, TypeSystem typeSystem)
        {
            Debug.Assert(codeStream != null);
            Debug.Assert(linker != null);

            this.MethodName = methodName;
            this.linker = linker;
            this.codeStream = codeStream;
            this.TypeSystem = typeSystem;
        }
コード例 #7
0
ファイル: MainForm.cs プロジェクト: Boddlnagg/MOSA-Project
        public void StartSimulator(string platform)
        {
            if (TypeSystem == null)
                return;

            Status = "Compiling...";

            Architecture = GetArchitecture(platform);
            var simAdapter = GetSimAdaptor(platform);
            Linker = new SimLinker(simAdapter);

            compileStartTime = DateTime.Now;

            var compilerOptions = new CompilerOptions();

            compilerOptions.EnableSSA = true;
            compilerOptions.EnableOptimizations = true;
            compilerOptions.EnablePromoteTemporaryVariablesOptimization = true;
            compilerOptions.EnableSparseConditionalConstantPropagation = true;

            SimCompiler.Compile(TypeSystem, TypeLayout, InternalTrace, compilerOptions, Architecture, simAdapter, Linker);

            SimCPU = simAdapter.SimCPU;

            SimCPU.Monitor.BreakAtTick = 1;
            SimCPU.Monitor.BreakOnException = true;
            SimCPU.Monitor.OnStateUpdate = UpdateSimState;
            SimCPU.Reset();

            Display32 = SimCPU.GetState().NativeRegisterSize == 32;

            SimCPU.Monitor.OnExecutionStepCompleted(true);

            Status = "Compiled.";

            symbolView.CreateEntries();
        }
コード例 #8
0
ファイル: MosaCompiler.cs プロジェクト: Zahovay/MOSA-Project
        public void Initialize()
        {
            Linker = new BaseLinker(CompilerOptions.BaseAddress, CompilerOptions.Architecture.Endianness, CompilerOptions.Architecture.MachineType, CompilerOptions.EmitSymbols, CompilerOptions.LinkerFormatType);

            BaseCompiler = CompilerFactory();

            BaseCompiler.Initialize(this);
        }
コード例 #9
0
        /// <summary>
        /// Initializes a new instance of <see cref="BaseCodeEmitter" />.
        /// </summary>
        /// <param name="methodName">Name of the method.</param>
        /// <param name="linker">The linker.</param>
        /// <param name="codeStream">The stream the machine code is written to.</param>
        public void Initialize(string methodName, BaseLinker linker, Stream codeStream)
        {
            Debug.Assert(codeStream != null);
            Debug.Assert(linker != null);

            MethodName = methodName;
            this.linker = linker;
            this.codeStream = codeStream;

            // only necessary if method is being recompiled (due to inline optimization, for example)
            var symbol = linker.GetSymbol(MethodName, SectionKind.Text);
            symbol.RemovePatches();
        }
コード例 #10
0
        /// <summary>
        /// Emits all symbols emitted in the binary file.
        /// </summary>
        /// <param name="linker">The linker.</param>
        private void EmitSymbols(BaseLinker linker)
        {
            writer.WriteLine("Virtual          Offset           Length           Symbol");

            foreach (var section in linker.LinkerSections)
            {
                foreach (var symbol in section.Symbols)
                {
                    writer.WriteLine("{0:x16} {1:x16} {2:x16} {3} {4}", symbol.VirtualAddress, symbol.SectionOffset, symbol.Size, symbol.SectionKind.ToString().PadRight(7), symbol.Name);
                }
            }

            var entryPoint = linker.EntryPoint;
            if (entryPoint != null)
            {
                writer.WriteLine();
                writer.WriteLine("Entry point is {0}", entryPoint.Name);
                writer.WriteLine("\tat Offset {0:x16}", entryPoint.SectionOffset); // TODO! add section offset too?
                writer.WriteLine("\tat virtual address {0:x16}", entryPoint.VirtualAddress);
            }

            //writer.WriteLine();
            //writer.WriteLine("Hash Table:");
            //writer.WriteLine();
            //writer.WriteLine("Virtual          Size     Pre-Hash  Post-Hash Symbol");

            //var symbols = linker.Symbols.OrderBy(symbol => symbol.Name);

            //foreach (var symbol in linker.Symbols)
            //{
            //	if (symbol.SectionKind == SectionKind.Text)
            //	{
            //		writer.WriteLine("{0:x16} {1:x8} {2} {3}  {4}", symbol.VirtualAddress, symbol.Size, ExtractHash(symbol.PreHash), ExtractHash(symbol.PostHash), symbol.Name);
            //	}
            //}

            //writer.WriteLine();
            //writer.WriteLine("Pre-Hash Table:");
            //writer.WriteLine();
            //writer.WriteLine("Hash     Size     Symbol");

            //var symbols2 = linker.Symbols.OrderBy(symbol => symbol.Name);

            //foreach (var symbol in symbols2)
            //{
            //	if (symbol.SectionKind == SectionKind.Text)
            //	{
            //		writer.WriteLine("{0} {1:x8} {2}", ExtractHash(symbol.PreHash), symbol.Size, symbol.Name);
            //	}
            //}
        }
コード例 #11
0
        /// <summary>
        /// Emits all symbols emitted in the binary file.
        /// </summary>
        /// <param name="linker">The linker.</param>
        private void EmitSymbols(BaseLinker linker)
        {
            writer.WriteLine("Offset           Virtual          Length           Section Symbols");

            foreach (var section in linker.Sections)
            {
                //foreach (var symbol in section.Ordered)
                foreach (var symbol in section.Symbols)
                {
                    writer.WriteLine("{0:x16} {1:x16} {2:x16} {3} {4}", symbol.SectionOffset, symbol.VirtualAddress, symbol.Size, symbol.SectionKind.ToString().PadRight(7), symbol.Name);
                }
            }

            var entryPoint = linker.EntryPoint;
            if (entryPoint != null)
            {
                writer.WriteLine();
                writer.WriteLine("Entry point is {0}", entryPoint.Name);
                writer.WriteLine("\tat Offset {0:x16}", entryPoint.SectionOffset); // TODO! add section offset too?
                writer.WriteLine("\tat virtual address {0:x16}", entryPoint.VirtualAddress);
            }
        }
コード例 #12
0
        public void Resolve(TypeSystem typeSystem, BaseLinker linker)
        {
            // Find the test method to execute
            RuntimeMethod = FindMethod(
                typeSystem,
                MethodNamespaceName,
                MethodTypeName,
                MethodName,
                Parameters
            );

            Debug.Assert(RuntimeMethod != null, MethodNamespaceName + "." + MethodTypeName + "." + MethodName);

            var symbol = linker.GetSymbol(RuntimeMethod.FullName, SectionKind.Text);

            Address = symbol.VirtualAddress;
        }
コード例 #13
0
        public void Resolve(TypeSystem typeSystem, BaseLinker linker)
        {
            // Find the test method to execute
            RuntimeMethod = UnitTestEngine.FindMethod(
                typeSystem,
                MethodNamespaceName,
                MethodTypeName,
                MethodName,
                Parameters
            );

            Address = UnitTestEngine.GetMethodAddress(RuntimeMethod, linker);
        }