instruction.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_INSTRUCTION_H
#define TRITON_INSTRUCTION_H
 
#include <list>
#include <map>
#include <ostream>
#include <set>
#include <sstream>
#include <utility>
#include <vector>
 
#include <triton/archEnums.hpp>
#include <triton/ast.hpp>
#include <triton/dllexport.hpp>
#include <triton/memoryAccess.hpp>
#include <triton/operandWrapper.hpp>
#include <triton/register.hpp>
#include <triton/symbolicExpression.hpp>
#include <triton/tritonTypes.hpp>
 
 
 
namespace triton {
  namespace arch {
    class Instruction {
      protected:
        triton::arch::architecture_e arch;
 
        triton::uint32 tid;
 
        triton::uint64 address;
 
        std::stringstream disassembly;
 
        triton::uint8 opcode[16];
 
        triton::uint32 size;
 
        triton::uint32 type;
 
        triton::arch::x86::prefix_e prefix;
 
        triton::arch::arm::condition_e codeCondition;
 
        std::set<std::pair<triton::arch::MemoryAccess, triton::ast::SharedAbstractNode>> loadAccess;
 
        std::set<std::pair<triton::arch::MemoryAccess, triton::ast::SharedAbstractNode>> storeAccess;
 
        std::set<std::pair<triton::arch::Register, triton::ast::SharedAbstractNode>> readRegisters;
 
        std::set<std::pair<triton::arch::Register, triton::ast::SharedAbstractNode>> writtenRegisters;
 
        std::set<std::pair<triton::arch::Immediate, triton::ast::SharedAbstractNode>> readImmediates;
 
        std::set<triton::arch::Register> undefinedRegisters;
 
        bool branch;
 
        bool controlFlow;
 
        bool conditionTaken;
 
        bool tainted;
 
        bool writeBack;
 
        bool updateFlag;
 
        bool thumb;
 
    private:
        void copy(const Instruction& other);
 
      public:
        std::vector<triton::arch::OperandWrapper> operands;
 
        std::vector<triton::engines::symbolic::SharedSymbolicExpression> symbolicExpressions;
 
        TRITON_EXPORT Instruction();
 
        TRITON_EXPORT Instruction(const void* opcode, triton::uint32 opSize);
 
        TRITON_EXPORT Instruction(triton::uint64 addr, const void* opcode, triton::uint32 opSize);
 
        TRITON_EXPORT Instruction(const Instruction& other);
 
        TRITON_EXPORT Instruction& operator=(const Instruction& other);
 
        TRITON_EXPORT ~Instruction();
 
        TRITON_EXPORT triton::arch::architecture_e getArchitecture(void) const;
 
        TRITON_EXPORT triton::uint32 getThreadId(void) const;
 
        TRITON_EXPORT void setThreadId(triton::uint32 tid);
 
        TRITON_EXPORT triton::uint64 getAddress(void) const;
 
        TRITON_EXPORT triton::uint64 getNextAddress(void) const;
 
        TRITON_EXPORT void setAddress(triton::uint64 addr);
 
        TRITON_EXPORT std::string getDisassembly(void) const;
 
        TRITON_EXPORT const triton::uint8* getOpcode(void) const;
 
        TRITON_EXPORT triton::uint32 getType(void) const;
 
        TRITON_EXPORT triton::arch::x86::prefix_e getPrefix(void) const;
 
        TRITON_EXPORT triton::arch::arm::condition_e getCodeCondition(void) const;
 
        TRITON_EXPORT std::set<std::pair<triton::arch::MemoryAccess, triton::ast::SharedAbstractNode>>& getLoadAccess(void);
 
        TRITON_EXPORT std::set<std::pair<triton::arch::MemoryAccess, triton::ast::SharedAbstractNode>>& getStoreAccess(void);
 
        TRITON_EXPORT std::set<std::pair<triton::arch::Register, triton::ast::SharedAbstractNode>>& getReadRegisters(void);
 
        TRITON_EXPORT std::set<std::pair<triton::arch::Register, triton::ast::SharedAbstractNode>>& getWrittenRegisters(void);
 
        TRITON_EXPORT std::set<std::pair<triton::arch::Immediate, triton::ast::SharedAbstractNode>>& getReadImmediates(void);
 
        TRITON_EXPORT std::set<triton::arch::Register>& getUndefinedRegisters(void);
 
        TRITON_EXPORT void setOpcode(const void* opcode, triton::uint32 size);
 
        TRITON_EXPORT triton::uint32 getSize(void) const;
 
        TRITON_EXPORT void setLoadAccess(const triton::arch::MemoryAccess& mem, const triton::ast::SharedAbstractNode& node);
 
        TRITON_EXPORT void removeLoadAccess(const triton::arch::MemoryAccess& mem);
 
        TRITON_EXPORT void setStoreAccess(const triton::arch::MemoryAccess& mem, const triton::ast::SharedAbstractNode& node);
 
        TRITON_EXPORT void removeStoreAccess(const triton::arch::MemoryAccess& mem);
 
        TRITON_EXPORT void setReadRegister(const triton::arch::Register& reg, const triton::ast::SharedAbstractNode& node);
 
        TRITON_EXPORT void removeReadRegister(const triton::arch::Register& reg);
 
        TRITON_EXPORT void setWrittenRegister(const triton::arch::Register& reg, const triton::ast::SharedAbstractNode& node);
 
        TRITON_EXPORT void removeWrittenRegister(const triton::arch::Register& reg);
 
        TRITON_EXPORT void setReadImmediate(const triton::arch::Immediate& imm, const triton::ast::SharedAbstractNode& node);
 
        TRITON_EXPORT void removeReadImmediate(const triton::arch::Immediate& imm);
 
        TRITON_EXPORT void setUndefinedRegister(const triton::arch::Register& reg);
 
        TRITON_EXPORT void removeUndefinedRegister(const triton::arch::Register& reg);
 
        TRITON_EXPORT void setSize(triton::uint32 size);
 
        TRITON_EXPORT void setArchitecture(triton::arch::architecture_e arch);
 
        TRITON_EXPORT void setType(triton::uint32 type);
 
        TRITON_EXPORT void setPrefix(triton::arch::x86::prefix_e prefix);
 
        TRITON_EXPORT void setCodeCondition(triton::arch::arm::condition_e codeCondition);
 
        TRITON_EXPORT void setDisassembly(const std::string& str);
 
        TRITON_EXPORT void setTaint(bool state);
 
        TRITON_EXPORT void setTaint(void);
 
        TRITON_EXPORT void setWriteBack(bool state);
 
        TRITON_EXPORT void setUpdateFlag(bool state);
 
        TRITON_EXPORT void setThumb(bool state);
 
        TRITON_EXPORT void addSymbolicExpression(const triton::engines::symbolic::SharedSymbolicExpression& expr);
 
        TRITON_EXPORT bool isBranch(void) const;
 
        TRITON_EXPORT bool isControlFlow(void) const;
 
        TRITON_EXPORT bool isConditionTaken(void) const;
 
        TRITON_EXPORT bool isTainted(void) const;
 
        TRITON_EXPORT bool isSymbolized(void) const;
 
        TRITON_EXPORT bool isMemoryRead(void) const;
 
        TRITON_EXPORT bool isMemoryWrite(void) const;
 
        TRITON_EXPORT bool isWriteTo(const triton::arch::OperandWrapper& target) const;
 
        TRITON_EXPORT bool isReadFrom(const triton::arch::OperandWrapper& target) const;
 
        TRITON_EXPORT bool isPrefixed(void) const;
 
        TRITON_EXPORT bool isWriteBack(void) const;
 
        TRITON_EXPORT bool isUpdateFlag(void) const;
 
        TRITON_EXPORT bool isThumb(void) const;
 
        TRITON_EXPORT void setBranch(bool flag);
 
        TRITON_EXPORT void setControlFlow(bool flag);
 
        TRITON_EXPORT void setConditionTaken(bool flag);
 
        TRITON_EXPORT void clear(void);
    };
 
    TRITON_EXPORT std::ostream& operator<<(std::ostream& stream, const Instruction& inst);
 
    TRITON_EXPORT std::ostream& operator<<(std::ostream& stream, const Instruction* inst);
 
  };
};
 
#endif /* TRITON_INSTRUCTION_H */