Esempio n. 1
0
 public CpuEmiter(MipsMethodEmiter MipsMethodEmiter, InstructionReader InstructionReader, Stream MemoryStream, CpuProcessor CpuProcessor)
 {
     this.MipsMethodEmiter  = MipsMethodEmiter;
     this.InstructionReader = InstructionReader;
     this.MemoryStream      = MemoryStream;
     this.CpuProcessor      = CpuProcessor;
 }
Esempio n. 2
0
 public override void InitializeComponent()
 {
     this.Callbacks          = new HleUidPool <HleCallback>();
     this.ScheduledCallbacks = new Queue <HleCallback>();
     this.CpuProcessor       = PspEmulatorContext.GetInstance <CpuProcessor>();
     this.HleInterop         = PspEmulatorContext.GetInstance <HleInterop>();
 }
Esempio n. 3
0
 public CpuEmiter(MipsMethodEmiter MipsMethodEmiter, InstructionReader InstructionReader, Stream MemoryStream, CpuProcessor CpuProcessor)
 {
     this.MipsMethodEmiter = MipsMethodEmiter;
     this.InstructionReader = InstructionReader;
     this.MemoryStream = MemoryStream;
     this.CpuProcessor = CpuProcessor;
 }
Esempio n. 4
0
        public override void InitializeComponent()
        {
            this.IsRunning     = true;
            this.CpuProcessor  = PspEmulatorContext.GetInstance <CpuProcessor>();
            this.GpuProcessor  = PspEmulatorContext.GetInstance <GpuProcessor>();
            this.PspAudio      = PspEmulatorContext.GetInstance <PspAudio>();
            this.PspConfig     = PspEmulatorContext.PspConfig;
            this.PspRtc        = PspEmulatorContext.GetInstance <PspRtc>();
            this.PspDisplay    = PspEmulatorContext.GetInstance <PspDisplay>();
            this.PspController = PspEmulatorContext.GetInstance <PspController>();

            this.MipsEmiter = new MipsEmiter();
            this.Kirk       = new Kirk();
            this.Kirk.kirk_init();

            this.HleOutputHandler = PspEmulatorContext.GetInstance <HleOutputHandler>();

            // @TODO FIX! New Instances!?
            this.ThreadManager       = PspEmulatorContext.GetInstance <HleThreadManager>();
            this.SemaphoreManager    = PspEmulatorContext.GetInstance <HleSemaphoreManager>();
            this.EventFlagManager    = PspEmulatorContext.GetInstance <HleEventFlagManager>();
            this.MemoryManager       = new HleMemoryManager(this.CpuProcessor.Memory);
            this.ModuleManager       = PspEmulatorContext.GetInstance <HleModuleManager>();
            this.CallbackManager     = PspEmulatorContext.GetInstance <HleCallbackManager>();
            this.HleIoManager        = PspEmulatorContext.GetInstance <HleIoManager>();
            this.HleRegistryManager  = PspEmulatorContext.GetInstance <HleRegistryManager>();
            this.HleInterruptManager = PspEmulatorContext.GetInstance <HleInterruptManager>();
        }
Esempio n. 5
0
 public LlePspCpu(string name, InjectContext injectContext, CpuProcessor cpuProcessor,
                  uint entryPoint = 0x1fc00000)
 {
     _name = name;
     //this.CachedGetMethodCache = PspEmulatorContext.GetInstance<CachedGetMethodCache>();
     CpuThreadState = new CpuThreadState(cpuProcessor);
     EntryPoint     = entryPoint;
 }
 public static AstNodeStm GlobalOptimize(CpuProcessor processor, AstNodeStm astNodeStm)
 {
     if (processor == null || processor.CpuConfig.EnableAstOptimizations)
     {
         return((AstNodeStm)(new AstOptimizerPsp(processor?.Memory)).Optimize(
                    ast.Statements(astNodeStm, ast.Return())));
     }
     return(astNodeStm);
 }
Esempio n. 7
0
		public static AstNodeStm GlobalOptimize(CpuProcessor Processor, AstNodeStm AstNodeStm)
		{
			if (Processor == null || Processor.CpuConfig.EnableAstOptimizations)
			{
				return (AstNodeStm)(new AstOptimizerPsp(Processor != null ? Processor.Memory : null)).Optimize(ast.Statements(AstNodeStm, ast.Return()));
			} else {
				return AstNodeStm;
			}
		}
Esempio n. 8
0
		public static AstNodeStm GlobalOptimize(CpuProcessor Processor, AstNodeStm AstNodeStm)
		{
			if (Processor.PspConfig.StoredConfig.EnableAstOptimizations)
			{
				return (AstNodeStm)(new AstOptimizerPsp(Processor)).Optimize(ast.Statements(AstNodeStm, ast.Return()));
			} else {
				return AstNodeStm;
			}
		}
        public void SetUp()
        {
            PspConfig          = new PspConfig();
            PspEmulatorContext = new PspEmulatorContext(PspConfig);
            PspEmulatorContext.SetInstanceType <PspMemory, LazyPspMemory>();

            Processor     = PspEmulatorContext.GetInstance <CpuProcessor>();
            MipsAssembler = new MipsAssembler(new PspMemoryStream(PspEmulatorContext.GetInstance <PspMemory>()));
        }
Esempio n. 10
0
        public override void InitializeComponent()
        {
            CpuProcessor  = PspEmulatorContext.GetInstance <CpuProcessor>();
            PspRtc        = PspEmulatorContext.GetInstance <PspRtc>();
            ThreadManager = PspEmulatorContext.GetInstance <HleThreadManager>();
            HleState      = PspEmulatorContext.GetInstance <HleState>();
            PspMemory     = PspEmulatorContext.GetInstance <PspMemory>();

            RegisterDevices();
        }
Esempio n. 11
0
        public void TestMethod2()
        {
            var processor   = new CpuProcessor();
            var state       = new CpuThreadState(processor);
            var interpreter = new CpuInterpreter(state);

            state.Gpr2 = 3;
            state.Gpr3 = 7;
            interpreter.Interpret(MipsAssembler.StaticAssembleInstructions(@"add r1, r2, r3").Instructions[0]);
            Assert.Equal(3 + 7, (int)state.Gpr1);
        }
Esempio n. 12
0
		public MipsMethodEmitter(CpuProcessor Processor, uint PC, bool DoDebug = false, bool DoLog = false)
		{
			this.Processor = Processor;

			DynamicMethod = new DynamicMethod(
				String.Format("DynamicMethod_0x{0:X}", PC),
				typeof(void),
				new Type[] { typeof(CpuThreadState) },
				Assembly.GetExecutingAssembly().ManifestModule
			);
		}
Esempio n. 13
0
        public MethodCompilerThread(CpuProcessor cpuProcessor, MethodCache methodCache)
        {
            _cpuProcessor = cpuProcessor;
            _methodCache  = methodCache;
            var thread = new Thread(Main)
            {
                Name         = "MethodCompilerThread",
                IsBackground = true
            };

            thread.Start();
        }
			internal InternalFunctionCompiler(CpuProcessor CpuProcessor, MipsMethodEmitter MipsMethodEmiter, DynarecFunctionCompiler DynarecFunctionCompiler, IInstructionReader InstructionReader, Action<uint> _ExploreNewPcCallback, uint EntryPC, bool DoLog)
			{
				this._ExploreNewPcCallback = _ExploreNewPcCallback;
				this.CpuEmitter = new CpuEmitter(MipsMethodEmiter, InstructionReader, CpuProcessor);
				this.MipsMethodEmitter = MipsMethodEmiter;
				this.GlobalInstructionStats = CpuProcessor.GlobalInstructionStats;
				this.InstructionStats = MipsMethodEmiter.InstructionStats;
				this.NewInstruction = new Dictionary<string, bool>();
				this.DoLog = DoLog;

				this.CpuProcessor = CpuProcessor;
				this.DynarecFunctionCompiler = DynarecFunctionCompiler;
				this.InstructionReader = InstructionReader;
				this.EntryPC = EntryPC;
			}
Esempio n. 15
0
 public override void InitializeComponent()
 {
     this.HleCallbackManager = PspEmulatorContext.GetInstance <HleCallbackManager>();
     this.CpuProcessor       = PspEmulatorContext.GetInstance <CpuProcessor>();
     this.HleInterop         = PspEmulatorContext.GetInstance <HleInterop>();
     //uint MaxHandlers = Enum.GetValues(typeof(PspInterrupts)).OfType<uint>().Max() + 1;
     InterruptHandlers = new HleInterruptHandler[(int)PspInterrupts._MAX];
     for (int n = 0; n < InterruptHandlers.Length; n++)
     {
         InterruptHandlers[n] = new HleInterruptHandler(
             this,
             (PspInterrupts)n,
             HleCallbackManager
             );
     }
 }
Esempio n. 16
0
        static public Action <CpuThreadState> CreateDelegateForPC(CpuProcessor CpuProcessor, Stream MemoryStream, uint EntryPC)
        {
            DateTime Start, End;
            int      InstructionsProcessed = 0;

            Start = DateTime.Now;
            try
            {
                return(_CreateDelegateForPC(CpuProcessor, MemoryStream, EntryPC, out InstructionsProcessed));
            }
            finally
            {
                End = DateTime.Now;
                //Console.WriteLine("Generated 0x{0:X} {1} ({2})", EntryPC, End - Start, InstructionsProcessed);
            }
        }
Esempio n. 17
0
 public AstNodeExprCallDelegate MethodCacheInfoCallStaticPc(CpuProcessor cpuProcessor, uint pc)
 {
     if (DynarecConfig.FunctionCallWithStaticReferences)
     {
         var methodCacheInfo = cpuProcessor.MethodCache.GetForPc(pc);
         return(Ast.CallDelegate(Ast.StaticFieldAccess(methodCacheInfo.StaticField.FieldInfo),
                                 Ast.CpuThreadStateExpr));
     }
     else
     {
         return(Ast.CallDelegate(
                    Ast.CallInstance(Ast.CpuThreadStateExpr,
                                     (Func <uint, Action <CpuThreadState> >)CpuThreadStateMethods.GetFuncAtPc, pc),
                    Ast.CpuThreadStateExpr));
     }
 }
Esempio n. 18
0
		public MipsMethodEmiter(MipsEmiter MipsEmiter, CpuProcessor Processor)
		{
			this.Processor = Processor;

			if (!InitializedOnce)
			{
				Field_GPRList = new FieldInfo[32];
				Field_FPRList = new FieldInfo[32];
				for (int n = 0; n < 32; n++)
				{
					Field_GPRList[n] = typeof(CpuThreadState).GetField("GPR" + n);
					Field_FPRList[n] = typeof(CpuThreadState).GetField("FPR" + n);
				}

				InitializedOnce = true;
			}

			UniqueCounter++;

#if USE_DYNAMIC_METHOD
			DynamicMethod = new DynamicMethod(
				"",
				typeof(void),
				new Type[] { typeof(CpuThreadState) },
				Assembly.GetExecutingAssembly().ManifestModule
			);
			ILGenerator = DynamicMethod.GetILGenerator();
#else
			TypeBuilder = MipsEmiter.ModuleBuilder.DefineType("type" + UniqueCounter, TypeAttributes.Sealed | TypeAttributes.Public);
			MethodBuilder = TypeBuilder.DefineMethod(
				name: MethodName = "method" + UniqueCounter,
				attributes: MethodAttributes.Static | MethodAttributes.Public | MethodAttributes.UnmanagedExport | MethodAttributes.Final,
				returnType: typeof(void),
				parameterTypes: new Type[] { typeof(CpuThreadState) }
			);
			ILGenerator = MethodBuilder.GetILGenerator();
#endif
		}
Esempio n. 19
0
        public MipsMethodEmiter(MipsEmiter MipsEmiter, CpuProcessor Processor)
        {
            this.Processor = Processor;

            if (!InitializedOnce)
            {
                Field_GPRList = new FieldInfo[32];
                Field_FPRList = new FieldInfo[32];
                for (int n = 0; n < 32; n++)
                {
                    Field_GPRList[n] = typeof(CpuThreadState).GetField("GPR" + n);
                    Field_FPRList[n] = typeof(CpuThreadState).GetField("FPR" + n);
                }

                InitializedOnce = true;
            }

            UniqueCounter++;

#if USE_DYNAMIC_METHOD
            DynamicMethod = new DynamicMethod(
                "",
                typeof(void),
                new Type[] { typeof(CpuThreadState) },
                Assembly.GetExecutingAssembly().ManifestModule
                );
            ILGenerator = DynamicMethod.GetILGenerator();
#else
            TypeBuilder          = MipsEmiter.ModuleBuilder.DefineType("type" + UniqueCounter, TypeAttributes.Sealed | TypeAttributes.Public);
            MethodBuilder        = TypeBuilder.DefineMethod(
                name: MethodName = "method" + UniqueCounter,
                attributes: MethodAttributes.Static | MethodAttributes.Public | MethodAttributes.UnmanagedExport | MethodAttributes.Final,
                returnType: typeof(void),
                parameterTypes: new Type[] { typeof(CpuThreadState) }
                );
            ILGenerator = MethodBuilder.GetILGenerator();
#endif
        }
Esempio n. 20
0
 public override void InitializeComponent()
 {
     this.Processor           = PspEmulatorContext.GetInstance <CpuProcessor>();
     this.HleCallbackManager  = PspEmulatorContext.GetInstance <HleCallbackManager>();
     this.HleInterruptManager = PspEmulatorContext.GetInstance <HleInterruptManager>();
 }
Esempio n. 21
0
		private AstOptimizerPsp(CpuProcessor Processor)
		{
			this.Processor = Processor;
		}
Esempio n. 22
0
 public static AstNodeStm Optimize(this AstNodeStm astNodeStm, CpuProcessor cpuProcessor) =>
 AstOptimizerPsp.GlobalOptimize(cpuProcessor, astNodeStm);
Esempio n. 23
0
        static private Action <CpuThreadState> _CreateDelegateForPC(CpuProcessor CpuProcessor, Stream MemoryStream, uint EntryPC, out int InstructionsProcessed)
        {
            InstructionsProcessed = 0;

            if (EntryPC == 0)
            {
                if (MemoryStream is PspMemoryStream)
                {
                    throw (new InvalidOperationException("EntryPC can't be NULL"));
                }
            }

            if (CpuProcessor.PspConfig.TraceJIT)
            {
                Console.WriteLine("Emiting EntryPC=0x{0:X}", EntryPC);
            }

            MemoryStream.Position = EntryPC;
            if ((MemoryStream.Length >= 8) && new BinaryReader(MemoryStream).ReadUInt64() == 0x0000000003E00008)
            {
                Console.WriteLine("NullSub detected at 0x{0:X}!", EntryPC);
            }

            var InstructionReader = new InstructionReader(MemoryStream);
            var MipsMethodEmiter  = new MipsMethodEmiter(MipsEmiter, CpuProcessor);
            var ILGenerator       = MipsMethodEmiter.ILGenerator;
            var CpuEmiter         = new CpuEmiter(MipsMethodEmiter, InstructionReader, MemoryStream, CpuProcessor);

            uint PC;
            uint EndPC = (uint)MemoryStream.Length;
            uint MinPC = uint.MaxValue, MaxPC = uint.MinValue;

            var Labels            = new SortedDictionary <uint, Label>();
            var BranchesToAnalyze = new Queue <uint>();
            var AnalyzedPC        = new HashSet <uint>();

            Labels[EntryPC] = ILGenerator.DefineLabel();

            BranchesToAnalyze.Enqueue(EntryPC);

            // PASS1: Analyze and find labels.
            PC = EntryPC;
            //Debug.WriteLine("PASS1: (PC={0:X}, EndPC={1:X})", PC, EndPC);

            var GlobalInstructionStats = CpuProcessor.GlobalInstructionStats;
            var InstructionStats       = new Dictionary <string, uint>();
            var NewInstruction         = new Dictionary <string, bool>();

            int MaxNumberOfInstructions = 8 * 1024;

            //int MaxNumberOfInstructions = 60;

            while (BranchesToAnalyze.Count > 0)
            {
                bool EndOfBranchFound = false;

                for (PC = BranchesToAnalyze.Dequeue(); PC < EndPC; PC += 4)
                {
                    // If already analyzed, stop scanning this branch.
                    if (AnalyzedPC.Contains(PC))
                    {
                        break;
                    }
                    AnalyzedPC.Add(PC);
                    //Console.WriteLine("%08X".Sprintf(PC));

                    if (AnalyzedPC.Count > MaxNumberOfInstructions)
                    {
                        throw (new InvalidDataException("Code sequence too long: >= " + MaxNumberOfInstructions + ""));
                    }

                    MinPC = Math.Min(MinPC, PC);
                    MaxPC = Math.Max(MaxPC, PC);

                    //Console.WriteLine("    PC:{0:X}", PC);

                    CpuEmiter.LoadAT(PC);

                    var BranchInfo = GetBranchInfo(CpuEmiter.Instruction.Value);
                    if (CpuProcessor.PspConfig.LogInstructionStats)
                    {
                        var InstructionName = GetInstructionName(CpuEmiter.Instruction.Value, null);

                        if (!InstructionStats.ContainsKey(InstructionName))
                        {
                            InstructionStats[InstructionName] = 0;
                        }
                        InstructionStats[InstructionName]++;

                        if (!GlobalInstructionStats.ContainsKey(InstructionName))
                        {
                            NewInstruction[InstructionName]         = true;
                            GlobalInstructionStats[InstructionName] = 0;
                        }

                        GlobalInstructionStats[InstructionName]++;
                        //var GlobalInstructionStats = CpuProcessor.GlobalInstructionStats;
                        //var InstructionStats = new Dictionary<string, uint>();
                        //var NewInstruction = new Dictionary<string, bool>();
                    }

                    // Branch instruction.
                    if ((BranchInfo & CpuBranchAnalyzer.Flags.JumpInstruction) != 0)
                    {
                        //Console.WriteLine("Instruction");
                        EndOfBranchFound = true;
                        continue;
                    }
                    else if ((BranchInfo & CpuBranchAnalyzer.Flags.BranchOrJumpInstruction) != 0)
                    {
                        var BranchAddress = CpuEmiter.Instruction.GetBranchAddress(PC);
                        Labels[BranchAddress] = ILGenerator.DefineLabel();
                        BranchesToAnalyze.Enqueue(BranchAddress);

                        // Jump Always performed.

                        /*
                         * if ((BranchInfo & CpuBranchAnalyzer.Flags.JumpAlways) != 0)
                         * {
                         *      EndOfBranchFound = true;
                         *      continue;
                         * }
                         */
                    }
                    else if ((BranchInfo & CpuBranchAnalyzer.Flags.SyscallInstruction) != 0)
                    {
                        // On this special Syscall
                        if (CpuEmiter.Instruction.CODE == FunctionGenerator.NativeCallSyscallCode)
                        {
                            //PC += 4;
                            break;
                        }
                    }

                    // A Jump Always found. And we have also processed the delayed branch slot. End the branch.
                    if (EndOfBranchFound)
                    {
                        EndOfBranchFound = false;
                        break;
                    }
                }
            }

            // PASS2: Generate code and put labels;
            Action <uint> _EmitCpuInstructionAT = (_PC) =>
            {
                if (CpuProcessor.PspConfig.TraceJIT)
                {
                    ILGenerator.Emit(OpCodes.Ldarg_0);
                    ILGenerator.Emit(OpCodes.Ldc_I4, _PC);
                    ILGenerator.Emit(OpCodes.Call, typeof(CpuThreadState).GetMethod("Trace"));
                    Console.WriteLine("     PC=0x{0:X}", _PC);
                }

                CpuEmiter.LoadAT(_PC);
                CpuEmiterInstruction(CpuEmiter.Instruction.Value, CpuEmiter);
            };

            uint InstructionsEmitedSinceLastWaypoint = 0;

            Action StorePC = () =>
            {
                MipsMethodEmiter.SavePC(PC);
            };

            Action <bool> EmitInstructionCountIncrement = (bool CheckForYield) =>
            {
                if (!CpuProcessor.PspConfig.CountInstructionsAndYield)
                {
                    return;
                }

                //Console.WriteLine("EmiteInstructionCountIncrement: {0},{1}", InstructionsEmitedSinceLastWaypoint, CheckForYield);
                if (InstructionsEmitedSinceLastWaypoint > 0)
                {
                    MipsMethodEmiter.SaveStepInstructionCount(() =>
                    {
                        MipsMethodEmiter.LoadStepInstructionCount();
                        ILGenerator.Emit(OpCodes.Ldc_I4, InstructionsEmitedSinceLastWaypoint);
                        //ILGenerator.Emit(OpCodes.Add);
                        ILGenerator.Emit(OpCodes.Sub);
                    });
                    //ILGenerator.Emit(OpCodes.Ldc_I4, 100);
                    //ILGenerator.EmitCall(OpCodes.Call, typeof(Console).GetMethod("WriteLine"), new Type[] { typeof(int) });
                    InstructionsEmitedSinceLastWaypoint = 0;
                }

                if (CheckForYield)
                {
                    if (!CpuProcessor.PspConfig.BreakInstructionThreadSwitchingForSpeed)
                    {
                        var NoYieldLabel = ILGenerator.DefineLabel();
                        MipsMethodEmiter.LoadStepInstructionCount();
                        ILGenerator.Emit(OpCodes.Ldc_I4_0);
                        ILGenerator.Emit(OpCodes.Bgt, NoYieldLabel);
                        //ILGenerator.Emit(OpCodes.Ldc_I4, 1000000);
                        //ILGenerator.Emit(OpCodes.Blt, NoYieldLabel);
                        MipsMethodEmiter.SaveStepInstructionCount(() =>
                        {
                            ILGenerator.Emit(OpCodes.Ldc_I4_0);
                        });
                        StorePC();
                        ILGenerator.Emit(OpCodes.Ldarg_0);
                        ILGenerator.Emit(OpCodes.Call, typeof(CpuThreadState).GetMethod("Yield"));
                        //ILGenerator.Emit(OpCodes.Call, typeof(GreenThread).GetMethod("Yield"));
                        ILGenerator.MarkLabel(NoYieldLabel);
                    }
                }
            };

            Action EmitCpuInstruction = () =>
            {
                if (CpuProcessor.NativeBreakpoints.Contains(PC))
                {
                    ILGenerator.Emit(OpCodes.Call, typeof(DebugUtils).GetMethod("IsDebuggerPresentDebugBreak"));
                }

                // Marks label.
                if (Labels.ContainsKey(PC))
                {
                    EmitInstructionCountIncrement(false);
                    ILGenerator.MarkLabel(Labels[PC]);
                }

                _EmitCpuInstructionAT(PC);
                PC += 4;
                InstructionsEmitedSinceLastWaypoint++;
            };

            //Debug.WriteLine("PASS2: MinPC:{0:X}, MaxPC:{1:X}", MinPC, MaxPC);

            // Jumps to the entry point.
            ILGenerator.Emit(OpCodes.Br, Labels[EntryPC]);

            for (PC = MinPC; PC <= MaxPC;)
            {
                uint        CurrentInstructionPC = PC;
                Instruction CurrentInstruction   = InstructionReader[PC];
                InstructionsProcessed++;

                /*
                 * if (!AnalyzedPC.Contains(CurrentInstructionPC))
                 * {
                 *      // Marks label.
                 *      if (Labels.ContainsKey(PC))
                 *      {
                 *              ILGenerator.MarkLabel(Labels[PC]);
                 *      }
                 *
                 *
                 *      PC += 4;
                 *      continue;
                 * }
                 */

                var BranchInfo = GetBranchInfo(CurrentInstruction.Value);

                // Delayed branch instruction.
                if ((BranchInfo & CpuBranchAnalyzer.Flags.BranchOrJumpInstruction) != 0)
                {
                    InstructionsEmitedSinceLastWaypoint += 2;
                    EmitInstructionCountIncrement(true);

                    var BranchAddress = CurrentInstruction.GetBranchAddress(PC);

                    if ((BranchInfo & CpuBranchAnalyzer.Flags.JumpInstruction) != 0)
                    {
                        // Marks label.
                        if (Labels.ContainsKey(PC))
                        {
                            ILGenerator.MarkLabel(Labels[PC]);
                        }

                        _EmitCpuInstructionAT(PC + 4);
                        _EmitCpuInstructionAT(PC + 0);
                        PC += 8;
                    }
                    else
                    {
                        // Branch instruction.
                        EmitCpuInstruction();

                        //if ((BranchInfo & CpuBranchAnalyzer.Flags.Likely) != 0)
                        if (BranchInfo.HasFlag(CpuBranchAnalyzer.Flags.Likely))
                        {
                            //Console.WriteLine("Likely");
                            // Delayed instruction.
                            CpuEmiter._branch_likely(() =>
                            {
                                EmitCpuInstruction();
                            });
                        }
                        else
                        {
                            //Console.WriteLine("Not Likely");
                            // Delayed instruction.
                            EmitCpuInstruction();
                        }

                        if (CurrentInstructionPC + 4 != BranchAddress)
                        {
                            if (Labels.ContainsKey(BranchAddress))
                            {
                                CpuEmiter._branch_post(Labels[BranchAddress]);
                            }
                            // Code not reached.
                            else
                            {
                            }
                        }
                    }
                }
                // Normal instruction.
                else
                {
                    // Syscall instruction.
                    if ((BranchInfo & CpuBranchAnalyzer.Flags.SyscallInstruction) != 0)
                    {
                        StorePC();
                    }
                    EmitCpuInstruction();
                    if ((BranchInfo & CpuBranchAnalyzer.Flags.SyscallInstruction) != 0)
                    {
                        // On this special Syscall
                        if (CurrentInstruction.CODE == FunctionGenerator.NativeCallSyscallCode)
                        {
                            //PC += 4;
                            break;
                        }
                    }
                }
            }


            if (CpuProcessor.PspConfig.ShowInstructionStats)
            {
                Console.Error.WriteLine("-------------------------- {0:X}-{1:X} ", MinPC, MaxPC);
                foreach (var Pair in InstructionStats.OrderByDescending(Item => Item.Value))
                {
                    Console.Error.Write("{0} : {1}", Pair.Key, Pair.Value);
                    if (NewInstruction.ContainsKey(Pair.Key))
                    {
                        Console.Error.Write(" <-- NEW!");
                    }
                    Console.Error.WriteLine("");
                }
            }

            //if (BreakPoint) IsDebuggerPresentDebugBreak();
            Action <CpuThreadState> Delegate = MipsMethodEmiter.CreateDelegate();

            return(Delegate);
        }
Esempio n. 24
0
 public MethodCompilerThread(CpuProcessor CpuProcessor, MethodCache MethodCache)
 {
     this.CpuProcessor = CpuProcessor;
     this.MethodCache = MethodCache;
     this.Thread = new Thread(Main)
     {
         IsBackground = true
     };
     this.Thread.Start();
 }
		//public readonly Dictionary<string, uint> InstructionStats = new Dictionary<string, uint>();

		public MipsMethodEmitter(CpuProcessor Processor, uint PC, bool DoDebug = false, bool DoLog = false)
		{
			this.Processor = Processor;
			this.PC = PC;
		}
		static public AstNodeExprCallDelegate MethodCacheInfoCallStaticPC(CpuProcessor CpuProcessor, uint PC)
		{
			var MethodCacheInfo = CpuProcessor.MethodCache.GetForPC(PC);
			return ast.CallDelegate(ast.StaticFieldAccess(MethodCacheInfo.StaticField.FieldInfo), CpuThreadStateArgument());
		}
Esempio n. 27
0
 public void SetUp()
 {
     Processor      = PspEmulatorContext.GetInstance <CpuProcessor>();
     CpuThreadState = new CpuThreadState(Processor);
 }
        //public readonly Dictionary<string, uint> InstructionStats = new Dictionary<string, uint>();

        public MipsMethodEmitter(CpuProcessor processor, uint pc, bool doDebug = false, bool doLog = false)
        {
            _processor = processor;
            _pc        = pc;
        }
Esempio n. 29
0
 public CpuEmiter(MipsMethodEmiter MipsMethodEmiter, IInstructionReader InstructionReader, CpuProcessor CpuProcessor)
 {
     this.MipsMethodEmiter = MipsMethodEmiter;
     this.InstructionReader = InstructionReader;
     this.CpuProcessor = CpuProcessor;
 }