symbolicExpression.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_SYMBOLICEXPRESSION_H
#define TRITON_SYMBOLICEXPRESSION_H
 
#include <memory>
#include <string>
 
#include <triton/ast.hpp>
#include <triton/dllexport.hpp>
#include <triton/memoryAccess.hpp>
#include <triton/register.hpp>
#include <triton/symbolicEnums.hpp>
#include <triton/tritonTypes.hpp>
 
 
 
namespace triton {
  namespace engines {
    namespace symbolic {
 
      class SymbolicExpression {
        protected:
          triton::engines::symbolic::expression_e type;
 
          triton::ast::SharedAbstractNode ast;
 
          std::string comment;
 
          triton::uint64 address;
 
          std::string disassembly;
 
          triton::usize id;
 
          triton::arch::MemoryAccess originMemory;
 
          triton::arch::Register originRegister;
 
        private:
          TRITON_EXPORT std::string getBitvectorDefine(void) const;
 
          TRITON_EXPORT std::string getArrayDefine(void) const;
 
        public:
          bool isTainted;
 
          TRITON_EXPORT SymbolicExpression(const triton::ast::SharedAbstractNode& node,
                                           triton::usize id,
                                           triton::engines::symbolic::expression_e type,
                                           const std::string& comment="");
 
          TRITON_EXPORT SymbolicExpression(const SymbolicExpression& other);
 
          TRITON_EXPORT SymbolicExpression& operator=(const SymbolicExpression& other);
 
          TRITON_EXPORT triton::usize getId(void) const;
 
          TRITON_EXPORT bool isMemory(void) const;
 
          TRITON_EXPORT bool isRegister(void) const;
 
          TRITON_EXPORT bool isSymbolized(void) const;
 
          TRITON_EXPORT triton::engines::symbolic::expression_e getType(void) const;
 
          TRITON_EXPORT const triton::ast::SharedAbstractNode& getAst(void) const;
 
          TRITON_EXPORT triton::ast::SharedAbstractNode getNewAst(void) const;
 
          TRITON_EXPORT const std::string& getComment(void) const;
 
          TRITON_EXPORT std::string getFormattedId(void) const;
 
          TRITON_EXPORT std::string getFormattedComment(void) const;
 
          TRITON_EXPORT std::string getFormattedExpression(void) const;
 
          TRITON_EXPORT const triton::arch::MemoryAccess& getOriginMemory(void) const;
 
          TRITON_EXPORT const triton::arch::Register& getOriginRegister(void) const;
 
          TRITON_EXPORT void setAst(const triton::ast::SharedAbstractNode& node);
 
          TRITON_EXPORT void setComment(const std::string& comment);
 
          TRITON_EXPORT void setType(triton::engines::symbolic::expression_e type);
 
          TRITON_EXPORT void setAddress(triton::uint64 address);
 
          TRITON_EXPORT triton::uint64 getAddress(void) const;
 
          TRITON_EXPORT void setOriginMemory(const triton::arch::MemoryAccess& mem);
 
          TRITON_EXPORT void setOriginRegister(const triton::arch::Register& reg);
 
          TRITON_EXPORT void writeBackDisassembly(const std::string& disassembly);
 
          TRITON_EXPORT const std::string& getDisassembly(void);
      };
 
      using SharedSymbolicExpression = std::shared_ptr<triton::engines::symbolic::SymbolicExpression>;
 
      using WeakSymbolicExpression = std::weak_ptr<triton::engines::symbolic::SymbolicExpression>;
 
      TRITON_EXPORT std::ostream& operator<<(std::ostream& stream, const SymbolicExpression& symExpr);
 
      TRITON_EXPORT std::ostream& operator<<(std::ostream& stream, const SymbolicExpression* symExpr);
 
    };
  };
};
 
#endif /* TRITON_SYMBOLICEXPRESSION_H */