public AstNodeStmIfElse(AstNodeExpr Condition, AstNodeStm True, AstNodeStm False = null) { //if (False == null) False = new AstNodeStmEmpty(); this.Condition = Condition; this.True = True; this.False = False; }
public AstNodeStmIfElse(AstNodeExpr condition, AstNodeStm @true, AstNodeStm @false = null) { //if (False == null) False = new AstNodeStmEmpty(); Condition = condition; True = @true; False = @false; }
public AstNodeStm _branch_likely(AstNodeStm Code) { return ast.IfElse( BranchFlag(), Code ); }
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 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; } }
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); }
public Action<CpuThreadState> CreateDelegate(AstNodeStm AstNodeStm) { //ILGenerator.Emit(OpCodes.Ret); // Optimize AstNodeStm = AstOptimizerPsp.GlobalOptimize(Processor, ast.Statements(AstNodeStm, ast.Return())); #if DEBUG_GENERATE_IL Console.WriteLine("{0}", GeneratorIL.GenerateToString<GeneratorILPsp>(DynamicMethod, AstNodeStm)); #endif #if DEBUG_GENERATE_IL_CSHARP Console.WriteLine("{0}", (new GeneratorCSharpPsp()).GenerateRoot(AstNodeStm).ToString().Replace("CpuThreadState.", "")); #endif new GeneratorILPsp().Init(DynamicMethod, ILGenerator).GenerateRoot(AstNodeStm); try { var Method = (Action<CpuThreadState>)DynamicMethod.CreateDelegate(typeof(Action<CpuThreadState>)); //Console.WriteLine(Method.Method.); if (Platform.IsMono) { Marshal.Prelink(Method.Method); } return Method; } catch (InvalidProgramException InvalidProgramException) { #if LOG_TRACE Console.WriteLine("Invalid Delegate:"); foreach (var Line in SafeILGenerator.GetEmittedInstructions()) { if (Line.Substr(0, 1) == ":") { Console.WriteLine("{0}", Line); } else { Console.WriteLine(" {0}", Line); } } #endif throw (InvalidProgramException); } }
public static void GenerateIl(this AstNodeStm astNodeStm, MethodInfo dynamicMethod) { ILGenerator ilGenerator; switch (dynamicMethod) { case DynamicMethod dm: ilGenerator = dm.GetILGenerator(); break; case MethodBuilder mb: ilGenerator = mb.GetILGenerator(); break; default: throw(new InvalidOperationException("Not a DynamicMethod/MethodBuilder")); } GenerateIl(astNodeStm, dynamicMethod, ilGenerator); }
public AstNodeCaseDefault Default(AstNodeStm code) => new AstNodeCaseDefault(code);
public AstNodeStmIfElse IfElse(AstNodeExpr condition, AstNodeStm True, AstNodeStm False) => new AstNodeStmIfElse(condition, True, False);
public AstNodeCase Case(object value, AstNodeStm code) => new AstNodeCase(value, code);
public AstNodeCaseDefault(AstNodeStm Code) { this.Code = Code; }
private AstNodeStm ProcessGeneratedInstruction(MipsDisassembler.Result disasm, AstNodeStm astNodeStm) { var pc = disasm.InstructionPc; return(_ast.Statements( #if DEBUG_TRACE_INSTRUCTIONS ast.DebugWrite(String.Format("0x{0:X8}: {1}", PC, Disasm)), #endif astNodeStm )); }
public Result CreateDelegate(AstNodeStm astNodeStm, int totalInstructions) { var time0 = DateTime.UtcNow; astNodeStm = AstOptimizerPsp.GlobalOptimize(_processor, Ast.Statements(astNodeStm, Ast.Return())); var time1 = DateTime.UtcNow; #if DEBUG_GENERATE_IL Console.WriteLine("{0}", GeneratorIL.GenerateToString <GeneratorILPsp>(DynamicMethod, AstNodeStm)); #endif #if DEBUG_GENERATE_IL_CSHARP Console.WriteLine("{0}", AstNodeExtensions.ToCSharpString(AstNodeStm).Replace("CpuThreadState.", "")); #endif Action <CpuThreadState> Delegate; var time2 = time1; var disableOptimizations = DynarecConfig.DisableDotNetJitOptimizations; if (totalInstructions >= DynarecConfig.InstructionCountToDisableOptimizations) { disableOptimizations = true; } if (Platform.IsMono) { disableOptimizations = false; } if (DynarecConfig.ForceJitOptimizationsOnEvenLargeFunctions) { disableOptimizations = false; } try { Delegate = MethodCreator.CreateDynamicMethod <Action <CpuThreadState> >( //Delegate = MethodCreator.CreateMethodInClass<Action<CpuThreadState>>( Assembly.GetExecutingAssembly().ManifestModule, $"DynamicMethod_0x{this._pc:X}", disableOptimizations, dynamicMethod => { astNodeStm.GenerateIl(dynamicMethod); time2 = DateTime.UtcNow; } ); } catch (InvalidProgramException) { Console.Error.WriteLine("Invalid Delegate:"); #if LOG_TRACE Console.WriteLine("Invalid Delegate:"); foreach (var Line in SafeILGenerator.GetEmittedInstructions()) { if (Line.Substr(0, 1) == ":") { Console.WriteLine("{0}", Line); } else { Console.WriteLine(" {0}", Line); } } #endif throw; } var time3 = DateTime.UtcNow; return(new Result { Delegate = Delegate, DisableOptimizations = disableOptimizations, TimeOptimize = time1 - time0, TimeGenerateIl = time2 - time1, TimeCreateDelegate = time3 - time2, }); }
public AstNodeStmIfElse IfElse(AstNodeExpr Condition, AstNodeStm True, AstNodeStm False) { return(new AstNodeStmIfElse(Condition, True, False)); }
public static void GenerateIl(this AstNodeStm astNodeStm, MethodInfo methodInfo, ILGenerator ilGenerator) => GeneratorIlPsp.Init(methodInfo, ilGenerator).Reset().GenerateRoot(astNodeStm);
public static void GenerateIl(this AstNodeStm astNodeStm, MethodBuilder dynamicMethod) => GenerateIl(astNodeStm, dynamicMethod, dynamicMethod.GetILGenerator());
public AstNodeCase(object value, AstNodeStm code) { CaseValue = value; Code = code; }
public AstNodeStmCpuInstruction(InstructionInfo InstructionInfo, AstNodeStm AstNodeStm) { this.InstructionInfo = InstructionInfo; this.AstNodeStm = AstNodeStm; }
public AstNodeCaseDefault(AstNodeStm code) { Code = code; }
public AstNodeCase(object Value, AstNodeStm Code) { this.CaseValue = Value; this.Code = Code; }
public static AstNodeStm Optimize(this AstNodeStm astNodeStm, CpuProcessor cpuProcessor) => AstOptimizerPsp.GlobalOptimize(cpuProcessor, astNodeStm);
public static string ToIlString(this AstNodeStm astNodeStm, MethodInfo methodInfo) => GeneratorIlPsp.Reset().GenerateToString(methodInfo, astNodeStm);
public static TType GenerateDelegate <TType>(this AstNodeStm astNodeStm, string methodName) => GeneratorIlPsp.GenerateDelegate <TType>(methodName, astNodeStm);
public AstNodeStmPspInstruction(MipsDisassembler.Result disassembledResult, AstNodeStm statement) { DisassembledResult = disassembledResult; Statement = statement; }
public AstNodeCaseDefault Default(AstNodeStm Code) { return(new AstNodeCaseDefault(Code)); }
public void AddStatement(AstNodeStm node) => Nodes.Add(node);
public static string ToIlString <TDelegate>(this AstNodeStm astNodeStm) => ToIlString(astNodeStm, typeof(TDelegate).GetMethod("Invoke"));
private void UpdateText() { if (PcListBox.SelectedItem != null) { var PCItem = (PCItem)PcListBox.SelectedItem; var MethodCacheInfo = PCItem.MethodCacheInfo; var MinPC = MethodCacheInfo.MinPc; var MaxPC = MethodCacheInfo.MaxPc; var Memory = CpuProcessor.Memory; AstNodeStm Node = null; if (MethodCacheInfo.AstTree != null) { Node = MethodCacheInfo.AstTree.Optimize(CpuProcessor); } var InfoLines = new List <string>(); InfoLines.Add($"Name: {MethodCacheInfo.Name}"); InfoLines.Add($"TotalInstructions: {MethodCacheInfo.TotalInstructions}"); InfoLines.Add($"DisableOptimizations: {MethodCacheInfo.DynarecFunction.DisableOptimizations}"); InfoLines.Add($"EntryPC: 0x{MethodCacheInfo.EntryPc:X8}"); InfoLines.Add($"MinPC: 0x{MethodCacheInfo.MinPc:X8}"); InfoLines.Add($"MaxPC: 0x{MethodCacheInfo.MaxPc:X8}"); InfoLines.Add( $"TimeAnalyzeBranches: {MethodCacheInfo.DynarecFunction.TimeAnalyzeBranches.TotalMilliseconds}"); InfoLines.Add($"TimeGenerateAst: {MethodCacheInfo.DynarecFunction.TimeGenerateAst.TotalMilliseconds}"); InfoLines.Add($"TimeOptimize: {MethodCacheInfo.DynarecFunction.TimeOptimize.TotalMilliseconds}"); InfoLines.Add($"TimeGenerateIL: {MethodCacheInfo.DynarecFunction.TimeGenerateIl.TotalMilliseconds}"); InfoLines.Add( $"TimeCreateDelegate: {MethodCacheInfo.DynarecFunction.TimeCreateDelegate.TotalMilliseconds}"); InfoLines.Add($"TimeLinking: {MethodCacheInfo.DynarecFunction.TimeLinking.TotalMilliseconds}"); InfoLines.Add($"TimeTotal: {MethodCacheInfo.DynarecFunction.TimeTotal.TotalMilliseconds}"); InfoLines.Add(string.Format("")); foreach (var Item in MethodCacheInfo.DynarecFunction.InstructionStats.OrderBy(Pair => Pair.Value)) { InfoLines.Add($"{Item.Key}: {Item.Value}"); } InfoTextBox.Text = string.Join("\r\n", InfoLines); var OutString = ""; switch (LanguageComboBox.SelectedItem.ToString()) { case "C#": if (Node != null) { OutString = Node.ToCSharpString().Replace("CpuThreadState.", ""); } break; case "IL": if (Node != null) { OutString = Node.ToIlString <Action <CpuThreadState> >(); } break; case "Ast": if (Node != null) { OutString = AstSerializer.SerializeAsXml(Node); } break; case "Mips": { var MipsDisassembler = new MipsDisassembler(); try { for (uint PC = MinPC; PC <= MaxPC; PC += 4) { var Instruction = Memory.ReadSafe <Instruction>(PC); var Result = MipsDisassembler.Disassemble(PC, Instruction); OutString += $"0x{PC:X8}: {Result.ToString()}\r\n"; } } catch (Exception Exception) { Console.Error.WriteLine(Exception); } } break; default: break; } ViewTextBox.Text = OutString.Replace("\n", "\r\n"); } }
public AstNodeStmPspInstruction(MipsDisassembler.Result DisassembledResult, AstNodeStm Statement) { this.DisassembledResult = DisassembledResult; this.Statement = Statement; }
public AstNodeCase Case(object Value, AstNodeStm Code) { return(new AstNodeCase(Value, Code)); }
public Result CreateDelegate(AstNodeStm AstNodeStm, int TotalInstructions) { var Time0 = DateTime.UtcNow; AstNodeStm = AstOptimizerPsp.GlobalOptimize(Processor, ast.Statements(AstNodeStm, ast.Return())); var Time1 = DateTime.UtcNow; #if DEBUG_GENERATE_IL Console.WriteLine("{0}", GeneratorIL.GenerateToString<GeneratorILPsp>(DynamicMethod, AstNodeStm)); #endif #if DEBUG_GENERATE_IL_CSHARP Console.WriteLine("{0}", AstNodeExtensions.ToCSharpString(AstNodeStm).Replace("CpuThreadState.", "")); #endif Action<CpuThreadState> Delegate; var Time2 = Time1; bool DisableOptimizations = _DynarecConfig.DisableDotNetJitOptimizations; if (TotalInstructions >= _DynarecConfig.InstructionCountToDisableOptimizations) DisableOptimizations = true; if (Platform.IsMono) DisableOptimizations = false; try { Delegate = MethodCreator.CreateDynamicMethod<Action<CpuThreadState>>( //Delegate = MethodCreator.CreateMethodInClass<Action<CpuThreadState>>( Assembly.GetExecutingAssembly().ManifestModule, String.Format("DynamicMethod_0x{0:X}", this.PC), DisableOptimizations, (DynamicMethod) => { AstNodeStm.GenerateIL(DynamicMethod); Time2 = DateTime.UtcNow; } ); } catch (InvalidProgramException InvalidProgramException) { Console.Error.WriteLine("Invalid Delegate:"); #if LOG_TRACE Console.WriteLine("Invalid Delegate:"); foreach (var Line in SafeILGenerator.GetEmittedInstructions()) { if (Line.Substr(0, 1) == ":") { Console.WriteLine("{0}", Line); } else { Console.WriteLine(" {0}", Line); } } #endif throw (InvalidProgramException); } var Time3 = DateTime.UtcNow; return new Result() { Delegate = Delegate, DisableOptimizations = DisableOptimizations, TimeOptimize = Time1 - Time0, TimeGenerateIL = Time2 - Time1, TimeCreateDelegate = Time3 - Time2, }; }
public void AddStatement(AstNodeStm Node) { this.Nodes.Add(Node); }
private AstNodeStm ProcessGeneratedInstruction(MipsDisassembler.Result Disasm, AstNodeStm AstNodeStm) { var PC = Disasm.InstructionPC; return ast.Statements( #if DEBUG_TRACE_INSTRUCTIONS ast.DebugWrite(String.Format("0x{0:X8}: {1}", PC, Disasm)), #endif AstNodeStm ); }
public AstNodeStm _branch_likely(AstNodeStm code) => _ast.If(BranchFlag(), code);