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 AstNodeStmIfElse(AstNodeExpr Condition, AstNodeStm True, AstNodeStm False = null)
{
//if (False == null) False = new AstNodeStmEmpty();
this.Condition = Condition;
this.True = True;
this.False = False;
}
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 AstNodeCaseDefault(AstNodeStm Code)
{
this.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 AstNodeCase(object Value, AstNodeStm Code)
{
this.CaseValue = Value;
this.Code = Code;
}
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);
public void AddStatement(AstNodeStm Node)
{
this.Nodes.Add(Node);
}
