astContext.hpp

Go to the documentation of this file.

 
/*
**  Copyright (C) - Triton
**
**  This program is under the terms of the Apache License 2.0.
*/
 
#ifndef TRITON_AST_CONTEXT_H
#define TRITON_AST_CONTEXT_H
 
#include <deque>
#include <list>
#include <memory>
#include <unordered_map>
#include <vector>
 
#include <triton/ast.hpp>
#include <triton/astRepresentation.hpp>
#include <triton/dllexport.hpp>
#include <triton/exceptions.hpp>
#include <triton/modes.hpp>
 
 
 
namespace triton {
  /* Forward declarations */
  namespace engines {
    namespace symbolic {
      class SymbolicExpression;
      using SharedSymbolicExpression = std::shared_ptr<triton::engines::symbolic::SymbolicExpression>;
 
      class SymbolicVariable;
      using SharedSymbolicVariable = std::shared_ptr<triton::engines::symbolic::SymbolicVariable>;
    };
  };
 
  namespace ast {
 
    class AstContext : public std::enable_shared_from_this<AstContext> {
      private:
        triton::modes::SharedModes modes;
 
        triton::ast::representations::AstRepresentation astRepresentation;
 
        std::unordered_map<std::string, std::pair<triton::ast::WeakAbstractNode, triton::uint512>> valueMapping;
 
        std::deque<SharedAbstractNode> nodes;
 
        SharedAbstractNode simplify_concat(std::vector<SharedAbstractNode> exprs);
 
        SharedAbstractNode simplify_extract(triton::uint32 high, triton::uint32 low, const SharedAbstractNode& expr);
 
      public:
        TRITON_EXPORT AstContext(const triton::modes::SharedModes& modes);
 
        TRITON_EXPORT ~AstContext();
 
        TRITON_EXPORT AstContext& operator=(const AstContext& other);
 
        TRITON_EXPORT SharedAbstractNode collect(const SharedAbstractNode& node);
 
        TRITON_EXPORT void garbage(void);
 
        TRITON_EXPORT SharedAbstractNode array(triton::uint32 addrSize);
 
        TRITON_EXPORT SharedAbstractNode assert_(const SharedAbstractNode& expr);
 
        TRITON_EXPORT SharedAbstractNode bswap(const SharedAbstractNode& expr);
 
        TRITON_EXPORT SharedAbstractNode bv(const triton::uint512& value, triton::uint32 size);
 
        TRITON_EXPORT SharedAbstractNode bvadd(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
 
        TRITON_EXPORT SharedAbstractNode bvand(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
 
        TRITON_EXPORT SharedAbstractNode bvashr(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
 
        TRITON_EXPORT SharedAbstractNode bvfalse(void);
 
        TRITON_EXPORT SharedAbstractNode bvlshr(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
 
        TRITON_EXPORT SharedAbstractNode bvmul(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
 
        TRITON_EXPORT SharedAbstractNode bvnand(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
 
        TRITON_EXPORT SharedAbstractNode bvneg(const SharedAbstractNode& expr);
 
        TRITON_EXPORT SharedAbstractNode bvnor(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
 
        TRITON_EXPORT SharedAbstractNode bvnot(const SharedAbstractNode& expr);
 
        TRITON_EXPORT SharedAbstractNode bvor(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
 
        TRITON_EXPORT SharedAbstractNode bvrol(const SharedAbstractNode& expr, triton::uint32 rot);
 
        TRITON_EXPORT SharedAbstractNode bvrol(const SharedAbstractNode& expr, const SharedAbstractNode& rot);
 
        TRITON_EXPORT SharedAbstractNode bvror(const SharedAbstractNode& expr, triton::uint32 rot);
 
        TRITON_EXPORT SharedAbstractNode bvror(const SharedAbstractNode& expr, const SharedAbstractNode& rot);
 
        TRITON_EXPORT SharedAbstractNode bvsdiv(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
 
        TRITON_EXPORT SharedAbstractNode bvsge(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
 
        TRITON_EXPORT SharedAbstractNode bvsgt(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
 
        TRITON_EXPORT SharedAbstractNode bvshl(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
 
        TRITON_EXPORT SharedAbstractNode bvsle(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
 
        TRITON_EXPORT SharedAbstractNode bvslt(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
 
        TRITON_EXPORT SharedAbstractNode bvsmod(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
 
        TRITON_EXPORT SharedAbstractNode bvsrem(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
 
        TRITON_EXPORT SharedAbstractNode bvsub(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
 
        TRITON_EXPORT SharedAbstractNode bvtrue(void);
 
        TRITON_EXPORT SharedAbstractNode bvudiv(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
 
        TRITON_EXPORT SharedAbstractNode bvuge(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
 
        TRITON_EXPORT SharedAbstractNode bvugt(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
 
        TRITON_EXPORT SharedAbstractNode bvule(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
 
        TRITON_EXPORT SharedAbstractNode bvult(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
 
        TRITON_EXPORT SharedAbstractNode bvurem(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
 
        TRITON_EXPORT SharedAbstractNode bvxnor(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
 
        TRITON_EXPORT SharedAbstractNode bvxor(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
 
        template <typename T> SharedAbstractNode compound(const T& exprs) {
          SharedAbstractNode node = std::make_shared<CompoundNode>(exprs, this->shared_from_this());
          if (node == nullptr)
            throw triton::exceptions::Ast("Node builders - Not enough memory");
          node->init();
          return this->collect(node);
        }
 
        TRITON_EXPORT SharedAbstractNode concat(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
 
        template <typename T> SharedAbstractNode concat(const T& exprs) {
          /* Do not concat if there is only one element */
          if (exprs.size() == 1) {
            return exprs.front();
          }
 
          /* Allocate node */
          SharedAbstractNode node = std::make_shared<ConcatNode>(exprs, this->shared_from_this());
          if (node == nullptr)
            throw triton::exceptions::Ast("Node builders - Not enough memory");
          node->init();
 
          if (this->modes->isModeEnabled(triton::modes::CONSTANT_FOLDING)) {
            if (node->isSymbolized() == false) {
              return this->bv(node->evaluate(), node->getBitvectorSize());
            }
          }
 
          if (this->modes->isModeEnabled(triton::modes::AST_OPTIMIZATIONS)) {
            /* Optimization: concatenate extractions in one if possible */
            auto n = this->simplify_concat(std::vector<SharedAbstractNode>(exprs.begin(), exprs.end()));
            if (n) {
              return n;
            }
          }
 
          return this->collect(node);
        }
 
        TRITON_EXPORT SharedAbstractNode declare(const SharedAbstractNode& var);
 
        TRITON_EXPORT SharedAbstractNode distinct(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
 
        TRITON_EXPORT SharedAbstractNode equal(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
 
        TRITON_EXPORT SharedAbstractNode extract(triton::uint32 high, triton::uint32 low, const SharedAbstractNode& expr);
 
        template <typename T> SharedAbstractNode forall(const T& vars, const SharedAbstractNode& body) {
          SharedAbstractNode node = std::make_shared<ForallNode>(vars, body);
          if (node == nullptr)
            throw triton::exceptions::Ast("Node builders - Not enough memory");
          node->init();
          return this->collect(node);
        }
 
        TRITON_EXPORT SharedAbstractNode iff(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
 
        TRITON_EXPORT SharedAbstractNode integer(const triton::uint512& value);
 
        TRITON_EXPORT SharedAbstractNode ite(const SharedAbstractNode& ifExpr, const SharedAbstractNode& thenExpr, const SharedAbstractNode& elseExpr);
 
        TRITON_EXPORT SharedAbstractNode land(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
 
        template <typename T> SharedAbstractNode land(const T& exprs) {
          SharedAbstractNode node = std::make_shared<LandNode>(exprs, this->shared_from_this());
          if (node == nullptr)
            throw triton::exceptions::Ast("Node builders - Not enough memory");
          node->init();
          return this->collect(node);
        }
 
        TRITON_EXPORT SharedAbstractNode let(std::string alias, const SharedAbstractNode& expr2, const SharedAbstractNode& expr3);
 
        TRITON_EXPORT SharedAbstractNode lnot(const SharedAbstractNode& expr);
 
        TRITON_EXPORT SharedAbstractNode lor(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
 
        template <typename T> SharedAbstractNode lor(const T& exprs) {
          SharedAbstractNode node = std::make_shared<LorNode>(exprs, this->shared_from_this());
          if (node == nullptr)
            throw triton::exceptions::Ast("Node builders - Not enough memory");
          node->init();
          return this->collect(node);
        }
 
        TRITON_EXPORT SharedAbstractNode lxor(const SharedAbstractNode& expr1, const SharedAbstractNode& expr2);
 
        template <typename T> SharedAbstractNode lxor(const T& exprs) {
          SharedAbstractNode node = std::make_shared<LxorNode>(exprs, this->shared_from_this());
          if (node == nullptr)
            throw triton::exceptions::Ast("Node builders - Not enough memory");
          node->init();
          return this->collect(node);
        }
 
        TRITON_EXPORT SharedAbstractNode reference(const triton::engines::symbolic::SharedSymbolicExpression& expr);
 
        TRITON_EXPORT SharedAbstractNode select(const SharedAbstractNode& array, triton::usize index);
 
        TRITON_EXPORT SharedAbstractNode select(const SharedAbstractNode& array, const SharedAbstractNode& index);
 
        TRITON_EXPORT SharedAbstractNode store(const SharedAbstractNode& array, triton::usize index, const SharedAbstractNode& expr);
 
        TRITON_EXPORT SharedAbstractNode store(const SharedAbstractNode& array, const SharedAbstractNode& index, const SharedAbstractNode& expr);
 
        TRITON_EXPORT SharedAbstractNode string(std::string value);
 
        TRITON_EXPORT SharedAbstractNode sx(triton::uint32 sizeExt, const SharedAbstractNode& expr);
 
        TRITON_EXPORT SharedAbstractNode variable(const triton::engines::symbolic::SharedSymbolicVariable& symVar);
 
        TRITON_EXPORT SharedAbstractNode zx(triton::uint32 sizeExt, const SharedAbstractNode& expr);
 
        TRITON_EXPORT void initVariable(const std::string& name, const triton::uint512& value, const SharedAbstractNode& node);
 
        TRITON_EXPORT void updateVariable(const std::string& name, const triton::uint512& value);
 
        SharedAbstractNode getVariableNode(const std::string& name);
 
        TRITON_EXPORT triton::uint16 getArraySize(void) const;
 
        TRITON_EXPORT const triton::uint512& getVariableValue(const std::string& name) const;
 
        TRITON_EXPORT void setRepresentationMode(triton::ast::representations::mode_e mode);
 
        TRITON_EXPORT triton::ast::representations::mode_e getRepresentationMode(void) const;
 
        TRITON_EXPORT std::ostream& print(std::ostream& stream, AbstractNode* node);
    };
 
    using SharedAstContext = std::shared_ptr<triton::ast::AstContext>;
 
  };
};
 
#endif /* TRITON_AST_CONTEXT_H */