reorganizing the code

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>

src/tactic/fpa/fpa2bv_converter.h

@@ -0,0 +1,200 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    fpa2bv_converter.h
+
+Abstract:
+
+    Conversion routines for Floating Point -> Bit-Vector
+
+Author:
+
+    Christoph (cwinter) 2012-02-09
+
+Notes:
+
+--*/
+#ifndef _FPA2BV_CONVERTER_
+#define _FPA2BV_CONVERTER_
+
+#include"ast.h"
+#include"obj_hashtable.h"
+#include"ref_util.h"
+#include"float_decl_plugin.h"
+#include"bv_decl_plugin.h"
+#include"model_converter.h"
+#include"basic_simplifier_plugin.h"
+
+typedef enum { BV_RM_TIES_TO_AWAY=0, BV_RM_TIES_TO_EVEN=1, BV_RM_TO_NEGATIVE=2, BV_RM_TO_POSITIVE=3, BV_RM_TO_ZERO=4 } BV_RM_VAL;
+
+class fpa2bv_model_converter;
+
+class fpa2bv_converter {
+    ast_manager              & m;
+    basic_simplifier_plugin    m_simp;
+    float_util                 m_util;
+	mpf_manager				 & m_mpf_manager;
+	unsynch_mpz_manager      & m_mpz_manager;
+    bv_util                    m_bv_util;    
+    float_decl_plugin        * m_plugin;
+
+    obj_map<func_decl, expr*>  m_const2bv;
+	obj_map<func_decl, expr*>  m_rm_const2bv;
+    
+public:
+    fpa2bv_converter(ast_manager & m);    
+    ~fpa2bv_converter();
+
+    float_util & fu() { return m_util; }
+
+    bool is_float(sort * s) { return m_util.is_float(s); }
+    bool is_float(expr * e) { return is_app(e) && m_util.is_float(to_app(e)->get_decl()->get_range()); }
+    bool is_float_family(func_decl * f) { return f->get_family_id() == m_util.get_family_id(); }
+	bool is_rm_sort(sort * s) { return m_util.is_rm(s); }
+
+    void mk_triple(expr * sign, expr * significand, expr * exponent, expr_ref & result) {
+		SASSERT(m_bv_util.is_bv(sign) && m_bv_util.get_bv_size(sign) == 1);
+		SASSERT(m_bv_util.is_bv(significand));
+		SASSERT(m_bv_util.is_bv(exponent));
+        result = m.mk_app(m_util.get_family_id(), OP_TO_FLOAT, sign, significand, exponent);
+    }
+
+    void mk_eq(expr * a, expr * b, expr_ref & result);
+    void mk_ite(expr * c, expr * t, expr * f, expr_ref & result);
+
+	void mk_rounding_mode(func_decl * f, expr_ref & result);
+    void mk_value(func_decl * f, unsigned num, expr * const * args, expr_ref & result);
+    void mk_const(func_decl * f, expr_ref & result);
+	void mk_rm_const(func_decl * f, expr_ref & result);
+
+    void mk_plus_inf(func_decl * f, expr_ref & result);
+    void mk_minus_inf(func_decl * f, expr_ref & result);
+    void mk_nan(func_decl * f, expr_ref & result);
+    void mk_nzero(func_decl *f, expr_ref & result);
+    void mk_pzero(func_decl *f, expr_ref & result);
+
+    void mk_add(func_decl * f, unsigned num, expr * const * args, expr_ref & result);
+    void mk_sub(func_decl * f, unsigned num, expr * const * args, expr_ref & result);
+    void mk_uminus(func_decl * f, unsigned num, expr * const * args, expr_ref & result);
+    void mk_mul(func_decl * f, unsigned num, expr * const * args, expr_ref & result);
+    void mk_div(func_decl * f, unsigned num, expr * const * args, expr_ref & result);
+    void mk_remainder(func_decl * f, unsigned num, expr * const * args, expr_ref & result);
+    void mk_abs(func_decl * f, unsigned num, expr * const * args, expr_ref & result);
+    void mk_min(func_decl * f, unsigned num, expr * const * args, expr_ref & result);
+    void mk_max(func_decl * f, unsigned num, expr * const * args, expr_ref & result);
+    void mk_fusedma(func_decl * f, unsigned num, expr * const * args, expr_ref & result);
+    void mk_sqrt(func_decl * f, unsigned num, expr * const * args, expr_ref & result);
+    void mk_round_to_integral(func_decl * f, unsigned num, expr * const * args, expr_ref & result);
+
+    void mk_float_eq(func_decl * f, unsigned num, expr * const * args, expr_ref & result);
+    void mk_float_lt(func_decl * f, unsigned num, expr * const * args, expr_ref & result);
+    void mk_float_gt(func_decl * f, unsigned num, expr * const * args, expr_ref & result);
+    void mk_float_le(func_decl * f, unsigned num, expr * const * args, expr_ref & result);
+    void mk_float_ge(func_decl * f, unsigned num, expr * const * args, expr_ref & result);
+
+    void mk_is_zero(func_decl * f, unsigned num, expr * const * args, expr_ref & result);
+    void mk_is_nzero(func_decl * f, unsigned num, expr * const * args, expr_ref & result);
+    void mk_is_pzero(func_decl * f, unsigned num, expr * const * args, expr_ref & result);
+    void mk_is_sign_minus(func_decl * f, unsigned num, expr * const * args, expr_ref & result);
+
+    void mk_to_float(func_decl * f, unsigned num, expr * const * args, expr_ref & result);
+
+    fpa2bv_model_converter * mk_model_converter();
+
+    void dbg_decouple(const char * prefix, expr_ref & e);
+    expr_ref_vector extra_assertions;
+
+protected:
+    void split(expr * e, expr * & sgn, expr * & sig, expr * & exp) const;
+
+    void mk_is_nan(expr * e, expr_ref & result);
+    void mk_is_inf(expr * e, expr_ref & result);
+    void mk_is_pinf(expr * e, expr_ref & result);
+    void mk_is_ninf(expr * e, expr_ref & result);
+    void mk_is_pos(expr * e, expr_ref & result);
+    void mk_is_neg(expr * e, expr_ref & result);
+    void mk_is_zero(expr * e, expr_ref & result);
+    void mk_is_nzero(expr * e, expr_ref & result);
+    void mk_is_pzero(expr * e, expr_ref & result);
+    void mk_is_denormal(expr * e, expr_ref & result);
+    void mk_is_normal(expr * e, expr_ref & result);
+
+	void mk_is_rm(expr * e, BV_RM_VAL rm, expr_ref & result);
+
+    void mk_top_exp(unsigned sz, expr_ref & result);
+    void mk_bot_exp(unsigned sz, expr_ref & result);
+	void mk_min_exp(unsigned ebits, expr_ref & result);
+    void mk_max_exp(unsigned ebits, expr_ref & result);
+
+    void mk_leading_zeros(expr * e, unsigned max_bits, expr_ref & result);
+
+    void mk_bias(expr * e, expr_ref & result);
+    void mk_unbias(expr * e, expr_ref & result);
+
+    void unpack(expr * e, expr_ref & sgn, expr_ref & sig, expr_ref & exp, bool normalize);
+    void round(sort * s, expr_ref & rm, expr_ref & sgn, expr_ref & sig, expr_ref & exp, expr_ref & result);	    
+
+    void add_core(unsigned sbits, unsigned ebits, expr_ref & rm,
+        expr_ref & c_sgn, expr_ref & c_sig, expr_ref & c_exp, expr_ref & d_sgn, expr_ref & d_sig, expr_ref & d_exp,
+        expr_ref & res_sgn, expr_ref & res_sig, expr_ref & res_exp);
+};
+
+
+class fpa2bv_model_converter : public model_converter {
+    ast_manager               & m;
+    obj_map<func_decl, expr*>   m_const2bv;
+	obj_map<func_decl, expr*>   m_rm_const2bv;
+
+public:
+    fpa2bv_model_converter(ast_manager & m, obj_map<func_decl, expr*> & const2bv,
+		                                    obj_map<func_decl, expr*> & rm_const2bv) : 
+      m(m) {
+          // Just create a copy?
+          for (obj_map<func_decl, expr*>::iterator it = const2bv.begin();
+               it != const2bv.end();
+               it++) 
+          {
+               m_const2bv.insert(it->m_key, it->m_value);
+               m.inc_ref(it->m_key);
+               m.inc_ref(it->m_value);
+          }
+		  for (obj_map<func_decl, expr*>::iterator it = rm_const2bv.begin();
+               it != rm_const2bv.end();
+               it++) 
+          {
+               m_rm_const2bv.insert(it->m_key, it->m_value);
+               m.inc_ref(it->m_key);
+               m.inc_ref(it->m_value);
+          }
+      }
+
+    virtual ~fpa2bv_model_converter() {
+        dec_ref_map_key_values(m, m_const2bv);
+		dec_ref_map_key_values(m, m_rm_const2bv);
+    }
+
+    virtual void operator()(model_ref & md, unsigned goal_idx) {
+        SASSERT(goal_idx == 0);
+        model * new_model = alloc(model, m);
+        obj_hashtable<func_decl> bits;
+        convert(md.get(), new_model);
+        md = new_model;
+    }
+
+    virtual void operator()(model_ref & md) {
+        operator()(md, 0);
+    }
+
+    void display(std::ostream & out);
+
+    virtual model_converter * translate(ast_translation & translator);
+
+protected:
+    fpa2bv_model_converter(ast_manager & m) : m(m) { }
+    
+    void convert(model * bv_mdl, model * float_mdl);
+};
+
+#endif

src/tactic/fpa/fpa2bv_tactic.cpp

@@ -0,0 +1,310 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    fpa2bv_tactic.cpp
+
+Abstract:
+
+    Tactic that converts floating points to bit-vectors
+
+Author:
+
+    Christoph (cwinter) 2012-02-09
+
+Notes:
+
+--*/
+#include"tactical.h"
+#include"rewriter_def.h"
+#include"cooperate.h"
+#include"ref_util.h"
+#include"bv_decl_plugin.h"
+#include"float_decl_plugin.h"
+#include"fpa2bv_converter.h"
+
+#include"tactical.h"
+#include"simplify_tactic.h"
+
+#include"fpa2bv_tactic.h"
+
+struct fpa2bv_rewriter_cfg : public default_rewriter_cfg {
+    ast_manager              & m_manager;    
+    expr_ref_vector            m_out;    
+    fpa2bv_converter         & m_conv;
+
+    unsigned long long         m_max_memory;
+    unsigned                   m_max_steps;
+
+    ast_manager & m() const { return m_manager; }
+
+    fpa2bv_rewriter_cfg(ast_manager & m, fpa2bv_converter & c, params_ref const & p):
+        m_manager(m),
+        m_out(m),
+        m_conv(c) {
+        updt_params(p);
+        // We need to make sure that the mananger has the BV plugin loaded.
+        symbol s_bv("bv");
+        if (!m_manager.has_plugin(s_bv))
+            m_manager.register_plugin(s_bv, alloc(bv_decl_plugin));
+    }
+
+    ~fpa2bv_rewriter_cfg() {        
+    }
+
+    void cleanup_buffers() {
+        m_out.finalize();
+    }
+
+    void updt_params(params_ref const & p) {
+        m_max_memory     = megabytes_to_bytes(p.get_uint(":max-memory", UINT_MAX));
+        m_max_steps      = p.get_uint(":max-steps", UINT_MAX);        
+    }
+
+    bool max_steps_exceeded(unsigned num_steps) const { 
+        cooperate("fpa2bv");
+        if (memory::get_allocation_size() > m_max_memory)
+            throw tactic_exception(TACTIC_MAX_MEMORY_MSG);
+        return num_steps > m_max_steps;
+    }
+
+    br_status reduce_app(func_decl * f, unsigned num, expr * const * args, expr_ref & result, proof_ref & result_pr) {
+        TRACE("fpa2bv_rw", tout << "APP: " << f->get_name() << std::endl; );
+
+        if (num == 0 && f->get_family_id() == null_family_id && m_conv.is_float(f->get_range())) {
+            m_conv.mk_const(f, result);
+            return BR_DONE;
+        }
+
+		if (num == 0 && f->get_family_id() == null_family_id && m_conv.is_rm_sort(f->get_range())) {
+            m_conv.mk_rm_const(f, result);
+            return BR_DONE;
+        }
+
+        if (m().is_eq(f)) {
+            SASSERT(num == 2);
+            if (m_conv.is_float(args[0])) {
+                m_conv.mk_eq(args[0], args[1], result);
+                return BR_DONE;
+            }
+            return BR_FAILED;
+        }
+
+        if (m().is_ite(f)) {
+            SASSERT(num == 3);
+            if (m_conv.is_float(args[1])) {
+                m_conv.mk_ite(args[0], args[1], args[2], result);
+                return BR_DONE;
+            }
+            return BR_FAILED;
+        }
+        
+        if (m_conv.is_float_family(f)) {
+            switch (f->get_decl_kind()) {            
+            case OP_RM_NEAREST_TIES_TO_AWAY:
+            case OP_RM_NEAREST_TIES_TO_EVEN:
+            case OP_RM_TOWARD_NEGATIVE:
+            case OP_RM_TOWARD_POSITIVE:
+			case OP_RM_TOWARD_ZERO: m_conv.mk_rounding_mode(f, result); return BR_DONE;            
+            case OP_FLOAT_VALUE: m_conv.mk_value(f, num, args, result); return BR_DONE;                             
+            case OP_FLOAT_PLUS_INF: m_conv.mk_plus_inf(f, result); return BR_DONE;
+            case OP_FLOAT_MINUS_INF: m_conv.mk_minus_inf(f, result); return BR_DONE;
+            case OP_FLOAT_NAN: m_conv.mk_nan(f, result); return BR_DONE;
+            case OP_FLOAT_ADD: m_conv.mk_add(f, num, args, result); return BR_DONE;
+            case OP_FLOAT_SUB: m_conv.mk_sub(f, num, args, result); return BR_DONE;
+            case OP_FLOAT_UMINUS: m_conv.mk_uminus(f, num, args, result); return BR_DONE;
+            case OP_FLOAT_MUL: m_conv.mk_mul(f, num, args, result); return BR_DONE;
+            case OP_FLOAT_DIV: m_conv.mk_div(f, num, args, result); return BR_DONE;
+            case OP_FLOAT_REM: m_conv.mk_remainder(f, num, args, result); return BR_DONE;
+            case OP_FLOAT_ABS: m_conv.mk_abs(f, num, args, result); return BR_DONE;
+            case OP_FLOAT_MIN: m_conv.mk_min(f, num, args, result); return BR_DONE;
+            case OP_FLOAT_MAX: m_conv.mk_max(f, num, args, result); return BR_DONE;
+            case OP_FLOAT_FUSED_MA: m_conv.mk_fusedma(f, num, args, result); return BR_DONE;
+            case OP_FLOAT_SQRT: m_conv.mk_sqrt(f, num, args, result); return BR_DONE;
+            case OP_FLOAT_ROUND_TO_INTEGRAL: m_conv.mk_round_to_integral(f, num, args, result); return BR_DONE;
+            case OP_FLOAT_EQ: m_conv.mk_float_eq(f, num, args, result); return BR_DONE;
+            case OP_FLOAT_LT: m_conv.mk_float_lt(f, num, args, result); return BR_DONE;
+            case OP_FLOAT_GT: m_conv.mk_float_gt(f, num, args, result); return BR_DONE;
+            case OP_FLOAT_LE: m_conv.mk_float_le(f, num, args, result); return BR_DONE;
+            case OP_FLOAT_GE: m_conv.mk_float_ge(f, num, args, result); return BR_DONE;
+            case OP_FLOAT_IS_ZERO: m_conv.mk_is_zero(f, num, args, result); return BR_DONE;
+            case OP_FLOAT_IS_NZERO: m_conv.mk_is_nzero(f, num, args, result); return BR_DONE;
+            case OP_FLOAT_IS_PZERO: m_conv.mk_is_pzero(f, num, args, result); return BR_DONE;
+            case OP_FLOAT_IS_SIGN_MINUS: m_conv.mk_is_sign_minus(f, num, args, result); return BR_DONE;
+            case OP_TO_FLOAT: m_conv.mk_to_float(f, num, args, result); return BR_DONE;
+            default:
+                TRACE("fpa2bv", tout << "unsupported operator: " << f->get_name() << "\n";
+                      for (unsigned i = 0; i < num; i++) tout << mk_ismt2_pp(args[i], m()) << std::endl;);
+                throw tactic_exception("NYI");
+            }
+        }
+        
+        return BR_FAILED;
+    }
+
+    bool reduce_quantifier(quantifier * old_q, 
+                           expr * new_body, 
+                           expr * const * new_patterns, 
+                           expr * const * new_no_patterns,
+                           expr_ref & result,
+                           proof_ref & result_pr) {
+        return false;
+    }
+
+    bool reduce_var(var * t, expr_ref & result, proof_ref & result_pr) { 
+        return false; 
+    }
+};
+
+template class rewriter_tpl<fpa2bv_rewriter_cfg>;
+
+struct fpa2bv_rewriter : public rewriter_tpl<fpa2bv_rewriter_cfg> {
+    fpa2bv_rewriter_cfg m_cfg;
+    fpa2bv_rewriter(ast_manager & m, fpa2bv_converter & c, params_ref const & p):
+        rewriter_tpl<fpa2bv_rewriter_cfg>(m, m.proofs_enabled(), m_cfg),        
+        m_cfg(m, c, p) {
+    }
+};
+
+class fpa2bv_tactic : public tactic {
+    struct imp {
+        ast_manager &     m;
+        fpa2bv_converter  m_conv;
+        fpa2bv_rewriter   m_rw;
+        unsigned          m_num_steps;
+
+        bool              m_proofs_enabled;
+        bool              m_produce_models;
+        bool              m_produce_unsat_cores;
+
+        imp(ast_manager & _m, params_ref const & p):
+            m(_m),
+            m_conv(m),
+            m_rw(m, m_conv, p),
+            m_proofs_enabled(false),
+            m_produce_models(false),
+            m_produce_unsat_cores(false) {
+            }
+
+        void updt_params(params_ref const & p) {
+            m_rw.cfg().updt_params(p);        
+        }
+        
+        void set_cancel(bool f) {
+            m_rw.set_cancel(f);
+        }
+
+        virtual void operator()(goal_ref const & g, 
+                                goal_ref_buffer & result, 
+                                model_converter_ref & mc, 
+                                proof_converter_ref & pc,
+                                expr_dependency_ref & core) {
+            SASSERT(g->is_well_sorted());
+            fail_if_proof_generation("fpa2bv", g);
+            fail_if_unsat_core_generation("fpa2bv", g);
+            m_proofs_enabled      = g->proofs_enabled();
+            m_produce_models      = g->models_enabled();
+            m_produce_unsat_cores = g->unsat_core_enabled();
+            
+            mc = 0; pc = 0; core = 0; result.reset();
+            tactic_report report("fpa2bv", *g);
+            m_rw.reset(); 
+
+            TRACE("fpa2bv", tout << "BEFORE: " << std::endl; g->display(tout););
+
+            if (g->inconsistent()) {
+                result.push_back(g.get());
+                return;
+            }
+            
+            m_num_steps = 0;
+            expr_ref   new_curr(m);
+            proof_ref  new_pr(m);
+            unsigned size = g->size();
+            for (unsigned idx = 0; idx < size; idx++) {
+                if (g->inconsistent())
+                    break;
+                expr * curr = g->form(idx);
+                m_rw(curr, new_curr, new_pr);
+                m_num_steps += m_rw.get_num_steps();
+                if (m_proofs_enabled) {
+                    proof * pr = g->pr(idx);
+                    new_pr     = m.mk_modus_ponens(pr, new_pr);
+                }
+                g->update(idx, new_curr, new_pr, g->dep(idx));
+            }
+
+            if (g->models_enabled())  
+                mc = m_conv.mk_model_converter();
+
+            g->inc_depth();
+            result.push_back(g.get());
+
+            for (unsigned i = 0; i < m_conv.extra_assertions.size(); i++)
+                result.back()->assert_expr(m_conv.extra_assertions[i].get());
+
+            SASSERT(g->is_well_sorted());
+            TRACE("fpa2bv", tout << "AFTER: " << std::endl; g->display(tout); 
+                            if (mc) mc->display(tout); tout << std::endl; );
+        }
+    };
+
+    imp *      m_imp;
+    params_ref m_params;
+
+public:
+    fpa2bv_tactic(ast_manager & m, params_ref const & p):
+        m_params(p) {
+        m_imp = alloc(imp, m, p);
+    }
+
+    virtual tactic * translate(ast_manager & m) {
+        return alloc(fpa2bv_tactic, m, m_params);
+    }
+
+    virtual ~fpa2bv_tactic() {
+        dealloc(m_imp);
+    }
+
+    virtual void updt_params(params_ref const & p) {
+        m_params = p;
+        m_imp->updt_params(p);
+    }
+
+    virtual void collect_param_descrs(param_descrs & r) {        
+    }
+
+    virtual void operator()(goal_ref const & in, 
+                            goal_ref_buffer & result, 
+                            model_converter_ref & mc, 
+                            proof_converter_ref & pc,
+                            expr_dependency_ref & core) {
+        (*m_imp)(in, result, mc, pc, core);
+    }
+    
+    virtual void cleanup() {
+        ast_manager & m = m_imp->m;
+        imp * d = m_imp;
+        #pragma omp critical (tactic_cancel)
+        {
+            d = m_imp;
+        }
+        dealloc(d);
+        d = alloc(imp, m, m_params);
+        #pragma omp critical (tactic_cancel) 
+        {
+            m_imp = d;
+        }
+    }
+
+protected:
+    virtual void set_cancel(bool f) {
+        if (m_imp)
+            m_imp->set_cancel(f);
+    }
+};
+
+tactic * mk_fpa2bv_tactic(ast_manager & m, params_ref const & p) {    
+    return clean(alloc(fpa2bv_tactic, m, p));
+}

src/tactic/fpa/fpa2bv_tactic.h

@@ -0,0 +1,28 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    fpa2bv_tactic.h
+
+Abstract:
+
+    Tactic that converts floating points to bit-vectors
+
+Author:
+
+    Christoph (cwinter) 2012-02-09
+
+Notes:
+
+--*/
+#ifndef _FPA2BV_TACTIC_
+#define _FPA2BV_TACTIC_
+
+#include"params.h"
+class ast_manager;
+class tactic;
+
+tactic * mk_fpa2bv_tactic(ast_manager & m, params_ref const & p = params_ref());
+
+#endif

src/tactic/fpa/qffpa_tactic.cpp

@@ -0,0 +1,38 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    qffpa_tactic.cpp
+
+Abstract:
+
+    Tactic for QF_FPA benchmarks.
+
+Author:
+
+    Christoph (cwinter) 2012-01-16
+
+Notes:
+
+--*/
+#include"tactical.h"
+#include"simplify_tactic.h"
+#include"bit_blaster_tactic.h"
+#include"sat_tactic.h"
+#include"fpa2bv_tactic.h"
+
+#include"qffpa_tactic.h"
+
+tactic * mk_qffpa_tactic(ast_manager & m, params_ref const & p) {
+    params_ref sat_simp_p = p;
+    sat_simp_p .set_bool(":elim-and", true);
+
+    return and_then(mk_simplify_tactic(m, p),
+                    mk_fpa2bv_tactic(m, p),
+                    using_params(mk_simplify_tactic(m, p), sat_simp_p),
+                    mk_bit_blaster_tactic(m, p),
+                    using_params(mk_simplify_tactic(m, p), sat_simp_p),
+                    mk_sat_tactic(m, p),
+                    mk_fail_if_undecided_tactic());
+}

src/tactic/fpa/qffpa_tactic.h

@@ -0,0 +1,29 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    qffpa_tactic.h
+
+Abstract:
+
+    Tactic QF_FPA benchmarks.
+
+Author:
+
+    Christoph (cwinter) 2012-01-16
+
+Notes:
+
+
+--*/
+#ifndef _QFFPA_TACTIC_H_
+#define _QFFPA_TACTIC_H_
+
+#include"params.h"
+class ast_manager;
+class tactic;
+
+tactic * mk_qffpa_tactic(ast_manager & m, params_ref const & p = params_ref());
+
+#endif