LlvmSemantics2.h

#ifndef Rose_LlvmSemantics2_H
#define Rose_LlvmSemantics2_H
#include <featureTests.h>
#ifdef ROSE_ENABLE_BINARY_ANALYSIS

#include "SymbolicSemantics2.h"
#include "CommandLine.h"
#include "DispatcherX86.h"

namespace Rose {
namespace BinaryAnalysis {
namespace InstructionSemantics2 {

namespace LlvmSemantics {

typedef std::vector<RegisterDescriptor> RegisterDescriptors;

typedef SymbolicExpr::Leaf LeafNode;
typedef SymbolicExpr::LeafPtr LeafPtr;
typedef SymbolicExpr::Interior InteriorNode;
typedef SymbolicExpr::InteriorPtr InteriorPtr;
typedef SymbolicExpr::Ptr ExpressionPtr;
typedef SymbolicExpr::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 {
private:
    typedef Map<SymbolicExpr::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 &solver = SmtSolverPtr())
        : SymbolicSemantics::RiscOperators(protoval, solver), indent_level(0), indent_string("    "), llvmVersion_(0) {
        name("Llvm");
    }

    explicit RiscOperators(const BaseSemantics::StatePtr &state, const SmtSolverPtr &solver = SmtSolverPtr())
        : SymbolicSemantics::RiscOperators(state, solver), indent_level(0), indent_string("    "), llvmVersion_(0) {
        name("Llvm");
    }

    // Static allocating constructors
public:
    static RiscOperatorsPtr instance(const RegisterDictionary *regdict, const SmtSolverPtr &solver = SmtSolverPtr()) {
        BaseSemantics::SValuePtr protoval = SValue::instance();
        BaseSemantics::RegisterStatePtr registers = RegisterState::instance(protoval, regdict);
        BaseSemantics::MemoryStatePtr memory = MemoryState::instance(protoval, protoval);
        BaseSemantics::StatePtr state = State::instance(registers, memory);
        return RiscOperatorsPtr(new RiscOperators(state, solver));
    }

    static RiscOperatorsPtr instance(const BaseSemantics::SValuePtr &protoval, const SmtSolverPtr &solver = SmtSolverPtr()) {
        return RiscOperatorsPtr(new RiscOperators(protoval, solver));
    }

    static RiscOperatorsPtr instance(const BaseSemantics::StatePtr &state, const SmtSolverPtr &solver = SmtSolverPtr()) {
        return RiscOperatorsPtr(new RiscOperators(state, solver));
    }

    // Virtual constructors
public:
    virtual BaseSemantics::RiscOperatorsPtr create(const BaseSemantics::SValuePtr &protoval,
                                                   const SmtSolverPtr &solver = SmtSolverPtr()) const ROSE_OVERRIDE {
        return instance(protoval, solver);
    }

    virtual BaseSemantics::RiscOperatorsPtr create(const BaseSemantics::StatePtr &state,
                                                   const SmtSolverPtr &solver = SmtSolverPtr()) const ROSE_OVERRIDE {
        return instance(state, solver);
    }

    // Dynamic pointer cases
public:
    static RiscOperatorsPtr promote(const BaseSemantics::RiscOperatorsPtr &x) {
        RiscOperatorsPtr retval = boost::dynamic_pointer_cast<RiscOperators>(x);
        assert(retval!=NULL);
        return retval;
    }

    // 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) ROSE_OVERRIDE;
    virtual void writeMemory(RegisterDescriptor segreg, const BaseSemantics::SValuePtr &addr,
                             const BaseSemantics::SValuePtr &data, const BaseSemantics::SValuePtr &cond) ROSE_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 RegisterDictionary*);

    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(rose_addr_t);

    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 {
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 &dispatcher)
        : dispatcher(dispatcher), emit_funcfrags(false), quiet_errors(false) {
        operators = RiscOperators::promote(dispatcher->operators());
    }

public:
    static TranscoderPtr instance(const BaseSemantics::DispatcherPtr &dispatcher) {
        return TranscoderPtr(new Transcoder(dispatcher));
    }

    static TranscoderPtr instanceX86() {
        const RegisterDictionary *regdict = RegisterDictionary::dictionary_pentium4();
        SmtSolverPtr solver = SmtSolver::instance(Rose::CommandLine::genericSwitchArgs.smtSolver);
        RiscOperatorsPtr ops = RiscOperators::instance(regdict, solver);
        BaseSemantics::DispatcherPtr dispatcher = DispatcherX86::instance(ops, 32);
        return instance(dispatcher);
    }

    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