public AstNodeStm Vrot()
{
var imm5 = _instruction.Imm5;
var cosIndex = BitUtils.Extract(imm5, 0, 2);
var sinIndex = BitUtils.Extract(imm5, 2, 2);
var negateSin = BitUtils.ExtractBool(imm5, 4);
var dest = VecVd;
var src = CelVs;
AstNodeExpr sine = _ast.CallStatic((Func <float, float>)MathFloat.SinV1, src.Get());
AstNodeExpr cosine = _ast.CallStatic((Func <float, float>)MathFloat.CosV1, src.Get());
if (negateSin)
{
sine = -sine;
}
//Console.WriteLine("{0},{1},{2}", CosIndex, SinIndex, NegateSin);
return(dest.SetVector(index =>
{
if (index == cosIndex)
{
return cosine;
}
if (index == sinIndex)
{
return sine;
}
return (sinIndex == cosIndex) ? sine : 0f;
}, _pc));
}
public AstNodeStmIfElse(AstNodeExpr condition, AstNodeStm @true, AstNodeStm @false = null)
{
//if (False == null) False = new AstNodeStmEmpty();
Condition = condition;
True = @true;
False = @false;
}
private AstNodeStm CallDynamicAddress(AstNodeExpr address)
{
return(_ast.StatementsInline(
_link(),
_ast.MethodCacheInfoCallDynamicPc(address, tailCall: false)
));
}
protected AstNodeExpr GetRegApplyPrefix(int[] indices, int regIndex, int prefixIndex)
{
var prefix = VReg.VfpuPrefix;
prefix.CheckPrefixUsage(Pc);
//Console.WriteLine("[Get] {0:X8}:: {1}", PC, Prefix.Enabled);
//Console.WriteLine("GetRegApplyPrefix: {0}, {1}", Indices.Length, RegIndex);
AstNodeExpr astNodeExpr = _GetVRegRef(indices[regIndex]);
if (prefix.Enabled && prefix.IsValidIndex(prefixIndex))
{
// Constant.
if (prefix.SourceConstant(prefixIndex))
{
float value = 0.0f;
var sourceIndex = prefix.SourceIndex(prefixIndex);
switch (sourceIndex)
{
case 0:
value = prefix.SourceAbsolute(prefixIndex) ? (3.0f) : (0.0f);
break;
case 1:
value = prefix.SourceAbsolute(prefixIndex) ? (1.0f / 3.0f) : (1.0f);
break;
case 2:
value = prefix.SourceAbsolute(prefixIndex) ? (1.0f / 4.0f) : (2.0f);
break;
case 3:
value = prefix.SourceAbsolute(prefixIndex) ? (1.0f / 6.0f) : (0.5f);
break;
default: throw (new InvalidOperationException("Invalid SourceIndex : " + sourceIndex));
}
astNodeExpr = Ast.Cast(GetVTypeType(), value);
}
// Value.
else
{
astNodeExpr = _GetVRegRef(indices[(int)prefix.SourceIndex(prefixIndex)]);
if (prefix.SourceAbsolute(prefixIndex))
{
astNodeExpr = Ast.CallStatic((Func <float, float>)MathFloat.Abs, astNodeExpr);
}
}
if (prefix.SourceNegate(prefixIndex))
{
astNodeExpr = Ast.Unary("-", astNodeExpr);
}
}
return(astNodeExpr);
}
public AstNodeStm AssignGPR_F(int index, AstNodeExpr expr)
{
if (index == 0)
{
return(new AstNodeStmEmpty());
}
return(Ast.Assign(GPR_F(index), Ast.Cast <float>(expr, false)));
}
//static public void DumpStackTrace()
//{
// Console.WriteLine(Environment.StackTrace);
//}
private AstNodeStm ReturnFromFunction(AstNodeExpr astNodeExpr)
{
return(_ast.StatementsInline(
_ast.AssignPc(_ast.Gpr(31)),
_ast.GetTickCall(BranchCount > 0),
_ast.Return()
));
}
private AstNodeStm _bvtf(bool True)
{
var register = (int)_instruction.Imm3;
AstNodeExpr branchExpr = _ast.Vcc(register);
if (!True)
{
branchExpr = _ast.Unary("!", branchExpr);
}
return(AssignBranchFlag(branchExpr));
}
public AstNodeExprLValue FieldPropertyAccess(AstNodeExpr Instance, string FieldPropertyName)
{
if (Instance.Type.GetField(FieldPropertyName) != null)
{
return(FieldAccess(Instance, FieldPropertyName));
}
if (Instance.Type.GetProperty(FieldPropertyName) != null)
{
return(PropertyAccess(Instance, FieldPropertyName));
}
throw (new InvalidOperationException(String.Format("Can't find Field/Property '{0}' for type '{1}'", FieldPropertyName, Instance.Type)));
}
public AstNodeExprLValue FieldPropertyAccess(AstNodeExpr instance, string fieldPropertyName)
{
if (instance.Type.GetField(fieldPropertyName) != null)
{
return(FieldAccess(instance, fieldPropertyName));
}
if (instance.Type.GetProperty(fieldPropertyName) != null)
{
return(PropertyAccess(instance, fieldPropertyName));
}
throw new InvalidOperationException(
$"Can't find Field/Property '{fieldPropertyName}' for type '{instance.Type}'");
}
private AstNodeStm JumpDynamicToAddress(AstNodeExpr address)
{
if (DynarecConfig.EnableTailCalling)
{
return(_ast.MethodCacheInfoCallDynamicPc(address, tailCall: true));
}
else
{
return(_ast.Statements(
_ast.AssignPc(address),
_ast.Return()
));
}
}
public AstNodeExpr MemoryGetPointer(PspMemory memory, AstNodeExpr address, bool safe,
string errorDescription = "ERROR", InvalidAddressAsEnum invalidAddress = InvalidAddressAsEnum.Exception)
{
if (safe)
{
return(Ast.CallInstance(
Ast.CpuThreadStateExpr,
(AddressToPointerWithErrorFunc)CpuThreadState.Methods.GetMemoryPtrSafeWithError,
Ast.Cast <uint>(address),
errorDescription,
true,
Ast.Immediate(invalidAddress)
));
}
else
{
if (DynarecConfig.AllowFastMemory && memory.HasFixedGlobalAddress)
{
if (DynarecConfig.EnableFastPspMemoryUtilsGetFastMemoryReader)
{
return(Ast.CallStatic(FastPspMemoryUtils.GetFastMemoryReader(memory.FixedGlobalAddress),
address));
}
else
{
var addressMasked = Ast.Binary(address, "&", Ast.Immediate(FastPspMemory.FastMemoryMask));
return(Ast.Immediate(memory.FixedGlobalAddress) + addressMasked);
}
}
else
{
return(Ast.CallInstance(
Ast.CpuThreadStateExpr,
(AddressToPointerFunc)CpuThreadState.Methods.GetMemoryPtr,
address
));
}
}
}
public AstNodeStm _vcmovtf(bool True)
{
var register = (int)_instruction.Imm3;
Func <int, AstNodeExpr> vcc = index =>
{
AstNodeExpr ret = _ast.Vcc(index);
if (!True)
{
ret = _ast.Unary("!", ret);
}
return(ret);
};
if (register < 6)
{
// TODO: CHECK THIS!
return(_ast.IfElse(
vcc(register),
VecVd.SetVector(index => VecVs[index], _pc),
_ast.Statements(
_ast.Assign(_ast.PrefixSourceEnabled(), false),
//ast.If(ast.PrefixDestinationEnabled(), VEC_VD.SetVector(Index => VEC_VD[Index], PC))
_ast.If(_ast.PrefixDestinationEnabled(), VecVd.SetVector(index => VecVd[index], _pc))
)
));
}
if (register == 6)
{
return(VecVd.SetVector(index => _ast.Ternary(vcc(index), VecVs[index], VecVd[index]), _pc));
}
// Register == 7
// Never copy (checked on a PSP)
return(_ast.Statement());
}
public AstNodeStm MethodCacheInfoCallDynamicPc(AstNodeExpr pc, bool tailCall)
{
//if (_DynarecConfig.FunctionCallWithStaticReferences)
//{
// var Call = (AstNodeExpr)ast.CallInstance(GetMethodCacheInfoAtPC(PC), (Action<CpuThreadState>)MethodCacheInfo.Methods.CallDelegate, ast.CpuThreadState);
// if (TailCall) Call = ast.TailCall(Call as AstNodeExprCall);
// return ast.Statement(Call);
//}
//else
{
var localCachedPc = Ast.Local(AstLocal.Create <uint>("CachedPC"));
var localCachedFunction = Ast.Local(AstLocal.Create <Action <CpuThreadState> >("CachedFunction"));
var localCalculatePc = Ast.Local(AstLocal.Create <uint>("CalculatePC"));
var call = (AstNodeExpr)Ast.CallDelegate(localCachedFunction, Ast.CpuThreadStateExpr);
var callStm = (AstNodeStm)Ast.Statement(call);
if (tailCall)
{
callStm = Ast.Statements(Ast.Statement(Ast.TailCall((AstNodeExprCall)call)), Ast.Return());
}
return(Ast.Statements(
Ast.Assign(localCalculatePc, pc),
Ast.If
(Ast.Binary(localCachedPc, "!=", localCalculatePc),
Ast.Statements(
Ast.Assign(localCachedPc, localCalculatePc),
Ast.Assign(localCachedFunction,
Ast.CallInstance(Ast.CpuThreadStateExpr,
(Func <uint, Action <CpuThreadState> >)CpuThreadStateMethods.GetFuncAtPc, pc))
)
),
callStm
));
}
}
public AstNodeExprCast Cast <T>(AstNodeExpr Expr, bool Explicit = true)
{
return(Cast(typeof(T), Expr, Explicit));
}
public AstNodeExprArrayAccess ArrayAccess(AstNodeExpr Instance, AstNodeExpr Index)
{
return(new AstNodeExprArrayAccess(Instance, Index));
}
public AstNodeExprPropertyAccess PropertyAccess(AstNodeExpr Instance, PropertyInfo PropertyInfo)
{
return(new AstNodeExprPropertyAccess(Instance, PropertyInfo));
}
public AstNodeExprPropertyAccess PropertyAccess(AstNodeExpr Instance, string PropertyName)
{
return(new AstNodeExprPropertyAccess(Instance, PropertyName));
}
public AstNodeExprFieldAccess FieldAccess(AstNodeExpr Instance, string FieldName)
{
return(new AstNodeExprFieldAccess(Instance, FieldName));
}
public AstNodeStmIfElse IfElse(AstNodeExpr Condition, AstNodeStm True, AstNodeStm False)
{
return(new AstNodeStmIfElse(Condition, True, False));
}
public AstNodeStm Throw(AstNodeExpr Expression)
{
return(new AstNodeStmThrow(Expression));
}
public AstNodeStmGotoIfFalse GotoIfFalse(AstLabel AstLabel, AstNodeExpr Condition)
{
return(new AstNodeStmGotoIfFalse(AstLabel, Condition));
}
public AstNodeStmSwitch Switch(AstNodeExpr ValueToCheck, AstNodeCaseDefault Default, params AstNodeCase[] Cases)
{
return(new AstNodeStmSwitch(ValueToCheck, Cases, Default));
}
public AstNodeExprSetGetLValue SetGetLValue(AstNodeExpr SetExpression, AstNodeExpr GetExpression)
{
return(new AstNodeExprSetGetLValue(SetExpression, GetExpression));
}
public AstNodeStmSwitch Switch(AstNodeExpr ValueToCheck, params AstNodeCase[] Cases)
{
return(new AstNodeStmSwitch(ValueToCheck, Cases));
}
public AstNodeStmExpr Statement(AstNodeExpr Expr)
{
return(new AstNodeStmExpr(Expr));
}
public AstNodeStmReturn Return(AstNodeExpr Expr = null)
{
return(new AstNodeStmReturn(Expr));
}
public AstNodeExprCast Cast(Type Type, AstNodeExpr Expr, bool Explicit = true)
{
return(new AstNodeExprCast(Type, Expr, Explicit));
}
public AstNodeStmAssign Assign(AstNodeExprLValue Left, AstNodeExpr Expr)
{
return(new AstNodeStmAssign(Left, Expr));
}
private AstNodeStm AssignBranchFlag(AstNodeExpr expr, bool andLink = false)
{
_andLink = andLink;
_branchPc = _pc;
return(_ast.Assign(BranchFlag(), _ast.Cast <bool>(expr, Explicit: false)));
}
public AstNodeExprIndirect Indirect(AstNodeExpr PointerExpr)
{
return(new AstNodeExprIndirect(PointerExpr));
}
