public static ulong?ToUlong(BitVecExpr value, uint nBits, Solver solver, Context ctx)
{
if (value.IsBVNumeral)
{
return(((BitVecNum)value).UInt64);
}
Tv[] results = new Tv[nBits];
using (BitVecNum oNE = ctx.MkBV(1, 1))
{
for (uint bit = 0; bit < nBits; ++bit)
{
using (BoolExpr b = GetBit(value, bit, oNE, ctx))
{
switch (GetTv(b, solver, ctx))
{
case Tv.ONE:
results[bit] = Tv.ONE;
break;
case Tv.ZERO:
results[bit] = Tv.ZERO;
break;
default:
return(null);
}
}
}
}
return(ToUlong(results));
}
private string ToString(Expr expr)
{
try
{
if (expr.IsTrue)
{
return("true");
}
if (expr.IsFalse)
{
return("false");
}
if (expr.IsNumeral)
{
BitVecNum num = expr as BitVecNum;
if (num != null)
{
ulong longValue = (ulong)num.BigInteger;
return("0x" + longValue.ToString("X"));
}
}
}
catch (Exception) { }
return(expr.ToString());
}
public static BoolExpr Create_CF_Sub(BitVecExpr a, BitVecExpr b, uint nBits, Context ctx)
{
BitVecExpr ax = ctx.MkZeroExt(1, a);
BitVecExpr bx = ctx.MkZeroExt(1, b);
BitVecNum ONE = ctx.MkBV(1, 1);
return(ToolsZ3.GetBit(ctx.MkBVSub(ax, bx), nBits, ONE, ctx));
//return ctx.MkNot(ctx.MkBVSubNoUnderflow(a, b, false));
}
public void Run()
{
Dictionary <string, string> cfg = new Dictionary <string, string>()
{
{ "AUTO_CONFIG", "true" }
};
Context ctx = new Context(cfg);
BitVecNum b = ctx.MkBV(0xbadc0de, 32);
Console.WriteLine(b.SExpr());
Console.WriteLine(b);
Console.WriteLine(b.Int64);
}
public static Tv[] GetTvArray(BitVecExpr value, int nBits, Solver solver, Context ctx)
{
Tv[] results = new Tv[nBits];
if (value == null)
{
Console.WriteLine("WARNING: ToolsZ3:GetTv5Array: value is null, assuming UNKNOWN");
return(results);
}
using (BitVecNum bv1_1bit = ctx.MkBV(1, 1))
{
for (uint bit = 0; bit < nBits; ++bit)
{
using (BoolExpr b = GetBit(value, bit, bv1_1bit, ctx))
{
results[bit] = GetTv(b, solver, ctx);
}
}
}
return(results);
}
/// <summary>Returns true if the provided valueExpr and undef yield the same tv5 array as the provided valueTv </summary>
public static bool Equals(BitVecExpr valueExpr, BitVecExpr undef, Tv[] valueTv, int nBits, Solver solver, Solver solver_U, Context ctx)
{
using (BitVecNum bv1_1bit = ctx.MkBV(1, 1))
{
for (uint bit = 0; bit < nBits; ++bit)
{
using (BoolExpr b = GetBit(valueExpr, bit, bv1_1bit, ctx))
using (BoolExpr b_undef = GetBit(undef, bit, bv1_1bit, ctx))
{
// this can be done faster
Tv tv = GetTv(b, b_undef, solver, solver_U, ctx);
if (tv != valueTv[bit])
{
return(false);
}
}
}
}
return(true);
}
/// <summary>
/// Simple bit-vector example.
/// </summary>
/// <remarks>
/// This example disproves that x - 10 <= 0 IFF x <= 10 for (32-bit) machine integers
/// </remarks>
public static void BitvectorExample1()
{
var ctx = new Z3.Context();
using var svc = Z3Api.Own(ctx);
var bv_type = ctx.MkBitVecSort(32);
var x = (BitVecExpr)ctx.MkConst("x", bv_type);
var zero = (BitVecNum)ctx.MkNumeral("0", bv_type);
BitVecNum ten = ctx.MkBV(10, 32);
BitVecExpr x_minus_ten = ctx.MkBVSub(x, ten);
/* bvsle is signed less than or equal to */
BoolExpr c1 = ctx.MkBVSLE(x, ten);
BoolExpr c2 = ctx.MkBVSLE(x_minus_ten, zero);
BoolExpr thm = ctx.MkIff(c1, c2);
print("disprove: x - 10 <= 0 IFF x <= 10 for (32-bit) machine integers");
Disprove(ctx, thm);
}
private static (bool valid, ulong value) IsSimpleAssignment_UNUSED(string name, BoolExpr e)
{
if (e.IsEq)
{
if (e.Args[0].IsConst)
{
if (e.Args[0].ToString().Equals(name, StringComparison.OrdinalIgnoreCase))
{
//Console.WriteLine("isSimpleAssignment: " + e + "; found name " + name+ "; type second argument ="+ e.Args[1].GetType());
if (e.Args[1].GetType().Equals(typeof(BitVecNum)))
{
//Console.WriteLine("isSimpleAssignment: e=" + e + "; second argument is numeral "+e.Args[1]);
BitVecNum value = e.Args[1] as BitVecNum;
return(valid : true, value : value.UInt64);
}
}
}
}
return(valid : false, value : 0);
}
public static BoolExpr GetBit(BitVecExpr value, uint pos, BitVecNum one, Context ctx)
{
Debug.Assert(one.SortSize == 1);
Debug.Assert(one.Int == 1);
return(ctx.MkEq(GetBit_BV(value, pos, ctx), one));
}
public static BitVecExpr Calc_Effective_Address(Operand op, string key, Context ctx)
{
Contract.Requires(op != null);
Contract.Requires(ctx != null);
uint nBitsOperand = (uint)op.NBits;
uint nBitsAddress = 64;
if (op.IsReg)
{
return(Create_Key(op.Rn, key, ctx));
}
else if (op.IsMem)
{
//Console.WriteLine("INFO: MemZ3:Calc_Effective_Address: operand=" + op);
(Rn baseReg, Rn indexReg, int scale, long displacement1) = op.Mem;
//Console.WriteLine(string.Format(AsmDudeToolsStatic.CultureUI, "INFO: Calc_Effective_Address: base={0}; index={1}; scale={2}; disp={3}", t.Item1, t.Item2, t.Item3, t.Item4));
BitVecExpr address = null;
//Offset = Base + (Index * Scale) + Displacement
//1] set the address to the value of the displacement
if (displacement1 != 0)
{
BitVecNum displacement = ctx.MkBV(displacement1, nBitsAddress);
address = displacement;
//Console.WriteLine(string.Format(AsmDudeToolsStatic.CultureUI, "INFO: MemZ3:Calc_Effective_Address: A: address={0}", address));
}
//2] add value of the base register
if (baseReg != Rn.NOREG)
{
BitVecExpr baseRegister;
BitVecExpr keyBitVector = Create_Key(baseReg, key, ctx);
switch (RegisterTools.NBits(baseReg))
{
case 64: baseRegister = keyBitVector; break;
case 32: baseRegister = ctx.MkZeroExt(32, keyBitVector); break;
case 16: baseRegister = ctx.MkZeroExt(48, keyBitVector); break;
default: throw new Exception();
}
//Console.WriteLine("baseRegister.NBits = " + baseRegister.SortSize + "; address.NBits = " + address.SortSize);
address = (address == null) ? baseRegister : ctx.MkBVAdd(address, baseRegister);
//Console.WriteLine(string.Format(AsmDudeToolsStatic.CultureUI, "INFO: MemZ3:Calc_Effective_Address: B: address={0}", address));
}
//3] add the value of (Index * Scale)
if (indexReg != Rn.NOREG)
{
if (scale > 0)
{
BitVecExpr indexRegister = Create_Key(indexReg, key, ctx);
switch (scale)
{
case 0:
indexRegister = null;
break;
case 1:
break;
case 2:
indexRegister = ctx.MkBVSHL(indexRegister, ctx.MkBV(1, nBitsAddress));
break;
case 4:
indexRegister = ctx.MkBVSHL(indexRegister, ctx.MkBV(2, nBitsAddress));
break;
case 8:
indexRegister = ctx.MkBVSHL(indexRegister, ctx.MkBV(3, nBitsAddress));
break;
default:
throw new Exception();
}
if (address == null)
{
address = indexRegister;
}
else if (indexRegister != null)
{
address = ctx.MkBVAdd(address, indexRegister);
//Console.WriteLine(string.Format(AsmDudeToolsStatic.CultureUI, "INFO: MemZ3:Calc_Effective_Address: C: address={0}", address));
}
}
}
if (address == null)
{ // then the operand was "qword ptr [0]"
return(ctx.MkBV(0, nBitsAddress));
}
return(address);
}
else
{
throw new Exception();
}
}
public static (BitVecExpr result, BoolExpr cf) ShiftOperations(
Mnemonic op,
BitVecExpr value,
BitVecExpr nShifts,
Context ctx,
Random rand)
{
Debug.Assert(nShifts.SortSize == 8);
BitVecExpr value_out;
BitVecNum one = ctx.MkBV(1, 8);
BitVecExpr nBitsBV = ctx.MkBV(value.SortSize, 8);
BitVecExpr bitPos;
BitVecExpr nShifts64 = ctx.MkZeroExt(value.SortSize - 8, nShifts);
switch (op)
{
case Mnemonic.SHR:
{
bitPos = ctx.MkBVSub(nShifts, one);
value_out = ctx.MkBVLSHR(value, nShifts64);
}
break;
case Mnemonic.SAR:
{
bitPos = ctx.MkBVSub(nShifts, one);
value_out = ctx.MkBVASHR(value, nShifts64);
}
break;
case Mnemonic.ROR:
{
bitPos = ctx.MkBVSub(nShifts, one);
value_out = ctx.MkBVRotateRight(value, nShifts64);
}
break;
case Mnemonic.SHL: // SHL and SAL are equal in functionality
case Mnemonic.SAL:
{
bitPos = ctx.MkBVSub(nBitsBV, nShifts);
//Console.WriteLine("BitOperations:SHL: bitPos=" + bitPos.Simplify());
value_out = ctx.MkBVSHL(value, nShifts64);
}
break;
case Mnemonic.ROL:
{
bitPos = ctx.MkBVSub(nBitsBV, nShifts);
value_out = ctx.MkBVRotateLeft(value, nShifts64);
}
break;
default: throw new Exception();
}
bitPos = ctx.MkZeroExt(value.SortSize - 8, bitPos);
BoolExpr bitValue = ToolsZ3.GetBit(value, bitPos, ctx);
BoolExpr CF_undef = Tools.Create_Flag_Key_Fresh(Flags.CF, rand, ctx);
BoolExpr cf = ctx.MkITE(ctx.MkEq(nShifts, ctx.MkBV(0, 8)), CF_undef, bitValue) as BoolExpr;
return(result : value_out, cf : cf);
}
