コード例 #1
0
        public void CreateAssembly()
        {
            AssemblyName aName = new AssemblyName("CpuAssembly");

            AssemblyBuilder aBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(aName, AssemblyBuilderAccess.RunAndSave);

            ModuleBuilder mBuilder = aBuilder.DefineDynamicModule(aName.Name, aName.Name + ".dll");

            TypeBuilder tb = mBuilder.DefineType("Cpu", TypeAttributes.Sealed | TypeAttributes.Public);

            IExpressionLibraryRegistry libRegistry = ExpressionRegistryHelper.Default;
            var DataAccessExp = libRegistry.GetLibrary<IDataAccessExpressionLibrary>();
            InstructionScanner instructionScanner = new InstructionScanner(libRegistry);
            var instructions = instructionScanner.BuildInstructionInfo(typeof(InstructionScanner).Assembly.GetTypes());
            IInstructionExpressionBuilder instructionExpressionBuilder = new InstructionExpressionBuilder(libRegistry);
            var opcodeResolver = (new DefaultInstructionSpaceBuilder()).BuildInstructionSpaceExpression(instructions,
                                                             libRegistry.GetLibrary<IProgramControlExpressionLibrary>(),
                                                             instructionExpressionBuilder, new InstructionSpace());

            
            var expressionBuilder = new ExpressionBuilder(libRegistry);

            MethodBuilder methodBuilder = tb.DefineMethod("DefaultInstructionSpace", MethodAttributes.Public | MethodAttributes.Static);

            CreateMethod(opcodeResolver, expressionBuilder, methodBuilder);
        
            tb.CreateType();
            
            aBuilder.Save("CpuAssembly.dll");
            //return lambda.Compile();*/
        }
コード例 #2
0
 private static void CreateMethod(Expression opcodeResolver, ExpressionBuilder expressionBuilder, MethodBuilder methodBuilder)
 {
     var methodBody = new List<Expression>();
     methodBody.Add(expressionBuilder.InitializeParameters());
     methodBody.Add(opcodeResolver);
     methodBody.Add(expressionBuilder.FinalizeParameters());
     var block = Expression.Block(expressionBuilder.GetLocals(), methodBody);
     var methodLambda = Expression.Lambda(block, expressionBuilder.GetParameterList());
     methodLambda.CompileToMethod(methodBuilder);
 }
コード例 #3
0
ファイル: Z80Cpu.cs プロジェクト: PhilipBrockmeyer/Wren
        static Z80Cpu()
        {
            _flagTables = new FlagTables();
            _flagTables.ScanForFlagTables(typeof(FlagTables).Assembly.GetTypes());

            var libRegistry = BuildExpressionLibraryRegistry(new ArraySystemBus(1024));
            var instructionScanner = new InstructionScanner(libRegistry);
            var instructions = instructionScanner.BuildInstructionInfo(typeof(InstructionScanner).Assembly.GetTypes());
            var instructionExpressionBuilder = new InstructionExpressionBuilder(libRegistry);

            /*if (IsDebugModeEnabled)
            {
                instructionExpressionBuilder.RegisterPreInstructionAdvice(new DisplayInstructionInDebugConsole());

                var broadCaster = new InstructionBroadcaster();
                broadCaster.InstructionRan += new EventHandler<CpuEventArgs>(broadCaster_InstructionRan);
                instructionExpressionBuilder.RegisterPostInstructionAdvice(broadCaster);
            }

            if (IsRecentHistoryEnabled)
            {
                _history = new RecentHistory();
                instructionExpressionBuilder.RegisterPreInstructionAdvice(_history);

                _instructions = new InstructionCalls();
                instructionExpressionBuilder.RegisterPreInstructionAdvice(_instructions);
            }*/

            var opcodeResolver = (new DefaultInstructionSpaceBuilder()).BuildInstructionSpaceExpression(instructions, libRegistry.GetLibrary<IProgramControlExpressionLibrary>(), instructionExpressionBuilder, new InstructionSpace());
            _expressionBuilder = new ExpressionBuilder(libRegistry);

            var methodBody = BuildLoopMethod(opcodeResolver, _expressionBuilder, libRegistry);
            var block = Expression.Block(_expressionBuilder.GetLocals(), methodBody);
            var lambda = Expression.Lambda(block, _expressionBuilder.GetParameterList());
            _cpuCode = lambda.Compile();
        }
コード例 #4
0
ファイル: Z80Cpu.cs プロジェクト: PhilipBrockmeyer/Wren
        private static List<Expression> BuildLoopMethod(Expression opcodeResolver, ExpressionBuilder expressionBuilder, IExpressionLibraryRegistry libRegistry)
        {
            LabelTarget beginMainLoop = Expression.Label("beginMainLoop");
            LabelTarget endMainLoop = Expression.Label("endMainLoop");

            IProgramControlExpressionLibrary pcel = libRegistry.GetLibrary<IProgramControlExpressionLibrary>();
            IInteruptExpressionLibrary iel = libRegistry.GetLibrary<IInteruptExpressionLibrary>();
            IDataAccessExpressionLibrary dael = libRegistry.GetLibrary<IDataAccessExpressionLibrary>();

            var methodBody = new List<Expression>();
            methodBody.Add(expressionBuilder.InitializeParameters());
            //methodBody.Add(Expression.Assign(pcel.CycleCounter, Expression.Constant(347)));

            methodBody.Add(Expression.Block(
                    // Handle IRQs if neccessary.
                    Expression.IfThen(Expression.Equal(iel.IFF1, Expression.Constant(true)),
                        Expression.IfThen(Expression.Equal(iel.InteruptRequested, Expression.Constant(true)),
                            Expression.Block(
                                Expression.Assign(iel.InteruptRequested, Expression.Constant(false)),
                                Expression.Assign(iel.IFF1, Expression.Constant(false)),
                                dael.Push(pcel.ProgramCounterRegister),
                                Expression.Assign(pcel.ProgramCounterRegister, Expression.Constant(0x0038)),
                                Expression.SubtractAssign(pcel.CycleCounter, Expression.Constant(13))
                            )
                        )
                    ),

                    Expression.Label(beginMainLoop),

                    Expression.IfThen(Expression.LessThanOrEqual(pcel.CycleCounter, Expression.Constant(0)),
                        Expression.Goto(endMainLoop)
                    ),

                    //Expression.SubtractAssign(pcel.CycleCounter, Expression.Constant(4)),

                    Expression.PostIncrementAssign(iel.RefreshRegister),
                    opcodeResolver,

                    Expression.Goto(beginMainLoop),
                    Expression.Label(endMainLoop)
                )
            );

            methodBody.Add(expressionBuilder.FinalizeParameters());
            return methodBody;
        }