synthesizer.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_SYNTHESIZER_HPP
#define TRITON_SYNTHESIZER_HPP
 
#include <array>
#include <deque>
#include <map>
 
#include <triton/astContext.hpp>
#include <triton/dllexport.hpp>
#include <triton/oracleEntry.hpp>
#include <triton/solverEngine.hpp>
#include <triton/symbolicEngine.hpp>
#include <triton/synthesisResult.hpp>
#include <triton/tritonTypes.hpp>
 
 
 
namespace triton {
  namespace engines {
    namespace synthesis {
      namespace oracles {
        extern std::map<triton::ast::ast_e, std::array<UnaryEntry, 40>> unopTable;
 
        extern std::map<triton::ast::ast_e, std::array<BinaryEntry, 40>> binopTable;
 
      };
 
 
      class Synthesizer {
        private:
          std::map<triton::uint512, triton::ast::SharedAbstractNode> hash2var;
 
          std::map<triton::ast::SharedAbstractNode, triton::ast::SharedAbstractNode> var2expr;
 
          triton::engines::solver::SolverEngine solver;
 
          triton::engines::symbolic::SymbolicEngine* symbolic;
 
          bool constantSynthesis(const std::deque<triton::ast::SharedAbstractNode>& vars, const triton::ast::SharedAbstractNode& node, SynthesisResult& result);
 
          bool opaqueConstantSynthesis(const std::deque<triton::ast::SharedAbstractNode>& vars, const triton::ast::SharedAbstractNode& node, SynthesisResult& result);
 
          bool unaryOperatorSynthesis(const std::deque<triton::ast::SharedAbstractNode>& vars, const triton::ast::SharedAbstractNode& node, SynthesisResult& result);
 
          bool binaryOperatorSynthesis(const std::deque<triton::ast::SharedAbstractNode>& vars, const triton::ast::SharedAbstractNode& node, SynthesisResult& result);
 
          bool childrenSynthesis(const triton::ast::SharedAbstractNode& node, bool constant, bool opaque, SynthesisResult& result);
 
          bool do_synthesize(const triton::ast::SharedAbstractNode& node, bool constant, bool opaque, SynthesisResult& result);
 
          triton::ast::SharedAbstractNode symbolizeSubExpression(const triton::ast::SharedAbstractNode& node, SynthesisResult& tmpResult);
 
          void substituteSubExpression(const triton::ast::SharedAbstractNode& node);
 
        public:
          TRITON_EXPORT Synthesizer(triton::engines::symbolic::SymbolicEngine* symbolic);
 
          TRITON_EXPORT SynthesisResult synthesize(const triton::ast::SharedAbstractNode& node, bool constant=true, bool subexpr=true, bool opaque=false);
      };
 
    };
  };
};
 
#endif /* TRITON_SYNTHESIZER_HPP */