mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-08-04 02:10:23 +00:00
Code Activity

fix #7572 and fix #7574

Browse source 
Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>
This commit is contained in:
Nikolaj Bjorner 2025-03-07 10:46:29 -08:00
parent 8df45b442b
commit 80f00f191a
26 changed files with 213 additions and 152 deletions
Download patch file Download diff file Expand all files Collapse all files

82
src/ast/bv_decl_plugin.cpp
View file

@ -143,7 +143,8 @@ void bv_decl_plugin::finalize() {
DEC_REF(m_ext_rotate_right);
DEC_REF(m_int2bv);
DEC_REF(m_bv2int);
DEC_REF(m_ubv2int);
DEC_REF(m_sbv2int);
for (auto& ds : m_bit2bool)
DEC_REF(ds);
DEC_REF(m_mkbv);
@ -228,13 +229,13 @@ func_decl * bv_decl_plugin::mk_int2bv(unsigned bv_size, unsigned num_parameters,
force_ptr_array_size(m_int2bv, bv_size + 1);
if (arity != 1) {
m_manager->raise_exception("expecting one argument to int2bv");
m_manager->raise_exception("expecting one argument to int_to_bv");
return nullptr;
}
if (m_int2bv[bv_size] == 0) {
sort * s = get_bv_sort(bv_size);
m_int2bv[bv_size] = m_manager->mk_func_decl(symbol("int2bv"), domain[0], s,
m_int2bv[bv_size] = m_manager->mk_func_decl(symbol("int_to_bv"), domain[0], s,
func_decl_info(m_family_id, OP_INT2BV, num_parameters, parameters));
m_manager->inc_ref(m_int2bv[bv_size]);
}
@ -242,22 +243,40 @@ func_decl * bv_decl_plugin::mk_int2bv(unsigned bv_size, unsigned num_parameters,
return m_int2bv[bv_size];
}
func_decl * bv_decl_plugin::mk_bv2int(unsigned bv_size, unsigned num_parameters, parameter const * parameters,
func_decl * bv_decl_plugin::mk_ubv2int(unsigned bv_size, unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain) {
force_ptr_array_size(m_bv2int, bv_size + 1);
force_ptr_array_size(m_ubv2int, bv_size + 1);
if (arity != 1) {
m_manager->raise_exception("expecting one argument to bv2int");
m_manager->raise_exception("expecting one argument to ubv_to_int");
return nullptr;
}
if (m_bv2int[bv_size] == 0) {
m_bv2int[bv_size] = m_manager->mk_func_decl(symbol("bv2int"), domain[0], m_int_sort,
func_decl_info(m_family_id, OP_BV2INT));
m_manager->inc_ref(m_bv2int[bv_size]);
if (m_ubv2int[bv_size] == 0) {
m_ubv2int[bv_size] = m_manager->mk_func_decl(symbol("ubv_to_int"), domain[0], m_int_sort,
func_decl_info(m_family_id, OP_UBV2INT));
m_manager->inc_ref(m_ubv2int[bv_size]);
}
return m_bv2int[bv_size];
return m_ubv2int[bv_size];
}
func_decl * bv_decl_plugin::mk_sbv2int(unsigned bv_size, unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain) {
force_ptr_array_size(m_sbv2int, bv_size + 1);
if (arity != 1) {
m_manager->raise_exception("expecting one argument to sbv_to_int");
return nullptr;
}
if (m_sbv2int[bv_size] == 0) {
m_sbv2int[bv_size] = m_manager->mk_func_decl(symbol("sbv_to_int"), domain[0], m_int_sort,
func_decl_info(m_family_id, OP_SBV2INT));
m_manager->inc_ref(m_sbv2int[bv_size]);
}
return m_sbv2int[bv_size];
}
func_decl * bv_decl_plugin::mk_unary_pred(ptr_vector<func_decl> & decls, decl_kind k, char const * name, unsigned bv_size) {
@ -552,8 +571,10 @@ func_decl * bv_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters, p
return mk_bit2bool(bv_size, num_parameters, parameters, arity, domain);
case OP_INT2BV:
return mk_int2bv(bv_size, num_parameters, parameters, arity, domain);
case OP_BV2INT:
return mk_bv2int(bv_size, num_parameters, parameters, arity, domain);
case OP_UBV2INT:
return mk_ubv2int(bv_size, num_parameters, parameters, arity, domain);
case OP_SBV2INT:
return mk_sbv2int(bv_size, num_parameters, parameters, arity, domain);
case OP_CONCAT:
if (!get_concat_size(arity, domain, r_size))
m_manager->raise_exception("invalid concat application");
@ -780,8 +801,11 @@ void bv_decl_plugin::get_op_names(svector<builtin_name> & op_names, symbol const
op_names.push_back(builtin_name("ext_rotate_left",OP_EXT_ROTATE_LEFT));
op_names.push_back(builtin_name("ext_rotate_right",OP_EXT_ROTATE_RIGHT));
op_names.push_back(builtin_name("int2bv",OP_INT2BV));
op_names.push_back(builtin_name("bv2int",OP_BV2INT));
op_names.push_back(builtin_name("bv2nat",OP_BV2INT));
op_names.push_back(builtin_name("int_to_bv",OP_INT2BV));
op_names.push_back(builtin_name("bv2int",OP_UBV2INT));
op_names.push_back(builtin_name("bv2nat",OP_UBV2INT));
op_names.push_back(builtin_name("ubv_to_int",OP_UBV2INT));
op_names.push_back(builtin_name("sbv_to_int",OP_SBV2INT));
op_names.push_back(builtin_name("mkbv",OP_MKBV));
}
}
@ -878,10 +902,8 @@ bool bv_recognizers::is_repeat(expr const * e, expr*& arg, unsigned& n) const {
}
bool bv_recognizers::is_bv2int(expr const* e, expr*& r) const {
if (!is_bv2int(e)) return false;
r = to_app(e)->get_arg(0);
return true;
bool bv_recognizers::is_ubv2int(expr const* e, expr*& r) const {
return is_ubv2int(e) && (r = to_app(e)->get_arg(0), true);
}
bool bv_recognizers::is_bit2bool(expr* e, expr*& bv, unsigned& idx) const {
@ -934,10 +956,28 @@ unsigned bv_util::get_int2bv_size(parameter const& p) {
return static_cast<unsigned>(sz);
}
app * bv_util::mk_bv2int(expr* e) const {
app * bv_util::mk_ubv2int(expr* e) const {
sort* s = m_manager.mk_sort(m_manager.mk_family_id("arith"), INT_SORT);
parameter p(s);
return m_manager.mk_app(get_fid(), OP_BV2INT, 1, &p, 1, &e);
return m_manager.mk_app(get_fid(), OP_UBV2INT, 1, &p, 1, &e);
}
app * bv_util::mk_sbv2int(expr* e) const {
sort* s = m_manager.mk_sort(m_manager.mk_family_id("arith"), INT_SORT);
parameter p(s);
return m_manager.mk_app(get_fid(), OP_SBV2INT, 1, &p, 1, &e);
}
app* bv_util::mk_sbv2int_as_ubv2int(expr* e) {
// if e <_s 0 then ubv2int(e) - 2^n else ubv2int(e)
app* r = mk_ubv2int(e);
arith_util autil(m_manager);
unsigned sz = get_bv_size(e);
expr_ref zero(mk_numeral(rational::zero(), sz), m_manager);
r = m_manager.mk_ite(mk_slt(e, zero),
autil.mk_sub(r, autil.mk_numeral(rational::power_of_two(sz), true)),
r);
return r;
}
app* bv_util::mk_int2bv(unsigned sz, expr* e) const {

20
src/ast/bv_decl_plugin.h
View file

@ -109,7 +109,8 @@ enum bv_op_kind {
OP_BIT2BOOL, // predicate
OP_MKBV, // bools to bv
OP_INT2BV,
OP_BV2INT,
OP_UBV2INT,
OP_SBV2INT,
OP_CARRY,
OP_XOR3,
@ -225,7 +226,8 @@ protected:
ptr_vector<func_decl> m_ext_rotate_left;
ptr_vector<func_decl> m_ext_rotate_right;
ptr_vector<func_decl> m_bv2int;
ptr_vector<func_decl> m_ubv2int;
ptr_vector<func_decl> m_sbv2int;
ptr_vector<func_decl> m_int2bv;
vector<ptr_vector<func_decl> > m_bit2bool;
ptr_vector<func_decl> m_mkbv;
@ -250,7 +252,9 @@ protected:
bool get_extract_size(unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain, int & result);
func_decl * mk_bv2int(unsigned bv_size, unsigned num_parameters, parameter const * parameters,
func_decl * mk_ubv2int(unsigned bv_size, unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain);
func_decl * mk_sbv2int(unsigned bv_size, unsigned num_parameters, parameter const * parameters,
unsigned arity, sort * const * domain);
func_decl * mk_int2bv(unsigned bv_size, unsigned num_parameters, parameter const * parameters,
@ -337,7 +341,8 @@ public:
unsigned get_extract_low(expr const * n) const { SASSERT(is_extract(n)); return get_extract_low(to_app(n)->get_decl()); }
bool is_extract(expr const * e, unsigned & low, unsigned & high, expr * & b) const;
bool is_repeat(expr const * e, expr*& arg, unsigned& n) const;
bool is_bv2int(expr const * e, expr * & r) const;
bool is_ubv2int(expr const * e, expr * & r) const;
bool is_sbv2int(expr const * e, expr * & r) const;
bool is_bv_add(expr const * e) const { return is_app_of(e, get_fid(), OP_BADD); }
bool is_bv_sub(expr const * e) const { return is_app_of(e, get_fid(), OP_BSUB); }
bool is_bv_mul(expr const * e) const { return is_app_of(e, get_fid(), OP_BMUL); }
@ -378,7 +383,8 @@ public:
bool is_uge(expr const * e) const { return is_app_of(e, get_fid(), OP_UGEQ); }
bool is_sge(expr const * e) const { return is_app_of(e, get_fid(), OP_SGEQ); }
bool is_bit2bool(expr const * e) const { return is_app_of(e, get_fid(), OP_BIT2BOOL); }
bool is_bv2int(expr const* e) const { return is_app_of(e, get_fid(), OP_BV2INT); }
bool is_ubv2int(expr const* e) const { return is_app_of(e, get_fid(), OP_UBV2INT); }
bool is_sbv2int(expr const* e) const { return is_app_of(e, get_fid(), OP_SBV2INT); }
bool is_int2bv(expr const* e) const { return is_app_of(e, get_fid(), OP_INT2BV); }
bool is_mkbv(expr const * e) const { return is_app_of(e, get_fid(), OP_MKBV); }
bool is_bv_ashr(expr const * e) const { return is_app_of(e, get_fid(), OP_BASHR); }
@ -549,7 +555,9 @@ public:
app * mk_bv_ashr(expr* arg1, expr* arg2) { return m_manager.mk_app(get_fid(), OP_BASHR, arg1, arg2); }
app * mk_bv_lshr(expr* arg1, expr* arg2) { return m_manager.mk_app(get_fid(), OP_BLSHR, arg1, arg2); }
app * mk_bv2int(expr* e) const;
app * mk_ubv2int(expr* e) const;
app * mk_sbv2int(expr* e) const;
app * mk_sbv2int_as_ubv2int(expr* e);
app * mk_int2bv(unsigned sz, expr* e) const;
app* mk_bv_rotate_left(expr* arg1, expr* arg2) { return m_manager.mk_app(get_fid(), OP_EXT_ROTATE_LEFT, arg1, arg2); }

24
src/ast/rewriter/bit2int.cpp
View file

@ -46,7 +46,7 @@ void bit2int::operator()(expr * n, expr_ref & result, proof_ref& p) {
unsigned bit2int::get_b2i_size(expr* n) {
expr* arg = nullptr;
VERIFY(m_bv_util.is_bv2int(n, arg));
VERIFY(m_bv_util.is_ubv2int(n, arg));
return m_bv_util.get_bv_size(arg);
}
@ -83,7 +83,7 @@ bool bit2int::extract_bv(expr* n, unsigned& sz, bool& sign, expr_ref& bv) {
numeral k;
bool is_int;
expr* r = nullptr;
if (m_bv_util.is_bv2int(n, r)) {
if (m_bv_util.is_ubv2int(n, r)) {
bv = r;
sz = m_bv_util.get_bv_size(bv);
sign = false;
@ -123,7 +123,7 @@ bool bit2int::mk_add(expr* e1, expr* e2, expr_ref& result) {
tmp2 = m_rewriter.mk_zero_extend(1, tmp2);
SASSERT(m_bv_util.get_bv_size(tmp1) == m_bv_util.get_bv_size(tmp2));
tmp3 = m_rewriter.mk_bv_add(tmp1, tmp2);
result = m_rewriter.mk_bv2int(tmp3);
result = m_rewriter.mk_ubv2int(tmp3);
return true;
}
return false;
@ -168,7 +168,7 @@ bool bit2int::mk_mul(expr* e1, expr* e2, expr_ref& result) {
SASSERT(m_bv_util.get_bv_size(tmp1) == m_bv_util.get_bv_size(tmp2));
tmp3 = m_rewriter.mk_bv_mul(tmp1, tmp2);
result = m_rewriter.mk_bv2int(tmp3);
result = m_rewriter.mk_ubv2int(tmp3);
if (sign1 != sign2) {
result = m_arith_util.mk_uminus(result);
}
@ -183,13 +183,13 @@ bool bit2int::is_bv_poly(expr* n, expr_ref& pos, expr_ref& neg) {
numeral k;
bool is_int;
todo.push_back(n);
neg = pos = m_rewriter.mk_bv2int(m_bit0);
neg = pos = m_rewriter.mk_ubv2int(m_bit0);
while (!todo.empty()) {
n = todo.back();
todo.pop_back();
expr* arg1 = nullptr, *arg2 = nullptr;
if (m_bv_util.is_bv2int(n)) {
if (m_bv_util.is_ubv2int(n)) {
VERIFY(mk_add(n, pos, pos));
}
else if (m_arith_util.is_numeral(n, k, is_int) && is_int) {
@ -208,16 +208,16 @@ bool bit2int::is_bv_poly(expr* n, expr_ref& pos, expr_ref& neg) {
}
else if (m_arith_util.is_mul(n, arg1, arg2) &&
m_arith_util.is_numeral(arg1, k, is_int) && is_int && k.is_minus_one() &&
m_bv_util.is_bv2int(arg2)) {
m_bv_util.is_ubv2int(arg2)) {
VERIFY(mk_add(arg2, neg, neg));
}
else if (m_arith_util.is_mul(n, arg1, arg2) &&
m_arith_util.is_numeral(arg2, k, is_int) && is_int && k.is_minus_one() &&
m_bv_util.is_bv2int(arg1)) {
m_bv_util.is_ubv2int(arg1)) {
VERIFY(mk_add(arg1, neg, neg));
}
else if (m_arith_util.is_uminus(n, arg1) &&
m_bv_util.is_bv2int(arg1)) {
m_bv_util.is_ubv2int(arg1)) {
VERIFY(mk_add(arg1, neg, neg));
}
else {
@ -251,7 +251,7 @@ void bit2int::visit(app* n) {
m_arith_util.is_lt(n) || m.is_eq(n);
expr_ref result(m);
for (unsigned i = 0; !has_b2i && i < num_args; ++i) {
has_b2i = m_bv_util.is_bv2int(args[i]);
has_b2i = m_bv_util.is_ubv2int(args[i]);
}
if (!has_b2i) {
result = m.mk_app(f, num_args, args);
@ -367,7 +367,7 @@ void bit2int::visit(app* n) {
tmp2 = e2bv;
align_sizes(tmp1, tmp2);
tmp3 = m_rewriter.mk_bv_urem(tmp1, tmp2);
result = m_rewriter.mk_bv2int(tmp3);
result = m_rewriter.mk_ubv2int(tmp3);
cache_result(n, result);
return;
}
@ -393,7 +393,7 @@ void bit2int::visit(app* n) {
tmp2 = e2bv;
align_sizes(tmp1, tmp2);
tmp3 = m_rewriter.mk_bv_urem(tmp1, tmp2);
result = m_rewriter.mk_bv2int(tmp3);
result = m_rewriter.mk_ubv2int(tmp3);
cache_result(n, result);
}

3
src/ast/rewriter/bit_blaster/bit_blaster_rewriter.cpp
View file

@ -548,7 +548,8 @@ MK_PARAMETRIC_UNARY_REDUCE(reduce_sign_extend, mk_sign_extend);
case OP_BIT2BOOL:
case OP_MKBV:
case OP_INT2BV:
case OP_BV2INT:
case OP_UBV2INT:
case OP_SBV2INT:
return BR_FAILED;
default:
TRACE("bit_blaster", tout << "non-supported operator: " << f->get_name() << "\n";

4
src/ast/rewriter/bv2int_translator.cpp
View file

@ -164,7 +164,7 @@ void bv2int_translator::translate_app(app* e) {
expr* r = m.mk_app(f, m_args);
if (has_bv_sort) {
ctx.push(push_back_vector(m_vars));
r = bv.mk_bv2int(r);
r = bv.mk_ubv2int(r);
}
set_translated(e, r);
return;
@ -424,7 +424,7 @@ void bv2int_translator::translate_bv(app* e) {
ctx.push(push_back_vector(m_int2bv));
r = arg(0);
break;
case OP_BV2INT:
case OP_UBV2INT:
m_bv2int.push_back(e);
ctx.push(push_back_vector(m_bv2int));
r = umod(e->get_arg(0), 0);

39
src/ast/rewriter/bv_rewriter.cpp
View file

@ -197,9 +197,12 @@ br_status bv_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * cons
case OP_EXT_ROTATE_RIGHT:
SASSERT(num_args == 2);
return mk_bv_ext_rotate_right(args[0], args[1], result);
case OP_BV2INT:
case OP_UBV2INT:
SASSERT(num_args == 1);
return mk_bv2int(args[0], result);
return mk_ubv2int(args[0], result);
case OP_SBV2INT:
SASSERT(num_args == 1);
return mk_sbv2int(args[0], result);
case OP_INT2BV:
SASSERT(num_args == 1);
return mk_int2bv(m_util.get_bv_size(f->get_range()), args[0], result);
@ -1480,20 +1483,20 @@ br_status bv_rewriter::mk_int2bv(unsigned bv_size, expr * arg, expr_ref & result
return BR_DONE;
}
// int2bv (bv2int x) --> x
if (m_util.is_bv2int(arg, x) && bv_size == get_bv_size(x)) {
// int2bv (ubv2int x) --> x
if (m_util.is_ubv2int(arg, x) && bv_size == get_bv_size(x)) {
result = x;
return BR_DONE;
}
// int2bv (bv2int x) --> 0000x
if (m_util.is_bv2int(arg, x) && bv_size > get_bv_size(x)) {
// int2bv (ubv2int x) --> 0000x
if (m_util.is_ubv2int(arg, x) && bv_size > get_bv_size(x)) {
mk_zero_extend(bv_size - get_bv_size(x), x, result);
return BR_REWRITE1;
}
// int2bv (bv2int x) --> x[sz-1:0]
if (m_util.is_bv2int(arg, x) && bv_size < get_bv_size(x)) {
// int2bv (ubv2int x) --> x[sz-1:0]
if (m_util.is_ubv2int(arg, x) && bv_size < get_bv_size(x)) {
result = m_mk_extract(bv_size - 1, 0, x);
return BR_REWRITE1;
}
@ -1520,7 +1523,13 @@ br_status bv_rewriter::mk_int2bv(unsigned bv_size, expr * arg, expr_ref & result
return BR_FAILED;
}
br_status bv_rewriter::mk_bv2int(expr * arg, expr_ref & result) {
br_status bv_rewriter::mk_sbv2int(expr* arg, expr_ref& result) {
result = m_util.mk_sbv2int_as_ubv2int(arg);
return BR_REWRITE2;
}
br_status bv_rewriter::mk_ubv2int(expr * arg, expr_ref & result) {
numeral v;
unsigned sz;
if (is_numeral(arg, v, sz)) {
@ -1536,7 +1545,7 @@ br_status bv_rewriter::mk_bv2int(expr * arg, expr_ref & result) {
unsigned num_args = to_app(arg)->get_num_args();
for (expr* x : *to_app(arg)) {
args.push_back(m_util.mk_bv2int(x));
args.push_back(m_util.mk_ubv2int(x));
}
unsigned sz = get_bv_size(to_app(arg)->get_arg(num_args-1));
for (unsigned i = num_args - 1; i > 0; ) {
@ -1552,13 +1561,13 @@ br_status bv_rewriter::mk_bv2int(expr * arg, expr_ref & result) {
}
if (is_mul_no_overflow(arg)) {
expr_ref_vector args(m);
for (expr* x : *to_app(arg)) args.push_back(m_util.mk_bv2int(x));
for (expr* x : *to_app(arg)) args.push_back(m_util.mk_ubv2int(x));
result = m_autil.mk_mul(args.size(), args.data());
return BR_REWRITE2;
}
if (is_add_no_overflow(arg)) {
expr_ref_vector args(m);
for (expr* x : *to_app(arg)) args.push_back(m_util.mk_bv2int(x));
for (expr* x : *to_app(arg)) args.push_back(m_util.mk_ubv2int(x));
result = m_autil.mk_add(args.size(), args.data());
return BR_REWRITE2;
}
@ -2805,7 +2814,7 @@ br_status bv_rewriter::mk_eq_bv2int(expr* lhs, expr* rhs, expr_ref& result) {
if (m_autil.is_numeral(lhs))
std::swap(lhs, rhs);
if (m_autil.is_numeral(rhs, r) && m_util.is_bv2int(lhs, x)) {
if (m_autil.is_numeral(rhs, r) && m_util.is_ubv2int(lhs, x)) {
unsigned bv_size = m_util.get_bv_size(x);
if (0 <= r && r < rational::power_of_two(bv_size))
result = m.mk_eq(m_util.mk_numeral(r, bv_size), x);
@ -2813,8 +2822,8 @@ br_status bv_rewriter::mk_eq_bv2int(expr* lhs, expr* rhs, expr_ref& result) {
result = m.mk_false();
return BR_REWRITE1;
}
if (m_util.is_bv2int(lhs, x) &&
m_util.is_bv2int(rhs, y)) {
if (m_util.is_ubv2int(lhs, x) &&
m_util.is_ubv2int(rhs, y)) {
auto szx = m_util.get_bv_size(x);
auto szy = m_util.get_bv_size(y);
if (szx < szy)

9
src/ast/rewriter/bv_rewriter.h
View file

@ -128,7 +128,8 @@ class bv_rewriter : public poly_rewriter<bv_rewriter_core> {
br_status mk_bv_urem_i(expr * arg1, expr * arg2, expr_ref & result) { return mk_bv_urem_core(arg1, arg2, true, result); }
br_status mk_bv_smod_i(expr * arg1, expr * arg2, expr_ref & result) { return mk_bv_smod_core(arg1, arg2, true, result); }
br_status mk_int2bv(unsigned bv_size, expr * arg, expr_ref & result);
br_status mk_bv2int(expr * arg, expr_ref & result);
br_status mk_ubv2int(expr * arg, expr_ref & result);
br_status mk_sbv2int(expr* arg, expr_ref& result);
br_status mk_bv_redor(expr * arg, expr_ref & result);
br_status mk_bv_redand(expr * arg, expr_ref & result);
br_status mk_bv_comp(expr * arg1, expr * arg2, expr_ref & result);
@ -244,10 +245,10 @@ public:
MK_BV_BINARY(mk_bv_sub);
expr_ref mk_bv2int(expr* a) {
expr_ref mk_ubv2int(expr* a) {
expr_ref result(m);
if (BR_FAILED == mk_bv2int(a, result))
result = m_util.mk_bv2int(a);
if (BR_FAILED == mk_ubv2int(a, result))
result = m_util.mk_ubv2int(a);
return result;
}

2
src/ast/rewriter/seq_rewriter.cpp
View file

@ -2639,7 +2639,7 @@ br_status seq_rewriter::mk_str_stoi(expr* a, expr_ref& result) {
}
if (str().is_ubv2s(a, b)) {
bv_util bv(m());
result = bv.mk_bv2int(b);
result = bv.mk_ubv2int(b);
return BR_DONE;
}

2
src/ast/rewriter/th_rewriter.cpp
View file

@ -693,7 +693,7 @@ struct th_rewriter_cfg : public default_rewriter_cfg {
}
br_status extended_bv_eq(expr* a, expr* b, expr_ref& result) {
if (m_bv_util.is_bv2int(a) || m_bv_util.is_bv2int(b))
if (m_bv_util.is_ubv2int(a) || m_bv_util.is_ubv2int(b))
return m_bv_rw.mk_eq_bv2int(a, b, result);
return BR_FAILED;
}

6
src/ast/sls/sls_bv_eval.cpp
View file

@ -693,7 +693,8 @@ namespace sls {
NOT_IMPLEMENTED_YET();
break;
case OP_BIT2BOOL:
case OP_BV2INT:
case OP_UBV2INT:
case OP_SBV2INT:
case OP_BNEG_OVFL:
case OP_BSADD_OVFL:
case OP_BUADD_OVFL:
@ -824,7 +825,8 @@ namespace sls {
return false;
case OP_BIT1:
return false;
case OP_BV2INT:
case OP_UBV2INT:
case OP_SBV2INT:
return false;
case OP_INT2BV:
return try_repair_int2bv(assign_value(e), e->get_arg(0));

3
src/ast/sls/sls_bv_fixed.cpp
View file

@ -514,7 +514,8 @@ namespace sls {
case OP_BV_NUM:
case OP_BIT0:
case OP_BIT1:
case OP_BV2INT:
case OP_UBV2INT:
case OP_SBV2INT:
case OP_BNEG_OVFL:
case OP_BSADD_OVFL:
case OP_BUADD_OVFL: