public override Constant ApplyConstants(Constant c1, Constant c2)
{
if (!ValidArgs(c1, c2))
{
return(InvalidConstant.Create(c1.DataType));
}
if (c1.DataType.IsPointer && c2.DataType.IsIntegral)
{
var dt = PrimitiveType.Create(Domain.Pointer, c1.DataType.BitSize);
return(Constant.Create(dt, c1.ToUInt64() + c2.ToUInt64()));
}
else if (c2.DataType.IsPointer && c1.DataType.IsIntegral)
{
var dt = PrimitiveType.Create(Domain.Pointer, c2.DataType.BitSize);
return(Constant.Create(dt, c1.ToUInt64() + c2.ToUInt64()));
}
else
{
var p1 = (PrimitiveType)c1.DataType;
var p2 = (PrimitiveType)c1.DataType;
if ((p1.Domain & p2.Domain) == 0 &&
(p1.Domain | p2.Domain) != Domain.Integer)
{
throw new ArgumentException(string.Format("Can't add types of disjoint domains {0} and {1}", c1.DataType, c2.DataType));
}
}
if (c2.DataType.BitSize <= 64 && c2.DataType.BitSize <= 64)
{
return(BuildConstant(c1.DataType, c2.DataType, c1.ToInt64() + c2.ToInt64()));
}
else
{
return(BuildConstant(c1.DataType, c2.DataType, c1.ToBigInteger() + c2.ToBigInteger()));
}
}
/// <summary>
/// Get the PIC register value. If the register is composed of subregisters, then calculate the value based on individual subregisters.
/// </summary>
/// <param name="reg">The PIC register.</param>
/// <returns>
/// The register value as a constant or invalid..
/// </returns>
public override Constant GetRegister(RegisterStorage reg)
{
if ((reg is PICRegisterStorage preg) && IsValid(preg))
{
uint ival;
if (preg.HasAttachedRegs)
{
ival = 0;
foreach (var sreg in preg.AttachedRegs !)
{
if (!IsValid(sreg))
{
return(InvalidConstant.Create(reg.DataType));
}
ival |= ValidRegsValues[sreg].ActualValue << (int)sreg.BitAddress;
}
}
else
{
ival = ValidRegsValues[preg].ActualValue;
}
return(Constant.Create(reg.DataType, ival));
}
return(InvalidConstant.Create(reg.DataType));
}
private void OkButton_Click(object sender, EventArgs e)
{
var items = new Dictionary <Storage, Constant>();
foreach (DataGridViewRow row in dlg.Grid.Rows)
{
Storage stg = null;
if (row.Cells[0].Value is string sRegister)
{
if (dlg.Architecture.TryGetRegister(sRegister, out var reg))
{
stg = reg;
}
else
{
stg = dlg.Architecture.GetFlagGroup(sRegister);
}
}
if (stg != null && row.Cells[1].Value is string sValue)
{
var value = sValue != "*"
? Constant.Create(stg.DataType, Convert.ToUInt64(sValue, 16))
: InvalidConstant.Create(stg.DataType);
items[stg] = value;
}
}
var list = items.Select(de => new UserRegisterValue(de.Key, de.Value)).ToList();
dlg.RegisterValues = list;
}
public void M68ks_SetIllegalValue()
{
var invalid = InvalidConstant.Create(Registers.a7.DataType);
state.SetValue(Registers.a7, invalid);
Assert.AreSame(invalid, state.GetValue(Registers.a7));
}
public override Constant ApplyConstants(Constant c1, Constant c2)
{
if (!ValidArgs(c1, c2))
{
return(InvalidConstant.Create(c1.DataType));
}
if (c1.DataType.IsPointer && c2.DataType.IsIntegral)
{
var dt = PrimitiveType.Create(Domain.Pointer, c1.DataType.BitSize);
return(Constant.Create(dt, c1.ToUInt64() - c2.ToUInt64()));
}
else if (c2.DataType.IsPointer && c1.DataType.IsIntegral)
{
var dt = PrimitiveType.Create(Domain.Pointer, c2.DataType.BitSize);
return(Constant.Create(dt, c1.ToUInt64() - c2.ToUInt64()));
}
else if (c1.DataType.BitSize <= 64 && c2.DataType.BitSize <= 64)
{
return(BuildConstant(c1.DataType, c2.DataType, c1.ToInt64() - c2.ToInt64()));
}
else
{
return(BuildConstant(c1.DataType, c2.DataType, c1.ToBigInteger() - c2.ToBigInteger()));
}
}
public CallInstruction Call(string procedureName, int retSizeOnStack)
{
var ci = new CallInstruction(InvalidConstant.Create(Architecture.WordWidth), new CallSite(retSizeOnStack, 0));
unresolvedProcedures.Add(new ProcedureConstantUpdater(procedureName, ci));
Emit(ci);
return(ci);
}
public override Expression BindReturnValue(Identifier id)
{
if (returnValues.ContainsKey(id))
{
return(returnValues[id]);
}
return(InvalidConstant.Create(id.DataType));
}
public override Constant ApplyConstants(Constant c1, Constant c2)
{
if (!ValidArgs(c1, c2))
{
return(InvalidConstant.Create(PrimitiveType.Bool));
}
return(Constant.Bool(c1.ToReal64() <= c2.ToReal64()));
}
public override Constant ApplyConstants(Constant c1, Constant c2)
{
if (!ValidArgs(c1, c2))
{
return(InvalidConstant.Create(c1.DataType));
}
return(c1.ToInt32() == c2.ToInt32() ? Constant.True() : Constant.False());
}
public override Constant GetRegister(RegisterStorage r)
{
if (regValues.TryGetValue(r.Domain, out var constant))
{
return(constant);
}
return(InvalidConstant.Create(r.DataType));
}
public override Constant ApplyConstants(Constant c1, Constant c2)
{
if (!ValidArgs(c1, c2))
{
return(InvalidConstant.Create(c1.DataType));
}
return(Constant.Bool(c1.ToReal64() < c2.ToReal64()));
}
public override Constant ApplyConstants(Constant c1, Constant c2)
{
if (!ValidArgs(c1, c2))
{
return(InvalidConstant.Create(c1.DataType));
}
return(BuildConstant(c1.DataType, c2.DataType, c1.ToInt64() | c2.ToInt64()));
}
public override Constant GetRegister(RegisterStorage r)
{
if (!regs.TryGetValue(r, out Constant c))
{
c = InvalidConstant.Create(r.DataType);
}
return(c);
}
public override Constant GetRegister(RegisterStorage reg)
{
if (regs.TryGetValue(reg, out Constant value))
{
return value;
}
else
return InvalidConstant.Create(reg.DataType);
}
public CallInstruction Call(string procedureName, int retSizeOnStack)
{
var tmp = InvalidConstant.Create(PrimitiveType.Word32);
var ci = new CallInstruction(tmp, new CallSite(retSizeOnStack, 0));
unresolvedProcedures.Add(new ProcedureConstantUpdater(procedureName, ci));
Emit(ci);
return(ci);
}
public override Constant ApplyConstants(Constant c1, Constant c2)
{
if (!ValidArgs(c1, c2))
{
return(InvalidConstant.Create(c1.DataType));
}
return(Constant.Create(
PrimitiveType.Create(Domain.SignedInt, c1.DataType.BitSize),
c1.ToInt64() >> c2.ToInt32()));
}
public Expression VisitMemoryAccess(MemoryAccess access)
{
var ea = access.EffectiveAddress.Accept(this);
if (ea is InvalidConstant)
{
return(InvalidConstant.Create(access.DataType));
}
return(new MemoryAccess(access.MemoryId, ea, access.DataType));
}
private void DefineUninitializedIdentifier(
Statement stm,
SsaIdentifier sid)
{
var value = InvalidConstant.Create(sid.Identifier.DataType);
var ass = new Assignment(sid.Identifier, value);
var newStm = InsertStatementAfter(ass, stm);
sid.DefExpression = value;
sid.DefStatement = newStm;
}
public override Constant GetRegister(RegisterStorage reg)
{
if (arch.Registers.IsGpRegister(reg) && valid[reg.Number])
{
return(Constant.Create(reg.DataType, regs[reg.Number]));
}
else
{
return(InvalidConstant.Create(reg.DataType));
}
}
public void BwiX86_SubWithSelf()
{
BuildTest32(m =>
{
m.Sub(m.eax, m.eax);
scanner.Setup(x => x.FindContainingBlock(It.Is <Address>(addr => addr.Offset == 0x00010000))).Returns(block);
});
state.SetRegister(Registers.eax, InvalidConstant.Create(PrimitiveType.Word32));
wi.Process();
Assert.AreEqual(0, state.GetRegister(Registers.eax).ToInt32());
}
public override Constant ApplyConstants(Constant c1, Constant c2)
{
if (!ValidArgs(c1, c2))
{
return(InvalidConstant.Create(c1.DataType));
}
ulong v1 = c1.ToUInt64();
ulong v2 = c2.ToUInt64();
return(Constant.Bool(v1 <= v2));
}
public override Constant GetRegister(RegisterStorage r)
{
if (valid[r.Number])
{
return(Constant.Byte(regs[r.Number]));
}
else
{
return(InvalidConstant.Create(r.DataType));
}
}
public override Constant GetRegister(RegisterStorage r)
{
if (regData.TryGetValue(r.Number, out ulong uVal))
{
return(Constant.Create(r.DataType, uVal));
}
else
{
return(InvalidConstant.Create(r.DataType));
}
}
public override Constant GetRegister(RegisterStorage reg)
{
if (isValid[(int)reg.Domain])
{
return(Constant.Create(reg.DataType, registerFile[(int)reg.Domain]));
}
else
{
return(InvalidConstant.Create(reg.DataType));
}
}
public override Constant GetRegister(RegisterStorage r)
{
if (!values.TryGetValue(r, out var value))
{
return(InvalidConstant.Create(r.DataType));
}
else
{
return(value);
}
}
public Expression VisitArrayAccess(ArrayAccess acc)
{
var arr = acc.Array.Accept(this);
var idx = acc.Index.Accept(this);
if (arr is InvalidConstant || idx is InvalidConstant)
{
return(InvalidConstant.Create(acc.DataType));
}
return(new ArrayAccess(acc.DataType, arr, idx));
}
public override Constant GetRegister(RegisterStorage reg)
{
if (IsValid(reg))
{
var val = (regs[reg.Number] & reg.BitMask) >> (int)reg.BitAddress;
return(Constant.Create(reg.DataType, val));
}
else
{
return(InvalidConstant.Create(reg.DataType));
}
}
public override Constant ApplyConstants(Constant c1, Constant c2)
{
if (!ValidArgs(c1, c2))
{
return(InvalidConstant.Create(c2.DataType));
}
if (c2.IsIntegerZero)
{
return(InvalidConstant.Create(c1.DataType));
}
return(BuildConstant(c1.DataType, c2.DataType, c1.ToInt32() % c2.ToInt32()));
}
public void Identifier_GetValue()
{
var id = m.Register("r3");
var invalid = InvalidConstant.Create(id.DataType);
ctx.Setup(c => c.GetValue(id)).Returns(invalid);
var subst = new Substitutor(ctx.Object);
var cInvalid = id.Accept(subst);
Assert.AreSame(invalid, cInvalid);
}
public void ConditionOf_Invalid()
{
var id = m.Register("r3");
var e = m.Cond(id);
ctx.Setup(c => c.GetValue(id)).Returns(InvalidConstant.Create(id.DataType));
var subst = new Substitutor(ctx.Object);
var e2 = e.Accept(subst);
Assert.IsTrue(e2 is InvalidConstant);
}
