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

Centralize and document TRACE tags using X-macros (#7657)

Browse source 
* Introduce X-macro-based trace tag definition
- Created trace_tags.def to centralize TRACE tag definitions
- Each tag includes a symbolic name and description
- Set up enum class TraceTag for type-safe usage in TRACE macros

* Add script to generate Markdown documentation from trace_tags.def
- Python script parses trace_tags.def and outputs trace_tags.md

* Refactor TRACE_NEW to prepend TraceTag and pass enum to is_trace_enabled

* trace: improve trace tag handling system with hierarchical tagging

- Introduce hierarchical tag-class structure: enabling a tag class activates all child tags
- Unify TRACE, STRACE, SCTRACE, and CTRACE under enum TraceTag
- Implement initial version of trace_tag.def using X(tag, tag_class, description)
  (class names and descriptions to be refined in a future update)

* trace: replace all string-based TRACE tags with enum TraceTag
- Migrated all TRACE, STRACE, SCTRACE, and CTRACE macros to use enum TraceTag values instead of raw string literals

* trace : add cstring header

* trace : Add Markdown documentation generation from trace_tags.def via mk_api_doc.py

* trace : rename macro parameter 'class' to 'tag_class' and remove Unicode comment in trace_tags.h.

* trace : Add TODO comment for future implementation of tag_class activation

* trace : Disable code related to tag_class until implementation is ready (#7663).
This commit is contained in:
LeeYoungJoon 2025-05-28 22:31:25 +09:00 • committed by GitHub
parent d766292dab
commit 0a93ff515d
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
583 changed files with 8698 additions and 7299 deletions
Download patch file Download diff file Expand all files Collapse all files

14
src/model/array_factory.cpp
View file

@ -61,7 +61,7 @@ void array_factory::get_some_args_for(sort * s, ptr_buffer<expr> & args) {
}
expr * array_factory::get_some_value(sort * s) {
TRACE("array_factory", tout << mk_pp(s, m_manager) << "\n";);
TRACE(array_factory, tout << mk_pp(s, m_manager) << "\n";);
value_set * set = nullptr;
if (m_sort2value_set.find(s, set) && !set->empty())
return *(set->begin());
@ -72,7 +72,7 @@ expr * array_factory::get_some_value(sort * s) {
}
bool array_factory::mk_two_diff_values_for(sort * s) {
TRACE("array_factory", tout << mk_pp(s, m_manager) << "\n";);
TRACE(array_factory, tout << mk_pp(s, m_manager) << "\n";);
DEBUG_CODE({
value_set * set = 0;
SASSERT(!m_sort2value_set.find(s, set) || set->size() <= 1);
@ -101,7 +101,7 @@ bool array_factory::get_some_values(sort * s, expr_ref & v1, expr_ref & v2) {
value_set * set = nullptr;
if (!m_sort2value_set.find(s, set) || set->size() < 2) {
if (!mk_two_diff_values_for(s)) {
TRACE("array_factory_bug", tout << "could not create diff values: " << mk_pp(s, m_manager) << "\n";);
TRACE(array_factory_bug, tout << "could not create diff values: " << mk_pp(s, m_manager) << "\n";);
return false;
}
}
@ -113,7 +113,7 @@ bool array_factory::get_some_values(sort * s, expr_ref & v1, expr_ref & v2) {
v1 = *it;
++it;
v2 = *it;
TRACE("array_factory", tout << v1 << " " << v2 << "\n";);
TRACE(array_factory, tout << v1 << " " << v2 << "\n";);
return true;
}
@ -147,7 +147,7 @@ expr * array_factory::get_fresh_value(sort * s) {
}
}
TRACE("array_factory_bug", tout << "array fresh value: using fresh index, range: " << mk_pp(range, m_manager) << "\n";);
TRACE(array_factory_bug, tout << "array fresh value: using fresh index, range: " << mk_pp(range, m_manager) << "\n";);
expr_ref v1(m_manager), v2(m_manager), w1(m_manager), w2(m_manager);
if (m_model.get_some_values(range, v1, v2)) {
// Claim: A is fresh if A[i1] = v1 and A[i2] = v2 where i1 and i2 are fresh values,
@ -157,7 +157,7 @@ expr * array_factory::get_fresh_value(sort * s) {
// Then A[i1] == A'[i1] and A[i2] == A'[i2]. Since, i1 and i2 are fresh,
// A' does not have an entry for i1 or i2, So A'[i1] == A'[i2] == A'.m_else.
// Thus, A[i1] == A[i2] which is a contradiction since v1 != v2 and A[i1] = v1 and A[i2] = v2.
TRACE("array_factory_bug", tout << "v1: " << mk_pp(v1, m_manager) << " v2: " << mk_pp(v2, m_manager) << "\n";);
TRACE(array_factory_bug, tout << "v1: " << mk_pp(v1, m_manager) << " v2: " << mk_pp(v2, m_manager) << "\n";);
ptr_buffer<expr> args1;
ptr_buffer<expr> args2;
bool found = false;
@ -196,7 +196,7 @@ expr * array_factory::get_fresh_value(sort * s) {
// need to be used.
// failed to create a fresh array value
TRACE("array_factory_bug", tout << "failed to build fresh array value\n";);
TRACE(array_factory_bug, tout << "failed to build fresh array value\n";);
return nullptr;
}

26
src/model/datatype_factory.cpp
View file

@ -39,7 +39,7 @@ expr * datatype_factory::get_some_value(sort * s) {
args.push_back(m_model.get_some_value(c->get_domain(i)));
expr * r = m_manager.mk_app(c, args);
register_value(r);
TRACE("datatype", tout << mk_pp(r, m_util.get_manager()) << "\n";);
TRACE(datatype, tout << mk_pp(r, m_util.get_manager()) << "\n";);
return r;
}
@ -67,7 +67,7 @@ bool datatype_factory::is_subterm_of_last_value(app* e) {
}
contains_app contains(m_manager, e);
bool result = contains(last);
TRACE("datatype", tout << mk_pp(e, m_manager) << " in " << mk_pp(last, m_manager) << " " << result << "\n";);
TRACE(datatype, tout << mk_pp(e, m_manager) << " in " << mk_pp(last, m_manager) << " " << result << "\n";);
return result;
}
@ -127,7 +127,7 @@ expr * datatype_factory::get_almost_fresh_value(sort * s) {
m_last_fresh_value.insert(s, new_value);
}
}
TRACE("datatype", tout << "almost fresh: " << mk_pp(new_value, m_manager) << "\n";);
TRACE(datatype, tout << "almost fresh: " << mk_pp(new_value, m_manager) << "\n";);
return new_value;
}
}
@ -139,7 +139,7 @@ expr * datatype_factory::get_almost_fresh_value(sort * s) {
expr * datatype_factory::get_fresh_value(sort * s) {
if (!m_util.is_datatype(s))
return m_model.get_fresh_value(s);
TRACE("datatype", tout << "generating fresh value for: " << s->get_name() << "\n";);
TRACE(datatype, tout << "generating fresh value for: " << s->get_name() << "\n";);
value_set * set = get_value_set(s);
// Approach 0)
// if no value for s was generated so far, then used get_some_value
@ -147,7 +147,7 @@ expr * datatype_factory::get_fresh_value(sort * s) {
expr * val = get_some_value(s);
if (m_util.is_recursive(s))
m_last_fresh_value.insert(s, val);
TRACE("datatype", tout << "0. result: " << mk_pp(val, m_manager) << "\n";);
TRACE(datatype, tout << "0. result: " << mk_pp(val, m_manager) << "\n";);
return val;
}
// Approach 1)
@ -180,14 +180,14 @@ expr * datatype_factory::get_fresh_value(sort * s) {
}
new_value = m_manager.mk_app(constructor, args);
CTRACE("datatype", found_fresh_arg && set->contains(new_value), tout << "seen: " << new_value << "\n";);
CTRACE(datatype, found_fresh_arg && set->contains(new_value), tout << "seen: " << new_value << "\n";);
if (found_fresh_arg && set->contains(new_value))
goto retry_value;
if (!set->contains(new_value)) {
register_value(new_value);
if (m_util.is_recursive(s))
m_last_fresh_value.insert(s, new_value);
TRACE("datatype", tout << "1. result: " << mk_pp(new_value, m_manager) << "\n";);
TRACE(datatype, tout << "1. result: " << mk_pp(new_value, m_manager) << "\n";);
return new_value;
}
}
@ -198,16 +198,16 @@ expr * datatype_factory::get_fresh_value(sort * s) {
if (m_util.is_recursive(s)) {
while (true) {
++num_iterations;
TRACE("datatype", tout << num_iterations << " " << mk_pp(get_last_fresh_value(s), m_manager) << "\n";);
TRACE(datatype, tout << num_iterations << " " << mk_pp(get_last_fresh_value(s), m_manager) << "\n";);
ptr_vector<func_decl> const & constructors = *m_util.get_datatype_constructors(s);
for (func_decl * constructor : constructors) {
expr_ref_vector args(m_manager);
bool found_sibling = false;
unsigned num = constructor->get_arity();
TRACE("datatype", tout << "checking constructor: " << constructor->get_name() << "\n";);
TRACE(datatype, tout << "checking constructor: " << constructor->get_name() << "\n";);
for (unsigned i = 0; i < num; i++) {
sort * s_arg = constructor->get_domain(i);
TRACE("datatype", tout << mk_pp(s, m_manager) << " "
TRACE(datatype, tout << mk_pp(s, m_manager) << " "
<< mk_pp(s_arg, m_manager) << " are_siblings "
<< m_util.are_siblings(s, s_arg) << " is_datatype "
<< m_util.is_datatype(s_arg) << " found_sibling "
@ -222,7 +222,7 @@ expr * datatype_factory::get_fresh_value(sort * s) {
else
maybe_new_arg = get_fresh_value(s_arg);
if (!maybe_new_arg) {
TRACE("datatype",
TRACE(datatype,
tout << "no argument found for " << mk_pp(s_arg, m_manager) << "\n";);
maybe_new_arg = m_model.get_some_value(s_arg);
found_sibling = false;
@ -239,11 +239,11 @@ expr * datatype_factory::get_fresh_value(sort * s) {
if (found_sibling) {
expr_ref new_value(m_manager);
new_value = m_manager.mk_app(constructor, args);
TRACE("datatype", tout << "potential new value: " << mk_pp(new_value, m_manager) << "\n";);
TRACE(datatype, tout << "potential new value: " << mk_pp(new_value, m_manager) << "\n";);
m_last_fresh_value.insert(s, new_value);
if (!set->contains(new_value)) {
register_value(new_value);
TRACE("datatype", tout << "2. result: " << mk_pp(new_value, m_manager) << "\n";);
TRACE(datatype, tout << "2. result: " << mk_pp(new_value, m_manager) << "\n";);
return new_value;
}
}

4
src/model/func_interp.cpp
View file

@ -142,7 +142,7 @@ void func_interp::set_else(expr * e) {
reset_interp_cache();
TRACE("func_interp", tout << "set_else: " << expr_ref(e, m()) << "\n";);
TRACE(func_interp, tout << "set_else: " << expr_ref(e, m()) << "\n";);
ptr_vector<expr> args;
while (e && is_fi_entry_expr(e, args)) {
@ -196,7 +196,7 @@ void func_interp::insert_entry(expr * const * args, expr * r) {
void func_interp::insert_new_entry(expr * const * args, expr * r) {
reset_interp_cache();
CTRACE("func_interp_bug", get_entry(args) != 0,
CTRACE(func_interp_bug, get_entry(args) != 0,
tout << "Old: " << mk_ismt2_pp(get_entry(args)->m_result, m()) << "\n";
tout << "Args:";
for (unsigned i = 0; i < m_arity; i++) {

12
src/model/model.cpp
View file

@ -95,7 +95,7 @@ bool model::eval_expr(expr * e, expr_ref & result, bool model_completion) {
}
catch (model_evaluator_exception & ex) {
(void)ex;
TRACE("model_evaluator", tout << ex.what() << "\n";);
TRACE(model_evaluator, tout << ex.what() << "\n";);
return false;
}
}
@ -278,7 +278,7 @@ void model::compress(bool force_inline) {
std::swap(m_decls, sorted_decls);
if (removed.empty())
break;
TRACE("model", tout << "remove\n"; for (func_decl* f : removed) tout << f->get_name() << "\n";);
TRACE(model, tout << "remove\n"; for (func_decl* f : removed) tout << f->get_name() << "\n";);
remove_decls(m_func_decls, removed);
remove_decls(m_const_decls, removed);
}
@ -443,7 +443,7 @@ bool model::can_inline_def(top_sort& ts, func_decl* f, bool force_inline) {
expr_ref model::cleanup_expr(top_sort& ts, expr* e, unsigned current_partition, bool force_inline) {
if (!e) return expr_ref(nullptr, m);
TRACE("model", tout << "cleaning up:\n" << mk_pp(e, m) << "\n";);
TRACE(model, tout << "cleaning up:\n" << mk_pp(e, m) << "\n";);
obj_map<expr, expr*> cache;
expr_ref_vector trail(m);
@ -488,7 +488,7 @@ expr_ref model::cleanup_expr(top_sort& ts, expr* e, unsigned current_partition,
fi = get_func_interp(f);
if (fi) {
new_t = fi->get_array_interp(f);
TRACE("model", tout << "array interpretation:" << new_t << "\n";);
TRACE(model, tout << "array interpretation:" << new_t << "\n";);
}
}
}
@ -516,7 +516,7 @@ expr_ref model::cleanup_expr(top_sort& ts, expr* e, unsigned current_partition,
}
if (t != new_t.get()) trail.push_back(new_t);
CTRACE("model", (t != new_t.get()), tout << mk_bounded_pp(t, m) << " " << new_t << "\n";);
CTRACE(model, (t != new_t.get()), tout << mk_bounded_pp(t, m) << " " << new_t << "\n";);
todo.pop_back();
cache.insert(t, new_t);
break;
@ -640,5 +640,5 @@ void model::add_rec_funs() {
fi->set_else(bodyr);
register_decl(f, fi);
}
TRACE("model", tout << *this << "\n";);
TRACE(model, tout << *this << "\n";);
}

4
src/model/model_core.cpp
View file

@ -53,7 +53,7 @@ void model_core::register_decl(func_decl * d, expr * v) {
register_decl(d, fi);
return;
}
TRACE("model", tout << "register " << d->get_name() << "\n";
TRACE(model, tout << "register " << d->get_name() << "\n";
if (v) tout << mk_pp(v, m) << "\n";
);
i_expr v0(0, nullptr);
@ -81,7 +81,7 @@ void model_core::register_decl(func_decl * d, func_interp * fi) {
}
func_interp* model_core::update_func_interp(func_decl* d, func_interp* fi) {
TRACE("model_verbose", tout << "register " << d->get_name() << "\n";);
TRACE(model_verbose, tout << "register " << d->get_name() << "\n";);
SASSERT(d->get_arity() > 0);
SASSERT(&fi->m() == &m);

52
src/model/model_evaluator.cpp
View file

@ -112,7 +112,7 @@ struct evaluator_cfg : public default_rewriter_cfg {
bool evaluate(func_decl * f, unsigned num, expr * const * args, expr_ref & result) {
func_interp * fi = m_model.get_func_interp(f);
bool r = (fi != nullptr) && eval_fi(fi, num, args, result);
CTRACE("model_evaluator", r, tout << "reduce_app " << f->get_name() << "\n";
CTRACE(model_evaluator, r, tout << "reduce_app " << f->get_name() << "\n";
for (unsigned i = 0; i < num; i++) tout << mk_ismt2_pp(args[i], m) << "\n";
tout << "---->\n" << mk_ismt2_pp(result, m) << "\n";);
return r;
@ -154,7 +154,7 @@ struct evaluator_cfg : public default_rewriter_cfg {
br_status reduce_app(func_decl * f, unsigned num, expr * const * args, expr_ref & result, proof_ref & result_pr) {
auto st = reduce_app_core(f, num, args, result, result_pr);
CTRACE("model_evaluator", st != BR_FAILED,
CTRACE(model_evaluator, st != BR_FAILED,
tout << st << " " << mk_pp(f, m) << " ";
for (unsigned i = 0; i < num; ++i) tout << mk_pp(args[i], m) << " ";
tout << "\n--> " << result << "\n";);
@ -205,7 +205,7 @@ struct evaluator_cfg : public default_rewriter_cfg {
func_decl* f;
expr_ref& r;
pp(func_decl* f, expr_ref& r) :f(f), r(r) {}
~pp() { TRACE("model_evaluator", tout << mk_pp(f, r.m()) << " " << r << "\n";); }
~pp() { TRACE(model_evaluator, tout << mk_pp(f, r.m()) << " " << r << "\n";); }
};
pp _pp(f, result);
#endif
@ -222,7 +222,7 @@ struct evaluator_cfg : public default_rewriter_cfg {
if (val != nullptr) {
result = val;
st = contains_redex(val) ? BR_REWRITE_FULL : BR_DONE;
TRACE("model_evaluator", tout << st << " " << result << "\n";);
TRACE(model_evaluator, tout << st << " " << result << "\n";);
return st;
}
if (!m_model_completion)
@ -324,7 +324,7 @@ struct evaluator_cfg : public default_rewriter_cfg {
expr* def = nullptr;
if (m_def_cache.find(g, def)) {
result = def;
TRACE("model_evaluator", tout << result << "\n";);
TRACE(model_evaluator, tout << result << "\n";);
return true;
}
expr_ref tmp(m);
@ -338,11 +338,11 @@ struct evaluator_cfg : public default_rewriter_cfg {
result = ev(tmp);
m_pinned.push_back(result);
m_def_cache.insert(g, result);
TRACE("model_evaluator", tout << mk_pp(g, m) << " " << result << "\n";);
TRACE(model_evaluator, tout << mk_pp(g, m) << " " << result << "\n";);
return true;
}
TRACE("model_evaluator",
TRACE(model_evaluator,
tout << "could not get array interpretation " << mk_pp(g, m) << " " << fi << "\n";
tout << m_model << "\n";);
@ -350,7 +350,7 @@ struct evaluator_cfg : public default_rewriter_cfg {
}
void expand_stores(expr_ref& val) {
TRACE("model_evaluator", tout << val << "\n";);
TRACE(model_evaluator, tout << val << "\n";);
vector<expr_ref_vector> stores;
expr_ref else_case(m);
bool _unused;
@ -365,7 +365,7 @@ struct evaluator_cfg : public default_rewriter_cfg {
args.append(stores[i].size(), stores[i].data());
val = m_ar.mk_store(args);
}
TRACE("model_evaluator", tout << val << "\n";);
TRACE(model_evaluator, tout << val << "\n";);
}
}
@ -417,7 +417,7 @@ struct evaluator_cfg : public default_rewriter_cfg {
SASSERT(def != nullptr);
}
CTRACE("model_evaluator", def != nullptr, tout << "get_macro for " << f->get_name() << " (model completion: " << m_model_completion << ") " << mk_pp(def, m) << "\n";);
CTRACE(model_evaluator, def != nullptr, tout << "get_macro for " << f->get_name() << " (model completion: " << m_model_completion << ") " << mk_pp(def, m) << "\n";);
return def != nullptr;
}
@ -516,7 +516,7 @@ struct evaluator_cfg : public default_rewriter_cfg {
if (!m_array_equalities) {
return m_ar_rw.mk_eq_core(a, b, result);
}
TRACE("model_evaluator", tout << "mk_array_eq " << m_array_equalities << " "
TRACE(model_evaluator, tout << "mk_array_eq " << m_array_equalities << " "
<< mk_pp(a, m) << " " << mk_pp(b, m) << "\n";);
vector<expr_ref_vector> stores1, stores2;
@ -536,7 +536,7 @@ struct evaluator_cfg : public default_rewriter_cfg {
conj.push_back(m.mk_eq(else1, else2));
}
if (args_are_unique1 && args_are_unique2 && !stores1.empty()) {
TRACE("model_evaluator", tout << "args are unique " << conj << "\n";);
TRACE(model_evaluator, tout << "args are unique " << conj << "\n";);
return mk_array_eq_core(stores1, else1, stores2, else2, conj, result);
}
@ -552,7 +552,7 @@ struct evaluator_cfg : public default_rewriter_cfg {
conj.push_back(m.mk_eq(s1, s2));
}
result = mk_and(conj);
TRACE("model_evaluator", tout << mk_pp(a, m) << " == " << mk_pp(b, m) << " -> " << conj << "\n";
TRACE(model_evaluator, tout << mk_pp(a, m) << " == " << mk_pp(b, m) << " -> " << conj << "\n";
for (auto& s : stores1) tout << "store: " << s << "\n"; );
return BR_REWRITE_FULL;
}
@ -593,7 +593,7 @@ struct evaluator_cfg : public default_rewriter_cfg {
args_eq ae(arity);
args_table table1(DEFAULT_HASHTABLE_INITIAL_CAPACITY, ah, ae);
args_table table2(DEFAULT_HASHTABLE_INITIAL_CAPACITY, ah, ae);
TRACE("model_evaluator",
TRACE(model_evaluator,
tout << "arity " << arity << "\n";
for (auto& v : stores1) tout << "stores1: " << v << "\n";
for (auto& v : stores2) tout << "stores2: " << v << "\n";
@ -609,14 +609,14 @@ struct evaluator_cfg : public default_rewriter_cfg {
for (unsigned i = 0, sz = stores2.size(); i < sz; ++i) {
if (table2.contains(stores2[i].data())) {
// first insertion takes precedence.
TRACE("model_evaluator", tout << "duplicate " << stores2[i] << "\n";);
TRACE(model_evaluator, tout << "duplicate " << stores2[i] << "\n";);
continue;
}
table2.insert(stores2[i].data());
expr * const* args = nullptr;
expr* val = stores2[i][arity];
if (table1.find(stores2[i].data(), args)) {
TRACE("model_evaluator", tout << "found value " << stores2[i] << "\n";);
TRACE(model_evaluator, tout << "found value " << stores2[i] << "\n";);
table1.remove(args);
switch (compare(args[arity], val)) {
case l_true: break;
@ -625,7 +625,7 @@ struct evaluator_cfg : public default_rewriter_cfg {
}
}
else {
TRACE("model_evaluator", tout << "not found value " << stores2[i] << "\n";);
TRACE(model_evaluator, tout << "not found value " << stores2[i] << "\n";);
switch (compare(else1, val)) {
case l_true: break;
case l_false: result = m.mk_false(); return BR_DONE;
@ -665,7 +665,7 @@ struct evaluator_cfg : public default_rewriter_cfg {
bool extract_array_func_interp(expr* a, vector<expr_ref_vector>& stores, expr_ref& else_case, bool& are_unique) {
SASSERT(m_ar.is_array(a));
are_unique = true;
TRACE("model_evaluator", tout << mk_pp(a, m) << "\n";);
TRACE(model_evaluator, tout << mk_pp(a, m) << "\n";);
while (m_ar.is_store(a)) {
expr_ref_vector store(m);
@ -686,20 +686,20 @@ struct evaluator_cfg : public default_rewriter_cfg {
return true;
}
if (!m_ar.is_as_array(a)) {
TRACE("model_evaluator", tout << "no translation: " << mk_pp(a, m) << "\n";);
TRACE("model_evaluator", tout << m_model << "\n";);
TRACE(model_evaluator, tout << "no translation: " << mk_pp(a, m) << "\n";);
TRACE(model_evaluator, tout << m_model << "\n";);
return false;
}
func_decl* f = m_ar.get_as_array_func_decl(to_app(a));
func_interp* g = m_model.get_func_interp(f);
if (!g) {
TRACE("model_evaluator", tout << "no interpretation for " << mk_pp(f, m) << "\n";);
TRACE(model_evaluator, tout << "no interpretation for " << mk_pp(f, m) << "\n";);
return false;
}
else_case = g->get_else();
if (!else_case) {
TRACE("model_evaluator", tout << "no else case " << mk_pp(a, m) << "\n";);
TRACE(model_evaluator, tout << "no else case " << mk_pp(a, m) << "\n";);
return false;
}
bool ground = is_ground(else_case);
@ -721,7 +721,7 @@ struct evaluator_cfg : public default_rewriter_cfg {
stores.push_back(store);
}
if (!ground) {
TRACE("model_evaluator", tout << "could not extract ground array interpretation: " << mk_pp(a, m) << "\n";);
TRACE(model_evaluator, tout << "could not extract ground array interpretation: " << mk_pp(a, m) << "\n";);
return false;
}
return true;
@ -802,10 +802,10 @@ void model_evaluator::reset(model_core &model, params_ref const& p) {
void model_evaluator::operator()(expr * t, expr_ref & result) {
TRACE("model_evaluator", tout << mk_ismt2_pp(t, m()) << "\n";);
TRACE(model_evaluator, tout << mk_ismt2_pp(t, m()) << "\n";);
m_imp->operator()(t, result);
m_imp->expand_stores(result);
TRACE("model_evaluator", tout << "eval: " << mk_ismt2_pp(t, m()) << " --> " << result << "\n";);
TRACE(model_evaluator, tout << "eval: " << mk_ismt2_pp(t, m()) << " --> " << result << "\n";);
}
expr_ref model_evaluator::operator()(expr * t) {
@ -853,7 +853,7 @@ bool model_evaluator::eval(expr* t, expr_ref& r, bool model_completion) {
}
catch (model_evaluator_exception &ex) {
(void)ex;
TRACE("model_evaluator", tout << ex.what () << "\n";);
TRACE(model_evaluator, tout << ex.what () << "\n";);
return false;
}
}

52
src/model/model_implicant.cpp
View file

@ -63,7 +63,7 @@ void model_implicant::assign_value(expr* e, expr* val) {
}
else {
IF_VERBOSE(3, verbose_stream() << "Not evaluated " << mk_pp(e, m) << " := " << mk_pp(val, m) << "\n";);
TRACE("pdr", tout << "Variable is not tracked: " << mk_pp(e, m) << " := " << mk_pp(val, m) << "\n";);
TRACE(pdr, tout << "Variable is not tracked: " << mk_pp(e, m) << " := " << mk_pp(val, m) << "\n";);
set_x(e);
}
}
@ -96,13 +96,13 @@ void model_implicant::reset() {
expr_ref_vector model_implicant::minimize_model(ptr_vector<expr> const & formulas, model_ref& mdl) {
setup_model(mdl);
TRACE("pdr_verbose",
TRACE(pdr_verbose,
tout << "formulas:\n";
for (unsigned i = 0; i < formulas.size(); ++i) tout << mk_pp(formulas[i], m) << "\n";
);
expr_ref_vector model = prune_by_cone_of_influence(formulas);
TRACE("pdr_verbose",
TRACE(pdr_verbose,
tout << "pruned model:\n";
for (unsigned i = 0; i < model.size(); ++i) tout << mk_pp(model[i].get(), m) << "\n";);
@ -118,7 +118,7 @@ expr_ref_vector model_implicant::minimize_model(ptr_vector<expr> const & formula
expr_ref_vector model_implicant::minimize_literals(ptr_vector<expr> const& formulas, model_ref& mdl) {
TRACE("pdr",
TRACE(pdr,
tout << "formulas:\n";
for (unsigned i = 0; i < formulas.size(); ++i) tout << mk_pp(formulas[i], m) << "\n";
);
@ -151,7 +151,7 @@ expr_ref_vector model_implicant::minimize_literals(ptr_vector<expr> const& formu
}
}
reset();
TRACE("pdr",
TRACE(pdr,
tout << "minimized model:\n";
for (unsigned i = 0; i < result.size(); ++i) tout << mk_pp(result[i].get(), m) << "\n";
);
@ -288,7 +288,7 @@ expr_ref_vector model_implicant::prune_by_cone_of_influence(ptr_vector<expr> con
m1.reset();
m2.reset();
for (unsigned i = 0; i < tocollect.size(); ++i) {
TRACE("pdr_verbose", tout << "collect: " << mk_pp(tocollect[i], m) << "\n";);
TRACE(pdr_verbose, tout << "collect: " << mk_pp(tocollect[i], m) << "\n";);
for_each_expr(*this, m_visited, tocollect[i]);
}
unsigned sz = m_model->get_num_constants();
@ -303,7 +303,7 @@ expr_ref_vector model_implicant::prune_by_cone_of_influence(ptr_vector<expr> con
}
}
m_visited.reset();
TRACE("pdr", tout << sz << " ==> " << model.size() << "\n";);
TRACE(pdr, tout << sz << " ==> " << model.size() << "\n";);
return model;
}
@ -445,7 +445,7 @@ void model_implicant::inherit_value(expr* e, expr* v) {
if (is_true(v)) set_true(e);
else if (is_false(v)) set_false(e);
else {
TRACE("pdr", tout << "not inherited:\n" << mk_pp(e, m) << "\n" << mk_pp(v, m) << "\n";);
TRACE(pdr, tout << "not inherited:\n" << mk_pp(e, m) << "\n" << mk_pp(v, m) << "\n";);
set_x(e);
}
}
@ -459,7 +459,7 @@ void model_implicant::inherit_value(expr* e, expr* v) {
set_value(e, w);
}
else {
TRACE("pdr", tout << "not inherited:\n" << mk_pp(e, m) << "\n" << mk_pp(v, m) << "\n";);
TRACE(pdr, tout << "not inherited:\n" << mk_pp(e, m) << "\n" << mk_pp(v, m) << "\n";);
set_x(e);
}
}
@ -476,7 +476,7 @@ void model_implicant::eval_exprs(expr_ref_vector& es) {
bool model_implicant::extract_array_func_interp(expr* a, vector<expr_ref_vector>& stores, expr_ref& else_case) {
SASSERT(m_array.is_array(a));
TRACE("pdr", tout << mk_pp(a, m) << "\n";);
TRACE(pdr, tout << mk_pp(a, m) << "\n";);
while (m_array.is_store(a)) {
expr_ref_vector store(m);
store.append(to_app(a)->get_num_args()-1, to_app(a)->get_args()+1);
@ -502,7 +502,7 @@ bool model_implicant::extract_array_func_interp(expr* a, vector<expr_ref_vector>
store.push_back(fe->get_result());
for (unsigned j = 0; j < store.size(); ++j) {
if (!is_ground(store[j].get())) {
TRACE("pdr", tout << "could not extract array interpretation: " << mk_pp(a, m) << "\n" << mk_pp(store[j].get(), m) << "\n";);
TRACE(pdr, tout << "could not extract array interpretation: " << mk_pp(a, m) << "\n" << mk_pp(store[j].get(), m) << "\n";);
return false;
}
}
@ -511,21 +511,21 @@ bool model_implicant::extract_array_func_interp(expr* a, vector<expr_ref_vector>
}
else_case = g->get_else();
if (!else_case) {
TRACE("pdr", tout << "no else case " << mk_pp(a, m) << "\n";);
TRACE(pdr, tout << "no else case " << mk_pp(a, m) << "\n";);
return false;
}
if (!is_ground(else_case)) {
TRACE("pdr", tout << "non-ground else case " << mk_pp(a, m) << "\n" << mk_pp(else_case, m) << "\n";);
TRACE(pdr, tout << "non-ground else case " << mk_pp(a, m) << "\n" << mk_pp(else_case, m) << "\n";);
return false;
}
if (m_array.is_as_array(else_case)) {
model_ref mr(m_model);
else_case = eval(mr, else_case);
}
TRACE("pdr", tout << "else case: " << mk_pp(else_case, m) << "\n";);
TRACE(pdr, tout << "else case: " << mk_pp(else_case, m) << "\n";);
return true;
}
TRACE("pdr", tout << "no translation: " << mk_pp(a, m) << "\n";);
TRACE(pdr, tout << "no translation: " << mk_pp(a, m) << "\n";);
return false;
}
@ -534,7 +534,7 @@ bool model_implicant::extract_array_func_interp(expr* a, vector<expr_ref_vector>
best effort evaluator of extensional array equality.
*/
void model_implicant::eval_array_eq(app* e, expr* arg1, expr* arg2) {
TRACE("pdr", tout << "array equality: " << mk_pp(e, m) << "\n";);
TRACE(pdr, tout << "array equality: " << mk_pp(e, m) << "\n";);
expr_ref v1 = (*m_model)(arg1);
expr_ref v2 = (*m_model)(arg2);
if (v1 == v2) {
@ -545,7 +545,7 @@ void model_implicant::eval_array_eq(app* e, expr* arg1, expr* arg2) {
sort* r = get_array_range(s);
// give up evaluating finite domain/range arrays
if (!r->is_infinite() && !r->is_very_big() && !s->is_infinite() && !s->is_very_big()) {
TRACE("pdr", tout << "equality is unknown: " << mk_pp(e, m) << "\n";);
TRACE(pdr, tout << "equality is unknown: " << mk_pp(e, m) << "\n";);
set_x(e);
return;
}
@ -553,14 +553,14 @@ void model_implicant::eval_array_eq(app* e, expr* arg1, expr* arg2) {
expr_ref else1(m), else2(m);
if (!extract_array_func_interp(v1, store, else1) ||
!extract_array_func_interp(v2, store, else2)) {
TRACE("pdr", tout << "equality is unknown: " << mk_pp(e, m) << "\n";);
TRACE(pdr, tout << "equality is unknown: " << mk_pp(e, m) << "\n";);
set_x(e);
return;
}
if (else1 != else2) {
if (m.is_value(else1) && m.is_value(else2)) {
TRACE("pdr", tout
TRACE(pdr, tout
<< "defaults are different: " << mk_pp(e, m) << " "
<< mk_pp(else1, m) << " " << mk_pp(else2, m) << "\n";);
set_false(e);
@ -569,7 +569,7 @@ void model_implicant::eval_array_eq(app* e, expr* arg1, expr* arg2) {
eval_array_eq(e, else1, else2);
}
else {
TRACE("pdr", tout << "equality is unknown: " << mk_pp(e, m) << "\n";);
TRACE(pdr, tout << "equality is unknown: " << mk_pp(e, m) << "\n";);
set_x(e);
}
return;
@ -592,7 +592,7 @@ void model_implicant::eval_array_eq(app* e, expr* arg1, expr* arg2) {
continue;
}
if (m.is_value(w1) && m.is_value(w2)) {
TRACE("pdr", tout << "Equality evaluation: " << mk_pp(e, m) << "\n";
TRACE(pdr, tout << "Equality evaluation: " << mk_pp(e, m) << "\n";
tout << mk_pp(s1, m) << " |-> " << mk_pp(w1, m) << "\n";
tout << mk_pp(s2, m) << " |-> " << mk_pp(w2, m) << "\n";);
set_false(e);
@ -604,7 +604,7 @@ void model_implicant::eval_array_eq(app* e, expr* arg1, expr* arg2) {
}
}
else {
TRACE("pdr", tout << "equality is unknown: " << mk_pp(e, m) << "\n";);
TRACE(pdr, tout << "equality is unknown: " << mk_pp(e, m) << "\n";);
set_x(e);
}
return;
@ -630,7 +630,7 @@ void model_implicant::eval_eq(app* e, expr* arg1, expr* arg2) {
set_bool(e, false);
}
else {
TRACE("pdr", tout << "cannot evaluate: " << mk_pp(vl, m) << "\n";);
TRACE(pdr, tout << "cannot evaluate: " << mk_pp(vl, m) << "\n";);
set_x(e);
}
}
@ -657,7 +657,7 @@ void model_implicant::eval_eq(app* e, expr* arg1, expr* arg2) {
set_bool(e, true);
}
else {
TRACE("pdr", tout << "not value equal:\n" << mk_pp(e1, m) << "\n" << mk_pp(e2, m) << "\n";);
TRACE(pdr, tout << "not value equal:\n" << mk_pp(e1, m) << "\n" << mk_pp(e2, m) << "\n";);
set_x(e);
}
}
@ -849,7 +849,7 @@ bool model_implicant::check_model(ptr_vector<expr> const& formulas) {
for (unsigned i = 0; i < formulas.size(); ++i) {
expr * form = formulas[i];
SASSERT(!is_unknown(form));
TRACE("pdr_verbose",
TRACE(pdr_verbose,
tout << "formula is " << (is_true(form) ? "true" : is_false(form) ? "false" : "unknown") << "\n" <<mk_pp(form, m)<< "\n";);
if (is_false(form)) {
@ -858,7 +858,7 @@ bool model_implicant::check_model(ptr_vector<expr> const& formulas) {
}
if (is_x(form)) {
IF_VERBOSE(0, verbose_stream() << "formula undetermined in model: " << mk_pp(form, m) << "\n";);
TRACE("pdr", model_smt2_pp(tout, m, *m_model, 0););
TRACE(pdr, model_smt2_pp(tout, m, *m_model, 0););
has_x = true;
}
}

2
src/model/model_implicant.h
View file

@ -73,7 +73,7 @@ class model_implicant {
inline void set_bool(expr* x, bool v) { if (v) { set_true(x); } else { set_false(x); } }
inline rational const& get_number(expr* x) const { return m_numbers.find(x); }
inline void set_number(expr* x, rational const& v) {
set_v(x); TRACE("pdr_verbose", tout << mk_pp(x,m) << " " << v << "\n";); m_numbers.insert(x,v);
set_v(x); TRACE(pdr_verbose, tout << mk_pp(x,m) << " " << v << "\n";); m_numbers.insert(x,v);
}
inline expr* get_value(expr* x) { return m_values.find(x); }
inline void set_value(expr* x, expr* v) { set_v(x); m_refs.push_back(v); m_values.insert(x, v); }

20
src/model/model_macro_solver.cpp
View file

@ -24,7 +24,7 @@ void base_macro_solver::set_else_interp(func_decl* f, expr* f_else) {
m_model->register_decl(f, fi);
}
fi->set_else(f_else);
TRACE("model_finder", tout << f->get_name() << " " << mk_pp(f_else, m) << "\n";);
TRACE(model_finder, tout << f->get_name() << " " << mk_pp(f_else, m) << "\n";);
}
void base_macro_solver::operator()(model_core& m, ptr_vector<quantifier>& qs, ptr_vector<quantifier>& residue) {
@ -67,7 +67,7 @@ bool simple_macro_solver::process(quantifier* q, ptr_vector<quantifier> const& q
// does not satisfy the quantifier.
// In all other cases the "else" of f will satisfy the quantifier.
set_else_interp(f, f_else);
TRACE("model_finder", tout << "satisfying the quantifier using simple macro:\n";
TRACE(model_finder, tout << "satisfying the quantifier using simple macro:\n";
m->display(tout); tout << "\n";);
return true; // satisfied quantifier
}
@ -307,7 +307,7 @@ void hint_macro_solver::greedy(func_decl* f, unsigned depth) {
if (depth >= GREEDY_MAX_DEPTH)
return; // failed
TRACE("model_finder_hint",
TRACE(model_finder_hint,
tout << "greedy depth: " << depth << ", f: " << f->get_name() << "\n";
display_search_state(tout););
@ -318,7 +318,7 @@ void hint_macro_solver::greedy(func_decl* f, unsigned depth) {
m_satisfied.push_scope();
m_residue.push_scope();
TRACE("model_finder", tout << f->get_name() << " " << mk_pp(def, m) << "\n";);
TRACE(model_finder, tout << f->get_name() << " " << mk_pp(def, m) << "\n";);
m_fs.insert(f, def);
if (update_satisfied_residue(f, def)) {
@ -373,7 +373,7 @@ bool hint_macro_solver::is_acyclic(expr* def) {
void hint_macro_solver::greedy(unsigned depth) {
if (m_residue.empty()) {
if (is_cyclic()) return;
TRACE("model_finder_hint",
TRACE(model_finder_hint,
tout << "found subset that is satisfied by macros\n";
display_search_state(tout););
throw found_satisfied_subset();
@ -381,7 +381,7 @@ void hint_macro_solver::greedy(unsigned depth) {
func_decl_set candidates;
get_candidates_from_residue(candidates);
TRACE("model_finder_hint", tout << "candidates from residue:\n";
TRACE(model_finder_hint, tout << "candidates from residue:\n";
for (func_decl* f : candidates) {
tout << f->get_name() << " ";
}
@ -444,7 +444,7 @@ bool hint_macro_solver::process(ptr_vector<quantifier> const& qs, ptr_vector<qua
return false;
}
mk_q_f_defs(qcandidates);
TRACE("model_finder_hint", tout << "starting hint-solver search using:\n"; display_qcandidates(tout, qcandidates););
TRACE(model_finder_hint, tout << "starting hint-solver search using:\n"; display_qcandidates(tout, qcandidates););
for (func_decl* f : m_candidates) {
try {
process(f);
@ -469,11 +469,11 @@ The auf_solver is ineffective in these clauses.
*/
bool non_auf_macro_solver::add_macro(func_decl* f, expr* f_else) {
TRACE("model_finder", tout << "trying to add macro for " << f->get_name() << "\n" << mk_pp(f_else, m) << "\n";);
TRACE(model_finder, tout << "trying to add macro for " << f->get_name() << "\n" << mk_pp(f_else, m) << "\n";);
func_decl_set* s = m_dependencies.mk_func_decl_set();
m_dependencies.collect_ng_func_decls(f_else, s);
if (!m_dependencies.insert(f, s)) {
TRACE("model_finder", tout << "failed to add macro\n";);
TRACE(model_finder, tout << "failed to add macro\n";);
return false; // cyclic dependency
}
set_else_interp(f, f_else);
@ -510,7 +510,7 @@ void non_auf_macro_solver::collect_candidates(ptr_vector<quantifier> const& qs,
for (cond_macro* m : qi->macros()) {
if (!m->is_hint()) {
func_decl* f = m->get_f();
TRACE("model_finder", tout << "considering macro for: " << f->get_name() << "\n";
TRACE(model_finder, tout << "considering macro for: " << f->get_name() << "\n";
m->display(tout); tout << "\n";);
if (m->is_unconditional() && (!qi->is_auf() || m->get_weight() >= m_mbqi_force_template)) {
full_macros.insert(f, std::make_pair(m, q));

2
src/model/model_smt2_pp.cpp
View file

@ -212,7 +212,7 @@ static void pp_funs(std::ostream & out, ast_printer_context & ctx, model_core co
else {
ctx.pp(f_i->get_else(), f->get_arity(), "x", body, var_names);
}
TRACE("model_smt2_pp", for (unsigned i = 0; i < var_names.size(); i++) tout << var_names[i] << "\n";);
TRACE(model_smt2_pp, for (unsigned i = 0; i < var_names.size(); i++) tout << var_names[i] << "\n";);
f_var_names.reset();
for (auto const& vn : var_names)
f_var_names.push_back(mk_string(m, vn.bare_str()));