symbolicEngine.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_SYMBOLICENGINE_H
#define TRITON_SYMBOLICENGINE_H
 
#include <map>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
#include <triton/architecture.hpp>
#include <triton/armOperandProperties.hpp>
#include <triton/ast.hpp>
#include <triton/astContext.hpp>
#include <triton/callbacks.hpp>
#include <triton/dllexport.hpp>
#include <triton/memoryAccess.hpp>
#include <triton/modes.hpp>
#include <triton/pathManager.hpp>
#include <triton/register.hpp>
#include <triton/symbolicEnums.hpp>
#include <triton/symbolicExpression.hpp>
#include <triton/symbolicSimplification.hpp>
#include <triton/symbolicVariable.hpp>
#include <triton/tritonTypes.hpp>
 
 
 
namespace triton {
  namespace engines {
    namespace symbolic {
 
      class SymbolicEngine
        : public triton::engines::symbolic::SymbolicSimplification,
          public triton::engines::symbolic::PathManager {
 
        protected:
          triton::uint32 numberOfRegisters;
 
          triton::usize uniqueSymExprId;
 
          triton::usize uniqueSymVarId;
 
          mutable std::unordered_map<triton::usize, WeakSymbolicVariable> symbolicVariables;
 
          mutable std::unordered_map<triton::usize, WeakSymbolicExpression> symbolicExpressions;
 
          std::map<std::pair<triton::uint64, triton::uint32>, SharedSymbolicExpression> alignedBitvectorMemory;
 
          std::vector<SharedSymbolicExpression> symbolicReg;
 
          std::unordered_map<triton::uint64, SharedSymbolicExpression> memoryBitvector;
 
          SharedSymbolicExpression memoryArray;
 
        private:
          triton::ast::SharedAstContext astCtxt;
 
          triton::arch::Architecture* architecture;
 
          triton::callbacks::Callbacks* callbacks;
 
          triton::modes::SharedModes modes;
 
          triton::usize getUniqueSymExprId(void);
 
          triton::usize getUniqueSymVarId(void);
 
          SharedSymbolicExpression getMemoryArray(void);
 
          const SharedSymbolicExpression& getAlignedMemory(triton::uint64 address, triton::uint32 size);
 
          void addAlignedMemory(triton::uint64 address, triton::uint32 size, const SharedSymbolicExpression& expr);
 
          bool isAlignedMemory(triton::uint64 address, triton::uint32 size);
 
          void removeAlignedMemory(triton::uint64 address, triton::uint32 size);
 
          inline void addBitvectorMemory(triton::uint64 mem, const SharedSymbolicExpression& expr);
 
          triton::ast::SharedAbstractNode getExtendAst(const triton::arch::arm::ArmOperandProperties& extend, const triton::ast::SharedAbstractNode& node);
 
          triton::ast::SharedAbstractNode insertSubRegisterInParent(const triton::arch::Register& reg, const triton::ast::SharedAbstractNode& node, bool zxForAssign=true);
 
          void setImplicitReadRegisterFromEffectiveAddress(triton::arch::Instruction& inst, const triton::arch::MemoryAccess& mem);
 
          const SharedSymbolicExpression& addSymbolicExpressions(triton::arch::Instruction& inst, triton::usize id) const;
 
          inline bool isAlignedMode(void) const;
 
          inline bool isArrayMode(void) const;
 
        public:
          TRITON_EXPORT SymbolicEngine(triton::arch::Architecture* architecture,
                                       const triton::modes::SharedModes& modes,
                                       const triton::ast::SharedAstContext& astCtxt,
                                       triton::callbacks::Callbacks* callbacks=nullptr);
 
          TRITON_EXPORT SymbolicEngine(const SymbolicEngine& other);
 
          TRITON_EXPORT ~SymbolicEngine();
 
          TRITON_EXPORT SymbolicEngine& operator=(const SymbolicEngine& other);
 
          TRITON_EXPORT SharedSymbolicExpression newSymbolicExpression(const triton::ast::SharedAbstractNode& node, triton::engines::symbolic::expression_e type, const std::string& comment="");
 
          TRITON_EXPORT void removeSymbolicExpression(const SharedSymbolicExpression& expr);
 
          TRITON_EXPORT SharedSymbolicVariable newSymbolicVariable(triton::engines::symbolic::variable_e type, triton::uint64 source, triton::uint32 size, const std::string& alias="");
 
          TRITON_EXPORT SharedSymbolicVariable getSymbolicVariable(triton::usize symVarId) const;
 
          TRITON_EXPORT SharedSymbolicVariable getSymbolicVariable(const std::string& name) const;
 
          TRITON_EXPORT SharedSymbolicExpression getSymbolicExpression(triton::usize symExprId) const;
 
          TRITON_EXPORT SharedSymbolicExpression getSymbolicMemory(triton::uint64 addr) const;
 
          TRITON_EXPORT const std::unordered_map<triton::uint64, SharedSymbolicExpression>& getSymbolicMemory(void) const;
 
          TRITON_EXPORT const SharedSymbolicExpression& getSymbolicRegister(const triton::arch::Register& reg) const;
 
          TRITON_EXPORT std::unordered_map<triton::arch::register_e, SharedSymbolicExpression> getSymbolicRegisters(void) const;
 
          TRITON_EXPORT triton::uint8 getSymbolicMemoryValue(triton::uint64 address);
 
          TRITON_EXPORT triton::uint512 getSymbolicMemoryValue(const triton::arch::MemoryAccess& mem);
 
          TRITON_EXPORT std::vector<triton::uint8> getSymbolicMemoryAreaValue(triton::uint64 baseAddr, triton::usize size);
 
          TRITON_EXPORT triton::uint512 getSymbolicRegisterValue(const triton::arch::Register& reg);
 
          TRITON_EXPORT triton::ast::SharedAbstractNode getOperandAst(const triton::arch::OperandWrapper& op);
 
          TRITON_EXPORT triton::ast::SharedAbstractNode getOperandAst(triton::arch::Instruction& inst, const triton::arch::OperandWrapper& op);
 
          TRITON_EXPORT triton::ast::SharedAbstractNode getImmediateAst(const triton::arch::Immediate& imm);
 
          TRITON_EXPORT triton::ast::SharedAbstractNode getImmediateAst(triton::arch::Instruction& inst, const triton::arch::Immediate& imm);
 
          TRITON_EXPORT triton::ast::SharedAbstractNode getMemoryAst(const triton::arch::MemoryAccess& mem);
 
          TRITON_EXPORT triton::ast::SharedAbstractNode getMemoryAst(triton::arch::Instruction& inst, const triton::arch::MemoryAccess& mem);
 
          TRITON_EXPORT triton::ast::SharedAbstractNode getRegisterAst(const triton::arch::Register& reg);
 
          TRITON_EXPORT triton::ast::SharedAbstractNode getRegisterAst(triton::arch::Instruction& inst, const triton::arch::Register& reg);
 
          triton::ast::SharedAbstractNode getShiftAst(const triton::arch::arm::ArmOperandProperties& shift, const triton::ast::SharedAbstractNode& node);
 
          TRITON_EXPORT const SharedSymbolicExpression& createSymbolicExpression(triton::arch::Instruction& inst, const triton::ast::SharedAbstractNode& node, const triton::arch::OperandWrapper& dst, const std::string& comment="");
 
          TRITON_EXPORT const SharedSymbolicExpression& createSymbolicMemoryExpression(triton::arch::Instruction& inst, const triton::ast::SharedAbstractNode& node, const triton::arch::MemoryAccess& mem, const std::string& comment="");
 
          TRITON_EXPORT const SharedSymbolicExpression& createSymbolicRegisterExpression(triton::arch::Instruction& inst, const triton::ast::SharedAbstractNode& node, const triton::arch::Register& reg, const std::string& comment="");
 
          TRITON_EXPORT const SharedSymbolicExpression& createSymbolicVolatileExpression(triton::arch::Instruction& inst, const triton::ast::SharedAbstractNode& node, const std::string& comment="");
 
          TRITON_EXPORT void assignSymbolicExpressionToRegister(const SharedSymbolicExpression& se, const triton::arch::Register& reg);
 
          TRITON_EXPORT void assignSymbolicExpressionToMemory(const SharedSymbolicExpression& se, const triton::arch::MemoryAccess& mem);
 
          TRITON_EXPORT std::unordered_map<triton::usize, SharedSymbolicExpression> sliceExpressions(const SharedSymbolicExpression& expr);
 
          TRITON_EXPORT std::vector<SharedSymbolicExpression> getTaintedSymbolicExpressions(void) const;
 
          TRITON_EXPORT std::unordered_map<triton::usize, SharedSymbolicExpression> getSymbolicExpressions(void) const;
 
          TRITON_EXPORT std::map<triton::usize, SharedSymbolicVariable> getSymbolicVariables(void) const;
 
          TRITON_EXPORT SharedSymbolicVariable symbolizeExpression(triton::usize exprId, triton::uint32 symVarSize, const std::string& symVarAlias="");
 
          TRITON_EXPORT SharedSymbolicVariable symbolizeMemory(const triton::arch::MemoryAccess& mem, const std::string& symVarAlias="");
 
          TRITON_EXPORT void symbolizeMemory(triton::uint64 addr, triton::usize size);
 
          TRITON_EXPORT SharedSymbolicVariable symbolizeRegister(const triton::arch::Register& reg, const std::string& symVarAlias="");
 
          TRITON_EXPORT void concretizeAllMemory(void);
 
          TRITON_EXPORT void concretizeAllRegister(void);
 
          TRITON_EXPORT void concretizeMemory(const triton::arch::MemoryAccess& mem, bool array=true);
 
          TRITON_EXPORT void concretizeMemory(triton::uint64 addr, bool array=true);
 
          TRITON_EXPORT void concretizeRegister(const triton::arch::Register& reg);
 
          TRITON_EXPORT bool isSymbolicExpressionExists(triton::usize symExprId) const;
 
          TRITON_EXPORT bool isMemorySymbolized(const triton::arch::MemoryAccess& mem) const;
 
          TRITON_EXPORT bool isMemorySymbolized(triton::uint64 addr, triton::uint32 size=1) const;
 
          TRITON_EXPORT bool isRegisterSymbolized(const triton::arch::Register& reg) const;
 
          TRITON_EXPORT void initLeaAst(triton::arch::MemoryAccess& mem, bool force=true);
 
          TRITON_EXPORT triton::uint512 getConcreteVariableValue(const SharedSymbolicVariable& symVar) const;
 
          TRITON_EXPORT void setConcreteVariableValue(const SharedSymbolicVariable& symVar, const triton::uint512& value);
      };
 
    };
  };
};
 
#endif /* TRITON_SYMBOLICENGINE_H */