InsnSemanticsExpr.h

Go to the documentation of this file.

#ifndef Rose_InsnSemanticsExpr_H
#define Rose_InsnSemanticsExpr_H

#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>

class SMTSolver;

namespace InsnSemanticsExpr {

    enum Operator 
        {
        OP_ADD,                 
        OP_AND,                 
        OP_ASR,                 
        OP_BV_AND,              
        OP_BV_OR,               
        OP_BV_XOR,              
        OP_CONCAT,              
        OP_EQ,                  
        OP_EXTRACT,             
        OP_INVERT,              
        OP_ITE,                 
        OP_LSSB,                
        OP_MSSB,                
        OP_NE,                  
        OP_NEGATE,              
        OP_NOOP,                
        OP_OR,                  
        OP_ROL,                 
        OP_ROR,                 
        OP_SDIV,                
        OP_SEXTEND,             
        OP_SGE,                 
        OP_SGT,                 
        OP_SHL0,                
        OP_SHL1,                
        OP_SHR0,                
        OP_SHR1,                
        OP_SLE,                 
        OP_SLT,                 
        OP_SMOD,                
        OP_SMUL,                
        OP_UDIV,                
        OP_UEXTEND,             
        OP_UGE,                 
        OP_UGT,                 
        OP_ULE,                 
        OP_ULT,                 
        OP_UMOD,                
        OP_UMUL,                
        OP_ZEROP,               
    };

    const char *to_str(Operator o);

    typedef std::map<uint64_t, uint64_t> RenameMap;

    class TreeNode;
    class InternalNode;
    class LeafNode;

    typedef boost::shared_ptr<const TreeNode> TreeNodePtr;
    typedef boost::shared_ptr<const InternalNode> InternalNodePtr;
    typedef boost::shared_ptr<const LeafNode> LeafNodePtr;

    class Visitor {
    public:
        virtual ~Visitor() {}
        virtual void operator()(const TreeNodePtr&) = 0;
    };

    class TreeNode: public boost::enable_shared_from_this<TreeNode> {
    protected:
        size_t nbits;           
        std::string comment;    
    public:
        TreeNode(size_t nbits, std::string comment=""): nbits(nbits), comment(comment) { assert(nbits>0); }

        virtual void print(std::ostream&, RenameMap *rmap=NULL) const = 0;

        virtual bool equal_to(const TreeNodePtr& other, SMTSolver*) const = 0;

        virtual bool is_known() const = 0;

        virtual uint64_t get_value() const = 0;

        const std::string& get_comment() const { return comment; }
        void set_comment(const std::string &s) { comment=s; }
        size_t get_nbits() const { return nbits; }

        virtual void depth_first_visit(Visitor*) const = 0;

        std::set<LeafNodePtr> get_variables() const;

        InternalNodePtr isInternalNode() const {
            return boost::dynamic_pointer_cast<const InternalNode>(shared_from_this());
        }

        LeafNodePtr isLeafNode() const {
            return boost::dynamic_pointer_cast<const LeafNode>(shared_from_this());
        }
    };

    class InternalNode: public TreeNode {
    private:
        Operator op;
        std::vector<TreeNodePtr> children;

        // Constructors should not be called directly.  Use the create() class method instead. This is to help prevent
        // accidently using pointers to these objects -- all access should be through boost::shared_ptr<>.
        InternalNode(size_t nbits, Operator op, const std::string comment="")
            : TreeNode(nbits, comment), op(op) {}
        InternalNode(size_t nbits, Operator op, const TreeNodePtr &a, std::string comment="")
            : TreeNode(nbits, comment), op(op) {
            add_child(a);
        }
        InternalNode(size_t nbits, Operator op, const TreeNodePtr &a, const TreeNodePtr &b, std::string comment="")
            : TreeNode(nbits, comment), op(op) {
            add_child(a);
            add_child(b);
        }
        InternalNode(size_t nbits, Operator op, const TreeNodePtr &a, const TreeNodePtr &b, const TreeNodePtr &c,
                     std::string comment="")
            : TreeNode(nbits, comment), op(op) {
            add_child(a);
            add_child(b);
            add_child(c);
        }

    public:
        static InternalNodePtr create(size_t nbits, Operator op, const std::string comment="") {
            InternalNodePtr retval(new InternalNode(nbits, op, comment));
            return retval;
        }
        static InternalNodePtr create(size_t nbits, Operator op, const TreeNodePtr &a, const std::string comment="") {
            InternalNodePtr retval(new InternalNode(nbits, op, a, comment));
            return retval;
        }
        static InternalNodePtr create(size_t nbits, Operator op, const TreeNodePtr &a, const TreeNodePtr &b,
                                      const std::string comment="") {
            InternalNodePtr retval(new InternalNode(nbits, op, a, b, comment));
            return retval;
        }
        static InternalNodePtr create(size_t nbits, Operator op, const TreeNodePtr &a, const TreeNodePtr &b, const TreeNodePtr &c,
                                      const std::string comment="") {
            InternalNodePtr retval(new InternalNode(nbits, op, a, b, c, comment));
            return retval;
        }
        /* see superclass, where this is pure virtual */
        virtual void print(std::ostream &o, RenameMap *rmap=NULL) const;

        /* see superclass, where this is pure virtual */
        virtual bool equal_to(const TreeNodePtr &other, SMTSolver*) const;

        /* see superclass, where this is pure virtual */
        virtual bool is_known() const {
            return false; /*if it's known, then it would have been folded to a leaf*/
        }

        /* see superclass, where this is pure virtual */
        virtual uint64_t get_value() const { ROSE_ASSERT(!"not a constant value"); return 0;}

        /* see superclass, where this is pure virtual */
        virtual void depth_first_visit(Visitor*) const;

        size_t size() const { return children.size(); }

        TreeNodePtr child(size_t idx) const { return children[idx]; }

        Operator get_operator() const { return op; }

        void add_child(const TreeNodePtr &child);
    };

    class LeafNode: public TreeNode {
    private:
        bool known;                         
        union {
            uint64_t ival;                  
            uint64_t name;                  
        };

        // Private to help prevent creating pointers to leaf nodes.  See create_* methods instead.
        LeafNode(std::string comment=""): TreeNode(32, comment), known(true), ival(0) {}

    public:
        static LeafNodePtr create_variable(size_t nbits, std::string comment="");

        static LeafNodePtr create_integer(size_t nbits, uint64_t n, std::string comment="");

        /* see superclass, where this is pure virtual */
        virtual bool is_known() const;

        /* see superclass, where this is pure virtual */
        virtual uint64_t get_value() const;

        uint64_t get_name() const;

        /* see superclass, where this is pure virtual */
        virtual void print(std::ostream &o, RenameMap *rmap=NULL) const;

        /* see superclass, where this is pure virtual */
        virtual bool equal_to(const TreeNodePtr &other, SMTSolver*) const;

        /* see superclass, where this is pure virtual */
        virtual void depth_first_visit(Visitor*) const;
    };
};


std::ostream& operator<<(std::ostream &o, const InsnSemanticsExpr::TreeNode &node);

#endif

---