LlvmSemantics.h

#ifndef ROSE_BinaryAnalysis_InstructionSemantics_LlvmSemantics_H
#define ROSE_BinaryAnalysis_InstructionSemantics_LlvmSemantics_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS
 
#include <Rose/BinaryAnalysis/BasicTypes.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/SymbolicSemantics.h>
#include <Rose/BinaryAnalysis/InstructionSemantics/DispatcherX86.h>
#include <Rose/CommandLine.h>
 
namespace Rose {
namespace BinaryAnalysis {
namespace InstructionSemantics {
 
namespace LlvmSemantics {
 
typedef std::vector<RegisterDescriptor> RegisterDescriptors;
 
typedef SymbolicExpression::Leaf LeafNode;
typedef SymbolicExpression::LeafPtr LeafPtr;
typedef SymbolicExpression::Interior InteriorNode;
typedef SymbolicExpression::InteriorPtr InteriorPtr;
typedef SymbolicExpression::Ptr ExpressionPtr;
typedef SymbolicExpression::Nodes TreeNodes;
 
typedef SymbolicSemantics::SValuePtr SValuePtr;
typedef SymbolicSemantics::SValue SValue;
 
typedef BaseSemantics::RegisterStateGenericPtr RegisterStatePtr;
typedef BaseSemantics::RegisterStateGeneric RegisterState;
 
typedef SymbolicSemantics::MemoryStatePtr MemoryStatePtr;
typedef SymbolicSemantics::MemoryState MemoryState;
 
typedef BaseSemantics::StatePtr StatePtr;
typedef BaseSemantics::State State;
 
typedef boost::shared_ptr<class RiscOperators> RiscOperatorsPtr;
 
class RiscOperators: public SymbolicSemantics::RiscOperators {
public:
    using Super = SymbolicSemantics::RiscOperators;
 
    using Ptr = RiscOperatorsPtr;
 
private:
    typedef Map<SymbolicExpression::Hash, LeafPtr> Rewrites;
    typedef Map<uint64_t, std::string> Variables;
 
    Rewrites rewrites;                                  // maps expressions to LLVM variables
    Variables variables;                                // ROSE-to-LLVM variable map; name includes sigil
    RegisterStatePtr prev_regstate;                     // most recently emitted register state
    RegisterDescriptors important_registers;            // registers that should be emitted to LLVM
    TreeNodes  mem_writes;                              // memory write operations (OP_WRITE expressions)
    int indent_level;                                   // level of indentation (might be negative, but prefix() clips to zero
    std::string indent_string;                          // white space per indentation level
    int llvmVersion_;                                   // 1000000*major + 1000*minor + patch. e.g., 3005000 = llvm-3.5.0
 
    // Real constructors
protected:
    explicit RiscOperators(const BaseSemantics::SValuePtr &protoval, const SmtSolverPtr&);
 
    explicit RiscOperators(const BaseSemantics::StatePtr&, const SmtSolverPtr&);
 
    // Static allocating constructors
public:
    ~RiscOperators();
 
    static RiscOperatorsPtr instanceFromRegisters(const RegisterDictionaryPtr&, const SmtSolverPtr &solver = SmtSolverPtr());
 
    static RiscOperatorsPtr instanceFromProtoval(const BaseSemantics::SValuePtr &protoval,
                                                 const SmtSolverPtr &solver = SmtSolverPtr());
 
    static RiscOperatorsPtr instanceFromState(const BaseSemantics::StatePtr&, const SmtSolverPtr &solver = SmtSolverPtr());
 
    // Virtual constructors
public:
    virtual BaseSemantics::RiscOperatorsPtr create(const BaseSemantics::SValuePtr &protoval,
                                                   const SmtSolverPtr &solver = SmtSolverPtr()) const override;
 
    virtual BaseSemantics::RiscOperatorsPtr create(const BaseSemantics::StatePtr &state,
                                                   const SmtSolverPtr &solver = SmtSolverPtr()) const override;
 
    // Dynamic pointer cases
public:
    static RiscOperatorsPtr promote(const BaseSemantics::RiscOperatorsPtr&);
 
    // Properties
public:
    int llvmVersion() const { return llvmVersion_; }
    void llvmVersion(int v) { llvmVersion_ = v; }
    // Methods we override from the super class
public:
    virtual BaseSemantics::SValuePtr readMemory(RegisterDescriptor segreg, const BaseSemantics::SValuePtr &addr,
                                                const BaseSemantics::SValuePtr &dflt,
                                                const BaseSemantics::SValuePtr &cond) override;
    virtual void writeMemory(RegisterDescriptor segreg, const BaseSemantics::SValuePtr &addr,
                             const BaseSemantics::SValuePtr &data, const BaseSemantics::SValuePtr &cond) override;
 
    // Methods to control indentation of LLVM output
public:
    int indent(int nlevels=1) { indent_level += nlevels; return nlevels; }
 
    std::string prefix() const;
 
    struct Indent {
        RiscOperators *ops;
        RiscOperatorsPtr ops_ptr;
        int nlevels;
        explicit Indent(const RiscOperatorsPtr &ops_ptr, int nlevels=1): ops_ptr(ops_ptr), nlevels(nlevels) {
            ops = ops_ptr.get();
            ops->indent(nlevels);
        }
        explicit Indent(RiscOperators *ops, int nlevels=1): ops(ops), nlevels(nlevels) {
            ops->indent(nlevels);
        }
        ~Indent() {
            ops->indent(-nlevels);
        }
    };
 
    // New methods to control/query the machine state
public:
    virtual void reset();
 
    virtual const RegisterDescriptors& get_important_registers();
 
    virtual RegisterDescriptors get_stored_registers();
 
    virtual RegisterDescriptors get_modified_registers();
 
    virtual RegisterDescriptor get_insn_pointer_register();
 
    virtual SValuePtr get_instruction_pointer();
 
    virtual const TreeNodes& get_memory_writes() { return mem_writes; }
 
    virtual void make_current();
 
    virtual void add_rewrite(const ExpressionPtr &from, const LeafPtr &to);
 
    virtual std::string add_variable(const LeafPtr&);
 
    virtual std::string get_variable(const LeafPtr&);
 
    // New methods to emit the machine state
public:
    virtual void emit_register_declarations(std::ostream&, const RegisterDescriptors&);
 
    virtual void emit_register_definitions(std::ostream&, const RegisterDescriptors&);
 
    virtual void emit_prerequisites(std::ostream&, const RegisterDescriptors&, const RegisterDictionaryPtr&);
 
    virtual void emit_next_eip(std::ostream&, SgAsmInstruction *latest_insn);
 
    virtual void emit_memory_writes(std::ostream&);
 
    virtual void emit_changed_state(std::ostream&);
 
    // New methods to return snippets of LLVM as strings or expressions
public:
    virtual std::string llvm_integer_type(size_t nbits);
 
    virtual std::string llvm_term(const ExpressionPtr&);
 
    virtual std::string llvm_lvalue(const LeafPtr&);
 
    virtual LeafPtr next_temporary(size_t nbits);
 
    virtual std::string next_label();
 
    virtual std::string addr_label(Address);
 
    virtual std::string function_label(SgAsmFunction*);
 
    // New methods to emit LLVM code for an expression.
public:
    virtual LeafPtr emit_expression(std::ostream&, const SValuePtr&);
    virtual LeafPtr emit_expression(std::ostream&, const ExpressionPtr&);
    virtual LeafPtr emit_expression(std::ostream&, const LeafPtr&);
protected:
    virtual LeafPtr emit_assignment(std::ostream&, const ExpressionPtr &rhs);
 
    virtual ExpressionPtr emit_zero_extend(std::ostream&, const ExpressionPtr &value, size_t nbits);
    virtual ExpressionPtr emit_sign_extend(std::ostream&, const ExpressionPtr &value, size_t nbits);
    virtual ExpressionPtr emit_truncate(std::ostream&, const ExpressionPtr &value, size_t nbits);
    virtual ExpressionPtr emit_unsigned_resize(std::ostream&, const ExpressionPtr &value, size_t nbits);
    virtual ExpressionPtr emit_binary(std::ostream&, const std::string &llvm_op, const ExpressionPtr&, const ExpressionPtr&);
    virtual ExpressionPtr emit_signed_binary(std::ostream&, const std::string &llvm_op, const ExpressionPtr&, const ExpressionPtr&);
    virtual ExpressionPtr emit_unsigned_binary(std::ostream&, const std::string &llvm_op, const ExpressionPtr&, const ExpressionPtr&);
    virtual ExpressionPtr emit_logical_right_shift(std::ostream&, const ExpressionPtr &value, const ExpressionPtr &amount);
    virtual ExpressionPtr emit_logical_right_shift_ones(std::ostream&, const ExpressionPtr &value, const ExpressionPtr &amount);
    virtual ExpressionPtr emit_arithmetic_right_shift(std::ostream&, const ExpressionPtr &value, const ExpressionPtr &amount);
    virtual ExpressionPtr emit_left_shift(std::ostream&, const ExpressionPtr &value, const ExpressionPtr &amount);
    virtual ExpressionPtr emit_left_shift_ones(std::ostream&, const ExpressionPtr &value, const ExpressionPtr &amount);
    virtual ExpressionPtr emit_lssb(std::ostream&, const ExpressionPtr&);
    virtual ExpressionPtr emit_mssb(std::ostream&, const ExpressionPtr&);
    virtual ExpressionPtr emit_extract(std::ostream&, const ExpressionPtr &value, const ExpressionPtr &from, size_t result_nbits);
    virtual ExpressionPtr emit_invert(std::ostream&, const ExpressionPtr &value);
    virtual ExpressionPtr emit_left_associative(std::ostream&, const std::string &llvm_op, const TreeNodes &operands);
    virtual ExpressionPtr emit_concat(std::ostream&, TreeNodes operands);
    virtual ExpressionPtr emit_signed_divide(std::ostream&, const ExpressionPtr &numerator, const ExpressionPtr &denominator);
    virtual ExpressionPtr emit_unsigned_divide(std::ostream&, const ExpressionPtr &numerator, const ExpressionPtr &denominator);
    virtual ExpressionPtr emit_signed_modulo(std::ostream&, const ExpressionPtr &numerator, const ExpressionPtr &denominator);
    virtual ExpressionPtr emit_unsigned_modulo(std::ostream&, const ExpressionPtr &numerator, const ExpressionPtr &denominator);
    virtual ExpressionPtr emit_signed_multiply(std::ostream&, const TreeNodes &operands);
    virtual ExpressionPtr emit_unsigned_multiply(std::ostream&, const TreeNodes &operands);
    virtual ExpressionPtr emit_rotate_left(std::ostream&, const ExpressionPtr &value, const ExpressionPtr &amount);
    virtual ExpressionPtr emit_rotate_right(std::ostream&, const ExpressionPtr &value, const ExpressionPtr &amount);
    virtual ExpressionPtr emit_compare(std::ostream&, const std::string &llvm_op, const ExpressionPtr&, const ExpressionPtr&);
    virtual ExpressionPtr emit_ite(std::ostream&, const ExpressionPtr &cond, const ExpressionPtr&, const ExpressionPtr&);
    virtual ExpressionPtr emit_memory_read(std::ostream&, const ExpressionPtr &address, size_t nbits);
    virtual ExpressionPtr emit_global_read(std::ostream&, const std::string &varname, size_t nbits);
    virtual void        emit_memory_write(std::ostream&, const ExpressionPtr &address, const ExpressionPtr &value);
};
 
typedef boost::shared_ptr<class Transcoder> TranscoderPtr;
 
class Transcoder {
public:
    using Ptr = TranscoderPtr;
 
private:
    RiscOperatorsPtr operators;
    BaseSemantics::DispatcherPtr dispatcher;
    bool emit_funcfrags;                                // emit BBs that aren't part of the CFG?
    bool quiet_errors;                                  // catch exceptions and emit an LLVM comment instead?
 
protected:
    explicit Transcoder(const BaseSemantics::DispatcherPtr&);
 
public:
    ~Transcoder();
 
    static TranscoderPtr instance(const BaseSemantics::DispatcherPtr&);
 
    static TranscoderPtr instanceX86();
 
    int llvmVersion() const;
    void llvmVersion(int version);
    bool emitFunctionFragements() const { return emit_funcfrags; }
    void emitFunctionFragements(bool b) { emit_funcfrags = b; }
    bool quietErrors() const { return quiet_errors; }
    void quietErrors(bool b) { quiet_errors = b; }
    void emitFilePrologue(std::ostream&);
    std::string emitFilePrologue();
    void emitFunctionDeclarations(SgNode *ast, std::ostream&);
    std::string emitFunctionDeclarations(SgNode *ast);
    void transcodeInstruction(SgAsmInstruction*, std::ostream&);
    std::string transcodeInstruction(SgAsmInstruction*);
    size_t transcodeBasicBlock(SgAsmBlock*, std::ostream&);
    std::string transcodeBasicBlock(SgAsmBlock*);
    size_t transcodeFunction(SgAsmFunction*, std::ostream&);
    std::string transcodeFunction(SgAsmFunction*);
    void transcodeInterpretation(SgAsmInterpretation*, std::ostream&);
    std::string transcodeInterpretation(SgAsmInterpretation*);
};
 
} // namespace
} // namespace
} // namespace
} // namespace
 
#endif
#endif